JavaScript中的原型和原型链

1、原型是什么?原型链是什么?

原型是一个prototype对象,用于表示类型之间的关系;

原型链指的是在JavaScript中对象之间的继承是通过prototype对象指向父类对象,直到指向Object对象为止,这样就形成了一个原型指向的链条,专业术语称之为原型链。

举例:

Student——>Person——>Object:学生继承人这个类,人这个类继承对象类;

<span style="font-size:14px;">  var Person=function(){      this.age="匿名"  };
  var Student=function(){};
  //创建继承关系,prototype执行Person的一个实例对象
  Student.prototype=new  Person();</span>  

五条原型规则:

1、所有的引用类型(数组、对象、函数),都具有对象特性,即可自由扩展属性(除了“null”以外);

2、所有的引用类型都有一个_proto_属性,叫隐式原型,属性值是一个普通的对象;

3、所有的函数,都有一个prototype属性,叫显式原型,属性值是一个普通的对象;

4、所有的引用类型的_proto_属性,指向它的构造函数的prototype属性值;

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title></title>
        <script>
            //所有的引用类型都具有对象属性
            var obj = {};
            obj.a = 100;
            var arr = [];
            arr.a = 100;
            function fn(){}
            fn.a = 100;

            //所有的引用类型都有一个隐式原型
            console.log(obj.__proto__);
            console.log(arr.__proto__);
            console.log(fn.__proto__);

            //所有的函数都有一个prototype属性
            console.log(fn.prototype);

            //所有的引用类型,__proto__属性值指向它的构造函数的“prototype”属性值
            console.log(obj.__proto__ === Object.prototype);
        </script>
    </head>
    <body>

    </body>
</html>

5、当试图得到一个对象的某个属性时,如果没有,会向它的_proto_中寻找,即去它的构造函数的prototype中寻找。

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title></title>
        <script>
            //构造函数
            function Foo(name,age){
                this.name = name;
            }
            Foo.prototype.alerName = function(){
                alert(this.name);
            }
            //创建实例
            var f = new Foo(‘zhangsan‘);
            f.printName = function(){
                console.log(this.name);
            }
            //测试
            f.printName();
            f.alerName();
        </script>
    </head>
    <body>

    </body>
</html>

再次举例:

Dog类继承了Animal类,随即拥有的Animal的eat方法(非常low的一个例子)

<script type="text/javascript">
        function Animal() {
            this.eat = function () {
                console.log("animal eat");
            }
        }

        function Dog() {
            this.bark = function () {
                console.log("dog bark")
            }
        }

        Dog.prototype = new Animal();
        var hashiqi = new Dog();
        hashiqi.eat();    //animal eat
        hashiqi.bark();   //dog bark
    </script>

接近实战的例子(一个封装DOM查询的例子):

//一定要非常注意JavaScript的位置
<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title></title>
    </head>
    <body>
        <div id="box">
            <span>测试原型继承封装原生JavaScript</span>
        </div>
    </body>
    <script>
        function Elem(id){
            this.elem = document.getElementById(id);
        }
        Elem.prototype.html = function(val){
            var elem = this.elem;
            if(val){
                elem.innerHTML = val;
                //链式操作
                return this;
            }else{
                return elem.innerHTML;
            }
        }
        Elem.prototype.on = function(type,fn){
            var elem = this.elem;
            elem.addEventListener(type,fn);
            return this;
        }
        var div1 = new Elem(‘box‘);
        div1.html(‘<p>hello imooc</p>‘).on(‘click‘,function(){
            alert(‘clicked‘);
        }).html(‘<p>javascript</p>‘);
    </script>
</html>

时间: 2024-10-17 17:23:40

JavaScript中的原型和原型链的相关文章

Javascript中的对象和原型(3)

在Javascript中的对象和原型(二)中我们提到,用构造函数创建的对象里面,每个对象之间都是独立的,这样就会降低系统资源的利用率,解决这样问题,我们就要用到下面提到的原型对象. 一 原型对象 原型对象实际上就是构造函数的一个实例对象,和普通的实例对象没有本质上的区别.可以包含特定类型的所有实例的共享属性或者方法.这样,如果我们需要修改所有实例中的属性或者方法,就只需要修改一处,就能够影响到所有实例了.因为原型中的属性和方法是共享的.我们可以看下两个图示:       构造函数方式 原型模式方

JavaScript中的继承与原型链

先看一个例子 function User(){} var u1 = new User(); console.log(u1.prototype);// undefined 使用对象实例无法访问到prototype console.log(User.prototype);//{},使用构造函数名访问prototype console.log(u1.__proto__);//{},使用对象实例访问prototype的指针 这个是 __proto__ 和prototype最基本的区别:说明构造的对象无p

JavaScript中的继承(原型链)

一.原型链 ECMAScript中将原型链作为实现继承的主要方法,基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法. 实例1: function SupType() { this.property = true; } SupType.prototype.getSupvalue = function() { return this.property; }; function SubType() { this.subproperty = false; } //原型对象等于一个类型的实例

javascript中的构造函数和原型及原型链

纯属个人理解,有错误的地方希望大牛指出,以免误人子弟 1.构造函数: 构造函数的作用 : 初始化由new创建出来的对象    new 的作用: 创建对象(空对象) new 后面跟的是函数调用,使用new来调用函数,跟普通的直接调用函数主要的不同: 就是 this 的指向不同了 , 再就是 会自动的返回新创建的对象 什么是原型?        原型的作用:就是为了实现继承!  一个对象的原型就是它的构造函数的prototype属性的值. 在讨论原型的时候,是指的 对象和原型对关系 prototyp

Javascript中获取对象的原型对象

在Javascript中,如果我们有一个对象但是又不知道它的构造函数时,如何获取它的原型对象呢? 在Chrome中或是FireFox浏览器中,我们可以直接使用对象的__proto__属性获取它的原型对象. <!-- lang: js --> function F(){}; var foo = new F(); alert(foo.__proto__ == F.prototype); 但是,__proto__属性在IE浏览器中一直到IE11才被支持. 那么在不支持__proto__属性的浏览器中

Javascript中的构造函数与原型

构造函数 构造函数,是一种特殊的方法.主要用来创建对象时初始化对象,即为对象成员变量赋初始值,总与new运算符一起使用在创建对象的语句中.特别的一个类可以有多个构造函数,可根据其参数个数的不同或参数类型的不同来区分它们即构造函数的重载. 示例: <span style="font-size:18px;">function Box(name,age) { this.name=name; this.age=age; this.run=function(){ return thi

JavaScript——中的prototype(原型)

JS中的prototype是JS中比较难理解的一个部分 本文基于下面几个知识点: 1 原型法设计模式 在.Net中可以使用clone()来实现原型法 原型法的主要思想是,现在有1个类A,我想要创建一个类B,这个类是以A为原型的,并且能进行扩展.我们称B的原型为A. 2 javascript的方法可以分为三类: a 类方法 b 对象方法 c 原型方法 例子: function People(name){  this.name=name;  //对象方法  this.Introduce=functi

JavaScript中的作用域和作用域链(边学边写)[看着别人的博客纯手敲]

作用域是JavaScript最重要的概念之一,想要学好JavaScript就需要理解JavaScript作用域和作用域的工作原理.今天这篇文章对JavaScript作用域和作用域链简单的介绍,希望能帮助大家更好的学习JavaScript. JavaScript作用域 任何程序设计语言都有作用域的概念,简单的说,作用域就是变量与函数的可访问范围,即作用域控制着变量与函数的可见性和生命周期.在JavaScript中,变量的作用域有全局作用域和局部作用域两种. 1.全局作用域(Global Scope

JavaScript中的作用域 、作用域链和闭包

JavaScript中作用,作用域链和闭包详解 一.作用域在js中有全局变量和局部变量之分:比如var a = 1;function sum(){var b=1console.log(b) //1console.log(a) //2 }sum()console.log(a) //3console.log(b) //4 例子中 a 是全局变量,b是局部变量(定义在函数内部,只能在函数内部访问)所以第1行正确 函数内部也能访问全局变量 a所以第2行也能正确 第三行也正确.第4行有外部不能访问内部变量

javascript中的模式解析——原型模式

理解原型模式,首先要理解prototyoe(这个单词翻译 原型)属性,<javascript高级程序设计>书中描述到——我们创建的每个函数都有一个prototype属性,这个属性是一个指针,指向一个对象,而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法. 我在上一篇构造函数模式所说的,我们构建了一个一个Person函数,然后通过new一个person函数来创建了person1实例,person2实例,既然每个函数都有一个prototype属性,那么我有几个问题想要弄明白: per