Массивы в JavaScript. Массивы Рекурсия и динамика значения


The push() method adds one or more elements to the end of an array and returns the new length of the array.

The source for this interactive example is stored in a GitHub repository. If you"d like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.

Syntax arr .push(element1 [, ...[, elementN ]]) Parameters elementN The element(s) to add to the end of the array. Return value Examples Adding elements to an array

The following code creates the sports array containing two elements, then appends two elements to it. The total variable contains the new length of the array.

Let sports = ["soccer", "baseball"] let total = sports.push("football", "swimming") console.log(sports) // ["soccer", "baseball", "football", "swimming"] console.log(total) // 4

Merging two arrays

This example uses apply() to push all elements from a second array.

Do not use this method if the second array (moreVegs in the example) is very large, because the maximum number of parameters that one function can take is limited in practice. See apply() for more details.

Let vegetables = ["parsnip", "potato"] let moreVegs = ["celery", "beetroot"] // Merge the second array into the first one // Equivalent to vegetables.push("celery", "beetroot") Array.prototype.push.apply(vegetables, moreVegs) console.log(vegetables) // ["parsnip", "potato", "celery", "beetroot"]

Using an object in an array-like fashion

As mentioned above, push is intentionally generic, and we can use that to our advantage. Array.prototype.push can work on an object just fine, as this example shows.

Note that we don"t create an array to store a collection of objects. Instead, we store the collection on the object itself and use call on Array.prototype.push to trick the method into thinking we are dealing with an array-and it just works, thanks to the way JavaScript allows us to establish the execution context however we please.

Let obj = { length: 0, addElem: function addElem(elem) { // obj.length is automatically incremented // every time an element is added. .push.call(this, elem) } } // Let"s add some empty objects just to illustrate. obj.addElem({}) obj.addElem({}) console.log(obj.length) // → 2

Note that although obj is not an array, the method push successfully incremented obj "s length property just like if we were dealing with an actual array.

Specifications Specification Status Comment
ECMAScript 3rd Edition (ECMA-262) Standard Initial definition. Implemented in JavaScript 1.2.
ECMAScript 5.1 (ECMA-262)
 Standard
ECMAScript 2015 (6th Edition, ECMA-262)
The definition of "Array.prototype.push" in that specification. 		Standard
ECMAScript Latest Draft (ECMA-262)
The definition of "Array.prototype.push" in that specification. 		Draft
Browser compatibility

The compatibility table in this page is generated from structured data. If you"d like to contribute to the data, please check out https://github.com/mdn/browser-compat-data and send us a pull request.

Update compatibility data on GitHub

Desktop Mobile Server Chrome Edge Firefox Internet Explorer Opera Safari Android webview Chrome for Android Firefox for Android Opera for Android Safari on iOS Samsung Internet Node.js push
Chrome Full support 1 Edge Full support 12 Firefox Full support 1 IE Full support 5.5 Opera Full support Yes Safari Full support 1 WebView Android Full support Yes Chrome Android Full support 18 Firefox Android Full support 4 Opera Android Full support Yes Safari iOS Full support 1 Samsung Internet Android Full support Yes nodejs Full support Yes

Стек позволяет отнести к данным историю изменения значений переменных. Описание данных и алгоритмов лежит в основе программирования. Стек - это основа для передачи управления между функциями, организации рекурсии и ссылок на параметры. Синтаксис и семантика JavaScript посредством методов массива push() и pop() дают возможность манипулировать смыслом и учитывать фактор времени. Особенность языка браузера и его логика позволяют иначе взглянуть на возможности фактора времени.

Массив данных и логика его образования

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

  • описать (создать) переменную;
  • присвоить значение;
  • изменить значение;
  • удалить переменную.

Функции push() и pop() позволяют изменить сущность переменных и их использование. Идея стека не изменилась с момента ее «рождения», но особенность JS как языка браузера и современной концепции программирования позволяет учесть фактор времени и придать данным динамику.

Функция value") - добавить что-то в конец массива. Функция - извлечь последний элемент массива. Указатель в контексте push/pop при добавлении перемещается на добавленный элемент, при извлечении - на предпоследний элемент, а последний элемент является результатом выполнения операции.

Стопка тарелок - традиционное описание стека в JavaScript - приобретает новое значение. Пусть всегда переменная - это массив. Собственно массив - это совокупность переменных, но рассматривая переменную как массив, можно иначе посмотреть на динамику изменения ее значений.

Движение по значениям

Суть стека - пришел последним, ушел первым. Нельзя извлечь значение вне данного порядка. Строго соблюдая это правило, рассматривая значения всего массива как одну переменную, можно получить динамику изменения значений этой переменной во времени.

В этом примере добавление значений JS array.push(...) - это одна последовательность действий, извлечение значений JS array pop() - другая последовательность. Оба варианта действий взаимосвязаны. Это означает, что активный элемент меняет свое значение не только по времени, но и по логике своего изменения.

Рекурсия и динамика значения

Если функция может вызвать саму себя и безопасно исполнить свое предназначение - это полная функциональность. Простой пример - таблица. В таблице могут быть и другие таблицы. А каждая таблица - это строчки, столбцы и ячейки. Каждая ячейка может содержать таблицу. Несколько ячеек по строке или по столбцу могут быть объединены в одну ячейку, в которой может находиться таблица. В таблице, находящейся в ячейке, может быть ячейка с двумя и более таблицами.

Реализовать сказанное в классическом стиле программирования практически невозможно, но в рекурсивном - элементарно. Если функциональность алгоритма работы с таблицей позволяет реализовать себя внутри любой ячейки - значит, это JS array push. На JavaScript этот «фокус» имеет особенный смысл. Таблицы - это пользовательское применение. Дерево страницы (DOM) - это работа на странице.

На элементах DOM (тегах страницы) висят обработчики. Один вариант, когда такой обработчик срабатывает один раз, совсем другой вариант, когда он может вызывать сам себя много раз. В разрезе всех обработчиков всех элементов страницы получается динамика страницы во времени.

Push/pop и рекурсия - это несколько иное представление о логике работы страницы: все меняется так, как требуется в текущей ситуации, а не программируется заранее в виде последовательной отработки действий посетителя.

Метод push() добавляет один или несколько элементов в конец массива и возвращает новую длину массива.

Синтаксис arr .push(element1 [, ...[, elementN ]]) параметры element N Элементы для добавления в конец массива. Возвращаемое значение var vegetables = ["parsnip", "potato"]; var moreVegs = ["celery", "beetroot"]; // Merge the second array into the first one // Equivalent to vegetables.push("celery", "beetroot"); Array.prototype.push.apply(vegetables, moreVegs); console.log(vegetables); // ["parsnip", "potato", "celery", "beetroot"] Использование объекта в виде массива

Как упоминалось выше, push намеренно является общим, и мы можем использовать это в наших интересах. Array.prototype.push может работать с объектом просто отлично, как показывает этот пример. Обратите внимание: мы не создаем массив для хранения коллекции объектов. Вместо этого мы храним коллекцию на самом объекте и используем call Array.prototype.push чтобы обмануть метод, думая, что мы имеем дело с массивом, и он просто работает, благодаря тому, что JavaScript позволяет нам установить контекст выполнения, однако мы пожалуйста.

Var obj = { length: 0, addElem: function addElem(elem) { // obj.length is automatically incremented // every time an element is added. .push.call(this, elem); } }; // Let"s add some empty objects just to illustrate. obj.addElem({}); obj.addElem({}); console.log(obj.length); // → 2

Обратите внимание, что хотя obj не является массивом, метод push успешно увеличивает значение length объекта obj же, как если бы мы имели дело с фактическим массивом.

ХарактеристикиСовместимость с браузером Особенность Веб-просмотр Android Chrome для Android Edge mobile Firefox для Android Операционная система Android iOS Safari Интернет-магазин Samsung

В JavaScript . Здесь мы продолжим знакомство с Массивами. Поговорим о свойстве length - как узнать: сколько же элементов содержит Массив?

Научимся добавлять элементы в начало и конец Массива - это методы unshift и push соответственно.

А также с помощью методов shift и pop сможем удалить элементы также из начала и конца Массива!

По сути, Массив - это некий объект, состоящий из определенного числа различных элементов.

Свойство length позволят узнать количество элементов в Массиве.

Для примера давайте возьмём Массив семи дней недели знакомый нам по прошлой теме .

var days = ["Пон." , "Вт.";

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

array.length - такой код даёт нам число элементов Массива (где array - имя Массива) .

var days = ["Пон." , "Вт.", "Ср.", "Чт.", "Пят.", "Суб.", "Вс."] ;

var count = days .length ;

document .write ( count );

Таким образом, в переменную count мы поместили число, равное количеству элементов Массива.

Вот так работает свойство length .

Метод push - добавляет элемент в конец Массива .

Для того чтобы начать работу с методами добавления элементов, нужно создать какой-либо Массив.

Ниже я создал Массив «Друзья» - friends .

, "Вячеслав", "Алексей"] ;

Сейчас нам необходимо добавить элемент, то есть ещё одно Имя в конец Массива.

Для этого существует метод push - он добавляет элемент в конец Массива. Это выглядит следующим образом:

, " Вячеслав", " Алексей"] ;

friends .push (" Яков" ); /*Добавляем элемент в конец Массива*/

document .write ( + friends .length );

document .write ("

" + friends ); /*Выводим весь Массив*/

document .write ("

" + friends ); /*Выводим последний 5-ый элемент Массива*/

Настя, Григорий, Вячеслав, Алексей, Яков

Яков

Для проверки работы метода push в примере выше, мы вывели количество элементов Массива friends при помощи свойства length - их стало 5. Затем вывели весь Массив friends , а также последний элемент Массива .

Теперь Вы можете сами убедиться, что элемент добавлен в конец Массива!

Метод unshift - добавляет элемент в начало Массива .

Здесь мы снова обратимся к Массиву friends .

var friends = ["Настя" , "Григорий", "Вячеслав", "Алексей"] ;

Теперь нам нужно добавить элемент в начало Массива. Для этого существует метод unshift .

var friends = [" Настя" , " Григорий", " Вячеслав", " Алексей"] ;

friends .unshift (" Борис" ); /*Добавляем элемент в начало Массива*/

document .write ("Количество элементов в Массиве равно " + friends .length );

document .write ("

" + friends ); /*Выводим весь Массив*/

document .write ("

" + friends ); /*Выводим первый элемент Массива*/

Количество элементов в Массиве равно 5

Борис , Настя, Григорий, Вячеслав, Алексей

Борис

Для проверки работы метода unshift мы вывели количество элементов Массива friends при помощи свойства length , потом вывели весь Массив friends , а также первый элемент Массива (напоминаем, что нумерация элементов Массива начинается с 0) .

Теперь, как видите, элемент добавлен в начало Массива!

Метод pop - удаляет последний элемент из Массива .

И снова работаем с Массивом «Друзья»

var friends = ["Настя" , "Григорий", "Вячеслав", "Алексей"] ;

Используя метод pop - удаляем последний элемент из Массива :

var friends = [" Настя" , " Григорий", " Вячеслав", " Алексей"] ;

friends .pop (); /*Удаляем последний элемент из Массива*/

document .write ("Количество элементов в Массиве равно " + friends .length );

document .write ("

" + friends ); /*Выводим весь Массив*/

document .write ("

" + friends ); /*Выводим последний элемент Массива. Для этого берём общее число элементов Массива - friends.length и, так как, нумерация в массиве начинается с нуля, то из этого числа вычитаем 1*/

Настя, Григорий, Вячеслав

Вячеслав

Для наглядности работы метода pop мы снова вывели количество элементов Массива при помощи свойства length , затем вывели весь Массив friends - уже без удалённого последнего элемента.

А также вывели последний элемент вновь получившегося Массива. Для вывода последнего элемента, воспользовавшись свойством length, мы взяли общее число оставшихся элементов в Массиве (3) и вычли из него 1. Таким образом, мы вывели последний элемент массива под номером 2. Но это третий элемент, так как нумерация в Массиве начинается с 0!!!

Метод shift - удаляет первый элемент из Массива .

Перед нами, как и ранее, Массивом «Друзья»

var friends = ["Настя" , "Григорий", "Вячеслав", "Алексей"] ;

С помощью метода shift - удаляем первый элемент из Массива :

var friends = [" Настя" , " Григорий", " Вячеслав", " Алексей"] ;

friends .shift (); /*Удаляем первый элемент из Массива*/

document .write ("Количество элементов в Массиве равно " + friends .length );

document .write ("

" + friends ); /*Выводим весь Массив*/

document .write ("

" + friends ); /*Выводим первый элемент Массива.*/

Количество элементов в Массиве равно 3

Григорий, Вячеслав, Алексей

Григорий

И, наконец, для проверки работы метода shift мы вывели количество элементов вновь получившегося Массива при помощи свойства length , затем вывели весь Массив friends - уже без удалённого первого элемента.

А также вывели первый элемент Массива . Нумерация в Массиве начинается с 0!!!

Напомню для Вас и для себя один интересный момент этой статьи!

Для того чтобы узнать номер/индекс последнего элемента Массива, нужно из числа его элементов (т.е. из ) Вычесть единицу!!!

Мы уже работали с этим в пункте темы .

Хорошим вариантом иллюстрации этого момента будет продолжение примера из пункта темы, где мы рассматривали Массив семи дней недели.

var days = ["Пон." , "Вт.", "Ср.", "Чт.", "Пят.", "Суб.", "Вс."] ;

var count = days .length ; /*Создаём переменную count в которую заносим число элементов Массива days*/

document .write ("Количество элементов в Массиве days равно " + count );

document .write ("

Номером последнего элемента Массива days является число " + (count - 1 ) );

Количество элементов в Массиве days равно 7

Номером последнего элемента Массива является число 6

Итак, этим примером мы заодно ещё раз отметили тот факт, что нумерация в Массиве начинается с 0 . И, как видно из этого примера, номером 7-го элемента массива является число 6.

В конце этой темы также выполним домашнее задание. И снова попробуйте решить его самостоятельно.

Домашнее задание по удалению из... и добавлению элементов в Массив в Javascript имеет следующее содержание:

1. Создайте массив с фруктами: апельсин, банан, груша.
2. Выведите на экран, сколько на данный момент у вас фруктов в массиве.
3. С помощью методов, изученных в предыдущем уроке, добавьте в конец массива два фрукта - яблоко и ананас, а в начало массива - грейпфрут.
4. Выведите на экран, сколько на данный момент у вас фруктов в массиве.
5. С помощью методов, изученных в предыдущем уроке, удалите из массива последний и первый элемент.
6. Выведите на экран, сколько на данный момент у вас фруктов в массиве.

var fruit = [" Апельсин" ," Банан" ," Груша" ];
document .write (fruit + "

" )
document .write ("Сейчас в моей корзине " + fruit.length + " фрукта" + "

fruit .push (" Яблоко" , " Ананас" ); // Добавляем элементы в КОНЕЦ массива
fruit .unshift (" Грейпфрут" ); // Добавляем элементы в НАЧАЛО массива
document .write (fruit + "

" )
document .write ("Сейчас в моей корзине " + fruit.length + " фруктов" + "

fruit .pop (); // Удаляем ПОСЛЕДНИЙ элемент из Массива
fruit .shift (); // Удаляем ПЕРВЫЙ элемент из Массива
document .write (fruit + "

" )
document .write ("Сейчас в моей корзине " + fruit.length + " фрукта" );

Апельсин, Банан, Груша

Сейчас в моей корзине 3 фрукта

Грейпфрут, Апельсин, Банан, Груша, Яблоко, Ананас

Сейчас в моей корзине 6 фруктов

Апельсин, Банан, Груша, Яблоко

Сейчас в моей корзине 4 фрукта

В этой статье мы рассмотрим стандартные JavaScript массивы с числовыми индексами. Массивы объявляются с помощью квадратных скобок:

var fruits = ["Apple", "Orange", "Donkey"]

Чтобы извлечь элемент, поместите его индекс в квадратные скобки. Первый индекс 0 :

var fruits = ["Apple", "Orange", "Donkey"] alert(fruits) alert(fruits) alert(fruits)

Мы также можем получить длину массива JavaScript :

var fruits = ["Apple", "Orange", "Donkey"] alert(fruits.length)

Упс! Мы создали массив с двумя фруктами и ослом. Теперь нам нужно удалить осла.

Методы pop и push

Метод pop в JavaScript удаляет элемент массива и возвращает его.

В следующем примере показано, как «Осел » извлекается из массива:

var fruits = ["Apple", "Orange", "Donkey"] alert("Я удаляю "+fruits.pop()) // Теперь у нас только ["Apple","Orange"] alert("Теперь размер массива: "+fruits.length) // осел удален

Обратите внимание, что pop изменяет сам массив.

Аналог pop — это метод push , который добавляет элемент в массив. Например, мы забыли добавить персик:

var fruits = ["Apple", "Orange"] fruits.push("Peach"); // теперь у нас есть ["Apple", "Orange", "Peach"] alert("Последний элемент:"+fruits)

  • Создайте массив styles с элементами “Jazz ”, “Blues ”;
  • Добавьте значение «Rock’n’Roll «;
  • Замените второе значение с конца значением «Classic «. У вас должен получиться массив: “Jazz ”, ”Classic ”, ”Rock’n’Roll ”. Код должен работать для любой длины массива;
  • Извлеките последнее значение из массива и выведите его через alert .
    • Решение

    // 1 var styles = ["Jazz", "Bluez"] // 2 styles.push("Rock"n"Roll") // или: styles = "Rock"n"Roll" // 3 styles = "Classic" // 4 alert(styles.pop())

    Методы shift/unshift

    Методы shift/unshift работают с концом массива, но вы также можете использовать shift , чтобы сдвинуть элементы вверх (первое значение массива удаляется со сдвигом элементов ). Метод unshift позволяет в JavaScript добавить элемент в массив с конца:

    var fruits = ["Apple", "Orange"] var apple = fruits.shift() // теперь у нас остался только ["Orange"] fruits.unshift("Lemon") // теперь мы имеем ["Lemon", "Orange"] alert(fruits.length) // 2

    И shift , и unshift могут работать с несколькими элементами одновременно:

    var fruits = ["Apple"] fruits.push("Orange","Peach") fruits.unshift("Pineapple","Lemon") // теперь массив выглядит так: ["Pineapple", "Lemon", "Apple", "Orange", "Peach"]

    Задание для самостоятельного выполнения

    Напишите код, чтобы вывести через alert случайное значение из массива arr :

    var arr = ["Plum","Orange","Donkey","Carrot","JavaScript"]

    Примечание: Код для получения случайного числа от минимального до максимального значения (включительно ) следующий:

    var rand = min + Math.floor(Math.random()*(max+1-min))

    Решение

    Нам нужно извлечь случайное число от 0 до arr.length-1 (включительно ):

    var arr = ["Plum","Orange","Donkey","Carrot","JavaScript"] var rand = Math.floor(Math.random()*arr.length) alert(arr)

    Перебор массива

    В JavaScript перебор массива осуществляется с помощью цикла for :

    var fruits = ["Pineapple", "Lemon", "Apple", "Orange", "Peach"] for(var i=0; i=0 проверить быстрее, чем i . Что в JavaScript ускоряет поиск в массиве.

    Использование length для обрезки массива

    С помощью свойства length можно обрезать массив следующим образом:

    Вы задаете длину, и браузер обрезает массив.

    Array представляет собой объект, что из этого следует

    На самом деле в JavaScript Array — это Object , дополненный автоматической установкой длины и специальными методами.

    Это отличается от концепции в других языках, где массивы представляют собой непрерывный сегмент памяти. Это также отличается от очереди или стека на основе связанных списков.

    Нечисловые ключи массива

    Ключи — это числа, но они могут иметь любые имена:

    arr = arr = 5 arr.prop = 10 // не делайте так

    В JavaScript массивы представляют собой хэш-таблицы с их преимуществами в плане производительности, но и с определенными недостатками.

    Например, push/pop работают только с крайними элементами массива, поэтому они невероятно быстры.

    push работает только с концом:

    var arr = ["My", "array"] arr.push("something") alert(arr) // строка "array"

    Методы shift/unshift медленные, потому что им нужно изменить нумерацию всего массива. Метод splice также может привести к изменению нумерации:

    Таким образом, shift/unshift работают медленнее, чем push/pop . Чем больше массив, тем больше времени занимает в JavaScript сортировка массива.

    Задание для самостоятельного выполнения

    Какой получится результат? Почему?

    arr = ["a", "b"] arr.push(function() { alert(this) }) arr() // ?

    Решение

    Поскольку массивы являются объектами, arr.. фактически является вызовом метода объекта, таким как objmethod:

    arr() // то же самое что arr() // синтаксически это неправильно, но концептуально то же самое: arr.2() // переписанное в том же стиле, что и obj.method() this = arr в таком случае передается функции, поэтому выводится содержимое arr. arr = ["a", "b"] arr.push(function() { alert(this) }) arr() // "a","b",функция

    Разреженные массивы, описание length

    Свойство length позволяет получить не размер массива в JavaScript , а последний индекс + 1 . Это важно, если речь идет о разреженных массивах, с «промежутками » в индексах.

    В следующем примере мы добавим два элемента в пустые fruits , но значение length останется 100 :

    var fruits = // пустой массив fruits = "Peach" fruits = "Apple" alert(fruits.length) // 100 (но элементов в массиве всего 2)

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

    var fruits = // пустой массив fruits = "Peach" fruits = "Apple" alert(fruits) // ,Peach,Apple (или что-то вроде этого)

    Но массив — это объект с двумя ключами. Недостающие значения не занимают места.

    Разреженные массивы ведут себя причудливо, когда к ним применяются методы массива. Они понятия не имеют о том, что индексы пропущены:

    var fruits = fruits = "Peach" fruits = "Apple" alert(fruits.pop()) // выталкиваем "Apple" (на индекс 9) alert(fruits.pop()) // выталкиваем не заданный элемент (на индекс 8)

    Старайтесь избегать разреженных массивов. Во всяком случае, их методы не будут работать нормально. Вместо этого используйте Object .

    Удаление из массива

    Как мы знаем, массивы — это объекты, поэтому мы могли бы использовать delete , чтобы удалить значение:

    var arr = ["Go", "to", "home"] delete arr // теперь arr = ["Go", undefined, "home"] alert(arr) // не задано

    Вы видите, что значение удаляется, но не так, как мы хотели бы, потому что массив содержит незаданный элемент.

    Оператор delete удаляет пару ключ-значение, и это все. Естественно, так как массив — это только хэш, позиция удаленного элемента становится undefined .

    Чаще всего нам нужно удалить элемент, не оставляя «дыр » между индексами. Существует еще один метод, который поможет нам в этом.

    Метод splice

    Метод splice может удалять элементы и заменять их в JavaScript многомерных массивах. Его синтаксис:

    arr.splice(index, deleteCount[, elem1, ..., elemN])

    Удаляет элемент deleteCount , начиная с index , а затем вставляет на его место elem1, …, elemN .

    Давайте рассмотрим несколько примеров:

    var arr = ["Go", "to", "home"] arr.splice(1, 1) // удалить 1 элемент, начиная с индекса 1 alert(arr.join(",")) // ["Go", "home"] (1 элемент удален)

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

    var arr = ["Go", "to", "home"] arr.splice(0, 1) // удаляем 1 элемент, начиная с индекса 0 alert(arr) // "to" стал первым элементом

    В следующем примере показано, как заменять элементы:

    Метод splice возвращает массив удаленных элементов:

    var arr = ["Go", "to", "home", "now"]; // удаляем 2 первых элемента var removed = arr.splice(0, 2) alert(removed) // "Go", "to" =0; i--) { if (c[i] == cls) c.splice(i,1) } elem.className = c.join(" ") } var obj = { className: "open menu" } removeClass(obj, "open") removeClass(obj, "blabla") alert(obj.className) // menu

    В приведенном выше примере переменная c задана в начале цикла, и для i задан ее последний индекс.

    Сам цикл выполняется в обратном направлении, заканчиваясь условием i>=0 . Это сделано потому, что i>=0 проверяется быстрее, чем i . Что ускоряет поиск свойства в c .

    Метод slice

    Можно извлечь часть массива с помощью метода slice(begin[, end]): var arr = ["Why", "learn", "JavaScript"]; var arr2 = arr.slice(0,2) // принимает 2 элемента, начиная с 0 alert(arr2.join(", ")) // "Why, learn"

    Обратите внимание, что этот метод не изменяет в JavaScript количество элементов в массиве, а копирует его часть.

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

    var arr = ["Why", "learn", "JavaScript"]; var arr2 = arr.slice(1) // принимает все элементы, начиная с 1 alert(arr2.join(", ")) // "learn, JavaScript"

    Метод поддерживает отрицательные индексы, так же, как String#slice .

    Метод reverse

    Еще один полезный метод — reverse . Предположим, я хочу получить последнюю часть домена, например, “com ” от “my.site.com ”. Вот как это можно сделать:

    var domain = "my.site.com" var last = domain.split(".").reverse() alert(last)

    Обратите внимание, что JavaScript массивы поддерживают сложный синтаксис (reverse()) для вызова метода, а затем извлечения элемента из полученного массива.

    Вы можете создавать более длинные вызовы, например, reverse()0] arr.sort() alert(arr) // 1, 15, 2

    Запустите приведенный выше код. Вы получите порядок 1 , 15 , 2 . Это потому, что метод преобразует все в строку и использует по умолчанию лексикографический порядок.