Какое свойство функции возвращает массив аргументов

Array

Объект Array , как и массивы в других языках программирования, позволяет хранить коллекцию из нескольких элементов под одним именем переменной и имеет методы для выполнения общих операций с массивами.

Описание

Массивы являются спископодобными объектами, чьи прототипы содержат методы для операций обхода и изменения массива. Ни размер JavaScript-массива, ни типы его элементов не являются фиксированными. Поскольку размер массива может увеличиваться и уменьшаться в любое время, то нет гарантии, что массив окажется плотным. То есть, при работе с массивом может возникнуть ситуация, что элемент массива, к которому вы обратитесь, будет пустым и вернёт undefined . В целом, это удобная характеристика; но если эта особенность массива не желательна в вашем специфическом случае, вы можете рассмотреть возможность использования типизированных массивов.

Некоторые полагают, что вы не должны использовать массив в качестве ассоциативного массива. В любом случае, вместо него вы можете использовать простые объекты , хотя у них есть и свои подводные камни. Смотрите пост Легковесные JavaScript-словари с произвольными ключами(англ.) в качестве примера.

Доступ к элементам массива

Массивы в JavaScript индексируются с нуля: первый элемент массива имеет индекс, равный 0 , а индекс последнего элемента равен значению свойства массива length минус 1.

const arr = ["первый элемент", "второй элемент", "последний элемент"]; console.log(arr[0]); // напечатает 'первый элемент' console.log(arr[1]); // напечатает 'второй элемент' console.log(arr[arr.length - 1]); // напечатает 'последний элемент' 

Элементы массива являются свойствами, точно такими же, как, например, свойство toString , однако попытка получить элемент массива по имени его свойства приведёт к синтаксической ошибке, поскольку имя свойства не является допустимым именем JavaScript:

.log(arr.0); // синтаксическая ошибка 

Это не особенность массивов или их свойств. В JavaScript к свойствам, начинающимся с цифры, невозможно обратиться посредством точечной нотации; к ним можно обратиться только с помощью скобочной нотации. Например, если у вас есть объект со свойством, названным ‘3d’ , вы сможете обратиться к нему только посредством скобочной нотации. Примеры:

const years = [1950, 1960, 1970, 1980, 1990, 2000, 2010]; console.log(years.0); // синтаксическая ошибка console.log(years[0]); // работает как положено 

.3d.setTexture(model, 'character.png'); // синтаксическая ошибка renderer['3d'].setTexture(model, 'character.png'); // работает как положено 

Обратите внимание, что во втором примере 3d заключено в кавычки: ‘3d’ . Индексы можно заключать в кавычки (например years[‘2’] вместо years[2] ), но в этом нет необходимости. Значение 2 в выражении years[2] будет неявно приведено к строке движком JavaScript через метод преобразования toString . Именно по этой причине ключи ‘2’ и ’02’ будут ссылаться на два разных элемента в объекте years и следующий пример выведет true :

.log(years["2"] != years["02"]); 

Аналогично, к свойствам объекта, являющимся зарезервированными словами(!) можно получить доступ только посредством скобочной нотации:

const promise =  var: "text", array: [1, 2, 3, 4], >; console.log(promise["array"]); 

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

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

const fruits = []; fruits.push("банан", "яблоко", "персик"); console.log(fruits.length); // 3 

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

[5] = "манго"; console.log(fruits[5]); // 'манго' console.log(Object.keys(fruits)); // ['0', '1', '2', '5'] console.log(fruits.length); // 6 

Увеличиваем свойство length

.length = 10; console.log(Object.keys(fruits)); // ['0', '1', '2', '5'] console.log(fruits.length); // 10 

Однако, уменьшение свойства length приведёт к удалению элементов.

.length = 2; console.log(Object.keys(fruits)); // ['0', '1'] console.log(fruits.length); // 2 

Более подробно эта тема освещена на странице, посвящённой свойству Array.length .

Создание массива с использованием результата сопоставления

Результатом сопоставления регулярного выражения строке является JavaScript-массив. Этот массив имеет свойства и элементы, предоставляющие информацию о сопоставлении. Подобные массивы возвращаются методами RegExp.exec , String.match и String.replace . Чтобы было проще понять, откуда и какие появились свойства и элементы, посмотрите следующий пример и обратитесь к таблице ниже:

// Сопоставляется с одним символом d, за которым следует один // или более символов b, за которыми следует один символ d // Запоминаются сопоставившиеся символы b и следующий за ними символ d // Регистр игнорируется const myRe = /d(b+)(d)/i; const myArray = myRe.exec("cdbBdbsbz"); 

Свойства и элементы, возвращаемые из данного сопоставления, описаны ниже:

Свойство/Элемент	Описание	Пример
input	Свойство только для чтения, отражающее оригинальную строку, с которой сопоставлялось регулярное выражение.	cdbBdbsbz
index	Свойство только для чтения, являющееся индексом (отсчёт начинается с нуля) в строке, с которого началось сопоставление.	1
[0]	Элемент только для чтения, определяющий последние сопоставившиеся символы.	dbBd
[1], . [n]	Элементы только для чтения, определяющие сопоставившиеся подстроки, заключённые в круглые скобки, если те включены в регулярное выражение. Количество возможных подстрок не ограничено.	[1]: bB [2]: d

Конструктор

Создаёт новый объект Array .

Статические свойства

Возвращает конструктор Array .

Статические методы

Создаёт новый экземпляр Array из итерируемого или массивоподобного объекта.

Создаёт новый экземпляр Array из асинхронно итерируемого, итерируемого или массивоподобного объекта.

Возвращает true если аргумент является массивом и false в противном случае.

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

Свойства экземпляра

Эти свойства определены в Array.prototype и есть у всех экземпляров Array .

Функция-конструктор, создающая экземпляр объекта. Для экземпляров Array начальным значением является конструктор Array (en-US).

Содержит имена свойств, которые не включены в стандарт ECMAScript до версии ES2015 и которые игнорируются оператором with .

Собственные свойства каждого экземпляра Array :

Отражает количество элементов в массиве.

Методы экземпляра

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

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

Копирует последовательность элементов внутри массива.

Возвращает новый объект array iterator, который содержит пары ключ/значение для каждого индекса в массиве.

Возвращает true если для каждого элемента массива переданная в качестве аргумента функция возвращает true .

Заполняет все элементы массива от начального индекса до последнего указанным значением.

Возвращает новый массив, содержащий все элементы исходного массива, для которых переданная функция вернула true .

Возвращает значение первого элемента массива, для которого переданная в качестве аргумента функция возвращает true , или undefined если таких элементов нет.

Возвращает индекс первого элемента массива, для которого переданная в качестве аргумента функция возвращает true , или -1 если таких элементов нет.

Возвращает значение последнего элемента массива, для которого переданная в качестве аргумента функция возвращает true , или undefined если таких элементов нет.

Возвращает индекс последнего элемента массива, для которого переданная в качестве аргумента функция возвращает true , или -1 если таких элементов нет.

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

Возвращает новый массив, сформированный вызовом переданной функции с каждым элементом, а затем «уплощённый» на один уровень.

Вызывает функцию для каждого элемента массива.

Возвращает true , если массив содержит переданное значение и false в противном случае.

Возвращает первый (наименьший) индекс, по которому может быть найден переданный элемент.

Объединяет все элементы массива в строку.

Возвращает новый объект array iterator, который содержит ключи каждого индекса массива.

Возвращает последний (наибольший) индекс, по которому может быть найден переданный элемент или -1 если таких элементов нет.

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

Удаляет последний элемент массива и возвращает его значение.

Добавляет один или более элементов в конец массива и возвращает новое значение length массива.

Вызывает указанную функцию-редьюсер для каждого элемента массива (слева направо) для получения единственного значения.

Вызывает указанную функцию-редьюсер для каждого элемента массива (справа налево) для получения единственного значения.

Изменяет порядок элементов массива на месте (то есть изменяя исходный массив) на обратный (первый станет последним, последний — первым).

Удаляет первый элемент массива и возвращает его значение.

Извлекает часть массива и возвращает её в виде нового массива.

Возвращает true если хотя бы для одного элемента массива переданная в качестве аргумента функция возвращает true .

Сортирует элементы массива на месте (то есть изменяя исходный массив) и возвращает массив.

Добавляет и/или удаляет элементы массива.

Возвращает локализованную строку, представляющую исходный массив и его элементы. Переопределяет метод Object.prototype.toLocaleString() .

Возвращает новый массив с элементами в обратном порядке без изменения исходного массива.

Возвращает новый массив с отсортированными по возрастанию элементами без изменения исходного массива.

Возвращает новый массив с удалёнными и/или заменёнными элементами без изменения исходного массива.

Возвращает строку, представляющую исходный массив и его элементы. Переопределяет метод Object.prototype.toString() .

Добавляет один или более элементов в начало массива и возвращает новое значение length массива.

Возвращает новый объект array iterator, который содержит значения каждого индекса массива.

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

Примеры

Пример: создание массива

Следующий пример создаёт массив msgArray с длиной 0, присваивает значения элементам msgArray[0] и msgArray[99] , что изменяет длину массива на 100.

const msgArray = []; msgArray[0] = "Привет"; msgArray[99] = "мир"; if (msgArray.length === 100)  console.log("Длина равна 100."); > 

Создание массива

const fruits = ["Яблоко", "Банан"]; console.log(fruits.length); // 2 

Доступ к элементу массива по индексу

const first = fruits[0]; // Яблоко const last = fruits[fruits.length - 1]; // Банан 

Итерирование по массиву

.forEach(function (item, index, array)  console.log(item, index); >); // Яблоко 0 // Банан 1 

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

const newLength = fruits.push("Апельсин"); // ["Яблоко", "Банан", "Апельсин"] 

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

const last = fruits.pop(); // удалим Апельсин (из конца) // ["Яблоко", "Банан"]; 

Удаление первого элемента массива

const first = fruits.shift(); // удалим Яблоко (из начала) // ["Банан"]; 

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

const newLength = fruits.unshift("Клубника"); // добавляет в начало // ["Клубника", "Банан"]; 

Поиск номера элемента в массиве

.push("Манго"); // ["Клубника", "Банан", "Манго"] const pos = fruits.indexOf("Банан"); // 1 

Удаление элемента с определённым индексом

const removedItem = fruits.splice(pos, 1); // так можно удалить элемент // ["Клубника", "Манго"] 

Удаление нескольких элементов, начиная с определённого индекса

const vegetables = ["Капуста", "Репа", "Редиска", "Морковка"]; console.log(vegetables); // ["Капуста", "Репа", "Редиска", "Морковка"] const start = 1; const deleteCount = 2; const removedItems = vegetables.splice(start, deleteCount); // так можно удалить элементы, deleteCount определяет количество элементов для удаления, // начиная с позиции(pos) и далее в направлении конца массива. console.log(vegetables); // ["Капуста", "Морковка"] (исходный массив изменён) console.log(removedItems); // ["Репа", "Редиска"] 

Создание копии массива

const shallowCopy = fruits.slice(); // так можно создать копию массива // ["Клубника", "Манго"] 

Пример: создание двумерного массива

Следующий код создаёт шахматную доску в виде двумерного массива строк. Затем он перемещает пешку путём копирования символа ‘p’ в позиции (6,4) на позицию (4,4). Старая позиция (6,4) затирается пустым местом.

const board = [ ["R", "N", "B", "Q", "K", "B", "N", "R"], ["P", "P", "P", "P", "P", "P", "P", "P"], [" ", " ", " ", " ", " ", " ", " ", " "], [" ", " ", " ", " ", " ", " ", " ", " "], [" ", " ", " ", " ", " ", " ", " ", " "], [" ", " ", " ", " ", " ", " ", " ", " "], ["p", "p", "p", "p", "p", "p", "p", "p"], ["r", "n", "b", "q", "k", "b", "n", "r"], ]; console.log(board.join("\n") + "\n\n"); // Двигаем королевскую пешку вперёд на две клетки board[4][4] = board[6][4]; board[6][4] = " "; console.log(board.join("\n")); 

Ниже показан вывод:

R,N,B,Q,K,B,N,R P,P,P,P,P,P,P,P , , , , , , , , , , , , , , , , , , , , , , , , , , , , p,p,p,p,p,p,p,p r,n,b,q,k,b,n,r R,N,B,Q,K,B,N,R P,P,P,P,P,P,P,P , , , , , , , , , , , , , , , , , ,p, , , , , , , , , , p,p,p,p, ,p,p,p r,n,b,q,k,b,n,r

Спецификации

Specification
ECMAScript Language Specification # sec-array-objects

Совместимость с браузерами

BCD tables only load in the browser

Смотрите также

• Упорядоченные наборы данных
• TypedArray
• ArrayBuffer

Found a content problem with this page?

• Edit the page on GitHub.
• Report the content issue.
• View the source on GitHub.

This page was last modified on 19 дек. 2023 г. by MDN contributors.

Your blueprint for a better internet.

Псевдомассив аргументов «arguments»

Материал на этой странице устарел, поэтому скрыт из оглавления сайта.

В JavaScript любая функция может быть вызвана с произвольным количеством аргументов.

function go(a,b) < alert("a="+a+", b="+b); >go(1); // a=1, b=undefined go(1,2); // a=1, b=2 go(1,2,3); // a=1, b=2, третий аргумент не вызовет ошибку

В JavaScript нет «перегрузки» функций

В некоторых языках программист может создать две функции с одинаковым именем, но разным набором аргументов, а при вызове интерпретатор сам выберет нужную:

function log(a) < . >function log(a, b, c) < . >log(a); // вызовется первая функция log(a, b, c); // вызовется вторая функция

Это называется «полиморфизмом функций» или «перегрузкой функций». В JavaScript ничего подобного нет.

Может быть только одна функция с именем log , которая вызывается с любыми аргументами.

А уже внутри она может посмотреть, с чем вызвана и по-разному отработать.

В примере выше второе объявление log просто переопределит первое.

Доступ к «лишним» аргументам

Как получить значения аргументов, которых нет в списке параметров?

Доступ к ним осуществляется через «псевдо-массив» arguments.

Он содержит список аргументов по номерам: arguments[0] , arguments[1] …, а также свойство length .

Например, выведем список всех аргументов:

function sayHi() < for (var i = 0; i < arguments.length; i++) < alert( "Привет, " + arguments[i] ); >> sayHi("Винни", "Пятачок"); // 'Привет, Винни', 'Привет, Пятачок'

Все параметры находятся в arguments , даже если они есть в списке. Код выше сработал бы также, будь функция объявлена sayHi(a,b,c) .

Связь между arguments и параметрами

В старом стандарте JavaScript псевдо-массив arguments и переменные-параметры ссылаются на одни и те же значения.

В результате изменения arguments влияют на параметры и наоборот.

function f(x) < arguments[0] = 5; // меняет переменную x alert( x ); // 5 >f(1);

function f(x) < x = 5; alert( arguments[0] ); // 5, обновлённый x >f(1);

В современной редакции стандарта это поведение изменено. Аргументы отделены от локальных переменных:

function f(x) < "use strict"; // для браузеров с поддержкой строгого режима arguments[0] = 5; alert( x ); // не 5, а 1! Переменная "отвязана" от arguments >f(1);

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

arguments – это не массив

Частая ошибка новичков – попытка применить методы Array к arguments . Это невозможно:

function sayHi() < var a = arguments.shift(); // ошибка! нет такого метода! >sayHi(1);

Дело в том, что arguments – это не массив Array .

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

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

var args = []; for (var i = 0; i

Такие объекты иногда называют «коллекциями» или «псевдомассивами».

Пример: копирование свойств copy(dst, src1, src2. )

Иногда встаёт задача – скопировать в существующий объект свойства из одного или нескольких других.

Напишем для этого функцию copy . Она будет работать с любым числом аргументов, благодаря использованию arguments .

copy(dst, src1, src2…) Копирует свойства из объектов src1, src2. в объект dst . Возвращает получившийся объект.

Для объединения нескольких объектов в один:

var vasya = < age: 21, name: 'Вася', surname: 'Петров' >; var user = < isAdmin: false, isEmailConfirmed: true >; var student = < university: 'My university' >; // добавить к vasya свойства из user и student copy(vasya, user, student); alert( vasya.isAdmin ); // false alert( vasya.university ); // My university

// скопирует все свойства в пустой объект var userClone = copy(<>, user);

А вот и реализация:

function copy() < var dst = arguments[0]; for (var i = 1; i < arguments.length; i++) < var arg = arguments[i]; for (var key in arg) < dst[key] = arg[key]; >> return dst; >

Здесь первый аргумент copy – это объект, в который нужно копировать, он назван dst . Для упрощения доступа к нему можно указать его прямо в объявлении функции:

function copy(dst) < // остальные аргументы остаются безымянными for (var i = 1; i < arguments.length; i++) < var arg = arguments[i]; for (var key in arg) < dst[key] = arg[key]; >> return dst; >

Аргументы по умолчанию через ||

Если функция вызвана с меньшим количеством аргументов, чем указано, то отсутствующие аргументы считаются равными undefined .

Зачастую в случае отсутствия аргумента мы хотим присвоить ему некоторое «стандартное» значение или, иначе говоря, значение «по умолчанию». Это можно удобно сделать при помощи оператора логическое ИЛИ || .

Например, функция showWarning , описанная ниже, должна показывать предупреждение. Для этого она принимает ширину width , высоту height , заголовок title и содержимое contents , но большая часть этих аргументов необязательна:

function showWarning(width, height, title, contents) < width = width || 200; // если не указана width, то width = 200 height = height || 100; // если нет height, то height = 100 title = title || "Предупреждение"; //. >

Это отлично работает в тех ситуациях, когда «нормальное» значение параметра в логическом контексте отлично от false . В коде выше, при передаче width = 0 или width = null , оператор ИЛИ заменит его на значение по умолчанию.

А что, если мы хотим использовать значение по умолчанию только если width === undefined ? В этом случае оператор ИЛИ уже не подойдёт, нужно поставить явную проверку:

function showWarning(width, height, title, contents) < if (width === undefined) width = 200; if (height === undefined) height = 100; if (title === undefined) title = "Предупреждение"; //. >

Устаревшее свойство arguments.callee

Используйте NFE вместо arguments.callee

Это свойство устарело, при use strict оно не работает.

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

Современная спецификация рекомендует использовать именованные функциональные выражения (NFE).

В старом стандарте JavaScript объект arguments не только хранил список аргументов, но и содержал в свойстве arguments.callee ссылку на функцию, которая выполняется в данный момент.

function f() < alert( arguments.callee === f ); // true >f();

Эти два примера будут работать одинаково:

// подвызов через NFE var factorial = function f(n) < return n==1 ? 1 : n*f(n-1); >; // подвызов через arguments.callee var factorial = function(n) < return n==1 ? 1 : n*arguments.callee(n-1); >;

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

arguments.callee.caller

Устаревшее свойство arguments.callee.caller хранит ссылку на функцию, которая вызвала данную.

Это свойство тоже устарело

Это свойство было в старом стандарте, при use strict оно не работает, как и arguments.callee .

Также ранее существовало более короткое свойство arguments.caller . Но это уже раритет, оно даже не кросс-браузерное. А вот свойство arguments.callee.caller поддерживается везде, если не использован use strict , поэтому в старом коде оно встречается.

f1(); function f1() < alert( arguments.callee.caller ); // null, меня вызвали из глобального кода f2(); >function f2() < alert( arguments.callee.caller ); // f1, функция, из которой меня вызвали f3(); >function f3() < alert( arguments.callee.caller ); // f2, функция, из которой меня вызвали >

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

«Именованные аргументы»

Именованные аргументы – альтернативная техника работы с аргументами, которая вообще не использует arguments .

Некоторые языки программирования позволяют передать параметры как-то так: f(width=100, height=200) , то есть по именам, а что не передано, тех аргументов нет. Это очень удобно в тех случаях, когда аргументов много, сложно запомнить их порядок и большинство вообще не надо передавать, по умолчанию подойдёт.

Такая ситуация часто встречается в компонентах интерфейса. Например, у «меню» может быть масса настроек отображения, которые можно «подкрутить» но обычно нужно передать всего один-два главных параметра, а остальные возьмутся по умолчанию.

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

function showWarning(options) < var width = options.width || 200; // по умолчанию var height = options.height || 100; var contents = options.contents || "Предупреждение"; // . >

Вызвать такую функцию очень легко. Достаточно передать объект аргументов, указав в нем только нужные:

showWarning(< contents: "Вы вызвали функцию" // и всё понятно! >);

Сравним это с передачей аргументов через список:

showWarning(null, null, "Предупреждение!"); // мысль программиста "а что это за null, null в начале? ох, надо глядеть описание функции"

Не правда ли, объект – гораздо проще и понятнее?

Ещё один бонус кроме красивой записи – возможность повторного использования объекта аргументов:

var opts = < width: 400, height: 200, contents: "Текст" >; showWarning(opts); opts.contents = "Другой текст"; showWarning(opts); // вызвать с новым текстом, без копирования других аргументов

Именованные аргументы применяются во многих JavaScript-фреймворках.

Итого

• Полный список аргументов, с которыми вызвана функция, доступен через arguments .
• Это псевдомассив, то есть объект, который похож на массив, в нём есть нумерованные свойства и length , но методов массива у него нет.
• В старом стандарте было свойство arguments.callee со ссылкой на текущую функцию, а также свойство arguments.callee.caller , содержащее ссылку на функцию, которая вызвала данную. Эти свойства устарели, при use strict обращение к ним приведёт к ошибке.
• Для указания аргументов по умолчанию, в тех случаях, когда они заведомо не false , удобен оператор || .

В тех случаях, когда возможных аргументов много и, в особенности, когда большинство их имеют значения по умолчанию, вместо работы с arguments организуют передачу данных через объект, который как правило называют options .

Возможен и гибридный подход, при котором первый аргумент обязателен, а второй – options , который содержит всевозможные дополнительные параметры:

function showMessage(text, options) < // показать сообщение text, настройки показа указаны в options >

Объект arguments

Устаревший способ получить все значения, переданные в функцию при вызове.

Время чтения: меньше 5 мин

Открыть/закрыть навигацию по статье

Обновлено 6 февраля 2023

Кратко

Скопировать ссылку «Кратко» Скопировано

Устаревший способ получить все значения, переданные в функцию при вызове в виде массивоподобного объекта. Используется в функциях, которые принимают произвольное количество аргументов.

Не работает в стрелочных функциях.

Используйте синтаксис остаточных (rest) параметров, он современнее и лучше читается.

Используйте arguments только если пишете код в версии языка раньше ES6, выпущенной в 2015 году.

Пример

Скопировать ссылку «Пример» Скопировано

Функция, которая принимает произвольное количество аргументов, выбирает из них только строки и склеивает с помощью пробела:

 function joinStrings()  const strings = [] for (let i = 0; i < arguments.length; i++)  if (typeof arguments[i] === 'string')  strings.push(arguments[i]) > > return strings.join(' ')> const result = joinStrings('hello', 12, 'world', false, null)console.log(result)// hello world function joinStrings()  const strings = [] for (let i = 0; i  arguments.length; i++)  if (typeof arguments[i] === 'string')  strings.push(arguments[i]) > > return strings.join(' ') > const result = joinStrings('hello', 12, 'world', false, null) console.log(result) // hello world    Скопировать Скопировано Не удалось скопировать   

Как понять

Скопировать ссылку «Как понять» Скопировано

arguments доступно во всех видах функций, за исключением стрелочных.

arguments — массивоподобный объект, к его элементам можно обращаться по индексу, у него есть свойство length , но arguments не имеет остальных методов массива, таких как push ( ) или filter ( ) .

Массивоподобность объекта позволяет обойти его элементы с помощью цикла.

На практике

Скопировать ссылку «На практике» Скопировано

Андрей Паскаль советует

Скопировать ссылку «Андрей Паскаль советует» Скопировано

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

 function myHandler(. [, second, third])  console.log(`Второй параметр = $`) console.log(`Третий параметр = $`)> myHandler(1, 2, 3) // Второй параметр = 2// Третий параметр = 3 function myHandler(. [, second, third])  console.log(`Второй параметр = $second>`) console.log(`Третий параметр = $third>`) > myHandler(1, 2, 3) // Второй параметр = 2 // Третий параметр = 3    Скопировать Скопировано Не удалось скопировать   

+ Развернуть

Николай Лопин советует

Скопировать ссылку «Николай Лопин советует» Скопировано

��️ В новом коде лучше применять синтаксис остаточных параметров. В этом случае у нас появляется настоящий массив переданных аргументов. Вот как будет выглядеть пример из начала статьи в этом синтаксисе:

 function joinStrings(. rest)  return rest .filter(function (value)  return typeof value === 'string' >) .join(' ')> const result = joinStrings('hello', 12, 'world', false, null)console.log(result)// hello world function joinStrings(. rest)  return rest .filter(function (value)  return typeof value === 'string' >) .join(' ') > const result = joinStrings('hello', 12, 'world', false, null) console.log(result) // hello world    Скопировать Скопировано Не удалось скопировать   

Объект arguments

Объект arguments — это подобный массиву объект, который содержит аргументы, переданные в функцию.

Примечание: Если вы пишете ES6-совместимый код, то лучше использовать остаточные параметры.

Примечание: «Подобный массиву» означает, что arguments имеет свойство length , а элементы индексируются начиная с нуля. Но при этом он не может обращаться к встроенным методам Array , таким как forEach() или map() . Подробнее об этом в §Описании.

Интерактивный пример

Синтаксис

arguments

Описание

Объект arguments — это локальная переменная, доступная внутри любой (нестрелочной) функции. Объект arguments позволяет ссылаться на аргументы функции внутри неё. Он состоит из переданных в функцию аргументов, индексация начинается с 0. Например, если в функцию было передано 3 аргумента, обратиться к ним можно следующим образом:

[0]; arguments[1]; arguments[2]; 

Аргументам может быть присвоено значение:

[1] = "new value"; 

Объект arguments не является Array . Он похож на массив, но не обладает ни одним из его свойств, кроме length . Например, у него нет метода pop . Однако, он может быть преобразован в обычный массив:

var args = Array.prototype.slice.call(arguments); var args = [].slice.call(arguments); // ES2015 const args = Array.from(arguments); const args = [. arguments]; 

Предупреждение: Использование slice на объекте arguments не позволяет сделать оптимизации в некоторых JavaScript движках (например, V8 — подробнее). Если они важны, можно попробовать вместо этого создать новый массив с аналогичной длиной и заполнить его элементами объекта arguments. Альтернативный вариант — использовать конструктор Array как функцию:

var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments); 

Объект arguments можно использовать при вызове функции с бо́льшим количеством аргументов, чем было предусмотрено в её объявлении. Такой способ удобен для функций, в которые допустимо передавать переменное количество аргументов. Можно воспользоваться arguments.length , чтобы определить количество переданных в функцию аргументов, а затем обработать каждый из них с помощью объекта arguments . Чтобы определить количество параметров функции, описанных в её сигнатуре (en-US) , можно использовать свойство Function.length .

Использование typeof с объектом arguments

Применение оператора typeof к arguments вернёт ‘object’.

console.log(typeof arguments); // 'object'

Определение типов аргументов может быть выполнено применением оператора typeof и индексацией.

// выведет тип первого аргумента console.log(typeof arguments[0]);

Использование оператора расширения для объекта arguments

Как и с обычными массива-подобными объектами, для преобразования объекта arguments в обычный массив можно использовать метод Array.from() или оператор расширения:

var args = Array.from(arguments); var args = [. arguments]; 

Свойства

Ссылка на функцию, которая выполняется в текущий момент.

Ссылка на функцию, которая вызвала функцию, выполняющуюся в текущий момент.

Количество переданных в функцию аргументов.

Возвращает новый объект Array Iterator , содержащий значения для каждого индекса в массиве.

Примеры

Создание функции, соединяющей несколько строк

Данный пример описывает функцию, которая соединяет несколько строк. Для этой функции объявлен только один аргумент, определяющий символ-разделитель соединяемых элементов. Функция определена следующим образом:

function myConcat(separator)  var args = Array.prototype.slice.call(arguments, 1); return args.join(separator); > 

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

// возвращает "red, orange, blue" myConcat(", ", "red", "orange", "blue"); // получает "elephant; giraffe; lion; cheetah" myConcat("; ", "elephant", "giraffe", "lion", "cheetah"); // выводит "sage. basil. oregano. pepper. parsley" myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley"); 

Функция, создающая HTML списки

В данном примере приведена функция, которая создаёт строку с HTML-разметкой для списка. Единственный её аргумент — строка, определяющая вид списка: если его значение равно «u», формируется неупорядоченный (маркированный) список, а если «o» — то упорядоченный (нумерованный):

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

Остаточные, деструктурированные и параметры по умолчанию

function foo(. args)  return arguments; > foo(1, 2, 3); // 

Тем не менее, в нестрогих функциях соответствие между их аргументами и объектом arguments существует только в том случае, если функция не содержит никаких остаточных параметров, параметров по умолчанию или деструктурированных параметров. Например, в функции, приведённой ниже, используется параметр по умолчанию, и в данном случае возвращаемый результат будет равен 10, а не 100:

function bar(a = 1)  arguments[0] = 100; return a; > bar(10); // 10 

function zoo(a)  arguments[0] = 100; return a; > zoo(10); // 100 

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

function func(a, b)  arguments[0] = 90; arguments[1] = 99; console.log(a + " " + b); > func(1, 2); //90, 99 

function func(a, b)  a = 9; b = 99; console.log(arguments[0] + " " + arguments[1]); > func(3, 4); //9, 99 

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

function func(a, b, c = 9)  arguments[0] = 99; arguments[1] = 98; console.log(a + " " + b); > func(3, 4); //3, 4 

Спецификации

Specification
ECMAScript Language Specification # sec-arguments-exotic-objects

Совместимость с браузерами

BCD tables only load in the browser

Смотрите также

Found a content problem with this page?

• Edit the page on GitHub.
• Report the content issue.
• View the source on GitHub.

This page was last modified on 6 янв. 2024 г. by MDN contributors.

Your blueprint for a better internet.

MDN

Support

• Product help
• Report an issue

Our communities

Developers

• Web Technologies
• Learn Web Development
• MDN Plus
• Hacks Blog

• Website Privacy Notice
• Cookies
• Legal
• Community Participation Guidelines

Visit Mozilla Corporation’s not-for-profit parent, the Mozilla Foundation.
Portions of this content are ©1998– 2024 by individual mozilla.org contributors. Content available under a Creative Commons license.