js引用类型

<script type="text/javascript" charset="UTF-8">
            //var arr1 = new Array();
            var arr = [1,2,3,4,true,‘abc‘,new date()];
            
            alert(arr.length);
            // 改变数组长度        
            arr.length = 5;    
            alert(arr);  // 1,2,3,4,true 默认调用了toString，将这个对象转换成了字符串
            
            
            var arr2 = [];
            var result = arr2.push(1,2,true); // 压栈，返回值是新数组长度
            var obj = arr2.pop();    //弹栈，从数组的尾部移除一个元素，返回值是移除的元素内容
            
            var arr3 = [1,2,3,true,new date()];
            var result1 = arr3.shift();// 移除数组第一个元素，返回值是移除的元素内容
            var result2 = arr3.unshift(10,false);// 从头部插入元素，返回值是数组的长度
            
            var arr4 = [1,2,3,4,5];
            // splice 第一个参数表示起始位置，第二个参数表示截取的个数，第三个参数以后表示追加的新元素
            // splice操作数组本身
            arr4.splice(1,2,3,4,5); //12345->134545  
            arr4.splice(1,2);//12345->145
            arr4.splice(1);//12345->1
            
            var arr5 = [1,2,3,4,5];
            // slice不操作数组本身
            arr5.slice(2,4);// 12345->34,左闭右开
            
            // 操作数组的方法
            // concat方法不操作数组本身
            var arr6 = [1,2,3];
            var arr7 = [true,4,5];
            var result3 = arr6.concat(arr7);// 数组合并操作
            
            // join方法不操作数组本身
            var resilt4 = arr6.join(‘-‘);//123->1-2-3 在每个元素之间加入内容
            
            // sort方法操作数组本身
            // reverse方法操作数组本身
            var arr8 = [1,4,3,5,2];
            var arr9 = [10,2,4,1,7];
            arr8.reverse();//倒序排序，并非按照大小排序，而是按照元素位置 1,4,3,5,2->2,5,3,4,1
            arr9.sort();//正序排序，按照java中string类型比较的方法去比较的，10.2.4.1.7->1,10,2,4,7
            
            // 想要实现自然排序，需要自己写排序方法。
            function compare (value1, value2){
                if(value1 < value2) {
                    return -1;
                } else if(value1 > value2) {
                    return 1;
                } else {
                    return 0;
                }
            }
            
            arr8.sort(compare); // 1,4,3,5,2 ->1,2,3,4,5
            
            // 位置方法
            var array1 = [1,2,3,4,5,4,3,2,1];
            // 比较的时候使用"==="来进行比较，不自动转换
            var value = array1.indexOf(4);// 返回结果为3，返回参数第一次出现的位置
            var value1 = array1.indexOf(4,4);// 第一个参数是起始位置，第二个参数是查找的内容，即从起始位置4开始查找第一次元素4出现的位置
            var value2 = array1.lastIndexOf(2);//返回7，从后往前查找
            
            // 迭代方法
            // every：对数组每一个元素进行一个函数的运行，函数如果都返回为true，最后结果返回true，如果有一个返回false，则结果为false。
            var res = array1.every(function(item, index, array) {
                return item > 2;
            });
            
            // filter:对于数组的每一个元素也是进行函数的运行，给定的函数去执行，把过滤后的结果返回
            var res1 = array1.filter(function(item, index, array) {
                return item > 2;
            });
            
            // foreach：循环数组每一项的值，并执行一个方法
            array1.foreach(function(item, index, array) {
                alert(item);
            });
            
            // map:对数组每个元素进行一个函数的运行，可以经过函数执行完毕后，将新的结果返回
            var res2 = array1.map(function(item, index, array) {
                return item * 3;
            });
            
            // some:对数组每一个元素进行一个函数的运行，函数如果有一个返回true，则结果为true，如果都为false，结果才为false
            var res3 = array1.some(function(item, index, array) {
                return item > 10;
            });
            
            // 缩小方法
            // 第一个参数为前一个值，第二个参数为当前值，第三个参数为当前索引位置，第四个参数是数组本身
            var res4 = array1.reduce(function(previous, current, index, array) {
                return previous + current;//求和
            });
            // 和reduce方法的区别，reduce方法是从左开始遍历，reduceRight方法是从右边开始遍历
            var res5 = array1.reduceRight(function(previous, current, index, array) {
                return previous + current;//求和
            });
        </script>

// Object 类的创建
            var obj = new Object();
            var obj1 = new Object; // 不建议
            var obj2 = {};

<script type="text/javascript" charset="UTF-8">
            // Object 所有类的基础类
            // Object 类的创建
            var obj = new Object();
            var obj1 = new Object; // 不建议
            var obj2 = {};
            
            // 给对象设置一些属性
            obj.name = ‘zhangsan‘;
            obj.age = 17;
            obj.sex = ‘male‘;
            // 下面的赋值方式，一定要加‘‘
            obj[‘birthday‘] = ‘1998-03-21‘;
            obj.say() = function() {
                alert(‘hello world‘);
            };
            // 访问对象的属性和方法
            alert(obj.name);
            alert(obj.age);
            obj.say();
            
            // 删除对象属性或方法 delete操作符
            delete obj.age;
            delete obj.say;
            
            alert(obj.age); // undefind
            obj.say();  //obj.say is not a function
            
            // 如何去遍历一个js对象 使用for in语句式
            for (var item in obj) {
                alert(item);
            }// name,sex,birthday会被输出
            
            for (var item in obj) {
                alert(obj[item]);
            }// zhangsan,male,1998-03-21被输出
            
            
            // Constructor： 保存对象的创建函数
            alert(obj.constructor); // function Object() {[native code]}
            var arr = [];
            alert(arr.constructor); // function Array(){[native code]}
            
            // hasOwnProperty(propertyName):用于检测给定属性在对象中是否存在
            obj.hasOwnProperty(‘name‘);// 返回值为boolean类型 
            
            // isPrototypeOf(Object): 检测原型
            
            // propertyEnumerable(propertyNmae)：用于检查给定的属性是否能通过for in语句来枚举
            obj.propertyEnumerable(‘name‘);// 返回值为true
        </script>