La lecture de cet article nécessite une expérience de programmation dans d'autres langues.
Les types simples en JavaScript incluent:
1. Nombres
2. String
3. Boolean (vrai et faux)
4.
5.
Les autres types sont des objets (nous ne devons pas être confus par la valeur de retour de l'opérateur de type), par exemple:
1. Fonction
2.
3. Expressions régulières
4. Objet (les objets sont naturellement des objets)
Base d'objet
Dans JavaScript, les objets sont des collections de propriétés (les objets sont des tableaux associatifs), chaque propriété comprend:
1. Le nom d'attribut doit être une chaîne
2. La valeur d'attribut peut être n'importe quelle valeur autre que non définie
Créer un objet via un objet littéral:
La copie de code est la suivante:
// Créer un objet vide via l'objet littéral {}
var vide_object = {};
Le nom d'attribut et la valeur d'attribut de l'objet:
La copie de code est la suivante:
var stande = {
// "First-Name" est le nom d'attribut, et "Jerome" est la valeur d'attribut
"Premier-nom": "Jerome",
// "Last-Name" est le nom d'attribut, et "Howard" est la valeur d'attribut
"Last-Name": "Howard"
};
Si le nom d'attribut est un identifiant juridique, les guillemets peuvent être omis:
La copie de code est la suivante:
var flight = {
compagnie aérienne: "Oceanic",
Numéro: 815,
département: {
Iata: "Syd",
Temps: "2004-09-22 14:55",
Ville: "Sydney"
},
arrivée: {
Iata: "lax",
Temps: "2004-09-23 10:42",
Ville: "Los Angeles"
}
};
Jetons un coup d'œil à l'exemple de l'accès à la propriété:
La copie de code est la suivante:
var propriétaire = {name: "name5566"};
propriétaire.name; // "name5566"
propriétaire ["nom"]; // "name5566"
propriétaire.job; // indéfini
propriétaire.job = "coder"; // ou propriétaire ["travail"] = "codeur";
Si le nom d'attribut n'est pas un identifiant légal, il doit être enveloppé dans des devis. La valeur de la propriété qui n'existe pas est non définie. Les objets sont passés par référence plutôt que par valeur:
La copie de code est la suivante:
var x = {};
Var propriétaire = x;
propriétaire.name = "name5566";
x.name; // x.name === "name5566"
Ici x et le propriétaire se réfèrent au même objet.
Les attributs d'un objet peuvent être supprimés à l'aide de l'opérateur de suppression:
La copie de code est la suivante:
supprimer obj.x; // Supprimer l'attribut x de l'objet obj
Prototype de l'objet
Chaque objet est lié à un objet prototype et l'objet peut hériter des attributs de l'objet Prototype. Nous créons un objet via l'objet littéral, dont l'objet prototype est un objet objet.prototype (l'objet objet.prototype lui-même n'a pas d'objet prototype). Lorsque nous créons un objet, nous pouvons définir l'objet prototype de l'objet (puis discuter de la méthode de paramètre spécifique). Lorsque vous essayez d'obtenir (pas de modifier) un attribut d'un objet, si l'objet n'existe pas, JavaScript essaie d'obtenir l'attribut à partir de l'objet prototype de cet objet, s'il n'y a pas un tel attribut dans l'objet prototype, puis consultez l'objet prototype de cet objet prototype, et ainsi de suite jusqu'à l'objet objet.prototype de prototype. Par rapport à l'obtention d'attributs, lorsque nous modifions l'attribut d'un objet, il n'affectera pas l'objet prototype.
Bases fonctionnelles
Les fonctions sont également des objets dans JavaScript, qui sont liés à la fonction.prototype Prototype Object (fonction.prototype liens vers object.prototype). La fonction a une propriété nommée prototype, et sa valeur est un objet. Cet objet a un constructeur de propriétés, et la valeur du constructeur est cette fonction:
La copie de code est la suivante:
var f = fonction () {}
typeof f.prototype; // 'objet'
typeof f.prototype.constructeur; // 'fonction'
f === f.prototype.constructeur; // vrai
Les fonctions sont des objets, vous pouvez utiliser des fonctions comme l'utilisation d'objets, c'est-à-dire que les fonctions peuvent être enregistrées dans des variables et des tableaux, et peuvent être transmises sous forme de paramètres aux fonctions, et les fonctions peuvent être définies dans les fonctions. En tant que note latérale, la fonction a deux propriétés cachées:
1. Le contexte de la fonction
2. Code de fonction
La fonction est créée comme suit:
La copie de code est la suivante:
var f = fonction add (a, b) {
retourner a + b;
}
console.log (f); // sortie [fonction: ajouter]
Le nom de la fonction après la fonction de mot-clé est facultatif. Nous formulons le nom de fonction principalement à plusieurs fins:
1. Pour un appel récursif
2. Les débogueurs, les outils de développement, etc. sont utilisés pour identifier les fonctions
Plusieurs fois, nous n'avons pas besoin de noms de fonction et les fonctions sans noms de fonction sont appelées fonctions anonymes. Une liste de paramètres est enveloppée entre parenthèses. JavaScript ne nécessite pas de correspondance des paramètres réels et des paramètres formels, par exemple:
La copie de code est la suivante:
var add = fonction (a, b) {
retourner a + b;
}
ajouter (1, 2, 3); // Le paramètre réel et le paramètre formel ne correspondent pas
S'il y a trop de paramètres réels, les paramètres réels excédentaires seront ignorés. S'il y a trop peu de paramètres réels, la valeur des paramètres formels non attribuées n'est pas définie. La fonction doit avoir une valeur de retour. Si la valeur de retour n'est pas spécifiée via l'instruction RETOUR, la valeur de retour de la fonction n'est pas définie.
Une fonction et les variables externes auxquelles il accède forment une fermeture. Ceci est le charme clé de JavaScript.
Appels de fonction
Lorsque chaque fonction est appelée, deux paramètres supplémentaires sont reçus:
1.
2. arguments
La valeur de ceci est liée au modèle d'appel spécifique. Il y a quatre modèles d'appel dans JavaScript:
1. Méthode d'appel. Si la propriété d'un objet est une fonction, elle est appelée méthode. Si une méthode est appelée via OM (args), il s'agit d'un objet O (qui peut être vu que ceci et O sont liés uniquement lorsqu'ils sont appelés), par exemple:
La copie de code est la suivante:
var obj = {
valeur: 0,
Incrément: fonction (v) {
this.value + = (typeof v === 'nombre'? V: 1);
}
};
obj.increment (); // ce === OBJ
2. Mode d'appel de fonction. Si une fonction n'est pas la propriété d'un objet, elle sera appelée en fonction, et cela est lié à l'objet global, par exemple:
La copie de code est la suivante:
Message = 'Hello World';
var p = fonction () {
console.log (this.sessage);
}
p (); // Sortie 'Hello World'
Ce comportement est parfois déroutant, voyez un exemple:
La copie de code est la suivante:
obj = {
valeur: 0,
incrément: function () {
var helper = function () {
// ajouter 1 à la valeur de l'objet global
this.value + = 1;
}
// L'assistance est appelée en fonction
// donc c'est un objet global
auxiliaire();
}
};
obj.increment (); // obj.value === 0
Les résultats que nous attendons devraient être:
La copie de code est la suivante:
obj = {
valeur: 0,
incrément: function () {
var that = this;
var helper = function () {
that.value + = 1;
}
auxiliaire();
}
};
obj.increment (); // obj.value === 1
3. Mode d'appel constructeur. Les fonctions qui ont l'intention d'utiliser le nouveau préfixe sont appelées constructeurs, par exemple:
La copie de code est la suivante:
// Le test est appelé constructeur
var test = fonction (string) {
this.Message = String;
}
var myTest = nouveau test ("Hello World");
Une fonction peut être appelée avec une nouvelle (de telles fonctions commencent généralement par la capitalisation). Après avoir ajouté un nouveau, un objet lié à la propriété Prototype de cette fonction sera créé, et cet objet dans le constructeur est cet objet.
4. Appliquer le mode d'appel. La méthode d'application de la fonction est utilisée pour appeler la fonction, qui a deux paramètres, le premier est celui-ci et le second est un tableau de paramètres, par exemple:
La copie de code est la suivante:
var add = fonction (a, b) {
retourner a + b;
}
var ret = add.Apply (null, [3, 4]); // ret === 7
Lors de l'appel de la fonction, nous pouvons accéder à un tableau de classes appelées arguments (tableau JavaScript non réel) qui contient tous les arguments, afin que nous puissions implémenter des paramètres de longueur variable:
La copie de code est la suivante:
var add = function () {
var sum = 0;
pour (var i = 0; i <arguments.length; ++ i) {
sum + = arguments [i];
}
somme de retour;
}
Ajouter (1, 2, 3, 4);
anormal
Parlons maintenant du mécanisme de gestion des exceptions de JavaScript. Nous utilisons l'instruction Throw pour lancer des exceptions et l'instruction Try-Cache pour attraper et gérer les exceptions:
La copie de code est la suivante:
var add = fonction (a, b) {
if (typeof a! == 'nombre' || type de b! == 'nombre') {
// Jetez une exception
lancer {
Nom: «TypeError»,
Message: «Ajouter des nombres de besoins»
};
}
retourner a + b;
}
// attraper et gérer les exceptions
essayer {
ajouter ("sept");
// e est l'objet exceptionnel jeté
} catch (e) {
console.log (e.name + ':' + e.mesage);
}
Ajouter des propriétés aux types JavaScript
Les constructeurs existent dans la plupart des types en JavaScript:
1. Le constructeur de l'objet est l'objet
2. Le constructeur du tableau est un tableau
3. Le constructeur de la fonction est la fonction
4. Le constructeur de la chaîne est une chaîne
5. Le constructeur du nombre est le numéro
6. Le constructeur du booléen est booléen
7. Le constructeur de l'expression régulière est regexp
Nous pouvons ajouter des propriétés (ajouter souvent des méthodes) au prototype du constructeur afin que cette propriété soit disponible pour les variables connexes:
La copie de code est la suivante:
Nombre.prototype.integer = function () {
retourner les mathématiques [ceci <0? «ceil»: «plancher»] (ceci);
}
(1.1) .Integer (); // 1
Portée
JavaScript doit créer des portes via des fonctions:
La copie de code est la suivante:
fonction() {
// ...
} ();
Une fonction anonyme est créée et exécutée ici. Portée pour masquer les variables que vous ne voulez pas être exposées:
La copie de code est la suivante:
var obj = fonction () {
// masquer la valeur, ne peut pas être accessible en externe
Var valeur = 0;
retour {
// seule cette méthode peut modifier la valeur
incrément: function () {
valeur + = 1;
},
// seule cette méthode peut lire la valeur
getValue: function () {
valeur de retour;
}
};
} ();
obj.increment ();
obj.getValue () === 1;
hériter
Il existe de nombreuses façons de mettre en œuvre l'héritage en JavaScript.
Lors de la création d'un objet, nous pouvons configurer l'objet prototype associé à l'objet, et nous faisons:
La copie de code est la suivante:
// Créer un objet O avec son objet prototype {x: 1, y: 2}
var o = object.create ({x: 1, y: 2});
La méthode objet.Create est définie dans ECMAScript 5. Si vous utilisez ECMascript 3, vous pouvez implémenter une méthode de création vous-même:
La copie de code est la suivante:
// Si la méthode objet.Create n'est pas définie
if (typeof object.create! == 'fonction') {
// Créer un objet.Create Méthode
Object.create = function (o) {
var f = function () {};
F.prototype = o;
// Créer un nouvel objet, l'objet prototype de cet objet est o
retourner nouveau f ();
};
}
Grâce à la méthode Object.Create, nous effectuons un héritage basé sur le prototype: un nouvel objet hérite directement des propriétés d'un ancien objet (par rapport à l'héritage basé sur la classe, il n'y a pas besoin de l'existence de la classe ici, et l'objet inhérit directement l'objet). exemple:
La copie de code est la suivante:
var mymammal = {
Nom: «Herb the Mammal»,
get_name: function () {
Renvoie ce.name;
},
dit: function () {
Renvoie ceci.Saying || '';
}
};
// hériter mymammal
var mycat = object.create (mymammal);
mycat.name = 'Henrietta';
mycat.saying = 'meow';
mycat.purr = fonction (n) {
var i, s = '';
pour (i = 0; i <n; i + = 1) {
if (s) {
S + = '-';
}
s + = 'r';
}
retour s;
};
mycat.get_name = function () {
return this.says () + '' + this.name + '' + this.says ();
};
Le code ci-dessus est simple, mais il ne peut pas protéger les membres privés. Nous pouvons utiliser le mode module. En mode module, un certain type d'objet est généré par une fonction et utilise la portée de la fonction pour protéger les membres privés de l'accès externe:
La copie de code est la suivante:
// fonction des mammifères, utilisé pour construire des objets de mammifères
var mammal = fonction (spec) {
// c'est l'objet construit
var that = {};
// La méthode publique get_name est accessible en externe
that.get_name = function () {
// spec.name ne peut pas être accessible directement depuis l'extérieur
return spec.name;
};
// La méthode publique dit peut être accessible en externe
that.says = function () {
// spec.Assayant aucun accès direct à
return spec.saying || '';
};
retourner cela;
};
// Créer un objet de mammifère
var mymammal = mammal ({name: 'herb'});
// Fonction de chat, utilisée pour construire un objet CAT
var cat = fonction (spec) {
spec.saying = spec.saying || 'Miaou';
// Cat hérite de mammifères, alors construisez d'abord l'objet mammifère
var that = mammal (spec);
// ajouter la méthode publique Runr
that.purr = function (n) {
var i, s = '';
pour (i = 0; i <n; i + = 1) {
if (s) {
S + = '-';
}
s + = 'r';
}
retour s;
};
// modifie la méthode publique get_name
that.get_name = function () {
retourne that.says () + '' + spec.name +
'' + that.says ();
retourner cela;
};
};
// Créer un objet chat
var mycat = cat ({nom: 'Henrietta'});
En mode module, l'héritage est réalisé en appelant le constructeur. De plus, nous pouvons également accéder aux méthodes de la classe parent dans la sous-classe:
La copie de code est la suivante:
Object.prototype.superior = fonction (name) {
var that = this, méthode = that [name];
return function () {
Retour Method.Apply (que, arguments);
};
};
var coolcat = fonction (spec) {
// Obtenez la méthode get_name de la sous-classe
var that = cat (spec), super_get_name = that.superior ('get_name');
that.get_name = function (n) {
return 'like' + super_get_name () + 'baby';
};
retourner cela;
};