Pengaturcaraan Lanjutan JavaScript (Edisi Ketiga) Nota Kajian Bab 6 dan 7_kemahiran javascript

Bab 6, Pengaturcaraan Berorientasikan Objek

Objek:

1. Atribut data

boleh dikonfigurasikan, menunjukkan sama ada atribut boleh ditakrifkan semula dengan memadamkan atribut melalui pemadaman, sama ada ciri atribut boleh diubah suai atau sama ada atribut itu boleh diubah suai menjadi atribut pengakses lalainya adalah benar

enumberbale, menunjukkan sama ada atribut boleh diakses melalui for-in, lalainya adalah benar

boleh ditulis, menunjukkan sama ada nilai atribut boleh diubah suai, lalainya adalah benar

nilai, lokasi storan data, lalai tidak ditentukan

Ubah suai ciri atribut lalai: Object.defineProperty(), yang menerima tiga parameter: objek tempat atribut terletak, nama atribut dan objek deskriptor Atribut objek deskriptor mestilah: boleh dikonfigurasikan, boleh dihitung, boleh ditulis, nilai

Contoh:

var obj = {};
Object.defineProperty(obj,”name”,{
writable:true,
value:”nihao”
}); 

2. Sifat pengakses

boleh dikonfigurasikan, menunjukkan sama ada atribut boleh ditakrifkan semula dengan memadamkan atribut melalui pemadaman, sama ada ciri atribut boleh diubah suai atau sama ada atribut itu boleh diubah suai menjadi atribut pengakses lalainya adalah benar

enumerbale, menunjukkan sama ada atribut boleh diakses melalui for-in, lalainya adalah benar

dapatkan, dipanggil semasa membaca atribut, lalai tidak ditentukan

set, dipanggil semasa menulis atribut, lalai tidak ditentukan

Pengubahsuaian mesti dilakukan melalui Object.defineProperty()

Contoh:

var obj = {
_year:2004,
edition:1
}
Object.defineProperty(book,”year”,{
get:function(){
return this._year;
},
set:function(newValue){
if(newValue > 2004){
this._year = newValue;
this.edition += newValue – 2004;
}
}
});
book.year = 2005;
alert(book.edition); //2 

Tentukan berbilang sifat: Object.defineProperties(), yang menerima dua objek Satu ialah sifat yang akan diubah suai atau ditambah Sifat objek kedua sepadan satu-dengan-satu dengan sifat objek pertama yang akan diubah suai atau ditambahkan Penyemak Imbas yang Disokong: IE9+, FireFox4+, Safari5+, Opera12+, chrome

Baca atribut: Object.getOwnPropertyDescriptor(), menerima dua parameter, objek tempat atribut terletak dan nama atribut deskriptor untuk dibaca Penyemak imbas yang disokong: IE9+, FireFox4+, Safari5+, Opera12+, chrome

Cipta objek:

Mod kilang:

function createPerson(name,age){
var o = new Object();
o.name = name;
o.age = age;
o.sayName = function(){
alert(this.name);
};
return o;
}
var person1 = createPerson(“g”,29); 

Corak pembina:

function Person(name,age){
this.name = name;
this.age = age;
this.sayName() = function(){
alert(this.name);
};
}
var person = new Person(“g”,28); 

Perbezaan antara dua mod:

Dalam mod pembina, tidak perlu mencipta objek secara eksplisit, memberikan nilai kepada ini secara langsung, dan tiada pernyataan pulangan

Huruf pertama nama pembina mesti menggunakan huruf besar, dan operator baharu mesti digunakan untuk mencipta contoh baharu

Mod Prototaip

Setiap fungsi yang dicipta mempunyai atribut prototaip, yang merupakan penunjuk kepada objek Tujuan objek ini adalah untuk mengandungi sifat dan kaedah yang boleh dikongsi oleh semua contoh jenis tertentu objek prototaip objek yang dicipta oleh fungsi Kelebihannya ialah semua kejadian boleh berkongsi sifat dan kaedah yang sama.

isPrototypeOf(), pemahaman peribadi saya ialah ia boleh digunakan untuk menentukan sama ada prototaip suatu kejadian adalah sama dengan prototaip semasa

Contoh:

Person.prototype.isPrototypeOf(person1); //true

Object.getPrototypeOf(), boleh mengembalikan prototaip contoh tertentu, pelayar yang disokong IE9+, Firefox3.5+, Safari5+, Opera12+, chrome

Nota: Apabila mengakses nama atribut objek, carian akan dilakukan Pertama, cari dalam objek contoh Jika ia tidak wujud, cari dalam objek prototaip objek semasa.

Nota: Jika atribut dalam contoh adalah sama dengan atribut dalam objek prototaip, atribut objek prototaip akan disekat, yang betul-betul sama dengan yang sebelumnya

Kaedah hasOwnProperty() boleh menentukan sama ada sesuatu harta itu datang daripada suatu tika. Jika ia tidak datang daripada suatu tika, ia akan mengembalikan palsu, jika tidak ia akan mengembalikan benar

Apabila anda memanggil padam pada contoh, hanya nama atribut pada tika itu akan dipadamkan dan atribut prototaip tidak akan dipadamkan

Contoh:

function Person(){
}
Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.sayName = function(){
alert(this.name);
}
var per1 = new Person();
var per2 = new Person();
per1.name = "Greg";
alert(per1.name); //"Greg" 来自实例
alert(per2.name); //"Nicholas"
delete per1.name;
alert(per1.name); //"Nicholas" 来自原型
delete per1.name;
alert(per1.name); //"Nicholas" 

Nota: Kaedah Object.getOwnPropertyDescriptor() hanya boleh digunakan untuk sifat contoh Untuk mendapatkan deskriptor sifat prototaip, kaedah ini mesti dipanggil terus pada objek prototaip

dalam operator: Mengembalikan benar hanya jika atribut berada dalam objek contoh atau dalam objek prototaip

Contoh:

alert(“name” in Person); //true
alert(“name” in per1); //true 

Gunakan dalam dan hasOwnProperty pada masa yang sama untuk menentukan sama ada harta itu wujud dalam prototaip atau contoh

Kaedah Object.keys(): menerima objek sebagai parameter dan mengembalikan tatasusunan rentetan yang terdiri daripada semua sifat terhitung

Kaedah Object.getOwnPropertyNames(): menerima objek dan mengembalikan tatasusunan rentetan yang terdiri daripada semua sifat, sama ada boleh dikira atau tidak

Sintaks prototaip yang lebih mudah:

Terlalu menyusahkan untuk menggunakan kaedah di atas Kaedah berikut lebih biasa digunakan: menggunakan literal objek

Person.prototype = {
name : “Nicholas”,
age : 29
sayName = function(){
alert(this.name);
}
} 

Walau bagaimanapun, kaedah ini bersamaan dengan menulis semula keseluruhan objek prototaip, yang akan menyebabkan sifat pembina tidak lagi menunjuk kepada Orang tetapi kepada Objek Walaupun instanceof masih akan mengembalikan hasil yang betul, jenis objek tidak boleh ditentukan melalui pembina .

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

若constructor真的很重要，可以如下设置

Person.prototype = {
constructor:Person,
name : “Nicholas”,
age : 29
sayName = function(){
alert(this.name);
}
} 

以上写法会使constructor的enumerable特性被设置为true，默认情况下原生的是false的，在兼容ECMAScript5的浏览器可以使用Object.defineProperty()进行设置

Object.defineProperty(Person.prototype,”constructor”,{
enumerable:false,
value:Person
}); 

注：重写原型对象，将会切断现有原型与任何之前已经存在的对象实例之间的联系

继承（难度较大，需再仔细研究）

使用原型链来实现

子类型要覆盖超类的方法，应该将给原型添加方法的代码放在替换原型之后，

注：通过原型链实现继承时，不能使用对象字面量创建原型方法，否则会重写原型链

借用构造函数

组合继承

原型式继承，Object.creat();接收两个参数：一是用作新对象原型的对象和（可选的）一个为新对象定义额外属性的对象

例：Object.creat(person,{name:{value:”greg”}});

寄生式继承

寄生组合式继承

第7章，函数表达式

创建方式：

1、函数声明，可以函数声明提升，就是可以把使用函数的语句放在函数声明之前

function funName(arg0,arg1){
//函数体
} 

2、函数表达式，不能进行函数提升，也就是无法在函数创建前使用函数，在这种情况下创建的函数称为匿名函数，有时也叫拉姆达函数

var funName = function(arg0,arg1){
//函数体
} 

严格模式下无法使用arguments.callee来实现递归，可以使用如下方式实现递归：

var factorial = (function f(num){
if(num <= 1){
return 1;
}else{
return num * f(num - 1);
}
}); 

闭包（难度也不小）

闭包指有权访问另一个函数作用域中的变量的函数，闭包，也是一个函数

创建闭包的常见方式是在一个函数内部创建另一个函数

闭包只能取得包含函数即外部函数中任何变量的最后一个值。下例可以清晰说明问题

例：

function createFuncrions(){
var result = new Array();
for(var i = 0;i < 10;i++){
result[i] = function(){
return i;
}
}
return result;
}
var re = createFuncrions();
alert(re[1](2)); 

每个函数返回的都将是10，而不是如预期般返回对应的索引值，因为createFuncrions函数最后返回时I = 10，此时每个函数都引用保存着变量i的同一个对象，所以在每个函数内部i都是10，可以使用如下方法强制闭包返回预期效果：

function createFuncrions(){
var result = new Array();
for(var i = 0;i < 10;i++){
result[i] = function(num){
return function(){
return num;
};
}(i);
}
return result;
}
var re = createFuncrions();
alert(re[2]()); 

每一个都会返回各自的索引值

模仿块级作用域

使用匿名函数可以模仿块级作用域：

(function(){
alert("test"); //块级作用域，没有使用圆括号将function包起来将会出错
})(); 

使用闭包和私有变量的明显不足之处在于，会在作用域链中多查找一个层次，在一定程度上影响查找速度

函数中定义的变量可以在一定程度上称为私有变量，通过函数可以模拟出私有变量，静态私有变量

增强模块模式：

var singleton = function(){
//private arg and private method
var privateVariable = 10;
function privateFunction(){
return false;
}
//create obj
var obj = new Object();
obj.publicProperty = true;
obj.publicFunction = function(){
privateVariable ++;
return privateFunction();
};
return obj;
}();
alert(typeof singleton);
alert(singleton.publicProperty);
alert(singleton.publicFunction());

以上内容是小编给大家介绍的JavaScript高级程序设计（第三版）学习笔记6、7章，希望对大家有所帮助！