Comment renvoyer la valeur du constructeur en javascript

JavaScript est un langage de programmation dynamique, et l'une de ses fonctionnalités importantes est la prise en charge de la programmation orientée objet (POO). Comme d’autres langages de programmation, le constructeur en JavaScript joue un rôle important dans la création d’objets. Les constructeurs définissent non seulement les propriétés et les méthodes d'un objet, mais ils peuvent également renvoyer une valeur lors de la création de l'objet. Cet article présentera des connaissances pertinentes sur les valeurs de retour des constructeurs en JavaScript.

Définition de base du constructeur

Un constructeur est un type spécial de fonction utilisé pour créer de nouveaux objets. En JavaScript, les constructeurs sont nommés commençant par une lettre majuscule, ce qui constitue l'une des différences par rapport aux fonctions ordinaires. Les constructeurs sont généralement utilisés pour initialiser les objets nouvellement créés et attribuer des propriétés et des méthodes aux objets. Dans le code ci-dessous, nous définissons un constructeur appelé Person qui crée un objet humain.

function Person(name, age) {
  this.name = name;
  this.age = age;
  this.sayHello = function() {
    console.log("Hello, my name is " + this.name + ", I am " + this.age + " years old.");
  }
}

Dans le code ci-dessus, Person est un constructeur qui accepte deux paramètres name et age, utilisés pour initialiser un objet humain. Le mot-clé this est utilisé pour pointer vers l'objet en cours de création. Grâce au mot-clé this, nous pouvons spécifier différentes valeurs d'attribut et méthodes pour chaque objet. Les attributs et les méthodes de l'objet ont leurs valeurs correspondantes. La valeur de l'attribut peut être n'importe quel type de valeur, notamment des nombres, des chaînes, des valeurs booléennes, etc. La méthode est généralement une fonction.

Lors de la création d'un objet Person, nous pouvons utiliser la méthode suivante :

var person = new Person("Tom", 20);

Cette ligne de code crée un objet nommé person, utilise le constructeur Person et passe le nom et les paramètres d’âge ont été saisis. Ensuite, nous pouvons appeler la méthode sayHello de l'objet :

person.sayHello(); // 输出：Hello, my name is Tom, I am 20 years old.

Dans le code ci-dessus, nous appelons la méthode sayHello de l'objet personne et générons certaines informations.

La valeur de retour du constructeur

En JavaScript, le constructeur peut avoir une valeur de retour, et la valeur renvoyée peut être de n'importe quel type. Si le constructeur ne renvoie pas explicitement de valeur, un nouvel objet est renvoyé par défaut. Si le constructeur renvoie une valeur normale, la valeur est ignorée et un nouvel objet est renvoyé. Si le constructeur renvoie un objet, cet objet remplace l'objet d'origine créé. Le code suivant illustre différentes situations de valeurs de retour du constructeur :

function Cat(name, age) {
  this.name = name;
  this.age = age;
  this.sayHello = function() {
    console.log("Hello, my name is " + this.name + ", I am " + this.age + " years old.");
  }
  // 返回值为undefined
}

var cat1 = new Cat("Jack", 3);
var cat2 = new Cat("Mimi", 4);

console.log(cat1); // 输出：Cat {name: "Jack", age: 3, sayHello: ƒ}
console.log(cat2); // 输出：Cat {name: "Mimi", age: 4, sayHello: ƒ}

Pour le code ci-dessus, bien que le constructeur Cat ne renvoie pas de valeur à la fin, deux nouveaux objets cat1 et cat2 sont toujours créés, et Propriétés et les méthodes sont correctement définies pour chaque objet.

Ensuite, regardons un exemple de retour d'une valeur normale :

function Dog(name, age) {
  this.name = name;
  this.age = age;
  this.sayHello = function() {
    console.log("Hello, my name is " + this.name + ", I am " + this.age + " years old.");
  }
  return "This is a new dog."; // 返回一个字符串
}

var dog1 = new Dog("Puppy", 1);
var dog2 = new Dog("Teddy", 2);

console.log(dog1); // 输出：Dog {name: "Puppy", age: 1, sayHello: ƒ}
console.log(dog2); // 输出：Dog {name: "Teddy", age: 2, sayHello: ƒ}

Lorsque le constructeur renvoie une chaîne, cela n'affecte pas la création de l'objet. Dans ce cas, la valeur de retour du constructeur est ignorée et un nouvel objet est toujours renvoyé.

Enfin, regardons un exemple de retour d'un objet :

function Car(model, year) {
  this.model = model;
  this.year = year;
  this.engine = {
    cylinders: 4,
    displacement: 2.0,
    horsepower: 200
  };
  return this.engine; // 返回一个对象
}

var car1 = new Car("BMW", 2017);
var car2 = new Car("Mercedes-Benz", 2018);

console.log(car1); // 输出：{cylinders: 4, displacement: 2.0, horsepower: 200}
console.log(car2); // 输出：{cylinders: 4, displacement: 2.0, horsepower: 200}

Dans l'exemple ci-dessus, le constructeur Car renvoie l'objet car1.engine, créant ainsi uniquement un objet moteur Nouvel objet car1. Lorsque l'objet car2 est à nouveau créé en utilisant le même constructeur, le même objet moteur est renvoyé.

Summary

Grâce à l'exemple ci-dessus, nous pouvons voir qu'en JavaScript, le constructeur peut avoir une valeur de retour, et le type de la valeur de retour peut être n'importe quel type, y compris undefined, Valeurs et objets ordinaires. Par défaut, le constructeur renvoie un nouvel objet. Si le constructeur renvoie une valeur non définie (y compris null), la valeur remplacera l'objet d'origine. Comprendre les règles des valeurs de retour du constructeur peut nous aider à mieux comprendre et utiliser les fonctionnalités de programmation orientée objet en 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!