2.javascript基础-基本语法 js面向对象 闭包 数组

数组对象的常用方法

    var arr = new Array(4, 3, 2, 1);
    alert(arr.toString());//toString()方法返回以逗号隔开的所有元素组成的字符串
    alert(arr.join('|'));//在数组各个元素中间插入指定的字符
    alert(arr.reverse().toString());//数组反转
    alert(arr.concat([5, 6, 7, 8, 9]).toString());//连接两个数组
    alert(arr.sort().toString());//升序排列
    alert(arr.push('p'));//向数组的末尾添加一个或多个元素，并返回新的长度。
    alert(arr.pop());//返回数组的最后一个元素
    alert(arr.shift().toString());//删除并返回数组的第一个元素
    arr.unshift([9, 0]);//向数组的开头添加一个或更多元素，并返回新的长度。
    alert(arr.slice(1, 4).toString());//从某个已有的数组返回选定的元素
    arr.splice(0, 4, [1, 2, 3, 4]);//删除元素，并向数组添加新元素。

数组对象的sort()方法

如果调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序，说得更精确点，是按照字符编码的顺序进行排序。要实现这一点，首先应把数组的元素都转换成字符串（如有必要），以便进行比较。
如果想按照其他标准进行排序，就需要提供比较函数，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数
a 和 b，其返回值如下：

    var arr = new Array(3, 1, 4, 3, 4, 3, 43, 65, 7, 8665);
    alert(arr.sort().toString());//不提供参数默认按照字符编码顺序进行排序
    arr.sort(function (a,b) {
        return a - b;
    });
    alert(arr.toString());

js中的键值对集合

第一种声明键值对集合的方式：数组形式
键值对数组的length属性值为0，因为length属性只支持索引为数字的数组，因此想要循环遍历键值对数组必须使用for-in循环

    var arr = new Array();
    arr['zs'] = '张三';
    arr['ls'] = '李四';
    arr['ww'] = '王五';
    //根据键查找值
    alert(arr['zs']);
    //键值对数组的length属性值为0，因为length属性只支持索引为数字的数组，因此想要循环遍历键值对数组必须使用for-in循环
    for (var key in arr) {
        alert('键：' + key + "   值：" + arr[key]);
    }

第二种声明键值对集合的方式：json格式

        var dict = { 'zs': '张三', 'ls': '李四', 'ww': '王五' };
        //还可以动态添加键和值
        dict.zl = '赵六';
        alert(dict.ls);//直接可以通过键值对对象点出来
        //循环遍历
        for (var key in dict) {
            alert('键：' + key + "   值：" + dict[key]);
        }

js中的String对象、Date对象、Math对象
String对象相关方法
Date对象相关方法
Math对象相关方法
js面向对象

    //这是一个函数，也可以叫做“函数对象”
    function Person() {
    }
    //第一种方式
    //对于Person函数可以直接调用，直接调用就是将Person()当做一个"函数"来使用
    //比如：
    Person();//把Person()当做一个普通函数来调用
    //把Person函数当做"类"来使用，通过Person函数创建一个Person类型的对象p。
    //当调用Person函数前加了new关键字，表示要通过Person函数创建一个对象。此时，一般把Person()函数叫做"构造函数"。也就是说，当直接调用一个函数的时候，那么叫"函数",当通过new关键字调用一个函数的时候，这个函数就叫做"构造函数"（不叫"类"）。
    var p = new Person();//这样就创建了一个Person类型的对象p
    //当定义一个函数的时候，如果要将该函数作为"构造函数"来使用，那么函数命名就应该采用"帕斯卡"命名法。如果定义函数的时候就已经确定将来该函数只作为一个普通函数来调用，那么就采用"骆驼命名法"。
    //通过构造函数创建Person对象
    function Person(name, age, gender) {
            this.userName = name;//这里的this表示通过构造函数创建的当前对象
            this.userAge = age;
            this.userGender = gender;
            this.sayHi = function () {
                alert('大家好，我叫' + this.userName + "，今年" + this.userAge + "岁了。");
            }
        }
    var p1 = new Person('张三', 18, '男');
    p1.sayHi();

    //对象的属性也可以通过键值对的方式进行访问,所以对象也可以进行遍历
    alert(p1['userName']);//对象的属性通过键值对方式进行访问
    for (var key in p1) {
            alert(key + '     ' + p1[key]);
        }

js中判断某个对象是否为某个类型,使用instanceof关键字

    function Person() { }
    var p = new Person();
    alert(p instanceof Person);//和C#中的is关键字效果一样

通过对象字面量来创建对象,这种方式不需要再去创建构造函数，可以快速的封装一个数据

    var p1 = {
        userName: '张三',
        userAge:20,
        userGender: '男',
        sayHi: function () {
            alert('hi...');
        },
        sayHello: function () {
            alert('hello.....');
        }
    }
    p1.sayHello();
    p1.sayHi();

js中的原型对象prototype

  function Person(name, age, gender) {
        this.userName = name;
        this.userAge = age;
        this.userGender = gender;
    }
    Person.prototype.sayHi = function () {//为Person类型通过prototype属性注册一个方法
        alert(this.userName + this.userAge + this.userGender);
    }

    var p1 = new Person('张三', 19, '男');
    var p2 = new Person('李四', 20, '男');
    p1.sayHi();
    p2.sayHi();

js原型中的属性是只读的

    Person.prototype.userEmail = 'sample@163.com';
    var p1 = new Person('张三');
    //下面的代码并没有修改原型中的userEmail属性的值，只是动态地为p1对象添加了userEmail属性
    p1.userEmail = 'zs@163.com';//将userEmail的属性值修改成了"zs@163.com"，其实原型中的userEmail属性值并没有改变，因为原型是只读的，这里只是将p1对象中添加了一个userEmial属性。当后面p1对象再次访问userEmial属性的时候，就是访问的p1对象本身的userEmail属性。
    var p2 = new Person('李四');
    alert(p1.userEmail);//此时打印"zs@163.com"，这个userEmial属性不是来自原型，而是自身注册的
    alert(p2.userEmail);//此时打印"sample@163.com"，p2对象打印的还是原型中的userEmail属性

通过原型进行扩展方法

一般不要给系统类型通过原型添加扩展的方法，因为如果后期系统类型也添加同名的方法，会造成混乱。

 //加入要给系统类型添加一个方法
    String.prototype.addStar = function () {
        return this + "☆";
    }
    var str = '1234';
    str= str.addStar();
    alert(str);

js中没有"类"的概念，"继承"是通过对象和对象来实现的

 //声明一个Person函数对象
    function Person(name, age, gender) {
        this.user_name = name;
        this.user_age = age;
        this.user_gender = gender;
    }
    //为Person函数对象添加扩展方法
    Person.prototype.sayHi = function () {
        alert('hi...'+this.user_name);
    }
    //声明一个Student函数对象
    function Student(sid, age, gender) {
        this.stu_id = sid;
        this.stu_age = age;
        this.stu_gender = gender;
    }
    var p1 = new Person();
    Student.prototype = p1;//这句话就实现了Student类型继承自Person类型，记得一定是把Person类型的对象赋值给Student函数对象的prototype属性才行
    var s1 = new Student('李四', 19, '女');
    s1.user_name = '王五';//Student类型的对象就能够访问Person类型的成员了
    s1.sayHi();

模拟私有属性

        //模拟私有属性
        function Person(name) {
            this.user_name = name;
            var user_age;//实例化的Person对象是无法直接访问这个所谓的"属性"的,可以将这个"属性"看作是"私有的"
            this.setAge = function (age) {
                user_age = age;
            };
            this.getAge = function () {
                return user_age;
            };
        }
        var p1 = new Person('张三');
        p1.setAge(20);
        alert(p1.user_name + '  ' + p1.getAge());

js中的闭包

定义：「函数」和「函数内部能访问到的变量」（也叫环境）的总和，就是一个闭包。
什么是闭包?简单来说，闭包是指可以访问另一个函数作用域变量的函数，一般是定义在外层函数中的内层函数。
为什么需要闭包？局部变量无法共享和长久的保存，而全局变量可能造成变量污染，所以我们希望有一种机制既可以长久的保存变量又不会造成全局污染。
特点：占用更多内存不容易被释放
何时使用？变量既想反复使用，又想避免全局污染如何使用？1.定义外层函数，封装被保护的局部变量。 2.定义内层函数，执行对外部函数变量的操作。 3.外层函数返回内层函数的对象，并且外层函数被调用，结果保存在一个全局的变量中。
闭包是通过作用域链实现的：

参考博客：深度解析js中的闭包

        function func1() {
            var arr = new Array();
            for (var i = 0; i < 10; i++) {
                arr[i] = function () {//在一个函数中能够访问函数外面的变量，这里就产生了一个闭包
                    alert(i);
                };
            }
            return arr;
        }

        var arr = func1();
        for (var i = 0; i < arr.length; i++) {//直到这里执行完了，func1函数中的变量才能够被释放，因为这里执行的函数要使用func1中的i变量
            arr[i]();
        }//结果打印10个10

js中的this表示什么

    function func1() {
        alert(this);//因为直接在页面上定义的函数默认是注册给了window对象，所以直接调用func1()这个函数和window.func1()是一样的。正因为func1()函数是window对象的函数，所以func1()函数内部的this就表示window对象。
        //也就是说，在一个函数内部，this表示的是哪个对象，取决于当前函数是哪个对象的函数。
    }
    func1();//这里的this就表示window对象

    function Person() {
    }
    var p1 = new Person();
    p1.fn = function () {
        alert(this instanceof Person);
    };
    p1.fn();//这里的this就表示p1对象

终止事件的触发

    document.getElementById('btn1').onclick = function () {
        alert('第一次弹窗');
        alert('第二次弹窗');
        return false;//return false语句就是终止事件，所以后面的代码就不会执行了
        alert('第三次弹窗');
    };