JavaScript Non-Primitive Data Types

Study Notes

JavaScript Non-Primitive Data Types

Arrays

Definition: Ordered collections of values that can hold multiple items.
Creation:
- Using array literals: let arr = [1, 2, 3];
- Using the Array constructor: let arr = new Array(1, 2, 3);
Key Characteristics:
- Can hold different data types (numbers, strings, objects, etc.).
- Dynamic size: Can change in size (e.g., push, pop).
Common Methods:
- .push(): Adds an item to the end.
- .pop(): Removes the last item.
- .shift(): Removes the first item.
- .unshift(): Adds an item to the front.
- .slice(): Returns a portion of the array.
- .map(): Creates a new array based on the results of a function.
- .filter(): Creates a new array with elements that pass a test.

Objects

Definition: Collections of key-value pairs, where keys are strings and values can be any data type.
Creation:
- Using object literals: let obj = {key1: value1, key2: value2};
- Using the Object constructor: let obj = new Object();
Key Characteristics:
- Keys can be any valid string (or Symbol).
- Can store functions as values (methods).
- Properties can be accessed using dot notation (obj.key1) or bracket notation (obj['key1']).
Common Methods:
- Object.keys(): Returns an array of keys.
- Object.values(): Returns an array of values.
- Object.entries(): Returns an array of [key, value] pairs.
- Object.assign(): Copies values from one or more source objects to a target object.

Functions

Definition: First-class objects that can be assigned to variables, passed as arguments, or returned from other functions.
Creation:
- Function declaration: function myFunction() { /*...*/ }
- Function expression: let myFunction = function() { /*...*/ };
- Arrow functions: let myFunction = () => { /*...*/ };
Key Characteristics:
- Can return a value using the return statement.
- Can have parameters and arguments.
- Can be called repeatedly.
- Can be used as a method within objects.
Common Concepts:
- Scope: Functions create their own scope.
- Closures: Functions can remember the environment they were created in.
- Higher-order functions: Functions that take other functions as arguments or return them.

This summary provides a brief overview of non-primitive data types in JavaScript, focusing particularly on arrays, objects, and functions, highlighting their definitions, characteristics, creation methods, and common functionalities.

Arrays

Ordered collections of values containing multiple items.
Dynamic size - can change in size
Can hold different data types (numbers, strings, objects, etc.)
Created using array literals let arr = [1, 2, 3]; or the Array constructor let arr = new Array(1, 2, 3);
Common methods:
- push(): Adds an item to the end.
- pop(): Removes the last item.
- shift(): Removes the first item.
- unshift(): Adds an item to the front.
- slice(): Returns a portion of the array.
- map(): Creates a new array based on the results of a function.
- filter(): Creates a new array with elements that pass a test.

Objects

Collections of key-value pairs, where keys are strings and values can be any data type.
Created using object literals let obj = {key1: value1, key2: value2}; or the Object constructor let obj = new Object();
Can store functions as values (methods)
Properties can be accessed using dot notation obj.key1 or bracket notation obj['key1']
Common methods:
- Object.keys(): Returns an array of keys.
- Object.values(): Returns an array of values.
- Object.entries(): Returns an array of [key, value] pairs.
- Object.assign(): Copies values from one or more source objects to a target object.

Functions

First-class objects that can be assigned to variables, passed as arguments, or returned from other functions.
Created using function declaration function myFunction() { } or function expression let myFunction = function() { }; or Arrow functions let myFunction = () => { };
Can return a value using the return statement.
Can have parameters and arguments.
Can be called repeatedly.
Can be used as a method within objects.
Common concepts:
- Scope: Functions create their own scope.
- Closures: Functions can remember the environment they were created in.
- Higher-order functions: Functions that take other functions as arguments or return them.

Description

Explore the essential non-primitive data types in JavaScript, focusing on arrays and objects. Learn how to create and manipulate these complex data structures through various methods and their characteristics. This quiz will test your understanding of these fundamental concepts in JavaScript programming.

JavaScript Non-Primitive Data Types

Choose a study mode

Podcast

Questions and Answers

What will be the content of the array `arr` after executing `arr.push(4)` on the array `let arr = [1, 2, 3];`?

Which method would you use to retrieve an array containing the keys of an object `let obj = {name: 'Alice', age: 25};`?

What happens if you execute `let arr = [1, 2, 3]; arr.shift();`?

Which of the following statements about JavaScript functions is true?

When creating an object using `let obj = new Object();`, which of the following is NOT automatically included?

What is the result of calling `arr.slice(1, 2)` on the array `let arr = [10, 20, 30, 40];`?

What characteristic of JavaScript arrays allows them to change in size?

What is the outcome of `let obj = {x: 1}; obj.y = 2; console.log(obj);`?

Which statement shows the correct way to create a method within an object?

What would be the result of using `Object.entries({a: 1, b: 2});`?

Study Notes