数组的相关概念

数组

基本概念

1、概念：是一组有序(按照顺序排列)的数据集合；

2、索引：数组的下标，索引永远从0开始；

数组的创建

1、字面量创建数组：

var arr = [1,2,3,'Fray','18']
console.log(arr)

2、通过系统构造函数创建数组

var arr1 = []
var arr2 = new Array()

      --- 若不传参数，输出得到的就是一个空数组

var arr1 = new Array()
console.log(arr1)   //[]

       --- 若传一个参数并且大于0的数字，数组的长度就是这个参数

var arr2 = new Array(10)
console.log(arr2);    //长度为10的空数组
console.log(arr2.lenght);    //10

      --- 传递多个参数，每一个参数按照顺序都是数组中存储的数据

var arr3 = new Arrary(1,'a','b')
console.log(arr3)

数组的获取

1、数组不能使用点语法，可通过数组的下标(索引)来获取操作对应的数据内容

console.log(arr[0])   //获取数组中的第一个
console.log(arr[4])    //获取数组中的第5个

2、修改数组中的每一个数据的内容

arr[4] = 5
console.log(arr)   //输出新的arr中下标为4的数据内容被改成5

3、给数组添加数据及内容

arr [6] = 666
console.log(arr)    //输出新的arr数组中包含添加的新数据

4、当索引的数值大于数组中数据的个数时，输出的内容为undefined；

数组的长度

概念：数组成员的个数；可通过数组的length属性获取；

                 数组的索引从0开始，故最大值就是数组的长度减1；

                 反之，数组的长度就是数组索引的最大值加1；

var arr = [1,2,3,4]
console.log(arr.length);   //4   索引最大值为3

数据在内存中的存储状态

基本数据类型：number，string，Boolean，undefined，null

复杂数据类型(引用数据类型)：function，array，object....

内存：

1、栈内存：基本数据类型；

2、堆内存复杂数据类型；

存储方法：

1、基本数据类型：直接在栈里面存储你的变量名，这个变量名就代表了这个数据；

2、复杂数据类型：数据在堆里面存储，变量名在栈里面存储赋值；

数据类型之间的比较：

1、基本数据类型是值的比较；

2、复杂数据类型是地址之间的比较；

变量赋值之间的区别

【主要看变量中存储的数据类型】

1、基本数据类型：赋值之后两个变量互不影响；

2、复杂数据类型：赋值以后，两个变量操作一个空间，只要用一个变量修改空间内容，那么两个变量看到的空间内容都修改了；

数组常用方法

【不改变变量中存储的地址】

1、删除数组最后一项数据   ——  pop

     语法：数.pop()  ；直接改变原始数组  ；返回值：删除掉的哪一项数据

var arr = [1,2,3,4]
var res = arr.pop()
console.log(arr);    //[1,2,3]
console.log(res);    //4   被删除的数组

2、在数组末尾添加一个数据  —— push

      语法：数组.push(需要添加的内容)  ；直接改变原始数组  ；返回值：增加数组之后的数组长度

var arr = [1,2,3,4]
var res = arr.push(100)
console.log(arr);    //Array(5)
console.log(res)    //长度为5

3、删除数组首项数据  ——  shift

     语法：数组.shift()   ；直接改变原始数组    ；返回值：删除的那一项数据

var arr = [1,2,3,4]
var res = arr.shift()
console.log(arr);     //[2,3,4]
console.log(res);     //1  被删除的那一项数据

4、在数据最前面添加一项数据  —— unshift

     语法：数组.unshift(需要添加的数据)   ；直接改变原数组   ；返回值：添加数组后的数组长度

var arr = [1,2,3,4]
var res = arr.unshift(100) 
console.log(arr);      //[100,1,2,3,4]
console.log(res);      // 5  添加数组后的长度

5、将数组的部分数据进行删除  —— splice

      语法：两种 ；直接改变原始数组  ；返回值：以数组的形势返回被删除的内容

//语法1：数组.splice(从哪个索引开始，删除多少个)
var arr = [1,2,3,4,5]
var res = arr.splice(2,2)
console.log(arr);          //[1,2,5]  从索引为2开始删除了两项数据
console.log(res);          //[3,4]   被删除的两项数据



//语法2：数组.splice(从哪一个索引开始，删除多少个，用新内容替换删掉的位置)
var arr = [1,2,3,4,5]
var res = arr.splice(2,2,'a','b')
console.log(arr);          //[1,2,a,b,5]若新内容的个数大于被删掉的个数，则按照输入顺序输出
console.log(res);          //[3,4] 被删除的内容

6、数组排序  —— sort

     语法：两种  ；直接改变原始数组  ；返回值：改变后的数组

//语法1：数组.sort()    
//直接使用，不传递参数时 是按最前面一位数字开始排序
var arr = [1,2,6,67,12,44,33,66,55]
var res = arr.sort()
console.log(arr);      //[1, 12, 2, 33, 44, 55, 6, 66, 67]
console.log(res);      //[1, 12, 2, 33, 44, 55, 6, 66, 67]


//语法2：数组.sort(function(a,b){return a-b})
//传递一个参数，这个参数是一个带着两个形参的函数，并且return 形参-形参
var arr = [1,2,6,67,12,44,33,66,55]
var res = arr.sort(function(a,b){return a-b})
console.log(arr);      //[1, 2, 6, 12, 33, 44, 55, 66, 67]
console.log(res);      //[1, 2, 6, 12, 33, 44, 55, 66, 67]

7、把数组反转过来  ——  reverse

      语法：数组.reverse  ；直接改变原始数组  ；返回值：就是改变后的数组

var arr = [1,2,3,4]
var res = arr.reverse()
console.log(arr);       //[4,3,2,1]   直接改变原始数组
console.log(res);       //[4,3,2,1]   返回改变后的数组

8、多个数组拼接  ——  concat

      语法：数组.concat(需要的拼接)  ；不直接改变原始数组  ；返回值：拼接好的数组；

var arr = [1,2,3,4]
var arr1 = [a,b,c,d]
var arr2 = ['say','hi']

var res = arr.concat(arr1,arr2,1234,true)
console.log(arr);     //[1,2,3,4]
console.log(arr1);    //[a,b,c,d]
console.log(arr2);    //['say','hi']
console.rlog(res);    //[1,2,3,4,a,b,c,d,'say','hi',1234,true]  
                      //所有的数组以逗号的形式拼接，可拼接数组，也可拼接单个数据

9、把数组元素转为字符串，并按照指定的东西连接  ——  join

      语法：数组.join  ；可以传参也可不传参，不传参则用逗号连接，传参就用传参的东西连接；

       不直接改变原始数组；   返回值：使用指定东西连接好的字符串

var arr = [1,2,3,4]
var res = arr.join()
console.log(arr);      //[1,2,3,4]   原始值不直接改变
console.log(res);      //1,2,3,4     不传参则用逗号连接

var res = arr.join('-')
console.log(arr);      //[1,2,3,4]   原始值不直接改变
console.log(res);      //1-2-3-4     传参则用传参的东西连接

10、查找数组中是否有对应的元素，有则返回对应元素的索引；无则返回-1；  —— indexOf

       语法：数组.indexOf (要查找的数组元素)  ；不直接返回原始数组  ；

        返回值：若数组有，则返回对应的索引；无则返回-1；

var arr = [1,2,3,4]

//语法1：数组.indexOf(要查找的数组元素)
var res = arr.indexOf('4')
console.log(arr);            //不直接改变原始数组
console.log(res);            //3  若有该元素，则返回对应的索引(下标)

var res = arr.indexOf('8')
console.log(res);              //-1  数组内无该元素则返回-1


var arr = [1,2,3,4,1,3]
//语法2：数组.indexOf(要查找的数组元素，从指定索引开始查找)
var res = arr.indexOf('1',2)
console.log(res);            //4 若有该元素，则返回对应元素的索引(下标)

二维数组

【数组中存储数组】

var arr = [
    [1,2,3,4],
    [5,6,7,8]
]
console.log(arr);    //Array(2)
console.log(arr[0][0])    // 1 第0项数组的第0项数据
console.log(arr[1][3])    // 8 第1项数组的第3项数据


//二维数组的遍历就是两层循环
for(var i = 0;i<arr.length;i++){
    for(var j = 0;j<arr[i];j++){
        console.log(arr[i][j])
    }
}

for和for in循环

通过for循环来循环数组的行为叫做遍历；

var arr = [1,2,3,4,5]
    for(var i = 0;i<arr.length;i++){
        console.log(arr[i])              //1,2,3,4,5
}

因为对象没有索引，所以需要用for in循环来遍历对象

var obj = {
    name:'Jack',
    age:18
}
for (var key in obj){
    console.log(key)       //输出值  Jack 和 18
}

for in循环的遍历次数以对象中有多少成员来决定，有多少成员，就执行多少次；

key是自己定义的一个变量，就如for循环中定义的i一样；

在每次循环过程中，key就代表着对象中某一个成员的属性名(键名)；

数组的排列

冒泡排列

【数组中两个数比较大小，小的往前排，大的靠后排；数组遍历一遍后最大的数字在最后，变量第二遍后，第二大的数字在倒数第二的位置】

for(var j = 0;j<arr.length-1;j++){
    for(var i = 0;i<arr.length-1-j;i++){
        if(arr[i]>arr[i+1]){
            var tmp = arr[i]
            arr[i] = arr[i+1]
            arr[i+1] = tmp
        }
    }
}
console.log(arr)

选择排列

【假设索引为0是最小的数字，然后遍历数字，若有比假设小的数字，则取代该位置，第一次遍历后，最小的数排在了第一位；遍历第二遍时，假设索引为1的数字是最小的数字，继续循环上述操作】

for(var j = 0;j<arr.length;j++){
    var minIndex = j
    for(var i = 0;i<arr.length;i++){
        minIndex = i
    }
}
if(j !== minIndex){
    var tmp = arr[j]
    arr[j] = arr[minIndex]
    arr[minIndex] = tmp
}
console.log(arr)