JavaScript-数组和数组的一些方法

JavaScript Array（数组） 对象

数组对象的作用是：使用单独的变量名来存储一系列的值。

什么是数组?

所谓数组，是有序的元素序列。 [1] 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按无序的形式组织起来的一种形式。 [1] 这些无序排列的同类数据元素的集合称为数组。

 var ary = [1,true,'qqq',null,undefined,{q:1},function(){console.log(2)}];

• 数组是用于储存多个相同类型数据的集合。**
• 数组的每一项的数据类型 是 可以为 任意数据类型
• 数组可以用一个变量名存储所有的值，并且可以用变量名访问任何一个值。
• 数组中的每个元素都有自己的的ID，以便它可以很容易地被访问到。

声明式数组

var ary = [1,2,3,4];

构造函数

var ary = new Array()

（1）创建数组

创建一个数组，有三种方法。下面的代码定义了一个名为 myCars的数组对象：
1：常规方式

var myCars=new Array(); 
myCars[0]="Saab";       
myCars[1]="Volvo";
myCars[2]="BMW";

2.简洁方式

var myCars=new Array("Saab","Volvo","BMW");

3.字面

var myCars=["Saab","Volvo","BMW"];

（2）数组赋值

1.有两种向数组赋值的方法（你可以添加任意多的值，就像你可以定义你需要的任意多的变量一样）。

var mycars=new Array()
mycars[0]="Saab"
mycars[1]="Volvo"
mycars[2]="BMW"

2.也可以使用一个整数自变量来控制数组的容量：

var mycars=new Array(3)
mycars[0]="Saab"
mycars[1]="Volvo"
mycars[2]="BMW"

（3）访问数组

数组的每一项都有一个属性名（数组本身就是一个对象，他只是对象的一个细分）跟他对应。这里的属性名（依次递增的数字） 我们叫做索引，所以数组也可以用for in循环，也可以用for循环，while循环

用for in循环遍历出数组的每一项

 var ary = [1,true,'qqq',null,undefined,{q:1},function(){console.log(2)}];
 for(var k in  ary){
 //k 每一个属性名
      console.log(ary[k])
 }

对象中的查看 打点 [’’]，因为数组是对象的一个细分，所以
数组本身也因该有打点和 [’’] 两种方式 ，对象中 数字的属性名，我们只能用 [’’]和[]的方式，所以数组中的查看我们只能用 [’’]和[]

var ary = [1,true,'qqq',null,undefined,{q:1},function(){console.log(2)}];
ary[1]；//true
ary['0'];//1

数组添加项

 var ary = [];
    ary.aa = 'aa';
    ary.bb = 'bb';
    ary[3]= '33';
    console.log(ary);

（4）修改 数组的方法

一、增加

 var ary =[];
 ary[3]='qq'

1.push() 在数组末尾增加几项；
push（xx,xxx,xxxx,）参数可以有很多个，参数的数据类型不限；返回值是改变后数组的长度；

 var ary=[2,3,4,5];
  var a =  ary.push(1)
  console.log(a) //5   赋值 是把右边的运行结果赋给左边；//右边的运行结果就是push --函数的返回值

也可以利用length在数组末尾添加
length;
数组的索引是从0开始的；数组的最后一项是ary.length-1;

var ary=[2,3,4,5];
ary[ary.length]='a';
console.log(ary);

封装的用length在数组末尾添加添加的方法

var ary=[2,3,6,8]; function myPush(ary,n) {
      console.log(ary[ary.length]);
      ary[ary.length] = n;
      return ary.length;
  }
  myPush(ary,'pppppp');

2.unshift:在数组的前面添加，返回值也是改变后的数组长度，参数也可以是多个;

var ary2 = [12,23,13,14];
    var res = ary2.unshift(1,2,3);
    console.log(res, ary2);//(7) [1, 2, 3, 12, 23, 13, 14]

二、删除

1.pop:删除数组的最后一项：参数无： 返回值：被删除的那一项；

 var ary =[12,13,14]
    var res3 = ary.pop();
     console.log(res3,ary);

用length 删除最后一项

var ary =[12,13,14];
ary.length=ary.length-1;
console.log(ary)

2.shift 删除数组的第一项；参数 无 ；返回值–>删除的那一项

 var ary4 =[12,13,14];
     var res4 =ary4.shift();
     console.log(res4,ary4);//12 [13,14]

3.splice(n,m,x,y,z,…)从索引为n（包含n）的地方开始，删除m个元素，用x,y,z,…替换之前的元素；返回值是删除的m项组成的新数组

    var ary5 =[12,13,14];
    var res5 =ary5.splice(1,1,21,22,22,32);
    console.log(res5,ary5)

用 splice 实现push

    function myPush2(ary,n) {
        // ary 要操作的数组
        // n  需要添加的项
        ary.splice(ary.length,0,n);
        // 操作数组 --》 在 ary 的最后一项后的一项 删除 0 个； 用 n 代替删除的 0个；也就是 在最后一项的后一项的前边 添加 n;  --- > 也就是在最后一项后边添加 n
        return ary.length;
        // 返回改变后的 数组的 长度
    };

用 splice 实现pop

  function myPop(ary) {
        var temp = null;
        temp = ary.splice(ary.length-1,1);
        return temp[0]
    };

数组排序

1、 reverse ：反转； 数组的反转；（ 参数 无返回值 反转后的数组）

    var ary = [1,2,3,4,5];
 var res = ary.reverse();//返回一个倒叙后的数组，跟原数组是同一个地址，
  console.log(res, ary);

自己封装的reverse倒叙方法

    function myReverse(ary) {
        for(var i = 0; i < ary.length/2 ; i++){
            var temp = ary[i];
            ary[i] = ary[ary.length -1 - i];
            ary[ary.length -1 - i] = temp;
        }
        return ary;
    }

    function myReverse2(ary) {
        var arr = [];
        // for(var i = 0; i < ary.length ; i++){
        //     arr.unshift(ary[i])
        // }
        for(var i = ary.length-1; i >= 0; i--){
            arr.push(ary[i])
        }
        // ary = arr;
        return arr;
    }

2.数组的 sort排序

• 参数可以没有 没有参数时， 它是只能实现 10 以内的排序
• 有参数时，参数是个函数（回调函数）
• 返回值 是排好序的 数组 跟 原数组是一个地址

   var ary2 = [1,2,4,2,1,5,3,7,5,9,6];
    var res2 = ary2.sort();
    res2[0] = 10;
    console.log(res2, ary2);

有回调函数时

var ary3 = [2342,11,32,12,232,245];
    ary3.sort(function(a,b){
        console.log(a, b);
        // 当返回值时 正数时  对应的两项要调换位置
        return a - b;
    });
        console.log(ary3);

    ary3.sort(function(a,b){
        console.log(a, b);
        // 当返回值时 正数时  对应的两项要调换位置
        return b - a;
    });
    console.log(ary3);

课外扩展（字母排序）

var ary4 = [‘a’,‘g’,‘s’,‘f’]; // 用localeCompare

不该变数组的一些方法

1、toString(); 不接受参数 返回值是 每一项用逗号连接的字符串

   var ary = [1,2,3,4,5];
    var res = ary.toString();
    console.log(res, typeof res, ary);

2. join(); 接受参数，可以不传参；把数组以指定字符，连接成字符串

  var res2 = ary.join();// 它是默认是 逗号 连接
    var res3 = ary.join(','); // 等价于 ary.toString()
    var res4 = ary.join('+');
    var res5 = ary.join(' ');
    var res6 = ary.join('');

eval();// 把字符串转化成 表达式

var str = '1+2+3';
    eval(str);//6

利用join和eval进行数组求和

 var ary =[1,2,3,4]
    function sum(ary) {
        var str3 = ary.join('+');//错误写法  类数组没有数组上的这些方法
        return eval(str3);
    }
    sum(ary);

3.concat（） 拼接数组用的，参数可以不传，也可以传多个，参数的数据类型不限。

复制数组

  var res1  = ary.concat();//数组复制一份，返回给res1；
    //复制一份  ary2=ary.slice(0)  ary2=ary.slice()

当参数是数组时，他会把这个数组拆开，一项一项的放到新数组中，
当数组是其他数据类型时，他是整个的拼到新数组中。

  var res2 = ary.concat(12,13,[22,23,[24,25]],{w:1,q:[34]},function () {
        console.log(22)
    },true); //
    console.log(res2);

4.slice(n,m) 从索引n（包含n）开始获取到索引m（不包含m）； 返回值是 获取到的项组成的数组；

     var res4 = ary.slice();//复制一份   //参数可以为负数；
    var res4 = ary.slice(0);//复制一份；

5、indexOf // 用途 一般用来查看 某一项在不在这个数组里边

• 没有 对应的项时 返回的值 是 -1;\
• ary.indexOf(xxx,n) // 从索引 n 开始查找， 是否包含xxx项，包含就返回其对应的索引，否则返回 -1，默认 n = 0
• lastIndexOf 从最后一项开始查看

    ary = [1,2,3,4,5,1,3,1,3];
    console.log(ary.indexOf(3));//2
    console.log(ary.lastIndexOf(3));//8

    console.log(ary.indexOf(1));//0
    console.log(ary.lastIndexOf(1));//7

    console.log(ary.indexOf(6));//-1
    console.log(ary.lastIndexOf(6));//-1

    var ary2 = ['qqq','www'];
    console.log(ary2.indexOf('qqq'));