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

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

(function (foo, bar) {
console.log(typeof arguments); // ?

arguments[0] = 42;
console.log(foo); // ?
})(10, 20);

А также покажу интересную идею-библиотеку

function test (foo, bar) {
Args(arguments).defaults(100, 100);

return [foo, bar];
};

test( ); // 100, 100
test(15 ); // 15, 100
test(21, 42); // 21, 42

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

Что такое arguments

Это хэш. Обычный хэш, как var object = {}

(function () { console.log(
typeof arguments, // object
Object.getPrototypeOf(arguments) == Object.prototype // true
) })();

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

var array = Array.prototype.slice.call(arguments, 0);
// или покороче, но менее производительно:
var array = [].slice.call(arguments, 0);

Мы вызываем метод slice прототипа Array от лица arguments.

Что есть в arguments

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

var count = function () {
console.log(arguments.length);
};

count(); // 0
count(first, second); // 2

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

function one (foo) {};
function three (foo, bar, qux) {};

console.log( one.length); // 1
console.log(three.length); // 3

arguments.callee — ссылка на саму функцию.

function foo () {
console.log(arguments.callee === foo); // true
}

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

function test (foo, bar, qux) {
return arguments.callee.length === arguments.length;
}

test(1); // false
test(1,2,3); // true

Аргументы в arguments

В arguments содержится также список переданных аргументов.

function test (foo, bar) {
console.log(foo, bar); // ‘a’, ‘b’
console.log(arguments[0], arguments[1]); // ‘a’, ‘b’
}
test(‘a’, ‘b’);

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

(function (foo) {
arguments[0] = 42;
console.log(foo); // 42!

foo = 20;
console.log(arguments[0]); // 20
})(5);

При этом связь достаточно крепкая:

function foo (qux) {
change(arguments);
return qux;
};

function change(a) {
a[0] = 42;
}

foo(10); // 42

Что из этого можно получить?

Во многих языках программирования есть «переменные по-умолчанию». К примеру, php:

function ($foo = 30, $bar = ‘test’) {
var_dump($foo);
var_dump($bar);
}

В javascript оно будет выглядеть как-то так:

function (foo, bar) {
if (typeof foo === ‘undefined’) foo = 30;
if (typeof bar === ‘undefined’) bar = ‘test’;

console.log(foo, bar);
}

Зная особенности arguments можно создать красивый интерфейс:

function test(foo, bar) {
Args(arguments).defaults(30, ‘test’);

console.log(foo, bar)
}

test(); // 30, ‘test’

С помощью такого кода:

function Args (args) {
if (this instanceof Args) {
this.args = args;
} else {
// Если создано не через new, а просто вызвана функция, создаем и возвращаем новый объект
return new Args(args);
}
};
Args.prototype = {
defaults: function () {
var defaults = arguments;
for (var i = defaults.length; i—;) {
if (typeof args[i] === ‘undefined’) args[i] = defaults[i];
}
return this;
}
};

Аналогично можно сделать автоматическое приведение типов:

function test(foo) {
Args(arguments)
.defaults(10)
.cast(Number);

console.log(foo)
}

test(‘0100’); // 100

Или Type Hinting:

function test(foo, bar) {
Args(arguments).types(Foo, Bar);

// code
}

test(new Foo(), new Bar());
test(1, 2); // Error

Из интересных идей — сообщение, что все аргументы обязательны:

function test (foo, bar, qux) {
Args(arguments).allRequired();
}

test(1,2,3); // success
test(1,2); // Error: 3 args required, 2 given

Заключение

Все эти идеи и возможности (и даже больше) я оформил в библиотеку — Args.js.
Согласен, что кое-какие вещи (как TypeHinting) не совсем подходят к идеологии языка. В то же время например defaults — очень удобная штука, имхо.
Пока что это прототип и, перед тем как вы будете его использовать — будьте уверены, что оно вам действительно нужно, а не что вы просто стараетесь из прекрасного языка сделать что-то похожее на C#.
Предлагаю обсудить, покритиковать код, найти пару багов и закоммитить несколько строк кода)

Args.js

К сожалению, из-за бага в трёх популярных браузерах(IE, Fx, Opera) я не смог добиться желаемого эффекта, полноценно самое вкусное заработало только в Chrome (ну по крайней мере в node.js работать будет)). Надеюсь, решим эту проблему вместе.

UPD: В комментах выяснили, что таки это бага Хрома, но, зато, какая приятная! Спасибо jamayka

• Значения параметров по умолчанию
• Дополнительный параметр

Параметры функции играют роль локальных переменных в теле функции. При указании параметров функции ключевое слово 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) { // … }

  Если при её вызове указать foo(1, 2, 3, 4), то аргументы 1, 2 и 3 будут присвоены параметрам a, b и c соответственно. В то же время аргумент 4 не будут присвоен ни одному из параметров данной функции.

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

Все функции имеют два неявных параметра: 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