Функции

Функции являются одним из самых мощных и важнейших понятий в программировании.

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

Объявление функций

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

function double(x) {
  return 2 * x;
}

К функции выше можно обращаться до её объявления.

В JavaScript функции это также и переменные; они могут храниться в переменных (подобно числам, строкам и др.) и передаваться в другие функции в качестве аргументов:

var double = function(x) {
  return 2 * x;
};

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

Функции высшего порядка

Функции высшего порядка являются функциями, которые управляют другими функциями. Например, функция может принимать другие функции в качестве аргументов и/или задавать функцию в качестве возвращаемого значения. Подобные необычные функциональные методы являются мощными конструкциями, доступными вам в JavaScript и других языках высокого уровня, таких как Python, Lisp и др.

Теперь мы создадим две простые функции add_2 и double, а также функцию высшего порядка с именем map. Функция map будет принимать два аргумента: func и list (поэтому функция объявляется как map(func,list)) и возвращать массив. func (первый аргумент) будет функцией, которая применяется к каждому элементу в массиве list (второй аргумент).

// Определяем две простые функции
var add_2 = function(x) {
  return x + 2;
};
var double = function(x) {
  return 2 * x;
};
  
// map это классная функция, которая принимает два аргумента:
//  func    функция для вызова
//  list    массив значений для вызова из func
var map = function(func, list) {
  var output=[];              // выходной список
  for(idx in list) {
    output.push( func(list[idx]) );
  }
  return output;
}

// Мы используем map чтобы применить функцию ко всему списку
// входящему в map, а затем получить соответствующий выходной список
map(add_2, [5,6,7]) // => [7, 8, 9]
 map(double, [5,6,7]) // => [10, 12, 14]

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

К примеру, если мы замечаем, что используем обращение к map(add_2, ...) и map(double, ...) в нашем коде слишком часто, то можем решить создать две специализированные функции для обработки списков, которые выполняют желаемые операции. Использовать составные функции можно следующим образом:

process_add_2 = function(list) {
  return map(add_2, list);
}
process_double = function(list) {
  return map(double, list);
}
process_add_2([5,6,7]) // => [7, 8, 9]
process_double([5,6,7]) // => [10, 12, 14]

Теперь создадим функцию с именем buildProcessor, которая берёт функцию func в качестве входных данных и возвращает process_func — функцию, которая применяет func к каждому элементу списка.

// функция генерирует обработку списка
var buildProcessor = function(func) {
  var process_func = function(list) {
    return map(func, list);
  }
  return process_func;
}
// buildProcessor возвращает функцию, которая вызывалась вместе со списком
  
// через buildProcessor мы можем генерировать обработчики списка add_2 и double следующим образом:
process_add_2 = buildProcessor(add_2);
process_double = buildProcessor(double);
  
process_add_2([5,6,7]) // => [7, 8, 9]
process_double([5,6,7]) // => [10, 12, 14]

Давайте взглянем на другой пример. Мы создадим функцию с именем buildMultiplier которая берёт число х в качестве входного параметра и возвращает функцию, которая умножает свой аргумент на х:

var buildMultiplier = function(x) {
  return function(y) {
    return x * y;
  }
}
  
var double = buildMultiplier(2);
var triple = buildMultiplier(3);
  
double(3); // => 6
triple(3); // => 9