澳门皇冠金沙网站-澳门皇冠844网站

热门关键词: 澳门皇冠金沙网站,澳门皇冠844网站

JS中类或对象的定义,JS中类或对象的定义说明

var oCar1=new Car();
var oCar2=new Car();
oCar1.drivers.push("Matt");
alert(oCar1.drivers);//输出 "Mike,Sue,Matt"
alert(oCar2.drivers);//输出"Mike,Sue,Matt"

我们知道,JS是面向对象的。谈到面向对象,就不可避免的要涉及类的概念。一般像c#,java这些强类型语言都有固定的定义类的语法。而JS的不同之处在于它能使用各种方法实现自己的类和对象。一般的实现有以下几种方式:   1.工厂方式 工厂方式是指创建一个返回特定对象类型的工厂函数,示例代码如下:  代码如下: function createCar(sColor,iDoors,iMpg) {    var oTempCar=new Object;    oTempCar.color=sColor;    oTempCar.doors=iDoors;    oTempCar.mpg=iMpg;    oTempCar.showColor=function()    {         alert(this.color);     }    return oTempCar; } var oCar1=createCar("red",4,23); var oCar2=createCar("blue",3,25); oCar1.showColor(); oCar2.showColor();   这种方式每次调用它的工厂函数,都会创建一个新对象。可问题在于每次生成一个新对象,都要创建新函数showColor,这使得每个对象都有自己的showColor版本,而事实上,所有的对象都共享同一个函数.为解决这个问题,开发者在工厂函数的外面定义了对象的方法,然后赋予对象一个指针指向这个这个函数,如下  代码如下: function showColor() {    alert(this.color); } function createCar(sColor,iDoors,iMpg) {    var oTempCar=new Object;    oTempCar.color=sColor;    oTempCar.doors=iDoors;    oTempCar.mpg=iMpg;    oTempCar.showColor=showColor;    return oTempCar; } var oCar1=createCar("red",4,23); var oCar2=createCar("blue",3,25); oCar1.showColor(); oCar2.showColor();   这样就不需要为每一个对象都创建自己的showColor函数,而只是创建指向这个函数的指针.这从功能上解决了问题,但是该函数却不像对象的方法。于是,引出了构造函数的方式。   2.构造函数方式 构造函数与工厂函数很相似,示例代码如下:  代码如下: function Car(sColor,iDoors,iMpg) {    this.color=sColor;    this.doors=iDoors;    this.mpg=iMpg;    this.showColor=function()    {       alert(this.color);    } } var oCar1=new Car("red",4,23); var oCar2=new Car("blue",3,25);   在构造函数中,内部无创建对象,而是使用this关键字。使用new运算符调用构造函数时,在执行第一行代码之前先创建一个对象,只有用this才能访问这个对象。但是这会遇到什么问题呢,很显然,它的每个对象也都会创建自己的showColor函数版本。为解决这个问题,引出了以下的原型方式.   3.原型方式 该方式利用了对象的prototype属性,可把它看成创建新对象所依赖的原型。这里,用空构造函数来设置类名。然后把所有的方法和属性都直接赋予prototype属性。如下: 代码如下: function Car() {} Car.prototype.color="red"; Car.prototype.doors=4; Car.prototype.mpg=23; Car.prototype.drivers=new Array("Mike","Sue"); Car.prototype.showColor=function() {    alert(this.color); }   原型方式只能直接赋值,而不能通过给构造函数传递参数初始化属性的值。在用这种方式时,会遇到两个问题,不知道大家注意到没有。第一问题是采用这种方式必须创建每个对象后才能改变属性的默认值。而不能在创建每个对象时都会直接有自己所需要的属性值。这点很讨厌。第二个问题在于属性所指的是对象的时候。函数共享不会出现任何问题,但是对象共享却会出现问题。因为每个实例一般都要实现自己的对象。   如下面: 代码如下: var oCar1=new Car(); var oCar2=new Car(); oCar1.drivers.push("Matt"); alert(oCar1.drivers);//输出 "Mike,Sue,Matt" alert(oCar2.drivers);//输出"Mike,Sue,Matt"   因此drivers属性只是指向对象的指针,所以所有的实例事实上共享同一个对象。由于出现这这些问题,我们引出了下面的联合使用构造函数和原型方式。   4.混合的构造函数/原型方式 这种方式的思想是用构造函数定义对象的所有非函数属性(包括普通属性和指向对象的属性),用原型方式定义对象的函数属性(方法)。结果使得所有的函数都只被创建一次,而每个对象都有自己的对象属性实例。示例代码如下:  代码如下: function Car(sColor,iDoors,iMpg) {    this.color=sColor;    this.doors=iDoors;    this.mpg=iMpg;    this.drivers=new Array("Mike","Sue"); } Car.prototype.showColor=function() {    alert(this.color); } var oCar1=new Car("red",4,23); var oCar2=new Car("blue",3,25); oCar1.drivers.push("Matt"); alert(oCar1.drivers);//输出 "Mike,Sue,Matt" alert(oCar2.drivers);//输出 "Mike,Sue"   由实例代码可知,这种方式同时解决了上一种方式的两个问题。不过,采用这种方式,仍有些开发者觉得不够完美。   5.动态原型方式 我们可知,大多数面向对象语言都对属性和方法进行了视觉上的封装。而上述方式的showColor方法却定义在了类的外面。因此,他们设计了动态原型方法。这种方式的基本思想和混合的构造函数/原型方式相同,唯一不同之处在于对象方法的位置。如下所示: 代码如下: function Car(sColor,iDoors,iMpg) {    this.color=sColor;    this.doors=iDoors;    this.mpg=iMpg;    this.drivers=new Array("Mike","Sue");    if(typeof Car._initialized=="undefined")   {      Car.prototype.showColor=function()      {         alert(this.color);      }   }   Car._initialized=true; }   这种方式Car.prototype.showColor只被创建一次。这样依赖,这段代码更像其他语言中的类定义了。   6.混合工厂方式 这种方式通常是不能应该前一种方式的变通方法。它的目的是创建假构造函数,只返回另一种对象的新实例。  代码如下: function createCar() {    var oTempCar=new Object;    oTempCar.color=“red”;    oTempCar.doors=4;    oTempCar.mpg=23;    oTempCar.showColor=function()    {         alert(this.color);     };    return oTempCar; } var car=new Car();   由于在Car()构造函数内部调用了new运算符,所以自动忽略第二个new运算符。在构造函数内部创建的对象被传递回变量var。这种方式在对象方法的内部管理方面与经典方式有着相同的问题。所以强烈建议:除非万不得已,还是避免使用这种方式。 

function Car(sColor, iDoors, iMpg) {
//通过构造函数的形式,会为每个对象生成独立的属性和函数
this.color = sColor;
this.doors = iDoors;
this.mpg = iMpg;
this.showColor = function () {
alert(this.color);
};

function Car(sColor,iDoors,iMpg)
{
   this.color=sColor;
   this.doors=iDoors;
   this.mpg=iMpg;
   this.drivers=new Array("Mike","Sue");
}
Car.prototype.showColor=function()
{
   alert(this.color);
}
var oCar1=new Car("red",4,23);
var oCar2=new Car("blue",3,25);
oCar1.drivers.push("Matt");
alert(oCar1.drivers);//输出 "Mike,Sue,Matt"
alert(oCar2.drivers);//输出 "Mike,Sue"

我们知道,JS是面向对象的。谈...

复制代码 代码如下:

6.混合工厂方式 这种方式通常是不能应该前一种方式的变通方法。它的目的是创建假构造函数,只返回另一种对象的新实例。

 本篇文章主要是对JS中类或对象的定义进行了说明介绍,需要的朋友可以过来参考下,希望对大家有所帮助

function Car() {

在构造函数中,内部无创建对象,而是使用this关键字。使用new运算符调用构造函数时,在执行第一行代码之前先创建一个对象,只有用this才能访问这个对象。但是这会遇到什么问题呢,很显然,它的每个对象也都会创建自己的showColor函数版本。为解决这个问题,引出了以下的原型方式.

var car = new Car();
car.showColor();

如下面:

function createCar() {
var oTempCar = new Object();
oTempCar.color = "red";
oTempCar.doors = 4;
oTempCar.mpg = 23;
oTempCar.showColor = function () {
alert(this.color);
};
return oTempCar;
}

复制代码 代码如下:

function Car() {
var oTempCar = new Object();
oTempCar.color = "red";
oTempCar.doors = 4;
oTempCar.mpg = 23;
oTempCar.showColor = function () {
alert(this.color);
};
return oTempCar;
}

由实例代码可知,这种方式同时解决了上一种方式的两个问题。不过,采用这种方式,仍有些开发者觉得不够完美。

二、类的定义--工厂方式实现:

function createCar()
{
   var oTempCar=new Object;
   oTempCar.color=“red”;
   oTempCar.doors=4;
   oTempCar.mpg=23;
   oTempCar.showColor=function()
   {
        alert(this.color);
   };
   return oTempCar;
}
var car=new Car();

这样做看似的确可以实现了对象了。实现也很简单,调用也很方便。但是有两个不是很好的地方:

function createCar(sColor,iDoors,iMpg)
{
   var oTempCar=new Object;
   oTempCar.color=sColor;
   oTempCar.doors=iDoors;
   oTempCar.mpg=iMpg;
   oTempCar.showColor=function()
   {
        alert(this.color);
   }
   return oTempCar;
}
var oCar1=createCar("red",4,23);
var oCar2=createCar("blue",3,25);
oCar1.showColor();
oCar2.showColor();

这样遇到的问题是每个对象都需要重新定义一次他的字段和方法。很麻烦。

这样就不需要为每一个对象都创建自己的showColor函数,而只是创建指向这个函数的指针.这从功能上解决了问题,但是该函数却不像对象的方法。于是,引出了构造函数的方式。

复制代码 代码如下:

function Car(sColor,iDoors,iMpg)
{
   this.color=sColor;
   this.doors=iDoors;
   this.mpg=iMpg;
   this.drivers=new Array("Mike","Sue");
   if(typeof Car._initialized=="undefined")
  {
     Car.prototype.showColor=function()
     {
        alert(this.color);
     }
  }
  Car._initialized=true;
}

function createCar(sColor, iDoors, iMpg) {
var oTempCar = new Object();
oTempCar.color = sColor;
oTempCar.doors = iDoors;
oTempCar.mpg = iMpg;
oTempCar.showColor = function () {
alert(this.color);
};

我们知道,JS是面向对象的。谈到面向对象,就不可避免的要涉及类的概念。一般像c#,java这些强类型语言都有固定的定义类的语法。而JS的不同之处在于它能使用各种方法实现自己的类和对象。一般的实现有以下几种方式:

2、在有多个实例时,对其中一个实例的属性的更改会影响到另外一个实例的属性。

这种方式Car.prototype.showColor只被创建一次。这样依赖,这段代码更像其他语言中的类定义了。

这种方式被称之为工厂方式。工厂方式看起来是省事多了。起码创建一个对象的时候不再需要那么多的行数。因为每个属性(color,doors,mpg)的值都是固定的,还需要再次进行改造,利用参数传递来实现:

5.动态原型方式 我们可知,大多数面向对象语言都对属性和方法进行了视觉上的封装。而上述方式的showColor方法却定义在了类的外面。因此,他们设计了动态原型方法。这种方式的基本思想和混合的构造函数/原型方式相同,唯一不同之处在于对象方法的位置。如下所示:

调用方式:

4.混合的构造函数/原型方式 这种方式的思想是用构造函数定义对象的所有非函数属性(包括普通属性和指向对象的属性),用原型方式定义对象的函数属性(方法)。结果使得所有的函数都只被创建一次,而每个对象都有自己的对象属性实例。示例代码如下:

测试代码:

您可能感兴趣的文章:

  • Nodejs学习笔记之Global Objects全局对象
  • JavaScript中的全局对象介绍
  • javascript中全局对象的isNaN()方法使用介绍
  • javascript中全局对象的parseInt()方法使用介绍
  • 浅析JavaScript中两种类型的全局对象/函数
  • Javascript 陷阱 window全局对象
  • js 多种变量定义(对象直接量,数组直接量和函数直接量)
  • javascript 对象的定义方法
  • Javascript创建自定义对象 创建Object实例添加属性和方法
  • javascript 对象定义方法 简单易学
  • Javascript 中创建自定义对象的方法汇总
  • JavaScript定义全局对象的方法示例

return oTempCar;
}

这种方式每次调用它的工厂函数,都会创建一个新对象。可问题在于每次生成一个新对象,都要创建新函数showColor,这使得每个对象都有自己的showColor版本,而事实上,所有的对象都共享同一个函数.为解决这个问题,开发者在工厂函数的外面定义了对象的方法,然后赋予对象一个指针指向这个这个函数,如下

复制代码 代码如下:

复制代码 代码如下:

这种方式和混合的构造函数/原型方式相比,提供了一种友好的编程风格(在混合的构造函数/原型方式中,showColor方法的定义是在方法体外实现的,而不是在构造函数的方法体内完成的)。这种类的定义方式使用也很多。

因此drivers属性只是指向对象的指针,所以所有的实例事实上共享同一个对象。由于出现这这些问题,我们引出了下面的联合使用构造函数和原型方式。

利用对象的prototype属性,把它看成是创建新对象所依赖的原型。用空构造函数来设置类名。然后所有的属性和方法都被直接赋予prototype属性。

复制代码 代码如下:

虽然这样解决了重复创建函数的问题,但这样的话,就使showColor函数看起来不像是对象的方法。

function Car()
{}
Car.prototype.color="red";
Car.prototype.doors=4;
Car.prototype.mpg=23;
Car.prototype.drivers=new Array("Mike","Sue");
Car.prototype.showColor=function()
{
   alert(this.color);
}

一、在javascript中实例化遇到的问题: 下面用《...

1.工厂方式 工厂方式是指创建一个返回特定对象类型的工厂函数,示例代码如下:

复制代码 代码如下:

本文由澳门皇冠金沙网站发布于前端开发,转载请注明出处:JS中类或对象的定义,JS中类或对象的定义说明