Javascript khi nào sử dụng nguyên mẫu

Tôi muốn hiểu khi nào thì thích hợp để sử dụng các phương thức nguyên mẫu trong js. Chúng có nên được sử dụng luôn không? Hoặc có những trường hợp sử dụng chúng không được ưu tiên và / hoặc phải chịu một hình phạt về hiệu suất?

Khi tìm kiếm xung quanh trang web này về các phương pháp phổ biến cho không gian tên trong js, có vẻ như hầu hết sử dụng cách triển khai không dựa trên nguyên mẫu: chỉ đơn giản là sử dụng một đối tượng hoặc một đối tượng hàm để đóng gói một không gian tên.

Đến từ một ngôn ngữ dựa trên lớp, thật khó để không thử vẽ các đối số và nghĩ rằng các nguyên mẫu giống như "các lớp" và các triển khai không gian tên mà tôi đã đề cập giống như các phương thức tĩnh.

Nguyên mẫu là một tối ưu hóa .

Một ví dụ tuyệt vời về việc sử dụng chúng tốt là thư viện jQuery. Mỗi khi bạn lấy một đối tượng jQuery bằng cách sử dụng $('.someClass'), đối tượng đó có hàng tá "phương thức". Thư viện có thể đạt được điều đó bằng cách trả về một đối tượng:

return {
   show: function() { ... },
   hide: function() { ... },
   css: function() { ... },
   animate: function() { ... },
   // etc...
};

Nhưng điều đó có nghĩa là mọi đối tượng jQuery trong bộ nhớ sẽ có hàng chục vị trí được đặt tên chứa các phương thức giống nhau, lặp đi lặp lại.

Thay vào đó, các phương thức đó được xác định trên một nguyên mẫu và tất cả các đối tượng jQuery "kế thừa" nguyên mẫu đó để đạt được tất cả các phương thức đó với chi phí thời gian chạy rất ít.

Một phần cực kỳ quan trọng trong cách jQuery làm đúng là điều này được ẩn với lập trình viên. Nó hoàn toàn được coi là một tối ưu hóa, không phải là thứ mà bạn phải lo lắng khi sử dụng thư viện.

Vấn đề với JavaScript là các hàm khởi tạo thường yêu cầu người gọi phải nhớ đặt tiền tố cho chúng newhoặc nếu không thì chúng thường không hoạt động. Không có lý do chính đáng cho điều này. jQuery làm đúng bằng cách giấu điều vô nghĩa đó đằng sau một hàm thông thường $, vì vậy bạn không cần quan tâm đến cách các đối tượng được triển khai.

Để bạn có thể thuận tiện tạo một đối tượng với một nguyên mẫu được chỉ định, ECMAScript 5 bao gồm một chức năng tiêu chuẩn Object.create. Một phiên bản được đơn giản hóa rất nhiều của nó sẽ trông như thế này:

Object.create = function(prototype) {
    var Type = function () {};
    Type.prototype = prototype;
    return new Type();
};

Nó chỉ lo việc viết một hàm khởi tạo và sau đó gọi nó bằng new.

Khi nào bạn tránh các nguyên mẫu?

Một so sánh hữu ích là với các ngôn ngữ OO phổ biến như Java và C #. Chúng hỗ trợ hai loại kế thừa:

• kế thừa giao diện , trong đó bạn implementmột interfacelớp cung cấp triển khai duy nhất của riêng nó cho mọi thành viên của giao diện.
• thực hiện kế thừa, nơi bạn có extendmột classcung cấp triển khai mặc định của một số phương pháp.

Trong JavaScript, kế thừa nguyên mẫu là một kiểu kế thừa triển khai . Vì vậy, trong những tình huống mà (trong C # hoặc Java), bạn sẽ bắt nguồn từ một lớp cơ sở để đạt được hành vi mặc định, sau đó bạn thực hiện các sửa đổi nhỏ thông qua ghi đè, thì trong JavaScript, kế thừa nguyên mẫu có ý nghĩa.

Tuy nhiên, nếu bạn đang ở trong tình huống mà bạn đã sử dụng giao diện trong C # hoặc Java, thì bạn không cần bất kỳ tính năng ngôn ngữ cụ thể nào trong JavaScript. Không cần phải khai báo rõ ràng một cái gì đó đại diện cho giao diện và không cần đánh dấu các đối tượng là "triển khai" giao diện đó:

var duck = {
    quack: function() { ... }
};

duck.quack(); // we're satisfied it's a duck!

Nói cách khác, nếu mỗi "loại" đối tượng có định nghĩa riêng về "phương thức", thì sẽ không có giá trị nào trong việc kế thừa từ một nguyên mẫu. Sau đó, nó phụ thuộc vào số lượng phiên bản bạn phân bổ của mỗi loại. Nhưng trong nhiều thiết kế mô-đun, chỉ có một trường hợp của một kiểu nhất định.

Và trên thực tế, nhiều người đã cho rằng kế thừa thực hiện là xấu xa . Nghĩa là, nếu có một số hoạt động phổ biến cho một kiểu, thì có lẽ sẽ rõ ràng hơn nếu chúng không được đưa vào một lớp cơ sở / siêu lớp, mà thay vào đó chỉ được hiển thị như các hàm thông thường trong một số mô-đun, mà bạn truyền (các) đối tượng vào. bạn muốn chúng hoạt động.

Bạn nên sử dụng các nguyên mẫu nếu bạn muốn khai báo một phương thức "không tĩnh" của đối tượng.

var myObject = function () {

};

myObject.prototype.getA = function (){
  alert("A");
};

myObject.getB = function (){
  alert("B");
};

myObject.getB();  // This works fine

myObject.getA();  // Error!

var myPrototypeCopy = new myObject();
myPrototypeCopy.getA();  // This works, too.

Một lý do để sử dụng prototypeđối tượng tích hợp sẵn là nếu bạn sẽ sao chép nhiều lần một đối tượng sẽ chia sẻ chức năng chung. Bằng cách đính kèm các phương thức vào nguyên mẫu, bạn có thể tiết kiệm các phương thức nhân bản được tạo cho mỗi newtrường hợp. Nhưng khi bạn đính kèm một phương thức vào prototype, tất cả các phiên bản sẽ có quyền truy cập vào các phương thức đó.

Giả sử bạn có một Car()lớp / đối tượng cơ sở .

function Car() {
    // do some car stuff
}

sau đó bạn tạo nhiều Car()phiên bản.

var volvo = new Car(),
    saab = new Car();

Bây giờ, bạn biết mỗi chiếc xe sẽ cần phải lái, bật máy, v.v. Thay vì đính kèm một phương thức trực tiếp vào Car()lớp (chiếm bộ nhớ trên mỗi phiên bản được tạo), bạn có thể đính kèm các phương thức vào nguyên mẫu thay thế (chỉ tạo các phương thức một lần), do đó cấp quyền truy cập vào các phương thức đó cho cả phương thức mới volvovà saab.

// just mapping for less typing
Car.fn = Car.prototype;

Car.fn.drive = function () {
    console.log("they see me rollin'");
};
Car.fn.honk = function () {
    console.log("HONK!!!");
}

volvo.honk();
// => HONK!!!
saab.drive();
// => they see me rollin'

Đặt các hàm trên một đối tượng nguyên mẫu khi bạn định tạo nhiều bản sao của một loại đối tượng cụ thể và tất cả chúng đều cần chia sẻ các hành vi chung. Làm như vậy, bạn sẽ tiết kiệm được một số bộ nhớ bằng cách chỉ có một bản sao của mỗi chức năng, nhưng đó chỉ là lợi ích đơn giản nhất.

Thay đổi phương thức trên các đối tượng nguyên mẫu hoặc thêm phương thức, ngay lập tức thay đổi bản chất của tất cả các bản sao của (các) kiểu tương ứng.

Bây giờ chính xác lý do tại sao bạn làm tất cả những điều này chủ yếu là một chức năng của thiết kế ứng dụng của riêng bạn và những thứ bạn cần làm trong mã phía máy khách. (Một câu chuyện hoàn toàn khác sẽ là mã bên trong máy chủ; dễ tưởng tượng hơn nhiều khi thực hiện mã "OO" quy mô lớn hơn ở đó.)

Nếu tôi giải thích trong thuật ngữ dựa trên lớp thì Person là lớp, walk () là phương thức Nguyên mẫu. Vì vậy, walk () sẽ chỉ tồn tại sau khi bạn khởi tạo đối tượng mới với điều này.

Vì vậy, nếu bạn muốn tạo các bản sao của đối tượng như Person u có thể tạo nhiều người dùng thì Prototype là giải pháp tốt vì nó tiết kiệm bộ nhớ bằng cách chia sẻ / kế thừa cùng một bản sao hàm cho từng đối tượng trong bộ nhớ.

Trong khi tĩnh không phải là trợ giúp lớn trong trường hợp như vậy.

function Person(){
this.name = "anonymous";
}

// its instance method and can access objects data data 
Person.prototype.walk = function(){
alert("person has started walking.");
}
// its like static method
Person.ProcessPerson = function(Person p){
alert("Persons name is = " + p.name);
}

var userOne = new Person();
var userTwo = new Person();

//Call instance methods
userOne.walk();

//Call static methods
Person.ProcessPerson(userTwo);

Vì vậy, với phương thức này giống như phương thức instance hơn của nó. Cách tiếp cận của đối tượng giống như các phương thức Tĩnh.

https://developer.mozilla.org/en/Introduction_to_Object-Oriented_JavaScript