程序博客网 > mac book pro md101

js综合知识

来源：互联网 发布：mac book pro md101 编辑：程序博客网 时间：2024/04/29 03:13

文章出处:http://coolshell.cn/articles/6441.html

Javascript 面向对象编程

2012年1月9日陈皓发表评论阅读评论30,754 人阅读    

Javascript是一个类C的语言，他的面向对象的东西相对于C++/Java比较奇怪，但是其的确相当的强大，在 Todd 同学的“对象的消息模型”一文中我们已经可以看到一些端倪了。这两天有个前同事总在问我Javascript面向对象的东西，所以，索性写篇文章让他看去吧，这里这篇文章主要想从一个整体的角度来说明一下Javascript的面向对象的编程。（成文比较仓促，应该有不准确或是有误的地方，请大家批评指正）

另，这篇文章主要基于 ECMAScript 5， 旨在介绍新技术。关于兼容性的东西，请看最后一节。

初探

我们知道Javascript中的变量定义基本如下：

1
2
3
varname = 'Chen Hao';;
varemail = 'haoel(@)hotmail.com';
varwebsite = 'http://coolshell.cn';

如果要用对象来写的话，就是下面这个样子：

1
2
3
4
5
varchenhao = {
    name :'Chen Hao',
    email : 'haoel(@)hotmail.com',
    website : 'http://coolshell.cn'
};

于是，我就可以这样访问：

1
2
3
4
5
6
7
8
9
//以成员的方式
chenhao.name;
chenhao.email;
chenhao.website;
 
//以hash map的方式
chenhao["name"];
chenhao["email"];
chenhao["website"];

关于函数，我们知道Javascript的函数是这样的：

1
2
3
vardoSomething = function(){
   alert('Hello World.');
};

于是，我们可以这么干：

1
2
3
4
5
6
7
8
9
10
11
varsayHello = function(){
   varhello = "Hello, I'm "+this.name
                +", my email is: " + this.email
                +", my website is: " + this.website;
   alert(hello);
};
 
//直接赋值，这里很像C/C++的函数指针
chenhao.Hello = sayHello;
 
chenhao.Hello();

相信这些东西都比较简单，大家都明白了。 可以看到javascript对象函数是直接声明，直接赋值，直接就用了。runtime的动态语言。

还有一种比较规范的写法是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//我们可以看到， 其用function来做class。
varPerson = function(name, email, website){
    this.name = name;
    this.email = email;
    this.website = website;
 
    this.sayHello = function(){
        varhello = "Hello, I'm "+this.name  + ", \n" +
                    "my email is: " + this.email + ", \n" +
                    "my website is: " + this.website;
        alert(hello);
    };
};
 
varchenhao = newPerson("Chen Hao","haoel@hotmail.com",
                                     "http://coolshell.cn");
chenhao.sayHello();

顺便说一下，要删除对象的属性，很简单：

1
deletechenhao['email']

上面的这些例子，我们可以看到这样几点：

  1. Javascript的数据和成员封装很简单。没有类完全是对象操作。纯动态！
  2. Javascript function中的this指针很关键，如果没有的话，那就是局部变量或局部函数。
  3. Javascript对象成员函数可以在使用时临时声明，并把一个全局函数直接赋过去就好了。
  4. Javascript的成员函数可以在实例上进行修改，也就是说不同实例相同函数名的行为不一定一样。

属性配置 – Object.defineProperty

先看下面的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//创建对象
varchenhao = Object.create(null);
 
//设置一个属性
 Object.defineProperty( chenhao,
                'name', { value:  'Chen Hao',
                          writable:    true,
                          configurable:true,
                          enumerable:  true});
 
//设置多个属性
Object.defineProperties( chenhao,
    {
        'email' : { value:  'haoel@hotmail.com',
                     writable:    true,
                     configurable:true,
                     enumerable:  true},
        'website': { value: 'http://coolshell.cn',
                     writable:    true,
                     configurable:true,
                     enumerable:  true}
    }
);

下面就说说这些属性配置是什么意思。

  • writable：这个属性的值是否可以改。
  • configurable：这个属性的配置是否可以改。
  • enumerable：这个属性是否能在for…in循环中遍历出来或在Object.keys中列举出来。
  • value：属性值。
  • get()/set(_value)：get和set访问器。

Get/Set 访问器

关于get/set访问器，它的意思就是用get/set来取代value（其不能和value一起使用），示例如下：

1
2
3
4
5
6
7
8
9
10
11
var age = 0;
Object.defineProperty( chenhao,
            'age', {
                      get:function() {returnage+1;},
                      set:function(value) {age = value;}
                      enumerable : true,
                      configurable : true
                    }
);
chenhao.age = 100; //调用set
alert(chenhao.age);//调用get 输出101（get中+1了）;

我们再看一个更为实用的例子——利用已有的属性(age)通过get和set构造新的属性(birth_year)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Object.defineProperty( chenhao,
            'birth_year',
            {
                get:function() {
                    vard = newDate();
                    vary = d.getFullYear();
                    return( y - this.age );
                },
                set:function(year) {
                    vard = newDate();
                    vary = d.getFullYear();
                    this.age = y - year;
                }
            }
);
 
alert(chenhao.birth_year);
chenhao.birth_year = 2000;
alert(chenhao.age);

这样做好像有点麻烦，你说，我为什么不写成下面这个样子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
varchenhao = {
    name:"Chen Hao",
    email:"haoel@hotmail.com",
    website:"http://coolshell.cn",
    age: 100,
    get birth_year() {
        vard = newDate();
        vary = d.getFullYear();
        return( y - this.age );
    },
    set birth_year(year) {
        vard = newDate();
        vary = d.getFullYear();
        this.age = y - year;
    }
 
};
alert(chenhao.birth_year);
chenhao.birth_year = 2000;
alert(chenhao.age);

是的，你的确可以这样的，不过通过defineProperty()你可以干这些事：
1）设置如 writable，configurable，enumerable 等这类的属性配置。
2）动态地为一个对象加属性。比如：一些HTML的DOM对像。

查看对象属性配置

如果查看并管理对象的这些配置，下面有个程序可以输出对象的属性和配置等东西：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//列出对象的属性.
functionlistProperties(obj)
{
    varnewLine = "<br />";
    varnames = Object.getOwnPropertyNames(obj);
    for(vari = 0; i < names.length; i++) {
        varprop = names[i];
        document.write(prop + newLine);
 
        // 列出对象的属性配置（descriptor）动用getOwnPropertyDescriptor函数。
        vardescriptor = Object.getOwnPropertyDescriptor(obj, prop);
        for(varattr indescriptor) {
            document.write("..."+ attr + ': ' + descriptor[attr]);
            document.write(newLine);
        }
        document.write(newLine);
    }
}
 
listProperties(chenhao);

call，apply， bind 和 this

关于Javascript的this指针，和C++/Java很类似。 我们来看个示例：（这个示例很简单了，我就不多说了）

1
2
3
4
5
6
7
8
9
10
11
12
13
functionprint(text){
    document.write(this.value + ' - ' + text+ '<br>');
}
 
vara = {value: 10, print : print};
varb = {value: 20, print : print};
 
print('hello');// this => global, output "undefined - hello"
 
a.print('a');// this => a, output "10 - a"
b.print('b');// this => b, output "20 - b"
 
a['print']('a');// this => a, output "10 - a"

我们再来看看call 和 apply，这两个函数的差别就是参数的样子不一样，另一个就是性能不一样，apply的性能要差很多。（关于性能，可到 JSPerf 上去跑跑看看）

1
2
3
4
5
print.call(a,'a');// this => a, output "10 - a"
print.call(b,'b');// this => b, output "20 - b"
 
print.apply(a, ['a']);// this => a, output "10 - a"
print.apply(b, ['b']);// this => b, output "20 - b"

但是在bind后，this指针，可能会有不一样，但是因为Javascript是动态的。如下面的示例

1
2
3
4
varp = print.bind(a);
p('a');            // this => a, output "10 - a"
p.call(b,'b');    // this => a, output "10 - b"
p.apply(b, ['b']); // this => a, output "10 - b"

继承 和 重载

通过上面的那些示例，我们可以通过Object.create()来实际继承，请看下面的代码，Student继承于Object。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
varPerson = Object.create(null);
 
Object.defineProperties
(
    Person,
    {
        'name' : {  value: 'Chen Hao'},
        'email' : { value : 'haoel@hotmail.com'},
        'website': { value: 'http://coolshell.cn'}
    }
);
 
Person.sayHello = function() {
    varhello = "<p>Hello, I am "+this.name  + ", <br>" +
                "my email is: " + this.email + ", <br>" +
                "my website is: " + this.website;
    document.write(hello + "<br>");
}
 
varStudent = Object.create(Person);
Student.no = "1234567";//学号
Student.dept = "Computer Science";//系
 
//使用Person的属性
document.write(Student.name + ' ' + Student.email + ' ' + Student.website +'<br>');
 
//使用Person的方法
Student.sayHello();
 
//重载SayHello方法
Student.sayHello = function(person) {
    varhello = "<p>Hello, I am "+this.name  + ", <br>" +
                "my email is: " + this.email + ", <br>" +
                "my website is: " + this.website + ", <br>" +
                "my student no is: " + this. no + ", <br>" +
                "my departent is: " + this. dept;
    document.write(hello + '<br>');
}
//再次调用
Student.sayHello();
 
//查看Student的属性（只有 no 、 dept 和 重载了的sayHello）
document.write('<p>'+ Object.keys(Student) + '<br>');

通用上面这个示例，我们可以看到，Person里的属性并没有被真正复制到了Student中来，但是我们可以去存取。这是因为Javascript用委托实现了这一机制。其实，这就是Prototype，Person是Student的Prototype。

当我们的代码需要一个属性的时候，Javascript的引擎会先看当前的这个对象中是否有这个属性，如果没有的话，就会查找他的Prototype对象是否有这个属性，一直继续下去，直到找到或是直到没有Prototype对象。

为了证明这个事，我们可以使用Object.getPrototypeOf()来检验一下：

1
2
3
4
5
6
7
Student.name = 'aaa';
 
//输出 aaa
document.write('<p>'+ Student.name + '</p>');
 
//输出 Chen Hao
document.write('<p>'+Object.getPrototypeOf(Student).name + '</p>');

于是，你还可以在子对象的函数里调用父对象的函数，就好像C++里的 Base::func() 一样。于是，我们重载hello的方法就可以使用父类的代码了，如下所示：

1
2
3
4
5
6
7
//新版的重载SayHello方法
Student.sayHello = function(person) {
    Object.getPrototypeOf(this).sayHello.call(this);
    varhello = "my student no is: " + this. no + ", <br>" +
                "my departent is: " + this. dept;
    document.write(hello + '<br>');
}

这个很强大吧。

组合

上面的那个东西还不能满足我们的要求，我们可能希望这些对象能真正的组合起来。为什么要组合？因为我们都知道是这是OO设计的最重要的东西。不过，这对于Javascript来并没有支持得特别好，不好我们依然可以搞定个事。

首先，我们需要定义一个Composition的函数：（target是作用于是对象，source是源对象），下面这个代码还是很简单的，就是把source里的属性一个一个拿出来然后定义到target中。

1
2
3
4
5
6
7
8
9
10
11
12
13
functionComposition(target, source)
{
    vardesc  = Object.getOwnPropertyDescriptor;
    varprop  = Object.getOwnPropertyNames;
    vardef_prop = Object.defineProperty;
 
    prop(source).forEach(
        function(key) {
            def_prop(target, key, desc(source, key))
        }
    )
    returntarget;
}

有了这个函数以后，我们就可以这来玩了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//艺术家
varArtist = Object.create(null);
Artist.sing = function() {
    returnthis.name + ' starts singing...';
}
Artist.paint = function() {
    returnthis.name + ' starts painting...';
}
 
//运动员
varSporter = Object.create(null);
Sporter.run = function() {
    returnthis.name + ' starts running...';
}
Sporter.swim = function() {
    returnthis.name + ' starts swimming...';
}
 
Composition(Person, Artist);
document.write(Person.sing() + '<br>');
document.write(Person.paint() + '<br>');
 
Composition(Person, Sporter);
document.write(Person.run() + '<br>');
document.write(Person.swim() + '<br>');
 
//看看 Person中有什么？（输出：sayHello,sing,paint,swim,run）
document.write('<p>'+ Object.keys(Person) + '<br>');

Prototype 和 继承

我们先来说说Prototype。我们先看下面的例程，这个例程不需要解释吧，很像C语言里的函数指针，在C语言里这样的东西见得多了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
varplus = function(x,y){
    document.write( x + ' + ' + y + ' = ' + (x+y) + '<br>');
    returnx + y;
};
 
varminus = function(x,y){
    document.write(x + ' - ' + y + ' = ' + (x-y) + '<br>');
    returnx - y;
};
 
varoperations = {
    '+': plus,
    '-': minus
};
 
varcalculate = function(x, y, operation){
    returnoperations[operation](x, y);
};
 
calculate(12, 4, '+');
calculate(24, 3, '-');

那么，我们能不能把这些东西封装起来呢，我们需要使用prototype。看下面的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
varCal = function(x, y){
    this.x = x;
    this.y = y;
}
 
Cal.prototype.operations = {
    '+':function(x, y) { returnx+y;},
    '-':function(x, y) { returnx-y;}
};
 
Cal.prototype.calculate = function(operation){
    returnthis.operations[operation](this.x,this.y);
};
 
varc = newCal(4, 5);
 
c.calculate('+');
c.calculate('-');

这就是prototype的用法，prototype 是javascript这个语言中最重要的内容。网上有太多的文章介始这个东西了。说白了，prototype就是对一对象进行扩展，其特点在于通过“复制”一个已经存在的实例来返回新的实例,而不是新建实例。被复制的实例就是我们所称的“原型”，这个原型是可定制的（当然，这里没有真正的复制，实际只是委托）。上面的这个例子中，我们扩展了实例Cal，让其有了一个operations的属性和一个calculate的方法。

这样，我们可以通过这一特性来实现继承。还记得我们最最前面的那个Person吧， 下面的示例是创建一个Student来继承Person。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
functionPerson(name, email, website){
    this.name = name;
    this.email = email;
    this.website = website;
};
 
Person.prototype.sayHello = function(){
    varhello = "Hello, I am "+this.name  + ", <br>" +
                "my email is: " + this.email + ", <br>" +
                "my website is: " + this.website;
    returnhello;
};
 
functionStudent(name, email, website, no, dept){
    varproto = Object.getPrototypeOf;
    proto(Student.prototype).constructor.call(this, name, email, website);
    this.no = no;
    this.dept = dept;
}
 
// 继承prototype
Student.prototype = Object.create(Person.prototype);
 
//重置构造函数
Student.prototype.constructor = Student;
 
//重载sayHello()
Student.prototype.sayHello = function(){
    varproto = Object.getPrototypeOf;
    varhello = proto(Student.prototype).sayHello.call(this) + '<br>';
    hello += "my student no is: " + this. no + ", <br>" +
             "my departent is: " + this. dept;
    returnhello;
};
 
varme = newStudent(
    "Chen Hao",
    "haoel@hotmail.com",
    "http://coolshell.cn",
    "12345678",
    "Computer Science"
);
document.write(me.sayHello());

兼容性

上面的这些代码并不一定能在所有的浏览器下都能运行，因为上面这些代码遵循 ECMAScript 5 的规范，关于ECMAScript 5 的浏览器兼容列表，你可以看这里“ES5浏览器兼容表”。

本文中的所有代码都在Chrome最新版中测试过了。

下面是一些函数，可以用在不兼容ES5的浏览器中：

Object.create()函数
1
2
3
4
5
6
7
8
9
10
functionclone(proto) {
    functionDummy() { }
 
    Dummy.prototype             = proto;
    Dummy.prototype.constructor = Dummy;
 
    returnnew Dummy(); //等价于Object.create(Person);
}
 
varme = clone(Person);
defineProperty()函数
1
2
3
4
5
6
7
8
9
10
functiondefineProperty(target, key, descriptor) {
    if(descriptor.value){
        target[key] = descriptor.value;
    }else{
        descriptor.get && target.__defineGetter__(key, descriptor.get);
        descriptor.set && target.__defineSetter__(key, descriptor.set);
    }
 
    returntarget
}
keys()函数
1
2
3
4
5
6
7
8
functionkeys(object) { varresult, key
    result = [];
    for(key inobject){
        if(object.hasOwnProperty(key))  result.push(key)
    }
 
    returnresult;
}
Object.getPrototypeOf() 函数
1
2
3
4
5
functionproto(object) {
    return!object?                null
         :'__proto__'in object?  object.__proto__
         :/* not exposed? */      object.constructor.prototype
}
bind 函数
1
2
3
4
5
6
7
8
varslice = [].slice
 
functionbind(fn, bound_this) { varbound_args
    bound_args = slice.call(arguments, 2)
    returnfunction() { varargs
        args = bound_args.concat(slice.call(arguments))
        returnfn.apply(bound_this, args) }
}

参考

  • W3CSchool
  • MDN (Mozilla Developer Network)
  • MSDN (Microsoft Software Development Network)
  • Understanding Javascript OOP.
mac book pro md101 mac book pro md101
原创粉丝点击
热门IT博客
什么叫泛型编程什么叫泛型编程
风驰电掣软件风驰电掣软件
金贵软件会员部
博客群发软件
淘宝105手柄
访客来源 我的淘宝
windows.old可以移动吗
js alert 自动关闭
java模块化的好处
网络推手哪里找
磁悬浮列车 知乎
e绅士漫画网络错误
mac开发者描述文件
mac专柜价格多少
淘宝免单活动在哪里
dhcp默认租期 linux
淘宝卖家怎样修改类目
快递员软件
海湾报警系统编程手册
mac硬盘全抹除
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 上古强身术txt全文下载 上古强身术我是多余人 上古强身术女主推到顺序 上古强身术 我是多余人 强辉陶瓷 强辉 强辉瓷砖是几线品牌 露台地砖 玻化地砖 庭院地砖 地砖样式 人行道地砖 家装地砖 厨房铺什么地砖好 地砖切割刀 全瓷地砖 强迫爱人 被强迫爱人 强迫读音 强迫交易罪 强迫的读音 强迫拼音 强迫妻子 强迫的拼音 强迫症病因 强迫观念 晚睡强迫症 呼吸强迫症 洁癖强迫症 心理强迫症 思维强迫症 口水强迫症 强迫症患者 学习强迫症 强迫症测试 强迫症吧 强迫症药物 强迫的意思 强迫怀疑 重度强迫 被强迫的爱人

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里