JavaScript之ECMA对象

1. 对象分类

• 由EMCAScript定义的本地对象 （native object）
• 内置对象（他们也是本地对象） （built-in object）
• 所有的非本地对象都是宿主对象（host object），即由ECMAScript实现的宿主环境提供的对象。所有BOM和DOM对象都是宿主对象。

注：object对象：ECMAScript 中的所有对象都由这个对象继承而来；Object 对象中的所有属性和方法都会出现在其他对象中

2. 11种内置对象

Array,String,Date,Math,Boolean,Number,Function,Global,Error,RegExp,Object

3. String

4. Array

5.Date

创建Date对象
var nowd1=new Date();
var nowd2=new Date(“2004/3/20 11:12”);
var nowd3=new Date(“04/03/20 11:12”);
var nowd3=new Date(5000);
var nowd4=new Date(2004,2,20,11,12,0,300);
显示：nowd1.toLocaleString( )

获取日期和时间
getDate() 获取日
getDay () 获取星期
getMonth () 获取月（0-11）
getFullYear () 获取完整年份
getYear () 获取年
getHours () 获取小时
getMinutes () 获取分钟
getSeconds () 获取秒
getMilliseconds () 获取毫秒
getTime () 返回累计毫秒数(从1970/1/1午夜)

//设置日期和时间
setDate(day_of_month) 设置日
setMonth (month) 设置月
setFullYear (year) 设置年
setHours (hour) 设置小时
setMinutes (minute) 设置分钟
setSeconds (second) 设置秒
setMillliseconds (ms) 设置毫秒(0-999)
setTime (allms) 设置累计毫秒(从1970/1/1午夜)

6.Function

1.函数创建方式

function 函数名 (参数){
    
函数体;
   return 返回值;
}
//another way:
var 函数名 = new Function("参数1","参数n","function_body");

2. length属性

func1.length: 声明函数期望的参数个数

3. 面试题

 function a(a,b){
    alert(a+b);
}

   var a=1;
   var b=2;
   a(a,b)
   //什么都不返回

4. arguments

在不确定参数个数的时候，可以使用arguments

function add(a,b){

        console.log(a+b);//3
        console.log(arguments.length);//2
        console.log(arguments);//[1,2]

    }
    add(1,2)

    ------------------arguments的用处1 ------------------
    function nxAdd(){
        var result=0;
        for (var num in arguments){
            result+=arguments[num]
        }
        alert(result)

    }

    nxAdd(1,2,3,4,5)
//     ------------------arguments的用处2 ------------------

    function f(a,b,c){
        if (arguments.length!=3){
            throw new Error("function f called with "+arguments.length+" arguments,but it just need 3 arguments")
        }
        else {
            alert("success!")
        }
    }

    f(1,2,3,4,5)

5.匿名函数

// 匿名函数
    var func = function(arg){
        return "tony";
    }

// 匿名函数的应用
    (function(){
        alert("tony");
    } )()

    (function(arg){
        console.log(arg);
    })('123')

6. 嵌套函数

var city = 'beijing';

    function func(){
        var city = 'shanghai';
        function inner(){
            var city = 'shenzhen';
            console.log(city);
        }
        inner();
    }
    func();
//深圳

在这里插入代码片var city = 'beijing';
function Bar(){
    console.log(city);
}
function func(){

    var city = 'shanghai';
    return Bar;
}
var ret = func();
ret();    //beijing

闭包

var city = 'beijing';

function func(){
    var city = "shanghai";
    function inner(){
        // var city = "langfang";
        console.log(city);
    }
    return inner;
}
var ret = func();
ret();
//shanghai

var city = 'beijing';

function func(){
    var city = "shanghai";
    function inner(){
        var city = "langfang";
        console.log(city);
    }
    return inner;
}
var ret = func();
ret();
//langfang

7.作用域链

什么是AO,VO?
       在函数创建时，每个函数都会创建一个活动对象Active Object(AO)，全局对象为Global Object(VO)，创建函数的过程也就是为这个对象添加属性的过程，作用域链就是由这些绑定了属性的活动对象构成的。
        例如：找x变量；bar函数在搜寻变量x的过程中，先从自身AO对象上找，如果bar.AO存在这个属性，那么会直接使用这个属性的值，如果不存在，则会转到父级函数的AO对象，也就是foo.AO
        如果找到x属性则使用，找不到继续 在global.VO对象查找，找到x的属性，返回属性值。如果在global.VO中没有找到，则会抛出异常ReferenceError

执行上下文。
       函数在执行时会创建一个称为“执行上下文（execution context）”的内部对象，执行上下文定义了函数
       执行时的环境。每个执行上下文都有自己的作用域链，用于标识符解析，当执行上下文被创建时，而它的作用
       域链初始化为当前运行函数的[[Scope]]所包含的对象。
函数执行
       在函数执行过程中，每遇到一个变量，都会检索从哪里获取和存储数据，该过程从作用域链头部，也就是从活
       动对象开始搜索，查找同名的标识符，如果找到了就使用这个标识符对应的变量，如果没有则继续搜索作用域
       链中的下一个对象，如果搜索完所有对象都未找到，则认为该标识符未定义，函数执行过程中，每个标识符都
       要经历这样的搜索过程。

创建作用域链的过程

函数进入全局，创建VO对象，绑定x属性<入栈>
        global.VO={x=underfind; foo:reference of function}(这里只是预解析，为AO对象绑定声明的属性，函数执行时才会执行赋值语句，所以值是underfind)
     遇到foo函数，创建foo.AO，绑定y属性<入栈>
     foo.AO={y=underfind, bar:reference of function}
     遇到bar函数，创建bar.AO，绑定z属性<入栈>
      bar.AO={z:underfind}
    作用域链和执行上下文都会保存在堆栈中，所以：
    bar函数的scope chain为：[0]bar.AO-->[1]foo.AO-->[2]global.VO

          foo函数的scope chain为：[0]foo.AO-->[1]global.Vo
    //建议：少定义全局变量
    //理由：因为作用域链是栈的结构，全局变量在栈底，每次访问全局变量都会遍历一次栈，//这样会影响效率

经典面试题

 for (var i=1; i<=9; i++) {
     setTimeout( function timer(){
     console.log( i );
     },1000 );
 }
 //返回9个10

//＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

for (var i=1; i<=9; i++) {
    (function(){
      var j = i;
      setTimeout( function timer(){
           console.log( j );
      }, 1000 );
     })();
     //返回1，2，3，4，5，6，7，8，9

setTimeout是异步的。正确的理解setTimeout的方式(注册事件)： 有两个参数，第一个参数是函数，第二参数是时间值。 调用setTimeout时，把函数参数，放到事件队列中。等主程序运行完，再调用。

详细解析：
https://www.cnblogs.com/destinyruru/p/5823760.html

【重点】