1. 数组可以用来存储一组相同类型的值
    1. 数组的存储会在内存中开辟一片连续的内存空间
    2. 可以通过索引直接获取数组中的元素，时间复杂度为O(1)
  2. 数组利查询，不利添加和删除操作，在数组中间插入和删除时，会导致大部分的数据存储位置发生移动

访问和迭代数组

  1. 可以通过下标的方式直接访问数组中的元素
  2. 迭代数组的方式
    1. for循环
    2. forEach
    3. map
    4. 等等

求斐波那契数列的第N项和前N项和

  1. 斐波那契数列规律
    1. 第N项为前两项和
    2. 第一项为1
    3. 第二项为1
      1. function fib(n) {
      2. let a = 1;
      3. let b = 1;
      4. let c = 0;
      5. let sum = 2;
      6. for (let i = 3; i <= n; i++) {
      7. c = a + b;
      8. a = b;
      9. b = c;
      10. sum += c;
      11. }
      12. return [c, sum];
      13. }
      14. console.log(fib(4));

      添加元素

      1. 添加元素时，添加位置往后的元素会向后移动
        1. 在末尾添加元素，只需要将 nums[nums.length] = n 即可
        2. 在开头添加元素，需要将所有的元素向后移动一位
        3. 在中间插入元素，则需要该位置往后的元素向后移动一位

在末尾添加元素 - push

  1. push方法可以添加多个参数
  1.    // 1.原生的push方法
  2.       let arr = [1, 2, 3, 4, 5];
  3.       arr.push(6);
  4.       console.log(arr);
  5.       function _push(n, nums) {
  6.         nums[nums.length] = n;
  7.       }
  8.       _push(7, arr);
  9.       console.log(arr);

在开头添加元素 - unshift

  1. 可以添加多个参数
  1.       // 1.原生unshift方法
  2.       let arr = [1, 2, 3];
  3.       arr.unshift(0);
  4.       console.log(arr);
  6.       // 1.所有元素往后移动一位
  7.       // 2.将添加的元素放在索引为0的位置
  8.       function _unshift(nums, n) {
  9.         for (let i = nums.length; i > 0; i--) {
  10.           nums[i] = nums[i - 1];
  11.         }
  12.         nums[0] = n;
  13.         return nums;
  14.       }
  15.       console.log(_unshift(arr, -1));

在中间插入元素

  1. 该位置往后的元素向后移动一位
  1. // 1.该位置往后的元素向后移动一位
  2.       // 2.将添加的元素放在该位置
  3.       function _insert(nums, n, index) {
  4.         // 比较数组的长度和插入位置
  5.         if (nums.length - 1 > index) {
  6.           for (let i = nums.length; i > index; i--) {
  7.             nums[i] = nums[i - 1];
  8.           }
  9.           nums[index] = n;
  10.           return nums;
  11.         }
  12.         nums[index] = n;
  13.         return nums;
  14.       }
  15.       let arr = [1, 2, 3];
  16.       console.log(_insert(arr, 4, 1));

删除元素

  1. 删除元素
    1. 在末尾删除元素，将末尾值设置为undefined
    2. 在开头删除元素，将每个元素都向前移动一位
    3. 在中间删除元素，将该位置之后的每个元素都向前移动一位

末尾删除元素 - pop

  1.  // 原生pop方法
  2.       let arr = [1, 2, 3, 4, 5, 6, 7];
  3.       arr.pop();
  4.       console.log(arr);
  5.       //   1.创建一个新的空数组
  6.       // 2.通过push方法+遍历的手段将除了最后一项的元素添加到新数组
  7.       function _pop(nums) {
  8.         let newNums = [];
  9.         for (let i = 0; i < nums.length - 1; i++) {
  10.           newNums.push(nums[i]);
  11.         }
  12.         return newNums;
  13.       }
  14.       console.log(_pop(arr));

开头删除元素 - shift

  1. 所有元素向后移动一位
  2. 添加元素放在开头
  1.  // 原生shift
  2.       let arr = [1, 2, 3, 4, 5, 6];
  3.       arr.shift();
  4.       console.log(arr);
  6.       // 1.创建一个新的数组
  7.       //   2.将除了第一位的元素遍历添加到新数组
  8.       function _shift(nums) {
  9.         let newNums = [];
  10.         for (let i = 1; i < nums.length; i++) {
  11.           newNums.push(nums[i]);
  12.         }
  13.         return newNums;
  14.       }
  15.       console.log(_shift(arr));

遍历多维数组

本质上就是遍历一维数组，需要用到for循环的嵌套

  1. 不要将内部的数组看成数组，先简单看成数值，优先遍历外层数组，再一层一层的遍历即可
  1.  let arr = [  // 先将数组看成[a,b,c]，等遍历完完成数组后再将a,b,c看成数组对其进行遍历
  2.         [1, 2, 3, 4],
  3.         [5, 6, 7, 8],
  4.         [9, 10, 11, 12, 13],
  5.       ];
  6.       function traverse(arr) {
  7.         for (let i = 0; i < arr.length; i++) {
  8.           for (let j = 0; j < arr[i].length; j++) {
  9.             console.log(arr[i][j]);
  10.           }
  11.         }
  12.       }
  13.       console.log(traverse(arr));