Для описания функции в javascript достаточно указать. JavaScript: Функции
Функция - это программный код, который определяется один раз и затем может вызываться на выполнение любое количество раз.
В JavaScript функция является значением, поэтому её можно присваивать переменным, элементам массива, свойствам объектов, передавать в качестве аргумента функциям и возвращать в качестве значения из функций.
Объявление и вызов функции
Существует три способа объявления функции: Function Declaration, Function Expression и Named Function Expression.
Function Declaration (сокращённо FD) – это "классическое" объявление функции. В JavaScript функции объявляются с помощью литерала функции. Синтаксис объявления FD:
Литерал функции состоит из следующих четырёх частей:
- Ключевое слово function .
- Обязательный идентификатор, определяющий имя функции. В качестве имени функции обычно выбирают глагол, т. к. функция выполняет действие.
- Пара круглых скобок вокруг списка из нуля или более идентификаторов, разделяемых запятыми. Данные идентификаторы называются параметрами функции.
- Тело функции, состоящее из пары фигурных скобок, внутри которых располагаются инструкции. Тело функции может быть пустым, но фигурные скобки должны быть указаны всегда.
Простой пример:
Function sayHi() { alert("Hello"); }
Встречая ключевое слово function интерпретатор создаёт функцию и затем присваивает ссылку на неё переменной с именем sayHi (переменная с данным именем создаётся интерпретатором автоматически).
Обратившись к переменной sayHi можно увидеть, что в качестве значения там находится функция (на самом деле ссылка на неё):
Alert(sayHi); // function sayHi() { alert("Hello"); }
Function Expression (сокращённо FE) – это объявление функции, которое является частью какого-либо выражения (например присваивания). Синтаксис объявления FE:
Function (параметры) { инструкции }
Простой пример:
Var sayHi = function () { alert("Hello"); };
Функцию FE иначе ещё называют "анонимной функцией ".
Named Function Expression (сокращённо NFE) – это объявление функции, которое является частью какого-либо выражения (например присваивания). Синтаксис объявления NFE:
Function идентификатор (параметры) { инструкции }
Простой пример:
Var sayHi = function foo() { alert("Hello"); };
Объявления FE и NFE обрабатываются интерпретатором точно так же, как и объявление FD: интерпретатор создаёт функцию и сохраняет ссылку на неё в переменной sayHi.
Программный код, расположенный в теле функции, выполняется не в момент объявления функции, а в момент её вызова. Для вызова функции используется оператор () (вызов функции):
Function sayHi() { alert("Hello"); } var sayHi2 = function () { alert("Hello2"); }; var sayHi3 = function foo() { alert("Hello3"); }; sayHi(); // "Hello" sayHi2(); // "Hello2" sayHi3(); // "Hello3"
Разница между представленными тремя объявлениями заключается в том, что функции, объявленные как FD, создаются интерпретатором до начала выполнения кода (на этапе анализа), поэтому их можно вызывать (в той области видимости где они объявлены) до объявления:
// Вызов функции до её объявления в коде верхнего уровня foo(); function foo() { alert("Вызов функции foo() в глобальной области видимости."); // Вызов функции до её объявления в области видимости функции bar(); function bar() { alert("Вызов функции bar() в области видимости функции."); } }
Функции, объявленные как FE или NFE, создаются в процессе выполнения кода, поэтому их можно вызывать только после того как они объявлены:
// sayHi(); // Ошибка. Функция sayHi ещё не существует var sayHi = function () { alert("Hello!"); }; sayHi();
Функции, объявленные внутри блока, находятся в блочной области видимости:
// foo(); // Ошибка. Функция не объявлена. { foo(); // 1 function foo() { console.log(1); } } foo(); // Ошибка. Функция не объявлена.
В отличие от FE, функция, объявленная как NFE, имеет возможность обращаться к себе по имени при рекурсивном вызове. Имя функции доступно только внутри самой функции:
(function sayHi(str) { if (str) { return; } sayHi("hi"); // Имя доступно внутри функции })(); sayHi(); // Ошибка. Функция не объявлена
Функция обратного вызова
Функция обратного вызова – это функция, которая передаётся в качестве аргумента другой функции для последующего её вызова.
Функции обратного вызова часто используются, в качестве обработчиков событий.
Ниже приведён пример функции, принимающей в качестве своего аргумента ссылку на другую функцию для её последующего вызова:
Function foo(callback) { return callback(); } foo (function() { alert("Hello!"); });
Этот пример наглядно демонстрирует принцип действия обратного вызова.
В этой главе:
Функции – это один из основных способов объединения операторов в логически связанные блоки. В языке JavaScript функция представляет собой группу выражений, служащих для выполнения какой-либо определенной задачи, объединенных под общим именем.
В отличие от большинства других языков программирования, JavaScript не делает различий между собственно функциями и процедурами. Подобно функциям, процедуры так же представляют собой программные блоки. Однако результаты выполнения процедур непосредственно сказываются на выполнении программы, в то время как функции должны возвращать значения. С этой точки зрения функции JavaScript можно рассматривать и как процедуры.
Определение и вызов функций
Прежде, чем вызывать и использовать функцию, ее надо определить. Определение функций в JavaScript имеет следующий синтаксис:
Function ИмяФункции (аргументы) { блок выражений }
Таким образом, функция состоит из следующих частей, предваряемых ключевым словом function:
- идентификатора, определяющего имя функции;
- списка аргументов, заключенного в круглые скобки и разделенного запятыми;
- операторов JavaScript, заключенных в фигурные скобки. Эти операторы могут включать вызовы других функций или даже самой этой функции (рекурсия).
В простейшем случае аргументы могут отсутствовать, а блок операций моет быть представлен единственным оператором:
Function MyFirstFunc () { var MyMessage="Это – моя функция!"; alert(MyMessage); }
Здесь мы определили функцию, которая будет выдавать окно с сообщением «Это – моя функция!». Следует заметить, что даже если функция не принимает никаких аргументов, она все равно должна иметь пару круглых скобок после своего названия.
ВНИМАНИЕ
Важное замечание следует сделать по поводу переменных, объявляемых в теле функций. Такие переменные видны программе только внутри той функции, в которой они определены. Так, в примере с MyFirstFunc, доступ к переменной MyMessage возможен только внутри этой функции, но не вне нее.
Но чаще всего функции все-таки принимают какие-либо значения в качестве своих аргументов. Возьмем для примера ранее рассмотренный блок, вычисляющий список чисел, на которые 100 делится без остатка. Если этот блок вынести в отдельную функцию, то можно будет использовать его для того, чтобы выводить список делителей для любого числа. Для этого нам потребуется всего один аргумент, который и будет определять число, для которого нам нужно получить такой список:
Function remainder_free(j) {
var i=0;
while (i В этом случае значение переменной j функция получает при своем вызове. И как раз тут важно учесть, тот факт, что когда браузер загружает документ и интерпретирует объявление функции, он только считывает ее в память. А для того чтобы функция была выполнена, ее надо вызвать. Вызов функции может производиться из любого места JavaScript программы, и имеет такой вид: ИмяФункции(параметры)
ИмяФункции означает имя ранее объявленной функции, а параметры – список из одного или нескольких значений, разделенных запятыми и передаваемых функции в качестве аргументов. Количество и порядок параметров, передаваемых функции, должен точно соответствовать списку аргументов, указанных при объявлении функции. Так, для случая с только что рассмотренной функцией поиска целых делителей, где используется 1 аргумент, вызов функции может быть таким: Remainder_free(100);
Если параметров будет меньше или больше чем надо, то в первом случае недостающим параметрам будет назначено значение NaN, а во втором – лишние параметры будут проигнорированы. Таким образом, следующие варианты вызова этой же функции не являются верными: Remainder_free; // так функции не вызывают вообще
remainder_free(); // недостаточно параметров
remainder_free(100,0); // лишний параметр
В случае если функция вызывается не просто как процедура (как только что рассмотренная), а именно как функция, т.е. если она должна возвращать значение, то в ней должен содержаться специальный оператор return, в котором указывается выражение, значение которого возвращает функция. Например, если требуется создать функцию, которая будет принимать в качестве аргумента число, и возвращать его третью степень, то она может выглядеть примерно так: Function cube(value) {
return value * value * value;
}
Таким образом, чтобы в любом месте программы вычислить значение числа в 3-й степени, достаточно написать такое выражение: Var x = cube(3);
В результате выполнения этого выражения переменной x будет присвоено значение 27. Примеры вызова функций вы можете посмотреть в JavaScript-калькуляторе (файл calc.html). Как уже отмечалось, функции могут содержать в себе вызовы других функций. Например, в случае с поиском делителей можно было бы вывести, к примеру, не сами делители, а их 3-ю степень, для чего из функции remainder_free вызывалась бы функция cube: Function remainder_free(j) {
var i=0, ic=0;
while (i Таким образом, функции можно вызывать друг и друга, управляя тем самым ходом исполнения сценария. Как и в некоторых других языках программирования (например, как в Паскале), функции в JavaScript могут быть вложенными. Суть использования вложенных функций состоит в том, что такая локальная функция не видна из других частей программы, что может быть удобными при разработке достаточно больших проектов, например, чтобы исключить переопределения имен переменных. Допустим, если бы рассмотренная нами функция cube была бы ненужной по ходу всего сценария, за исключением одного частного случая (скажем, функции, складывающей кубы двух чисел), то можно было бы сделать ее вложенной: Function AddCubes(x,y) {
function cube(value) {
return value * value * value;
};
return cube(x) + cube(y);
}
В данном случае определена функция AddCubes, внутри которой определена еще одна функция – cube. При этом следует учитывать, что для вложенной функции видны переменные, используемые во внешней («наружной») функции, но не наоборот. В то же время сама вложенная функция доступна только для выражений из внешней функции: в данном случае функцией cube можно будет воспользоваться только из функции AddCubes. Язык JavaScript поддерживает также и такую весьма полезную возможность, как рекурсивный вызов функций, или просто рекурсию. Под рекурсией понимают вызов функции из самой себя. Рассмотрим этот вопрос на следующем примере: Function recfunc(x) {
x--;
if (x>5) recfunc(x);
alert(x);
}
Здесь мы объявили функцию recfunc, принимающую один аргумент, и вызывающую саму себя до тех пор, пока значение этого аргумента больше 5. Хотя на первый взгляд может показаться, что такое поведение функции похоже на обычный цикл, на самом деле все работает несколько по-иному: если вы вызовите ее со значением 8, то она выдаст вам 3 сообщения в следующей последовательности: 5, 6, 7. Иначе говоря, функция вызывала саму себя до тех пор, пока значение x было больше 5, и собственно вывод сообщений начала 3-я по уровню получившейся вложенности функция, которая и вывела первое сообщение (в данном случае им стало декрементированное 6, т.е. 5). В языке JavaScript аргументы функции могут рассматриваться как массив. Для обращения к массиву аргументов используется следующий синтаксис: Arguments[i];
ИмяФункции.arguments[i];
Здесь i должно быть целым числом, являющимся порядковым номером аргумента, при этом отсчет аргументов начинается с нуля. В случае, когда обращение к массиву аргументов происходит из самой функции, имя функции можно опустить. Чтобы узнать число аргументов, используйте выражение свойство массива length: Arguments.length;
Использование массива аргументов призвано разрешить задачу вызова функции с числом аргументов, превышающим указанное при определении функции. Это может быть полезным в том случае, если вы не знаете заранее, сколько аргументов должна принять функция. В таком случае при описании функции обычно определяют только обязательные аргументы, а с остальными работают через массив. Допустим, нам нужно написать функцию, которая будет склеивать несколько строк при помощи указанного разделителя. В таком случае нам требуется определить только один аргумент – разделитель, а все остальные значения такая функция должна будет принимать через массив аргументов: Function ConcatSeparated(separator) {
result=""; // инициализируем возвращаемое значение
for (var i=1; i Эта функция будет возвращать одну строку, состоящую из списка аргументов, начиная со второго, и «склеенную» первым аргументом. Пример ее использования можно посмотреть в файле argarray.html. Но, на самом деле, применение массива аргументов позволяет обходиться вообще без объявления параметров. Допустим, нам нужна функция, возвращающая среднее значение нескольких чисел. Как известно, для этого достаточно сложить все числа и разделить результат на их количество. Соответственно, нам пригодится свойство массива length, отвечающее за количество аргументов. В результате функция получит примерно такой вид: Function calcAvg() {
var summ=0; // инициализируем переменные
for (var i=0; i Здесь хотелось бы обратить внимание на то, что обход массива начинается с нулевого элемента. Это вполне естественно, поскольку нумерация элементов массивов начинается с 0. Если же у вас возник вопрос, почему в предыдущем примере отсчет начинался с 1, то обратите внимание на то, что первым аргументом там был separator, объявленный явно, и который ни с чем склеивать не требовалось. Другой момент – это использование сокращенной формы записи для подсчета суммы. Конечно, можно было бы написать это выражение в более привычном виде: Summ = summ + arguments[i];
Но, поскольку уж в JavaScript предусмотрены сокращенные формы записи, то почему бы их и не использовать? Ну и, наконец, после оператора return записана не переменная, а выражение, что так же вполне допустимо с точки зрения синтаксиса языка. Что касается использования только что созданной функции, то ее вызов может быть произведен одним из следующих способов: Var avg = calcAvg(1,3,5); // переменной avg будет присвоено значение 3
var avg = calcAvg(2); // переменной avg будет присвоено значение 2
var avg = calcAvg(0,4,8,14); // переменной avg будет присвоено значение 6,5
Заметьте, что во всех случаях используется некоторая переменная (avg), которой присваивается значение, возвращаемое функцией. Если бы такой переменной не было указано, то результат вычислений попросту пропал бы. Иначе говоря, если функция возвращает какое-либо значение, то оно должно использоваться – не обязательно путем присвоения переменной, но и любым другим способом: Alert(calcAvg(10,100));
В данном случае возвращаемое функцией значение будет использовано в качестве параметра метода alert(). В использовании возвращаемого значения и кроется главное отличие между собственно функциями и функциями, используемыми в качестве процедур (без оператора return): последние ничего не возвращают, а только производят какую-либо работу. В JavaScript имеется ряд функций, являющихся частью самого языка, и не связанных с какими-либо конкретными объектами (вернее, они являются функциями некоего глобального объекта global, на который, тем не менее, никогда не требуется ссылаться). Такие функции называются предопределенными. К предопределенным функциям JavaScript 1.3 относятся: eval, isFinite, isNaN, parseInt, parseFloat, Number, String, escape и unescape. В JavaScript 1.5 вместо функций escape и unescape используются 4 новых функции: encodeURI, encodeURIComponent, decodeURI, и decodeURIComponent. Краткое описание всех этих функций приведено в таблице 4.9. Рассмотрим некоторые функции подробнее. Начнем с функции eval, которая передает интерпретатору строку с кодом JavaScript без ссылки на какой-либо конкретный объект. Способ использования у этой функции следующий: Eval(выражение);
Здесь «выражение» – строка, которая должна содержать код на языке JavaScript для обработки интерпретатором. Ценность функции eval в том, что с ее помощью можно динамически составлять фрагменты программы и отправлять их на выполнение. При дальнейшем написании сценариев мы не раз воспользуемся этой функцией. Функция isFinite проверяет, является ли переданное ей значение конечным числом. Если в качестве значения, передаваемого этой функции, указать -3, то результатом будет истина. А если указать Infinity (специальное ключевое слово, обозначающее бесконечность), результатом будет ложь, как, впрочем, и в том случае, если вместо числа указать строку. Функция isNaN выполняет противоположную задачу – она проверяет, что указанный аргумент не является числом. Здесь следует отметить, что в JavaScript имеется еще одно ключевое слово – NaN. Оно используется, когда требуется указать значение, не являющееся числом. Например, такой вызов функции isNaN возвратит истину: IsNaN(NaN);
Для преобразования строки в число с плавающей запятой служит функция parseFloat. Например, чтобы присвоить некоторой переменной значение, которое должно быть вещественным числом, следует написать следующее выражение: Var a = parseFloat("31416e-4");
В этом случае переменной a будет присвоено значение 3,1416. В том случае, если преобразовать строку в число не представляется возможным, функция parseFloat возвращает значение NaN. Кроме функции parseFloat, для преобразования строк в число имеется функция parseInt. В отличие от parseFloat, она может принимать как один, так и два аргумента: ParseInt("25");
parseInt("25", 10);
Здесь первый аргумент является числом для преобразования, а второй указывает на систему счисления, по которой следует производить преобразование. По умолчанию используется десятеричная система счисления, поэтому оба приведенных выше вызова функции аналогичны. Но чтобы точнее разобраться с этой функцией, давайте рассмотрим пример, в котором все ее вызовы возвращают значение 15: Var x = parseInt("15"); /* если не оговорено иначе, подразумевается, что система счисления – десятеричная */
var x = parseInt("15", 10); /* здесь мы явно указываем десятеричную систему счисления */
var x = parseInt(15.99, 10); /* в данном случае исходным значением служит не строка, а число с плавающей точкой */
var x = parseInt("F", 16); // шестнадцатеричное F равно десятеричному 15
var x = parseInt("FXX123", 16); /* если какой-либо знак распознать не удается, следующие за ним значения отбрасываются */
var x = parseInt("17", 8); // Восьмеричная система тоже иногда используется
var x = parseInt("1111", 2); // Двоичная система – тоже не редкость
В том случае, когда даже первый символ преобразовать в число не удастся, функция возвращает значение NaN: ParseInt("8",8); // В восьмеричной системе счисления нет цифры 8!
Для преобразования строк и чисел в JavaScript имеются еще 2 функции – String и Number. Они используются для преобразования объектов в строку и число соответственно. Например, если нам надо что-либо преобразовать в строку, например, объект document, то можно написать так: Var doc = String(document);
В данном случае в качестве значения переменной doc мы получим строку, описывающую объект как «». Примеры работы этих и других предопределенных функций можно найти в файле predef.html. И, наконец, осталось рассмотреть функции кодирования. На самом деле, в клиентских сценариях они практически не используются, и предназначены для работы на стороне сервера (для случая, если web-сервером является Netscape Enterprise). Так что мы не будем на них останавливаться, и отметим лишь, что, поскольку функции escape и unescape не работают с национальными символами, то, начиная с JavaScript 1.5, они объявлены устаревшими, а вместо них следует использовать encodeURI, decodeURI, encodeURIComponent и decodeURIComponent. 2011-07-28 // Есть вопросы, предложения, замечания? Вы можете Функции - ключевая концепция в JavaScript. Важнейшей особенностью языка является первоклассная поддержка функций (functions as first-class citizen)
. Любая функция это объект,
и следовательно ею можно манипулировать как объектом, в частности: Это определяет высокую выразительную мощность JavaScript и позволяет относить его к числу языков, реализующих функциональную парадигму программирования (что само по себе есть очень круто по многим соображениям). Функция в JavaScript
специальный тип объектов, позволяющий формализовать средствами языка определённую логику поведения и обработки данных. Для понимания работы функций необходимо (и достаточно?) иметь представление о следующих моментах: Объявление функции (function definition
, или function declaration
, или function statement
) состоит из ключевого слова function и следующих частей: Например, следующий код объявляет простую функцию с именим square: Function square(number) {
return number * number;
}
Функция square принимает один параметр, названный number. Состоит из одной инструкции, которая означает вернуть параметр этой функции (это number) умноженный на самого себя. Инструкция return указывает на значение, которые будет возвращено функцией. Return number * number;
Примитивные параметры (например, число) передаются функции значением; значение
передаётся в функцию, но если функция меняет значение параметра, это изменение не отразится глобально или после вызова функции.
Если Вы передадите объект как параметр (не примитив, например, или определяемые пользователем объкты), и функция изменит свойство переданного в неё объекта, это изменение будет видно и вне функции, как показано в следующим примере: Function myFunc(theObject) {
theObject.make = "Toyota";
}
var mycar = {make: "Honda", model: "Accord", year: 1998};
var x, y;
x = mycar.make; // x получает значение "Honda"
myFunc(mycar);
y = mycar.make; // y получает значение "Toyota"
// (свойство было изменено функцией)
Функция вида "function declaration statement" по синтаксису является инструкцией (statement
), ещё функция может быть вида "function definition expression". Такая функция может быть анонимной
(она не имеет имени). Например, функция square может быть вызвана так: Var square = function(number) { return number * number; };
var x = square(4); // x получает значение 16
Однако, имя может быть и присвоено для вызова самой себя внутри самой функции и для отладчика (debugger
) для идентифицирования функции в стек-треках (stack traces
; "trace" - "след" / "отпечаток"). Var factorial = function fac(n) { return n < 2 ? 1: n * fac(n - 1); };
console.log(factorial(3));
Функции вида "function definition expression" удобны, когда функция передается аргументом другой функции. Следующий пример показывает функцию map , которая должна получить функцию первым аргументом и массив вторым. Function map(f, a) {
var result = , // Create a new Array
i;
for (i = 0; i != a.length; i++)
result[i] = f(a[i]);
return result;
}
В следующим коде наша функция принимает функцию, которая является function definition expression, и выполняет его для каждого элемента принятого массива вторым аргументом. Function map(f, a) {
var result = ; // Create a new Array
var i; // Declare variable
for (i = 0; i != a.length; i++)
result[i] = f(a[i]);
return result;
}
var f = function(x) {
return x * x * x;
}
var numbers = ;
var cube = map(f,numbers);
console.log(cube);
Функция возвращает: . В JavaScript функция может быть объявлена с условием. Например, следующая функция будет присвоена переменной myFunc только, если num равно 0: Var myFunc;
if (num === 0) {
myFunc = function(theObject) {
theObject.make = "Toyota";
}
}
В дополнение к объявлениям функций, описанных здесь, Вы также можете использовать конструктор Function для создания функций из строки во время выполнения (runtime
), подобно . Метод
- это функция, которая является свойством объекта. Узнать больше про объекты и методы можно по ссылке: Работа с объектами . Объявление функции не выполняет её. Объявление функции просто называет функцию и указывает, что делать при вызове функции. Вызов
функции фактически выполняет указанные действия с указанными параметрами. Например, если Вы определите функцию square , Вы можете вызвать её следующим образом: Square(5);
Эта инструкция вызывает функцию с аргументом 5. Функция вызывает свои инструкции и возвращает значение 25. Функции могут быть в области видимости, когда они уже определены, но функции вида "function declaration statment" могут быть подняты (поднятие -
hoisting
), также как в этом примере: Console.log(square(5));
/* ... */
function square(n) { return n * n; }
Область видимости функции - функция, в котором она определена, или целая программа, если она объявлена по уровню выше. Примечание:
Это работает только тогда, когда объявлении функции использует вышеупомянутый синтаксис (т.е. function funcName(){}). Код ниже не будет работать. Имеется в виду то, что поднятие функции работает только с function declaration и не работает с function expression. Console.log(square); // square поднят со значением undefined.
console.log(square(5)); // TypeError: square is not a function
var square = function(n) {
return n * n;
}
Аргументы функции не ограничиваются строками и числами. Вы можете передавать целые объекты в функцию. Функция show_props() (объявленная в Работа с объектами) является примером функции, принимающей объекты аргументом. Функция может вызвать саму себя. Например, вот функция рекурсивного вычисления факториала: Function factorial(n) {
if ((n === 0) || (n === 1))
return 1;
else
return (n * factorial(n - 1));
}
Затем вы можете вычислить факториалы от одного до пяти следующим образом: Var a, b, c, d, e;
a = factorial(1); // a gets the value 1
b = factorial(2); // b gets the value 2
c = factorial(3); // c gets the value 6
d = factorial(4); // d gets the value 24
e = factorial(5); // e gets the value 120
Есть другие способы вызвать функцию. Существуют частые случаи, когда функции необходимо вызывать динамически, или поменять номера аргументов функции, или необходимо вызвать функцию с привязкой к определенному контексту. Оказывается, что функции сами по себе являются объектами, и эти объекты в свою очередь имеют методы (посмотрите объект ). Один из них это метод , использование которого может достигнуть этой цели. (function scope)
Переменные объявленные в функции не могут быть доступными где-нибудь вне этой функции, поэтому переменные (которые нужны именно для функции) объявляют только в scope функции. При этом функция имеет доступ ко всем переменным и функциям, объявленным внутри её scope. Другими словами функция объявленная в глобальном scope имеет доступ ко всем переменным в глобальном scope. Функция объявленная внутри другой функции ещё имеет доступ и ко всем переменным её родителькой функции и другим переменным, к которым эта родительская функция имеет доступ.
// Следующие переменные объявленны в глобальном scope
var num1 = 20,
num2 = 3,
name = "Chamahk";
// Эта функция объявленна в глобальном scope
function multiply() {
return num1 * num2;
}
multiply(); // вернет 60
// Пример вложенной функции
function getScore() {
var num1 = 2,
num2 = 3;
function add() {
return name + " scored " + (num1 + num2);
}
return add();
}
getScore(); // вернет "Chamahk scored 5"
(function stack)
Функция может вызывать саму себя. Три способа такого вызова: Для примера рассмотрим следующие функцию: Var foo = function bar() {
// statements go here
};
Внутри функции (function body
) все следующие вызовы эквивалентны: Функция, которая вызывает саму себя, называется рекурсивной функцией
(recursive function
). Получается, что рекурсия аналогична циклу (loop
). Оба вызывают некоторый код несколько раз, и оба требуют условия (чтобы избежать бесконечного цикла, вернее бесконечной рекурсии). Например, следующий цикл: Var x = 0;
while (x < 10) { // "x < 10" - это условие для цикла
// do stuff
x++;
}
можно было изменить на рекурсивную функцию и вызовом этой функции: Function loop(x) {
if (x >= 10) // "x >= 10" - это условие для конца выполения (тоже самое, что "!(x < 10)")
return;
// делать что-то
loop(x + 1); // рекурсионный вызов
}
loop(0);
Однако некоторые алгоритмы не могут быть простыми повторяющимися циклами. Например, получение всех элементов структуры дерева (например, ) проще всего реализуется использованием рекурсии: Function walkTree(node) {
if (node == null) //
return;
// что-то делаем с элементами
for (var i = 0; i < node.childNodes.length; i++) {
walkTree(node.childNodes[i]);
}
}
В сравнении с функцией loop , каждый рекурсивный вызов сам вызывает много рекурсивных вызовов. Также возможно превращение некоторых рекурсивных алгоритмов в нерекурсивные, но часто их логика очень сложна, и для этого потребуется использование стека (stack
). По факту рекурсия использует stach: function stack. Поведение stack"а можно увидеть в следующем примере: Function foo(i) {
if (i < 0)
return;
console.log("begin: " + i);
foo(i - 1);
console.log("end: " + i);
}
foo(3);
// Output:
// begin: 3
// begin: 2
// begin: 1
// begin: 0
// end: 0
// end: 1
// end: 2
// end: 3
Вы можете вложить одну функцию в другую. Вложенная функция (nested function
; inner
) приватная (private
) и она помещена в другую функцию (outer
). Так образуется замыкание
(closure
). Closure - это выражение (обычно функция), которое может иметь свободные переменные вместе со средой, которая связывает эти переменые (что "закрывает" ("close"
) выражение). Поскольку вложенная функция это closure, это означает, что вложенная функция может "унаследовать" (inherit
) аргументы и переменные функции, в которую та вложена. Другими словами, вложенная функция содержит scope внешней ("outer"
) функции. Подведем итог: Следующий пример показывает вложенную функцию: Function addSquares(a, b) {
function square(x) {
return x * x;
}
return square(a) + square(b);
}
a = addSquares(2, 3); // возвращает 13
b = addSquares(3, 4); // возвращает 25
c = addSquares(4, 5); // возвращает 41
Поскольку вложенная функция формирует closure, Вы можете вызвать внешную функцию и указать аргументы для обоих функций (для outer и innner). Function outside(x) {
function inside(y) {
return x + y;
}
return inside;
}
fn_inside = outside(3); // Подумайте над этим: дайте мне функцию,
// который передай 3
result = fn_inside(5); // возвращает 8
result1 = outside(3)(5); // возвращает 8
Обратите внимание, значение x сохранилось, когда возвращалось inside . Closure должно сохранять аргументы и переменные во всем scope. Поскольку каждый вызов предоставляет потенциально разные аргументы, создается новый closure для каждого вызова во вне. Память может быть очищена только тогда, когда inside уже возвратился и больше не доступен. Это не отличается от хранения ссылок в других объектах, но часто менее очевидно, потому что не устанавливаются ссылки напрямую и нельзя посмотреть там. Функции можно вкадывать несколько раз, т.е. функция (A) хранит в себе функцию (B), которая хранит в себе функцию (C). Обе фукнкции B и C формируют closures, так B имеет доступ к переменным и аргументам A, и C имеет такой же доступ к B. В добавок, поскольку C имеет такой доступ к B, который имеет такой же доступ к A, C ещё имеет такой же доспут к A. Таким образом cloures может хранить в себе несколько scope; они рекурсивно хранят scope функций, содержащих его. Это называется chaining
(chain - цепь
; Почему названо "chaining" будет объяснено позже) Рассмотрим следующий пример: Function A(x) {
function B(y) {
function C(z) {
console.log(x + y + z);
}
C(3);
}
B(2);
}
A(1); // в консоле выведится 6 (1 + 2 + 3)
В этом примере C имеет доступ к y функции B и к x функции A . Так получается, потому что: В обратном порядке, однако, это не верно. A не имеет доступ к переменным и аргументам C , потому что A не имеет такой доступ к B . Таким образом, C остается приватным только для B . Когда два аргумента или переменных в scope у closure имеют одинаковые имена, происходит конфликт имени
(name conflict
). Более вложенный (more inner
) scope имеет приоритет, так самый вложенный scope имеет наивысший приоритет, и наоборот. Это цепочка областей видимости (scope chain
). Самым первым звеном является самый глубокий scope, и наоборот. Рассмотрим следующие: Function outside() {
var x = 5;
function inside(x) {
return x * 2;
}
return inside;
}
outside()(10); // возвращает 20 вместо 10
Конфликт имени произошел в инструкции return x * 2 между параметром x функции inside и переменной x функции outside . Scope chain здесь будет таким: { inside ==> outside ==> глобальный объект (global object
)}. Следовательно x функции inside имеет больший приоритет по сравнению с outside , и нам вернулось 20 (= 10 * 2), а не 10 (= 5 * 2). (Closures)
Closures это один из главных особенностей JavaScript. JavaScript разрешает вложенность функций и предоставляет вложенной функции полный доступ ко всем переменным и функциям, объявленным внутри внешней функции (и другим переменным и функцим, к которым имеет доступ эта внешняя функция). Однако, внешняя функция не имеет доступа к переменным и функциям, объявленным во внутренней функции. Это обеспечивает своего рода инкапсуляцию для переменных внутри вложенной функции. Также, поскольку вложенная функция имеет доступ к scope внешней функции, переменные и функции, объявленные во внешней функции, будет продолжать существовать и после её выполнения для вложенной функции, если на них и на неё сохранился доступ (имеется ввиду, что переменные, объявленные во внешней функции, сохраняются, только если внутренняя функция обращается к ним). Closure создается, когда вложенная функция как-то стала доступной в неком scope вне внешней функции. Var pet = function(name) { // Внешняя функция объявила переменную "name"
var getName = function() {
return name; // Вложенная функция имеет доступ к "name" внешней функции
}
return getName; // Возвращаем вложенную функцию, тем самым сохраняя доступ
// к ней для другого scope
}
myPet = pet("Vivie");
myPet(); // Возвращается "Vivie",
// т.к. даже после выполнения внешней функции
// name сохранился для вложенной функции
Более сложный пример представлен ниже. Объект с методами для манипуляции вложенной функции внешней функцией можно вернуть (return
). Var createPet = function(name) {
var sex;
return {
setName: function(newName) {
name = newName;
},
getName: function() {
return name;
},
getSex: function() {
return sex;
},
setSex: function(newSex) {
if(typeof newSex === "string" && (newSex.toLowerCase() === "male" ||
newSex.toLowerCase() === "female")) {
sex = newSex;
}
}
}
}
var pet = createPet("Vivie");
pet.getName(); // Vivie
pet.setName("Oliver");
pet.setSex("male");
pet.getSex(); // male
pet.getName(); // Oliver
В коде выше переменная name внешней функции доступна для вложенной функции, и нет другого способа доступа к вложенным переменным кроме как через вложенную функцию. Вложенные переменные вложенной функции являются безопасными хранилищами для внешних аргументов и переменных. Они содержат "постоянные" и "инкапсулированные" данные для работы с ними вложенными функциями. Функции даже не должны присваиваться переменной или иметь имя. Var getCode = (function() {
var apiCode = "0]Eal(eh&2"; // A code we do not want outsiders to be able to modify...
return function() {
return apiCode;
};
}());
getCode(); // Returns the apiCode
Однако есть ряд подводных камней, которые следует учитывать при использовании замыканий. Если закрытая функция определяет переменную с тем же именем, что и имя переменной во внешней области, нет способа снова ссылаться на переменную во внешней области. Var createPet = function(name) { // The outer function defines a variable called "name".
return {
setName: function(name) { // The enclosed function also defines a variable called "name".
name = name; // How do we access the "name" defined by the outer function?
}
}
}
Объект arguments функции является псевдо-массивом. Внутри функции Вы можете ссылаться к аргументам следующим образом: Arguments[i]
где i - это порядковый номер аргумента, отсчитывающийся с 0. К первому аргументу, переданному функции, обращаются так arguments . А получить количество всех аргументов - arguments.length . С помощью объекта arguments Вы можете вызвать функцию, передавая в неё больше аргументов, чем формально объявили принять. Это очень полезно, если Вы не знаете точно, сколько аргументов должна принять Ваша функция. Вы можете использовать arguments.length для определения количества аргументов, переданных функции, а затем получить доступ к каждому аргументу, используя объект arguments . Для примера рассмотрим функцию, которая конкатенирует несколько строк. Единственным формальным аргументом для функции будет строка, которая указывает символы, которые разделяют элементы для конкатенации. Функция определяется следующим образом: Function myConcat(separator) {
var result = "";
var i;
// iterate through arguments
for (i = 1; i < arguments.length; i++) {
result += arguments[i] + separator;
}
return result;
}
Вы можете передавать любое количество аргументов в эту функцию, и он конкатенирует каждый аргумент в одну строку.
// возвращает "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");
Т.к. arguments является псевдо-массивом, к нему применимы некоторые методы массивов, например, for .. in Function func() {
for (value in arguments){
console.log(value);
}
}
func(1, 2, 3);
// 1
// 2
// 3
Примечание:
arguments является псевдо-массивом, но не массивом. Это псевдо-массив, в котором есть пронумерованные индексы и свойство length . Однако он не обладает всеми методами массивов. На введение стрелочных функций повлияли два фактора: более короткие функции и лексика this . В некоторый функциональных паттернах приветствуется использование более коротких функций. Сравните: Var a = [
"Hydrogen",
"Helium",
"Lithium",
"Beryllium"
];
var a2 = a.map(function(s) { return s.length; });
console.log(a2); // logs
var a3 = a.map(s => s.length);
console.log(a3); // logs
До стрелочных функций каждая новая функция определяла свое значение this (новый объект в случае конструктора, undefined в strict mode, контекстный объект, если функция вызвана как метод объекта, и т.д.). Это оказалось раздражающим с точки зрения объектно-орентированного стиля программирования. Function Person() {
// Конструктор Person() определяет `this` как самого себя.
this.age = 0;
setInterval(function growUp() {
// Без strict mode функция growUp() определяет `this`
// как global object, который отличается от `this`
// определенного конструктором Person().
this.age++;
}, 1000);
}
var p = new Person();
В ECMAScript 3/5 эта проблема была исправлена путем присвоения значения this переменной, которую можно было бы замкнуть. Function Person() {
var self = this; // Некоторые выбирают `that` вместо `self`.
// Выберите что-то одно и будьте последовательны.
self.age = 0;
setInterval(function growUp() {
// The callback refers to the `self` variable of which
// the value is the expected object.
self.age++;
}, 1000);
}
Смотрите также Function в Справочнике JavaScript для получения дополнительной информации по функции как объекту. В этой статье описаны функции Javascript на уровне языка: создание, параметры, приемы работы, замыкания и многое другое. Существует 3 способа создать функцию. Основное отличие в результате их работы - в том, что именованная функция видна везде, а анонимная - только после объявления: В javascript функции являются полноценными объектами встроенного класса Function. Именно поэтому их можно присваивать переменным, передавать и, конечно, у них есть свойства: Function f() {
...
}
f.test = 6
...
alert(f.test) // 6
Свойства функции доступны и внутри функции, так что их можно использовать как статические переменные. Например, Function func() {
var funcObj = arguments.callee
funcObj.test++
alert(funcObj.test)
}
func.test = 1
func()
func()
В начале работы каждая функция создает внутри себя переменную arguments и присваивает arguments.callee ссылку на себя. Так что arguments.callee.test - свойство func.test , т.е статическая переменная test. В примере нельзя было сделать присвоение: Var test = arguments.callee.test
test++
так как при этом операция ++ сработала бы на локальной переменной test , а не на свойстве test объекта функции. Объект arguments также содержит все аргументы и может быть преобразован в массив (хотя им не является), об этом - ниже, в разделе про параметры. Каждая функция, точнее даже каждый запуск функции задает свою индивидуальную область видимости. Переменные можно объявлять в любом месте. Ключевое слово var задает переменную в текущей области видимости. Если его забыть, то переменная попадет в глобальный объект window . Возможны неожиданные пересечения с другими переменными окна, конфликты и глюки. В отличие от ряда языков, блоки не задают отдельную область видимости. Без разницы - определена переменная внутри блока или вне его. Так что эти два фрагмента совершенно эквивалентны: Заданная через var переменная видна везде в области видимости, даже до оператора var . Для примера сделаем функцию, которая будет менять переменную, var для которой находится ниже. Например: Function a() {
z = 5 // поменяет z локально..
// .. т.к z объявлена через var
var z
}
// тест
delete z // очистим на всякий случай глобальную z
a()
alert(window.z) // => undefined, т.к z была изменена локально
Функции можно запускать с любым числом параметров. Если функции передано меньше параметров, чем есть в определении, то отсутствующие считаются undefined . Следующая функция возвращает время time , необходимое на преодоление дистанции distance с равномерной скоростью speed . При первом запуске функция работает с аргументами distance=10 , speed=undefined . Обычно такая ситуация, если она поддерживается функцией, предусматривает значение по умолчанию:
// если speed - ложное значение(undefined, 0, false...) - подставить 10
speed = speed || 10
Оператор || в яваскрипт возвращает не true/false , а само значение (первое, которое приводится к true). Поэтому его используют для задания значений по умолчанию. В нашем вызове speed будет вычислено как undefined || 10 = 10 . Поэтому результат будет 10/10 = 1 . Второй запуск - стандартный. Третий запуск задает несколько дополнительных аргументов. В функции не предусмотрена работа с дополнительными аргументами, поэтому они просто игнорируются. Ну и в последнем случае аргументов вообще нет, поэтому distance = undefined , и имеем результат деления undefined/10 = NaN (Not-A-Number, произошла ошибка). Непосредственно перед входом в тело функции, автоматически создается объект arguments , который содержит Например, Function func() {
for(var i=0;i Свойство arguments похоже на массив, т.к у него есть длина и числовые индексы. На самом деле arguments не принадлежит классу Array и не содержит его методов, таких как push , pop и других. Если все же хочется воспользоваться этими методами, например, чтобы вызвать другую функцию с теми же аргументами, но кроме первого, можно создать из arguments настоящий массив: Var args = Array.prototype.slice.call(arguments)
// .. теперь args - настоящий массив аргументов..
args.shift()
...
Вызвать функцию для массива аргументов можно при помощи apply: Var func = function(a,b) { alert(a+b) }
var arr =
func.apply(null, arr) // => alert(3)
Функцию легко можно передавать в качестве аргумента другой функции. Например, map берет функцию func , применяет ее к каждому элементу массива arr и возвращает получившийся массив: Var map = function(func, arr) {
var result =
for(var i=0; i Пример использования: Map(run, ) // =
Или можно создать анонимную функцию непосредственно в вызове map:
// анонимная функция утраивает числа
map(function (a) { return a*3 } , ) // =
Бывают функции, аргументы которых сильно варьируются. Например:
// можно указать только часть аргументов
// не указанные - вычисляются или берутся по умолчанию
function resize(toWidth, toHeight, saveProportions, animate) {
// значения по умолчанию
saveProportions = saveProportions || true
animate = animate || true
toHeight = toHeight || ...
}
Вызов с необязательными параметрами приходится делать так: Resize(100, null, null, true)
Чтобы избежать лишних null и сделать код более понятным, используют нечто вроде "keyword arguments", существующих в Python и Ruby. Для этого много параметров пакуют в единый объект: Function resize(setup) {
// значения по умолчанию
var saveProportions = setup.saveProportions || true
var animate = setup.animate || true
var toHeight = setup.toHeight || ...
}
Вызов теперь делается гораздо проще: Var setup = {toWidth: 100, animate: true}
resize(setup)
// или
resize({toWidth: 100, animate: true})
Так - куда понятнее. А если параметров больше 5, то вообще - единственный нормальный способ. Кроме того, с объектом можно удобнее делать последовательности вызовов вроде: Var setup = {toWidth: 100, animate: true, saveProportions: false}
resize(setup)
setup.toWidth = 200
resize(setup)Вложение функций и рекурсия
Массивы аргументов
Предопределенные функции
Таблица 4.9. Предопределенные функции языка JavaScript
Функция
Синтаксис
Описание
eval
eval(выражение)
Обрабатывает строку как код JavaScript
isFinite
isFinite(значение)
Проверяет, что значение является конечным числом
isNaN
isNaN(значение)
Проверяет, что значение не является числом
parseInt
parseInt(строка, система)
Преобразует строку в целое
parseFloat
parseFloat(строка)
Преобразует строку в вещественное число
Number
Number(объект)
Преобразует объект в число
String
String(объект)
Преобразует объект в строку
escape
escape(строка ASCII)
Преобразует строку в последовательность символов
unescape
unescape(строка)
Преобразует последовательность escape-символов в строку
encodeURI
encodeURI(URL в ASCII)
Кодирует URI полностью путем замены символов на их коды UTF-8
encodeURIComponent
encodeURIComponent(URL в ASCII)
Кодирует URI по составным частям путем замены символов на их коды UTF-8
decodeURI
decodeURI(URL в UTF-8)
Раскодирует значение, созданное при помощи encodeURI
decodeURIComponent
decodeURIComponent(URL в UTF-8)
Раскодирует значение, созданное при помощи encodeURIComponent
Объявление функций
Функции вида "function declaration statement"
Функции вида "function definition expression"
Вызовы функций
Область видимости функций
Scope и стек функции
Рекурсия
Вложенные функции (nested functions) и замыкания (closures)
Сохранение переменных
Несколько уровней вложенности функций (Multiply-nested functions)
Конфликты имен (Name conflicts)
Замыкания
Использование объекта arguments
Оставшиеся параметры (Rest parameters)
Более короткие функции
Лексика this
Создание функций
Функции - объекты
Области видимости
Параметры функции
Работа с неопределенным числом параметров
Пример передачи функции по ссылке
Сворачивание параметров в объект
