Ikuti saya untuk mempelajari 8 cara untuk mencipta objek (kelas) dalam JavaScript

8 cara untuk mencipta objek (kelas) dalam JavaScript, Yiyi memperkenalkannya kepada anda, saya harap anda menyukainya.

1. Gunakan pembina Objek untuk mencipta objek

Kod berikut mencipta objek orang dan mencetak nilai atribut Nama dalam dua cara.

 var person = new Object();
  person.name="kevin";
  person.age=31;
  alert(person.name);
  alert(person["name"])

Satu lagi bentuk kaedah penulisan di atas ialah menggunakan literal objek untuk mencipta objek Jangan terkejut dengan orang[“5”], ia adalah sah di sini; sebaliknya gunakan ini Dalam cara kurungan, mungkin terdapat ruang antara medan, seperti orang["umur saya"].

var person = 
  {
    name:"Kevin",
    age:31,
    5:"Test"
  };
  alert(person.name);
  alert(person["5"]);

Walaupun pembina Objek atau literal objek boleh digunakan Untuk mencipta objek tunggal, tetapi kaedah ini mempunyai kelemahan yang jelas: menggunakan antara muka yang sama untuk mencipta banyak objek akan menghasilkan banyak kod pendua. Untuk menyelesaikan masalah ini, orang ramai mula menggunakan variasi corak kilang.

2. Corak kilang

Corak kilang ialah corak reka bentuk yang terkenal dalam bidang kejuruteraan perisian dalam ECMAScript Memandangkan kelas tidak dapat dibuat, pembangun mencipta fungsi untuk merangkum butiran mencipta objek dengan antara muka tertentu, seperti yang ditunjukkan dalam contoh berikut.

function createPerson(name, age, job){
  var o = new Object();
  o.name = name;
  o.age = age;
  o.job = job;
  o.sayName = function(){
    alert(this.name);
  };
  return o;
}
var person1 = createPerson("Nicholas", 29, "Software Engineer");
var person2 = createPerson("Greg", 27, "Doctor");

Walaupun corak kilang menyelesaikan masalah mencipta berbilang objek yang serupa, ia tidak menyelesaikan masalah pengecaman objek (iaitu, bagaimana untuk mengetahui jenis objek) . Dengan pembangunan JavaScript
, satu lagi corak baharu telah muncul.

3. Corak Pembina

Pembina seperti Object dan Array akan muncul secara automatik dalam persekitaran pelaksanaan semasa masa jalan. Di samping itu, anda boleh mencipta pembina tersuai untuk menentukan sifat dan kaedah jenis objek tersuai. Sebagai contoh, contoh sebelumnya boleh ditulis semula seperti berikut menggunakan corak pembina.

function Person(name, age, job){
  this.name = name;
  this.age = age;
  this.job = job;
  this.sayName = function(){
  alert(this.name);
};
}
var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");

Dalam contoh ini, fungsi Person() menggantikan fungsi createPerson(). Kami mendapati bahawa, sebagai tambahan kepada bahagian yang sama seperti createPerson(), kod dalam Person() juga mempunyai perbezaan berikut:

• Objek tidak dibuat secara eksplisit

• secara langsung memberikan sifat dan kaedah kepada objek ini;

• Untuk mencipta tika baharu Orang, pengendali baharu mesti digunakan. Memanggil pembina dengan cara ini sebenarnya akan melalui

4 langkah berikut:

(1) Cipta objek baharu (2) Bina Skop daripada fungsi diberikan kepada objek baharu (jadi ini menunjukkan kepada objek baharu); (3) melaksanakan kod dalam pembina (menambah atribut kepada objek baharu); . Pada penghujung contoh sebelumnya, person1 dan person2 masing-masing memegang instance Person yang berbeza. Kedua-dua objek mempunyai atribut pembina yang menunjuk kepada Orang seperti yang ditunjukkan di bawah.

Atribut pembina objek pada mulanya digunakan untuk mengenal pasti jenis objek. Walau bagaimanapun, apabila ia datang untuk mengesan jenis objek, pengendali instanceof lebih dipercayai. Semua objek yang kami cipta dalam contoh ini adalah kedua-dua contoh Objek dan contoh Orang, yang boleh disahkan melalui pengendali instanceof.

alert(person1.constructor == Person); //true
alert(person2.constructor == Person); //true

alert(person1 instanceof Object); //true
alert(person1 instanceof Person); //true
alert(person2 instanceof Object); //true
alert(person2 instanceof Person); //true

Walaupun corak pembina mudah digunakan, ia bukan tanpa kekurangannya. Masalah utama dengan menggunakan pembina ialah setiap kaedah mesti dicipta semula pada setiap contoh. Fungsi dalam ECMAScript ialah objek, jadi setiap kali sesuatu fungsi ditakrifkan, objek akan dijadikan instantiated. Dari perspektif logik, pembina pada masa ini juga boleh ditakrifkan seperti ini.

function Person(name, age, job){
  this.name = name;
  this.age = age;
  this.job = job;
  this.sayName = new Function("alert(this.name)"); // 与声明函数在逻辑上是等价的
}

alert(person1.sayName == person2.sayName); //false

function Person(name, age, job){
  this.name = name;
  this.age = age;
  this.job = job;
  this.sayName = sayName;
}
function sayName(){
  alert(this.name);
}
var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");

要理解原型对象，可见我的另一篇博客：JavaScript prototype详解

前面例子中每添加一个属性和方法就要敲一遍Person.prototype。为减少不必要的输入，也为了从视觉上更好地封装原型的功能，更常见的做法是用一个包含所有属性和方法的对象字面量来重写整个原型对象，如下面的例子所示。

function Person(){
}
Person.prototype = {
  name : "Nicholas",
  age : 29,
  job: "Software Engineer",
  sayName : function () {
    alert(this.name);
  }
};

在上面的代码中，我们将Person.prototype 设置为等于一个以对象字面量形式创建的新对象。最终结果相同，但有一个例外：constructor 属性不再指向Person 了。前面曾经介绍过，每创建一个函数，就会同时创建它的prototype 对象，这个对象也会自动获得constructor 属性。而我们在这里使用的语法，本质上完全重写了默认的prototype 对象，因此constructor 属性也就变成了新对象的constructor 属性（指向Object 构造函数），不再指向Person 函数。此时，尽管instanceof操作符还能返回正确的结果，但通过constructor 已经无法确定对象的类型了，如下所示。

var friend = new Person();
alert(friend instanceof Object); //true
alert(friend instanceof Person); //true
alert(friend.constructor == Person); //false
alert(friend.constructor == Object); //true

在此，用instanceof 操作符测试Object 和Person 仍然返回true，但constructor 属性则等于Object 而不等于Person 了。如果constructor 的值真的很重要，可以像下面这样特意将它设置回适当的值。

function Person(){
}
  Person.prototype = {
  constructor : Person,
  name : "Nicholas",
  age : 29,
  job: "Software Engineer",
  sayName : function () {
    alert(this.name);
  }
};

需要注意一点就是：实例中的指针仅指向原型，而不指向构造函数。

原型对象的问题：原型模式也不是没有缺点。首先，它省略了为构造函数传递初始化参数这一环节，结果所有实例在默认情况下都将取得相同的属性值。虽然这会在某种程度上带来一些不方便，但还不是原型的最大问题。原型模式的最大问题是由其共享的本性所导致的。

function Person(){
}
Person.prototype = {
  constructor: Person,
  name : "Nicholas",
  age : 29,
  job : "Software Engineer",
  friends : ["Shelby", "Court"],
  sayName : function () {
    alert(this.name);
  }
};
var person1 = new Person();
var person2 = new Person();
person1.friends.push("Van");
alert(person1.friends); //"Shelby,Court,Van"
alert(person2.friends); //"Shelby,Court,Van"
alert(person1.friends === person2.friends); //true

5、组合使用构造函数模式和原型模式（最常用）

创建自定义类型的最常见方式，就是组合使用构造函数模式与原型模式。构造函数模式用于定义实例属性，而原型模式用于定义方法和共享的属性。结果，每个实例都会有自己的一份实例属性的副本，但同时又共享着对方法的引用，最大限度地节省了内存。另外，这种混成模式还支持向构造函数传递参数；可谓是集两种模式之长。

function Person(name, age, job){
  this.name = name;
  this.age = age;
  this.job = job;
  this.friends = ["Shelby", "Court"];
}

Person.prototype = {
  constructor : Person,
  sayName : function(){
    alert(this.name);
  }
}
var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");
person1.friends.push("Van");
alert(person1.friends); //"Shelby,Count,Van"
alert(person2.friends); //"Shelby,Count"
alert(person1.friends === person2.friends); //false
alert(person1.sayName === person2.sayName); //true

6、动态原型模式

有其他OO 语言经验的开发人员在看到独立的构造函数和原型时，很可能会感到非常困惑。动态原型模式正是致力于解决这个问题的一个方案，它把所有信息都封装在了构造函数中，而通过在构造函数中初始化原型（仅在必要的情况下），又保持了同时使用构造函数和原型的优点。换句话说，可以通过检查某个应该存在的方法是否有效，来决定是否需要初始化原型。来看一个例子。

function Person(name, age, job){
  //属性
  this.name = name;
  this.age = age;
  this.job = job;
  //方法
  ---------------------------------------------
  if (typeof this.sayName != "function"){
    Person.prototype.sayName = function(){
      alert(this.name);
    };
  }
  --------------------------------------------  
}
var friend = new Person("Nicholas", 29, "Software Engineer");
friend.sayName();

7、寄生构造函数模式

通常，在前述的几种模式都不适用的情况下，可以使用寄生（parasitic）构造函数模式。这种模式的基本思想是创建一个函数，该函数的作用仅仅是封装创建对象的代码，然后再返回新创建的对象；但从表面上看，这个函数又很像是典型的构造函数。下面是一个例子。

function Person(name, age, job){
  var o = new Object();
  o.name = name;
  o.age = age;
  o.job = job;
  o.sayName = function(){
    alert(this.name);
  };
  return o;
}
var friend = new Person("Nicholas", 29, "Software Engineer");
friend.sayName(); //"Nicholas"

在这个例子中，Person 函数创建了一个新对象，并以相应的属性和方法初始化该对象，然后又返回了这个对象。除了使用new 操作符并把使用的包装函数叫做构造函数之外，这个模式跟工厂模式其实是一模一样的。构造函数在不返回值的情况下，默认会返回新对象实例。

8、稳妥构造函数模式

所谓稳妥对象，指的是没有公共属性，而且其方法也不引用this 的对象。稳妥对象最适合在一些安全的环境中（这些环境中会禁止使用this 和new），或者在防止数据被其他应用程序（如Mashup程序）改动时使用。稳妥构造函数遵循与寄生构造函数类似的模式，但有两点不同：一是新创建对象的实例方法不引用this；二是不使用new 操作符调用构造函数。按照稳妥构造函数的要求，可以将前面的Person 构造函数重写如下。

function Person(name, age, job){
  //创建要返回的对象
  var o = new Object();
  //可以在这里定义私有变量和函数
  //添加方法
  o.sayName = function(){
    alert(name);
  };
//返回对象
return o;
}

Sudahkah anda mempelajari 8 kaedah mencipta objek (kelas) dalam JavaScript di atas, saya harap ia akan membantu pembelajaran anda.

【Tutorial berkaitan yang disyorkan】

1 Tutorial video JavaScript
2 Manual dalam talian JavaScript
3 tutorial bootstrap