js中的对象分为两种，一种是面向对象另一种是遍历对象。

面向对象在js里有两bai个层次的含义，第一种是会使用面向对象函数；第二种是构造面向对象函数。

js也是面向对象中的一种写法，不过相对于java，js是一种弱数据类型，并不是严格意义上的面向对象。但是jq就是使用面向对象的写法创作出来的js库。

面向对象有四个特点：

抽象：抓住核心问题

封装：即把能够实现功能的函数写成封装起来，在面向对象里叫做方法。简单来说就是把实现功能的函数写成方法。

继承：继承的意思是，在实现同一种功能的前提下，新对象可以使用就对象的属性和方法。

多态：一个变量在引用不同类型的情况下的不同状态。多态开发在开发组件和模块化开发的时候能节省很多资源。

创建对象的方法

1、new 操作符 + Object 创建对象

var person = new Object();

person.name = "lisi";

person.age = 21;

person.family = ["lida","lier","wangwu"];

person.say = function(){

alert(this.name);

}

2、字面式创建对象

var person ={

name: "lisi",

age: 21,

family: ["lida","lier","wangwu"],

say: function(){

alert(this.name);

}

};

3、工厂模式

function createPerson(name,age,family) {

var o = new Object();

o.name = name;

o.age = age;

o.family = family;

o.say = function(){

alert(this.name);

}

return o;

}

var person1 = createPerson("lisi",21,["lida","lier","wangwu"]); //instanceof无法判断它是谁的实例，只能判断他是对象，构造函数都可以判断出

var person2 = createPerson("wangwu",18,["lida","lier","lisi"]);

console.log(person1 instanceof Object); //true

4、构造函数模式

function Person(name,age,family) {

this.name = name;

this.age = age;

this.family = family;

this.say = function(){

alert(this.name);

}

}

var person1 = new Person("lisi",21,["lida","lier","wangwu"]);

var person2 = new Person("lisi",21,["lida","lier","lisi"]);

console.log(person1 instanceof Object); //true

console.log(person1 instanceof Person); //true

console.log(person2 instanceof Object); //true

console.log(person2 instanceof Person); //true

console.log(person1.constructor); //constructor 属性返回对创建此对象的数组、函数的引用

对比工厂模式有以下不同之处：

1、没有显式地创建对象

2、直接将属性和方法赋给了 this 对象

3、没有 return 语句

以此方法调用构造函数步骤：

1、创建一个新对象

2、将构造函数的作用域赋给新对象(将this指向这个新对象)

3、执行构造函数代码(为这个新对象添加属性)

4、返回新对象 ( 指针赋给变量person ？？？ )

可以看出，构造函数知道自己从哪里来(通过 instanceof 可以看出其既是Object的实例，又是Person的实例)

构造函数也有其缺陷，每个实例都包含不同的Function实例( 构造函数内的方法在做同一件事，但是实例化后却产生了不同的对象，方法是函数 ，函数也是对象)

因此产生了原型模式

5、原型模式

function Person() {

}

Person.prototype.name = "lisi";

Person.prototype.age = 21;

Person.prototype.family = ["lida","lier","wangwu"];

Person.prototype.say = function(){

alert(this.name);

};

console.log(Person.prototype); //Object{name: 'lisi', age: 21, family: Array[3]}

var person1 = new Person(); //创建一个实例person1

console.log(person1.name); //lisi

var person2 = new Person(); //创建实例person2

person2.name = "wangwu";

person2.family = ["lida","lier","lisi"];

console.log(person2); //Person {name: "wangwu", family: Array[3]}

// console.log(person2.prototype.name); //报错

console.log(person2.age); //21

原型模式的好处是所有对象实例共享它的属性和方法(即所谓的共有属性)，此外还可以如代码第16,17行那样设置实例自己的属性(方法)(即所谓的私有属性)，可以覆盖原型对象上的同名属性(方法)。

6、混合模式(构造函数模式+原型模式)

构造函数模式用于定义实例属性，原型模式用于定义方法和共享的属性

function Person(name,age,family){

this.name = name;

this.age = age;

this.family = family;

}

Person.prototype = {

constructor: Person, //每个函数都有prototype属性，指向该函数原型对象，原型对象都有constructor属性，这是一个指向prototype属性所在函数的指针

say: function(){

alert(this.name);

}

}

var person1 = new Person("lisi",21,["lida","lier","wangwu"]);

console.log(person1);

var person2 = new Person("wangwu",21,["lida","lier","lisi"]);

console.log(person2);

可以看出，混合模式共享着对相同方法的引用，又保证了每个实例有自己的私有属性。最大限度的节省了内存。

高程中还提到了动态原型模式，寄生构造函数模式，稳妥构造函数模式。

给对象添加修改数据的方法

给JS对象添加属性和方法

方式一：在定义对象时，直接添加属性和方法

function Person(name,age) {

this.name = name;

this.age = age;

this.say = function() {

alert(name + ':::' + age);

}

}

var person = new Person('张三', 24);

person.say();

方式二：通过"对象.属性名"的方式添加

function Person() {}

var person = new Person();

person.name = '张三';

person.say = function() {alert(this.name)};

person.say();

方式三：通过prototype(原型)属性添加

注：需要使用构造方法添加！

function Person() {}

var person = new Person();

Person.prototype.name = '张三';

Person.prototype.say = function() {alert(this.name)};

person.say();

本文地址：https://blog.csdn.net/hanbic/article/details/107298174

希望与广大网友互动？？

点此进行留言吧！