Функции, возвращающие функцию

Я застрял с концепцией «Функции, возвращающие функции». Я имею в виду книгу Стояна Стефанова «Объектно-ориентированный Javascript».

Фрагмент первый:

    function a() {
      
        alert('A!');
    
        function b(){
            alert('B!'); 
        }
    
        return b();
    }
    
    var s = a();
    alert('break');
    s();

Вывод:

A!
B!
break

Фрагмент два

function a() {
  
    alert('A!');

    function b(){
        alert('B!'); 
    }

    return b;
}

var s = a();
alert('break');
s();

A!
break
B!

Может ли кто-нибудь сказать мне разницу между возвратом bи b()приведенными выше фрагментами?

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

Демо

function a() {
    alert('A');
}
//alerts 'A', returns undefined

function b() {
    alert('B');
    return a;
}
//alerts 'B', returns function a

function c() {
    alert('C');
    return a();
}
//alerts 'C', alerts 'A', returns undefined

alert("Function 'a' returns " + a());
alert("Function 'b' returns " + b());
alert("Function 'c' returns " + c());

В вашем примере вы также определяете функции внутри функции. Такие как:

function d() {
    function e() {
        alert('E');
    }
    return e;
}
d()();
//alerts 'E'

Функция по-прежнему вызывается. Он все еще существует. Это постоянно используется в JavaScript. Функции можно передавать так же, как и другие значения. Учтите следующее:

function counter() {
    var count = 0;
    return function() {
        alert(count++);
    }
}
var count = counter();
count();
count();
count();

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

Возврат имени функции без ()возвращает ссылку на функцию, которую можно присвоить так же, как вы сделали с var s = a(). snow содержит ссылку на функцию b(), и вызов s()функционально эквивалентен вызову b().

// Return a reference to the function b().
// In your example, the reference is assigned to var s
return b;

Вызов функции с помощью ()в операторе return выполняет функцию и возвращает любое значение, возвращенное функцией. Это похоже на вызов var x = b();, но вместо того, чтобы присваивать возвращаемое значение, b()вы возвращаете его из вызывающей функции a(). Если сама функция b()не возвращает значение, вызов возвращается undefinedпосле выполнения любой другой работы b().

// Execute function b() and return its value
return b();
// If b() has no return value, this is equivalent to calling b(), followed by
// return undefined;

return b(); вызывает функцию b () и возвращает ее результат.

return b; возвращает ссылку на функцию b, которую вы можете сохранить в переменной для последующего вызова.

Возвращение b - это возврат объекта функции. В Javascript функции - это просто объекты, как и любой другой объект. Если вы сочтете это бесполезным, просто замените слово «объект» на «вещь». Вы можете вернуть любой объект из функции. Вы можете вернуть значение истина / ложь. Целое число (1,2,3,4 ...). Вы можете вернуть строку. Вы можете вернуть сложный объект с несколькими свойствами. И вы можете вернуть функцию. функция - это просто вещь.

В вашем случае возврат bвозвращает вещь, это вызываемая функция. Возврат b()возвращает значение, возвращаемое вызываемой функцией.

Рассмотрим этот код:

function b() {
   return 42;
}

Используя приведенное выше определение, return b();возвращает значение 42. С другой стороны, return b;возвращает функцию, которая сама возвращает значение 42. Это две разные вещи.

Когда вы вернетесь b, это просто ссылка на функцию b, но в настоящее время она не выполняется.

Когда вы возвращаетесь b(), вы выполняете функцию и возвращаете ее значение.

Попробуйте alertING typeof(s)в ваших примерах. Фрагмент b даст вам «функцию». Что даст вам сниппет?

Представьте себе функцию как тип, например int. Вы можете вернуть целые числа в функции. Вы тоже можете возвращать функции, они являются объектом типа «функция».

Теперь проблема синтаксиса: поскольку функции возвращают значения, как вы можете вернуть функцию, а не ее значение?

опуская скобки! Потому что без скобок функция не будет выполняться! Так:

return b;

Вернет «функцию» (представьте, что вы возвращаете число), а:

return b();

Сначала выполняет функцию, а затем возвращает значение, полученное при ее выполнении, это большая разница!

Создайте переменную :

var thing1 = undefined;

Объявить функцию :

function something1 () {
    return "Hi there, I'm number 1!";
}

Предупредить значение из thing1(нашего первых переменного):

alert(thing1); // Outputs: "undefined".

Теперь, если бы мы хотели thing1быть ссылкой на функцию something1, то есть это было бы то же самое, что и наша созданная функция, мы бы сделали:

thing1 = something1;

Однако, если нам нужно return значение функции, мы должны присвоить ему значение, возвращаемое выполненной функцией. Вы выполняете функцию, используя круглые скобки:

thing1 = something1(); // Value of thing1: "Hi there, I'm number 1!" 

Первый фрагмент:

function a() {
  
    alert('A!');

    function b(){
        alert('B!'); 
    }

    return b(); //return nothing here as b not defined a return value
}

var s = a(); //s got nothing assigned as b() and thus a() return nothing.
alert('break');
s(); // s equals nothing so nothing will be executed, JavaScript interpreter will complain

оператор 'b ()' означает выполнение функции с именем 'b', которая отображает диалоговое окно с текстом 'B!'

оператор return b (); означает выполнить функцию с именем 'b' и затем вернуть то, что возвращает функция 'b'. но 'b' ничего не возвращает, тогда и этот оператор 'return b ()' ничего не возвращает. Если b () возвращает число, то return b () также является числом.

Теперь 's' присваивается значение того, что возвращает 'a ()', которое возвращает 'b ()', что является ничем, поэтому 's' - это ничто (в JavaScript это действительно вещь, это 'undefined'. Итак, когда вы просите JavaScript интерпретировать, какой тип данных представляет собой 's', интерпретатор JavaScript сообщит вам, что 's' является неопределенным.) Поскольку 's' является неопределенным, когда вы запрашиваете JavaScript для выполнения этого оператора 's ()', вы просите JavaScript выполнить функцию с именем 's', но 's' здесь означает 'undefined', а не функцию, поэтому JavaScript будет жаловаться: "эй, s не функция, я не знаю, как чтобы сделать с этим s ", то сообщение об ошибке" Uncaught TypeError: s is not a function "будет отображаться с помощью JavaScript (проверено в Firefox и Chrome)

Фрагмент два

function a() {
  
    alert('A!');

    function b(){
        alert('B!'); 
    }

    return b; //return pointer to function b here
}

var s = a();  //s get the value of pointer to b
alert('break');
s(); // b() function is executed

теперь функция 'a' возвращает указатель / псевдоним функции с именем 'b'. поэтому при выполнении 's = a ()' 's' получит значение, указывающее на b, то есть 's' теперь является псевдонимом 'b', вызов 's' равен вызову 'b'. ie 's' теперь функция. Execute 's ()' означает запуск функции 'b' (то же самое, что выполнение 'b ()'), диалоговое окно, показывающее 'B!' появится (т. е. выполнение оператора 'alert (' B! '); в функции' b ')

Это очень полезно в реальной жизни.

Работа с Express.js

Итак, ваш обычный expressмаршрут выглядит так:

function itWorksHandler( req, res, next ) {
  res.send("It works!");
}

router.get("/check/works", itWorksHandler );

Но что, если вам нужно добавить оболочку, обработчик ошибок или что-то еще?

Затем вы вызываете свою функцию из оболочки.

function loggingWrapper( req, res, next, yourFunction ) {
  try {
    yourFunction( req, res );
  } catch ( err ) {
    console.error( err );
    next( err );
  }
}

router.get("/check/works", function( req, res, next ) {
  loggingWrapper( req, res, next, itWorksHandler );
});

Выглядит сложно? Ну как насчет этого:

function function loggingWrapper( yourFunction ) => ( req, res, next ) {
  try {
    yourFunction( req, res, next );
  } catch ( err ) {
    console.error( err );
    next( err );
  }
}

router.get("/check/works", loggingWrapper( itWorksHandler ) );

Посмотрите, в конце вы передаете функцию, loggingWrapperимеющую один аргумент в качестве другой функции itWorksHandler, и loggingWrapperвозвращает новую функцию, которая принимает в req, res, nextкачестве аргументов.