面向对象细节知识点汇总

基本包装类型：

基本类型：字符串+数值+null+undefined +布尔值；
为了便于操作基本类型，ECMAScript提供了三个特殊的引用类型：Boolean+Number+String。
基本类型值并不是对象，因此逻辑上讨论他们不应该有属性和方法，内部的具体处理：

创建String类型的一个实例对象
在实例对象上面读取指定的属性（length），调用指定的方法（subString）
销毁该对象

创建字符串对象:String是字符串的对象包装类型。

    var st1 = new String('demo1') ;
    console.log(st1);//String {0: "d", 1: "e", 2: "m", 3: "o", 4: "1", 
    length: 5, [[PrimitiveValue]]: "demo1"}
    console.log(typeof st1);//object
    var st2 = 'demo';
    console.log(typeof st2);//string
    var st3 = String('demo');
    console.log(typeof st3);//string

创建数值对象:Number是与数字值相对应的引用类型。

    var num1 = new Number(10);
    console.log(typeof num1);// object
    console.log(num1);//Number {[[PrimitiveValue]]: 10}
    var num2 = 10;
    console.log(typeof num2);// number
    console.log(num2);//10
    var num3 = Number(10);
    console.log(typeof num3);// number
    console.log(num3);//10

创建布尔对象:Boolean是与布尔值对象的引用类型。

    var boo1 = new Boolean(true); // object
    var boo2 = true; // boolean
    var boo3 = Boolean(true); // boolean

特殊的方法创建

    var st4 = new Object('demo');
    var num4 = new Object(10);
    var boo4 = new Object(true);

注意点：

对象还是基本数据类型值？
对象：通过new调用构造函数创建出来的是对象；
基本数据类型值：通过字面量方式赋值 |通过省略new 关键字调用构造函数方式创建的是基本数据类型值。

   var str1 = new String('hello');
    var str2 = 'hello';
    var str3 = String('hello');
    说明：以上代码中，str1是对象，而str2和str3是字符串（基本数据类型值）

相等问题
基本类型值判断相等==》值相等
引用类型值判断相等==》值相等且引用相等

    var str1 = '这是一个字符串';           //基本数据类型
    var str2 = String('这是一个字符串');   //基本数据类型
    console.log(str1 == str2);        //true 相等
    var str3 = new String('这是一个字符串');  //引用类型-对象
    console.log(str1 == str3);    //true    //值相等
    console.log(str2 == str3);    //true    //值相等

    console.log(str1 === str3);    //false  //值相等,但是引用不相等
    console.log(str2 === str3);    //false  //值相等,但是引用不相等
    //判断下面的变量是否相等
    var num1 = 10;                  //基本数据类型
    var num2 = new Number(10);      //对象
    console.log(num1 == num2);      //true
    console.log(num1 ===  num2);    //false

    var bool1 = true;    //基本数据类型
    var bool2 = new Boolean(true); //对象
    console.log(bool1 == bool2);    //true
    console.log(bool1 === bool2);   //false

this

函数调用方式发生改变会导致this的指向发生改变。

函数作为对象的方法调用 this-->当前的对象

 var obj = {
        name : 'zs',
        showName : function () {
            console.log(this);
        }
    }
    obj.showName(); // this->obj

函数作为普通函数调用 this-->window

 var obj = {
        name : 'zs',
        showName : function () {
            console.log(this);
        }
    }
   var showName = obj.showName;
    showName(); // this->window

使用new构造函数调用 this-->构造函数内部新创建的对象

 function Person() {
        console.log(this);
    }
    var p1 = new Person();

使用call |apply 调用个（函数上下文调用） this-->第一个参数

 var obj = {
        name : 'zs',
        showName : function (p1,p2) {
            console.log(this,p1,p2);
        }
    }
    var o = {};
    obj.showName.call(o,1,2);

Object.prototype

constructor 指向对象的构造函数
hasOwnProperty 判断某个对象中是否有某个属性（实例）
isPrototypeOf 判断某个对象是否是指定对象的原型对象（判断是整一条原型链）
prototypeIsEnumerable 是否可枚举，如果可以枚举，就能够通过for···in 遍历
toString 返回对象的字符串描述信息
1. 基本包装类型（String Number Boolean）,返回对应的基本数据类型的字符串;
2. object 类型的对象，返回[ object object ];
3. 数组或者函数，返回对应的字符串形式；
4. Number 对象可以传参，表示进制转换。
toLocalString 一般情况下和toString用法一样，特殊情况下会做本地化处理
valueOf 返回对应的值
1. 基本包装类型，返回对应的基本数据类型
2. object 类型。返回是对应本身
  3.日期对象，返回时间戳

成员：属性+方法

静态成员：构造函数也是一个对象，也有自己的属性和方法。
实例成员：直接定义在对象身上的属性和方法。
原型成员：定义在原型对象上的属性和方法。

Object的静态成员

Object.apply 借用其他对象的方法
Object.arguments 接受实参,保存实参
Object.assign 属性拷贝
Object.call 借用其他对象的方法
Object.caller 返回值是一个函数,返回调用函数的函数，如果在全局作用域中调用,返回null不是window

function fun1() {
    console.log(fun1.caller); // 返回调用函数的函数
}
function fun2() {
    fun1();
}
    fun2();//function fun2() {fun1();}

Object.constructor 指向构造函数
Object.create 创建对象并且设置这个对象的原型对象
Object.getOwnPropertyDescriptor 获取实例属性的描述信息

configurable 是否可配置(01是否可删除02是否可以修改该配置)
enumerable 是否可枚举可以枚举就是可以通过for..in遍历
value 属性的值
writable 是否可重写(修改)
Object.defineProperty 定义属性并设置属性的描述对象
1>.如果该属性已经存在,默认是true
2>.如果定义一个新的属性,默认是false
Object.getOwnPropertyNames 获取对象所有实例属性的名字,返回一个数组,不能获取原型属性
Object.keys 获取对象所有属性的名字,不能获取原型属性和不可以枚举的属性
Object.getPrototypeOf 获取原型对象
Object.preventExtensions | Object.isExtensible
禁止扩展,不可以添加属性,但是可以修改属性也可以删除
Object.seal | Object.isSealed密封对象禁止扩展,不能删除,可以修改
Object.freeze | Object.isFrozen冻结对象禁止扩展禁止删除禁止修改

function 构造函数的使用

创建函数的方法：

直接声明一个函数
函数表达式
使用new
使用new Function

 var fun4 = new Function('a','b','console.log(a+b);');
    // 如果没有传参数,是空函数,没有函数体
    // 如果只有一个参数,这个参数就是函数体
    // 如果有多个参数,最后一个才是函数体,其他的是形参列表

处理参数过长解决问题

使用+拼接字符串
使用反括号``
使用JS模板

小应用：
去重：返回一个数组，数组中的元素不重复
tips：返回数组中某个元素的索引，如果该元素不存在，返回-1

求最大值:逐一比较大小，每次比较后保存较大值并赋值给MaxNum

 function getMaxNum() {

        var maxNum = arguments[0];

        for (var i = 1; i < arguments.length; i++) {
            if(maxNum < arguments[i]){
                maxNum = arguments[i];
            }
        }

        return maxNum;
    }

arguments:是一个类似数组的对象，对应于传递给函数的参数，除了长度之外没有任何数组属性。
实参和形参：

在函数调用的时候，默认会把实参复制给形参，并且把实参保存在arguments中；
实参的个数大于形参的时候，超出的可以通过arguments获取；
实参个数小于形参，会依次赋值，多余的形参是undefined
arguments.length: 实参的长度
函数名.length:形参的长度
callee和caller
caller : 返回一个函数,返回调用当前函数的函数，如果函数是在全局作用域中调用,返回 null

   function f1() {
     console.log(f1.caller); // 返回调用函数的函数
        console.log(arguments.callee);// 返回函数自身
    }
    function f2() {
        f1();
    }
  f2();

Function.prototype原型链

Object 和Function

所有的对象都是继承Object
Object和Function互为对方的实例

    console.log(Object instanceof Function); // true
    console.log(Object instanceof Object); // true
    console.log(Function instanceof Function); // true
    console.log(Function instanceof Object); // true

eval 函数

作用：可以把字符串转为对应的JS代码

eval('var o = 10');
console.log(o);

eval 和 Function区别和联系：
1. 都可以把字符串转为对应的JS代码；
2. eval转为代码后直接执行，Function需要调用才会执行。
eval 用于处理JSON数据

  var JSONdate = '{"name":"zs"}';
//    var o = {"name" : "zs"};
    eval('var o =' + JSONdate);
    console.log(o);
    ({"name" : "zs"});
//    eval('(' +JSONdate + ')');

JSON数据：一种数据结构，用来表示数据，传输数据，本质是个字符串。
JSON数据的Key必须使用双引号包裹
处理JSON 数据：
1. 把json数据转为对象；
2.把对象转为JSON数据。

    var a = 10;
    var JSONdate = '{"name":"zs"}';
//    // 1. 把json数据转为对象
//    var o = JSON.parse(JSONdate);
//    // 2.把对象转为JSON数据
//    var str = JSON.stringify(o);
//    console.log(str);

建议:不建议使用(JS是词法作用域,eval函数可以动态的调整(破坏)词法作用域,性能不好)

with :

可以把变量的作用域引申到{}中,用来减少代码的.
使用的注意点:
1.不能使用无前缀的方式添加属性
2.this 指向window
3.在严格模式下,禁止使用
场合:当需要引用深层次的对象时可以缩短代码(对象.属性.属性....)
建议:不建议使用.

  var div =document.getElementById('demo');
    div.style.background = 'red';
    div.style.width = '100px';
    div.style.height = '100px';

//    with(div.style){
//        background = 'red';
//        width = '100px';
//        height = '100px';
//    }

    // 使用即时调用函数替代with
    (function (t) {
        t.background = 'red';
        t.width = '100px';
        t.height = '100px';
    })(div.style);

私有变量和私有函数：
直接写在构造函数内部的变量和函数成为私有变量和私有函数。

 function Person(name,age) {
        //对象
        this.name = name;
        this.age = age;
        this.showName = function () {
            console.log(this.name);
        }
        var a = 10
        function  demo() {
            console.log("111");
        }
        //特权方法：像test这样的实例方法，可以访问私有变量函数，这个方法成为特权方法
        this.test= function () {
            return a ;
        }
    }