js笔记

js 基础

1. var val = (1,2,4)
   val //4
2. var obj = {}
   Object.defineProperty(obj, 'x'{
   configurable:false,
   value:1
   })
   delete obj.x //false
   obj.x //1

3.in

window.x = "1"
"x" in window //true

4. try {
   throw "test";
   } catch (ex) {
   console.log(ex); // test
   } finally {
   console.log('finally');
   }
5. 'use strict'
   严格模式是一种特殊的执行模式，
   它修复了部分语言上的不足,提供更强的错误检查，并增强安全性。
   不允许用with所有变量必须声明, 赋值给为声明的变量报错，而不是隐式创建全局变量。
   eval中的代码不能创建eval所在作用域下的变量、函数。而是为eval单独创建一个作用域，并在eval返回时丢弃。
   函数中得特殊对象arguments是静态副本，而不像非严格模式那样，修改arguments或修改参数变量会相互影响。
   删除configurable=false的属性时报错，而不是忽略
   禁止八进制字面量，如010 (八进制的8)
   eval, arguments变为关键字，不可作为变量名、函数名等
   一般函数调用时(不是对象的方法调用，也不使用apply/call/bind等修改this)this指向null，而不是全局对象。
   若使用apply/call，当传入null或undefined时，this将指向null或undefined，而不是全局对象。
   试图修改不可写属性(writable=false)，在不可扩展的对象上添加属性时报TypeError，而不是忽略。
   arguments.caller, arguments.callee被禁用

prototype //直接声明的函数 拥有prototype这个属性，而new 构造出来的函数不存在prototype这个属性象。

function foo(){}                                function foo2(){}
undefined                                       undefined
foo.x = 1                                       foo2.prototype.x = 1
1                                               1
foo.y=2                                         foo2.prototype.y = 1
2                             VS                1
var test = new foo()                            var test2= new foo2()
undefined                                       undefined
test2                                           test2
foo {}                                          foo2 {x: 1, y: 1}
test.x                                          test2.x
undefined                                       1

7. 对象创建

   var a ={} var b = Object.create({x:1})
   undefined undefined
   a.x =1 b.x
   1 1
   a.hasOwnProperty('x') b.hasOwnProperty('x')
   true false

8. 对象属性删除

   var a = {}
   a.x = 1
   delete a.x`

   var globalVal = 1;
   delete globalVal; // false

   (function() {
   var localVal = 1;
   return delete localVal;
   }()); // false

   ohNo = 1;
   window.ohNo; // 1
   delete ohNo; // true

9. 对象属性检测
   in hasOwnProperty propertyIsEnumerable

10. 枚举类型

    var o = {x : 1, y : 2, z : 3};
    for (var key in o) {
    console.log(key); // x, y, z
    }

11. getter setter
    var man = {
    name : 'Bosn',
    weibo : '@Bosn',
    get age() {
    return new Date().getFullYear() - 1988;
    },
    set age(val) {
    console.log('Age can't be set to ' + val);
    }
    }
    console.log(man.age); // 27
    man.age = 100; // Age can't be set to 100
    console.log(man.age); // still 27
    var man = {
    weibo : '@Bosn',
    $age : null,
    get age() {
    if (this.$age == undefined) {
    return new Date().getFullYear() - 1988;
    } else {
    return this.$age;
    }
    },
    set age(val) {
    val = +val;
    if (!isNaN(val) && val > 0 && val < 150) {
    this.$age = +val;
    } else {
    throw new Error('Incorrect val = ' + val);
    }
    }
    }

对象属性及的权限设置

       var person = {};
       Object.defineProperty(person, 'name', {
       configurable : false, //配置
        writable : false,   //写
       enumerable : true, //枚举
       value : "Bosn Ma" //值
       });
       person.name; // Bosn Ma
   person.name = 1;
   person.name; // still Bosn Ma
   delete person.name; // false
        Object.defineProperties(person, {
    title : {value : 'fe', enumerable : true},
    corp : {value : 'BABA', enumerable : true},
    salary : {value : 50000, enumerable : true, writable : true}
});
Object.getOwnPropertyDescriptor(person, 'salary');
// Object {value: 50000, writable: true, enumerable: true, configurable: false}
Object.getOwnPropertyDescriptor(person, 'corp');
// Object {value: "BABA", writable: false, enumerable: true, configurable: false}`

13. call apply
    1、方法定义
    call方法:
    语法：call([thisObj[,arg1[, arg2[,[,.argN]]]]])
    定义：调用一个对象的一个方法，以另一个对象替换当前对象。
    说明：

    call 方法可以用来代替另一个对象调用一个方法。call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。
    如果没有提供 thisObj 参数，那么 Global 对象被用作 thisObj。

    apply方法：
    语法：apply([thisObj[,argArray]])
    定义：应用某一对象的一个方法，用另一个对象替换当前对象。
    说明：
    如果 argArray 不是一个有效的数组或者不是 arguments 对象，那么将导致一个 TypeError。
    如果没有提供 argArray 和 thisObj 任何一个参数，那么 Global 对象将被用作 thisObj， 并且无法被传递任何参数.

14. function bind
    this.x = 9
    9
    var module = {
    x:81,
    getX: function(){
    return this.x
    }
    }
    module.getX()
    81
    var getX = module.getX
    getX()
    9
    var boundGetX = getX.bind(module)
    boundGetX()
    81
    function add(a,b,c){
    return a + b + c
    }
    var func =add.bind(undefined, 100)
    func(1,2)
    103
    var func2 =func.bind(undefined, 200)
    func2(100)
    400
    function getConfig(color, size, otherOptions){
    console.log(color, size, otherOptions)
    }
    var defaultConfig = getConfig.bind(null, "#000", "1024 * 768")`
    defaultConfig("123")
    #000 1024 * 768 123
    defaultConfig("456")
    #000 1024 * 768 456

15. 闭包 //允许一个函数在立即词法作用域外调用时，仍可以访问本地变量
    优点： //灵活、 方便
    缺点： //浪费空间、内存泄露、性能消耗

16. arguments caller callee
    arguments :
    // 在函数调用时， 会自动在该函数内部生成一个名为 arguments的隐藏对象。 该对象类似于数组，
    //但又不是数组。可以使用[]操作符获取函数调用时传递的实参。

    caller :
    //在一个函数调用另一个函数时，被调用函数会自动生成一个caller属性，指向调用它的函数对象。
    //如果该函数当前未被调用，或并非被其他函数调用，则caller为null。

    callee :
    //当函数被调用时，它的arguments.callee对象就会指向自身，也就是一个对自己的引用。
    //由于arguments在函数被调用时才有效，因此arguments.callee在函数未调用时是不存在的（即null.callee），且解引用它会产生异常。
    //

17. this

    在函数执行时，this 总是指向调用该函数的对象。要判断 this 的指向，其实就是判断 this 所在的函数属于谁。

    在《javaScript语言精粹》这本书中，把 this 出现的场景分为四类，简单的说就是：

    有对象就指向调用对象
    没调用对象就指向全局对象
    用new构造就指向新对象
    通过 apply 或 call 或 bind 来改变 this 的所指。
    1）函数有所属对象时：指向所属对象

    函数有所属对象时，通常通过 . 表达式调用，这时 this 自然指向所属对象。比如下面的例子：

    var myObject = {value: 100};
    myObject.getValue = function () {
    console.log(this.value); // 输出 100

    // 输出 { value: 100, getValue: [Function] }，
    // 其实就是 myObject 对象本身
    console.log(this);

    return this.value;
    };

    console.log(myObject.getValue()); // => 100
    getValue() 属于对象 myObject，并由 myOjbect 进行 . 调用，因此 this 指向对象 myObject。

    2. 函数没有所属对象：指向全局对象

    var myObject = {value: 100};
    myObject.getValue = function () {
    var foo = function () {
    console.log(this.value) // => undefined
    console.log(this);// 输出全局对象 global
    };

    foo();

    return this.value;
    };

    console.log(myObject.getValue()); // => 100
    在上述代码块中，foo 函数虽然定义在 getValue 的函数体内，但实际上它既不属于 getValue 也不属于 myObject。foo 并没有被绑定在任何对象上，所以当调用时，它的 this 指针指向了全局对象 global。

    据说这是个设计错误。

    3）构造器中的 this：指向新对象

    js 中，我们通过 new 关键词来调用构造函数，此时 this 会绑定在该新对象上。

    var SomeClass = function(){
    this.value = 100;
    }

    var myCreate = new SomeClass();

    console.log(myCreate.value); // 输出100
    顺便说一句，在 js 中，构造函数、普通函数、对象方法、闭包，这四者没有明确界线。界线都在人的心中。

    4. apply 和 call 调用以及 bind 绑定：指向绑定的对象

    apply() 方法接受两个参数第一个是函数运行的作用域，另外一个是一个参数数组(arguments)。

    call() 方法第一个参数的意义与 apply() 方法相同，只是其他的参数需要一个个列举出来。

    简单来说，call 的方式更接近我们平时调用函数，而 apply 需要我们传递 Array 形式的数组给它。它们是可以互相转换的。

    var myObject = {value: 100};

    var foo = function(){
    console.log(this);
    };

    foo(); // 全局变量 global
    foo.apply(myObject); // { value: 100 }
    foo.call(myObject); // { value: 100 }

    var newFoo = foo.bind(myObject);
    newFoo(); // { value: 100 }

18. 闭包的一个坑
    闭包这个概念，在函数式编程里很常见，简单的说，就是使内部函数可以访问定义在外部函数中的变量。
    for (var i = 0; i < 5; i++) {
    setTimeout(function () {
    console.log(i);
    }, 5);
    }
    上面这个代码块会打印五个 5 出来，而我们预想的结果是打印 1 2 3 4 5。
    之所以会这样，是因为 setTimeout 中的 i 是对外层 i 的引用。当 setTimeout 的代码被解释的时候，运行时只是记录了 i 的引用，而不是值。而当 setTimeout 被触发时，五个 setTimeout 中的 i 同时被取值，由于它们都指向了外层的同一个 i，而那个 i 的值在迭代完成时为 5，所以打印了五次 5。
    为了得到我们预想的结果，我们可以把 i 赋值成一个局部的变量，从而摆脱外层迭代的影响。

    for (var i = 0; i < 5; i++) {
    (function (idx) {
    setTimeout(function () {
    console.log(idx);
    }, 5);
    })(i);
    }