Which functions in Array.prototype are pure function in Javascript

Note: This list includes the first standard the method appears in. For clarity for older standards:

• [ES1997] is ES1 - 1st edition of the ECMAScript standard
• [ES1999] is ES3 - 3rd edition of the ECMAScript standard
• [ES2009] is the 5.0 version of the ECMAScript standard, it has been revised in 2011 as 5.1, however no new relevant methods have been added in there

Array static methods

• from^{1 [ES2015]}

• isArray ^[ES2009]

• of ^[ES2015]

Array instance methods

• at ^[ES2022]

• concat ^[ES1999]

• entries^{2 [ES2015]}

• every^{1 [ES2009]}

• filter^{1 [ES2009]}

• find^{1 [ES2015]}

• findLast^{1 [ES2023]}

• findIndex^{1 [ES2015]}

• findLastIndex^{1 [ES2023]}

• flat ^[ES2020]

• flatMap()^{1 [ES2020]}

• forEach^{3 [ES2009]}

• includes ^[ES2015]

• indexOf ^[ES2009]

• join ^[ES1997]

• keys^{2 [ES2015]}

• lastIndexOf ^[ES2009]

• map^{1 [ES2009]}

• reduce^{1 [ES2009]}

• reduceRight^{1 [ES2009]}

• slice ^[ES1999]

• some^{1 [ES2009]}

• toReversed⁴ - pure version of reverse ^[ES2023]

• toSorted⁴ - pure version of sort ^[ES2023]

• toSpliced⁴ - pure version of splice ^[ES2023]

• values^{2 [ES2015]}

• with⁴ - pure version of assigning a value to an index ^[ES2023]

• @@iterator^{2 [ES2015]}

¹ These accept a callback parameter. While the method will not itself alter any of the arguments, the callback might. So, technically it's possible to pass an impure callback which makes the whole operation impure.

² Returns an iterator. The operation is pure but using the iterator is not. For example, you might get different results if you get all the values of the iterator immediately or you get some, then the array is altered in-place, then you continue getting values from the iterator.

³ Technically pure by its operation but the expectation is that the callback it accepts will have side effects. If the callback doesn't have side effects, it's likely not going to be a useful operation.

⁴ This is a pure version of an existing method. Instead of mutating the current instance, it returns a new array with the operation applied to it.

References:

• ES1997 - Standard ECMA-262 / June 1997 (PDF).
• ES1998 - Standard ECMA-262 2^nd Edition / August 1998 (PDF). No new relevant methods were defined by the standard.
• ES1999 - ECMAScript Language Specification Edition 3 Final / March 2000 (PDF). From the document:

  This Standard has been adopted as 3rd Edition of ECMA-262 by the ECMA General Assembly in December, 1999

• ES2009 - ECMA-262 5^th Edition / December 2009 (PDF).
• ES2011 - ECMA-262 5.1 Edition / June 2011 (HTML). Refinements over 5 but no new relevant methods have been added for arrays.
• ES2015 - ECMA-262 6^th Edition / June 2015 (HTML). Also called ES6.
• ES2016 - ECMA-262 7^th Edition / June 2016 (HTML). Also called ES7. No new relevant array methods.
• ES2017 - ECMA-262 8^th edition / June 2017 (HTML). Also called ES8. No new relevant array methods.
• ES2018 - ECMA-262 9^th edition / June 2018 (HTML). Also called ES9. No new relevant array methods.
• ES2019 - ECMA-262 10^th edition / June 2019 (HTML). Also called ES10. No new relevant array methods.
• ES2020 - ECMA-262 11^th edition / June 2020 (HTML). Also called ES11.
• ES2021 - ECMA-262 12^th edition / June 2021 (HTML). Also called ES12. No new relevant array methods.
• ES2022 - ECMA-262 13^th edition / June 2022 (HTML). Also called ES13.
• ES2023 - ECMA-262 14^th edition / June 2023 (HTML). Also called ES14.