Функции для работы с массивами


JS Array concat() constructor copyWithin() entries() every() fill() filter() find() findIndex() forEach() from() includes() indexOf() isArray() join() keys() length lastIndexOf() map() pop() prototype push() reduce() reduceRight() reverse() shift() slice() some() sort() splice() toString() unshift() valueOf()

JS Boolean constructor prototype toString() valueOf()

JS Classes constructor() extends static super

JS Date constructor getDate() getDay() getFullYear() getHours() getMilliseconds() getMinutes() getMonth() getSeconds() getTime() getTimezoneOffset() getUTCDate() getUTCDay() getUTCFullYear() getUTCHours() getUTCMilliseconds() getUTCMinutes() getUTCMonth() getUTCSeconds() now() parse() prototype setDate() setFullYear() setHours() setMilliseconds() setMinutes() setMonth() setSeconds() setTime() setUTCDate() setUTCFullYear() setUTCHours() setUTCMilliseconds() setUTCMinutes() setUTCMonth() setUTCSeconds() toDateString() toISOString() toJSON() toLocaleDateString() toLocaleTimeString() toLocaleString() toString() toTimeString() toUTCString() UTC() valueOf()

JS Error name message

JS Global decodeURI() decodeURIComponent() encodeURI() encodeURIComponent() escape() eval() Infinity isFinite() isNaN() NaN Number() parseFloat() parseInt() String() undefined unescape()

JS JSON parse() stringify()

JS Math abs() acos() acosh() asin() asinh() atan() atan2() atanh() cbrt() ceil() cos() cosh() E exp() floor() LN2 LN10 log() LOG2E LOG10E max() min() PI pow() random() round() sin() sqrt() SQRT1_2 SQRT2 tan() tanh() trunc()

JS Number constructor isFinite() isInteger() isNaN() isSafeInteger() MAX_VALUE MIN_VALUE NEGATIVE_INFINITY NaN POSITIVE_INFINITY prototype toExponential() toFixed() toLocaleString() toPrecision() toString() valueOf()

JS OperatorsJS RegExp constructor compile() exec() g global i ignoreCase lastIndex m multiline n+ n* n? n{X} n{X,Y} n{X,} n$ ^n ?=n ?!n source test() toString() (x|y) . \w \W \d \D \s \S \b \B \0 \n \f \r \t \v \xxx \xdd \uxxxx

JS Statements break class continue debugger do…while for for…in for…of function if…else return switch throw try…catch var while

JS String charAt() charCodeAt() concat() constructor endsWith() fromCharCode() includes() indexOf() lastIndexOf() length localeCompare() match() prototype repeat() replace() search() slice() split() startsWith() substr() substring() toLocaleLowerCase() toLocaleUpperCase() toLowerCase() toString() toUpperCase() trim() valueOf()


An array is a special kind of object. The square brackets used to access a property actually come from the object syntax. That’s essentially the same as , where is the object, while numbers are used as keys.

They extend objects providing special methods to work with ordered collections of data and also the property. But at the core it’s still an object.

Remember, there are only 7 basic types in JavaScript. Array is an object and thus behaves like an object.

For instance, it is copied by reference:

…But what makes arrays really special is their internal representation. The engine tries to store its elements in the contiguous memory area, one after another, just as depicted on the illustrations in this chapter, and there are other optimizations as well, to make arrays work really fast.

But they all break if we quit working with an array as with an “ordered collection” and start working with it as if it were a regular object.

For instance, technically we can do this:

That’s possible, because arrays are objects at their base. We can add any properties to them.

But the engine will see that we’re working with the array as with a regular object. Array-specific optimizations are not suited for such cases and will be turned off, their benefits disappear.

The ways to misuse an array:

  • Add a non-numeric property like .
  • Make holes, like: add and then (and nothing between them).
  • Fill the array in the reverse order, like , and so on.

Please think of arrays as special structures to work with the ordered data. They provide special methods for that. Arrays are carefully tuned inside JavaScript engines to work with contiguous ordered data, please use them this way. And if you need arbitrary keys, chances are high that you actually require a regular object .


There are two syntaxes for creating an empty array:

Almost all the time, the second syntax is used. We can supply initial elements in the brackets:

Array elements are numbered, starting with zero.

We can get an element by its number in square brackets:

We can replace an element:

…Or add a new one to the array:

The total count of the elements in the array is its :

We can also use to show the whole array.

An array can store elements of any type.

For instance:

Trailing comma

An array, just like an object, may end with a comma:

The “trailing comma” style makes it easier to insert/remove items, because all lines become alike.

Slicing an Array

The method slices out a piece of an array into a new array.

This example slices out a part of an array starting from array element 1 («Orange»):

var fruits = ; var citrus = fruits.slice(1);

The method creates a new array. It does not remove any elements from the source array.

This example slices out a part of an array starting from array element 3 («Apple»):

var fruits = ; var citrus = fruits.slice(3);

The method can take two arguments like .

The method then selects elements from the start argument, and up to (but not including) the end argument.

var fruits = ; var citrus = fruits.slice(1, 3);

If the end argument is omitted, like in the first examples, the method slices out the rest of the array.

Methods pop/push, shift/unshift

A queue is one of the most common uses of an array. In computer science, this means an ordered collection of elements which supports two operations:

  • appends an element to the end.
  • get an element from the beginning, advancing the queue, so that the 2nd element becomes the 1st.

Arrays support both operations.

In practice we need it very often. For example, a queue of messages that need to be shown on-screen.

There’s another use case for arrays – the data structure named stack.

It supports two operations:

  • adds an element to the end.
  • takes an element from the end.

So new elements are added or taken always from the “end”.

A stack is usually illustrated as a pack of cards: new cards are added to the top or taken from the top:

For stacks, the latest pushed item is received first, that’s also called LIFO (Last-In-First-Out) principle. For queues, we have FIFO (First-In-First-Out).

Arrays in JavaScript can work both as a queue and as a stack. They allow you to add/remove elements both to/from the beginning or the end.

In computer science the data structure that allows this, is called deque.

Methods that work with the end of the array:

Extracts the last element of the array and returns it:

Append the element to the end of the array:

The call is equal to .

Methods that work with the beginning of the array:

Extracts the first element of the array and returns it:

Add the element to the beginning of the array:

Methods and can add multiple elements at once:


The method calls a function (a callback function) once for each array element.


var txt = «»;var numbers = ; numbers.forEach(myFunction); function myFunction(value, index, array) {   txt = txt + value + «<br>»; }

Note that the function takes 3 arguments:

  • The item value
  • The item index
  • The array itself

The example above uses only the value parameter. The example can be rewritten to:


var txt = «»;var numbers = ; numbers.forEach(myFunction); function myFunction(value) {   txt = txt + value + «<br>»; }

is supported in all browsers except Internet Explorer 8 or earlier:

Yes 9.0 Yes Yes Yes


Операція не виконується для неініціалізованих значень (розріджені масиви)

const arraySparse = ;
let numCallbackRuns = 0;


console.log("numCallbackRuns: ", numCallbackRuns);

// 1
// 3
// 7
// numCallbackRuns: 3
// коментар: як бачите, пропущене значення між 3 та 7 не викликало функцію.

Перетворення циклу for на forEach

const items = ;
const copy = [];

// було
for (let i = 0; i < items.length; i++) {

// стане
items.forEach(function(item) {

Друк вмісту масиву

Наведений код виводить значення кожного елемента масиву з нового рядка:

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

// Завважте, що індекс 2 буде пропущено,
// позаяк елемента на тому місці в масиві немає.

// Буде виведено у консоль:
// array = 2
// array = 5
// array = 9


Наведений приклад змінює властивості об’єкта відповідно до кожного елемента в отриманому масиві:

function Counter() {
  this.sum = 0;
  this.count = 0;

Counter.prototype.add = function(array) {
  array.forEach(function(entry) {
    this.sum += entry;
  }, this);
  // ^---- Зверніть увагу!

const obj = new Counter();
// 3
// 16

Оскільки для вказано параметр , для кожного виклику (тут безіменної функції) він вживатиметься як .

Якщо передавати аргумент функції за допомогою стрілкового запису функції, то параметр можна не вказувати, позаяк стрілкова функція лексично прив’язує значення .

Функція копіювання об’єкта

Наступний код створює копію наданого об’єкта. Існує чимало способів створення копії об’єкта. Наведений приклад є лише одним з них і насправді призначений лише для наочного пояснення того, як працює на прикладі використання нових функцій ECMAScript 5 з для роботи з керованими властивостями:

function copy(obj) {
  const copy = Object.create(Object.getPrototypeOf(obj));
  const propNames = Object.getOwnPropertyNames(obj);

  propNames.forEach(function(name) {
    const desc = Object.getOwnPropertyDescriptor(obj, name);
    Object.defineProperty(copy, name, desc);

  return copy;

const obj1 = {a: 1, b: 2};
const obj2 = copy(obj1);  // obj2 тепер схожий на obj1

Якщо масив змінено під час перебору, інші елементи може бути пропущено

Наведений приклад виводить у консоль послідовно «перший», «другий» та «четвертий». Коли перебір сягне другого елемента (що має значення «другий»), виклик видалить перший елемент масиву, а всі, що лишаться, посунуться на одне місце ліворуч — «четвертий» стане наступним (після поточного), і «третій» таким чином буде пропущено:

var words = ;

words.forEach(function(word) {

  if (word === 'другий') {

// перший
// другий
// четвертий

Вирівнювання масиву

Даний приклад наведено суто для навчальння. Якщо вам потрібно вирівняти масив вбудованими методами, ви можете скористатись методом  (очікується у ES2019 та вже реалізований у деяких переглядачах).

* Вирівнює переданий масив у одномірний
* @params {array} arr
* @returns {array}
function flatten(arr) {
  const result = [];

  arr.forEach((i) => {
    if (Array.isArray(i)) {
    } else {

  return result;

// Використання
const problem = , 8, 9]]

flatten(problem) // 


Использование представлений с буферами

Прежде всего, необходимо создать буфер с фиксированной длиной 16 байт:

var buffer = new ArrayBuffer(16);

На данном этапе мы имеем область памяти в 16 байт, инициализированной нулевыми значениями. Всё, что мы можем сделать сейчас, это убедиться, что длина буфера действительно 16 байт:

if (buffer.byteLength === 16) {
  console.log("Да, это 16 байт.");
} else {
  console.log("О нет, размер не наш!");

Прежде чем мы сможем приступить к полноценной работе с памятью, нам нужно создать представление. Давайте создадим представление, которое отображает буфер как массив из 32-битных целочисленных значений со знаком:

var int32View = new Int32Array(buffer);

Теперь мы можем получить доступ к элементам представления как к элементам обычного массива:

for (var i = 0; i < int32View.length; i++) {
  int32View = i * 2;

Этот код поместит 4 элемента в буфер (4 элемента по 4 байта даст 16 байт) со следующими значениям: , ,  и .

Множество представлений для одних и тех же данных

Всё становится намного интереснее, если создать несколько разных представлений для одного и того же буфера. Например, приведенный выше код можно дополнить следующим образом:

var int16View = new Int16Array(buffer);

for (var i = 0; i < int16View.length; i++) {
  console.log('Entry ' + i + ': ' + int16View);

Здесь мы создаем 16-битное целочисленное представление, которое ссылается на тот же самый буфер, что и 32-битное представление, и затем выводим все 16-битные элементы этого представления. Мы получим следующий вывод: 0, 0, 2, 0, 4, 0, 6, 0.

Можно пойти дальше. Оцените этот код:

int16View = 32;
console.log('Элемент 0 в 32-битном представлении теперь равен ' + int32View);

Результатом выполнения станет текст: «Элемент 0 в 32-битном представлении теперь равен 32». Другими словами, два массива на самом деле являются лишь разными представлениями одного и того же буфера данных в разных форматах. Вы можете повторить это с  любого типа.

Работа со сложными структурами данных

Рассмотрим следующую структуру из языка C:

struct someStruct {
  unsigned long id;
  char username;
  float amountDue;

Получить доступ к полям этой структуры можно следующим образом:

var buffer = new ArrayBuffer(24);

// ... поместить данные структуры в буфер ...

var idView = new Uint32Array(buffer, 0, 1);
var usernameView = new Uint8Array(buffer, 4, 16);
var amountDueView = new Float32Array(buffer, 20, 1);

Теперь получить или изменить значение поля , к примеру, можно путем обращения к .

Примечание: Выравнивание данных в языке C является платформозависимым. Принимайте меры по вычислению правильных отступов в данных с учетом выравнивания.

Преобразование в обычные массивы

Иногда после обработки типизированного массива бывает полезно конвертировать его в обычный массив, чтобы получить доступ к методам прототипа . Для этих целей существует метод . А в тех случаях, когда  не поддерживается, используйте следующий код:

var typedArray = new Uint8Array(),
    normalArray = Array.prototype.slice.call(typedArray);
normalArray.length === 4;
normalArray.constructor === Array;


The method searches an array for an element value and returns its position.

Note: The first item has position 0, the second item has position 1, and so on.


Search an array for the item «Apple»:

var fruits = ; var a = fruits.indexOf(«Apple»);

is supported in all browsers except Internet Explorer 8 or earlier.

Yes 9.0 Yes Yes Yes


array.indexOf(item, start)

item Required. The item to search for.
start Optional. Where to start the search. Negative values will start at the given position counting from the end, and search to the end.

returns -1 if the item is not found.

If the item is present more than once, it returns the position of the first occurrence.


Array is a special kind of object, suited to storing and managing ordered data items.

  • The declaration:

    The call to creates an array with the given length, but without elements.

  • The property is the array length or, to be precise, its last numeric index plus one. It is auto-adjusted by array methods.

  • If we shorten manually, the array is truncated.

We can use an array as a deque with the following operations:

  • adds to the end.
  • removes the element from the end and returns it.
  • removes the element from the beginning and returns it.
  • adds to the beginning.

To loop over the elements of the array:

  • – works fastest, old-browser-compatible.
  • – the modern syntax for items only,
  • – never use.

We will return to arrays and study more methods to add, remove, extract elements and sort arrays in the chapter Array methods.


// Production steps of ECMA-262, Edition 6,
if (!Array.from) {
  Array.from = (function () {
    var toStr = Object.prototype.toString;
    var isCallable = function (fn) {
      return typeof fn === 'function' || toStr.call(fn) === '';
    var toInteger = function (value) {
      var number = Number(value);
      if (isNaN(number)) { return 0; }
      if (number === 0 || !isFinite(number)) { return number; }
      return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number));
    var maxSafeInteger = Math.pow(2, 53) - 1;
    var toLength = function (value) {
      var len = toInteger(value);
      return Math.min(Math.max(len, 0), maxSafeInteger);

    // The length property of the from method is 1.
    return function from(arrayLike/*, mapFn, thisArg */) {
      // 1. Let C be the this value.
      var C = this;

      // 2. Let items be ToObject(arrayLike).
      var items = Object(arrayLike);

      // 3. ReturnIfAbrupt(items).
      if (arrayLike == null) {
        throw new TypeError("Array.from requires an array-like object - not null or undefined");

      // 4. If mapfn is undefined, then let mapping be false.
      var mapFn = arguments.length > 1 ? arguments : void undefined;
      var T;
      if (typeof mapFn !== 'undefined') {
        // 5. else
        // 5. a If IsCallable(mapfn) is false, throw a TypeError exception.
        if (!isCallable(mapFn)) {
          throw new TypeError('Array.from: when provided, the second argument must be a function');

        // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined.
        if (arguments.length > 2) {
          T = arguments;

      // 10. Let lenValue be Get(items, "length").
      // 11. Let len be ToLength(lenValue).
      var len = toLength(items.length);

      // 13. If IsConstructor(C) is true, then
      // 13. a. Let A be the result of calling the ] internal method 
      // of C with an argument list containing the single item len.
      // 14. a. Else, Let A be ArrayCreate(len).
      var A = isCallable(C) ? Object(new C(len)) : new Array(len);

      // 16. Let k be 0.
      var k = 0;
      // 17. Repeat, while k < len… (also steps a - h)
      var kValue;
      while (k < len) {
        kValue = items;
        if (mapFn) {
          A = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k);
        } else {
          A = kValue;
        k += 1;
      // 18. Let putStatus be Put(A, "length", len, true).
      A.length = len;
      // 20. Return A.
      return A;


aşağıdaki yapılardan  oluşturmanıza izin verir:

  • dizi-benzeri nesneler (sıralı öğeler ve bir uzunluk() özelliği olan nesneler) ya da

has an optional parameter , which allows you to execute a function on each element of the array (or subclass object) that is being created. More clearly, has the same result as , except that it does not create an intermediate array. This is especially important for certain array subclasses, like typed arrays, since the intermediate array would necessarily have values truncated to fit into the appropriate type.

The property of the method is 1.

In ES2015, the class syntax allows for sub-classing of both built-in and user defined classes; as a result, static methods such as are «inherited» by subclasses of and create new instances of the subclass, not .

JS Tutorial

JS HOMEJS IntroductionJS Where ToJS OutputJS StatementsJS SyntaxJS CommentsJS VariablesJS OperatorsJS ArithmeticJS AssignmentJS Data TypesJS FunctionsJS ObjectsJS EventsJS StringsJS String MethodsJS NumbersJS Number MethodsJS ArraysJS Array MethodsJS Array SortJS Array IterationJS DatesJS Date FormatsJS Date Get MethodsJS Date Set MethodsJS MathJS RandomJS BooleansJS ComparisonsJS ConditionsJS SwitchJS Loop ForJS Loop WhileJS BreakJS Type ConversionJS BitwiseJS RegExpJS ErrorsJS ScopeJS HoistingJS Strict ModeJS this KeywordJS LetJS ConstJS Arrow FunctionJS DebuggingJS Style GuideJS Best PracticesJS MistakesJS PerformanceJS Reserved WordsJS VersionsJS Version ES5JS Version ES6JS JSON

С этим читают