关于javascript:day-06-数组

1. 数组

（1）概念

一个变量只能存储一个数据，如果咱们有一组数据，比方 1 到 100 一百个数字，定义 100 个变量来存储就太苦楚了，这时候咱们就须要数组来存储这样的数据。数组相似于数学概念中的中的汇合。

（2）定义

​ 1）构造方法：应用 new 在内存中开拓空间, 返回的是 new 进去空间的地址

var arr = new Array();// 无参构造函数，创立一空数组
var arr = new Array(5);// 创立指定长度的数组 (因为数组长度能够动静调整，作用并不大)
var arr = new Array(1,2,'hello');// 创立数组并初始化参数数据 

​ 2) 字面量：应用方括号，与下面的 new 是一样的，也会在内存中开拓空间

var arr = [ ];// 等同于调用无参构造函数
var arr = [10];// 等同于调用带有初始化数据的构造函数 

（3）数组元素的拜访

• 语法：数组名 [下标];

  • 下标 base on zero，下标最大取值是“长度 -1”，千万不要越界（越界后的后果不是你想要的后果）
  • 下标是间断的整数
  • 下标能够是变量或表达式
  • 数组的长度：数组名.length 返回以后数组的长度

• 数组的批改

   数组名 [下标]= 赋值;

  var arr = [5,7,9];
  arr['haha'] = 99;// 如果对没有的下标元素进行赋值，则等价于增加新元素
  console.log(arr);//5，7，9，99

（4）数组的遍历

通常操作数组时，每个元素都要操作一遍，这个时候咱们会用循环来拜访每一个元素，循环拜访数组的每一个元素的过程就叫做数组的遍历。

//1. 惯例的 for 循环
for(var i=0;i<arr.length; i++){console.log(arr[i]);
}

 //2. for...in... 遍历数据的下标
     for(var index in arr){// console.log(arr[index]);
        console.log(index);
    }

// 3. for...of... 遍历内容
for(var item of arr){console.log(item);
}

（5）数组的逆序

<script>
    var arr=[5,6,3,7,8,4];
    for(var i=0; i<parseInt(arr.length/2);i++){
        // 替换元素
        var temp;
        temp = arr[i];
        arr[i] = arr[arr.length-i-1];
        arr[arr.length-i-1] = temp;
    }
    for(var i=0; i<arr.length;i++){console.log(arr[i]);
    }
</script>

（6）数组的常见函数

如何学习函数：关注 3 点

1. 函数的性能
2. 函数的参数
3. 函数的返回值

push 尾插 返回数组的新长度

• 数组名.push (参数 1,[ 参数 2 … 参数 N]):
• 向数组的开端增加一个或多个元素

var arr = [1,2,3];
var len = arr.push(4,5);
console.log(len);//5
console.log(arr);//1,2,3,4,5

pop 尾删 无参 返回被删元素

• 删除并返回数组的最初一个元素

var arr=[8,5,9];
var x = arr.pop();
console.log(x);//9
console.log(arr);//8,5

unshift 头插 返回数组的新长度

• 数组名.unshift(参数 1,[ 参数 2 … 参数 N])
• 向数组的结尾增加一个或多个元素，并返回新的长度

var arr = [6,5,7];
var a = arr.unshift(10,90);
console.log(a);//5
console.log(arr);//10,90,6,5,7

shift 头删 无参 返回被删元素

• 把数组的第一个元素从其中删除，并返回第一个元素的值

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

splice 删除若干个元素或增加若干个元素

• splice(参数 1, 参数 2, 参数 3) 返回一个由删除元素组成的新数组

  • 参数 1 开始索引
  • 参数 2 删除元素的位数
  • 参数 3 插入的新元素，当然也能够写多个

join 通过参数连接成字符串

• 数组名.join([分隔符号])

• 将数组转为字符串 : 返回值为转换后的字符串

  var arr=[4,7,3];
  console.log(arr.join('~'));//4~7~3

slice 截取子数组

• slice (起始地位，完结地位): 返回截取的子数组 左闭右开

var arr=[4,6,7,4,6,5];
var arr1 = arr.slice(3,5);
console.log(arr1);//4, 6

concat 拼接数组

• concat(减少的数组): 返回一个新数组

  var arr1 = [6,7,5,8];
  var arr2 = [0,3,7];
  console.log(arr1.concat(arr2));//6,7,5,8,0,3,7

reverse() 将数组逆序

• 无参 无返回 与之前不同的是它会间接批改原数组

var arr=[5,7,8,9,3];
arr.reverse();
console.log(arr);//3,9,8,7,5

sort() 数组排序

• 用于对数组进行排序 (只能由小到大)
• 字符串比拟，所以和咱们料想的后果不同
• 返回排序后的数组，且原数组产生扭转

var arr=[9,7,8,5];
arr.sort();
console.log(arr);//5,7,8,9

var arr=[19,7,8,5];
arr.sort();
console.log(arr);//19, 5,7,8

二维数组（理解）

var arr = [[],[],[],[]];

随机函数

• Math.random();
• 无参, 返回值为 0~1 的小数

排序

冒泡排序

• 趟次 (外层循环)：N-1；
• 次（内层循环）：N-1-i; 内层循环两两替换

// 应用冒泡法由小到大排列
<script type="text/javascript">
    var arr= [5,7,8,4,6,5,2,7];
    var temp;
    // 外层循环 n - 1 次
    for(var i=0; i<arr.length; i++){
        // 内层循环 n -i-1
        for(var j=0; j<arr.length-i-1;j++){
            // 由小到大排列
            if(arr[j]>arr[j+1]){temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
    console.log(arr);//[2, 4, 5, 5, 6, 7, 7, 8]
</script>