js基础（数组）

 

对象的分类：内建对象、宿主对象、自定义对象

普通对象使用属性名进行访问，数组对象使用索进行访问

创建一个数组：var arr = new Array();

使用typeof检查一个对象，会返回一个object

向数组中添加一个元素：arr[0] = 1;

对于连续的数组，使用length可以获取到数组的长度（元素的个数），对于非连续型数组，使用length会获取到数组的最大索引+1，尽量不要使用非连续型数组

修改length，arr.length = 5、如果修改后的length大于原长度，则多出来的部分会空出来，如果修改的length小于原长度，则多于的长度户会直接删除

 

使用字面量创建数组：var arr = [13,"abc", true, 53.2];

使用构造函数创建数组的时候，也可以同时添加元素，将要添加的元素作为构造函数的参数进行传递    var arr = new Array(343,"jack", true, 45.3);

 

 

push()//该方法可以向数组的末尾添加一个或者多个元素，并返回数组的新长度

 

var arr = new Array(343,"jack", true, 45.3);
var result = arr.push("Tom",false);
console.log(arr);//[343, "jack", true, 45.3, "Tom", false]
console.log(result);//6

 

pop()//该方法可以删除数组的最后一个元素，并将删除的元素作为返回值进行返回

var arr = new Array(343,"jack", true, 45.3);
var result = arr.push("Tom",false);
console.log(arr);//[343, "jack", true, 45.3, "Tom", false]
console.log(arr.pop());//false
console.log(arr);//[343, "jack", true, 45.3, "Tom"]

unshift()  //向数组开头添加一个或者多个元素，并返回数组的新长度，其他元素自动进行调整

var arr = new Array(343,"jack", true, 45.3);
var result = arr.unshift("新增元素1","新增元素2");
console.log(arr);//["新增元素1", "新增元素2", 343, "jack", true, 45.3]

shift()  //删除元素的个数，并将删除的元素返回

var arr = new Array(343,"jack", true, 45.3);
var result = arr.unshift("新增元素1","新增元素2");
console.log(arr);//["新增元素1", "新增元素2", 343, "jack", true, 45.3]
result = arr.shift();
console.log(arr);//["新增元素2", 343, "jack", true, 45.3]
console.log(result);//新增元素1

 

forEach()需要一个函数作为参数，这种函数称为回调函数　　//这个方法只支持IE8以上的浏览器

var arr = new Array(343,"jack", true, 45.3);
arr.forEach(function(value , index , obj){
                    console.log("index:" + index + "    value:" + value+ "    obj:" + obj);
          });

//输出结果：
index:0    value:343     obj:343,jack,true,45.3
index:1    value:jack    obj:343,jack,true,45.3
index:2    value:true    obj:343,jack,true,45.3
index:3    value:45.3    obj:343,jack,true,45.3

 

slice()：从数组中提取指定的元素，这个方法不会改变元素数组，而是将截取的元素封装到一个新的数组进行返回

/*         - 参数：
 *                  1.截取开始的位置的索引,包含开始索引
 *                  2.截取结束的位置的索引,不包含结束索引
 *                            - 第二个参数可以省略不写,此时会截取从开始索引往后的所有元素
 *                  - 索引可以传递一个负值，如果传递一个负值，则从后往前计算
 *                            -1 倒数第一个
 *                            -2 倒数第二个
 */
var arr = [343,"jack", true, 45.3, false];                  
var result = arr.slice(1,4);
console.log(result);//["jack", true, 45.3]
result = arr.slice(3);
console.log(result);//[45.3, false]
result = arr.slice(1,-2);
console.log(result);//["jack", true]

 

splice()：用于删除数组中指定的元素，会影响原数组，将删除的元素返回

          /*        - 参数：
           *                  第一个，表示开始位置的索引
           *                  第二个，表示删除的数量
           *                  第三个及以后。。
           *                            可以传递一些新的元素，这些元素将会自动插入到开始位置索引前边
           *        
           */
var arr = [343,"jack", true, 45.3, false];                  
var result = arr.splice(3,1,"Tom","Marry","Bob");                              
console.log(arr);//[343, "jack", true, "Tom", "Marry", "Bob", false]
console.log(result);//[45.3]

var arr = [343,"jack", true, 45.3, false];                  
var result = arr.splice(3,0,"Tom","Marry","Bob");                              
console.log(arr);// [343, "jack", true, "Tom", "Marry", "Bob", 45.3, false]
console.log(result);//[]

 

去除数组中的元素

//创建一个数组
var arr = [1,2,3,2,2,1,3,4,2,5];

//去除数组中重复的数字
//获取数组中的每一个元素
for(var i=0 ; i<arr.length ; i++){
          //console.log(arr[i]);
          /*获取当前元素后的所有元素*/
          for(var j=i+1 ; j<arr.length ; j++){
                    //console.log("---->"+arr[j]);
                    //判断两个元素的值是否相等
                    if(arr[i] == arr[j]){
                              //如果相等则证明出现了重复的元素，则删除j对应的元素
                              arr.splice(j,1);
                              //当删除了当前j所在的元素以后，后边的元素会自动补位
                              //此时将不会在比较这个元素吧，我需要在比较一次j所在位置的元素
                              //使j自减
                              j--;
                    }
          }
}

console.log(arr);

 

concat()方法可以连接两个或者多个数组，并将新的数组返回，不会对原数组产生影响

var arr1 = [1234,3454,5656,454];
var arr2 = ["Tom","Jacky","Marry"];
var arr3 = [true, false];
var arr = arr1.concat(arr2,arr3);
console.log(arr);//[1234, 3454, 5656, 454, "Tom", "Jacky", "Marry", true, false]
console.log(arr1);//[1234, 3454, 5656, 454]
console.log(arr2);//["Tom", "Jacky", "Marry"]
console.log(arr3);//[true, false]

 

join()   将一个数组转换成一个字符串，不会对原数组产生影响，在方法中指定一个字符串作为参数（连接符），如果不指定，默认是，，如果不想使用连接符，则用""

var arr = ["Tom","Jacky","Marry"];
console.log(arr);//["Tom", "Jacky", "Marry"]
console.log(arr.join());//Tom,Jacky,Marry
console.log(arr.join(""));//TomJackyMarry
console.log(arr.join("##"));//Tom##Jacky##Marry

 

reverse()数组反转，会改变原数组

var arr = ["Tom","Jacky","Marry"];
console.log(arr.reverse());// ["Marry", "Jacky", "Tom"]

 

sort()  数组排序（按照Unicode进行排序），影响结果

var arr = ["Tom","Jacky","Marry"];
console.log(arr.sort());// ["Jacky", "Marry", "Tom"]
arr = ["b","d","e","a","c"];
console.log(arr.sort());//["a", "b", "c", "d", "e"]
arr = [5,11,2,1,3,6,8,7];
console.log(arr.sort());//[1, 11, 2, 3, 5, 6, 7, 8]

浏览器根据回调函数决定元素的位置，如果返回值大于0，两数交换位置，如果返回值小于0，位置不变

arr = [5,11,2,1,13,6,8,7];
                              
arr.sort(function(a,b){          
          //前边的大
         if(a > b){
                    return -1;
          }else if(a < b){
                    return 1;
          }else{
                    return 0;
          }         
          //升序排列
          //return a - b;        
          //降序排列
          return b - a;         
});

console.log(arr);