深拷贝实例、数组基础、数组方法、数组排序（十五）

一、数组基础

1.1 数组声明方式

var arr1 = []; // 数组字面量
// 通过系统内置的Array构造函数声明数组
var arr2 = new Array(); // 不推荐
var arr3 = Array(); // 不使用

//---------------------------------------------

var arr1 = new Array(1, 3, 5, 7);
var arr2 = new Array(5); // 当传入一个参数且是整数时，创建一个长度为n的数组
console.log(arr1);
console.log(arr1.__proto__);
console.log(arr2.__proto__);
console.log(arr3.__proto__);
// 所有数组都继承于Array.prototype

//--------------------------------------------------

// 对象
var obj1 = {}; // 对象字面量
var obj2 = new Object();
//通过系统内置的Object构造函数声明对象
var obj3 = Object();

console.log(obj1.__proto__);
console.log(obj2.__proto__);
console.log(obj3.__proto__);
// 所有对象都继承于Object.ptototype

1.2 访问数组元素

var arr = [1, 2, 3, 4, 5];
// index数组元素的下标（索引值）从0开始
console.log(arr[2]); // 3

1.3 稀疏数组

var arr1 = [, 1, 3, , , 5, 7]; // 稀疏数组
var arr2 = [1, 3, 5,,,];			 //  如果最后一位没有值，最后一个（,）将会被忽略
console.log(arr1);
console.log(arr2);

二、数组方法

2.1 push/unshift

push()

push()方法将一个或多个元素添加到数组的末尾， 并返回该数组的新长度（该方法修改原有数组）。 语法

arr.push(element1, ..., elementN)

参数 elementN 被添加到数组末尾的元素或多个元素。 返回值 当一个对象调用该方法时，新的length属性值将被返回。

var arr = [2, 3, 4];
arr.push(5);
var len = arr.push(6, 7, 8);
console.log(arr);
console.log(len);

unshift()

unshift()方法将一个或多个元素添加到数组的开头， 并返回该数组的新长度（该方法修改原有数组）。 语法

arr.unshift(element1, ..., elementN)

参数 elementN 被添加到数组开头的元素或多个元素。 返回值 当一个对象调用该方法时，新的length属性值将被返回。

var arr = [2, 3, 4];
arr.unshift(1);
var len = arr.unshift(5, 6, 7);
console.log(arr);
console.log(len);

实现push方法

Array.prototype.myPush = function () {
  for (var i = 0; i < arguments.length; i++) {
    this[this.length] = arguments[i];
  }
  return this.length;
}
var arr = [2, 3, 4];
console.log(arr.myPush(5, 6, 7));
console.log(arr);

2.2 pop/shift

pop()

pop()方法从数组中删除最后一个元素， 并返回该元素的值（此方法更改数组的长度）。 语法

arr.pop()

返回值 从数组中删除的元素（当数组为空时返回undefined）

var arr = ['a', 'b', 'c'];
var str = arr.pop();
console.log(str);
console.log(arr);

shift()

shift()方法从数组中删除第一个元素， 并返回该元素的值（此方法更改数组的长度）。 语法

arr.shift()

返回值 从数组中删除的元素（当数组为空时返回undefined）

var arr = ['a', 'b', 'c'];
var str = arr.shift();
console.log(str);
console.log(arr);

2.3 reverse

reverse()方法将数组中的位置颠倒。 该方法会改变原数组。 语法

arr.reverse()

返回值 颠倒后的数组。

var arr = ['a', 'b', 'c', 'd', 'e'];
var res = arr.reverse();
console.log(arr);
console.log(res);

2.4 splice

splice()方法通过删除或替换现有元素或者原地添加新的元素来修改数组，并以数组形式返回被修改的内容。 此方法会改变原数组。 语法

arr.splice(start, deleteCount, item1, item2, ...)

参数 start 指定修改的开始位置（从0计数）。 如果超出了数组的长度，则从数组末尾开始添加内容。 如果是负值，则表示从数组末位开始的第几位（arr.length-n）。 如果负数的绝对值大于数组的长度，则表示开始位置为第0位。 deleteCount （可选） 整数，表示要移除的数组元素的个数。 如果deleteCount大于等于start之后的元素的总数，或者deleteCount被省略了则从start后面的元素都将被删除（含第start位）。 如果deleteCount是0或者负数，则不移除元素。 item1, item2, ... （可选） 要添加进数组的元素，从start位置开始。 如果不指定，则splice()方法将只删除数组元素。 返回值 由被删除的元素组成的一个数组。 如果只删除了一个元素，则返回只包含一个元素的数组。 如果没有删除元素，则返回空数组。

var arr = ['a', 'b', 'c'];
// 从数组第1位开始，删除2个元素（包含第1位）
var res1 = arr.splice(1, 2);
console.log(arr);
console.log(res1);

// 把元素插入到arr[0]之前
var res2 = arr.splice(0, 0, 'b', 'c', 'd', 'e');
console.log(arr);
console.log(res2);

简单实现splice方法返回start参数在数组中的索引

var arr = ['a', 'b', 'c', 'e'];
// 
function splice(arr, index) {
  // index为正数时，直接返回
  // index为负数时，加上arr.length返回
  return index += ((index >= 0) ? 0 : arr.length);
}

console.log(arr[splice(arr, -1)]);

完整版

function splice(arr, index) {
  var len = arr.length;
  if (index >= 0 && index < len) {
    return index;
  } else if (index >= len) {
    return len; 
  } else if (Math.abs(index) > len) {
    return 0;
  } else {
    return index + len;
  }
}

三、数组排序

sort() sort()方法对数组的元素进行排序，并返回数组。 默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16编码（升序排列）。 语法

arr.sort(compareFunction)

参数 compareFunction(a, b)（可选） 用来指定按某种顺序进行排列的函数。 如果省略，按各个字符的Unicode进行升序排列。 参数 firstEl（a） 第一个用于比较的元素。 SecondEl（b） 第二个用于比较的元素。 返回值 如果返回值小于0，那么a会被排列到b之前。 如果返回值等于0，a和b的相对位置不变。 如果返回值大于0，b会被排列到a之前。

返回值 排序后的数组。

3.1 默认排序

var arr1 = [-1, -5, 8, 0, 2];
var arr2 = ['b', 'z', 'h', 'i', 'a']; 
arr1.sort();
arr2.sort();
console.log(arr1);
console.log(arr2);

3.2 使用比较函数

var arr = [27, 49, 5, 7];
/* arr.sort(function (a, b) {
  if (a > b) {
    return 1;
  } else {
    return -1
  }
}); */

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

console.log(arr);

3.3 随机排序

var arr = [1, 2, 3, 4, 5, 6];

// Math.random() -> (0, 1)
arr.sort(function (a, b) {
  // var rand = Math.random();
  // if (rand - 0.5 > 0) {
  //   return 1
  // } else {
  //   return -1
  // }
  return Math.random() - 0.5;
});

console.log(arr);

3.4 按照要求排序

3.4.1 按照年龄排序

var arr = [
  {
    son: 'Jenny',
    age: 18
  },
  {
    son: 'Jone',
    age: 10
  },
  {
    son: 'Ben',
    age: 16
  },
  {
    son: 'Crytal',
    age: 3
  },
  {
    son: 'Lucy',
    age: 11
  }
];

arr.sort(function (a, b) {
  if (a.age > b.age) {
    return 1;
  } else {
    return -1
  }
});

console.log(arr);

3.4.2 按照字符串长度排序

var arr = ['12345', '1', '1234', '12', '1234567'];

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

console.log(arr);

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