JavaScript Array Methods

Name: JavaScript Array Methods
Creator: staticdata.dev
License: https://opensource.org/licenses/MIT

A complete reference for all Array.prototype instance methods in JavaScript, covering every standardized method from ES1 through ES2023. Each entry records the full call signature, what value the method returns, whether it mutates the original array, a concise description of its behavior, and the ECMAScript edition in which it was introduced — making it straightforward to check browser support requirements or quickly identify the non-mutating counterparts added in ES2023.

v1.0.0 MIT 38 records Updated 2026-10-05 stable Source: MDN Web Docs — Array.prototype methods, ECMAScript Language Specification

Quick fetch

Stable URL. CORS-enabled. No auth.

bash

curl https://staticdata.dev/v1/js-array-methods.json

Or use as a typed import: import { jsArrayMethods } from "https://staticdata.dev/v1/js-array-methods.ts"

Formats

JSON 10.7 KB

/v1/js-array-methods.json

Open

min: 9.1 KB · /v1/js-array-methods.min.json
CSV 6.3 KB

/v1/js-array-methods.csv

Open
TypeScript 10.9 KB

/v1/js-array-methods.ts

export const jsArrayMethods

type ArrayMethod = (typeof jsArrayMethods)[number]

Open

Schema

Each record in the dataset has the following shape.

Schema
Field	Type	Description	Example
name	string	Method name without the Array.prototype prefix	map
signature	string	Full call signature including parameters	Array.prototype.map(callbackFn, thisArg)
returns	string	Type or value the method returns	Array
mutates	boolean	Whether the method modifies the array in place	false
description	string	Concise description of what the method does	Creates a new array populated with the results of calling a provided function on every element.
ecmaVersion	string	ECMAScript edition that introduced this method	ES5

Preview

First 10 records.

Data preview
name	signature	returns	mutates	description	ecmaVersion
at	Array.prototype.at(index)	any	false	Returns the element at the given index, accepting negative integers which count back from the end of the array.	ES2022
concat	Array.prototype.concat(...values)	Array	false	Returns a new array formed by merging the original array with one or more arrays and/or values.	ES3
copyWithin	Array.prototype.copyWithin(target, start, end)	Array	true	Shallow-copies a portion of the array to another location within the same array and returns it.	ES2015
entries	Array.prototype.entries()	Iterator	false	Returns a new Array Iterator object that contains the [index, value] pairs for each element.	ES2015
every	Array.prototype.every(callbackFn, thisArg)	boolean	false	Tests whether all elements in the array pass the test implemented by the provided function.	ES5
fill	Array.prototype.fill(value, start, end)	Array	true	Fills all or a portion of the array with a static value and returns the modified array.	ES2015
filter	Array.prototype.filter(callbackFn, thisArg)	Array	false	Creates a new array with all elements that pass the test implemented by the provided function.	ES5
find	Array.prototype.find(callbackFn, thisArg)	any	false	Returns the first element that satisfies the provided testing function, or undefined if none found.	ES2015
findIndex	Array.prototype.findIndex(callbackFn, thisArg)	number	false	Returns the index of the first element that satisfies the provided testing function, or -1 if none found.	ES2015
findLast	Array.prototype.findLast(callbackFn, thisArg)	any	false	Iterates from the end and returns the value of the last element that satisfies the provided testing function.	ES2023

Showing 10 of 38. View full data: JSON · CSV

Fetch examples

Drop-in snippets in five languages.

curl

curl -sSL https://staticdata.dev/v1/js-array-methods.json | jq '.[0]'

JavaScript

import type { ArrayMethod } from "https://staticdata.dev/v1/js-array-methods.ts";

const res = await fetch("https://staticdata.dev/v1/js-array-methods.min.json");
if (!res.ok) throw new Error(`Fetch failed: ${res.status}`);
const jsArrayMethods: ArrayMethod[] = await res.json();
console.log(jsArrayMethods[0]);

Python

import urllib.request, json

with urllib.request.urlopen("https://staticdata.dev/v1/js-array-methods.min.json") as r:
    jsArrayMethods = json.load(r)

print(jsArrayMethods[0])

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
)

func main() {
	resp, err := http.Get("https://staticdata.dev/v1/js-array-methods.min.json")
	if err != nil { panic(err) }
	defer resp.Body.Close()

	var data []map[string]any
	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
		panic(err)
	}
	fmt.Println(data[0])
}

Rust

use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let body = ureq::get("https://staticdata.dev/v1/js-array-methods.min.json").call()?.into_string()?;
    let data: Vec<Value> = serde_json::from_str(&body)?;
    println!("{:?}", data.first());
    Ok(())
}

Sources and methodology

Data is curated from the MDN Web Docs and cross-referenced against the ECMAScript Language Specification. Every standard Array.prototype method (38 as of ES2026, October 2026) is included — from the original ES1 methods (join, reverse, sort, toString) and the ES3 additions (concat, push, pop, shift, unshift, slice, splice) through the ES2023 additions (toReversed, toSorted, toSpliced, with, findLast, findLastIndex).

The mutates field follows the ECMAScript specification semantics: a method is marked true only when it modifies the receiver array as a side effect. The four ES2023 copy methods (toReversed, toSorted, toSpliced, with) were specifically designed as non-mutating counterparts to reverse, sort, splice, and bracket assignment respectively. Iterator-returning methods (entries, keys, values) are non-mutating and return a fresh Iterator object each time they are called.

ecmaVersion records the edition of the ECMA-262 standard that first standardized the method. Methods from the original 1997 specification are listed as ES1. Note that some methods (e.g. push, pop) were de-facto standard before ES3 but were formally specified in that edition; the entry reflects first formal standardization. Implementations may differ slightly from the specification in older engines — always verify with MDN compatibility tables for browser/Node.js support targets.

Versioning

URLs under /v1/ are stable: field names and types will not change in a way that breaks consumers. Values can be corrected or records added when the upstream source changes; schema-incompatible updates ship under a new version path. See the js-array-methods changelog for this dataset's history.