Javascript-Array-CSDN博客

本文链接：https://blog.csdn.net/qq_43675078/article/details/116055911

1-introduce

  1)每一项都可以保存任何类型的数据。
  2)数组的大小是可以动态调整。
  3)数组的length属性：可读可写，可以通过设置length的值从数组的末尾移除项或向数组中添加新项

2-define

  1)  var arr = new Array();
    > var arr = new Array(20);  // 预先指定数组的大小
    > var arr = new Array("terry","larry","boss");//传入参数
  2)  var arr = ["terry","larry","boss"];

3-visit elements of Array

//数组最多可以包含4 294 967 295个项
//var arr = new Array();
  arr[index]; //element undefined 添加新元素
    》var arr = ["terry","larry","boss"];
	    arr[3] ="jacky";		//添加元素,数组长度变为4

4-数组的方法

1）数组检测

arr instanceof Array //对于一个网页或者一个全局作用域使用
Array.isArray(arr) //网页中包含多个框架、不同的全局执行环境

 var arr = [];
 var arr1 = "string";
 console.log(arr instanceof Array);//true
 console.log(arr instanceof Object);//false
 console.log(Array.isArray(arr));//true

2)数组长度

       >arr.length
        //该方法可以从数组末尾移项或者向数组中添加项目 
        //该方法也可以修改数组的大小
  
   var arr = ['a','v','d'];
    arr.length = 2;
    console.log(arr);//[ 'a', 'v' ]
    var arr1 = ['a','v','d'];
    arr.length = 5;
    console.log(arr1); //[ 'a', 'v', 'd', <2 empty items> ]

3)数组的遍历

>for-in  
    var arr = ['1','d','m'];
    for (var key in arr){
      console.log(arr[key]);
    }//key 是索引
>while
>do-while

4) 数组的构造
Array.prototype //构造函数的原型

5)数组的序列化`将数组转换为字符串.

>toString()
  arr.toString();
>join()
  arr.join();//可以通过任意字符链接
>JSON.stringify()
  JSON.stringify(arr);
---------------------------------------
  var arr = [1,2,3,4];
  console.log(arr.toString()); //1,2,3,4
  console.log(arr.join()); //1,2,3,4
  console.log(arr.join(-)); //1-2-3-4
  console.log(JSON.stringify(arr)); //[1,2,3,4]

6)数组的反转`arr.reverse();

  提问:如何将字符串反转?
    1 把字符串通过split('')将字符串切割成数组
    2 将数组元素反转
    3 将反转好的数组元素拼接成字符串
  var str = 'hello';
  var res = str.split('').reverse().join('');
  console.log(res);

7)数组的排序`arr.sort()

1)默认排序：该方法会调用每个数组项的toString() 方法，然后按照字符序列排序
  var arr = [12,34,56,4];
  console.log(arr.sort());// [12,34,4,56]

2)自定义排序：

a.该方法可以接受一个比较函数作为参数，比较函数有两个参数
b.如果第一个参数位于第二个参数之前，返回负数
c.如果第一个参数位于第二个参数之后，返回正数 
      var arr = [12,34,56,4];
      var res = arr.sort(function(a,b){
        return a>b?1:-1;
      })// 1:从小到大排序 2:从大到小排序
      console.log(res);//[ 4, 12, 34, 56 ]

      var arr = [12,34,56,4]; 
      var res = arr.sort(function(a,b){
        return a>b?-1:1;
      })// 1:从小到大排序 2:从大到小排序
      console.log(res);//[ 56, 34, 12, 4 ]

8)数组迭代`数组自己提供的方法

五个遍历方法都三个参数的匿名函数,
      >item:
      >index;
      >arr:
forEach(function(item,index,arr){}) //对数组中的每一元素运行给定的函数，没有返回值，常用来遍历元素
map(function(item,index,arr){}) //对数组中的每一元素运行给定的函数，返回每次函数调用的结果组成的数组
every(function(item,index,arr){})
filter(function(item,index,arr){})//对数组中的每一项运行给定的函数，会返回满足该函数的项组成的数组
some(function(item,index,arr){})

 var arr = ['a','d','s','e'];
 arr.forEach(function(item,index,arr){//forEach函数没有返回值.
   console.log(item,index,arr);
 });
 输出:a 0 [ 'a', 'd', 's', 'e' ]
     d 1 [ 'a', 'd', 's', 'e' ]
     s 2 [ 'a', 'd', 's', 'e' ]
     e 3 [ 'a', 'd', 's', 'e' ]

 var arr = [4,'d','s',23];
 var result = arr.map(function(item,index,arr){
     return item * 2;
 });
 console.log(result);
 输出:[ 2, NaN, NaN, 46 ]

 var arr1 = [4,0,13,23];
 var result1 = arr1.filter(function(item,index,arr1){
     return item > 4;
 });
 console.log(result1);
 输出:[ 13,23 ]

 var arr1 = [4,0,13,23];
 var result1 = arr1.some(function(item,index,arr1){
     return item > 4;
 });
 console.log(result1);
 输出:true

9)数组的元素的增删改

    >push()
      //在数组后放新增元素
      //新增元素
      //返回值:新增完元素后数组的长度
    >unshift()
      //在数组前方仅新增一个元素
      //返回值:新增完元素后数组的长度
      //参数:新增元素
    >pop()
      //在数组后放仅删除一个元素
      //返回值:被删除的元素
      //参数:无
    >shift()
      //在数组前方仅删除一个元素
      //返回值:被删除的元素
      //参数:无
    >concat()
      //拼接两个数组
      //参数:需要拼接的的数组(可以有多个数组用,隔开)
      //返回值:拼接好的新数组
    >可以通过Array.prototype 函数名 = function(){} 重构函数
    > slice() ——> 不会改变原数组
  定义：切割数组
  参数：
      一个参数：表示从当前参数指定位置开始【索引】，截取数组，一直到数组结尾;
      两个参数：表示截取两个参数之间的元素【不包含结束位置上的元素】;
  返回值：截取到的元素组成的新数组，如果没有截取到元素，则返回空数组

      var arr = [1,2,3];
       var res = arr.slice(1);
       console.log(arr);           //[ 1, 2, 3 ]
       console.log(res);           //[ 2, 3 ]

       var arr = [1,2,3];
       var res = arr.slice(5);
       console.log(arr);           //[ 1, 2, 3 ]
       console.log(res);           //[]

       var arr = [1,2,3,4,5,6];
       var res = arr.slice(2,4);
       console.log(arr);           //[ 1, 2, 3, 4, 5, 6 ]
       console.log(res);           //[ 3, 4 ]

splice() ——>
定义：对数组进行删除、替换、插入的操作
参数：
删除：指定两个参数(起始位置，要删除的项数)
var arr = [1,2,3,4,5,6];
var res = arr.splice(2,1);
console.log(arr); //[ 1, 2, 4, 5, 6 ]
console.log(res); //[ 3 ]
返回值：被删除的元素组成的新数组

  插入：指定三个参数(起始位置，0，要插入的任意数量的项)
      var arr = [1,2,3,4,5,6];
      var res = arr.splice(2,0,'a','b');
      console.log(arr);                   //[ 1, 2, 'a', 'b', 3, 4, 5, 6 ]
      console.log(res);                   //[]
  返回值：空数组

  替换：指定三个参数(起始位置，要删除的项数，要插入的任意数量的项)
      var arr = [1,2,3,4,5,6];
      var res = arr.splice(2,3,'a','b');
      console.log(arr);                   //[ 1, 2, 'a', 'b', 6 ]
      console.log(res);                   //[ 3, 4, 5 ]
  返回值：被删除的元素组成的新数组

5-数组元素的检测

 indexOf()
     定义：查找数组中的元素
     参数：需要查找的元素
     返回值：
         如果元素在数组中存在，则返回元素在数组中首次出现时的索引位置；
         如果元素在数组中不存在，则返回-1；

     var arr = [1,2,3,1,2,3];
     var res1 = arr.indexOf(1);
     var res2 = arr.indexOf(2);
     var res3 = arr.indexOf(3);
     var res4 = arr.indexOf(4);
     console.log(arr);
     console.log(res1);      //0
     console.log(res2);      //1
     console.log(res3);      //2
     console.log(res4);      //-1

5-API

  数组的api由实例调用
  var arr = new Array()// arr :实例,可以调用构造函数原型上面的方法
                          Array:构造函数
                          Array.prototype :构造原型函数

例题:

console.log(’---------------自己造一个函数--------------------’);
// 随便输入数据添加到数组结尾
var arr1 = [1,2,3];
Array.prototype.myPush = function(){
console.log(arguments.length);//传递参数的个数
for(var i=0; i<arguments.length;i++){
this[this.length] = arguments[i];
}
return this.length;
};
// 随便输入数据添加到数组开头
Array.prototype.myUnShift = function(){
for(var j=0; j<arguments.length; j++){
this.unshift(arguments[j]);
}
return this.length;
};

//myShift()数组出队
Array.prototype.myShift = function(){
if (this.length == 0) {
return undefined;
}
var firstElement = this[0];
for(var i = 1 ; i < this.length ; i++){
this[i-1] = this[i];
}
this.length = this.length-1;
return firstElement;
}

//myUnshift 数组入队
Array.prototype.myUnshift = function(){
var L = this.length;
for(var i = L + arguments.length - 1 ; i >= 0 ; i–){
if(i > arguments.length - 1){
this[i] = this[i - arguments.length];
}else{
this[i] = arguments[i];
}
}
return this.length;
}

var res2 = arr1.myPush(3,5);
console.log(arr1);
console.log(res2);
var res3 = arr1.myUnShift(3,5);
console.log(arr1);
console.log(res3);