Constructor de objeto de JavaScript

En los capítulos anteriores, aprendimos cómo crear objetos en JavaScript.

Los ejemplos de los primeros capítulos son limitados. Solo crean un solo objeto.

A veces necesitamos un "modelo" para crear muchos objetos del mismo tipo (ejemplo).

创建“模型”的方法是使用对象构造函数.

一个对象的构造函数可以很容易地创建多个对象（示例）具有相同的属性和方法。

在下面的示例中，function User()是一个对象构造函数：

　　function User(fname, lname, age, loc) {
　　　this.firstName = fname;
　　　this.lastName = lname;
　　　this.age = age;
　　　this.location = loc;
　　}

通过使用new关键字调用构造函数来创建相同类型的对象：

var Seagull = new User("Seagull", "Anna",　22, "New Delhi");
var tarush = new User("Tarush", "Balodhi",　34, "Bihar");

正如您看到的，我们可以通过使用不同的参数调用User构造函数来快速构建大量不同的用户对象。这与JavaScript在其内置构造函数（如Array()和Date()）中使用的模式完全相同。

this关键字

JavaScript有一个特殊的关键字this，您可以在方法中使用它来引用当前对象。

this在对象中使用时，它的值是对象本身。

在构造函数中this没有值。它代替了新对象。创建新对象时，this的值将成为新对象。

向对象添加属性

为了向对象添加新属性，您可以使用赋值运算符（=）将新值分配给属性。

Seagull.weapon = "Sword";

注意：该属性将添加到Seagull中。不要。（不适用于任何其他User对象）。

向对象添加方法

为了向对象添加新方法，您可以使用赋值运算符（=）将新函数分配给属性。

Seagull.greet = function() {
return "Hello World";
};

注意：该方法将被添加到Seagull中。(不指向任何其他User对象)。

向构造函数添加属性

我们不能像向现有对象添加新属性那样，向构造函数添加新属性:

User.weapon = "Sword";

function User(fname, lname, age, loc) {
　　　this.firstName = fname;
　　　this.lastName = lname;
　　　this.age = age;
　　　this.location = loc;
　　　this.weapon = "Sword";
}

有时，我们希望在后期将新属性添加到一个构造函数中，该构造函数将在所有对象(示例)之间共享。答案是原型 del objeto.

向构造函数添加方法

构造函数也可以定义方法。

我们不能像向现有对象添加新方法一样，向构造函数添加新方法。

向对象添加方法必须在构造函数内完成。

function User(fname, lname, age, loc) {
　　　this.firstName = fname;
　　　this.lastName = lname;
　　　this.age = age;
　　　this.location = loc;
　　　this.fullName = function() {
　　　return this.firstName　+　" "　+　this.lastName;
　　　};
}

A veces queremos agregar nuevos métodos a los constructores más tarde, que se compartirán entre todos los objetos (ejemplo). La respuesta es原型 del objeto.

Constructores nativos de JavaScript

JavaScript tiene los siguientes constructores nativos para objetos:

let　x1　= new String();　//un nuevo objeto String.
let　x2　= new Number();　//un nuevo objeto number.
let　x3　= new Boolean();　//un nuevo objeto boolean.
let　x4　= new Object();　//un nuevo objeto Object.
let　x5　= new Array();　//un nuevo objeto Array.
let　x6　= new RegExp();　//un nuevo objeto RegExp.
let　x7　= new Date();　//un nuevo objeto date.
let　x8　= new Function();　//un nuevo objeto de función.

No declare Number, String o Boolean como objetos

Como puedes ver arriba, JavaScript tiene tipos de datos primitivos como objetos: String, Number y Boolean.

No tenemos razón para crear objetos complejos. Porque los valores primitivos son mucho más rápidos.

Siempre considera los números, cadenas o booleanos como valores primitivos. No como objetos.

Declarar estos tipos como objetos reducirá la velocidad de ejecución y producirá resultados inesperados.

var str1　= "New Delhi";
var str2　= new String("New Delhi");
document.write(str1　=== str2);　//　devuelve un error porque str1y str2con diferentes tipos

no se puede comparar el objeto:

var str1　= new String("New Delhi");
var str2　= new String("New Delhi");
document.write(str1　== str2);　//　devuelve un error porque str1y str2con diferentes tipos
document.write(str1　=== str2);　//　r devuelve un error porque str1y str2con diferentes tipos

También se puede hacer así:

• usar {} en lugar de new Object()

• usar "" en lugar de new String()

• usar 0 en lugar de new Number()

• usar false en lugar de new Boolean()

• usar [] en lugar de new Array()

• usar/()/usar new RegExp()

• usar function (){} en lugar de new Function()

let　x1　={};
let　x2　=　"";
let　x3　=　0;
let　x4　=　false;
let　x5　=　[];
let　x6　=　/()/;
let　x7　=　function(){};

Primitivos de cadena y objetos de cadena

Pero también se puede usar la palabra clave new para definir una cadena como objeto: var city = new String("New Delhi");.

En “ Cadenas de JS En el capítulo “Por qué no se debe crear una cadena como objeto” se explica por qué.

Primitivos numéricos y objetos numéricos

Por lo general, los números de JavaScript se crean como valores primitivos: var num = 50;.

Pero también se puede usar la palabra clave new para definir un número como objeto: var num = new Number("0");.50);.

En “ Números de JS En el capítulo “Por qué no se debe crear un número como objeto” se explica por qué.

Primitivos booleanos y objetos booleanos

Por lo general, los valores booleanos de JavaScript se crean como valores primitivos: var x = false;.

Pero también se puede usar la palabra clave new para definir un valor booleano como objeto: var x = new Boolean(false);.

En “ Booleanos de JS En el capítulo “Por qué no se debe crear un valor booleano como objeto” se explica por qué.