js对象及函数(四)

一、对象
1、函数对象的创建
方法一：使用new构造函数去创建构造函数对象
eg:

    var obj = new Object();
    //向对象里面添加属性或方法
    obj.name = 'nzc';
    obj.age = 21;
    obj.sayName =  function(){}

方法二：使用对象字面量来声明对象

    var obj = {
        name:"nzc",
        age:21,
        gender:'男',
        sayName: function(){}
    };

   
2、对象中属性和方法的调用：
a.使用 . 来调用对象中的属性和方法
eg:

    console.log(obj.name); //输出为 nzc
    console.log(obj.id); //输出为 undefined  调用对象中不存在的属性会返回undefined。
    obj.sayName();  //调用obj对象的sayName()方法
    console.log(obj.sayName);  //输出为 [Function]

b.使用['属性名']来调用对象的属性
eg:

    console.log(obj['name']);  //输出为 nzc ，注意：[]内需要加双引号再加属性名才能得到相应对象属性的属性值（即里面值为String类型），否则会报错

3、对象中的属性
a.对象中属性值可以为任意类型【可以为object、array等类型值】
b.对象中属性值的遍历方法：
for-in   循环遍历对象中的自有属性
eg：

    for(key in obj){
        console.log(key+':'+obj[key]);    //单次执行输出格式为：name:nzc  ,然后循环则会遍历对象
    }    

obj为需要遍历的对象，key为依次遍历对象的属性名【string类型】，obj[key]获取相应对象属性属性值
c.对象中属性的删除

     delete obj.name;    //删除obj对象中的name属性

4、js对象与JSON字符串间的相互转化
a.js对象转化为JSON字符串

    JSON.stringify(obj);  //将obj对象转化为JSON字符串

b.JSON字符串转化为js对象

    JSON.parse(str);  //将JSON str字符串转化为一个对象

   
二、函数
1.函数的声明：
方法一：

    function test(){
        console.log('test');
        return 1;  //函数返回值，看需要情况是否写该语句
    }

方法二：  【function(){}  匿名函数(立即执行函数IIFE)】

    var test = function(){
        console.log('test');
    }

函数体中return语句后面的函数将不会执行【return;  表示函数结束语句】

2.函数的调用(使用)
a.基本函数的调用

    test();  //函数名()
    var result = test();  //将函数test()返回值赋值给result

b.匿名函数的调用

    (function(){})();    //(匿名函数体)()

三、变量与函数的声明提前
1、声明提前
a.变量的声明提前
在声明变量的前面使用该变量返回undefined
eg：

    console.log(a);  //undefined  而不是提示 a is not defined.变量声明提到前面了
    var a = 'hello!!!'

b.函数声明提前
函数调用可以写在函数声明前面【函数声明提前】
eg：

    test();
    function test(){
        console.log('我是test()函数方法');
    }    

c.变量声明提前与函数声明提前优先级问题【当变量名和函数名相同冲突时】

解释一：函数声明通常置于javaScript的最顶端【即函数声明优先级最高】

eg:

    console.log(test);  //[Function test]
    function test(){}
    var test = 123;
    console.log(test);  //123

过程解析：

　function test(){}
    console.log(test);   //[Function test]
    test = 123;
    console.log(test);  //123

说明：函数声明置于顶部，后面若有相同变量声明初始化则其将不再声明直接使用初始化的值覆盖test函数

解释二：变量声明优于函数声明【即变量声明优先级最高】
eg：

    console.log(test);  //[Function test]  
    function test(){}
    var test = 123;
    console.log(test);  //123

过程解析：
    var test；
    function test(){}
    console.log(test);   //[Function test]
    test = 123;
    console.log(test);  //123

说明：变量先声明后再函数声明，函数声明将变量声明覆盖了，后面test为函数

注意：

当变量名和函数名相同时且变量名初始化了【变量赋予了值】，
与该变量名相同的函数名方法将会失效【其实是该函数无法被调用了】
如上面例子所示：使用test();调用函数其无法识别【它会解析test为一个变量即为【test()=>123()】,会提示test不是一个函数】;

函数表达式形式不符合上面这些说法：
函数表达式形式:
    var test = function(){}
使用函数表达式本质上是变量之间的比较和变量提前声明再按照顺序执行初始化操作，再进行赋值覆盖。

2、函数的内部属性【只有在函数内部才能访问的属性】
a、arguments属性：
arguments是类数组对象，包含着传入函数中的所有参数;
arguments对象还有一个callee的属性，用来指向拥有这个arguments对象的函数，可以使用arguments.callee代替该函数名来使用
eg：

     //arguments存放的是实参列表，类数组对象，length属性代表存放的实参个数，callee属性代表函数
    //对1,2,34,12,155,22,4进行累加
    function add(a,b){
            console.log(arguments); //类数组对象:{ '0': 1, '1': 2, '2': 34, '3': 12, '4': 155, '5': 22, '6': 4 }
            var total = 0;
            for(var i=0;i<arguments.length;i++){
                    //console.log(arguments[i]);
                    total += arguments[i];
            }
            return total;
    }
    var result = add(1,2,34,12,155,22,4);
    console.log(result);  //输出为：230


    //递归阶乘(arguments.callee的使用)
    function mul(num){
            //console.log(arguments.callee); //函数在自身函数内部调用自身使用arguments.callee代替函数名
            if(num>1){
                    return num*arguments.callee(num-1);
            }else{
                    return 1;
            }
    }

    var result = mul(5);
    console.log(result); //计算出5的阶乘结果：120

b.this属性:
指向的是函数赖以执行的环境对象【指向当前函数的作用域】
eg:

    //this指向当前函数的作用域
    function test(){
     console.log(this);  //global全局对象,在node.js环境中;  如果测试环境是浏览器，指向的是window对象
    }
    test();

    var obj = {
        name:'nzc';
        age:21;
        sayName:function(){
        console.log(this.name);  //this指向调用该方法的对象
        }
    };
    obj.sayName();  //nzc

调用方式：
        test();　　 globel对象
        test.call(Object,[参数列表]);
        　　Object:　　 this指向对象
       　　 [参数列表]   test()方法携带的参数

        test().apply(Object,[参数数值])
        　　[参数数组]  test()需要携带的参数组合成的数组

        test.bind(Object)(参数列表)　　 //更改了函数中this指向的对象并传递了参数且会执行
        test.bind(Object,参数列表)()　　//只是更改了函数中this指向的对象，函数不会执行   换回的是函数    后面还需要调用执行来执行它

3、构造函数和原型和实例间的关系

每一个构造函数都有一个原型对象
   Object.prototype.constructor === Object;
实例是通过构造函数创建出来的，实例可以调用构造它的构造函数对应的原型对象中的属性和方法
　　obj.toString === Object.ptototype.toString
       Object.prototype.isPrototypeof(obj)