day22（数组的详细介绍：定义 使用 遍历以及数组的API 多维数组以及冒泡排序的写法）

一.数组的概念

	数组:批量存储变量的容器，通过该容器操作数组中的所有元素；

二.数组的定义

1.要点
	所有的引用类型数据都必须通过new关键字和构造函数开辟空间
	构造方法：
	  1. new关键字的作用是在堆内存中开辟空间；
	  2. Array是数组的构造函数,是数组的数据类型（一个模版）；（除了数组类型之外还可
	     以有字符串类型等）
	  4. new和构造函数必须连用，不能分开，代表在堆内存开辟某种引用类型的对象空间
	     字面量：字面量都是一些不可改变的值（比如常量12345或者固定的字符串内容  
	     等），变量的值一般可以用来保存字面量，而且变量的值是可以任意改变的，变量更
	     加方便我们的使用，所以一般在开发中通常都是通过变量去保存一个字面量，而且很
	     少使用字面量，可以通过变量对字面量进行描述
2.语法
	基本语法：
	    var 标识符 = new 构造函数(参数);
	写法1：（用得少）
	     var arr = new Array(1,2,3,4,5);
	写法2：（字面量写法）
	    var arr = [1,2,3,4,5];    第二种写法与第一种写法相比少了一个很关键的部分
	 “new”关键字，此处系统会自动加上看不见的“new”
	    
	    此处要注意数组储存的是元素，元素有数值，相当于变量有自己的数值，这和数组内
	 部直接储存数值不同，元素（变量）的数值是可以更改的
	    
	    两个写法代表的效果相同（创造了一个数组对象,该对象有五个元素,数值分别为
	 1,2,3,4,5），更多用第二个

三.内置基本类型与引用类型的存储方式

内置类型在内存的存储方式：
   	 只有一块栈空间,存储的是数值
引用类型在内存的存储方式：
  	 有两块空间，一块栈空间，存储的是new来源空间（堆空间）的地址；一块堆空间，存储
  的是数据本身
	  注意点：无论是内置基本类型还是引用类型，值传递都只发生在栈空间，与堆空间无
   关，所以，对引用类型来说，值传递就是在栈空间传递他在堆空间的地址。就好比一个房间
   的若干把钥匙，每一把钥匙都可以打开房门。在栈空间传递的引用类型的存储地址也都可以
   影响到堆空间的数据，这就是引用类型实参与形参双向值传递的本质，究其根本，是因为存
   储地址被传入封装函数，经过若干运算，直接改变了堆空间的数据，封装函数调用后再使用
   堆空间地址时，获取的就是被改变之后的数据了

四.数组元素的使用

1.语法
	元素的访问：
    数组名[下标]
  举例：
	    var arr = [5,7,"heihei",4,9];
	    arr[0] = "xixi";    此处对数组arr的第一个元素赋值新的值 “xixi”；
2.下标要点
	下标:数组元素的索引
	  1.从0开始连续的自然数
	  2.取值范围是0~length-1（length是数组的长度，就是数组内的元素个数）
	  3.可以使用变量
	  4.数组不能越界访问，越界的结果就是undefined（越界就是下标的数值超过元素个
	    数，试图去定义或寻找一个数组内不存在的元素）

五.数组的遍历

遍历：对数组的所有元素进行相同的操作(本质就是循环操作所有元素)
特点：依赖于循环，访问数组的所有元素 ,做某种相同的操作；

案例：
	所有元素加上10
  var arr = [1,2,3,4,5,7,8];    
 for(var i=0; i<arr.length; i++){    length就是数组元素个数的数值，此处循环给数组所有元素加上10
        arr[i] += 10;
    }
    
数组的逆序：
思路：
    实现数组的逆序，可以通过两两交换，第1个与第length-2个交换位置，第2个与第length-3个交换位置，互换位置的两个元素，他们的下标的数值之和就是length-1，从第一个一直换到第length/2个，也就是正中间位置
    var arr = [6,5,4,7,8,3,9,2,0,1];
    var len = arr.length;
    var t;

    for(var i=0; i<parseInt(len/2); i++){
        t = arr[i];    这里利用空变量交换他们的数值；
        arr[i] = arr[len-i-1];    
        arr[len-i-1] = t;
    }

六.数组的API（数组函数）

1.pop
	功能:数组尾部删除一个元素
	参数:无参
	返回值:被删除的元素
	案例：
	    var fruits = ["Banana", "Orange", "Apple", "Mango"];
	    var x = fruits.pop();  ------------------------Returns "Mango"，
	    这一句将数组fruits内的元素“mango”删除
	    
	    var arr = [6,4,7,8,3];
	    arr.pop();----------------------使用写法，此处删除数组arr内元素“3”
	    console.log(arr);
	
	    arr.pop();
	    console.log(arr);    此处删除数组arr内元素“8”
2.push
	功能:数组尾部插入元素
	参数:push(x1,[x2,x3...])  x1是必须的,被[]括起来的参数是非必须的
	返回值:新数组的长度length（注意区分，不是新数组的元素，而是元素个数）
	案例：
	    var arr = [6,4,7,8,3];
	    arr.push(1,2);    在该数组尾部插入1,2
	    var x = arr.push(9); 在该函数尾部插入9，x的值为9，因为此时数组内部有9个元素
3.shift
	功能:在数组头部删除第一个元素
	参数:无
	返回值:被删除的元素
	案例：
	    var arr = [6,4,7,8,3];
	    var x = arr.shift();
4.unshift
	功能:在数组头部插入元素
	参数:unshift(x1,[x2,x3...])  x1是必须的,被[]括起来的参数是非必须的
	返回值:新数组的长度
	案例：
	    var arr = [6,5,4,7,8,9];
	    var x = arr.unshift(1,2,3);
	    console.log(arr);    此时arr值为：1,2,3,6,5,4,7,8,9
	    console.log(x);    x值为新数组的元素个数，也就是9
5.reverse
	功能:让元素逆序排列，会改变原数组的排列顺序
	参数:无
	返回值:被逆序的数组
	案例：
	    var arr = [5,4,6,7,8,3];
	    arr.reverse();
	    console.log(arr); 此时arr值为：3,8,7,6,4,5
6.concat
	功能:数组的拼接,该方法不会改变原数组（所以需要将拼接结果赋给新的数组才能体现）
	参数:concat(数组)
	返回值:拼接后的新数组
	案例：
	    var arr1 = [1,2,3];
	    var arr2 = [4,5,6];
	
	    var arr3 = arr1.concat(arr2);
	
	    console.log(arr3);
7.splice
	功能:删除且替换
	参数:splice(起始位置,偏移量,[替换的元素]);    此处起始位置用数组的下标来计算，
	     偏移量就是从起始位置往右数需要被删除并替换的元素的个数；替换元素被加上[]代
	     表不是用这个函数就必须写上替换元素，替换元素可写可不写，根据需求，是可以只
	     删除不替换的，但如果要写替换元素切替换元素不止一个的话，替换元素之间两两以
	     逗号隔开
	返回值:被删除的元素
	案例：
	    var arr = [5,6,4,7,8,3];
	    var arr1 = arr.splice(1,4,"heihei","yingyingying");    这里函数替换删除起始点从元素“6”开始到“8”，所以6,4,7,8全部被删除，以“heihei”，“yingyingying”这两个新元素替代
	
	    console.log(arr);
	    console.log(arr1); 这里arr1的值就是原数组被删去的元素；
8.slice
	功能:截取数组的区间,不会改变原数组（这是这个函数与splice只删除效果的区别）
	参数:slice(起始位置,结束位置); 左闭右开 [2,4)     此处结束位置计算方式与splice
         不同，这里是从第几个元素到第几个元素，不再是往后数几个元素，且序列区间左闭
         右开，意味着结束位置的元素要往回退一个，如果结束位置是第n个元素，slice截取
         的最后一个元素则是第n-1个
	返回值:被截取的数组
	案例：
	    var arr = [6,5,7,4,8];
	    console.log(arr.slice(2,4));    此处被截取的元素为7，4，原本第四个元素应
	      该是8，但因为右边是闭区间，所以不包含8，被截取部分最后一个元素是4。
	注意：虽然解释上说明元素序列区间为左闭右开，但代码里面右边不写方括号，两边都是
	      圆括号，改方括号会报错。
9.join
	功能:将数组转换为字符串（不改变原数组）
	参数:join([分隔符]) 括号里面啥都没写的时候默认用逗号分开元素
	返回值:被转换的字符串
	案例：
	    var arr = [6,5,7,4,8];
	    console.log(arr.join("，"));

多维数组：：：：：：：：：：

多维数组:JS中没有多维数组的概念，所谓的多维数组是通过一维数组的嵌套实现的（一般套两
         层，也就是二维数组）
     var arr = [
        [1,2,3],    数组arr的第一个元素，arr[0]也是一个数组，而这个小数组里面的第一个元素“1”，就是arr[0][0],下面数组都同理
        [4,5],
        [6,7,8,9]
    ];
    
多维数组的遍历：
    for(var i=0; i<arr.length; i++){    这一层外循环是第一层数组
        for(var j=0; j<arr[i].length; j++){ 这一层内循环是第二层数组
            document.write(arr[i][j]+" ");    嵌套循环遍历数组，给小数组的元素都加上空字符串。
        }
        document.write("
");    每循环完一个小数组则换行来区分
    }

冒泡排序：：：：：：：：：：

冒泡排序：数值存在数组中，按照由小到大（大到小）一种排序算法
    核心思想:两两交换    整体思路就是数值大（小）的往右换
    外层循环:趟数 N-1
    内层循环:次数 N-1-i(趟数)
    
代码展示：
var arr = [5,6,7,4,8,3,9,2,1,0];
var t;
    for(var i=0; i<arr.length-1; i++){
        for(var j=0; j<arr.length-i-1; j++){
            if(arr[j]<arr[j+1]){
                这里选择条件为前一个数值小于后一个数值就换位置，也就是大的数字往左
            排，小的数字往右排，故数组arr最终的值为：9,8,7,6,5,4,3,2,1,0，换成大于
            号就正好相反，结果逆序排列
                t = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = t;
            }
        }
    }

    console.log(arr);