• js13--对象、原型


    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
    <html>
        <head>
            <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
            <title>Untitled Document</title>
            <script type=text/javascript charset=utf-8>
            var obj = new Object(); // 一样的var obj = {};     var a = new F();
            obj.name = 'z3';
            obj.sex  = '';
            obj.sayName = function(){alert('我是张三!')};
            // 类的概念
            
            // 第一种形式 工厂模型 
            function createPerson(name , sex , age){
                var obj = new Object();
                obj.name = name ; 
                obj.sex = sex ;
                obj.age = age ;
                obj.sayName = function(){
                    alert(this.name);
                }
                return obj;
            }
            var p1 = createPerson('z3' , '' , 20);
            var p2 = createPerson('z4' , '' , 25);
            alert(p1.sex);
            p1.sayName();
            
            // 第二中形式 构造函数式  new Array new Date
            // 函数的第一个字母大写 (类的模版)
            function Person(name , age , sex){
                this.name = name ;
                this.age  = age ; 
                this.sex  = sex ;
                this.sayName = function(){
                    alert(this.name);
                }
            }
            
            //构造一个对象 new关键字 传递参数 执行模版代码 返回对象
            
            var p1 = new Person('小1' , 20 , '');
            var p2 = new Person('小2' , 21 , '');
            alert(p1.name);
            p1.sayName();
            alert(p1 == p2); //false, 
            
            alert(p1.constructor == Person);
            alert(p2.constructor == Person);
        
            alert(p1 instanceof Person);    //true
            alert(p1 instanceof Object);    //true
            
            //创建对象的方式:
            // 1当作构造函数去使用 :
            var p1 = new Person('小1' , 20 , '');
            // 2作为普通的函数去调用
            Person('小2' , 25 , '');//在全局环境里定义属性并复制 直接定义在window上,this是window,
            alert(name);
            // 3在另一个对象的作用域中调用
            var o = new Object();  
            // call  applly
            Person.call(o,'小4' , 12 , '');  //o动态加一个方法,一次性的,复制方法的属性
            alert(o.name);
            </script>
        </head>
        <body>
        </body>
    </html>
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
    <html>
        <head>
            <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
            <title>Untitled Document</title>
            <script type=text/javascript charset=utf-8>
            //同级函数可以互相访问
            function Person(name , age){
                this.name = 1 ; 
                sayName() ; //同级函数可以互相访问
                alert(333);
            }
    
            function sayName(){
                alert(222);
                Person();//同级函数可以互相访问
            }
            
            // 原型 prototype
            function Person(name , age){
                this.name = name ; 
                this.age  = age ; 
                this.sayName = function(){alert('我是姓名!')};//后面的函数看成匿名对象,每次不一样。函数可以公用,放在原型里面。
                this.sayName = sayName1 ; //右边的函数是外部的函数
            }
            // 定义了一次函数
            function sayName1(){
                alert(this.name);
            }
            var p1 = new Person('z3',20);
            var p2 = new Person('z4',21);
            p1.sayName();
            p2.sayName();
            alert(p1.sayName == p2.sayName);     // false 
            alert(p1.name == p2.name);         // false 
            
            
            // prototype 创建每一个函数都有一个prototype属性,这个属性其实是一个指针,而这个指针总指向一个对象
            // 这个对象的用途就是将特定的属性和方法包含在内,起到一个所有实例所共享的作用
            //闭包实现了函数层面多个子函数共享父类函数的属性、方法。类层面上原型实现了多个子类对象共享父类对象的属性、方法。
            function Person(){}
            var obj = Person.prototype;//原型的构造器是函数本身
            alert(typeof obj);//object
            obj.name = 'z3';
            obj.age  = 20 ; 
            obj.sayName = function(){alert(this.name);};//原型对象里面的this是对象自己
            var p1 = new Person();
            var p2 = new Person();
            alert(p1.age);
            alert(p2.age);
            p1.sayName();
            p2.sayName();
            alert(p1.sayName == p2.sayName)//true,同一个地址
            
            //函数.prototype =  原型对象,原型对象.constructor = 函数
            alert(obj.constructor);//Person
            //实例对象.prototype = 原型对象
            alert(p1.prototype);
            alert(obj.isPrototypeOf(p1));//是不是这个对象的原型
            //Object.getPrototypeOf():根据实例对象获得原型对象
            //object.hasOwnProperty(attribute) 判断属性是否属于对象本身
    //in 操作符 判断对象中是否存在该属性(无论是实例对象还是原型对象)
    //Object.keys();拿到当前对象里的所有keys 返回一个数组
    //getOwnPropertyNames 枚举对象所有的属性 :不管该内部属性能否被枚举
    
            </script>
        </head>
        <body>
        </body>
    </html>
  • 相关阅读:
    跨域抓取360搜索结果
    css的圣杯布局
    css的双飞翼布局
    C#WebBroswer控件的使用
    使用Chart控件进行实时监控
    GzipStream的简单使用压缩和解压
    poj 1611 The Suspects
    hdu 1856 More is better
    hdu 1232
    UvaOJ 10167
  • 原文地址:https://www.cnblogs.com/yaowen/p/6865695.html
Copyright © 2020-2023  润新知