A quoi sert new en javascript

En JavaScript, l'opérateur new est utilisé pour créer une instance d'objet personnalisée ou une instance de l'objet intégré d'un constructeur ; l'instance créée par new peut accéder aux propriétés du constructeur Person.

L'environnement d'exploitation de ce tutoriel : système Windows 10, JavaScript version 1.8.5, ordinateur Dell G3.

Quelle est l'utilisation de new en javascript ?

Utilisation de new

new : L'opérateur new est utilisé pour créer une instance d'objet personnalisée ou une instance d'un objet intégré au constructeur. Qu’est-ce que cela signifie ? C’est un peu difficile à prononcer. Voyons cela d’abord.

Que s'est-il passé lorsque

new F()

La première version

La châtaigne est là :

function Person(name, age) {
    this.name = name
    this.age = age
    console.log(this) // Person{name: "xuedinge", age: "20"}
}
Person.prototype.have = "cat"
const person = new Person("xuedinge", "20")
console.log(person.name) // xuedinge
console.log(person.have) // cat
console.log(person) // Person{name: "xuedinge", age: "20"}

De cette châtaigne, nous pouvons voir que new a les capacités suivantes :

1 L'instance créée par new peut. Accédez aux propriétés dans le constructeur Person;

2. L'instance créée par new peut accéder aux propriétés du prototype du constructeur

3. New peut lier cela dans le constructeur à l'objet nouvellement créé ; capacités du nouveau d'abord :

function fakeNew(Fn) {
    // 创建一个空对象
    let obj = new Object()
    // 将新对象的原型指针指向构造函数的原型
    obj.__proto__ = Fn.prototype
    // 处理除了 Fn 以外的剩余参数
    Fn.apply(obj, [].slice.call(arguments, 1))
    return obj
}

Jetons un coup d'œil à l'effet

function Person(name, age) {
    this.name = name
    this.age = age
    console.log(this) // Person {name: "xuedinge", age: "20"}
}
Person.prototype.have = "cat"
function fakeNew(Fn) {
    // 创建一个空对象
    let obj = new Object()
    // 将新对象的原型指针指向构造函数的原型
    obj.__proto__ = Fn.prototype
    // 处理除了 Fn 以外的剩余参数
    Fn.apply(obj, [].slice.call(arguments, 1))
    return obj
}
const newPerson = fakeNew(Person, "xuedinge", "20")
console.log(newPerson.name) // xuedinge
console.log(newPerson.have) // 20
console.log(newPerson) // Person {name: "xuedinge", age: "20"}

Il semble être similaire aux capacités du nouveau. Mais à quoi cela ressemble-t-il lorsqu'il y a une valeur de retour dans le constructeur ? Regardez à nouveau ceci :

// 当返回值是对象时：
function Person(name, age) {
    this.name = name
    this.age = age
    console.log(this) // Person {name: "xuedinge", age: "20"}
    return {
      car: "leikesasi"
    }
}
Person.prototype.have = "cat"
const person = new Person("xuedinge", "20")
console.log(person.name) // undefined
console.log(person.have) // undefined
console.log(person.car) // leikesasi
console.log(person) // {car: "leikesasi"}

On peut voir que lorsque la valeur de retour du constructeur est un objet, l'objet instance créé par new est le résultat renvoyé. par le constructeur. Lorsque la valeur de retour est un objet ordinaire, regardez ceci :

// 当返回值是普通值时：
unction Person(name, age) {
    this.name = name
    this.age = age
    console.log(this) // Person{name: "xuedinge", age: "20"}
    return "leikesasi"
}
Person.prototype.have = "cat"
const person = new Person("xuedinge", "20")
console.log(person.name) // xuedinge
console.log(person.have) // cat
console.log(person) // Person{name: "xuedinge", age: "20"}

Lorsque la valeur de retour est un objet ordinaire, le résultat est le même que lorsqu'il n'y a pas de valeur de retour.

Recommandations associées : Tutoriel d'apprentissage Javascript

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!