This returns an integer value of 32 bit.

We can also use an array length property when we want to empty an array at any time. When you increase the length of any array, it will not increase the number of elements in it. We can set or return the length of any array using the array length property.

Consider the following example:

var num=new Array[1,2,3];
Document. write (num.length);

The output will be as follows:

3

The concat() method returns the concatenated array.

The concat() method takes a string to concatenate with.

This takes two arrays and joins them.

var alpha = ['a', 'b', 'c'],
var numeric = [1, 2, 3];
var alphaNumeric = alpha.concat(numeric);
console.log(alphaNumeric); // Result: ['a', 'b', 'c', 1, 2, 3]

The every() method returns a Boolean true or false.

A call back function to be applied on every element of the array.

If every element in an array provides the testing function, then it returns true.

function isBigEnough(element, index, array) {
  return element >= 10;
}
[12, 5, 8, 130, 44].every(isBigEnough);   // false
[12, 54, 18, 130, 44].every(isBigEnough); // true

The output of each function.

A call back function to be called for every element of the array.

The foreach() method calls the functions of each element:

function logArrayElements(element, index, array) {
  console.log('a[' + index + '] = ' + element);
}

// Note elision, there is no member at 2 so it isn't visited
[2, 5, , 9].forEach(logArrayElements);
// logs:
// a[0] = 2
// a[1] = 5
// a[3] = 9

A joined string.

Null or a separator to place between array elements.

It joins all elements into a string.

var a = ['One', 'Two', 'Three'];
var var1 = a.join();      // assigns 'One,Two,Three' to var1
var var2 = a.join(', ');  // assigns 'One, Two, Three' to var2
var var3 = a.join(' + '); // assigns 'One + Two + Three' to var3
var var4 = a.join('');    // assigns 'OneTwoThree' to var4

The pop() method returns a null parameter.

The pop() method takes the null parameter.

It removes the last element of an array, just like a stack.

var myColours = ['Yellow', 'Black', 'Blue', 'Green'];
console.log(myColours); // ['Yellow', 'Black', 'Blue', 'Green']
var popped = myColours.pop();
console.log(myColours); // ['Yellow', 'Black', 'Blue' ] 
console.log(popped); // 'Green'

null.

null.

This adds elements at the last index on an array.

var sports = ['cricket', 'baseball'];
var total = sports.push('football');

console.log(sports); // ['cricket', 'baseball', 'football']
console.log(total);  // 3

The indexOf() method returns an index.

The indexOf() method takes an array element as a parameter.

It returns the first index of an array.

var array = [2, 5, 9];
array.indexOf(9);     // 2
array.indexOf(7);     // -1 if not found

It returns the last index of an array.

An array element.

The array.

null.

The reverse() method reverses the order of the elements in an array. The first element becomes the last element and so on.

var myArray = ['one', 'two', 'three'];
myArray.reverse(); 

console.log(myArray) // ['three', 'two', 'one']

null.

null.

In an array, it removes the very first element and returns the removed element.

var myColours = ['Yellow', 'Black', 'Blue', 'Green'];
console.log(myColours); // ['Yellow', 'Black', 'Blue', 'Green']
var shifted = myColours.shift();
console.log(myColours); // ['Black', 'Blue', 'Green'] 
console.log(shifted); // 'Green'

The new length of the array.

The element(s) to add in the array.

This method adds a new element at the beginning of the array and returns the new array length:

var arr = [1, 2, 3];
arr.unshift(0); // arr is [0, 1, 2, 3]

The new sliced array.

The indices of elements to slice.

This method slices an array into a new array:

var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];
var citrus = fruits.slice(1, 3);

// citrus contains ['Orange','Lemon']

The new spliced array.

The indices of elements to remove and the elements to add.

This method is also used to add new elements to an array by removing existing elements:

var myCars = ['Audi', 'BMW', 'Ferrari', 'Volkswagen'];

// removes 0 elements from index 2, and inserts 'Toyota'
var removed = myCars.splice(2, 0, 'Toyota');
// myCars is ['Audi', 'BMW', 'Toyota', 'Volkswagen']
// removed is [], no elements removed

null.

null.

Called as an array method, this sorts an array alphabetically (unicode characters) and will not work well with numbers:

var fruit = ['cherries', 'apples', 'bananas'];
fruit.sort(); // ['apples', 'bananas', 'cherries']

The toString() method returns a string.

The toString() method takes a null parameter.

Converts the array object into a string with its elements separated by commas character.

var monthNames = ['Jan', 'Feb', 'Mar', 'Apr'];
var myVar = monthNames.toString(); // 'Jan,Feb,Mar,Apr' to myVar.

A modified array.

A callback function.

It loops through an array, running a function, and creates a new array based on the return values from each iteration. It takes the same arguments as the forEach() method.

Here is a simple example:

var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt);

The roots are now as follows:

[1, 2, 3]

A modified array.

A callback function.

It creates a new array of only those elements that returned true to their callbacks.

Here is a simple example:

function isBigEnough(value) {
  return value >= 10;
}
var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);

The output is as follows:

[12, 130, 44]

A modified array.

A callback function.

The array.prototype.reduce() method is used to accumulate all values in an array to a single value by the operations performed in the callback function.

Here is a simple example:

[0, 1, 2, 3, 4].reduce(function(previousValue, currentValue, index, array) {
  return previousValue + currentValue;
});

The callbacks are executed as follows:

The output of each function.

A callback function to be called for every element of the array.

The array.prototype.forEach() method calls functions of each element. Here is a simple example:

function logArrayElements(element, index, array) {
  console.log('a[' + index + '] = ' + element);
}

// Note elision, there is no member at 2 so it isn't visited
[2, 5, , 9].forEach(logArrayElements);
// logs:
// a[0] = 2
// a[1] = 5
// a[3] = 9

An index.

An array element.

The array.prototype.indexOf() method returns the first index of an array. Here is a simple example:

var array = [2, 5, 9];
array.indexOf(9);     // 2
array.indexOf(7);     // -1 if not found

It returns the last index of an array.

An array element.

As stated in the preceding descriptions, the array.prototype.lastIndexOf() function will return the last index of the specified element if found within the array. Here is a simple example:

var array = [2, 5, 9, 2];
array.indexOf(2);     // 3
array.indexOf(7);     // -1 if not found

A Boolean true or false.

A callback function to be applied on every element of the array.

If every element in an array provides the testing function, then it returns true. Here is a simple example:

function isBigEnough(element, index, array) {
  return element >= 10;
}
[12, 5, 8, 130, 44].every(isBigEnough);   // false
[12, 54, 18, 130, 44].every(isBigEnough); // true

A Boolean True or False.

A callback function.

The array.prototype.some() method is similar to Array.prototype.every(), but here the condition is that at least one callback should return true.

A simple example is as follows:

function isBiggerThan10(element, index, array) {
  return element > 10;
}
[2, 5, 8, 1, 4].some(isBiggerThan10);  // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true

A modified array.

A callback function.

This is exactly the same as reduce, but it starts from right and moves toward the left while accumulating the values.

Here is a simple example:

var total = [0, 1, 2, 3].reduceRight(function(a, b) {
  return a + b;
});

This returns the sum as 6.