Comprendre la relation entre la fonction constructeur du prototype avec la chaîne de quatre prototypes

Tout d'abord: Comment comprendre la même fonction point, les constructeurs et les différences?

1. Le constructeur est une fonction ordinaire, et la manière de créer une fonction normale est pas différent, sauf que la première habitude majuscule de la lettre du constructeur.
2. La différence entre un constructeur et une fonction ordinaire est invoquée de différentes manières, la fonction ordinaire est appelée directement, alors que le besoin constructeur d'utiliser le nouveau mot - clé à l' appel.
   Par exemple: une personne de créer une fonction constructeur et personne

//普通函数
function person(name , age ,gender){
	//创建一个新的对象
	var obj = new Object();
	//向对象中添加属性
	obj.name = name;
	obj.age = age;
	obj.gender = gender;
	obj.sayName = function(){
		alert(this.name);
	};
	//将新的对象返回
	return obj;
}
//普通函数的调用
var obj = person("蜘蛛精",18,"女"); 
console.log(obj);

//构造函数
function Person(name , age , gender){
	this.name = name;
	this.age = age;
	this.gender = gender;
	this.sayName = function(){
		alert(this.name);
	};
}
// 构造函数的调用
var per = new Person("猪八戒",28,"男");
console.log(per);

3. Objet créé par des fonctions ordinaires sont des instances d'objets d'objets créés par le constructeur de son propre instance, mais tous les objets sont descendants d'objets.

Par exemple: Dans l'exemple ci - dessus les résultats semblent sortie de la console de la figure.

4. Une fois sous la forme d'un appel de fonction, c'est la fenêtre, et lorsqu'il est appelé dans le constructeur de la forme, c'est l'objet nouvellement créé.

//普通函数
function fn() {
	console.log(this) //输出的是window
}
//普通函数的调用
var obj = fn()
//构造函数
function Function() {
	console.log(this) //输出的是Function
}
//构造函数的调用
var Fn = new Function()

Deuxièmement: la relation entre le prototype et la chaîne prototype

I, sur le prototype:

1. Toutes les fonctions que nous avons créé, l'analyseur ajoutera une propriété au prototype de la fonction, et la propriété de prototype à un objet, l'objet qui est le prototype de cette fonction, nous pouvons appeler un prototype.
2. Si la fonction est appelée comme un prototype de fonction ordinaire n'a pas d'effet lorsque la fonction est appelée l'objet constructeur, il aura créé une propriété implicite, pointant vers le constructeur de l'objet prototype, nous pouvons être __proto__ accès à la propriété.
3. objet prototype est équivalent à un espace public, toutes les instances du même accès classe peut à l'objet prototype, nous pouvons cibler le contenu sont ensemble commun, unifié à l'objet prototype.

En second lieu, sur la chaîne de prototype:

1. objet Prototype est un objet, il a aussi un prototype, lorsque nous utilisons la propriété ou méthode d'un objet, va lui-même se trouve maintenant s'il y a, l'utilisation directe, sinon passez à l'objet prototype à trouver, si l'objet prototype a est utilisé, sinon passez à trouver le prototype du prototype, formant ainsi une structure de chaîne, nous appelons la chaîne prototype.
2. chaîne de prototype est le prototype de l'objet de premier plan objet, objet prototype d'objet n'est pas un prototype, si vous utilisez une propriété ou méthode d'un objet, la chaîne prototype ne trouve pas toujours le prototype de l'objet, trouver ne pas encore le prototype d'objet non défini est retourné.

La chaîne prototype que l'on appelle est en fait composé d'un objet prototype d'objet prototype d'une structure de chaîne.

En troisième lieu, le prototype du rôle:

• Lorsque vous créez un constructeur, l'objet peut être des propriétés et méthodes partagées, l'unité ajoutée au constructeur de l'objet prototype, il ne faut pas séparément pour chaque objet est ajouté, il ne sera pas une incidence sur la portée globale, vous pouvez faire chaque objet ayant ces propriétés et les méthodes.

Quatrièmement, comment vérifier l'objet contient une seule propriété

• Lorsque l'on utilise à vérifier si l'objet contient une propriété, mais si l'objet ne dispose pas d'un prototype, retourne vrai

console.log("属性名" in 对象名);

Cinquièmement, vérifier si l'objet lui-même contient une propriété

• Si l'objet peut être utilisé hasOwnProperty () pour vérifier l'objet contenant l'attribut lui-même, que lorsque les attributs contenus dans l'objet lui-même, en utilisant cette méthode renvoie true

console.log(对象名.hasOwnProperty("属性名"));

Troisièmement, les fonctions, entre le constructeur de l'objet prototype

• objet prototype de la fonction ordinaire est l'objet prototype d'objet, l'objet prototype objet prototype d' un constructeur est l'objet prototype d'objet. Fonction constructeur ou l' apparence sortie exemplifiées.
  
  ** Note: ** par la propriété du constructeur entre la capture d' écran, nous pouvons voir que les points de propriété du constructeur par défaut à une fonction normale de l'objet prototype où le constructeur objet, et les points de propriété du constructeur à un constructeur de constructeur par défaut personne objet prototype est situé.