JavaScript Array Methods

Question 1

Array.from()

Answer 1

A method that creates a new, shallow-copied Array instance from an array-like or iterable object:

console.log(Array.from('foo'));
// expected output: Array ["f", "o", "o"]

Question 2

Array.isArray()

Answer 2

A method that determines whether the passed value is an Array:

Array.isArray([1, 2, 3]); // true
Array.isArray({foo: 123}); // false
Array.isArray(‘foobar’); // false
Array.isArray(undefined); // false

Question 3

Array.of()

Answer 3

A method that creates a new Array instance from a variable number of arguments, regardless of number or type of the arguments:

Array.of(7); // [7]
Array.of(1, 2, 3); // [1, 2, 3]

Array(7); // array of 7 empty slots
Array(1, 2, 3); // [1, 2, 3]

Question 4

Array.prototype.every()

Answer 4

The every() method that tests whether all elements in the arras pass the test implemented by the provided function. It returns a Boolean value.

const isBelowThreshold = (currentValue) => currentValue < 40;

const array1 = [1, 30, 39, 29, 10, 13];

console.log(array1.every(isBelowThreshold));
// expected output: true

Question 5

Array.prototype.fill()

Answer 5

The fill() method fills (modifies) all the elements of an array from a start index (default 0) to an end index (default array length) with a static value

const array1 = [1, 2, 3, 4];

// fill with 0 from position 2 until position 4
console.log(array1.fill(0, 2, 4));
// expected output: [1, 2, 0, 0]

Question 6

Array.prototype.filter()

Answer 6

The filter() method creates a new array with all elements that pass the test implemented by the provided function.

const words = [‘spray’, ‘limit’, ‘elite’, ‘exuberant’, ‘destruction’, ‘present’];

const result = words.filter(word => word.length > 6);

console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]

Question 7

Array.prototype.find()

Answer 7

The find() method returns the value of the first element in the provided array that satisfies the provided testing function.

const array1 = [5, 12, 8, 130, 44];

const found = array1.find(element => element > 10);

console.log(found);
// expected output: 12

Question 8

Array.prototype.findIndex()

Answer 8

The findIndex() method returns the index of the first element in the array that satisfies the provided testing function. Otherwise, it returns -1, indicating that no element passed the test.

const array1 = [5, 12, 8, 130, 44];

const isLargeNumber = (element) => element > 13;

console.log(array1.findIndex(isLargeNumber));
// expected output: 3

Question 9

Array.prototype.concat()

Answer 9

The concat() method is used to merge two or more arrays. This method does not change the existing arrays, but instead returns a new array.

const array1 = ['a', 'b', 'c'];
const array2 = ['d', 'e', 'f'];

console.log(array1.concat(array2));
// expected output: Array ["a", "b", "c", "d", "e", "f"]

Question 10

Array.prototype.copyWithin()

Answer 10

The copyWithin() method shallow copies part of an array to another location in the same array and returns it without modifying its length.

const array1 = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’];

// copy to index 0 the element at index 3
console.log(array1.copyWithin(0, 3, 4));
// expected output: Array ["d", "b", "c", "d", "e"]

// copy to index 1 all elements from index 3 to the end
console.log(array1.copyWithin(1, 3));
// expected output: Array ["d", "d", "e", "d", "e"]

Question 11

Array.prototype.flat()

Answer 11

The flat() method creates a new array with all sub-array elements concatenated into it recursively up to the specified depth

var arr5 = [1, 2, , 4, 5];
arr5.flat();
// [1, 2, 4, 5]

Question 12

Array.prototype.forEach()

Answer 12

The forEach() method executes a provided function once for each array element.

const array1 = [‘a’, ‘b’, ‘c’];

array1.forEach(element => console.log(element));

// expected output: "a"
// expected output: "b"
// expected output: "c"

Question 13

Array.prototype.includes()

Answer 13

The includes() method determines whether an array includes a certain value among its entries, returning true or false as appropriate.

const array1 = [1, 2, 3];

console.log(array1.includes(2));
// expected output: true

const pets = [‘cat’, ‘dog’, ‘bat’];

console.log(pets.includes('cat'));
// expected output: true

console.log(pets.includes('at'));
// expected output: false

Question 14

Array.prototype.indexOf()

Answer 14

The indexOf() method returns the first index at which a given element can be fond in the array, or -1 if it is not present.

const beasts = [‘ant’, ‘bison’, ‘camel’, ‘duck’, ‘bison’];

console.log(beasts.indexOf('bison'));
// expected output: 1

// start from index 2
console.log(beasts.indexOf('bison', 2));
// expected output: 4

console.log(beasts.indexOf('giraffe'));
// expected output: -1

Question 15

Array.prototype.join()

Answer 15

The join() method creates and returns a new string by concatenating all of the elements in an array (or an array-like object), separated by commas or a specified separator string. If the array has only one item, then that item will be returned without using the separator.

const elements = [‘Fire’, ‘Air’, ‘Water’];

console.log(elements.join());
// expected output: "Fire,Air,Water"

console.log(elements.join(''));
// expected output: "FireAirWater"

console.log(elements.join('-'));
// expected output: "Fire-Air-Water"

Question 16

Array.prototype.lastIndexOf()

Answer 16

The lastIndexOf() method returns the last index at which a given element can be found in the array, or -1 if it is not present. The array is searched backwards, starting at fromIndex.

const animals = [‘Dodo’, ‘Tiger’, ‘Penguin’, ‘Dodo’];

console.log(animals.lastIndexOf('Dodo'));
// expected output: 3

console.log(animals.lastIndexOf('Tiger'));
// expected output: 1

Question 17

Array.prototype.map()

Answer 17

The map() method creates a new array with the results of calling a provided function on every element in the calling array.

const array1 = [1, 4, 9, 16];

// pass a function to map
const map1 = array1.map(x => x * 2);

console.log(map1);
// expected output: Array [2, 8, 18, 32]

Question 18

Array.prototype.pop()

Answer 18

The pop() method removes the last element from an array and returns that element. This method changes the length of the array.

const plants = [‘broccoli’, ‘cauliflower’, ‘cabbage’, ‘kale’, ‘tomato’];

console.log(plants.pop());
// expected output: "tomato"

console.log(plants);
// expected output: Array ["broccoli", "cauliflower", "cabbage", "kale"]

plants.pop();

console.log(plants);
// expected output: Array ["broccoli", "cauliflower", "cabbage"]

Question 19

Array.prototype.push()

Answer 19

The push() method adds one or more elements to the end of an array and returns the new length of the array.

const animals = [‘pigs’, ‘goats’, ‘sheep’];

const count = animals.push('cows');
console.log(count);
// expected output: 4
console.log(animals);
// expected output: Array ["pigs", "goats", "sheep", "cows"]

animals.push(‘chickens’, ‘cats’, ‘dogs’);
console.log(animals);
// expected output: Array [“pigs”, “goats”, “sheep”, “cows”, “chickens”, “cats”, “dogs”]

Question 20

Array.prototype.reduce()

Answer 20

The reduce() method executes a reducer function (that you provide) on each element of the array, resulting in a single output value.

const array1 = [1, 2, 3, 4];
const reducer = (accumulator, currentValue) => accumulator + currentValue;

// 1 + 2 + 3 + 4
console.log(array1.reduce(reducer));
// expected output: 10

// 5 + 1 + 2 + 3 + 4
console.log(array1.reduce(reducer, 5));
// expected output: 15

Question 21

Array.prototype.toLocaleString()

Answer 21

The toLocaleString() method returns a string representing the elements of the array. The elements are converted to Strings using their to Loacle String mehtods and these Strings are separated by a locale-specific String (such as a comma “,”)

const array1 = [1, 'a', new Date('21 Dec 1997 14:12:00 UTC')];
const localeString = array1.toLocaleString('en', {timeZone: "UTC"});

console.log(localeString);
// expected output: "1,a,12/21/1997, 2:12:00 PM",
// This assumes "en" locale and UTC timezone - your results may vary

Question 22

Array.prototype.splice()

Answer 22

The splice() method changes the contents of an array by removing or replacing existing elements and/or adding new elements in place.

const months = [‘Jan’, ‘March’, ‘April’, ‘June’];
months.splice(1, 0, ‘Feb’);
// inserts at index 1
console.log(months);
// expected output: Array [“Jan”, “Feb”, “March”, “April”, “June”]

months.splice(4, 1, ‘May’);
// replaces 1 element at index 4
console.log(months);
// expected output: Array [“Jan”, “Feb”, “March”, “April”, “May”]

Question 23

Array.prototype.sort()

Answer 23

The sort() method sorts the elements of an array in place and returns the sorted array. The default sort order is ascending, built upon converting the elements into strings, then comparing their sequences of UTF-16 code unit values.

const months = [‘March’, ‘Jan’, ‘Feb’, ‘Dec’];
months.sort();
console.log(months);
// expected output: Array [“Dec”, “Feb”, “Jan”, “March”]

const array1 = [1, 30, 4, 21, 100000];
array1.sort();
console.log(array1);
// expected output: Array[1, 100000, 21, 30, 4]

Question 24

Array.prototype.some()

Answer 24

The some() method tests whether at least one element in the array passes the test implemented by the provided function. It returns a Boolean value.

const array = [1, 2, 3, 4, 5];

// checks whether an element is even
const even = (element) => element % 2 === 0;

console.log(array.some(even));
// expected output: true

Question 25

Array.prototype.slice()

Answer 25

The slice() method returns a shallow copy of a portion of an array into a new array object seleceted from begin to end (end not included) where begin and end represent the index of items in that array. The original array will not be modified.

const animals = [‘ant’, ‘bison’, ‘camel’, ‘duck’, ‘elephant’];

console.log(animals.slice(2));
// expected output: Array ["camel", "duck", "elephant"]

console.log(animals.slice(2, 4));
// expected output: Array ["camel", "duck"]

console.log(animals.slice(1, 5));
// expected output: Array ["bison", "camel", "duck", "elephant"]

Question 26

Array.prototype.shift()

Answer 26

The shift() method removes the first element from an array and returns that removed element. This method changes the length of the array.

const array1 = [1, 2, 3];

const firstElement = array1.shift();

console.log(array1);
// expected output: Array [2, 3]

console.log(firstElement);
// expected output: 1

Question 27

Array.prototype.reverse()

Answer 27

the reverse() method reverses an array in place. The first array element becomes the last, and the last array element becomes the first.

const array1 = ['one', 'two', 'three'];
console.log('array1:', array1);
// expected output: "array1:" Array ["one", "two", "three"]

const reversed = array1.reverse();
console.log('reversed:', reversed);
// expected output: "reversed:" Array ["three", "two", "one"]

/* Careful: reverse is destructive. It also changes
the original array */
console.log(‘array1:’, array1);
// expected output: “array1:” Array [“three”, “two”, “one”]

Question 28

Array.prototype.reduceRight()

Answer 28

the reduceRight() method applies a function against an accumulator and each value of the array (from right-to-left) to reduce it to a single value.

const array1 = [[0, 1], [2, 3], [4, 5]].reduceRight(
(accumulator, currentValue) => accumulator.concat(currentValue)
);

console.log(array1);
// expected output: Array [4, 5, 2, 3, 0, 1]

Question 29

The values() method returns a new Array Iterator object that contains the values for each index in the array.

Answer 29

const array1 = ['a', 'b', 'c'];
const iterator = array1.values();

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

// expected output: "a"
// expected output: "b"
// expected output: "c"

Question 30

Array.prototype.unshift()

Answer 30

The unshift() method adds one or more elements to the beginning of an array and returns the new length of the array.

const array1 = [1, 2, 3];

console.log(array1.unshift(4, 5));
// expected output: 5

console.log(array1);
// expected output: Array [4, 5, 1, 2, 3]

Question 31

Array.prototype.toString()

Answer 31

The toString() method returns a string representing the specified array and its elements.

const array1 = [1, 2, ‘a’, ‘1a’];

console.log(array1.toString());
// expected output: "1,2,a,1a"