Datentyp
JavaScript ist eine schwache Sprache, aber nicht ohne Typen. JavaScript kann die folgenden 7 verschiedenen Arten von Werten erkennen:
Grundlegende Datentypen
1.Boolean
2. Number
3. STRING
4. Null
5.undefiniert
6.Symbol
Objekt
1.Array
2.RegExp
3.Date
4.Math
5 ....
Sie können Typeof verwenden, um den Datentyp zu bestimmen. Der Bediener gibt eine Zeichenfolge zurück, aber nicht alle zurückgegebenen Ergebnisse stimmen mit den Erwartungen überein.
Typeof False // "boolean" Typof .2 // "number" Typof nan // "number" TypOf '// "String" Typof Undefined // "Undefined" typef Symbol () // "Symbol" Typeof new Date () // "Objekt" typof [] // "ObjectOf Alert //" Funktion ".
Variable
Verwenden Sie in der Anwendung Variablen, um den Wert zu benennen. Der Name der Variablen wird als Kennungen bezeichnet
Stellungnahme
1. Verwenden Sie das Schlüsselwort var: Funktionsbereich
2. Verwenden
3. Direkter Gebrauch: Globaler Umfang
var Global_var = 1; Funktion fn () {var fn_var = 2; if (fn_var> 10) {lass block_var = 3; global_var2 = 4;}} lass block_var = 3;Deklarieren Sie nur keine Zuordnung, der Standardwert der Variablen ist undefiniert nicht definiert
Das CONT -Schlüsselwort kann unveränderliche Variablen deklarieren und wird auch blockiert. Das Verständnis unveränderlicher Objekte erfordert Aufmerksamkeit
const num = 1; const obj = {prop: 'value'}; num = 2; // Uncortn TypeError: Zuordnung zur konstanten Variablen.OBJ ['prop'] = 'value2'; obj = []; // Uncortn TypeError: Zuordnung zur konstanten Variablen.Variable Verbesserung
JavaScript kann sich auf Variablen beziehen, die später deklariert wurden, ohne unterschiedliche Konzepte zu werfen. Dieses Konzept wird als Variable -Deklaration -Promotion (Hebelung) bezeichnet.
console.log (a); // undefinedvar a = 2;
Äquivalent zu
var a; Konsole.log (a); a = 2;
Funktion
Eine Funktion ist eine Unterroutine, die durch externen Code (oder rekursiv von der Funktion selbst aufgerufen werden kann).
Funktionen definieren
1. Funktionserklärung
2. Funktionsausdrücke
3. Funktionskonstruktor
4. Pfeilfunktion
Funktion fn () {} var fn = function () {} var fn = Neue Funktion (arg1, arg2, ... argn, funcbody) var fn = (param) => {}Argumente
1.Argumente: Ein Array-ähnliches Objekt, das Parameter enthält, die an die aktuelle Ausführungsfunktion übergeben wurden
2.Argumente.Length: Die Anzahl der an die Funktion übergebenen Parameter
3.Argumente.CALLER: Rufen Sie die Funktion auf, die derzeit die Funktion ausführt
4.Argumente.Callee: Die derzeit ausgeführte Funktion wird ausgeführt
Funktion foo () {Rückgabeargumente;} foo (1, 2, 3); // Argumente [3] // {"0": 1, "1": 2, "2": 3}ausruhen
Funktion foo (... args) {return args;} foo (1, 2, 3); // Array [3] // [1, 2, 3] Funktion fn (a, b, ... args) {return args;} fn (1, 2, 3, 4, 5); // Array [3] // [3, 4, 5]Standard
Die Standardwerte können bei der Definition der Parameter der Funktion vereinbart werden.
Funktion fn (a = 2, b = 3) {return a + b;} fn (2, 3); // 5fn (2); // 5fn (); // 5Objekt
Objekte in JavaScript sind variable Schlüsselkollektionen
Objekte definieren
1. wörtlich
2. Konstruktor
var obj = {prop: 'value', fn: function () {}}; var date = new Date ();Konstruktor
Es gibt keinen Unterschied zwischen einem Konstruktor und einer normalen Funktion. Das Aufrufen mit dem neuen Schlüsselwort ist ein Konstruktor. Die Verwendung des Konstruktors kann ein Objekt instanziieren.
Es gibt zwei mögliche Renditen der Funktion
1. Rufen Sie ausdrücklich die Rückkehr an, um die Bewertung des Ausdrucks nach der Rückkehr zurückzusetzen
2. Es wird keine Rückkehr gerufen und undefiniert zurückgegeben
Funktion people (Name, Alter) {this.name = name; this.age = älter;} var people = new people ('byron', 26);Der Konstruktor gibt Wert zurück
1. Kein Rückgabewert
2. Einfacher Datentyp
3. Objekttyp
Der Konstruktor gibt in den ersten beiden Fällen eine Instanz des Konstruktors zurück. Diese Funktion wird durch Instanziierung des Objekts verwendet.
Der dritte Konstruktor führt dasselbe wie die gewöhnliche Funktion und gibt das Ergebnis des Ausdrucks nach der Rückkehr zurück
Prototyp
1. Jede Funktion hat ein Objektattribut des Prototyps, und im Objekt befindet sich ein Konstruktorattribut, das standardmäßig auf die Funktion selbst hinweist.
2. Jedes Objekt hat ein __Proto__ -Attribut, und der Tierkreis verweist auf den Prototyp seines übergeordneten Typs
Funktionsperson (Name) {this.name = name;} Person.Prototype.print = function () {console.log (this.name);}; var p1 = new Person ('Byron'); var p2 = new Person ('Casper'); p1.print (); p2.print ();Dies und Umfang
Der Umfang kann auf beliebte Weise verstanden werden
1. Wer bin ich
2. Welche Art von Reitern habe ich
Wer bin ich beantwortet das?
Der Reiter ist meine lokale Variable
Diese Szene
Normale Funktionen
1. Strikter Modus: undefiniert
2. Non-Strikt-Modus: globales Objekt
3.Node: Global
4. Browser: Fenster
Konstruktor: eine Instanz eines Objekts
Objektmethode: Objekt selbst
Rufen Sie an und bewerben Sie sich
1.Fn.Call (Kontext, arg1, arg2,…, argn)
2.Fn.Apply (Kontext, Args)
Funktion isNumber (obj) {return object.prototype.toString.call (obj) === '[Objektnummer]';}Function.prototype.bind
Bind gibt eine neue Funktion zurück, der Umfang der Funktion ist der Bind -Parameter
Funktion fn () {this.i = 0; setInterval (function () {console.log (this.i ++);}. bind (this), 500)} fn (); () => {}Die Pfeilfunktion ist eine neue Funktion von ES6, die der Funktionsausdruck mit lexikalischer Umfang und dieser Wert abgekürzt wird
Funktion fn () {this.i = 0; setInterval (() => {console.log (this.i ++);}, 500)} fn ();erben
Im JavaScript -Szenario hat die Erbschaft zwei Ziele und die Unterklasse muss die übergeordnete Klasse erhalten:
1. Objekteigenschaften
2. Objektmethode
Funktionserbringe (untergeordnet, übergeordnet) {var _proptotype = Object.create (parent.prototype); _ Proptotype.Constructor = child.Prototype.Constructor; child.Prototype = _proptotype; this.name;} Funktion Englisch (Name, Alter, Sprache) {people.call (dieser, Name, Alter); this.language = Sprache;} erbt (englisch, people); englisch.Prototype.inTroduce = function () {console.log ('hi, i Am' + this.getname (). {People.call (this, Name, Alter); this.language = Sprache;} erbt (chinesisch, people); chinesische. Chinesisch ('Salatöl', 27, 'Chinesisch'); en.Interducuce (); cn.Interducuce ();ES6 -Klasse und Erbschaft
"Strict"; Class People {Constructor (Name, Alter) {this.name = name; this.age = älter;} getName () {return this.name;}} Klasse Englisch erweitert People {Constructor (Name, Alter, Sprache) {Super (Name, Age); this.getName ()); console.log ('i speep' + this.language);}} let en = new English ('Byron', 26, 'English'); en.Inroducuce ();Grammatik
Label -Anweisung
Schleife:
für (var i = 0; i <10; i ++) {für (var j = 0; j <5; j ++) {console.log (j); if (j === 1) {Break Loop;}}} console.log (i);Aussagen und Ausdrücke
var x = {a: 1}; {a: 1} {a: 1, b: 2}Führen Sie die Funktion sofort aus
(function () {} ()); (function () {}) (); [function () {} ()]; ~ function () {} ();! function () {} ();+ function () {} ();- function () {} (); void function () {} (); typeof function () {} (); function () {} (); 1> function () {} ();Erweiterte Funktionen
Funktionen höherer Ordnung sind Funktionen, die Funktionen als Parameter oder Rückgabewerte als Funktionen behandeln.
Rückruffunktion
[1, 2, 3, 4] .foreach (Funktion (Element) {console.log (item);});Schließung
Der Verschluss besteht aus zwei Teilen
1. Funktion
2. Umgebung: Lokale Variablen innerhalb des Umfangs bei der Funktionserstellung
Funktion makeCounter (init) {var init = init || 0; return function () {return ++ init;}} var counter = makeCounter (10); console.log (counter ()); console.log (counter ()); console.log (counter ());Typischer Fehler
for (var i = 0; i < doms.length; i++) {doms.eq(i).on('click', function (ev) {console.log(i);});} for (var i = 0; i < doms.length; i++) {(function (i) {doms.eq(i).on('click', function (ev) {console.log (i);});}) (i);}Faule Funktionen
Funktion eventBIndergenerator () {if (window.adDeVentListener) {Rückgabefunktion (Element, Typ, Handler) {Element.AdDEventListener (Typ, Hander, False);}} else {return function (Element, Typ, Handler) {Element.attachEvent ('}} -Typ, Handler, Handler, Handler (Element), Handler, Handler (Element), Handler, Handler (Element). EventBIndergenerator ();Curry
Eine Möglichkeit, die Verwendung von Teilparametern zu ermöglichen, um Funktionen zu generieren
Funktion iStype (type) {return function (obj) {return object.prototype.toString.call (obj) === '[Objekt' + Typ + ']';}} var isNumber = istype ('number'); console.log (isnumber (1)); console (is iStype ('array'); Konsole.log (Isarray (1)); Konsole.log (Isarray ([1, 2, 3]); Funktion f (n) {return n * n;} Funktion g (n) {return n * 2;} console.log (f (g (5)));Schwanzrekursion
1. Schwanzaufruf bedeutet, dass der letzte Schritt einer Funktion darin besteht, eine andere Funktion aufzurufen
2. Die Funktionsaufruf selbst, die als Rekursion bezeichnet wird
3. Wenn sich der Schwanz selbst nennt, wird er als Schwanzrekursion bezeichnet
Rekursion ist anfällig für "Stack Overflow" -Fehler (Stapelüberlauf)
Funktion factorial (n) {if (n === 1) return 1; return n * factorial (n - 1);} faktorial (5) // 120Aber für die Schwanzrekursion, da es nur einen Aufrufdatensatz gibt, wird der Fehler "Stack Overflow" niemals auftreten
Funktionsfaktor (n, insgesamt) {if (n === 1) Rückgabe Total; Rückgabefaktor (n - 1, n * Total);} Faktorial (5, 1) // 120Currying reduziert die Parameter
Funktion Currying (fn, n) {return function (m) {return fn.call (this, m, n);};Antikurriierung
Function.prototype.uncurry = function () {return this.call.bind (this);};Verallgemeinerung vorantreiben
var push = array.prototype.push.uncurry (); var arr = []; push (arr, 1); push (arr, 2); push (arr, 3); Konsole.log (arr);
Der obige Inhalt ist die vollständige Beschreibung der exquisiten klassischen Beispiele für JavaScript -Sprache (Zusammenstellung), die Ihnen vom Editor vorgestellt wurden. Ich hoffe, es wird für alle hilfreich sein!