Type de données
JavaScript est une langue de type faible , mais ce n'est pas sans types. JavaScript peut reconnaître les 7 types de valeurs différents suivants:
Types de données de base
1.Boolean
2. nombrer
3.
4.
5.
6. symbole
Objet
1.Assurez-vous
2.Regexp
3.Date
4.Matter
5 ....
Vous pouvez utiliser le type OF pour déterminer le type de données. L'opérateur renvoie une chaîne, mais tous les résultats renvoyés ne sont pas conformes aux attentes.
typeof false // "boolean" typeof .2 // "nombre" typeof nan // "nombre" typeof '' // "string" typeof undefined // "undefined" typeof symbol () // "symbol" typeof date () // "objet" typeof [] // "objet" typeof alert // "funde" null // "objet" typeof not_defined_var // "undofef null //" Object "Typeof Not_Defined_var //" unfined Null // "Objet"
variable
Dans l'application, utilisez des variables pour nommer la valeur. Le nom de la variable est appelé identificateurs
déclaration
1. Utilisez le mot-clé var: portée de la fonction
2. Utilisez le mot-clé Selt: Block Scope Variable locale
3. Utilisation directe: portée globale
var global_var = 1; fonction fn () {var fn_var = 2; if (fn_var> 10) {let block_var = 3; global_var2 = 4;}}Ne déclarer aucune affectation, la valeur par défaut de la variable n'est pas définie
Le mot-clé Const peut déclarer des variables immuables et est également bloqué dans la portée. La compréhension des objets immuables nécessite une attention
Cons num = 1; const obj = {prop: 'value'}; num = 2; // non apparié TypeError: affectation à la variable constante.obj ['prop'] = 'value2'; obj = []; // non apparenté TypeError: affectation à une variable constante.Amélioration variable
JavaScript peut faire référence aux variables déclarées plus tard sans lancer différents concepts. Ce concept est appelé promotion de la déclaration variable (histin)
console.log (a); // UndefinedVar a = 2;
Équivalent à
var a; console.log (a); a = 2;
fonction
Une fonction est un sous-programme qui peut être appelé par un code externe (ou récursivement appelé par la fonction elle-même).
Définir les fonctions
1. Déclaration de fonction
2. Expressions de fonction
3. Constructeur de fonction
4. Fonction de flèche
fonction fn () {} var fn = fonction () {} var fn = new function (arg1, arg2, ... argn, funcbody) var fn = (param) => {}arguments
1. Arguments: un objet de type tableau qui contient des paramètres transmis à la fonction d'exécution actuelle
2.Arguments.Length: Le nombre de paramètres transmis à la fonction
3.Arguments.Caller: Appelez la fonction qui exécute actuellement la fonction
4. arguments.Callee: la fonction actuellement exécutée
fonction foo () {return arguments;} foo (1, 2, 3); // Arguments [3] // {"0": 1, "1": 2, "2": 3}repos
fonction foo (... args) {return args;} foo (1, 2, 3); // Array [3] // [1, 2, 3] fonction fn (a, b, ... args) {return args;} fn (1, 2, 3, 4, 5); // Array [3] // [3, 4, 5]défaut
Les valeurs par défaut peuvent être convenues lors de la définition des paramètres de la fonction.
fonction fn (a = 2, b = 3) {return a + b;} fn (2, 3); // 5FN (2); // 5fn (); // 5Objet
Les objets en JavaScript sont des collections à clé variable
Définir les objets
1. Littéral
2. Constructeur
var obj = {prop: 'value', fn: function () {}}; var date = new Date ();Constructeur
Il n'y a pas de différence entre un constructeur et une fonction normale. Appeler avec le nouveau mot-clé est un constructeur. L'utilisation du constructeur peut instancier un objet.
Il y a deux retours possibles de la fonction
1. Appelez explicitement le retour pour retourner l'évaluation de l'expression après le retour
2. Aucun retour n'est appelé et retourné indéfini
Fonction People (nom, âge) {this.name = name; this.age = age;} var peuple = new People ('Byron', 26);Le constructeur renvoie la valeur
1. Aucune valeur de retour
2. Type de données simple
3. Type d'objet
Le constructeur renvoie une instance du constructeur dans les deux premiers cas. Cette fonctionnalité est utilisée en instanciant l'objet.
Le troisième constructeur exécute la même chose que la fonction ordinaire et renvoie le résultat de l'expression après le retour
prototype
1. Chaque fonction a un attribut d'objet de prototype, et il y a un attribut de constructeur dans l'objet, qui pointe la fonction elle-même par défaut.
2. Chaque objet a un attribut __proto__, et le zodiac pointe le prototype de son type de parent
fonction personne (name) {this.name = name;} personne.prototype.print = fonction () {console.log (this.name);}; var p1 = new personne ('byron'); var p2 = new personne ('casper'); p1.print (); p2.print ();ceci et la portée
La portée peut être comprise de manière populaire
1. Qui suis-je
2. Quel genre de cavaliers ai-je
Qui suis-je répondu à ceci
Le cavalier est ma variable locale
Cette scène
Fonctions normales
1. Mode strict: non défini
2. Mode non stricte: objet global
3.NODE: Global
4. Browser: fenêtre
Constructeur: une instance d'un objet
Méthode d'objet: Objet lui-même
Appeler et appliquer
1.Fn.Call (Context, Arg1, Arg2,…, Argn)
2.Fn.Apply (contexte, args)
fonction isNumber (obj) {return object.prototype.tostring.call (obj) === '[numéro d'objet]';}Function.prototype.bind
Bind renvoie une nouvelle fonction, la portée de la fonction est le paramètre de liaison
fonction fn () {this.i = 0; setInterval (function () {console.log (this.i ++);}. bind (this), 500)} fn (); () => {}La fonction Arrow est une nouvelle fonctionnalité fournie par ES6, c'est l'expression de la fonction abrégée, avec une portée lexicale et cette valeur
fonction fn () {this.i = 0; setInterval (() => {console.log (this.i ++);}, 500)} fn ();hériter
Dans le scénario JavaScript, l'héritage a deux buts et la sous-classe doit obtenir la classe parent:
1. Propriétés de l'objet
2. Méthode d'objet
Fonction hérite (enfant, parent) {var _proptotype = object.create (parent.prototype); _ proptotype.constructor = child.prototype.constructor; child.prototype = _proptotype;} fonction des gens (nom, âge) {this.name = name; this.age = age;} People.pototype. this.name;} fonction anglais (nom, âge, langue) {People.Call (this, nom, âge); this.language = langue;} hérite (anglais, peuple); anglais.prototype.introduce = function () {console.log ('Hi, je suis' + this.getName ()); console.log ('i speak {People.Call (ce, nom, âge); this.language = langue;} hérite (chinois, peuple); chinois.prototype.introduce = function () {console.log ('Hello, je suis' + this.getName ()); console.log ('j'ai dit' + this.Language);} var en = new English ('' byron ', 26,'); VAR Cn = var cn = Chinois («huile de salade», 27, «chinois»); en.introduce (); cn.introduce ();Classe ES6 et héritage
"Utiliser Strict"; classe People {Constructor (name, age) {this.name = name; this.age = age;} getName () {return this.name;}} class English étend les gens {constructeur (nom, age, langue) {super (nom, âge); this.language = language;} introdu () {console.log ('hi, je suis' + this.getName ()); console.log ('je parle' + this.language);}} let en = new anglais ('byron', 26, 'anglais'); en.introduce ();grammaire
étiquette
boucle:
for (var i = 0; i <10; i ++) {for (var j = 0; j <5; j ++) {console.log (j); if (j === 1) {Break Loop;}}} console.log (i);Déclarations et expressions
var x = {a: 1}; {a: 1} {a: 1, b: 2}Exécutez la fonction immédiatement
(function () {} ()); (function () {}) (); [function () {} ()]; ~ function () {} () ;! function () {} (); + function () {} (); - function () {} (); delete function () {} (); nouveau fonction () {} (); nouvelle fonction () {} (); function () {} (); 1> function () {} ();Fonctions avancées
Les fonctions d'ordre supérieur sont des fonctions qui traitent les fonctions comme des paramètres ou des valeurs de retour en fonction.
Fonction de rappel
[1, 2, 3, 4] .ForEach (fonction (item) {console.log (item);});Fermeture
La fermeture se compose de deux parties
1. Fonction
2. Environnement: variables locales dans la portée lors de la création de la fonction
fonction makeCounter (init) {var init = init || 0; return function () {return ++ init;}} var counter = makeCounter (10); console.log (compteur ()); console.log (compteur ()); console.log (compteur ());Erreur typique
pour (var i = 0; i <dom.length; i ++) {doms.eq (i) .on ('click', fonction (ev) {console.log (i);});} pour (var i = 0; i <dom.length; i ++) {(ev) (i) {dom.eq (i) .on ('click', fonction (ev) {console.log (i);});}) (i);}Fonctions paresseuses
fonction eventBinderGenerator () {if (window.addeventListener) {return function (élément, type, handler) {element.addeventListener (type, hanlder, false);}} else {return function (élément, type, handler) {element.attachevent ('on' + type, handler.bind (élément, window.event));}}} EventBinderGenerator ();Curry
Un moyen de permettre l'utilisation de paramètres partiels pour générer des fonctions
function isType (type) {return function (obj) {return object.prototype.tostring.call (obj) === '[objet' + type + ']';}} var isNumber = istype ('nombre'); console.log (isNumber (1)); console.log (isNumber (s ')); istype ('array'); console.log (isArray (1)); console.log (isArray ([1, 2, 3])); fonction f (n) {return n * n;} fonction g (n) {return n * 2;} console.log (f (g (5)); function tuyRécursivité de la queue
1. L'appel de queue signifie que la dernière étape d'une fonction consiste à appeler une autre fonction
2. La fonction s'appelle, appelée récursivité
3. Si la queue s'appelle, elle s'appelle la récursivité de la queue
La récursivité est sujette aux erreurs de "débordement de pile" (pile déborde)
fonction factorielle (n) {if (n === 1) renvoyer 1; retour n * factoriel (n - 1);} factoriel (5) // 120Mais pour la récursivité de la queue, car il n'y a qu'un seul enregistrement d'appel, l'erreur "Stack Overflow" ne se produira jamais
fonction factorielle (n, total) {if (n === 1) return total; return factorial (n - 1, n * total);} factoriel (5, 1) // 120Le curry réduit les paramètres
Fonction Currying (fn, n) {return function (m) {return fn.call (this, m, n);};} function tailfactorial (n, total) {if (n === 1) return total; return tailfactorial (n - 1, n * total);} const factorial = currying (tailfactorie, 1); factoriel (5) //120Anti-contournement
Function.prototype.uncurry = function () {return this.call.bind (this);};généralisation de la poussée
var push = array.prototype.push.uncurry (); var arr = []; push (arr, 1); push (arr, 2); push (arr, 3); console.log (arr);
Le contenu ci-dessus est la description complète des exemples classiques exquis du langage JavaScript (compilation) présentés par l'éditeur. J'espère que ce sera utile à tous!