Особенности свойства length массивов

Searching in array

Now let’s cover methods that search in an array.

The methods arr.indexOf, arr.lastIndexOf and arr.includes have the same syntax and do essentially the same as their string counterparts, but operate on items instead of characters:

• – looks for starting from index , and returns the index where it was found, otherwise .
• – same, but looks for from right to left.
• – looks for starting from index , returns if found.

For instance:

Note that the methods use comparison. So, if we look for , it finds exactly and not the zero.

If we want to check for inclusion, and don’t want to know the exact index, then is preferred.

Also, a very minor difference of is that it correctly handles , unlike :

Imagine we have an array of objects. How do we find an object with the specific condition?

Here the arr.find(fn) method comes in handy.

The syntax is:

The function is called for elements of the array, one after another:

• is the element.
• is its index.
• is the array itself.

If it returns , the search is stopped, the is returned. If nothing found, is returned.

For example, we have an array of users, each with the fields and . Let’s find the one with :

In real life arrays of objects is a common thing, so the method is very useful.

Note that in the example we provide to the function with one argument. That’s typical, other arguments of this function are rarely used.

The arr.findIndex method is essentially the same, but it returns the index where the element was found instead of the element itself and is returned when nothing is found.

The method looks for a single (first) element that makes the function return .

If there may be many, we can use arr.filter(fn).

The syntax is similar to , but returns an array of all matching elements:

For instance:

slice()

Метод  копирует заданную часть массива и возвращает её в виде совершенно нового массива. Этот метод вообще не трогает оригинальный массив:

From: с индекса какого элемента начинается нарезка массива

Until: до какого элемента массива нарезается массив

Для примера, нам нужно нарезать первые три элемента из вышеуказанного массива. Так как первый элемент в массиве всегда имеет индекс 0, то начнём мы нарезку именно с него.

А теперь хитрый момент. Когда мне надо нарезать первые три элемента, мне надо задать параметр . Почему? Потому что  не затрагивает последний заданный элемент.

Это может создать некое недопонимание. Именно по этому я назвал второй параметр  (до).

И наконец, я назначаю нарезанный массив на переменную . Давайте посмотрим, что получается:

Важное замечание: метод  также можно использовать и на строках

Взаимосвязь свойства length с числовыми свойствами массивов

Некоторые встроенные методы массива (например, join, slice, indexOf и т.д.) учитывают значение свойства length при своём вызове. Другие методы (например, push, splice и т.д.) в результате своей работы обновляют свойство length массива.

При установке свойства в массиве, если свойство имеет действительный индекс и этот индекс выходит за пределы текущих границ массива, движок соответствующим образом обновит свойство length:

JavaScript

const numArray = ;
let value = numArray.length;
console.log(value, numArray); // 5 Array(5)

numArray.length = 0;
console.log(numArray); // [] — получили пустой массив

numArray.length = 100;
console.log(numArray); // (100)  — получили массив из 100 элементов, так как перезаписали свойство массива length

1 2 3 4 5 6 7 8 9

constnumArray=12,45,67,456,34; let value=numArray.length; console.log(value,numArray);// 5 Array(5) numArray.length=; console.log(numArray);// [] — получили пустой массив numArray.length=100; console.log(numArray);// (100)  — получили массив из 100 элементов, так как перезаписали свойство массива length

Уменьшение свойства length приводит к удалению элементов массива:

JavaScript

var arr = ;

console.log(arr.length); // 3
console.log(arr); // Array(3)

arr.length= 1;
console.log(arr); // Array

1 2 3 4 5 6 7

vararr=»Alex»,»Mary»,»Serg»; console.log(arr.length);// 3 console.log(arr);// Array(3) arr.length=1; console.log(arr);// Array

split()

Методы  и  для массивов. А вот метод  используется для строк. Он делит строку на подстроки и отдаёт их в виде массива. Ему нужны 2 параметра и оба они опциональны.

Separator: определяет как разделять строку. Запятой, символом или тп.

Limits: ограничивает количество разделений, опираясь на заданное число.

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

Давайте посмотрим как это работает.

Сначала мы конвертируем наш массив в строку при помощи метода :

Теперь давайте разделим  по запятым, ограничив его до 3 подстрок и возвратим его, как массив:

Как мы видим,  разделен запятыми. А так как мы ограничиваем разбитие строки до 3-х элементов в массиве, то только первые 3 из них будут возвращены.

Обратите внимание, что если бы мы использовали , то каждый символ в строке был бы разделен на подстроки:

Add/remove items

We already know methods that add and remove items from the beginning or the end:

• – adds items to the end,
• – extracts an item from the end,
• – extracts an item from the beginning,
• – adds items to the beginning.

Here are a few others.

How to delete an element from the array?

The arrays are objects, so we can try to use :

The element was removed, but the array still has 3 elements, we can see that .

That’s natural, because removes a value by the . It’s all it does. Fine for objects. But for arrays we usually want the rest of elements to shift and occupy the freed place. We expect to have a shorter array now.

So, special methods should be used.

The arr.splice method is a swiss army knife for arrays. It can do everything: insert, remove and replace elements.

The syntax is:

It modifies starting from the index : removes elements and then inserts at their place. Returns the array of removed elements.

This method is easy to grasp by examples.

Let’s start with the deletion:

Easy, right? Starting from the index it removed element.

In the next example we remove 3 elements and replace them with the other two:

Here we can see that returns the array of removed elements:

The method is also able to insert the elements without any removals. For that we need to set to :

Negative indexes allowed

Here and in other array methods, negative indexes are allowed. They specify the position from the end of the array, like here:

The method arr.slice is much simpler than similar-looking .

The syntax is:

It returns a new array copying to it all items from index to (not including ). Both and can be negative, in that case position from array end is assumed.

It’s similar to a string method , but instead of substrings it makes subarrays.

For instance:

We can also call it without arguments: creates a copy of . That’s often used to obtain a copy for further transformations that should not affect the original array.

The method arr.concat creates a new array that includes values from other arrays and additional items.

The syntax is:

It accepts any number of arguments – either arrays or values.

The result is a new array containing items from , then , etc.

If an argument is an array, then all its elements are copied. Otherwise, the argument itself is copied.

For instance:

Normally, it only copies elements from arrays. Other objects, even if they look like arrays, are added as a whole:

…But if an array-like object has a special property, then it’s treated as an array by : its elements are added instead:

Массивы в JavaScript

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

Чтобы работать с такими массивами, нам понадобятся JavaScript-методы: например, slice () & splice (). Создать массив можно так:

let arrayDefinition = [];   // Array declaration in JS

Теперь создадим другой массив с данными разного типа:

let array = ;

В JavaScript можно создавать массивы с разными типами данных: с числами, строками и логическими значениями.

splice()

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

Удаление элементов

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

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

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

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

После 1-го вызова:

После 2-го вызова:

В общем, это будет продолжаться пока вообще не останется элементов под индексом 2.

Добавление элементов

Для добавления элементов нам нужно указать 3, 4 и 5й параметры (в зависимости от того, сколько мы хотим добавить) методу :

Как пример, я добавляю  и  в самое начала массива, при этом ничего не удаляя:

Slice ( )

Метод slice () копирует заданную часть массива и возвращает эту скопированную часть в виде нового массива. Исходный массив при этом не изменяется.

array.slice(from, until);

• From: Нарезает массив начиная с этого элемента
• Until: Нарезает массив до этого элемента

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

array.slice(0, until);

Дальше начинается часть посложнее. Я хочу нарезать первые три элемента, поэтому в качестве параметра until я указываю 3. Метод slice () не включает последний заданный элемент.

array --> 1              // included
array --> 2              // included
array --> 3              // included
array --> "hello world"  // not included

Здесь можно запутаться! Вот почему я объявил “until” .

let newArray = array.slice(0, 3);   // Return value is also an array

Наконец я создаю новый массив и связываю его с переменной newArray. Посмотрим результат:

Нарезка массива и добавление элементов в новый массив 

Переменная newArray становится новым массивом, оригинальный массив остается без изменений.

Синтаксис

Необязательный

Индекс (счёт начинается с нуля), по которому начинать извлечение.

Если индекс отрицательный, указывает смещение от конца последовательности. Вызов извлечёт два последних элемента последовательности.

Если  не определён, начинает работать с индекса .

Если  больше длины последовательности вернётся пустой массив.

Необязательный

Индекс (счёт начинается с нуля), по которому заканчивать извлечение. Метод извлекает элементы с индексом меньше .

Вызов извлечёт элементы со второго по четвёртый (элементы по индексам 1, 2 и 3).

Если индекс отрицательный, указывает смещение от конца последовательности. Вызов извлечёт из последовательности элементы начиная с третьего элемента с начала и заканчивая вторым с конца.

Если опущен, извлекает все элементы до конца последовательности ().

Новый массив, содержащий извлечённые элементы.

Добавление элемента в конец массива (метод push() )

Метод push():

• присоединяет элементы к концу массива, используядля определения места вставки свойство length;
• возвращает новое значение свойства length объекта, для которого был вызван данный метод. 

Особенности метода push():

1. Если свойство length не может быть преобразовано в число, будет использован индекс 0. Если свойство length не существует, то в этом случае оно будет создано.
2. К строкам (как массивоподобным объектам) метод push() применён быть не может, так как строки являются неизменяемыми.

JavaScript

const numArray = ;
let value;

value = numArray.push(100); // добавление элемента в конец массива, переменная value принимает новое значение свойства length
console.log(value, numArray); // 6 Array(6)

1 2 3 4 5

constnumArray=12,45,67,456,34; let value; value=numArray.push(100);// добавление элемента в конец массива, переменная value принимает новое значение свойства length console.log(value,numArray);// 6 Array(6)

Примеры

Summary

A cheat sheet of array methods:

• To add/remove elements:

  • – adds items to the end,
  • – extracts an item from the end,
  • – extracts an item from the beginning,
  • – adds items to the beginning.
  • – at index deletes elements and inserts .
  • – creates a new array, copies elements from index till (not inclusive) into it.
  • – returns a new array: copies all members of the current one and adds to it. If any of is an array, then its elements are taken.

• To search among elements:

  • – look for starting from position , return the index or if not found.
  • – returns if the array has , otherwise .
  • – filter elements through the function, return first/all values that make it return .
  • is like , but returns the index instead of a value.

• To iterate over elements:

  forEach(func) – calls func for every element, does not return anything.

• To transform the array:

  • – creates a new array from results of calling for every element.
  • – sorts the array in-place, then returns it.
  • – reverses the array in-place, then returns it.
  • – convert a string to array and back.
  • – calculate a single value over the array by calling for each element and passing an intermediate result between the calls.

• Additionally:

  Array.isArray(arr) checks arr for being an array.

Please note that methods , and modify the array itself.

These methods are the most used ones, they cover 99% of use cases. But there are few others:

• arr.some(fn)/arr.every(fn) check the array.

  The function is called on each element of the array similar to . If any/all results are , returns , otherwise .

  These methods behave sort of like and operators: if returns a truthy value, immediately returns and stops iterating over the rest of items; if returns a falsy value, immediately returns and stops iterating over the rest of items as well.

  We can use to compare arrays:

• arr.fill(value, start, end) – fills the array with repeating from index to .

• arr.copyWithin(target, start, end) – copies its elements from position till position into itself, at position (overwrites existing).

• arr.flat(depth)/arr.flatMap(fn) create a new flat array from a multidimensional array.

For the full list, see the manual.

From the first sight it may seem that there are so many methods, quite difficult to remember. But actually that’s much easier.

Look through the cheat sheet just to be aware of them. Then solve the tasks of this chapter to practice, so that you have experience with array methods.

Afterwards whenever you need to do something with an array, and you don’t know how – come here, look at the cheat sheet and find the right method. Examples will help you to write it correctly. Soon you’ll automatically remember the methods, without specific efforts from your side.

Удаление элементов

Чтобы удалить элементы, введите элемент, с которого нужно начать (index) и количество элементов, которые нужно удалить (number of elements):

array.splice(index, number of elements);

Параметр Index — это начальная точка удаления элементов. Элементы с порядковым номером меньше заданного параметра Index не будут удалены:

array.splice(2);  // Every element starting from index 2, will be removed

Если не указать второй параметр, все элементы от заданного параметра Index и до конца будут удалены:

only index 0 and 1 are still there

В качестве еще одно примера, я указал 1 в качестве второго параметра: таким образом, каждый раз при повторе метода splice ( ) будет удалять по одному элементу, начиная со второго:

array.splice(2, 1);

Массив до метода splice ( )

Splice ( ) применен один раз:

Элемент 3 удален: следовательно, теперь элемент “hello world” имеет порядковый номер 2

Splice ( ) применен два раза:

На этот раз, был удален элемент “hello world”, потому что его порядковый номер 2

Так можно продолжать до тех пор, пока не останется элементов с порядковым номером 2.

Добавление элемента в начало массива (метод unshift() )

Метод unshift():

• добавляет элементы в начало массива;
• возвращает новое значение свойства length объекта, для которого был вызван данный метод. 

const numberArray = ;
let value;

value = numberArray.unshift(200,100); // добавление элементов в начало массива, переменная value принимает новое значение свойства length
console.log(value, numberArray); // 7 Array (7)

// Ещё пример

const numArray = ;
numArray.unshift(); // добавление элементов в начало массива
console.log(numArray); // Array (2) , 10]

1 2 3 4 5 6 7 8 9 10 11

constnumberArray=12,45,67,456,34; let value; value=numberArray.unshift(200,100);// добавление элементов в начало массива, переменная value принимает новое значение свойства length console.log(value,numberArray);// 7 Array (7)   // Ещё пример   constnumArray=10; numArray.unshift(-200);// добавление элементов в начало массива console.log(numArray);// Array (2) , 10]

Конспект:

Slice ( )

• Копирует элементы из массива
• Возвращает их в новый массив
• Не меняет оригинальный массив
• Нарезает массив с помощью параметров from и until: array.slice (from, until)
• Не включает параметр, заданный в “until”
• Используется и в массивах, и в строках

Splice ( )

• Добавляет и удаляет элементы из массива
• Возвращает массив удаленных элементов
• Меняет массив
• Добавление элементов: array.splice (index, number of elements, element)
• Удаление элементов: array.splice (index, number of elements)
• Используется только в массивах

Split ( )

• Делит строки на подстроки
• Возвращает их в виде массива
• 2 параметра, и оба из них не обязательно указывать: string.split(separator, limit)
• Не меняет оригинальную строку
• Используется только в строках

В JavaScript есть еще много других встроенных методов работы с массивами и строками. Если вы научитесь их использовать, программировать станет намного проще.

Перевод статьи Cem Eygi: Let’s clear up the confusion around the slice( ), splice( ), & split( ) methods in JavaScript

Window

Window Object
alert()
atob()
blur()
btoa()
clearInterval()
clearTimeout()
close()
closed
confirm()
console
defaultStatus
document
focus()
frameElement
frames
history
getComputedStyle()
innerHeight
innerWidth
length
localStorage
location
matchMedia()
moveBy()
moveTo()
name
navigator
open()
opener
outerHeight
outerWidth
pageXOffset
pageYOffset
parent
print()
prompt()
resizeBy()
resizeTo()
screen
screenLeft
screenTop
screenX
screenY
scrollBy()
scrollTo()
scrollX
scrollY
sessionStorage
self
setInterval()
setTimeout()
status
stop()
top

Window History
back()
forward()
go()
length

Window Location
hash
host
hostname
href
origin
pathname
port
protocol
search
assign()
reload()
replace()

Window Navigator
appCodeName
appName
appVersion
cookieEnabled
geolocation
language
onLine
platform
product
userAgent
javaEnabled()
taintEnabled()

Window Screen
availHeight
availWidth
colorDepth
height
pixelDepth
width

Most methods support “thisArg”

Almost all array methods that call functions – like , , , with a notable exception of , accept an optional additional parameter .

That parameter is not explained in the sections above, because it’s rarely used. But for completeness we have to cover it.

Here’s the full syntax of these methods:

The value of parameter becomes for .

For example, here we use a method of object as a filter, and passes the context:

If in the example above we used , then would be called as a standalone function, with , thus leading to an instant error.

A call to can be replaced with , that does the same. The latter is used more often, as it’s a bit easier to understand for most people.

JavaScript

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()
clz32()
cos()
cosh()
E
exp()
expm1()
floor()
fround()
LN2
LN10
log()
log10()
log1p()
log2()
LOG2E
LOG10E
max()
min()
PI
pow()
random()
round()
sign()
sin()
sinh()
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
Modifiers:
g
i
m
Groups:

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

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()

Удаление элемента из начала массива (метод shift() )

Метод shift():

•  удаляет первый элемент из массива (изменяет длину массива, последовательно сдвигая значения индексов по направлению к нулю);
• возвращает значение удаленного из массива элемента (или undefined, если массив пуст).

const numberArray = ;
let value;

value = numberArray.shift(); // удаление элемента из начала массива, в value записывается значение удаленного элемента
console.log(value, numberArray); // 200 Array(6)
console.log(numberArray); // 12 (индексы сдвинуты к началу)

1 2 3 4 5 6

constnumberArray=200,12,45,67,456,34,100; let value; value=numberArray.shift();// удаление элемента из начала массива, в value записывается значение удаленного элемента console.log(value,numberArray);// 200 Array(6) console.log(numberArray);// 12 (индексы сдвинуты к началу)

Обрезка массива ( метод slice() )

Метод slice() возвращает новый массив, содержащий копию части исходного массива.

JavaScript

arr.slice(])

1	arr.slice(begin,end)

Параметры метода slice ():

• begin (необязательный) — индекс, с которого начинается извлечение (отсчёт начинается с 0):
  1. если индекс отрицательный, begin указывает смещение от конца последовательности (т.е. вызов slice(-2) извлечёт два последних элемента последовательности);
  2. если begin не определен, slice() начинает работать с индекса 0;
  3. если begin больше длины последовательности — вернется пустой массив.
• end (необязательный) — индекс (счёт начинается с нуля), по которому заканчивать извлечение. Метод slice() извлекает элементы с индексом меньше end (т.е. вызов slice(1, 4) извлечёт элементы со второго по четвёртый (элементы по индексам 1, 2 и 3):
  1. если индекс отрицательный, end указывает смещение от конца последовательности (т.е. вызов slice(2, -1) извлечёт из последовательности элементы начиная с третьего элемента с начала и заканчивая вторым с конца);
  2. если end опущен, slice() извлекает все элементы до конца последовательности (т.е. до arr.length).

Возвращаемое значение:

новый массив, содержащий извлеченные элементы.

Элементы исходного массива копируются в новый массив по следующим правилам:

JavaScript

var fruits = ;
var citrus = fruits.slice(1, 3); // citrus содержит

const numArray = ;
let value;
value = numArray.slice(0, 3); // обрезка массива (вернет с 0 по 3-й элемент)
console.log(value, numArray); // Array(3) Array(5)

1 2 3 4 5 6 7

varfruits=’Банан’,’Апельсин’,’Лимон’,’Яблоко’,’Манго’; varcitrus=fruits.slice(1,3);// citrus содержит constnumArray=12,45,67,456,34; let value; value=numArray.slice(,3);// обрезка массива (вернет с 0 по 3-й элемент) console.log(value,numArray);// Array(3) Array(5)

Добавление и удаление элементов массива с определённым индексом ( Array.splice() )

JavaScript

var arr = ;
var val = arr.splice(0, 2);
console.log(val); // Array , т.е. вырезано 2 элемента. начиная с 0-го
console.log(arr); // Array — оставшиеся элементы массива

// ИЛИ

const numArray = ;
let value;

value = numArray.splice(0, 2, «one», «two»); // удаление 2-х элементов массива (с 0-го, 2 элемента добавляем)
console.log(value, numArray); // Array Array(5)

value = numArray.splice(1, 0, «AAA», «BBB»); // добавление элементов массива (с 1, добавляем 2 элемента)
console.log(value, numArray); // Array [] Array(7)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

vararr=»Alex»,»Mary»,»Serg»; varval=arr.splice(,2); console.log(val);// Array , т.е. вырезано 2 элемента. начиная с 0-го console.log(arr);// Array — оставшиеся элементы массива   // ИЛИ   constnumArray=12,45,67,456,34; let value; value=numArray.splice(,2,»one»,»two»);// удаление 2-х элементов массива (с 0-го, 2 элемента добавляем) console.log(value,numArray);// Array Array(5) value=numArray.splice(1,,»AAA»,»BBB»);// добавление элементов массива (с 1,  добавляем 2 элемента) console.log(value,numArray);// Array [] Array(7)

Совершенствование кросс-браузерного поведения

Хотя спецификация не требует от хост-объектов (например, объектов DOM) следовать поведению Mozilla при преобразовании с помощью и IE < 9 так не делает, версии IE, начиная с 9-й это умеют. «Прокладывание» позволяет добиться надёжного кросс-браузерного поведения. Пока другие современные браузеры будут поддерживать эту способность, что и делают в настоящее время IE, Mozilla, Chrome, Safari и Opera, разработчики, читая (поддерживающий DOM) код функции , опирающийся на эту прокладку, не будут вводиться в заблуждение его семантикой; они могут смело полагаться на текущую семантику, являющуюся, видимо, де-факто стандартным поведением. (Прокладка также исправляет поведение IE, позволяя работать со вторым аргументом , явно определённым как /, поскольку более ранние версии IE такое не позволяют, но все современные браузеры, в том числе IE >= 9, поддерживают данное поведение.)

Подводим итоги

Slice()

• Копирует элементы из массива
• Отдаёт их как новый массив
• Не трогает изначальный массив
• Начинает нарезку с … до заданного индекса: 
• Последний параметр не нарезается методом 
• Может использоваться как и для массивов, так и для строк

Splice()

• Используется для добавления/удаления элементов из массива
• Отдаёт массив удаленных элементов
• Изменяет массив
• Для добавления элементов используйте: 
• Для удаления элементов: 
• Может использоваться только для массивов

Split()

• Разделяет строку на подстроки
• Отдаёт их в массив
• Берёт 2 параметра, оба опциональны: 
• Не изменяет изначальную строку
• Может использоваться только для строк

Конечно же есть и другие встроенные JavaScript методы для работы с массивами и строками. Если вы поймете как их использовать, то они значительно упростят ваш процесс разработки.