JavaScript-对象、函数、数组

时间 2020-01-19

原文原文链接

循环语句正则表达式

1) 循环三要素
        初始化条件
        结束断定条件
        迭代
    2) 三种基本循环语句
        2.1 for循环
            for(初始化条件; 结束断定条件; 迭代){
                循环体
            }    

            var result = 0;
            for(var i=1; i<=3;i++){
                result += i;
            }

            var result = 0;
            var i = 1;

            i<=3                 //true
            result+=i     //result = 1;
            i++                 //i = 2

            i<=3                 //true
            result+=i     // result = 3;
            i++                 // i=3

            i<=3                 //true
            result+=i     // result = 6;
            i++                 // i=4

            i<=3                 //false     结束

        2.2 前置判断循环 while循环

            初始化条件
            while(结束断定条件){
                循环体
                迭代
            }

        2.3 后置判断循环 do-while循环
            初始化条件
            do{
                循环体
                迭代
            } while(后置判断循环);

对象
引用数据类型，用于保存复杂的数据，是多个属性和方法的集合
1) 对象如何建立编程

1. 对象字面量
    var obj = {
        name:"terry",
        age:12,
        gender:"male",
        sayName:function(){
            console.log(this.name);
        }
    };

    对象使用"{}"做为对象的边界，对象是由多个属性组成，属性与属性之间经过","隔开，属性名与属性值经过":"隔开;属性名通常不添加引号（当属性名中出现特殊字符的时候须要添加引号），属性值若是是字符串的必定添加引号。
2. 经过构造函数来建立对象
    var obj = new Object();
    obj.name = "terry";
    obj.age = 12;
    <=>
    var obj = {};
    obj.name= "terry";
    obj.age = 12;

2) 对象如何访问
    点访问符 对象.属性名
        obj.name
        obj.age
    中括号访问符
        var name = "name";
        obj[name]

        =>
        obj["name"]
3) 删除对象中的属性
        delete obj.sayName
        从obj对象中删除sayName属性

4) Object
    根构造函数，全部的对象都直接间接继承Object，全部的对象均可以调用Object原型中的方法
    
    toString()
    valueOf()
    constructor
        构造函数
    hasOwnProperty(prop)
        判断某个属性是不是自有属性
    propertyIsEnumerable()
    ...

5) 遍历对象中的属性
    加强for循环

    for(var key in obj){
        var val = obj[key];
    }
    key属性
    obj对象
    依次从obj中获取到属性名

6) 检测一个属性是否能够被对象调用
    "name" in obj

函数
1) 做用api

1. 功能的封装，【方法】
    将特定功能的代码封装起来，当须要的时候调用它才会执行。
2. 构建对象的模板，【构造函数】

2) 定义
    1. 函数声明
        函数声明会提高，也就是在执行全部代码以前，函数声明会先执行；

        function 函数名(形式参数){
            函数体;
            返回值;
        }
        function add(a,b){
            var result = a + b;
            return result;
        }
        var total = add(1,2);

    2. 函数表达式
        var 函数名 = function(形式参数){};
        var a = 3;
        var obj = {};
        var add = function(a,b){return a+b;};
        var foo = add;
        var bar = add;
3) 函数调用
    1. 函数名(实参);
        add(1,2);
        foo(2,3);
        bar(3,4);
    2. 函数名.call(obj,实参列表)
        调用指定函数名的函数，而且将obj赋值给该函数中的this
    3. 函数名.apply(obj,实参数组)
        调用指定函数名的函数，而且将obj赋值给该函数中的this

4) 函数在内存中的表现形式

5) 函数的做用域
    1. 函数内部声明的变量，在函数外部不能访问
    2. 函数外部声明的变量，在函数内部能够访问，那这个时候，函数与外部的这个变量就组成了闭包。
    3. 在js中函数内部不存在局部做用域
        function foo(){
            if(true){
                var a = 3;
            }

            console.log(a);    //3
        }
    4. 若是想在函数中建立一个具备局部做用域的变量，如何实现？
        1) 使用let声明变量
            function foo(){
                let b = 4;
                if(true){
                    let a = 3;
                }
                console.log(a);    //报错
            }
        2) 使用匿名函数的执行来虚拟局部变量

            (function(){
                if(true){
                    var b = 1;
                }
            })();
6) 函数的内部属性
    只有在函数内部才能访问、只有函数在执行过程当中才能肯定的属性

    function add(a,b){
        var result = a + b;
        return result;
    }
    add(22,42,12,44);

    1.参数
        形式参数是方法接受实参的快捷方式，真正的实参保存在arguments
    2. arguments
        类数组对象
        {
            '0':22,
            '1':42,
            '2':12,
            '3':44
        }
    3. this
        当前的执行对象
        this的取值与函数的调用方式有关
        1) 若是使用"()"调用函数，观察"()"左边是不是函数名，若是是函数名，继续观察函数名左边是否存在对象，若是是，那么this指向这个对象；若是不是指向全局对象（global/window）

        var sayName = function(){
            console.log("hello i am "+this.name);
        }
        var p1 = {
            name:"terry",
            age:12,
            sayName:sayName
        }
        var p2 = {
            name:"larry",
            age:12,
            sayName:sayName
        }
        sayName()
        p1.sayName();
        p2.sayName();

7) 引用传递，值传递【赋值是赋栈区的值】
    var a = 3;
    var b = a;        (值传递)
    b++;    

    var a = function(){}
    var b = a;         （引用传递）
        a将指向函数的引用地址传递给b,a和b都指向该函数

    var a = {name:"terry",age:12};
    var b = a;        (引用传递)
    b.age++；
    a.age             

8) 函数做为值，实参，返回值
    var a = function(){}    【匿名函数】
    1. 函数当作实参
        回调函数（函数当作参数来传递）【定制】
        函数，参数进行遍历，调用者
        加工厂     成衣             贴牌
        A对象调用B对象的C方法，C方法在执行的过程当中又返回来调用A对象的D方法 
    2. 函数当作返回值    
        比较器函数
        [{
            id:1,
            name:"terry",
            age:12
        },{
            id:2,
            name:"larry",
            age:9
        } ,{
            id:2,
            name:"tom",
            age:19
        }]

        按照age来排序
            function(a,b){
                if(a.age>b.age){
                    return 1;
                } else {
                    return -1;
                }
            }
        按照编号来排序
            function(a,b){
                if(a.id>b.id){
                    return 1;
                } else {
                    return -1;
                }
            }

        工厂函数
            function factory(prop){
                return function(a,b){
                    if(a[prop]>b[prop]){
                        return 1;
                    } else {
                        return -1;
                    }
                }
            }

            factory("age");

数组
数组是存听任意数据类型值的集合，容器。在数组字面量中，数组使用"[]"做为数组的边界，数组由多个元素组成，元素与元素之间经过","隔开，元素能够为任意数据类型。数组是一种特殊的对象，经过length属性来获取数组的长度（也就是数组中元素的个数）数组

1) 数组的定义闭包

1. 数组字面量
    var name = "name"
    var arr = [12,name,true,"larry",{},function(){},[],null];

    arr.length
2. 构造函数
    var arr = new Array();     
    =》
    var arr = [];

    var arr = new Array(length);
    建立一个长度为length的数组
        var arr = new Array(2);
        var arr = [undefined,undefined];

    var arr = new Array(p1,p2,...);
    建立一个数组，数组中的元素使用实参初始化
        var arr = new Array(1,2,3);
        var arr = [1,2,3];

3) 数组的访问
        经过索引来访问，索引从0开始的，直到数组的长度-1，索引能够超过索引范围，只不过访问的值为undefined

        var arr = [1,2,3];
        索引：0~2

        arr[0]         //1
        arr[100]     //undefined

    4) 数组的遍历
        1. 普通for循环
            var arr = [1,2,3];
            for(var i=0;i<arr.length;i++){
                var item = arr[i];
            }
        2. while循环
        3. do-while循环
        4. 加强for循环
            for(var key in arr){
                var val = arr
            }
    5) 数组在内存中的表现
        var arr = [[1,2],[3,4],[5,6]];
        arr[1][0]    //3

    7) 数组api
        arr     Array     Object
        arr能够调用Array.prototype的方法,也能够调用Object.prototype中的方法

        api (应用程序编程接口)
            做用
            参数
            返回值

        1. 添加或者移除元素 【对原值进行了改变】
            push()    入栈，将元素添加到数组的最后
                参数：入栈的元素
                返回值：入栈后数组的长度
            pop()     出栈，将数组中的最后一个元素移除，而且返回
                参数：none
                返回值：被出栈的元素
            shift() 出队，将数组中的第一个元素移除，而且返回
                参数：none
                返回值：被移除的元素
            unshift()     插队，将元素添加到数组的最前面
                参数：插队的元素
                返回值：插队后数组的长度
        2. 排序方法【改变原值】

            var arr = [82,1,43,2,8,32,5];
            arr.mySort()
            console.log(arr);

            // [1,2,5,8.32,43,82]

            sort();
                默认状况下，按照每位字符在字符编码表中出现的位置进行排序
            sort(comparator)
                comparator
                    接受两个参数a,b;
                    若是a在b以前返回-1
                    若是a在b以后返回1

        3. 截取方法
            concat()     【不改变原值】
                数组合并
                参数：多个数组
                返回值：合并的后的新数组
            slice(begin [,end])【不改变原值】
                截取子数组，而且返回
                参数： begin表示截取的开始位置；end默认为0
                返回值：截取后的子数组
            splice(begin,delete,insert,...)【改变原值】
                arr.splice(3,2)
                arr.splice(3,2,"terry","larry")

                返回值：被删除的元素组成的数组
        4. 索引方法
            indexOf()
            lastIndexOf()
        5. 序列表
            JSON

            字符串
                arr.join("*")
                将数组元素转换为字符串，使用"*"链接arr中的每一个元素

        6. 迭代
            1) 循环方法
                forEach(function(item,index,arr){

                })

                Array.prototype.myForEach = function(handler){
                    for(var i=0;i<this.length;i++){
                        handler.call(this,this[i],i,this)
                    }
                }
                arr.myForEach(function(item,index,arr){})
            2) every
                every(function(item,index,arr){
                    return boolean
                })
                当回调函数每次都返回true，返回值才为true
                当回调函数有一次返回false,返回值就为false，而且会中止执行
            3) some
                some(function(item,index,arr){
                    return boolean
                })
                当回调函数每次都返回false，返回值才为false
                当回调函数有一次返回true,返回值就为true，而且会中止执行
            4) filter
                filter(function(item,index,arr){
                    return boolean
                })
                当回调函数返回true的时候，当前元素会被添加到返回值数组中
            5) map
                filter(function(item,index,arr){
                    return v
                })

                将回调函数的返回值组成一个新的数组返回

包装器数据类型
var a = 3;app
- a = new Number(a);// 自动装箱

a.toString();    

Number()
Boolean()
String()
    var a = 3;
    var b = true;
    var c = "hello world"    

c 能够调用String.prototype中的方法以及Object.prototype原型中的方法

String相关API
    length         字符串中字符个数
    charAt()    指定索引位置上的字符
    charCodeAt()     指定索引位置上字符的字符编码号
    indexOf()         从前日后查找指定字符在字符串中出现的位置
    lastIndexOf() 从后往前查找指定字符在字符串中出现的位置

    concat()     字符串拼接
    slice(begin,end)     从begin处开始截取，直到end可是不包含，将截取的值返回，不改变原值
    substring(begin,end)    从begin处开始截取，直到end可是不包含，将截取的值返回，不改变原值
    substr(begin,len)     从begin处开始截取，截取长度为len

    trim()     删除字符串左右两边的空格
    toUpperCase()     转换为大写
    toLowerCase()     转换为小写


    正则表达式相关方法：
    search()     
    match()
    replace()
    split()

Math对象
Math.min()
Math.max()
Math.ceil()
Math.round()
Math.floor()
Math.random() 0~1
js中函数的维护构造函数原型