Quelles sont les étapes de ce programme JavaScript prend

Question

Quelqu'un peut-il s'il vous plaît expliquer les étapes de ce programme prend et l'ordre dans lequel elles sont prises afin de produire le résultat « false »

function negate(func) { 
    return function(x) { 
    return !func(x); 
    }; 
} 
var isNotNaN = negate(isNaN); 
show(isNotNaN(NaN)); 

Answer 1

// 1. A function called "negate is declared 
function negate(func) { // 3. The "isNaN" function is received by negate(). 

    return function(x) { // 4. A function is returned from the negate() call 
    return !func(x);  //  that invokes the "isNaN" function, and returns 
    };      //  the logical opposite of its return value. 

} 

        // 2. The built in "isNaN" function is passed to negate() 
var isNotNaN = negate(isNaN); 
// 5. The function returned from negate() is assigned to the "isNotNaN" variable 

     // 6. The "isNotNaN" function is invoked, and passed the "NaN" value. 
show(isNotNaN(NaN)); 
// 7. The result returned from "isNotNaN" is passed to the show() function. 

Le résultat final est que vous avez une fonction qui retourne à l'opposé de la fonction isNaN.

Apparemment, vous pouvez appeler isNaN avec !.

show(!isNaN(NaN)); // gives the same result 

Answer 2

lorsque vous appelez la Négation fonction cela crée une fermeture autour de la fonction que vous y passez. donc quand vous appelez isNotNaN, il exécute en fait isNaN qui a été inclus dans la fonction et l'annule ensuite avec l'opérateur booléen not "!".

Answer 3

1. Définit la fonction negate().
2. Définit la variable isNotNaN pour le retour de negate(isNaN).
3. negate() renvoie une fonction, tout en conservant la portée à func (dans ce cas isNaN).
4. Appelez show() avec isNotNan(NaN) (en passant pas un nombre à la négation de isNaN). Identique à (! isNaN(NaN)).

Answer 4

Le code définit une fonction « négation » qui prend comme paramètre une autre fonction. La fonction "negate" elle-même renvoie encore une autre fonction, qui retourne le booléen opposé au résultat de l'appel de la fonction parameter sur le paramètre passé.

Ensuite, le code définit une variable, "isNotNan", et la définit comme égale au résultat de l'appel de "negate" avec une fonction (que nous ne voyons pas ici) appelée "isNaN". Appelant que fonction avec la constante NaN est effectivement le même que d'appeler !isNaN(NaN), qui est false car NaN est NaN.

Answer 5

function negate(func) { 
    return function(x) { 
    return !func(x); 
    }; 
} 
var isNotNaN = negate(isNaN); 
show(isNotNaN(NaN)); 

permet de démarrer à partir du haut:

function negate(func) 
{ 
    ... 
} 

déclare une fonction avec un paramètre negatefunc. La fonction retourne une fonction anonyme:

function(x) 
{ 
    return !func(x); 
} 

La fonction anonyme exécutera la fonction fournie dans le paramètre func de la fonction d'origine, mais nier la vaule de retour.

Ensuite isNotNaN est défini comme une fonction qui retourne true lorsque le paramètre est pasNaN et false lorsque le paramètre estNaN;

var isNotNaN = negate(isNaN); 

Enfin NaN est jeté dans la fonction renvoyant le résultat attendu de false

show(isNotNaN(NaN));