JavaScript Arrays

What is an array in JavaScript?

An array in JavaScript is a special type of object that allows you to store multiple values in a single variable. Arrays can hold values of any data type, including numbers, strings, objects, and even other arrays.

How do you create an array in JavaScript?

You can create an array using array literals or the Array constructor.

• Using array literals:

  const fruits = ['apple', 'banana', 'orange'];
  

• Using the Array constructor:

  const numbers = new Array(1, 2, 3, 4);
  

How do you access elements in an array?

You can access elements in an array using their index, with the first element at index 0.

const colors = ['red', 'green', 'blue'];
console.log(colors[0]); // red
console.log(colors[1]); // green

What methods can you use to add and remove elements from an array?

You can use the following methods to add and remove elements:

• Adding elements:
  • push(): Adds one or more elements to the end of the array.
  • unshift(): Adds one or more elements to the beginning of the array.
• Removing elements:
  • pop(): Removes the last element from the array.
  • shift(): Removes the first element from the array.

const fruits = ['apple', 'banana'];
fruits.push('orange'); // Adds 'orange' to the end
console.log(fruits); // ['apple', 'banana', 'orange']

fruits.pop(); // Removes the last element
console.log(fruits); // ['apple', 'banana']

What is the length property of an array?

The length property of an array returns the number of elements in the array. It is dynamically updated when elements are added or removed.

const numbers = [1, 2, 3, 4];
console.log(numbers.length); // 4
numbers.push(5);
console.log(numbers.length); // 5

How do you iterate over an array in JavaScript?

You can iterate over an array using various methods:

• for loop:

  const arr = [1, 2, 3];
  for (let i = 0; i < arr.length; i++) {
    console.log(arr[i]);
  }
  

• forEach method:

  arr.forEach((element) => {
    console.log(element);
  });
  

• for...of loop:

  for (const value of arr) {
    console.log(value);
  }
  

What are some common array methods in JavaScript?

Common array methods include:

• map(): Creates a new array with the results of calling a provided function on every element in the calling array.
• filter(): Creates a new array with all elements that pass the test implemented by the provided function.
• reduce(): Executes a reducer function on each element of the array, resulting in a single output value.
• slice(): Returns a shallow copy of a portion of an array into a new array.
• splice(): Changes the contents of an array by removing or replacing existing elements and/or adding new elements.

Can you provide an example of the map method?

const numbers = [1, 2, 3, 4];
const squares = numbers.map(num => num * num);
console.log(squares); // [1, 4, 9, 16]

What is the difference between slice() and splice() methods?

The slice() method returns a shallow copy of a portion of an array, without modifying the original array. The splice() method changes the contents of an array by removing or adding elements.

// Using slice
const fruits = ['apple', 'banana', 'orange'];
const citrus = fruits.slice(1, 3); // ['banana', 'orange']
console.log(citrus);

// Using splice
fruits.splice(1, 1); // Removes 'banana'
console.log(fruits); // ['apple', 'orange']

How do you sort an array in JavaScript?

You can sort an array using the sort() method. By default, the sort method sorts the elements as strings. You can provide a comparison function for custom sorting.

const numbers = [4, 2, 5, 1, 3];
numbers.sort(); // Sorts as strings: [1, 2, 3, 4, 5]
console.log(numbers);

numbers.sort((a, b) => a - b); // Sorts as numbers: [1, 2, 3, 4, 5]
console.log(numbers);

What is the difference between shallow copy and deep copy of an array?

A shallow copy creates a new array with the same elements as the original array, but nested arrays or objects still refer to the same instances. A deep copy creates a new array along with copies of nested arrays or objects, ensuring no shared references.

// Shallow copy
const original = [1, 2, [3, 4]];
const shallowCopy = [...original];
shallowCopy[2][0] = 5;
console.log(original[2][0]); // 5 (affected)

// Deep copy using JSON methods
const deepCopy = JSON.parse(JSON.stringify(original));
deepCopy[2][0] = 6;
console.log(original[2][0]); // 5 (not affected)

How can you find the index of an element in an array?

You can find the index of an element in an array using the indexOf() method, which returns the first index at which a given element can be found, or -1 if it is not present.

const fruits = ['apple', 'banana', 'orange'];
console.log(fruits.indexOf('banana')); // 1
console.log(fruits.indexOf('grape')); // -1

What is the purpose of the forEach() method?

The forEach() method executes a provided function once for each array element. It is often used for side effects or when you need to iterate over an array without modifying it.

const numbers = [1, 2, 3];
numbers.forEach((num) => {
  console.log(num * 2); // Outputs: 2, 4, 6
});