Hướng dẫn what is the use of new in javascript? - việc sử dụng mới trong javascript là gì?

Question

Toán tử

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

3 cho phép các nhà phát triển tạo một thể hiện của loại đối tượng do người dùng xác định hoặc của một trong các loại đối tượng tích hợp có hàm tạo hàm.
function Foo(bar1, bar2) { this.bar1 = bar1; this.bar2 = bar2; }
3 operator lets developers create an instance of a user-defined object type or of one of the built-in object types that has a constructor function.

Nội dung chính Show

Thông số
Sự mô tả
Loại đối tượng và thể hiện đối tượng
Thuộc tính đối tượng tự nó là một đối tượng khác
Sử dụng function Foo(bar1, bar2) { this.bar1 = bar1; this.bar2 = bar2; } 3 với các lớp
Thông số kỹ thuật
Tính tương thích của trình duyệt web
Việc sử dụng mới là gì?
Tôi có nên sử dụng mới trong JavaScript không?
Mục đích của nhà điều hành mới trong Java là gì?

Thử nó

Cú pháp

new constructor
new constructor()
new constructor(arg1)
new constructor(arg1, arg2)
new constructor(arg1, arg2, /* …, */ argN)

Thông số

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

4

Một lớp hoặc hàm chỉ định loại thể hiện đối tượng.

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

5,

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

6, xông,

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

7

Một danh sách các giá trị mà

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

4 sẽ được gọi với.

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

9 tương đương với

const myFoo = new Foo('Bar 1', 2021);

0, tức là nếu không có danh sách đối số nào được chỉ định,

const myFoo = new Foo('Bar 1', 2021);

1 được gọi mà không có đối số.

Sự mô tả

Khi một hàm được gọi với từ khóa

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

3, hàm sẽ được sử dụng làm hàm tạo.

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

3 sẽ làm những việc sau:function Foo(bar1, bar2) { this.bar1 = bar1; this.bar2 = bar2; }
3 keyword, the function will be used as a constructor.

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

3 will do the following things:

Tạo một đối tượng JavaScript trống, đơn giản. Để thuận tiện, hãy gọi nó là
```
const myFoo = new Foo('Bar 1', 2021);
```
4.

Các điểm ________ 24 [[nguyên mẫu]] cho thuộc tính

const myFoo = new Foo('Bar 1', 2021);

6 của hàm xây dựng, nếu

const myFoo = new Foo('Bar 1', 2021);

6 là

const myFoo = new Foo('Bar 1', 2021);

8. Mặt khác,

const myFoo = new Foo('Bar 1', 2021);

4 vẫn là một đối tượng đơn giản với

function Car() {}
const car1 = new Car();
const car2 = new Car();

console.log(car1.color);    // undefined

Car.prototype.color = 'original color';
console.log(car1.color);    // 'original color'

car1.color = 'black';
console.log(car1.color);    // 'black'

console.log(Object.getPrototypeOf(car1).color); // 'original color'
console.log(Object.getPrototypeOf(car2).color); // 'original color'
console.log(car1.color);   // 'black'
console.log(car2.color);   // 'original color'

0 như [[nguyên mẫu]].

Lưu ý: Do đó, các thuộc tính/đối tượng được thêm vào thuộc tính

const myFoo = new Foo('Bar 1', 2021);

6 của hàm xây dựng có thể truy cập được cho tất cả các trường hợp được tạo từ hàm hàm tạo. Properties/objects added to the constructor function's

const myFoo = new Foo('Bar 1', 2021);

6 property are therefore accessible to all instances created from the constructor function.

Thực thi hàm hàm tạo với các đối số đã cho, liên kết

const myFoo = new Foo('Bar 1', 2021);

4 là bối cảnh

function Car() {}
const car1 = new Car();
const car2 = new Car();

console.log(car1.color);    // undefined

Car.prototype.color = 'original color';
console.log(car1.color);    // 'original color'

car1.color = 'black';
console.log(car1.color);    // 'black'

console.log(Object.getPrototypeOf(car1).color); // 'original color'
console.log(Object.getPrototypeOf(car2).color); // 'original color'
console.log(car1.color);   // 'black'
console.log(car2.color);   // 'original color'

3 (nghĩa là tất cả các tham chiếu đến

function Car() {}
const car1 = new Car();
const car2 = new Car();

console.log(car1.color);    // undefined

Car.prototype.color = 'original color';
console.log(car1.color);    // 'original color'

car1.color = 'black';
console.log(car1.color);    // 'black'

console.log(Object.getPrototypeOf(car1).color); // 'original color'
console.log(Object.getPrototypeOf(car2).color); // 'original color'
console.log(car1.color);   // 'black'
console.log(car2.color);   // 'original color'

3 trong hàm hàm tạo hiện tham khảo

const myFoo = new Foo('Bar 1', 2021);

4).

Nếu hàm hàm tạo trả về không nguyên thủy, giá trị trả về này sẽ trở thành kết quả của toàn bộ biểu thức
```
function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}
```
3. Mặt khác, nếu hàm hàm tạo không trả về bất cứ điều gì hoặc trả về nguyên thủy, thay vào đó,
```
const myFoo = new Foo('Bar 1', 2021);
```
4 sẽ được trả về. .

Các lớp chỉ có thể được khởi tạo với toán tử

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

3 - cố gắng gọi một lớp mà không có

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

3 sẽ ném

function Car(color) {
  if (!new.target) {
    // Called as function.
    return `${color} car`;
  }
  // Called with new.
  this.color = color;
}

const a = Car("red"); // a is "red car"
const b = new Car("red"); // b is `Car { color: "red" }`

0.

Tạo một đối tượng có chức năng xây dựng do người dùng xác định yêu cầu hai bước:

Xác định loại đối tượng bằng cách viết một hàm chỉ định tên và thuộc tính của nó. Ví dụ: hàm tạo hàm để tạo đối tượng
```
const myFoo = new Foo('Bar 1', 2021);
```
1 có thể trông như thế này:
```
function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}
```

Tạo một thể hiện của đối tượng với

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

3.

const myFoo = new Foo('Bar 1', 2021);

Lưu ý: Một đối tượng có thể có một thuộc tính tự nó là một đối tượng khác. Xem các ví dụ dưới đây. An object can have a property that is itself another object. See the examples below.

Bạn luôn có thể thêm một thuộc tính vào một thể hiện đối tượng được xác định trước đó. Ví dụ: câu lệnh

function Car(color) {
  if (!new.target) {
    // Called as function.
    return `${color} car`;
  }
  // Called with new.
  this.color = color;
}

const a = Car("red"); // a is "red car"
const b = new Car("red"); // b is `Car { color: "red" }`

3 thêm một thuộc tính

function Car(color) {
  if (!new.target) {
    // Called as function.
    return `${color} car`;
  }
  // Called with new.
  this.color = color;
}

const a = Car("red"); // a is "red car"
const b = new Car("red"); // b is `Car { color: "red" }`

4 vào

function Car(color) {
  if (!new.target) {
    // Called as function.
    return `${color} car`;
  }
  // Called with new.
  this.color = color;
}

const a = Car("red"); // a is "red car"
const b = new Car("red"); // b is `Car { color: "red" }`

5 và gán cho nó một giá trị là

function Car(color) {
  if (!new.target) {
    // Called as function.
    return `${color} car`;
  }
  // Called with new.
  this.color = color;
}

const a = Car("red"); // a is "red car"
const b = new Car("red"); // b is `Car { color: "red" }`

6.

Tuy nhiên, điều này không ảnh hưởng đến bất kỳ đối tượng nào khác. Để thêm thuộc tính mới vào tất cả các đối tượng cùng loại, bạn phải thêm thuộc tính vào thuộc tính

const myFoo = new Foo('Bar 1', 2021);

6 của hàm tạo. Điều này xác định một thuộc tính được chia sẻ bởi tất cả các đối tượng được tạo với chức năng đó, thay vì chỉ bằng một thể hiện của loại đối tượng. Mã sau đây thêm thuộc tính

function Car(color) {
  if (!new.target) {
    // Called as function.
    return `${color} car`;
  }
  // Called with new.
  this.color = color;
}

const a = Car("red"); // a is "red car"
const b = new Car("red"); // b is `Car { color: "red" }`

4 có giá trị

function Car(color) {
  if (!new.target) {
    // Called as function.
    return `${color} car`;
  }
  // Called with new.
  this.color = color;
}

const a = Car("red"); // a is "red car"
const b = new Car("red"); // b is `Car { color: "red" }`

9 cho tất cả các đối tượng thuộc loại

function Car(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
}

0, sau đó ghi lại giá trị đó bằng chuỗi

function Car(color) {
  if (!new.target) {
    // Called as function.
    return `${color} car`;
  }
  // Called with new.
  this.color = color;
}

const a = Car("red"); // a is "red car"
const b = new Car("red"); // b is `Car { color: "red" }`

6 chỉ trong đối tượng thể hiện

function Car(color) {
  if (!new.target) {
    // Called as function.
    return `${color} car`;
  }
  // Called with new.
  this.color = color;
}

const a = Car("red"); // a is "red car"
const b = new Car("red"); // b is `Car { color: "red" }`

5. Để biết thêm thông tin, xem nguyên mẫu.

function Car() {}
const car1 = new Car();
const car2 = new Car();

console.log(car1.color);    // undefined

Car.prototype.color = 'original color';
console.log(car1.color);    // 'original color'

car1.color = 'black';
console.log(car1.color);    // 'black'

console.log(Object.getPrototypeOf(car1).color); // 'original color'
console.log(Object.getPrototypeOf(car2).color); // 'original color'
console.log(car1.color);   // 'black'
console.log(car2.color);   // 'original color'

Lưu ý: Mặc dù hàm hàm tạo có thể được gọi giống như bất kỳ hàm chính quy nào (nghĩa là không có toán tử

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

3), trong trường hợp này, một đối tượng mới không được tạo và giá trị của
function Car() {} const car1 = new Car(); const car2 = new Car(); console.log(car1.color); // undefined Car.prototype.color = 'original color'; console.log(car1.color); // 'original color' car1.color = 'black'; console.log(car1.color); // 'black' console.log(Object.getPrototypeOf(car1).color); // 'original color' console.log(Object.getPrototypeOf(car2).color); // 'original color' console.log(car1.color); // 'black' console.log(car2.color); // 'original color'
3 cũng khác nhau. While the constructor function can be invoked like any regular function (i.e. without the

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

3 operator), in this case a new object is not created and the value of

function Car() {}
const car1 = new Car();
const car2 = new Car();

console.log(car1.color);    // undefined

Car.prototype.color = 'original color';
console.log(car1.color);    // 'original color'

car1.color = 'black';
console.log(car1.color);    // 'black'

console.log(Object.getPrototypeOf(car1).color); // 'original color'
console.log(Object.getPrototypeOf(car2).color); // 'original color'
console.log(car1.color);   // 'black'
console.log(car2.color);   // 'original color'

3 is also different.

Một chức năng có thể biết liệu nó có được gọi bằng

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

3 hay không bằng cách kiểm tra

function Car(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
}

6.

function Car(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
}

6 chỉ là

function Car(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
}

8 khi hàm được gọi mà không có

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

3. Ví dụ: bạn có thể có một chức năng hoạt động khác nhau khi nó được gọi là so với khi nó được xây dựng:

function Car(color) {
  if (!new.target) {
    // Called as function.
    return `${color} car`;
  }
  // Called with new.
  this.color = color;
}

const a = Car("red"); // a is "red car"
const b = new Car("red"); // b is `Car { color: "red" }`

Trước ES6, trong đó giới thiệu các lớp, hầu hết các bản dựng JavaScript đều có thể gọi và có thể xây dựng, mặc dù nhiều trong số chúng thể hiện các hành vi khác nhau. Đến tên một vài:

const myCar = new Car('Eagle', 'Talon TSi', 1993);

0,

const myCar = new Car('Eagle', 'Talon TSi', 1993);

1 và

const myCar = new Car('Eagle', 'Talon TSi', 1993);

2 hoạt động giống nhau khi được gọi là hàm hoặc hàm tạo.

```
const myCar = new Car('Eagle', 'Talon TSi', 1993);
```
3,
```
const myCar = new Car('Eagle', 'Talon TSi', 1993);
```
4 và
```
const myCar = new Car('Eagle', 'Talon TSi', 1993);
```
5 ép buộc đối số của họ với loại nguyên thủy tương ứng khi được gọi và trả về các đối tượng bao bọc khi được xây dựng.

const myCar = new Car('Eagle', 'Talon TSi', 1993);

6 Trả về một chuỗi đại diện cho ngày hiện tại khi được gọi, tương đương với

const myCar = new Car('Eagle', 'Talon TSi', 1993);

7.

Sau ES6, ngôn ngữ nghiêm ngặt hơn về các hàm tạo và là các chức năng. Ví dụ:

const myCar = new Car('Eagle', 'Talon TSi', 1993);

8 và

const myCar = new Car('Eagle', 'Talon TSi', 1993);

9 chỉ có thể được gọi mà không có

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

3. Cố gắng xây dựng chúng sẽ ném

function Car(color) {
  if (!new.target) {
    // Called as function.
    return `${color} car`;
  }
  // Called with new.
  this.color = color;
}

const a = Car("red"); // a is "red car"
const b = new Car("red"); // b is `Car { color: "red" }`

0.

const kensCar = new Car('Nissan', '300ZX', 1992);

2 và

const kensCar = new Car('Nissan', '300ZX', 1992);

3 chỉ có thể được xây dựng với

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

3. Cố gắng gọi họ sẽ ném

function Car(color) {
  if (!new.target) {
    // Called as function.
    return `${color} car`;
  }
  // Called with new.
  this.color = color;
}

const a = Car("red"); // a is "red car"
const b = new Car("red"); // b is `Car { color: "red" }`

0.

Ví dụ

Loại đối tượng và thể hiện đối tượng

Giả sử bạn muốn tạo một loại đối tượng cho xe hơi. Bạn muốn loại đối tượng này được gọi là

function Car(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
}

0 và bạn muốn nó có thuộc tính để tạo, mô hình và năm. Để làm điều này, bạn sẽ viết chức năng sau:

function Car(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
}

Bây giờ bạn có thể tạo một đối tượng được gọi là

const kensCar = new Car('Nissan', '300ZX', 1992);

7 như sau:

const myCar = new Car('Eagle', 'Talon TSi', 1993);

Câu lệnh này tạo ra

const kensCar = new Car('Nissan', '300ZX', 1992);

7 và gán nó các giá trị được chỉ định cho các thuộc tính của nó. Sau đó, giá trị của

const kensCar = new Car('Nissan', '300ZX', 1992);

9 là chuỗi "đại bàng",

function Person(name, age, sex) {
  this.name = name;
  this.age = age;
  this.sex = sex;
}

0 là số nguyên năm 1993, v.v.

Bạn có thể tạo bất kỳ số lượng đối tượng

function Person(name, age, sex) {
  this.name = name;
  this.age = age;
  this.sex = sex;
}

1 bằng các cuộc gọi đến

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

3. Ví dụ:

const kensCar = new Car('Nissan', '300ZX', 1992);

Thuộc tính đối tượng tự nó là một đối tượng khác

Giả sử bạn xác định một đối tượng được gọi là

function Person(name, age, sex) {
  this.name = name;
  this.age = age;
  this.sex = sex;
}

3 như sau:

function Person(name, age, sex) {
  this.name = name;
  this.age = age;
  this.sex = sex;
}

Và sau đó khởi tạo hai đối tượng

function Person(name, age, sex) {
  this.name = name;
  this.age = age;
  this.sex = sex;
}

3 mới như sau:

const rand = new Person('Rand McNally', 33, 'M');
const ken = new Person('Ken Jones', 39, 'M');

Sau đó, bạn có thể viết lại định nghĩa của

function Car(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
}

0 để bao gồm một thuộc tính

function Person(name, age, sex) {
  this.name = name;
  this.age = age;
  this.sex = sex;
}

6 có đối tượng

function Person(name, age, sex) {
  this.name = name;
  this.age = age;
  this.sex = sex;
}

3, như sau:

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

0

Để khởi tạo các đối tượng mới, sau đó bạn sử dụng các đối tượng sau:

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

1

Thay vì truyền một chuỗi theo nghĩa đen hoặc giá trị số nguyên khi tạo các đối tượng mới, các câu lệnh trên truyền các đối tượng

function Person(name, age, sex) {
  this.name = name;
  this.age = age;
  this.sex = sex;
}

8 và

function Person(name, age, sex) {
  this.name = name;
  this.age = age;
  this.sex = sex;
}

9 làm tham số cho chủ sở hữu. Để tìm ra tên của chủ sở hữu của

const rand = new Person('Rand McNally', 33, 'M');
const ken = new Person('Ken Jones', 39, 'M');

0, bạn có thể truy cập thuộc tính sau:

Sử dụng function Foo(bar1, bar2) { this.bar1 = bar1; this.bar2 = bar2; } 3 với các lớp

function Foo(bar1, bar2) {
  this.bar1 = bar1;
  this.bar2 = bar2;
}

2

Thông số kỹ thuật

Sự chỉ rõ
Đặc tả ngôn ngữ Ecmascript # Sec-New-Experator # sec-new-operator

Tính tương thích của trình duyệt web

Bảng BCD chỉ tải trong trình duyệt

Xem thêm

Việc sử dụng mới là gì?

Việc sử dụng toán tử mới biểu thị yêu cầu phân bổ bộ nhớ trên đống.Nếu có đủ bộ nhớ, nó sẽ khởi tạo bộ nhớ và trả về địa chỉ của nó cho biến con trỏ.Toán tử mới chỉ nên được sử dụng nếu đối tượng dữ liệu phải ở trong bộ nhớ cho đến khi xóa được gọi.signifies a request for the memory allocation on the heap. If the sufficient memory is available, it initializes the memory and returns its address to the pointer variable. The new operator should only be used if the data object should remain in memory until delete is called.

Tôi có nên sử dụng mới trong JavaScript không?

Không 'xấu' khi sử dụng từ khóa mới.Nhưng nếu bạn quên nó, bạn sẽ gọi hàm tạo đối tượng là một hàm thông thường.Nếu hàm tạo của bạn không kiểm tra bối cảnh thực thi của nó thì nó sẽ không nhận thấy rằng 'cái này' chỉ ra đối tượng khác nhau (thông thường là đối tượng toàn cầu) thay vì thể hiện mới.. But if you forget it, you will be calling the object constructor as a regular function. If your constructor doesn't check its execution context then it won't notice that 'this' points to different object (ordinarily the global object) instead of the new instance.

Mục đích của nhà điều hành mới trong Java là gì?

Toán tử mới khởi tạo một lớp bằng cách phân bổ động (nghĩa là phân bổ trong thời gian chạy) cho một đối tượng mới và trả về một tham chiếu đến bộ nhớ đó.Tài liệu tham khảo này sau đó được lưu trữ trong biến.Do đó, trong Java, tất cả các đối tượng lớp phải được phân bổ động.instantiates a class by dynamically allocating(i.e, allocation at run time) memory for a new object and returning a reference to that memory. This reference is then stored in the variable. Thus, in Java, all class objects must be dynamically allocated.

programming javascript New in Java Constructor function Object constructor Depth javascript Spread js

Hướng dẫn what is the use of new in javascript? - việc sử dụng mới trong javascript là gì?

Thử nó

Cú pháp

Thông số

Sự mô tả

Ví dụ

Loại đối tượng và thể hiện đối tượng

Thuộc tính đối tượng tự nó là một đối tượng khác

Sử dụng function Foo(bar1, bar2) { this.bar1 = bar1; this.bar2 = bar2; } 3 với các lớp

Thông số kỹ thuật

Tính tương thích của trình duyệt web

Xem thêm

Việc sử dụng mới là gì?

Tôi có nên sử dụng mới trong JavaScript không?

Mục đích của nhà điều hành mới trong Java là gì?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội