javascript内置对象一： Array数组

在JavaScript中的任何事物，字符串，数组，函数等等都是对象。

理解：浏览器自己封装好的对象，可以直接使用。

　　

push   /pʊʃ/  增加 在末尾增加              unshif   /ʌn'ʃɪft/   将这些元素插入到一个数组的开始部分

pop   /pɒp/   删除末尾一个                  shift   /ʃɪft/   移除第一个

　　

如果数组全是数字时使用arr.sort()会产生错误的排序结果，这里需要修正如：

var arr = [-5,23,-4,55,-16,-11,25];

console.log(arr.sort());

var result = arr.sort(function(a,b){ return a-b; })  这样输出才正确，必须指定排序条件指定 由小到大 升序排列即可。

===============

<script>
    //创建数组的两种方式：
    //一，构造函数表示法 var array=new Array(n);  方法Array()中的 Array首字母必须大写。 n从0开始，为0可以不写，表示空数组。
    //二，字面量表示法：var infos=[5,"nam",true,Object]; 数组可以用来保存一组不同类型的数据
    //此外使用索引进行读写修改值：
    //读：console.log(infos[3]);
    //改：infos[3]="woaini";
    //数组的length属性可以获得数组里面的数据长度：console.log(infos.length);
    
    //构造函数表示法
    var nums=new Array(3);//已知数组长度，不写长度默认为零。即空数组。
    var colors=new Array();//定义空数组。       
    var pics=new Array(1,2,3,4);//已知数组内容。
    console.log(colors);
    console.log(nums);
    console.log(pics);

//字面量表示法，可以任意类型数据。{email:304676177@qq.com}Object对象
    var infos=[6,"zheng",true,{email:"304676177@qq.com"}]
    console.log(infos[3]);//数组取值，下标从0开始
    infos[2]="aini";//修改对应索引的数组值。
    console.log(infos[2]);
    console.log(infos[5]);//超过数组下标的索引，显示未定义undefined;

//数组中四个栈方法。栈方法只能增删数组第一个和最后一个值
    //push()  unshift()  pop()  shift()
    //array.push(a,b,c...); 在数组后面添加n个值。返回值：添加后数组长度。
    //array.unshift(a,b,c,d...);在数组前面添加n个值。返回值：添加后数组长度。
    //array.pop();删除数组最后一个值。返回值：被删除的对象。
    //array.shift();删除数组第一个值。返回值：被添加的对象。
    var array=[1,"a","b",2,3];
    var len=array.push(4,5,6,7);//数组最后添加n个值:(4,5,6,7)
    document.write(array+"<br/>");//输出添加后的整个数组
    document.write(len);//输出添加后数组的长度，等于array.length.

var a=[1,"a","b",2,3];
    var len=a.unshift(4,5,6,7,8);//数组前面添加n个值:(4,5,6,7,8)
    document.write(a+"<br/>");//输出添加后的整个数组
    document.write(len);//输出添加后数组的长度，等于array.length.

var b=[1,"a","b",2,3];
    var obj=b.pop();//删除数组最后一个值:3。可以调用多次，表示删除多次。
    document.write(b+"<br/>");//输出删除后的整个数组。
    document.write(obj);//输出被删除的对象:3

document.write("<hr/>");
    var c=[1,"a","b",2,3];
    var obj=c.shift();//删除数组第一个值:1。可以调用多次，表示删除多次。
    document.write(c+"<br/>");//输出删除后的整个数组。
    document.write(obj);//输出被删除的对象:1

//-------join分隔符---------
    var str=["a","b","c","d","e"];
    //array.join(separator);  使用分隔符把数组组成一串字符串。
    //separator分隔符，不写默认在数组中插入逗号。可自定义连接符。返回值：字符串。
    console.log(str.join()); //默认把数组用逗号分开重新组成一串字符串。
    console.log(str.join("-"));//把数组用 “-” 分开重新组成一串字符串。
    console.log(str.join("+++"));//把数组用 “-” 分开重新组成一串字符串。

//-------reverse反序---------
    var array=[1,2,3,4,5];
    //array.reverse(); 反序，把数组的顺序颠倒过来。返回值：数组
    console.log(array.reverse());// 5,4,3,2,1

var array=["e","d","g","b","h"];
    console.log(array.sort());//降序：b,d,e,g,h 。
    //使用默认排序：a到b降序，如果想反过来就使用array.reverse()进行排序。
    console.log(array.sort().reverse());//反序: h,g,e,d,b

//-------sortby排序依据---------
    //说白了只有两种排序：
    //sort（）方法用于对数组的元素进行排序，sort里面可以接收一个比较函数作为参数，return y-x时是降序排序；return x-y时，升序排序。
    //一，array.sort() 默认升序排列，按照第一个字符排序（遵循：1-9,a-b）。另含有字母的所有数组都是按照首字符进行排序。
    //二，纯数字，按照整个数字进行大小排序：
    //1， array.sort(sort(function(a,b){return a-b}));  升序
    //2， array.sort(sort(function(a,b){return b-a}));  降序

var array=["uef",22,66,9,"def",-44,-12,"gge"];
    console.log(array.sort());//默认排序，第一个字符排序
    //array.sort(sortby);按照某种规则排序。默认按照所有数组值的第一个字母或者数字进行排序：1到9,再a到b...
    //数组字母，数字混排，无法比较大小，则下面自定义排序规则，是按照数组对象的第一个数字或首字母进行排序的：先1到9，再a到b。。。返回值：数组
    //sort(:排序依据，对于数字，字母混排无法比较大小，按照第一个字母或数字，按照1-9，a-b排序。
    //sortby:排序依据，对于纯数字，是对整个数组对象的大小进行升降序排列，return a-b 升序 ，return b-a降序
    //一， array.sort(sort(function(a,b){return a-b}));  升序
    //二， array.sort(sort(function(a,b){return b-a}));  降序

var array=[21,144,32,74,15];//纯数字，按照每个值大小进行排序。
    console.log(array.sort());//默认按照首字符排序。 144, 15, 21, 32, 74
    console.log(array.sort(function(a,b){return a-b}));//升序： 144, 15, 21, 32, 74
    console.log(array.sort(function(a,b){return b-a}));//降序：144, 74, 32, 21, 15

var array=["dbg","eee","jgs","ttt","fff"];
    console.log(array.sort());//默认排序，和 自定义a-b，按照首字母升序排列
    console.log(array.sort(function(a,b){return a-b}));//升序：按照首字母升序排列
    console.log(array.sort(function(a,b){return b-a}));//降序：按照首字母降序排列

var array=["e",8,"d",66,"g","b",16,"h",9];
    console.log(array.sort());//默认按照首字符排序：1-9再a-b。
    console.log(array.sort(function(a,b){return a-b}));//升序:h,g,e,d,b,8,9,16,66
    console.log(array.sort(function(a,b){return b-a}));//降序：66,16,9,8,b,d,e,g,h

</script>

===============

<script>
//==============数组操作方法concat合并,slice截取===============
    //concat 合并多个数组
    //array.concat(arr1,arr2,arr3...)  使用array与多个数组合并，返回值：数组。
    var array=[];//字面量创建数组
    var arr1=["a","b","c"];
    var arr2=["d","e","f"];
    var arr3=[1,2,3,4];
    console.log(array.concat(arr1,arr2,arr3));

//slice截取
    //var arr=[]; arr=array.slice(start,end); start,end截取数组所以start到end-1。即：不包含end。
    //如果end是负数:-2，即：start=array.length-2；即从start开始截取到end-1。
    var cols=["red","blue","yellow","orange","green","pink"];
    console.log(array=cols.slice(0));//slice(n),表示从数组的索引n开始一直截取到最后。这里相当于复制。
    console.log(array=cols.slice(2,5));//表示从数组索引2截取到5，不包括5。5是不包括。
    console.log(array=cols.slice(-2,5));//如果start是负数，array.length数组长度加上-2等于4，即截取范围：4到5，不包括5.
    //console.log(array=cols,slice(5,3)); //start=5,end=3, start>end 报错slice is undefined。未定义。

//-----------
    //面试题，复制下面数组，越多越好
    var newArray;//未定义，所以使用时千万记住先声明定义，即使是null或者是空""，也比undefined好，因为undefined很有可能会报错。
    var arr1=["a","b","c"];
    var arr2=["d","e","f"];
    var arr3=[1,"yes",5,"false"];

//复制数组方法一：
     //声明未定义的变量
    newArray1=new Array();//构造函数定义空数组。构造函数使用(),字面量创建数组才使用[]。
    newArray1=[].concat(arr1);//array.concat(arr1,arr2,arr3)，合并多个数组。[]表示一个空数组。
    console.log(newArray1);

//复制数组方法二：
    //声明未定义的变量
    newArray2=new Array();//构造函数定义空数组。构造函数使用(),字面量创建数组才使用[]。
    newArray2=arr2.slice(0);
    console.log(newArray2);

//复制数组方法三：
    //声明未定义的变量
    newArray3=new Array();//构造函数定义空数组。构造函数使用(),字面量创建数组才使用[]。
    for (var i = 0; i < arr3.length; i++) {
        newArray3.push(arr3[i]);
    }
    console.log(newArray3);
</script>

============

<script>
    //splice /splaɪs/  拼接  
    //删除，添加，替换：array.splice(index,n,"a","b","c","d");
    //index,n :表示从索引index开始删除n个元素。然后在索引index前面添加："a","b","c","d"。
    //index,n，n=0时，表示删除0个元素，即表示添加："a","b","c","d"。
    //省略: "a","b","c","d";   array.splice(index.n);表示从索引index开始，删除n个元素。
    
    var array=["a","b","c","d","e","f"];
    //删除
    var arr=array.splice(2,3);//表示从索引值从2开始，删除三个数组元素。
    var arr=array.splice(2);//表示索引值从2开始，删除后面的所有数组元素。
    var arr=array.splice(2,0);//表示索引值从2开始，0表示删除个数，所以一个都不删除。
    console.log(array);
    console.log(arr);

var array=["a","b","c","d","e","f"];
    //添加 返回值：空数组
    arr1=array.splice(2,0,1,2,3);//2,0 ：表示从索引2开始不删除任何值，在索引2的前面添加：1,2,3。
    console.log(arr1);//添加操作返回值为空数组
    console.log(array);//Array(9) [ "a", "b", 1, 2, 3, "c", "d", "e", "f" ]

var array=["a","b","c","d","e","f"];
    //替换  返回被删除的数组
    arr2=array.splice(2,2,1,2,3,4);//2,2 ：表示从索引2开始删除两个元素，且从索引2开始添加数组：1,2,3,4。
    console.log(arr2);//返回值：Array(3) [ "c", "d"]
    console.log(array);//返回值：Array(8) [ "a", "b", 1, 2, 3, 4, "e", "f" ]
</script>

==================================

CSS3中

　　

<script>
    //==========ECMAScript新增属性，存在兼容性==============
    //indexOf(searchValue,startIndex),lastIndexOf(searchValue,startIndex)是ECMAScript新增属性，存在兼容性
    
    var array=[1,2,"b",3,4,"a","b",4,"c","d"];
    //array.indexOf(searchValue,startIndex索引值可选); 存在返回searchValue的索引，不存在则返回-1.
    //从数组索引startIndex，开始向后查找searchValue所在的索引值。
    var pos=array.indexOf("b");//返回Number:2  从数组开头查找第一个"b"的索引。
    console.log(pos);//返回Number:2;
    var pos1=array.indexOf("b",3);//返回Number:6  从数组的索引3开始向后寻找"b"的索引
    console.log(pos1);//返回Number:6

var array=[1,2,"b",3,4,"a","b",4,"c","d"];
    //array.lastIndexOf(searchValue,startIndex索引值可选); 存在返回searchValue的索引，不存在则返回-1.
    //从后向前查找数组中searchValue的索引值。
    var p1=array.indexOf("b");//返回：2    从数组前面向后面查找第一个"b"的索引值。
    console.log(p1);//返回：2   查找对象存在返回索引值，不存在返回：-1.
    var p=array.lastIndexOf("b");//返回：6   从数组后面向前查找第一个"b"的索引值。
    console.log(p);//返回：6   查找对象存在返回索引值，不存在返回：-1.
    var p2=array.lastIndexOf("b",5);//返回值：2，索引5的位置："a"，即从索引值：5 = "a"的位置开始向前查找第一个"b"的索引。
    console.log(p2);

//indexOf(searchValue,startIndex),lastIndexOf(searchValue,startIndex)是ECMAScript新增属性，存在兼容性
    //为了兼容其他浏览器可以自己封装一个方法进行兼容：
    function ArrayIndexOf(array,searchValue){
        for (var i = 0; i < array.length; i++) {//遍历数组
            if (array[i]===searchValue) {//遍历数组，是否有值全等于searchValue。一定要全等，因为7不等于"7"。
                return i;//数组中存在searchValue，获取该值的索引值。
            }
        }
        return  -1;//不存在，则返回number：-1.
    }
    var array=[1,2,"b",3,4,"a","b",4,"c","d"];
    alert(ArrayIndexOf(array,"c"));//从前向后查询数组中"c"的索引值：8
</script>