1. 数组基础

1.1声明数组的三种方式

  1. var arr1 = [];//数组字面量
  2. var arr2 = new Array();//通过系统内置的Array构造函数声明数组，不推荐使用
  4. var arr3 = Array();//第三种(不使用的)，打印出来也是数组

这三种方式构造出来的数组的原型都是Array,所有数组都继承于Array.prototype。

声明对象的三种方式

  1. var obj1 = {};//对象字面量
  2. var obj2 = new Object();通过系统内置的Object构造函数声明数组
  3. var obj3 = Object();//第三种(不使用的)

例如

  1. var arr4 = [1, 2, 3, 4, 5];
  2. var obj4 = {
  3.   0: 1,
  4.   1: 2,
  5.   2: 3,
  6.   3: 4,
  7.   4: 5
  8. }
  9. //对象的键名是数组的下标，键值是数组的元素
  1.  var obj5 = {
  2.    name: 'a'
  3.  }

此对象的访问是obj5.name,机制其实就是js底层做了处理obj5[‘name’]，在javascript当中，数组就是对象另外一种形式，只是写法不同，但是访问机制是一样的。

1.2例

  1. var arr5 = [,,];
  2. console.log(arr5);//(2) [empty × 2]
  3. console.log(arr5.length);//2
  5. var arr6 = [ , 1, 3, 5, 7, ];
  6. console.log(arr6);
  7. //(5) [empty, 1, 3, 5, 7]，最后一个值打印不出来，其实是数组最后一个值打逗号，但还是不算的，系统内置有截取的机制，就相当于var arr6 = [ , 1, 3, 5, 7];
  8. console.log(arr6.length);//5
  10. var arr7 = [ , 1, 3,,,5, 7];//这种数组叫稀松数组
  12. var arr8 = new Array[ ,1, 2, 3, 4, ];//报错，语法错误，用系统内置的构造函数中间不能有空值
  14. var arr9 = new Array(5);
  15. //[empty × 5],如果只填一个number值，那就是这个数组的长度，相当于[,,,,,],这并不是空数组，数组的有元素的，只是每个元素都是空
  17. var arr10 = new Array(5.2);//Invalid array length报错，非法的数组长度
  18. var arr11 = new Array(a);//报错，a is not defined
  19. var arr12 = new Array('a');//['a']
  1. var arr13 = [1, 2, 3, 4];
  2. console.log(arr13[4]);//undefined
  3. //为什么返回undefined，举例
  4. var obj6 = {
  5.   0: 1,
  6.   1: 2,
  7.   2: 3,
  8.   3: 4
  9. }
  10. console.log(obj6[4]);//undefined，因为找不到第五位

2. 数组方法

2.1 push unshift

  1. 数组的这些方法都是继承了Array这个构造函数上的属性prototype而来的.
  2. push是在数组的最后一位添加元素，unshift是在数组的第一位前面添加元素，都可以加多个值。返回值都是是执行了方法以后数组新的长度

    模拟push方法:

    1. Array.prototype.myPush = function(){
    2. for(var i = 0; i < arguments.length; i++){
    3.  this[this.length] = arguments[i];
    4. }
    5. return this.length;//返回值是数组长度
    6. }

    2.2 pop shift

    pop每次会把数组最后一位剪切掉，返回值是剪切的值，该方法没有参数。
    shift每次会把数组第一位剪切掉，返回值是剪切的值,该方法没有参数。
    1. var arr15 = ['a', 'b', 'c'];
    2. var str = arr15.shift();
    3. console.log(str);//'a',可以用变量去接返回值

    2.3 reverse

    把数组倒序
    1. var arr16 = ['a', 'b', 'c'];
    2. arr16.reverse();
    3. console.log(arr16)//'c', 'b', 'a'

    2.4 splice

    arr.splice(开始项的下标(也可以填负值，从最后一位开始算，从-1开始)，
    剪切长度，
    剪切以后最后一位开始添加数据) ```javascript var arr17 = [‘a’, ‘b’, ‘c’]; arr17.splice(1, 1, 1, 2 ,3); console.log(arr17);//[‘a’, 1, 2, 3, ‘c’]

var arr18 = [‘a’, ‘b’, ‘c’, ‘e’]; //arr18.splice(3, 0, ‘d’);//[‘a’, ‘b’, ‘c’, ‘d’, ‘e’]第二个参数写0，直接添加 arr18.splice(-1, 0, ‘d’);//效果同上

  1. splice这个方法怎么实现的？关于负值位置的判断是如何计算的？模拟splice方法的函数
  2. ```javascript
  3. function splice(arr, index){
  4.   return index += index >= 0 ? 0 : arr.length; 
  5. }

2.5 sort

  1. var arr19 = [-1, -5, 8, 0, 2];
  2. arr19.sort();
  3. console.log(arr19);//[-1, -5, 0, 2, 8]打印结果按照升序来排
  5. var arr20 = ['b', 'z', 'h', 'i', 'a'];
  6. arr20.sort();
  7. console.log(arr20);//['a', 'b', 'h', 'i', 'z']打印结果也是按升序排
  1. var arr21 = [27, 49, 5, 7];
  2. //          27 49
  3. //          5  27
  4. //          7  27
  5. //          5  49
  6. //          7  49
  7. //          5  7  冒泡排序法，把每一位和前后一位进行比对
  8. arr21.sort();
  9. console.log(arr21);//[27, 49, 5, 7]，ascii码来排，只比对了第一位

sort函数返回的值是排序以后的数组，排序是按照ascii码来排的
1.必须有两个参数，例a，b
2.必须设定返回值： 1负值，a就排前面
2.正值，b就排前面
3. 0 保持不动 

  1. arr21.sort(function(a, b){
  2.   if(a > b){
  3.     return 1;
  4.   }else{
  5.     return -1;
  6.   }
  7.   //最终简化写成 return a - b，如果是降序就写成b - a
  8. });
  9. console.log(arr21);//[5, 7, 27, 49]

例，sort方法随机排序
Math.random(),随机数，返回0 ~ 1，开区间不包含0和1

  1. var arr22 = [1, 2, 3, 4, 5, 6];
  2. arr22.sort(function(a, b){
  3.   var rand = Math.random();
  4.   if(rand - 0.5 > 0){
  5.     return 1;
  6.   }else{
  7.     return -1;
  8.   }  
  9.   //return  Math.random() - 0.5;或者把条件语句直接写成这句
  10. });
  11. console.log(arr22);

例，按照数组内的参数进行年龄大小的升序来排序

  1.  var arr23 = [
  2.    {
  3.      son: 'Jenny',
  4.      age: 18
  5.    },
  6.    {
  7.      son: 'Jone',
  8.      age: 10
  9.    },
  10.    {
  11.      son: 'Ben',
  12.      age: 16
  13.    },
  14.    {
  15.      son: '  Crytal',
  16.      age: 3
  17.    },
  18.    {
  19.      son: 'Lucy',
  20.      age: 11
  21.    }
  22.  ];
  23. arr23.sort(function(a, b){
  24.   if(a.age > b.age){
  25.     return 1;
  26.   }else{
  27.     return -1;
  28.   }
  29.   //return a.age - b.age;或者可以写成这样
  30. });
  31. console.log(arr23);//打印的数组是按照age数字升序来排列数组

例，对比数组长度

  1. var arr24 = ['12345', '1', '1234', '12', '1234567'];
  2. arr24.sort(function(a, b){
  3.   if(a.length > b.length){
  4.     return 1;
  5.   }else{
  6.     return -1;
  7.   }
  8.   //return a.length - b.length;或者可以写成这样
  9. });
  10. console.log(arr24);

总结

修改原数组的方法 ：push/unshift pop/shift reverse splice sort