Что такое аргумент в javascript

Параметры функций JavaScript

Ранее в этом учебнике вы узнали, что у функций могут быть параметры:

function имяФункции(параметр1, параметр2, параметр3) выполняемый код
>

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

При этом функции JavaScript не выполняют никакой проверки значений параметров (аргументов).

Правила параметров

• Определение функции JavaScript не задает тип данных для параметров.
• Функции JavaScript не проводят проверку типов переданных аргументов.
• Функции JavaScript не проверяют количество полученных аргументов.

Параметры по умолчанию

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

Иногда это приемлемо, но иногда лучше присваивать параметру значение по умолчанию:

 function myFunction(x, y) < if (y === undefined) < y = 0; >> 

В ECMAScript 2015 допускает использование параметров по умолчанию в заголовке функции:

 function (a=1, b=1) < // код функции >

Если функция вызывается с лишними аргументами (большим количеством параметров, чем декларировано в определении), то доступ к этим аргументам можно получить через специальный объект arguments.

Объект Arguments

У всех функций JavaScript есть встроенный объект arguments, который называется объект аргументов.

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

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

 x = findMax(1, 123, 500, 115, 44, 88); function findMax() < var i; var max = -Infinity; for (i = 0; i < arguments.length; i++) < if (arguments[i] >max) < max = arguments[i]; >> return max; > 

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

 x = sumAll(1, 123, 500, 115, 44, 88); function sumAll() < var i; var sum = 0; for (i = 0; i < arguments.length; i++) < sum += arguments[i]; >return sum; > 

Аргументы передаются по значению

Параметры в вызове функции — это аргументы функции.

Аргументы передаются по значению. Т.е. функция знает только значение аргумента, но не его расположение.

Если функция изменит значение аргумента, то это не изменит оригинальное значение параметра.

Изменение аргумента не заметно (не отражается) за пределами функции.

Объекты передаются по ссылке

В JavaScript ссылки на объект являются значениями.

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

Изменение свойства объекта заметно (отражается) за пределами функции.

JavaScript: Параметры и аргументы функции

Параметры функции играют роль локальных переменных в теле функции. При указании параметров функции ключевое слово var или let использовать не нужно, JavaScript объявляет их в качестве локальных переменные автоматически. Параметров может быть указано любое количество:

function foo(a, b, c) < . >// a, b, c – параметры функции

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

function foo(a, b) < var sum = a + b; alert(sum); >foo(5, 7); // 12

Когда при вызове функции ей передаётся список аргументов, эти аргументы присваиваются параметрам функции в том порядке, в каком они указаны: первый аргумент присваивается первому параметру, второй аргумент – второму параметру и т. д.

Если число аргументов отличается от числа параметров, то никакой ошибки не происходит. В JavaScript подобная ситуация разрешается следующим образом:

Если при вызове функции ей передаётся больше аргументов, чем задано параметров, «лишние» аргументы просто не присваиваются параметрам. Допустим, имеется следующее объявление функции:

function foo(a, b, c) < // . >

Все функции имеют два неявных параметра: arguments и this . Под словом неявный подразумевается, что эти параметры не перечисляются явно в объявлении функции. Эти параметры также неявно инициализируются при вызове функции. К ним можно обращаться в самой функции так же, как и к любым другим явно установленным параметрам.

Значения параметров по умолчанию

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

function foo(greeting = "Привет", name = "Гость") < console.log(greeting + ", " + name + "!"); >foo(); // "Привет, Гость!"

Передача значения undefined в качестве аргумента воспринимается как отсутствие аргумента:

function foo(greeting = "Привет", name = "Гость") < console.log(greeting + ", " + name + "!"); >foo(undefined, "Гомер"); // "Привет, Гомер!"

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

function foo(a, b = 2) < console.log(a === arguments[0]); console.log(b === arguments[1]); >foo(1); // true // false

Так как в функцию передаётся только один аргумент, arguments[1] имеет значение undefined , поэтому сравнение console.log(b === arguments[1]); в результате даёт false .

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

function foo(a = 1) < "use strict"; // Ошибка >

Значением по умолчанию может быть как простое, так и сложное выражение:

function foo(a = 1, b = 2 + 2) < console.log(a, b); >foo(1); // 1 4

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

function foo(a, b = a) < console.log(a, b); >foo(1); // 1 1

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

function foo(a = b, b) < console.log(a, b); >foo(undefined, 1); // Ошибка

Параметры создаются в момент вызова функции в том порядке, в котором они следуют в определении функции. Каждый параметр создаётся по аналогии объявления переменной с помощью ключевого слова let. Это означает, что использование параметра до того как он был создан вызовет ошибку.

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

function foo(a = b) < var b = 5; console.log(a); >foo(); // Ошибка

Дополнительный параметр

Параметр с префиксом . называется дополнительным (или необязательным). Дополнительный параметр указывается в качестве последнего параметра. Дополнительный параметр – это массив, в который сохраняются лишние аргументы, когда количество переданных аргументов превышает количество параметров:

function foo(a, b, . args) < console.log(args); >foo(1, 2, 3, 4, 5); // 3, 4, 5

С этой темой смотрят:

• Объявление и вызов функции
• arguments и this
• Инструкция return
• Рекурсия

Копирование материалов с данного сайта возможно только с разрешения администрации сайта
и при указании прямой активной ссылки на источник.
2011 – 2023 © puzzleweb.ru | razumnikum.ru

Объект 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 7 авг. 2023 г. 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– 2023 by individual mozilla.org contributors. Content available under a Creative Commons license.