数组 与 数组方法unshift，push，shift，pop，splice，sort，reverse，join，concat

数组

    // 数组
    // 所谓的数组,就是数据的集合
    // 基本数据类型 : 在变量中只能存储一个单元的数据;
    // 数组,是数据的集合,可以存储多个单元的数据

    // 数组的创建方式
    
    // 1,字面量方式
    // var 变量 = [ 数据1 , 数据2 , 数据3 , ..... ];
    // 在 [] 中,定义多个数据单元,中间使用逗号间隔

    // 创建一个变量 存储数组,数组中有5个数据单元
    // 数组中的数据单元,可以是任意形式的数据内容
    // 数组中的数据单元,可以是一个数组,对象,函数
    var arr = [1,2,3,4,5,'北京','上海',true,false,undefined,null,[6,7,8,9,10],{name:'张三'},function fun(){console.log}];

    console.log(arr);

    // 2, 构造函数方式 -- 创造一个空数组
    // 然后再向这个数组中添加单元
    // 这是JavaScript的固定语法,必须这么写
    // 一般不用这种方式来定义数组

    // 调用 构造函数 Array() 通过 new 关键词,来生成数组的实例化对象,存储在变量中
    // new 是JavaScript的关键词
    // Array() 是JavaScript定义好的构造函数,可以直接使用
    var arr2 = new Array();

    console.log(arr2);

    // 数组是JavaScript中,一个非常重要的数据类型
    // 后端接口返回给我们的数据行是,往往都是数组的形式

// 1, 定义数组

    // 字面量方式
    var arr = [1,2,3,4,5];
    console.log(arr);


    // 内置构造函数方式
    var arr2 = new Array();

// 2, 调用数据的数据

    // (1) 索引下标
    //     JavaScript程序给数组中的每一个单元都定义了一个编号,是从0开始的整数
    //     通过索引下标,就可以获取到对应的具体某一个数据

    console.log( arr[0] );    // 调用索引下标是0的第一个单元的数据  
    console.log( arr[1] );    // 调用索引下标是1的第二个单元的数据  
    console.log( arr[2] );    // 调用索引下标是2的第三个单元的数据  
    console.log( arr[3] );    // 调用索引下标是3的第四个单元的数据  
    console.log( arr[4] );    // 调用索引下标是4的第五个单元的数据  
    console.log( arr[400] );  // 调用不存在的索引下标,执行结果是undefined
    console.log( arr[0,1] );  // []中写两个索引,不会同时调取两个数据,后面的会覆盖前面的
                              // 因此,一般只在[]中写一个索引下标
                              // 数组单元,只能一个一个获取

    // 这是一个嵌套数组
    // 第一层的数组,我们称为 一维数组
    // 第二层的数组,我们称为 二维数组
    // 一维数组中,数据的调用,是,正常的调用方法,数组变量[索引]
    //
    var arr2 = [ '北京' , '上海' , '广州' , ['a' , 'b' , 'c' , 'd'] ];

    console.log(arr2);

    console.log(arr2[0])     // 北京
    console.log(arr2[1])     // 上海
    console.log(arr2[2])     // 广州
    console.log(arr2[3])     // 二维数组['a' , 'b' , 'c' , 'd']
    console.log(arr2[3][0])  // 二维数组中,索引下标是0的第一个单元 a
    console.log(arr2[3][1])  // 二维数组中,索引下标是1的第二个单元 b
    console.log(arr2[3][2])  // 二维数组中,索引下标是2的第三个单元 c
    console.log(arr2[3][3])  // 二维数组中,索引下标是3的第四个单元 d

    // 数组的length属性
    // 是数组特有的属性,表示数组的长度,也就是单元的个数
    // 数组中最大的索引下标 是 length-1 
    // 获取length属性值 :  数组变量.length 

序号	姓名	年龄	地址	性别

// 定义的数组,根据数组,渲染生成页面内容

// 通过索引下标来操作数组

<script>
    // 1,通过索引下标,调用数组中,指定单元的数据

    var arr = ['北京','上海','广州','重庆','天津'];
    // arr[0] ---> 调用索引下标是 0 ,实际是第一个单元的数据 北京


    // 2,通过索引下标,来修改数组中,存储的单元的数据
    // 对已存在的索引下标,进行赋值,进行的是重复赋值,会覆盖之前存储的数据
    arr[0] = '武汉';
    // console.log(arr);

    // 3,通过索引下标,来新增数组的单元
    // 对不存在的索引下标,进行赋值,是新增数组单元的操作
    
    // 连续索引 
    arr[5] = '郑州';

    // 间隔索引
    arr[100] = '瞎写的';

    // console.log(arr);
    // console.log(arr[50]);

    // 4,通过索引下标,来删除数组的单元
    // 定义数组的length长度属性,通过定义数组的单元个数,来删除数组的单元
    // 只能是从数组的结尾处开始删除单元,不能从数组的起始开始删除单元
    // 一般不使用,除非是一定要限制数组长度

    arr.length = 100;
    // arr.length = 6;

    console.log(arr);
</script>

操作数组方法

// 总结:新增可以是一个或者多个
    //      删除一次只能一个

    // unshift()  起始新增,可以是一个或者多个
    // push()     结束新增,可以是一个或者多个
    // shift()    起始删除,只能是一个
    // pop()      结束删除,只能是一个

// 截取数组的指定单元 / 删除数组的指定单元 splice

    var arr = ['北京','上海','广州','重庆','天津'];

    **// 删除广州重庆**

    // 方法1,从结束位置删除 3个单元 
    //      之后再把 天津 添加上

    // 方法2,  数组.splice()
    // 参数1: 删除起始单元的位置---索引下标
    // 参数2: 从起始单元开始,删除单元个数---删除几个单元
    // 参数3: 在删除的位置上,插入的新的数据
    //        替换插入的数据,可以是一个,可以是多个,多个单元之间使用逗号间隔
    //                      也可以任意JavaScript支持的数据类型

    // 从索引下标是2,也就是第三个单元开始,删除2个单元
    // 操作结果返回值是 删除单元组成的新的数组
    // var res = arr.splice(2,2);

    // console.log(arr);
    // console.log(res);


    // 如果只写一个参数,是从删除位置开始,删除之后所有的单元,包括起始位置单元
    // arr.splice(2);

    // 如果不写参数,没有效果的
    // arr.splice();

    // 写三个单元执行效果类似于替换操作
    // 从索引下标是2,实际是第三个单元开始,删除2个单元(包裹索引2的单元)
    // 然后替换插入数据 武汉 , 加油
    var res2 = arr.splice(2,2,'武汉','加油');

    console.log(arr);
    console.log(res2);

// 数组的排序方法 sort

    // 将数组中的数据按照数值大小来进行排序

    // 数组.sort()  默认按照首位数值排序,不是数值的实际大小
    // 数值.sort( function(a,b){return a-b} )  按照数值的实际大小排序 --- 从小到大
    // 数值.sort( function(a,b){return b-a} )  按照数值的实际大小排序 --- 从大到小

    var arr = [3,21,3215432,321321,32,43,5,34,43,23,32543,1234,45,321,14,234,4];
    
    // 数组的排序方法
    // arr.sort();

    // 从小到大的固定语法形式
    // arr.sort( function(a,b){return a-b} )

    // 从大到小的固定语法形式
    arr.sort( function(a,b){return b-a} )

    console.log(arr);

// 数组的反转
// 数组.reverse();

    // 将数据库中,数组最后的最新的消息,反转到最上方先显示

    // var arr = ['北京','上海','广州','重庆','天津'];

    // arr.reverse();

    // console.log(arr);

// 数组和字符串的转化
// 数组.join() 不会改变原始数组的内容
// 返回值是字符串类型,内容是数组中每个单元存储的数据信息,默认使用逗号间隔
// 遵守其他数据类型转化为字符串类型的自动转化原则

    var arr = ['北京','上海','广州','重庆','天津',true,false,100,[1,2,3,4],{name:'张三'},function fun(){}];

    // 默认逗号间隔
    var res1 = arr.join();
    // 设定间隔符号   
    var res2 = arr.join('-');   
    // 没有间隔符号,设定空字符串作为间隔  
    var res3 = arr.join('');  

    // console.log(arr);
    // console.log(res1);
    // console.log(res2);
    // console.log(res3);


    // 字符串转化为数组
    // 将字符串,切割,存储为数组的形式
    // 不会改变原始字符串
    // 返回值是: 按照字符串,转化为的数组
    // 语法1:不定义参数,将字符串整个转化为数组的一个单元
    // 语法2:定义参数为'' 空字符串 将每个字符,转化为一个单元
    // 语法3:可以按照特定的间隔符号来分割字符串
    //       存储单元数据内容中,没有间隔符号
    // 语法4:设定第二个参数,是设定数组的单元个数,也就是length长度
    //       一般是不写的

    var str1 = '北京-上海-广州-天津-重庆';
    // 按照间隔符号 - 减号来分割字符串,存储成数组形式
    // 并且设定数组为3个单元成都
    var res4 = str1.split('-' , 3);
    console.log(res4);

// 数组的拼接
// 数组1.concat(数组2)
// 将两个数组,拼接为一个数组
// 将来两个数组的数据内容进行拼接

    var arr1 = [1,2,3,4,5];
    var arr2 = ['北京','上海','广州','重庆','天津'];

    var arr3 = arr1.concat(arr2);
    console.log(arr3);