Array<T>.prototype.*

• concat(...items: (T | Array<T>)[]): T[] 🔒 ^ES3

  Returns a new array that is the concatenation of this and all items. Non-array parameters are treated as if they were arrays with single elements.

  > ['a'].concat('b', ['c', 'd'])
  [ 'a', 'b', 'c', 'd' ]
  

• copyWithin(target: number, start: number, end=this.length): this ✏️ ^ES6

  Copies the elements whose indices range from start to (excl.) end to indices starting with target. Overlapping is handled correctly.

  > ['a', 'b', 'c', 'd'].copyWithin(0, 2, 4)
  [ 'c', 'd', 'c', 'd' ]
  

• entries(): Iterable<[number, T]> 🔒 ^ES6

  Returns an iterable over [index, element] pairs.

  > Array.from(['a', 'b'].entries())
  [ [ 0, 'a' ], [ 1, 'b' ] ]
  

• every(callback: (value: T, index: number, array: Array<T>) => boolean, thisArg?: any): boolean 🔒 ^ES5

  Returns true if callback returns true for every element. Stops as soon as it receives false. Math: ∀

  > [1, 2, 3].every(x => x > 0)
  true
  > [1, -2, 3].every(x => x > 0)
  false
  

• fill(value: T, start=0, end=this.length): this ✏️ ^ES6

  Assigns value to every index.

  > [0, 1, 2].fill('a')
  [ 'a', 'a', 'a' ]
  

• filter(callback: (value: T, index: number, array: Array<T>) => any, thisArg?: any): T[] 🔒 ^ES5

  Returns an array with only those elements for which callback returns true.

  > [1, -2, 3].filter(x => x > 0)
  [ 1, 3 ]
  

• find(predicate: (value: T, index: number, obj: T[]) => boolean, thisArg?: any): T | undefined 🔒 ^ES6

  The result is the first element for which predicate returns true. If it never does, the result is undefined.

  > [1, -2, 3].find(x => x < 0)
  -2
  > [1, 2, 3].find(x => x < 0)
  undefined
  

• findIndex(predicate: (value: T, index: number, obj: T[]) => boolean, thisArg?: any): number 🔒 ^ES6

  The result is the index of the first element for which predicate returns true. If it never does, the result is -1.

  > [1, -2, 3].findIndex(x => x < 0)
  1
  > [1, 2, 3].findIndex(x => x < 0)
  -1
  

• forEach(callback: (value: T, index: number, array: Array<T>) => void, thisArg?: any): void 🔒 ^ES5

  Calls callback for each element.

  ['a', 'b'].forEach((x, i) => console.log(x, i))
  // 'a' 0
  // 'b' 1

• includes(searchElement: T, fromIndex=0): boolean 🔒 ^ES2016

  Returns true if searchElement is an element and false, otherwise.

  > [0, 1, 2].includes(1)
  true
  > [0, 1, 2].includes(5)
  false
  

• indexOf(searchElement: T, fromIndex=0): number 🔒 ^ES5

  Returns the index of the first element that is strictly equal to searchElement. Returns -1 if there is no such element. Starts searching at index fromIndex, visiting subsequent indices next.

  > ['a', 'b', 'a'].indexOf('a')
  0
  > ['a', 'b', 'a'].indexOf('a', 1)
  2
  > ['a', 'b', 'a'].indexOf('c')
  -1
  

• join(separator = ','): string 🔒 ^ES1

  Creates a string by concatenating string representations of all elements, separating by separator.

  > ['a', 'b', 'c'].join()
  'a,b,c'
  > ['a', 'b', 'c'].join('##')
  'a##b##c'
  

• keys(): Iterable<number> 🔒 ^ES6

  Returns an iterable over the keys of the array.

  > [...['a', 'b'].keys()]
  [ 0, 1 ]
  

• lastIndexOf(searchElement: T, fromIndex=this.length-1): number 🔒 ^ES5

  Returns the index of the first element that is strictly equal to searchElement. Returns -1 if there is no such element. Starts searching at index fromIndex, visiting preceding indices next.

  > ['a', 'b', 'a'].lastIndexOf('a')
  2
  > ['a', 'b', 'a'].lastIndexOf('a', 1)
  0
  > ['a', 'b', 'a'].lastIndexOf('c')
  -1
  

• map<U>(callback: (value: T, index: number, array: ReadonlyArray<T>) => U, thisArg?: any): U[] 🔒 ^ES5

  Returns a new array, in which every element is the result of callback being applied to the corresponding element of this.

  > [1, 2, 3].map(x => x * 2)
  [ 2, 4, 6 ]
  > ['a', 'b', 'c'].map((x, i) => i)
  [ 0, 1, 2 ]
  

• pop(): T | undefined ✏️ ^ES3

  Removes and returns the last element of the array. That is, it treats the end of the array as a stack.

  > const arr = ['a', 'b', 'c'];
  > arr.pop()
  'c'
  > arr
  [ 'a', 'b' ]
  

• push(...items: T[]): number ✏️ ^ES3

  Adds adds zero or more items to the end of the array. That is, it treats the end of the array as a stack. The return value is the length of this after the change.

  > const arr = ['a', 'b'];
  > arr.push('c', 'd')
  4
  > arr
  [ 'a', 'b', 'c', 'd' ]
  

• reduce<U>(callback: (state: U, element: T, index: number, array: T[]) => U, firstState?: U): U 🔒 ^ES5

  The callback computes the next state, given the current state and an element of the array. .reduce() feeds it the array elements, starting at index 0, going forward. If no firstState is provided, the array element at index 0 is used, instead. The last state is the result of .reduce().

  > [1, 2, 3].reduce((state, x) => state + String(x), '')
  '123'
  > [1, 2, 3].reduce((state, x) => state + x, 0)
  6
  

• reduceRight<U>(callback: (state: U, element: T, index: number, array: T[]) => U, firstState?: U): U 🔒 ^ES5

  Works like .reduce(), but visits the array elements backward, starting with the last element.

  > [1, 2, 3].reduceRight((state, x) => state + String(x), '')
  '321'
  

• reverse

• shift

• slice

• some

• sort

• splice

• toLocaleString

• toString

• unshift

• values(): Iterable<T>

How holes are handled is described in Sect. “Array operations and holes” in “Exploring ES6”.