JavaScript Basic Functions_in-Tiefe Analyse von Variablen und Scopes

Funktionsdefinition und Anruf

Funktionen definieren. In JavaScript ist der Weg, um Funktionen zu definieren, wie folgt:

 Funktion ABS (x) {if (x> = 0) {return x;} else {return -x;}}

Die obige Abs () -Funktion ist wie folgt definiert:

Die Funktion gibt an, dass dies eine Funktionsdefinition ist.

ABS ist der Name der Funktion;

(x) Listen Sie die Parameter der Funktion in Klammern auf, die durch mehrere Parameter getrennt sind.

Der Code zwischen {...} ist eine Funktionskörper, die mehrere Anweisungen oder auch ohne Anweisung enthalten kann.

HINWEIS: Wenn die Anweisung in der Funktionsstelle ausgeführt wird, wird die Funktion ausgeführt und das Ergebnis zurückgegeben. Daher kann die interne Bestimmung und Schleife sehr komplex implementiert werden.

Wenn es keine Rückgabeanweisung gibt, wird das Ergebnis nach Ausführung der Funktion zurückgegeben, das Ergebnis ist jedoch undefiniert.

Da die Funktion von JavaScript auch ein Objekt ist, ist die oben definierte ABS () -Funktion tatsächlich ein Funktionsobjekt, und der Funktionsname ABS kann als eine Variable angesehen werden, die auf die Funktion zeigt.

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

Auf diese Weise ist die Funktion (x) {...} eine anonyme Funktion, die keinen Funktionsnamen hat. Diese anonyme Funktion wird jedoch der Variablen -ABS zugeordnet, sodass die Funktion durch die Variablen -ABS aufgerufen werden kann.

Die beiden Definitionen sind vollständig äquivalent. Beachten Sie, dass die zweite Methode eine am Ende der Funktionskörper nach der vollständigen Syntax hinzufügen muss, was darauf hinweist, dass die Zuweisungsanweisung endet.

Geben Sie beim Aufrufen einer Funktion einfach die Parameter in der Reihenfolge ein:

ABS (10); // Rückkehr 10

ABS (-9); // kehre zu 9 zurück

Da JavaScript es ermöglicht, dass ein Parameter ohne Betroffene übergeben wird, gibt es kein Problem, dass mehr Parameter übergeben werden als definierte Parameter, obwohl diese Parameter in der Funktion nicht erforderlich sind.

ABS (10, 'Blablabla'); // Rückkehr 10

ABS (-9, 'haha', 'hehe', null) // kehre zu 9 zurück

Es gibt kein Problem mit weniger Parametern als definiert

ABS (); Nan zurückgeben

Zu diesem Zeitpunkt empfängt der Parameter x der Abs (x) -Funktion undefinierter und das Berechnungsergebnis ist NAN

 Funktion ABS (x) {if (typeof x!

Argumente

JavaScript verfügt außerdem über kostenlose Keyword -Argumente, die nur innerhalb der Funktion funktioniert und immer auf alle vom Anrufer der aktuellen Funktion übergebenen Parameter verweist.

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

Mit Argumenten können Sie alle vom Anrufer übergebenen Parameter übergeben lassen. Das heißt, auch wenn die Funktion keine Parameter definiert, kann der Wert des Parameters dennoch erhalten werden:

 Funktion ABS () {if (argumente.length === 0) {return 0;} var x = argumente [0] return x> = 0? x: -x;} abs (); // 0abs (10); // 10Abs (-9) // 9

Tatsächlich werden Argumente am häufigsten verwendet, um die Anzahl der eingehenden Parameter zu bestimmen. Sie können dieses Schreiben sehen:

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

// 2 ~ 3 Parameter akzeptieren, B ist ein optionaler Parameter. Wenn nur zwei Parameter eingegeben und beendet werden, ist B standardmäßig null

 Funktion foo (a, b, c) {if (argumente.length ==== 2) {// Die erhaltenen Parameter sind a und bc sind undefinedc = b; b = null; // B wird zum Standardwert

Um den mittleren Parameter B in einen "optionalen" Parameter zu ändern, können Sie ihn nur durch Argumente beurteilen, dann die Parameter neu einstellen und Werte zuweisen.

Ruheparameter

Da JavaScript -Funktionen einen Parameter erhalten können, müssen wir Argumente verwenden, um alle Parameter bei Problemen zu erhalten:

 Funktion foo (a, b) {var i, rest = []; if (Argumente.Length> 2) {für (i = 2; i <argumente.length; i ++) {rest.push (Argumente [i]);}} console.log ('A =' + a); console.log (b = ' + b); console.log (log (';

Um andere Parameter als definierte Parameter A und B zu erhalten, müssen wir Argumente verwenden, und die Schleife beginnt mit Index 2, um die ersten beiden Parameter auszuschließen. Diese Schreibmethode ist umständlich, nur um den zusätzlichen Ruheparameter zu erhalten. Gibt es einen besseren Weg?

Der ES6 -Standard führt den Restparameter ein, und die obige Funktion kann als:

 Funktion foo (a, b, ... rest) {console.log ('a =' + a); console.log ('b =' + b); console.log (rest);} foo (1,2,3,4,5); // result // a = 1 // b = 2 // aray [3,4,5] foo (1) //).

Der Restparameter kann nur am Ende geschrieben werden und ist mit ... aus dem Laufergebnis markiert. Aus dem Betriebsergebnis können wir feststellen, dass die übergebenen Parameter an A, B gebunden sind und die zusätzlichen Parameter an die variable Ruhe in einem Array übergeben werden, also, also,

Wir erhalten alle Parameter, ohne Argumente zu erfordern.

Wenn die übergebenen Parameter nicht mit normalen definierten Parametern gefüllt sind, spielt es keine Rolle, dass der Restparameter ein leeres Array empfängt (beachten Sie, dass es nicht undefiniert ist).

Rückgabeerklärung

Wir haben bereits erwähnt, dass die JavaScript -Engine einen Mechanismus hat, um am Ende der Linie automatisch Semikolonen hinzuzufügen, was dazu führen kann, dass Sie in der Rückkehrerklärung in eine große Grube fallen:

 Funktion foo () {return {name: 'foo'};} foo (); // {name: 'foo'}

Notiz:

 Funktion foo () {return: // Ein Semikolon wurde automatisch hinzugefügt, was gleichwertig ist, undefined {name: 'foo'}; // Diese Zeile der Anweisung kann nicht mehr ausgeführt werden. }

Die richtige Art, mehrere Zeilen zu schreiben

 Funktion foo () {return {// Ein Semikolon wird hier nicht automatisch hinzugefügt, da dies bedeutet, dass die Anweisung noch nicht beendet ist. Name: 'foo'}}

Variabler Umfang

In JavaScript wird das, was mit VAR deklariert wird, tatsächlich Scoped.

Wenn eine Variable innerhalb der Funktionskörper deklariert wird, ist der Umfang der Variablen die gesamte Funktionskörper, und die Variable sollte außerhalb des Funktionsorganisation nicht referenziert werden.

 'strict': function foo () {var x = 1; x = x +1;} x = x +2; // RevenceError kann nicht auf die Variable x außerhalb der Funktion verweisen

Wenn zwei verschiedene Funktionen jeweils dieselbe Variable deklarieren, funktioniert die Variable nur im Körper ihrer jeweiligen Funktionen. Mit anderen Worten, Variablen mit demselben Namen innerhalb verschiedener Funktionen sind unabhängig voneinander und beeinflussen sich nicht gegenseitig:

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

Da JavaScript -Funktionen verschachtelt werden können, kann die interne Funktion auf Variablen zugreifen, die durch externe Funktionen definiert sind, und umgekehrt nicht:

 'Verwenden Sie Strict'; Funktion foo () {var x = 1; Funktion bar () {var x = 1; Funktion bar () {var y = x +1; // Balken kann auf die Variable x von foo z = y + 1 zugreifen; // ReferenzError! Foo kann nicht auf die Variable y der Bar zugreifen! }}

Was ist, wenn die Variablennamen interner und externer Funktionen verdoppelt werden?

 'strict': function foo () {var x = 1; Funktion bar () {var x = 'a'; alert ('x in bar () =' + x); // 'a'} alert ('x in foo () =' + x) // 1bar ();}

Variable Verbesserung

Die Funktionsdefinition von JavaScript hat eine Funktion, mit der zuerst die gesamte Funktionsbody -Anweisung scannt und alle deklarierten Variablen an die Spitze der Funktion "aktualisiert" werden:

 'strict'; Funktion foo () {var x = 'Hallo,'+y; alert (x); var y = 'bob';} foo ();

Für die obige Funktion foo () entspricht der von der JavaScript -Engine beobachtete Code:

 Funktion foo () {var y; // Erhöhen Sie das Var x der Variablen y = 'Hallo' + y; alert (x); y = 'bob';}

Aufgrund dieser seltsamen "Merkmal" von JavaScript halten Sie sich, wenn wir Variablen innerhalb einer Funktion definieren, die Regel "," alle Variablen zuerst innerhalb einer Funktion "zu deklarieren. Die häufigste Möglichkeit ist, einen VAR zu verwenden, um alle in der Funktion verwendeten Variablen zu deklarieren:

 Funktion foo () {var x = 1, // x wird auf 1y = x +1 initialisiert, // y wird auf 2Z initialisiert, i; // z und ich sind undefiniert // andere Anweisungen für (i = 0; i <100; i ++) {...}}

Globaler Umfang

Variablen, die in keiner Funktion definiert sind, haben einen globalen Bereich. Tatsächlich verfügt JavaScript standardmäßig über eine globale Scoped -Variable, die tatsächlich an eine Eigenschaft des Fensters gebunden ist.

 "Verwenden Sie Strict"; var scry = "JavaScript lernen"; alert (kurs); // 'JavaScript lernen'; alert (Fenster.Course); // 'JavaScript lernen'

Namespace

Globale Variablen werden an das Fenster gebunden. Verschiedene JavaScript-Dateien verwenden dieselben globalen Variablen oder haben den gleichen Namen auf obersten Ebenen, was verursacht wird

Konflikten nennen und sind schwer zu erkennen.

Eine Möglichkeit, Konflikte zu reduzieren, besteht darin, alle Ihre Variablen und Funktionen in eine globale Variable zu binden.

 // Die einzige Quju -Variable myAppvar myapp = {}; // Andere Variablen: myapp.name = 'myapp'; myapp.version = 1.0; // Andere Funktionen myapp.foo = function () {return 'foo';};

Wenn Sie Ihren gesamten Code in den eindeutigen Namespace MyApp einfügen, wird die Möglichkeit globaler variabler Konflikte erheblich reduziert.

Lokaler Bereich

Da der variable Umfang von JavaScript tatsächlich in einer Funktion liegt, können wir keine Variablen definieren, die in Anweisungsblöcken wie für Schleifen nicht definiert werden können.

 Funktion foo () {für (var i = 0; i <100; i ++) {//} i+= 100; // Variablen können weiterhin verwiesen werden;}

Um den Umfang auf Blockebene zu lösen, hat ES6 ein neues Schlüsselwort LET eingeführt, und anstelle von VAR können Sie eine Variable auf Blockebene deklarieren:

 Funktion foo () {var sum = 0; für (let i = 0; i <100; i ++) {sum += i;} i += 1;}

Konstante

Da var und lassen Sie Variablen deklarieren, funktioniert dies, wenn Sie eine Konstante deklarieren möchten, nicht vor ES6. Wir verwenden normalerweise alle Kapitalvariablen, um anzuzeigen, dass dies eine Konstante ist

Ändern Sie seinen Wert nicht.

var pi = 3,14;

Der ES6-Standard führt ein neues Schlüsselwort const ein, um Konstanten zu definieren, sowohl konstant als auch let blockpegel.

const pi = 3,14;

Pi = 3; // Einige Browser melden keine Fehler, haben aber keine Wirkung.

PI; // 3.14

Die obige JavaScript-Basisfunktionen_in-Depth-Analyse von Variablen und Umfang ist der gesamte Inhalt, den ich mit Ihnen teile. Ich hoffe, Sie können Ihnen eine Referenz geben und ich hoffe, Sie können wulin.com mehr unterstützen.