Дэвид Флэнаган - JavaScript. Подробное руководство, 6-е издание

function square(x) { return х*х; }

Это определение создает новый объект функции и присваивает его переменной square. Имя функции действительно нематериально - это просто имя переменной, которая ссылается на объект функции. Функция может быть присвоена другой переменной, и при этом работать так же, как и раньше:

var s = square; // Теперь s ссылается на ту же функцию, что и square

square(4); // => 16

s(4); // => 16

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

var о = {square: function(x) { return х*х; }}; // Литерал объекта

var у = о.square(16); // у = 256

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

var а = [function(x) { return х*х; }, 20]; // Литерал объекта

а[0](а[1]); // => 400

Синтаксис вызова функции в последнем примере выглядит необычно, однако это вполне допустимый вариант применения выражения вызова!

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

Пример 8.2. Использование функций как данных

// Определения нескольких простых функций

function add(x.y) { return х + у; }

function subtract(x,у) { return х - у; }

function multiply(x,у) { return х * у; }

function divide(x,y) { return x / у; }

// Эта функция принимает одну из предыдущих функций

// в качестве аргумента и вызывает ее с двумя операндами

function operate(operator, operand1, operand2) {

return operator(operand1, operand2);

}

// Так можно вызвать эту функцию для вычисления выражения (2+3)+(4*5):

var і = operate(add, operate(add, 2, 3), operate(multiply, 4, 5));

// Ради примера реализуем эти функции снова, на этот раз

// с помощью литералов функций внутри литерала объекта,

var operators = {

add: function(x,у) { return x+y; },

subtract: function(x,y) { return x-y; },

multiply: function(x,y) { return x*y; },

divide: function(x,y) { return x/y; },

pow: Math.pow // Можно использовать даже предопределенные функции

}

// Эта функция принимает имя оператора, отыскивает оператор в объекте,

// а затем вызывает его с указанными операндами.

// Обратите внимание на синтаксис вызова функции оператора,

function operate2(operation, operand1, operand2) {

if (typeof operators[operation] === "function")

return operators[operation](operand1. operand2);

else throw "неизвестный оператор":

}

// Вычислить значение ("hello" + " " + "world"):

var j = operate2("add", "hello", operate2("add", " ", "world")):

// Использовать предопределенную функцию Math.pow():

var k = operate2("pow", 10, 2):

В качестве еще одного примера использования функций как значений рассмотрим метод Array.sort(). Он сортирует элементы массива. Существует много возможных порядков сортировки (числовой, алфавитный, по датам, по возрастанию, по убыванию и т. д.), поэтому метод sort() принимает в качестве необязательного аргумента функцию, которая сообщает о том, как выполнять сортировку. Эта функция делает простую работу: получает два значения, сравнивает их и возвращает результат, указывающий, какой из элементов должен быть первым. Этот аргумент-функция делает метод Array.sort() совершенно универсальным и бесконечно гибким - он может сортировать любой тип данных в любом мыслимом порядке. Примеры использования функции Array.sort() представлены в разделе 7.8.3.

Функции в языке JavaScript являются не простыми значениями, а особой разновидностью объектов, благодаря чему функции могут иметь свойства. Когда функции требуется «статическая» переменная, значение которой должно сохраняться между ее вызовами, часто оказывается удобным использовать свойство объекта функции, позволяющее не занимать пространство имен определениями глобальных переменных. Например, предположим, что надо написать функцию, возвращающую уникальное целое число при каждом своем вызове. Функция никогда не должна возвращать одно и то же значение дважды. Чтобы обеспечить это, функция должна запоминать последнее возвращенное значение и сохранять его между ее вызовами. Эту информацию можно было бы хранить в глобальной переменной, но это было бы нежелательно, потому что данная информация используется только этой функцией. Лучше сохранять ее в свойстве объекта Function . Вот пример функции, которая возвращает уникальное целое значение при каждом вызове:

// Инициализировать свойство counter объекта функции. Объявления функций

// поднимаются вверх, поэтому мы можем выполнить это присваивание до объявления функции.

uniquelnteger.counter =0;

// Эта функция возвращает разные целые числа при каждом вызове.

// Для сохранения следующего возвращаемого значения она использует собственное свойство.

function uniqueInteger() {

return uniqueInteger.counter++; // Увеличить и вернуть свойство counter

}

Еще один пример, взгляните на следующую функцию factorial() , которая использует собственные свойства (интерпретируя себя как массив) для сохранения результатов предыдущих вычислений:

// Вычисляет факториалы и сохраняет результаты в собственных свойствах.

function factorial(n) {

if (isFinite(n) && n>0 && n==Math.round(n)) { // Только конечные положительные целые

if (!(n in factorial)) // Если не сохранялось ранее

factorial[n] = n * factorial(n-1); // Вычислить и сохранить

return factorial[n]; // Вернуть сохр. результат

}

else return NaN; // Для ошибочного аргумента

}

factorial[1] = 1; // Инициализировать кэш базовым случаем.

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