Répertoire d'articles
对象的创建方法
var obj = {}plainObject objet littéral / objet direct- Constructeur
- Le constructeur intégré du système
new Object() - Fonction personnalisée
new FunctionName()
- Le constructeur intégré du système
Les fonctions personnalisées sont nommées avec une grande casse de chameau (toutes les premières lettres sont en majuscule)
构造函数内部原理
- Ajoutez implicitement this = () à l'avant du corps de la fonction
- Exécutez this.xxx = xxx;
- Renvoyer implicitement ceci
Peut également passer des paramètres
function Car(number){
// this = {};
this.date = 2020;
this.number = number;
//return this;
}
new car1 = new Car(1);
包装类
- nouveau numéro()
- nouvelle chaîne ()
- new Boolean ()
Le type d'origine n'a pas d'attributs ni de méthodes
, et devient en fait automatiquement une classe wrapper lorsqu'il est appelé
//包装类
var a = 1;
a.abc = 2;
// 不忍心报错 自动执行
// new Number(1).len = 2; delete 执行完又删除了
console.log(a.len); // undefined
// 发现访问属性又自动创建 new Number(4).len 是空的
La chaîne a la propriété .length et le
processus est le même que ci-dessus
var str = 'abcd';
str.length = 2;
// nwe String('abcd').length = 2; delete
console.log(str); // 4
// new String('abcd').length 本身这个属性是存在的
ps. Du Yi "Object, Packaging (Part 2)" exercices dans la seconde moitié
原型
.prototype - Le prototype est un ancêtre
Person.prototype.name= 'hello';
function Person{
}
var a = new Person();
console.log(a.name); // 输出 hello 继承自原型
Le prototype est aussi un objet peut être écrit comme ça
Person.prototype = {
name : 'hello'
}
...
方别写很多
Mais il y a une légère différence mentionnée plus tard
定义
Le prototype est un attribut de l'objet fonction, qui définit l'ancêtre commun
de l'objet produit par le constructeur. L'objet produit par le constructeur peut hériter des propriétés et des méthodes du
prototype. Le prototype est aussi un objet.
功能
Réduisez la duplication du code et
insérez des parties communes dans le prototype
修改原型
L'ajout, la suppression, la modification et la vérification
ne peuvent exécuter directement que des opérations de prototype
Ne peut pas être utilisé par les éléments enfants
function Father(){
this.num = 1;
}
var father = new Father();
Son.prototype = father;
function Son(){
}
var son = new Son();
son.num = 2;
//son.num ++; 同
console.log(father.num); // 1
Cela équivaut à ajouter un nouvel attribut num à son. L'attribut de
père n'a pas été modifié ou modifié (erreur),
mais cela peut être fait
function Father(){
this.num = 1;
this.say = {
name : 'niko'
}
}
var father = new Father();
Son.prototype = father;
function Son(){
}
var son = new Son();
son.say.name = 'dio'; // 二次调用 .name
console.log(son.say.name); // dio
Une modification réussie ne peut modifier que les attributs de la méthode, ce qui équivaut à un deuxième appel
constructor
Le prototype du système a un attribut de constructeur et
renvoie un constructeur,
mais il peut être modifié manuellement
_proto_
_proto_Pointez sur le prototype,
connectez le prototype et le sous-objet,
trouvez l'attribut dans _proto_ après avoir trouvé l'attribut
_proto_Le prototype stocké par défaut
mais peut être modifié
La différence entre les deux écritures
Faites une différence dans la deuxième modification
Person.prototype.name = 'hello';
function Person(){
// 系统自动执行 var this = {_proto_ : Person.prototype}
}
var person = new Person();
//两种修改方式
// 1. Person.prototype.name = 'wow';
// 2. Person.prototype = {
// name : 'wow'
// }
-
Une modification réussie équivaut à changer directement les données dans l'espace
-
Person.prototype.name est toujours
la vague de bonjour. Cette vague est de créer un nouvel espace. Notez que le commentaire dans le constructeur fait référence à la direction de _proto_ pour
une meilleure compréhension:
var obj = {
name : 'a'};
var obj1 = obj ;
obj = {
name : 'b'}; // obj1 指向的还是a
Person.prototype = {
name : 'a'};
_proto_ = Person.prototype;
Person.prototype = {
name : 'b'};
Espace changé
1 Changer la propriété dans la pièce
2 Changer la pièce directement
Notez la commande tout à l'heure! !
Person.prototype.name = 'hello';
function Person(){
// 系统自动执行 var this = {_proto_ : Person.prototype}
}
Person.prototype = {
name : 'wow'
}
var person = new Person();
Maintenant, modifiez avec succès le nouveau à l'arrière
Chaîne de prototype
Je n’ai pas besoin d’en dire plus sur la composition de la chaîne de prototypes.
Ajouter, supprimer, modifier
Identique au prototype ci-dessus
cette petite connaissance
Son.prototype = {
name : 'niko',
sayName : function (){
console.log(this.name);
}
}
function Son () {
this.name = 'dio';
}
var son = new Son(); // dio
cela indique la personne qui a appelé la méthode ici est l'appel du fils
Object.create (prototype)
Construction plus pratique
var obj = {
name : 'sunny' , age : 123};
var obj1 = Object.create(obj); // obj1 原型就是obj 可以使用name和age
等同于
Obj.prototype.name = 'sunny';
function Obj() {
}
var obj1 = new Obj();
//var obj1 = Object.creat(Obj.prototype); 和上面相等 构造函数是空的就一样
Le plus terminal de la plupart des objets est Object.prototype
Le prototype de terminal de chaîne Object.prototype
a des méthodes telles que toString (la classe wrapper a également son propre toString)
Notez que dans la plupart des cas, il existe des cas particuliers. Le
prototype peut être nul lorsqu'il est construit avec Object.creat ()
var obj = Object.creat(null);
Il n'y a pas de propriété dans la méthode Object.prototype
définie sur null après l'ajout de personnes _proto_ne peuvent pas utiliser
(doute au coucher) _proto_et .prototype
réécriture toString
123.toStringLe point d'erreur est reconnu comme un nombre à virgule flottante et affecté à la variable
. La chaîne toString de 123 est appelée à l'aide d'un montant intermédiaire . Il s'agit de la méthode propre à Number au lieu d'Object.
var num = 123;
num.toString(); --> // new Number(num).toString();
Number.prototype.toString = function(){
} --> 有自己的toString
Number.prototype._proto_=Object.prototype
Cette situation est appelée 方法重写: La méthode du même nom implémente différentes fonctions z
est couverte à l'avant de la chaîne prototype
ToSting (); la méthode est appelée lorsque document.write (xx); est appelé
Précision hors sujet
La plage que js peut calculer normalement est de 16 chiffres avant la virgule décimale et de 16 chiffres après la virgule décimale
appeler / postuler
Fonction Changement de ce point Le
but est de changer le this dans la fonction d'exécution en objet passé, la
différence étant que la liste de paramètres est différente.
var name = "1";
var obj = {
name:2,
prop: {
name:3,
getName: function() {
return this.name;
}
}
}
console.log(obj.prop.getName()); //3
console.log(obj.prop.getName.call(obj)); //2
console.log(obj.prop.getName.call(this)); //1 在全局的this 是window
Si vous voulez obtenir 3 directement obj.prop.getName (), l'objet courant de cette méthode est prop
Si nous voulons obtenir 2, nous pouvons obj.prop.getName.call (obj) c'est passer l'objet obj à la méthode, cette fois, cet objet est obj, this.name est équivalent à obj.name
1 est le même que obj.prop.getName.call (this) où c'est la page actuelle et la fenêtre est la même
Bien sûr, vous pouvez également utiliser apply. La différence entre apply et call est call, c'est-à-dire que la méthode call accepte une liste de plusieurs paramètres, tandis que la méthode apply accepte un tableau contenant plusieurs paramètres. apply (thisargs, []) utilise un tableau pour passer des paramètres à la méthode, call (this, param1, param2); un petit exemple ci-dessous
function callTest(name, price) {
console.info(name + "-" + price);
}
callTest.call(this, 'superbing', 100);
callTest.apply(this, ['superbing', 200]);
Exemple pratique
借用别人的函数实现自己的功能
function Person(name,age,sex){
this.name = name;
this.age = age;
this.sex = sex; // Person的this
}
function Student(name,age,sex,tel,grade){
// var this ={} 等待赋值
Person.call(this,name,age,sex);
this.tel = tel;
this.grade = grade;
}
var student = new Student('sunny',123,'male',139,2017);
Passez l'objet Student à Person pour que ce dans Person fasse réellement référence à la variable dans Student, ce qui
équivaut à prendre les trois phrases de Person à Student. Il est
abrégé lorsque la structure des autres est complètement en ligne avec vous-même.
prototype et proto
C'est bon