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



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



function noisy(f) {
return function(arg) {
console.log("calling with", arg);
var val = f(arg);
console.log("called with", arg, "- got", val);
return val;
};
}
noisy(Boolean)(0);
// → calling with 0
// → called with 0 - got false




  1. Почему вызов функции так шумит? Является ли (булево) приведение? Гипс для чего? возвращаемое значение? или спор? почему бы и нет (Boolean)noisy(0), если это возвращаемое значение. Или noisy ((Boolean) 0), если аргумент является приведенным.



    noisy(Boolean)(0)



  2. Что происходит в эта линия? Где вообще определяется f ()?



    var val = f(arg);


604   4  

4 ответов:

  1. Boolean это функция. Это функция, которую вы вызываете косвенно через noisy. Немного запутанно, я знаю, потому что это похоже на название типа. Но в JavaScript эти изначально ограниченные вещи (Boolean, Number, String, и так далее) являются функциями. Когда вы звоните Boolean (без использования new), он пытается преобразовать аргумент, который вы ему дали, в примитивное значение boolean и возвращает результат. (См.§15.6.1 в городе спекуляция.)

  2. f является именем аргумента в функции noisy.

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

Когда вы это сделаете

noisy(Boolean)(0)
Здесь происходят две вещи. Первый:
// (In effect, we're not really creating a variable...)
var x = noisy(Boolean);

Это дает нам функцию, которая при вызове будет вызывать Boolean с аргументом, который мы ей даем, одновременно выполняя эти console.log операторы. Это и есть функция вы видите, как создается в noisy (return function(arg)...);

Тогда мы называем эту функцию:

x(0);

И вот тогда вы видите вывод консоли. Поскольку Boolean(0) является false, вы видите, что Boolean возвращает это значение.

Вот гораздо более простой пример:

function foo(bar) {
    bar();
}
function testing() {
    alert("testing got called");
}
foo(testing);

Там я передаю функцию testing в foo. Имя аргумента, которое я использую для этого в foo, - bar. Строка bar(); вызывает функцию.

Функция без () является действительной функцией. Функция с () - это вызов функции. Также имейте в виду, что JavaScript-это слабо типизированный язык, поэтому вы не объявляете типы переменных. Я добавил несколько комментариев к вашему примеру, чтобы попытаться помочь.

// We define a function named noisy that takes in an argument named f. We are expecting f to be a function but this isn't enforced till the interpreter throws an error. 
function noisy(f) {
// Noisy returns a single item, an anonymous function. That anonymous function takes in an argument named arg
  return function(arg) {
    console.log("calling with", arg);
// Our anonymous function then takes f (It can use f because its defined inside noisy, see closures for more details) and invokes it with the argument arg and stores the result in a variable named val. 
    var val = f(arg);
    console.log("called with", arg, "- got", val);
// It now returns val
    return val;
  };
}

Тогда noisy (Boolean) (0) работает следующим образом

F-Булева функция

Noisy возвращает такую функцию

function(arg) {
  var val = Boolean(arg);
  return val;
}

Итак, теперь у нас есть

Наша возвращаемая функция (0)

Который выполняет как нормальный, чтобы стать

function(0) {
  var val = Boolean(0); // false
  return val;
}

Я относительно новичок в JS, и я также только что прочитал красноречивый Javascript, и мне стало легче понять, как только я понял вызов функции (отвечая на Ваш пункт 1):

noisy(Boolean)(0);

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

function greaterThan(n) {
  return function(m) { return m > n; };
}
var greaterThan10 = greaterThan(10);
console.log(greaterThan10(11));

Его также можно было бы назвать так:

greaterThan(10)(11);

Я надеюсь, что это проясняет ваше первый вопрос о том, почему он так называется.

По второму вопросу. The f in:

var val = f(arg);

- это функция Boolean, которая была передана в noisy при вводе noisy(Boolean). Затем он был использован в качестве аргумента в функции noisy. Я также не понимал, что Boolean может быть функцией сама по себе, а не просто типом данных. Как уже говорили другие - он преобразует аргумент, который вы ему дали, в логическое значение и возвращает результат.

Поэтому val становится Boolean(arg) который становится Boolean(0), что приводит к false. Если вы попытаетесь вызвать noisy(Boolean)(1);, вы увидите, что он возвращает true. console.log("called with", arg, "- got", val); просто регистрирует аргумент (0 в данном случае) и результат его вычисления (false).

По сути, он изменил Булеву функцию на ту, которая регистрирует аргумент и результат, а также возвращает результат.

Я надеюсь, что это помогает. Просто написание его помогло моему собственному пониманию.

Если у вас все еще есть проблемы с этим, вот как я это понимаю (у меня тоже болела голова..)

function noisy(f) {
    return function(arg) {
        console.log("calling with", arg);
        var val = f(arg);
        console.log("called with", arg, "- got", val);
        return val;
    };
}

noisy(Boolean)(0)

Функция - это просто регулярное значение.Предыдущее предложение-ключ к пониманию того, что здесь происходит.

Наша зашумленная функция(f) является значением. Это то, что он возвращает.

Noisy (f) возвращает функцию, которая принимает аргумент (arg).

Шумный(f) также принимает аргумент (f). Внутренние функции (функции, вызываемые изнутри функций) иметь доступ к переменным и аргументам, которые были переданы внешней функции.

Мы вызываем нашу внешнюю функцию и передаем ей аргумент Boolean. Наша внешняя функция возвращает свою внутреннюю функцию, которая принимает аргумент (0). К пониманию всего вышесказанного должно стать понятно, что шумно(логическое значение(0)) было бы просто передать аргумент, чтобы наша внешняя функция, при этом ничего не передавая внутренней функции, которая возвращается нашей внешней функцией.

Это так просто на самом деле. Теперь, когда мы поймите, трудно поверить, что это вызвало у нас такую головную боль... */`

Comments

    Ничего не найдено.