JavaScript Basic Functions_in-Depth Analyse des variables et des lunettes

Définition et appel de la fonction

Définir les fonctions. En JavaScript, la façon de définir les fonctions est la suivante:

 fonction abs (x) {if (x> = 0) {return x;} else {return -x;}}

La fonction ABS () ci-dessus est définie comme suit:

La fonction indique qu'il s'agit d'une définition de fonction;

ABS est le nom de la fonction;

(x) Énumérez les paramètres de la fonction dans les supports, séparés par plusieurs paramètres;

Le code entre {...} est un corps de fonction, qui peut contenir plusieurs instructions, ou même sans aucune instruction.

Remarque: Lorsque l'instruction à l'intérieur du corps de fonction est exécutée, une fois qu'il est exécuté pour retourner, la fonction est exécutée et le résultat est renvoyé. Par conséquent, la détermination et la boucle internes peuvent être mises en œuvre très complexes.

S'il n'y a pas d'instruction de retour, le résultat sera renvoyé après l'exécution de la fonction, mais le résultat n'est pas défini.

Étant donné que la fonction de JavaScript est également un objet, la fonction ABS () définie ci-dessus est en fait un objet de fonction, et le nom de fonction ABS peut être considéré comme une variable pointant vers la fonction.

 var abs = function (x) {if (x> = 0) {return x;} else {return -x;}}

De cette façon, la fonction (x) {...} est une fonction anonyme qui n'a pas de nom de fonction. Cependant, cette fonction anonyme est attribuée à l'ABS variable, de sorte que la fonction peut être appelée via l'ABS variable.

Les deux définitions sont complètement équivalentes. Notez que la deuxième méthode doit en ajouter une à la fin du corps de fonction en fonction de la syntaxe complète, indiquant que l'instruction d'affectation se termine.

Lorsque vous appelez une fonction, passez simplement dans les paramètres dans l'ordre:

ABS (10); // Retour 10

ABS (-9); // retour à 9

Étant donné que JavaScript permet à un paramètre de passer sans être affecté, il n'y a aucun problème à passer plus de paramètres que les paramètres définis, bien que ces paramètres ne soient pas requis dans la fonction.

ABS (10, «blablabla»); // Retour 10

abs (-9, «haha», «hehe», null) // retour à 9

Il n'y a aucun problème avec moins de paramètres que défini

abs (); Retour nan

À l'heure

 fonction abs (x) {if (typeof x! == 'nombre') {throw 'pas un nombre':} if (x> = 0) {return x;} else {return -x;}}

arguments

JavaScript a également des arguments de mots clés gratuits, qui ne fonctionnent que dans la fonction et pointe toujours vers tous les paramètres transmis par l'appelant de la fonction actuelle.

 fonction foo (x) {alert (x); // 10for (var i = 0; i <arguments.length; ++) {alert (arguments [i]); // 10,20,30}} foo (10.20,30)

Avec des arguments, vous pouvez faire passer tous les paramètres par l'appelant. C'est-à-dire que même si la fonction ne définit aucun paramètre, la valeur du paramètre peut toujours être obtenue:

 fonction abs () {if (arguments.length === 0) {return 0;} var x = arguments [0] return x> = 0? x: -x;} abs (); // 0abs (10); // 10abs (-9) // 9

En fait, les arguments sont le plus souvent utilisés pour déterminer le nombre de paramètres entrants. Vous pouvez voir cette écriture:

// foo (a [, b], c)

// Accepte 2 ~ 3 paramètres, B est un paramètre facultatif. Si seulement deux paramètres sont entrés et sortis, B est nul par défaut

 fonction foo (a, b, c) {if (arguments.length === 2) {// Les paramètres réels obtenus sont a et bc sont indéfinisc = b; b = null; // b devient la valeur par défaut

Pour changer le paramètre moyen B en un paramètre "facultatif", vous ne pouvez le juger que par des arguments, puis réajustez les paramètres et attribuer des valeurs.

paramètre de repos

Étant donné que les fonctions JavaScript permettent de recevoir n'importe quel paramètre, nous devons utiliser des arguments pour obtenir tous les paramètres lors de la rencontre des problèmes:

 fonction foo (a, b) {var i, rest = []; if (arguments.length> 2) {for (i = 2; i <arguments.length; i ++) {rest.push (arguments [i]);}} console.log ('a =' + a); console.log ('b =' + b); console.log (repos);};

Afin d'obtenir des paramètres autres que les paramètres définis A et B, nous devons utiliser des arguments, et la boucle commence à partir de l'index 2 pour exclure les deux premiers paramètres. Cette méthode d'écriture est gênante, juste pour obtenir le paramètre de repos supplémentaire. Y a-t-il une meilleure façon?

La norme ES6 introduit le paramètre REST, et la fonction ci-dessus peut être réécrite comme suit:

 fonction foo (a, b, ... rest) {console.log ('a =' + a); console.log ('b =' + b); console.log (rest);} foo (1,2,3,4,5); // résultat // a = 1 // b = 2 // Array [3,4,5] foo (1) // résultat //

Le paramètre de reste ne peut être écrit qu'à la fin et est marqué de ... du résultat de l'exécution. D'après le résultat de l'opération, nous pouvons voir que les paramètres passés sont liés à A, B, et les paramètres supplémentaires sont remis au repos variable dans un tableau, donc,

Nous obtenons tous les paramètres sans nécessiter d'arguments.

Si les paramètres passés ne sont pas remplis de paramètres définis normaux, peu importe, le paramètre de repos recevra un tableau vide (notez qu'il n'est pas défini).

déclaration de retour

Nous avons mentionné plus tôt que le moteur JavaScript avait un mécanisme pour ajouter automatiquement des demi-finales à la fin de la ligne, ce qui peut vous faire tomber dans une grande fosse dans la déclaration de retour:

 fonction foo () {return {name: 'foo'};} foo (); // {nom: 'foo'}

Note:

 fonction foo () {return: // Un demi-colon a été ajouté automatiquement, ce qui est équivalent pour retourner undefined {name: 'foo'}; // Cette ligne d'instruction ne peut plus être exécutée. }

Donc la bonne façon d'écrire plusieurs lignes est

 Fonction foo () {return {// Un point-virgule ne sera pas automatiquement ajouté ici car cela signifie que l'instruction ne s'est pas encore terminée. nom: 'foo'}}

Portée variable

Dans JavaScript, ce qui est déclaré avec VAR est en fait dans la portée.

Si une variable est déclarée à l'intérieur du corps de la fonction, la portée de la variable est le corps de fonction entier et la variable ne doit pas être référencée en dehors du corps de fonction.

 'utiliser strict': fonction foo () {var x = 1; x = x +1;} x = x +2; // ProfenanceError ne peut pas se référer à la variable x en dehors de la fonction

Si deux fonctions différentes déclarent chacune la même variable, la variable ne fonctionne que dans le corps de leurs fonctions respectives. En d'autres termes, les variables avec le même nom au sein de différentes fonctions sont indépendantes les unes des autres et ne se affectent pas mutuellement:

 'use struct': fonction foo () {var x = 1; x = x +1;} function bar () {var x = 'a'; x = x + 'b';}

Étant donné que les fonctions JavaScript peuvent être imbriquées, la fonction interne peut accéder aux variables définies par les fonctions externes, et l'inverse n'est pas:

 'utiliser strict'; fonction foo () {var x = 1; function bar () {var x = 1; function bar () {var y = x +1; // La barre peut accéder à la variable x de foo z = y + 1; // ReferenceError! Foo ne peut pas accéder à la variable y de la barre! }}

Et si les noms variables des fonctions internes et externes sont doublés?

 'utiliser strict': fonction foo () {var x = 1; fonction bar () {var x = 'a'; alert ('x dans bar () =' + x); // 'a'} alert ('x dans foo () =' + x) // 1bar ();}

Amélioration variable

La définition de la fonction de JavaScript a une fonctionnalité, qui analysera d'abord toute l'instruction corporelle de la fonction et "mise à niveau" toutes les variables déclarées en haut de la fonction:

 'utiliser strict'; fonction foo () {var x = 'bonjour,' + y; alert (x); var y = 'bob';} foo ();

Pour la fonction foo () ci-dessus, le code vu par le moteur JavaScript est équivalent à:

 fonction foo () {var y; // soulève le var x de la variable y = 'hello' + y; alert (x); y = 'bob';}

En raison de cette étrange "caractéristique" de JavaScript, lorsque nous définissons les variables à l'intérieur d'une fonction, veuillez respecter strictement la règle "pour déclarer toutes les variables d'abord dans une fonction". Le moyen le plus courant consiste à utiliser un VAR pour déclarer toutes les variables utilisées en interne dans la fonction:

 fonction foo () {var x = 1, // x est initialisé à 1y = x +1, // y est initialisé à 2z, i; // z et je suis indéfini // Autres instructions pour (i = 0; i <100; i ++) {...}}

Portée mondiale

Les variables non définies dans aucune fonction ont une portée globale. En fait, JavaScript a une variable étendue globale par défaut qui est en fait liée à une propriété de la fenêtre.

 «utiliser strict»; var source = «Learn javascript»; alert (cours); // 'apprendre javascript'; alert (window.course); // 'apprendre javascript'

Espace de noms

Les variables globales seront liées à la fenêtre. Différents fichiers JavaScript utilisent les mêmes variables globales, ou ont le même nom de fonctions de niveau supérieur, ce qui entraînera

Nommer les conflits et est difficile à détecter.

Une façon de réduire les conflits est de lier toutes vos variables et fonctions dans une variable globale.

 // la seule variable quju myAppvar myApp = {}; // autres variables: myApp.name = 'myApp'; myApp.version = 1.0; // autres fonctions myApp.foo = function () {return 'foo';};

Mettre tout votre code dans l'espace de noms unique MyApp réduira considérablement la possibilité de conflits de variables mondiales.

Portée locale

Étant donné que la portée variable de JavaScript est en fait à l'intérieur d'une fonction, nous ne pouvons pas définir des variables qui ne peuvent pas être définies dans des blocs d'instruction tels que pour les boucles.

 fonction foo () {for (var i = 0; i <100; i ++) {//} i + = 100; // Les variables peuvent toujours être référencées;}

Pour résoudre la portée au niveau du bloc, ES6 a introduit un nouveau mot-clé LET, et au lieu de VAR, vous pouvez déclarer une variable de portée au niveau du bloc:

 fonction foo () {var sum = 0; for (soit i = 0; i <100; i ++) {sum + = i;} i + = 1;}

constante

Puisque var et laissez déclarer des variables, si vous souhaitez déclarer une constante, cela ne fonctionnera pas avant ES6. Nous utilisons généralement toutes les variables de capital pour indiquer qu'il s'agit d'une constante

Ne modifiez pas sa valeur.

var pi = 3,14;

La norme ES6 introduit un nouveau mot clé const pour définir les constantes, à la fois Const et Let As Are au niveau du bloc;

const pi = 3,14;

Pi = 3; // Certains navigateurs ne signalent pas les erreurs, mais n'ont aucun effet.

PI; // 3.14

L'analyse de base JavaScript de base de JavaScript_in des variables et de la portée est tout le contenu que je partage avec vous. J'espère que vous pourrez vous faire référence et j'espère que vous pourrez soutenir Wulin.com plus.