JavaScript高级程序设计第六章

ECMAScript有两种属性：数据属性和访问器属性

修改对象的属性的特性

var person = {};

Object.defineProperty(person,“name”,{
writeable:false,
value:“lala”
});

alert(person.name); //lala
person.name = “haha”;
alert(person.name); //lala
这个是无法修改name的值

var person = {};

Object.defineProperty(person,“name”,{
configurable:false,
value:“lala”
});

alert(person.name); //lala
delete person.name;
alert(person.name); //lala

访问器属性
例子：
var book = {
year :2018,
edition :1
};

Object.defineProperty(book,“year”,{
get:function(){
return this.year;
},
set:function(newValue){
this.year = newValue;
this.edition += newValue-2019;
}
});

book.year = 2020;
alert(book.edition); //2
只指定getter意味着属性不能写
只指定setter，意味着属性不能读

定义多个属性：
例子：
var book = {};

Object.defindProperty(book,{
year :{
value:2020
},

edition:{
	value:1
},

year:{set:funtion(newValue){
	this.year = newValue
},
	
          get:funtion(){
	return this.year;
}
}

});
把数据属性和访问器属性一起定义了

工厂模式，由于JavaScript没有类的定义，那么实现这个工厂模式是定义一个方法

function createPerson(name,age,job){

var obj = new Object();
obj.name = name;
obj.age = age;
obj.job = job;
obj.sayName = function(){
	alert(this.name);
	         };
return obj;

};

person1 = create(“lala”,18,“engineer”);

或者这样
function Person(name,age,job){

this.name = name;
this.age = age;
this.job = job;
this.sayName = function(){
	alert(this.name);
	         };

};//没有newObjct，没有return，使用this
var person2 = new Person(“haha”,20,“engineer”);

按照惯例，构造函数的名字开头是大写的

任何函数，用new来调用，那么它就是构造函数，只要不是用new来调用的，那么它就是普通函数

另一种方式来构造对象

fiction Person(name,age,job){
this.name = name;
this.age = age;
this.job = job;
this.sayName = function(){
alert(this.name);
};
};

var o = new Object();
Person.call(o,“lala”,20,“engineer”);

每个函数都有一个prototype属性，这个属性是一个指针，指向一个对象

原型对象(共享属性和方法)：

function Person(){}

Person.prototype.name = “lala”;
Person.prototype.age = 18;
Person.prototype.sayName = function(){
alert(this.name);
};

var person1 = new Person();
var person2 = new Person();

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

无论什么时候，只要创建一个新函数，就会为这个函数创建一个prototype属性，这个属性指向函数的原型对象

每当代码读取某个对象的属性，首先会查看对象实例本身有没有给定名字的属性，如果有就用了，没有就继续搜素指针指向的原型对象

var person = {};

function Person(){}

Person.prototype.name = “lala”;
Person.prototype.age = 18;
Person.prototype.sayName = function (){alert(this.name);};

var person1 = new Person();
person1.name = “haha”;
alert(person1.name); //haha

alert(person1.hasOwnProperty(“name”); //true，因为person1有自己的name属性，如果没有会返回false，通过这个 //方法可以很清楚知道，现在访问的这个属性是实例属性还是原型属性

in 的使用

var person = {};

function Person(){}

Person.prototype.name = “lala”;
Person.prototype.age = 18;
Person.prototype.sayName = function (){alert(this.name);};

var person1 = new Person();
alert(“name” in person1); //true

原型中的toString函数是不可枚举的

使用keys方法获取可枚举属性的字符串数组

var person = {};

function Person(){}

Person.prototype.name = “lala”;
Person.prototype.age = 18;
Person.prototype.sayName = function (){alert(this.name);};

var keys = Object.keys(Person.prototype); //注意这里如果写成Person是不行的

var person1 = new Person();
person1.name = “haha”;
person1.age = 20;
var key1 = Object.keys(person1); //注意这里如果写成person1.prototype是不行的

更常见的封装是
function Person() = {}

Person.prototype = {

name :"lala",
age :18,
sayName: function(){
alert(this.name);
}

};

var person = new Person();
alert(person.name); //lala

但是如果这样写
function Person(){}

var person = new Person();

Person.prototype = {

name :“lala”,
age :18
};

alert(person.name); //undefind

留给读者思考prototype指针，上面这种写法的prototype指针发生了变化

通过原生对象的原型，不仅可以用所有默认的方法，还有为它增加新的方法
例子：

String.prototype.startWith = function(text){
return String.indexOf(text) == 0;
};

var mas = “hello world”;
alert(mas.startWith(“h”); //true

我们一般都会使用混合模式来创建对象，既使用构造函数，也使用原型模式
例子：

function Person(name,age,job){

this.name = name;
this.age = age;
this.job = job;

}

Person.prototype.sayName = function(){

alert(this.name);

};

var person1 = new Person(“lala”,20,“engineer”);
var person2 = new Person(“haha”,20,“engineer”);

person1.sayName();
person2.sayName();

对13点的方法进行部分改造

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 person1 = new Person(“lala”,20,“engineer”);
var person2 = new Person(“haha”,20,“engineer”);

person1.sayName();
person2.sayName();

重温一下call和apply方法
apply:方法能劫持另外一个对象的方法，继承另外一个对象的属性.

Function.apply(obj,args)方法能接收两个参数
obj：这个对象将代替Function类里this对象
args：这个是数组，它将作为参数传给Function（args–>arguments）

call:和apply的意思一样,只不过是参数列表不一样.

Function.call(obj,[param1[,param2[,…[,paramN]]]])
obj：这个对象将代替Function类里this对象
params：这个是一个参数列表

分析: Person.apply(this,arguments);

this:在创建对象在这个时候代表的是student

arguments:是一个数组,也就是[“zhangsan”,”21”,”一年级”];

也就是通俗一点讲就是:用student去执行Person这个类里面的内容,在Person这个类里面存在this.name等之类的语句,这样就将属性创建到了student对象里面

利用apply可以干很多事情：
例如：
求最大值的Math.max(里面只能传n个参数,不能传入数组)
但是这样写可以传入数组

var getMax = Math.max.apply(null,array);