16、数组

数组

数组的定义

es6新增了创建数组的方法form() of()

new Array(length/content);

var arr = new Array();
var arr = new Array(1,3,3,4,6)

字面量(推荐使用)

var arr =[,,];  // undefined x 2
var arr = [1,2,,,,3,4]; // 稀松数组 不是每位都有值 arr.length是7

两种定义方式的区别

// 只传一位参数 会默认是长度为10的空数组
var arr = new Array(10); 

// 这里就是一个数组里面只有一个值10  长度是1
var arr1 = [10]; 

var arr = new Array(10.2); // 报错  长度不能有小数  不合法
var arr = [10.2]  // 默认是值为10.2且长度为1的数组

数组的读和写(es3.0)

arr[num] //不可以溢出读(结果是undefined)

数组几乎不报错 因为数组是基于对象的 没有属性就会打印undefined

arr[num] = xxx; //可以溢出写

// 如果给一个空数组的第十一位赋值 就会把数组程度撑 长
arr[10] = "abc"  ==> "abc"  
arr ==> [undefined × 10，“abc”]

数组常用的方法

改变原数组(在原来的数组的基础上改变)

push, pop, shift, unshift,sort,reverse,splice

push：给数组中的最后增加元素

注意：可以同时在数组最后添加很多位

// 模拟push方法（了解）
var arr = [1,2,3];

// 注意不能传形参 因为可以push多个  不知道形参有多少个
Array.prototype.push = function () {  
    for(var i = 0; i < arguments.length; i ++){
   		this[this.length] = arguments[i];
    }
    return this.length;
}

pop：剪切数组中的最后一位

var arr = [1,2,3];

不可以传参数，传了也是默认剪切最后一位

arr.pop()返回3是因为是剪切 所以数组中还有三位 但是再访问arr时只有[1,2]

shift：把数组的第一个元素删除

var arr = [1,2,3];

unshift：在数组的最前面加元素

reverse：逆转数组的顺序

var arr = [1,2,3];

splice：截取数组长度，并添加新数据

arr.splice(从第几位开始，截取多少的长度，在切口处添加新的数据)

var arr = [2,1,8,4,5,2,0,9]

从第二位开始切（注意数组下标是从0开始），截取四位

var arr = [2,1,8,4,5,7,0,9]
arr.splice(2,3,11,12,13,14,15,16)
访问arr:[2, 1, 11, 12, 13, 14, 15, 16, 7, 0, 9]

第三位表示从切口处替换截取的长度的数据(这里截取的数据是[8,4,5] 所以这三位被替换成插入的数据了)

如果说只是需要单纯的插入数据，不希望替换截取的长度的数据，那就设置截取长度为0就好了

var arr = [1,2,3,5]
arr.splice(3,0,4)

注意：-1位就是倒数第一位

// 为什么-1是倒数第一位
var arr = [1,2,3,5];
splice = function (pos) {
    // 所在位置=-1+数组长度=-1+4=3  注意3是第四位 下标0开始
    pos += pos > 0 ? 0 : this.length;
}

sort：给数组排序（升序）

想降序就可以在升序之后逆转数组(reverse)

注意这里会优先比较每个数组的ASCII，不是按照数字排序

// 自己定义排序规则
var arr = [1,3,5,4,10]
// 冒泡排序
// 1.必须写俩形参
// 2.看返回值
//		1)当返回值为负数时，那么前面的数放在前面
//		2）为正数，那么后面的数在前
//		3）为0，不动
arr.sort(function (a,b) {
    /*if(a > b) {
        return 1;   	
    }else {
        return -1;
    }  下面的简写 直接返回return a - b;*/
    
    /* a > b ==> a - b > 0  a < b ==> a - b < 0
    所以不管升序接返回a-b  降序直接返回b-a */
    return a - b;
});

// 第一轮(1往后依次比较)
// 第一次传入1,3 1>3 false 所以返回-1 不需要变换1,3位置
// 第二次传入1,5 1>5 false 所以返回-1 不需要变换1,5位置
// 第三次传入1,4 1>4 false 所以返回-1 不需要变换1,4位置
// 第四次传入1,10 1>10 false 所以返回-1 不需要变换1,10位置

// 第二轮(3往后依次比较)
// 第一次传入3,5 3>5 false 所以返回-1 不需要变换3,5位置
// 第二次传入3,4 3>4 false 所以返回-1 不需要变换3,4位置
// 第三次传入3,10 3>10 false 所以返回-1 不需要变换3,10位置

// 第三轮(5往后依次比较)
// 第一次传入5,4 5>4 true 所以返回1 需要变换5,4位置 [1,3,4,5,10]
// 第二次传入4,10 4>10 false 所以返回-1 不需要变换4,10位置（注意数值变换之后就是变换之后的值往后进行比较）

// 第四轮(5往后依次比较)
// 第一次传入5,10 5>10 false 所以返回-1 不需要变换5,10位置

sort选择排序验证，完美！！！

var arr = [2,10,20,13,4,18,9]
arr.sort(function (a,b) {
    // 升序
    return a - b;
});

var arr = [2,10,20,13,4,18,9]
arr.sort(function (a,b) {
    // 降序
    return b - a;
});

练习一：给一个有序的数组，乱序

var arr = [1,2,3,4,5,6,7];
// Math.random()返回的是[0,1)之间的数
// Math.random() - 0.5就是可正可负的数
arr.sort(function (a,b) {
    return Math.random() - 0.5
});

数组顺序就会被打乱

练习二：给对象按照年龄排序

var cheng = {
    name : "cheng",
    age : 18,
    sex : 'male' ,
    face : "handsome"
}
var deng = {
    name : "deng",
    age : 40,
    sex : undefined,
    face : "amazing"
}
var zhang = {
    name : "zhang",
    age : 20,
    sex : "male"
}

// 三个对象放到数组中
var arr = [cheng, deng, zhang];
arr.sort(function (a,b) {
    // 升序
    return a.age - b.age;
});

arr.sort(function (a,b) {
    // 降序
    return b.age - a.age;
});

练习三：按照字符串长度排序

var arr = ['ac','bcd','cccc','dddd','asdfkhiuqwe','asdoifqwoeiur','asdf'];
arr.sort(function (a,b) {
    // 升序
    return a.length - b.length;
});

arr.sort(function (a,b) {
    // 降序
    return b.length - a.length;
});

练习四：按照字节长度排序

function retBytes(str) {
    var num = str.length; // 字节长度就先默认等于字符串长度
    for(var i =0; i < str.length; i ++ ) {
        // ASCII大于255的字节长度加1 因为>255的是汉字 占两个字节
        if(str.charCodeAt(i) > 255){ 
        	num++;
        }
    }
    return num;
}

var arr = ['ac','bcd','cccc','dddd','asdfkhiuqwe','asdoifqwoeiur','asdf'];

arr.sort( function (a, b){
    // 升序
	return retBytes(a) - retBytes(b);
});

arr.sort( function (a, b){
    // 降序
	return retBytes(b) - retBytes(a);
});

不改变原数组

concat,join——>split,toString,slice

concat：数组拼接

var arr = [1,2,3,4,5,6];
var arr1 = [7,8,9];
arr.concat(arr1)  // 把arr1拼接在arr数组上

注意拼接不会影响原数组 拼接完再访问arr和arr1又是原来的样子

toString：把数组变成字符串展示出来

slice：截取区间

slice(从该位(包含)开始截取，截取到该位的前一位)

从第一位(2)开始截取，截取到第三位(4)的前一位

只写一个参数代表从第几位开始截取到数组最后一位

不写参数就是整个数组都截下来，截取负数位就同前面一样 取负数加数组长度的值对应的位数

join：把数组中的每一位连接起来（参数只能传字符串）

var arr = [1,2,3,4,5,6];
arr.join("-");

join应用

// 把下面的字符串拼接在一起  不需要连接符
var str = "alibaba";
var str1 = 'baidu';
var str2 = 'tencent';
var str3 = 'toutiao';
var str4 = 'wangyi';
var str5 = 'xiaowang';
var str6 = 'nv';

// 字符串放在栈中  后进先出  连接效率低
// 散列  (把字符串放到数组中 再通过数组进行连接)
var arr = [str,str1,str2,str3,str4,str5,str6];
arr.join("");  //传引号才是没有连接符，不传默认是逗号

字符串方法split：按照什么把字符串拆分成数组

注意：字符串拆分成数组之后，数组中的值还是字符串类型

var str = arr.join('-');
str.split("-")；