5-对象+函数+数组note+数组详细

对象
    属性和方法的集合
    1) 常见方式
        1. 构造函数 Object      Date
            var obj = new Object();
            obj.name = "terry";
            obj.age = 12;
            
        2. 对象字面量
            var obj = {
                name:"terry",
                age:12,
                sayName:function(){
                    alert(this.name);
                }
            };
    2) 属性的访问方式
        1. 点
            obj.name=>obj["name"];

        2. 中括号
            解析变量
            var name = "name"
            obj[name]=>obj["name"];
    3) 方法的访问
        对象名.方法名(实参列表)
        对象名.方法名.call(为this赋值,参数列表)
        对象名.方法名.apply(为this赋值,参数数组)
    4) 动态添加属性和删除属性
        obj.salary = 10000;
        delete obj.name;
    5) 属性的检测
        in    自有，继承
        hasOwnProperty()        自有
        propertyIsEnumerable()    是否可以枚举
    6) 对象直接间接继承Object
        {
            toString    
            valueOf   
            hasOwnProperty
            propertyIsEnumerable
            toLocalString    
        }
    7) 方法的覆盖
        子对象提供一个与父对方法一样的方法，这时候通过子对象的引用调用该方法体现子对象的特点

        重写
            toString()
            valueOf()

函数   ：有属性也有方法
    1.定义方式
        1) 函数声明    //可放在前面也可以放在后面，都可以调用
            add();  
            function add(){
            
            }
            将函数声明，初始化，进行提升
        2) 函数表达式
            var add = function(){
            
            };
            只能放在后面， 否则报错 不能提升
    2.内部属性 （只有内部成员，才能访问内部属性）

        函数调用的时候，内部属性才会初始化
        1)arguments
            类属组对象，保存了实参
            arguments.length    获取实参个数
            arguments.callee    指向拥有arugments属性的函数（递归） （也就是指向当前函数）
                n!
        2)this
            指向当前函数的执行上下文，跟调用函数的方式有关，this在函数调用期间才能确定，this一旦确定不能改变。
            function add(){
                arguments
            }
            add();       //m
    3.函数的属性（外部属性）
        length    期望接受参数(形参)的个数

    4.函数的方法
        call(this的值,)
        apply(this的值,)

引用数据类型
JS当中核心对象有哪些？
    Object
    Date
    Function
    Array

数组
    Java:数组是相同数据类型的集合
        int[] arr = {1,2,3};
        String[] arr = {"tery","jack"};
        数组的长度一但指定，不能更改

    JS:
        数组是任意数据类型值的集合
        数组长度可以任意修改
        var arr = [1,2,3,4];
        arr.length    // 4
        arr.length = 5;
    数组长度：
        通过length属性来获取
        数组中元素个数
    1)数组的创建方式
        1.构造函数  所有构造函数首字母 大写！！！  1，for循坏  2，for-in循环
            1)Array 无参数
                var arr = new Array();
                arr[0] = 8;    
                arr[1] = 9;
            2)Array 有一个整数参数
                var arr = new Array(10);
            3)Array 有一个小数参数
                报错  RangeError
            4)Array 有多个参数
                为数组初始化
        2.数组字面量    类似对象自变量
            var age = 12;
            var arr = ["terry",1,true,null,age,{age:1},function(){}]
                            age是个字符， 数组会把age当变量来解析 即 解析age的 值 12
                            结尾不加逗号，在IE低版本中会出现 arr.length 与火狐当中的arr.length不同
                
    2)数组的访问方式
        数组名[索引]
            索引从0开始
    3)数组的长度
        通过length属性来获取
        动态变化
    4)数组的遍历    
        for(var key in arr){
        
        }
    5)数组的内存表示

    6)数组(Array)API
    学习一个方法主要学习    {API 1)函数含义，函数的参数，函数返回值}

        isArray    属于数组的
        isNaN
        isFinite   属于window的

        1.isArray
            Array.isArray(val);
            当val为数组的时候，返回true
        2.join
            arr.join("字符标识");
            通过指定的字符标识来连接数组中的每个元素、
        3.栈方法（后进先出）
            arr.push()
                将元素添加到数组的末尾
                返回值：为添加后数组的长度
                参数:    
                    参数为多个，按照顺序入栈  arr.push(2,3,4);
                    参数如果为数组的时候，当做普通值压入
            arr.pop()
                将末尾的元素从数组中移出
                返回值：出栈元素
                参数：没有参数
        4.队列方法
            arr.shift() 出队
                将数组中开头的元素移出
                返回值：出队列元素
                参数：没有参数
            arr.unshift() 插队
                将元素插入到数组的开头位置
                参数：    要插入的元素
                返回值：插入后数组的长度
        5.排序
            arr.reverse();
                将数组中的元素顺序翻转
                参数：没有参数
                返回：为翻转之后的数组
                注意！改变了原数组
            
            arr.sort();
                排序 默认将数组中的元素转换成字符串后进行排序
                参数：
                    1)可以没有参数
                        将数组中的元素转换为字符串然后进行排序
                    2)可以是函数（回调函数）
                        比较器
                        a.该方法可以接受一个比较函数作为参数，比较函数有两个参数
                        b.如果第一个参数位于第二个参数之前，返回负数
                        c.如果第一个参数位于第二个参数之后，返回正数
                返回值：为排序后的数组
                注意：改变原数组

        6. 数组的连接
            var arr1 = [1,2,3];
            var arr2 = [4,5,6];
            arr1.push(arr2);    //[1,2,3,[4,5,6]]

            arr1.concat(arr2);
                数组的连接
                参数：
                    1)数组，可有多个
                        直接连接
                    2)值列表
                        直接连接
                返回值
                    连接后的结果
                注意：不改变原值
                    
        7.获取子数组
            arr.slice();
            获取子数组
            参数：
                1)1个整数（索引）
                    从指定索引位置开始截取，直到数组的末尾
                2)2个整数（索引开始位置,索引结束位置）
                    从索引开始位置截取，直到结束位置但是不包含结束位置
                3)负数
                    从数组的末尾开始计数，最后一个元素位置为-1，但是截取子数组的时候还是从当前位置开始往后截取
            返回值：
                截取到的子数组
            注意:不改变原值
        8.强大的方法
            arr.splice()
                可以对数组进行插入，删除，替换操作
            参数：
                1)1个(删除的起始位置)
                    从指定位置开始删除，直到数组末尾

                2)两个(删除的起始位置，删除元素的个数)
                    删除
                3)三个(删除的起始位置，删除元素的个数，插入的元素)
                    
            返回值：    
                删除后的元素
            注意:改变原值
        

               

***************************************************数组详细*********************************************

1. Array类型

    ECMAScript数组和其他语言中的数组都是有序列表，但是有以下特性：
    a.每一项都可以保存任何类型的数据。
    b.数组的大小是可以动态调整。
    c.数组的length属性：可读可写，可以通过设置length的值从数组的末尾移除项或向数组中添加新项

    1) 创建方法
       1. 使用Array构造函数
          var arr = new Array();
          var arr = new Array(20);  // 预先指定数组的大小  无法打印数组内容 因为没有做打印初始化
          var arr = new Array("terry","larry","boss"); //传入参数
          注意：new 关键字也可以省略，但是尽量不要省略
       2. 使用数组字面量
          由一对包含数组项的方括号表示，多个数组项之间用逗号分隔
          var arr = ["terry","larry","boss"];  （结尾加分号）
          var arr = []            //空数组 undefined

    2) 访问数组元素
       数组变量名[索引]
        1.如果索引小于数组的长度，返回对应项的值
            var arr = ["terry","larry","boss"];
            arr[0] ;            //访问数组中第一个元素,返回值为terry
        2.如果索引大于数组的长度，数组自动增加到该索引值加1的长度
            var arr = ["terry","larry","boss"];
            arr[3] ="jacky";    //添加元素,数组程度变为4

        数组最多可以包含4 294 967 295个项
        数组长度： 数组中元素个数   通过length属性来获取 可以动态变化

    3) 检查数组
        var arr = [];
        typeOf(arr);        //返回object
        Array.isArray(arr);    //判断arr是否是数组类型
        
        isArray    属于数组的
        isNaN
        isFinite   属于window的


    4) 转换数组为字符串
        数组继承Object方法，并且对这些方法进行了重写
        toLocalString();
        方法一 toString();        在默认情况下都会以 逗号分隔字符串 的形式 返回数组项
            例如：
            var arr = ["terry","larry","boss"，{age:12}];    
            arr.toString()        //terry,larry,boss,[object object]
    方法二 valueOf(); 在默认情况下以数组字面量的方式显示（firefox）  ["terry", "larry", "tom", Object { age=12}]
            arr.valueOf();        //["terry","larry","boss"];    
    方法三    join();    使用指定的字符串用来分隔数组字符串
            例如：
            arr.join("||");        //briup||terry||jacky


            toString();        
                返回对象的字符串表示
            valueOf();        
                返回对象的字符串，数值，布尔值的表示。
            toLocaleString();    
                返回对象的字符串表示，该字符串与执行环境的地区对应

    对象序列化
        对象序列化是指将对象的状态转换为字符串，也可以反序列化，将字符串还原为对象函数，RegExp,Error对象，undefined值不能序列化和反序列化。
        JSON.stringify(obj)  
            将对象序列化为Json字符串,只能序列化对象可枚举的自有属性。
        JSON.parse(jsonStr)  
            反序列化

    5) 栈，队列方法
        1.栈  LIFO (Last-In-First-Out)
            push() 可接受任意类型的参数，将它们逐个添加到数组的末尾，并返回数组的长度
            pop()     从数组的末尾移除最后一项，减少数组的length值，返回移除的项
        2.队列    FIFO (First-In-First-Out)
            shift()  移除数组中的第一个项并且返回该项，同时将数组的长度减一。
            unshift() 在数组的前端添加任意个项，并返回新数组的长度。

    6) 排序
       reverse()  反转数组项的顺序
       sort()      
         1.默认排序：该方法会调用每个数组项的toString() 转型方法，然后排序（将数组元素转换成字符串，按字符串在Unicode编码表中的大小排序）
         2.自定义排序：
            a.该方法可以接受一个比较函数作为参数，比较函数有两个参数
            b.如果第一个参数位于第二个参数之前，返回负数
            c.如果第一个参数位于第二个参数之后，返回正数
            var arr = [11,5,23,7,4,1,9,1];
            console.log(arr.sort(compare));

            //该比较函数适合于大多数数据类型
            function compare(v1,v2){
                if(v1>v2){
                    return -1;
                }else if( v1<v2){
                    return 1;
                }else{
                    return 0;
                }
            }
    7) 数组的连接
        concat()    :先创建当前数组的一个副本，然后将接收到的参数添加到这个副本的末尾，返回副本
            var arr = ["aa","bb","cc","dd"];
            var arr_new = arr.concat("ee","ff");
                // arr_new = ["aa", "bb", "cc", "dd", "ee", "ff"]// arr不改变
        slice()    :可接受一个或者两个参数（返回项的起始位置，结束位置）
            当接受一个参数，从该参数指定的位置开始，到当前数组末尾的所有项
            当接受两个参数，起始到结束之间的项，但是不包含结束位置的项
            例如：
            var arr = ["aa","bb","cc","dd"];
            1.接受一个参数时
              var arr_new = arr.slice(1);
                // arr_new = ["bb", "cc", "dd"],arr 不改变
            2.接受两个参数时
              var arr_new = arr.slice(1,2);    
                // arr_new = ["bb"]; arr不改变
        splice()    : 向数组的中部插入数据将始终返回一个数组，该数组中包含从原始数组中删除的项。
            删除：指定两个参数(删除的起始位置，要删除的项数)
            插入：指定三个参数(起始位置，0，要插入的项任意数量的项)
            替换：指定三个参数(起始位置，要删除的项，要插入的任意数量的项)

            例如：
            var arr = ["aa","bb","cc","dd"];
            1.删除
              var del_arr = arr.splice(1,2);
                // arr = ["aa","dd"];     在原数组进行了删除操作
                // del_arr = ["bb","cc"];返回删除的元素数组
            2.插入
              var del_arr = arr.splice(1,0,"ee","ff");
                // arr =  ["aa", "ee", "ff", "bb", "cc", "dd"] 将指定项插入到1位置处
                //del_arr = [], 返回空数组
            3.替换
              var del_arr = arr.splice(1,2,"ee","ff");
                // arr =  ["aa", "ee", "ff", "dd"] 将"bb","cc" 替换成了"ee","ff"
                //del_arr = ["bb", "cc"], 返回删除的元素数组
        indexOf()(要查找的项，开始查找的位置(可选)) 从数组开头向后查找，使用全等操作符，找不到该元素返回-1
            var arr = ["22","11","cc","dd","11"];
            arr.indexOf(11); //返回-1，因为使用"==="进行匹配
            arr.indexOf("11"); //返回1，从前往后匹配，返回第一个匹配元素的位置
        lastIndexOf()(要查找的项，开始查找的位置(可选)) 从数组末尾向前查找，使用全等操作符，找不到该元素返回-1
            var arr = ["22","11","cc","dd","11"];
            arr.lastIndexOf("11"); //返回1，从后往前匹配，返回第一个匹配元素的位置
    
    8) 迭代方法：
        参数： 每一项上运行的函数，运行该函数的作用域对象（可选）
        every();对数组中的每一运行给定的函数，如果该函数对每一项都返回true,则返回true
            var arr = [11,5,23,7,4,1,9,1];
            var result = arr.e
            very(function(item,index,arr){
                return item >2;
            });
            console.log(result); //false
        some(); 对数组中的每一运行给定的函数，如果该函数对任意一项都返回true,则返回true
            var result = arr.every(function(item,index,arr){
                return item >2;
            });
            console.log(result); //true
        filter();对数组中的每一运行给定的函数，会返回满足该函数的项组成的数组
            var result = arr.filter(function(item,index,arr){
                return item >2;
            });
            console.log(result); // [11, 5, 23, 7, 4, 9]
        map();对数组中的每一运行给定的函数,返回每次函数调用的结果组成的数组
            var result = arr.map(function(item,index,arr){
                return item * 2;
            });
            console.log(result); // [22, 10, 46, 14, 8, 2, 18, 2]
        forEach();对数组中的每一运行给定的函数,没有返回值，常用来遍历元素
            var result = arr.forEach(function(item,index,arr){
                console.log(item);
            });