马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。
您需要 登录 才可以下载或查看，没有账号？立即注册
×
第 15 章 面向对象与原型
1.创建对象
2.原型
3.继续
ECMAScript 有两种开辟模式：1.函数式(过程化)，2.面向对象(OOP)。面向对象的语言有一个标志，那就是类的概念，而通过类可以创建恣意多个具有类似属性和方法的对象。但是，ECMAScript 没有类的概念，因此它的对象也与基于类的语言中的对象有所差别。
一．创建对象
创建一个对象，然后给这个对象新建属性和方法。- var box = new Object(); //创建一个 Object 对象
- box.name = 'Lee'; //创建一个 name 属性并赋值
- box.age = 100; //创建一个 age 属性并赋值
- box.run = function () { //创建一个 run()方法并返回值
- return this.name + this.age + '运行中...';
- };
- alert(box.run()); //输出属性和方法的值
- var box2 = box; //得到 box 的引用
- box2.name = 'Jack'; //直接改变了 name 属性
- alert(box2.run()); //用 box.run()发现 name 也改变了
- var box2 = new Object(); box2.name = 'Jack'; box2.age = 200; box2.run = function () {
- return this.name + this.age + '运行中...';
- };
- alert(box2.run()); //这样才避免和 box 混淆，从而保持独立
- function createObject(name, age) { //集中实例化的函数 var obj = new Object();
- obj.name = name; obj.age = age; obj.run = function () {
- return this.name + this.age + '运行中...';
- };
- return obj;
- }
- var box1 = createObject('Lee', 100); //第一个实例
- var box2 = createObject('Jack', 200); //第二个实例
- alert(box1.run());
- alert(box2.run()); //保持独立
- alert(typeof box1); //Object
- alert(box1 instanceof Object); //true
象。- function Box(name, age) { //构造函数模式
- this.name = name;
- this.age = age;
- this.run = function () {
- return this.name + this.age + '运行中...';
- };
- }
- var box1 = new Box('Lee', 100); //new Box()即可
- var box2 = new Box('Jack', 200);
- alert(box1.run());
- alert(box1 instanceof Box); //很清晰的识别他从属于 Box
使用了构造函数的方法，和使用工厂模式的方法他们差别之处如下：
1.构造函数方法没有体现的创建对象(newObject())；
2.直接将属性和方法赋值给 this 对象；
3.没有 renturn 语句。
构造函数的方法有一些规范：
1.函数名和实例化构造名类似且大写，(PS：非欺压，但这么写有助于区分构造函数宁静凡函数)；
2.通过构造函数创建对象，必须使用 new 运算符。
既然通过构造函数可以创建对象，那么这个对象是那里来的，new Object()在什么地方实行了？实行的过程如下：
1.当使用了构造函数，而且 new 构造函数()，那么就配景实行了 new Object()；2.将构造函数的作用域给新对象，(即 new Object()创建出的对象)，而函数体内的 this 就
代表 new Object()出来的对象。
3.实行构造函数内的代码；
4.返回新对象(配景直接返回)。
关于 this 的使用，this 实在就是代表当前作用域对象的引用。假如在全局范围 this 就代表 window 对象，假如在构造函数体内，就代表当前的构造函数所声明的对象。- var box = 2;
- alert(this.box); //全局，代表 window
- var box = new Box('Lee', 100); //构造模式调用 alert(box.run());
- Box('Lee', 20); //普通模式调用，无效
- var o = new Object();
- Box.call(o, 'Jack', 200) //对象冒充调用 alert(o.run());
等。- var box1 = new Box('Lee', 100); //传递一致
- var box2 = new Box('Lee', 100); //同上
- alert(box1.name == box2.name); //true，属性的值相等
- alert(box1.run == box2.run); //false，方法其实也是一种引用地址
- alert(box1.run() == box2.run()); //true，方法的值相等，因为传参一致
证实，他们终极判断的是引用地点，唯一性。- function Box(name, age) { //new Function()唯一性
- this.name = name;
- this.age = age;
- this.run = new Function("return this.name + this.age + '运行中...'");
- }
法没什么须要，只是加深学习相识：- function Box(name, age) {
- this.name = name;
- this.age = age;
- this.run = run;
- }
- function run() { //通过外面调用，保证引用地址一致
- return this.name + this.age + '运行中...';
- }
二．原型
我们创建的每个函数都有一个 prototype(原型)属性，这个属性是一个对象，它的用途是包罗可以由特定范例的全部实例共享的属性和方法。逻辑上可以这么明白：prototype 通过调用构造函数而创建的谁人对象的原型对象。使用原型的利益可以让全部对象实例共享它所包罗的属性和方法。也就是说，不必在构造函数中界说对象信息，而是可以直接将这些信息添加到原型中。- function Box() {} //声明一个构造函数
- Box.prototype.name = 'Lee'; //在原型里添加属性
- Box.prototype.age = 100;
- Box.prototype.run = function () { //在原型里添加方法
- return this.name + this.age + '运行中...';
- };
- var box1 = new Box();
- var box2 = new Box();
- alert(box1.run == box2.run); //true，方法的引用地址保持一致
构造函数方式
原型模式方式
在原型模式声明中，多了两个属性，这两个属性都是创建对象时主动天生的。__proto__属性是实例指向原型对象的一个指针，它的作用就是指向构造函数的原型属性 constructor。通过这两个属性，就可以访问到原型里的属性和方法了。
PS：IE 欣赏器在脚本访问__proto__会不能辨认，火狐和谷歌欣赏器及其他某些欣赏器均能辨认。固然可以输出，但无法获取内部信息。- alert(box1.__proto__); //[object Object]
- 判断一个对象是否指向了该构造函数的原型对象，可以使用 isPrototypeOf()方法来测试。 alert(Box.prototype.isPrototypeOf(box)); //只要实例化对象，即都会指向
1.先查找构造函数实例里的属性或方法，假如有，立即返回；
2.假如构造函数实例里没有，则去它的原型对象里找，假如有，就返回；
固然我们可以通过对象实例访问生存在原型中的值，但却不能访问通过对象实例重写原型中的值。- var box1 = new Box();
- alert(box1.name); //Lee，原型里的值
- box1.name = 'Jack';
- alert(box.1name); //Jack，就近原则，
- var box2 = new Box();
- alert(box2.name); //Lee，原型里的值，没有被 box1 修改
- delete box1.name; //删除属性
- alert(box1.name);
- alert(box.hasOwnProperty('name')); //实例里有返回 true，否则返回 false
in 操纵符会在通过对象可以或许访问给定属性时返回 true，无论该属性存在于实例中还是原型中。- alert('name' in box); //true，存在实例中或原型中
- function isProperty(object, property) { //判断原型中是否存在属性
- return !object.hasOwnProperty(property) && (property in object);
- }
- var box = new Box();
- alert(isProperty(box, 'name')) //true，如果原型有
- function Box() {};
- Box.prototype = { //使用字面量的方式 name : 'Lee',
- age : 100,
- run : function () {
- return this.name + this.age + '运行中...';
- }
- };
- var box = new Box();
- alert(box instanceof Box);
- alert(box instanceof Object);
- alert(box.constructor == Box); //字面量方式，返回 false，否则，true
- alert(box.constructor == Object); //字面量方式，返回 true，否则，false
- 如果想让字面量方式的 constructor 指向实例对象，那么可以这么做：
- Box.prototype = {
- constructor : Box, //直接强制指向即可
- };
就是创建了一个新对象。而每创建一个函数，就会同时创建它 prototype，这个对象也会主动获取 constructor 属性。以是，新对象的 constructor 重写了 Box 原来的 constructor，因此会指向新对象，谁人新对象没有指定构造函数，那么就默以为 Object。
原型的声明是有先后次序的，以是，重写的原型会堵截之前的原型。- function Box() {};
- Box.prototype = { //原型被重写了
- constructor : Box,
- name : 'Lee',
- age : 100,
- run : function () {
- return this.name + this.age + '运行中...';
- }
- };
- Box.prototype = {
- age = 200
- };
- var box = new Box(); //在这里声明
- alert(box.run()); //box 只是最初声明的原型
- alert(Array.prototype.sort); //sort 就是 Array 类型的原型方法
- alert(String.prototype.substring); //substring 就是 String 类型的原型方法
- String.prototype.addstring = function () { //给 String 类型添加一个方法
- return this + '，被添加了！'; //this 代表调用的字符串
- };
- alert('Lee'.addstring()); //使用这个方法
原型模式创建对象也有自己的缺点，它省略了构造函数传参初始化这一过程，带来的缺点就是初始化的值都是同等的。而原型最大的缺点就是它最大的优点，那就是共享。
原型中全部属性是被很多实例共享的，共享对于函数非常符合，对于包罗根本值的属性也还可以。但假如属性包罗引用范例，就存在肯定的题目：- function Box() {}; Box.prototype = {
- constructor : Box,
- name : 'Lee',
- age : 100,
- family : ['父亲', '母亲', '妹妹'], //添加了一个数组属性
- run : function () {
- return this.name + this.age + this.family;
- }
- };
- var box1 = new Box();
- box1.family.push('哥哥'); //在实例中添加'哥哥'
- alert(box1.run());
- var box2 = new Box();
- alert(box2.run()); //共享带来的麻烦，也有'哥哥'了
为了办理构造传参和共享题目，可以组合构造函数+原型模式：- function Box(name, age) { //不共享的使用构造函数
- this.name = name;
- this.age = age;
- this. family = ['父亲', '母亲', '妹妹'];
- };
- Box.prototype = { //共享的使用原型模式 constructor : Box,
- run : function () {
- return this.name + this.age + this.family;
- }
- };
原型模式，不管你是否调用了原型中的共享方法，它都会初始化原型中的方法，而且在声明一个对象时，构造函数+原型部门让人感觉又很怪异，最好就是把构造函数和原型封装到一起。为了办理这个题目，我们可以使用动态原型模式。- function Box(name ,age) { //将所有信息封装到函数体内
- this.name = name;
- this.age = age;
- if (typeof this.run != 'function') { //仅在第一次调用的初始化
- Box.prototype.run = function () {
- return this.name + this.age + '运行中...';
- };
- }
- }
- var box = new Box('Lee', 100); alert(box.run());
- if (typeof this.run != 'function') { alert('第一次初始化'); //测试用
- Box.prototype.run = function () {
- return this.name + this.age + '运行中...';
- };
- }
- var box = new Box('Lee', 100); //第一次创建对象
- alert(box.run()); //第一次调用
- alert(box.run()); //第二次调用
- var box2 = new Box('Jack', 200); //第二次创建对象
- alert(box2.run());
- alert(box2.run());
以上解说了各种方式对象创建的方法，假如这几种方式都不能满意需求，可以使用一开始那种模式：寄生构造函数。- function Box(name, age) { var obj = new Object(); obj.name = name; obj.age = age;
- obj.run = function () {
- return this.name + this.age + '运行中...';
- };
- return obj;
- }
在什么环境下使用寄生构造函数比力符合呢？假设要创建一个具有额外方法的引用范例。由于之前分析不发起直接 String.prototype.addstring，可以通过寄生构造的方式添加。- function myString(string) {
- var str = new String(string); str.addstring = function () {
- return this + '，被添加了！';
- };
- return str;
- }
- var box = new myString('Lee'); //比直接在引用原型添加要繁琐好多
- alert(box.addstring());
- function Box(name , age) {
- var obj = new Object();
- obj.run = function () {
- return name + age + '运行中...'; //直接打印参数即可
- };
- return obj;
- }
- var box = Box('Lee', 100); //直接调用函数
- alert(box.run());
四．继续
继续是面向对象中一个比力核心的概念。其他正统面向对象语言都会用两种方式实现继续：一个是接口实现，一个是继续。而 ECMAScript 只支持继续，不支持接口实现，而实现继续的方式依赖原型链完成。- function Box() { //Box 构造
- this.name = 'Lee';
- }
- function Desk() { //Desk 构造
- this.age = 100;
- }
- Desk.prototype = new Box(); //Desc 继承了 Box，通过原型，形成链条
- var desk = new Desk();
- alert(desk.age);
- alert(desk.name); //得到被继承的属性
- function Table() { //Table 构造
- this.level = 'AAAAA';
- }
- Table.prototype = new Desk(); //继续原型链继承
- var table = new Table();
- alert(table.name); //继承了 Box 和 Desk
假如要实例化 table，那么Desk实例中有age=100，原型中增长类似的属性 age=200，末了结果是多少呢？- Desk.prototype.age = 200; //实例和原型中均包含 age
- PS：以上原型链继承还缺少一环，那就是 Obejct，所有的构造函数都继承自 Obejct。而继承 Object 是自动完成的，并不需要程序员手动继承。
- 经过继承后的实例，他们的从属关系会怎样呢？
- alert(table instanceof Object); //true
- alert(desk instanceof Table); //false，desk 是 table 的超类
- alert(table instanceof Desk); //true
- alert(table instanceof Box); //true
为了办理引用共享和超范例无法传参的题目，我们采取一种叫借用构造函数的技能，大概成为对象假冒(伪造对象、经典继续)的技能来办理这两种题目。- function Box(age) {
- this.name = ['Lee', 'Jack', 'Hello'] this.age = age;
- }
- function Desk(age) {
- Box.call(this, age); //对象冒充，给超类型传参
- }
- var desk = new Desk(200); alert(desk.age); alert(desk.name);
- desk.name.push('AAA'); //添加的新数据，只给 desk alert(desk.name);
要原型链+借用构造函数的模式，这种模式成为组合继续。- function Box(age) {
- this.name = ['Lee', 'Jack', 'Hello'] this.age = age;
- }
- Box.prototype.run = function () {
- return this.name + this.age;
- };
- function Desk(age) {
- Box.call(this, age); //对象冒充
- }
- Desk.prototype = new Box(); //原型链继承
- var desk = new Desk(100);
- alert(desk.run());
- function obj(o) { //传递一个字面量函数
- function F() {} //创建一个构造函数
- F.prototype = o; //把字面量函数赋值给构造函数的原型
- return new F(); //最终返回出实例化的构造函数
- }
- var box = { //字面量对象
- name : 'Lee',
- arr : ['哥哥','妹妹','姐姐']
- };
- var box1 = obj(box); //传递
- alert(box1.name);
- box1.name = 'Jack'; alert(box1.name);
- alert(box1.arr); box1.arr.push('父母'); alert(box1.arr);
- var box2 = obj(box); //传递
- alert(box2.name);
- alert(box2.arr); //引用类型共享了
- function create(o) { //封装创建过程
- var f= obj(o);
- f.run = function () {
- return this.arr; //同样，会共享引用
- };
- return f;
- }
- function Box(name) {
- this.name = name;
- this.arr = ['哥哥','妹妹','父母'];
- }
- Box.prototype.run = function () { return this.name;
- };
- function Desk(name, age) {
- Box.call(this, name); //第二次调用 Box this.age = age;
- }
- Desk.prototype = new Box(); //第一次调用 Box
- function obj(o) {
- function F() {}
- F.prototype = o;
- return new F();
- }
- function create(box, desk) {
- var f = obj(box.prototype);
- f.constructor = desk;
- desk.prototype = f;
- }
- function Box(name) {
- this.name = name;
- this.arr = ['哥哥','妹妹','父母'];
- }
- Box.prototype.run = function () {
- return this.name;
- };
- function Desk(name, age) {
- Box.call(this, name);
- this.age = age;
- }
- inPrototype(Box, Desk); //通过这里实现继承
- var desk = new Desk('Lee',100);
- desk.arr.push('姐姐');
- alert(desk.arr);
- alert(desk.run()); //只共享了方法
- var desk2 = new Desk('Jack', 200);
- alert(desk2.arr); //引用问题解决
|
发表于 2026-1-31 12:17:30