1. Valeur originale et valeur de référence
La valeur d'origine est stockée dans la pile et la valeur de référence est stockée dans le tas. Tel que le programme :
Copiez le code comme suit :
function Personne (identifiant, nom, âge) {
this.id = identifiant;
this.name = nom ;
this.age = âge;
}
varnum = 10 ;
var bol = vrai ;
var str = "abc";
var obj = nouvel objet ();
var arr = ['a','b','c'];
var person = new Person(100,"La devise de l'idiot",25);
2.indéfini et nul
undefined : La variable est indéfinie ; c'est une valeur exclusive de type Indéfini ;
null : La référence n'est pas allouée ; c'est une valeur exclusive de type Null.
typeof(non défini) == non défini ;
typeof(null) == objet ;
non défini == nul ;
indéfini!==null;
instance nulle d'objet == false ;
instance d'objet non définie == false ;
Bien qu'il existe des types Undefined et Null, l'exemple suivant illustre que ces deux types sont invisibles, ce qui signifie que nous ne pouvons utiliser que leurs valeurs :
alert (instance non définie de non définie);
alert (instance nulle de Null);
3. Pseudo-tableau
Caractéristiques:
1) Possède un attribut de longueur ;
2) Accédez aux données dans l’ordre d’index comme un tableau ;
3) Il n'existe pas de méthodes de manipulation de données spécifiques aux tableaux telles que push, pop, slice...
Les pseudo-tableaux peuvent être convertis en tableaux réels via Array.prototype.slice :
var faceArray = {0 : 'a', 1 : 'b', longueur : 2}//Pseudo-tableau standard ;
var realArray = Array.prototype.slice.call(fakeArray);
Pseudo-tableaux en js : arguments, node.childNodes, document.getElementsByTagName()...
Problème dans IE : node.childNodes dans IE ne peut pas être converti avec slice.
Pseudo-tableau dans Jquery : Jquery lui-même est un pseudo-tableau :
alerte($('.class1').length); alerte($('.class1').[0].tagName);
4. À propos des littéraux de type simple
var a = 1 ; b = vrai, c = "ccc" ;
Les littéraux semblent avoir des types
alerte (type de a); // numéro
alert(typeof b);//booléen
alerte (type de c); // chaîne
Mais cela ne peut pas être mesuré par des instances de.
alert (une instance de Number) // false
alert (une instance d'objet) // false
alert(b instanceof Boolean)//false
alerte (b instance d'objet) // faux
alerte (c instance de chaîne) // faux
alerte (c instance d'objet) // faux
5. L'attribut prototype de la fonction et l'attribut prototype interne de l'instance d'objet
Chaque fonction (constructeur) a un attribut prototype, et chaque instance d'objet a un attribut prototype interne invisible (mozilla le rend public et peut être obtenu via __proto__), qui pointe vers l'attribut prototype du constructeur. propre propriété de prototype, qui forme la chaîne de prototypes. Object est l'objet supérieur, donc toutes les chaînes de prototypes finiront par pointer vers Object.prototype lors de l'accès aux propriétés/méthodes de l'instance d'objet. Commencez la recherche à partir de l'instance d'objet elle-même. Si elle ne peut pas être trouvée, recherchez vers le haut le long de la chaîne de prototypes jusqu'à ce que Object.prototype.prototype == null.
6. Un petit secret du constructeur
Copiez le code comme suit :
var s = nouvelle fonction(){return "sss"};
alerte(s);//[objet Objet]
s = new function(){return new String("sss")};
alerte(s);//sss
Explication de ce code :
Tant que le constructeur après la nouvelle expression renvoie un objet de référence (tableau, objet, fonction, etc.), il écrasera l'objet anonyme créé par new s'il renvoie un type primitif (quand il n'y a pas de retour, il renvoie en fait. le type primitif undefined ), puis l'objet anonyme créé par new est renvoyé.
7. Le processus de création d'objets
Copiez le code comme suit :
fonction Personne(nom){
this.name = nom ;
}
Personne.prototype = {
getName : function(){return this.name}
} ;
var p = new Person('zhangsan');
Décryptez le processus de création de p :
◦Créez un objet obj intégré et initialisez-le ;
◦Pointez le [[Prototype]] interne de p vers Person.prototype ;
◦Utilisez p comme ceci et utilisez le paramètre arguments pour appeler la méthode interne [[Call]] de Person, c'est-à-dire exécuter le corps de la fonction Person et renvoyer la valeur de retour. S'il n'y a pas de retour, undefined est renvoyé ;
◦Si l'étape précédente renvoie un type Objet, renvoyez cette valeur à p, sinon renvoyez obj.
8. Propriétés propres de l'objet et propriétés héritées
Copiez le code comme suit :
fonction Personne(nom){
this.name = nom ;
}
Personne.prototype = {
tapez : 'humain',
getName : function(){return this.name}
} ;
var p = new Person('zhangsan');
alert(p.hasOwnProperty('type'));//false
p.type = 'ren';
alert(p.hasOwnProperty('type'));//true
Le résultat en cours d'exécution est très clair. Les propriétés d'un objet ne peuvent pas modifier la propriété du même nom dans son prototype, mais créeront uniquement une propriété du même nom et lui attribueront une valeur.
9. Processus de création d'objets fonction
Créez un objet objet fn intégré ;
Définissez le [[Prototype]] interne de fn sur Function.prototype ;
Définissez l'attribut interne [[Call]], qui est une méthode implémentée en interne qui gère la logique des appels de fonction. (Simplement compris comme pointant vers le corps de la fonction) ;
Définissez fn.length sur funArgs.length Si la fonction n'a aucun paramètre, définissez fn.length sur 0 ;
Le constructeur de fn.prototype pointe vers fn lui-même ;
Retourner fn.
10.Principe d'instance de
Pour vérifier si a est une instance de B, vous devez vérifier si l'objet pointé par le prototype de B (attribut prototype du constructeur) est sur la chaîne de prototypes de a.
11. Devinettes sur la fonction et l'objet
alert (instance de fonction de fonction); // true
alert (instance de fonction d'objet); // true
alert (instance d'objet de fonction); // true
alert (instance d'objet d'objet); // true
J'y pense depuis longtemps, mais je n'ai pas compris...