大前端学习笔记之JS Day08

常见问题 2022-08-26

数组

数据类型分类

  • number / string / boolean / undefined / null / object / function / array / …
  • 数组也是数据类型中的一种
  • 我们简单的把所有数据类型分为两个大类 基本数据类型 和 复杂数据类型
  • 基本数据类型： number / string / boolean / undefined / null
  • 复杂数据类型： object / function / array / …

创建一个数组

  • 数组就是一个 []
  • 在 [] 里面存储着各种各样的数据，按照顺序依次排好

字面量创建一个数组

  • 直接使用 [] 的方式创建一个数组

    // 创建一个空数组
var arr1 = []

// 创建一个有内容的数组
var arr2 = [1, 2, 3]

内置构造函数创建数组

  • 使用 js 的内置构造函数 Array 创建一个数组

    // 创建一个空数组
var arr1 = new Array()

// 创建一个长度为 10 的数组
var arr2 = new Array(10)

// 创建一个有内容的数组
var arr3 = new Array(1, 2, 3)

数组的索引

  • 索引，也叫做下标，是指一个数据在数组里面排在第几个的位置

  • 注意： 在所有的语言里面，索引都是从 0 开始的

  • 在 js 里面也一样，数组的索引从 0 开始

    // 创建一个数组
var arr = ['hello', 'world']

  • 上面这个数组中，第 0 个 数据就是字符串 hello，第 1 个 数据就是字符串 world

  • 想获取数组中的第几个就使用 数组[索引] 来获取

    var arr = ['hello', 'world']

console.log(arr[0]) // hello
console.log(arr[1]) // world

数组的常用方法

数组常用方法之 push

  • push 是用来在数组的末尾追加一个元素

    var arr = [1, 2, 3]

// 使用 push 方法追加一个元素在末尾
arr.push(4)

console.log(arr) // [1, 2, 3, 4]

数组常用方法之 pop

  • pop 是用来删除数组末尾的一个元素

    var arr = [1, 2, 3]

// 使用 pop 方法删除末尾的一个元素
arr.pop()

console.log(arr) // [1, 2]

数组常用方法之 unshift

  • unshift 是在数组的最前面添加一个元素

    var arr = [1, 2, 3]

// 使用 unshift 方法想数组的最前面添加一个元素
arr.unshift(4)

console.log(arr) // [4, 1, 2, 3]

数组常用方法之 shift

  • shift 是删除数组最前面的一个元素

    var arr = [1, 2, 3]

// 使用 shift 方法删除数组最前面的一个元素
arr.shift()

console.log(arr) // [2, 3]

数组常用方法之 splice

  • splice 是截取数组中的某些内容，按照数组的索引来截取

  • 语法： splice(从哪一个索引位置开始，截取多少个，替换的新元素) （第三个参数可以不写）

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

// 使用 splice 方法截取数组
arr.splice(1, 2)

console.log(arr) // [1, 4, 5]
    • arr.splice(1, 2) 表示从索引 1 开始截取 2 个内容
    • 第三个参数没有写，就是没有新内容替换掉截取位置
    var arr = [1, 2, 3, 4, 5]

// 使用 splice 方法截取数组
arr.splice(1, 2, '我是新内容')

console.log(arr) // [1, '我是新内容', 4, 5]
    • arr.splice(1, 2, '我是新内容') 表示从索引 1 开始截取 2 个内容
    • 然后用第三个参数把截取完空出来的位置填充

数组常用方法之 reverse

  • reverse 是用来反转数组使用的

    var arr = [1, 2, 3]

// 使用 reverse 方法来反转数组
arr.reverse()

console.log(arr) // [3, 2, 1]

数组常用方法之 sort

  • sort 是用来给数组排序的

    var arr = [2, 3, 1]

// 使用 sort 方法给数组排序
arr.sort()

console.log(arr) // [1, 2, 3]

数组常用方法之 concat

  • concat 是把多个数组进行拼接

  • 和之前的方法有一些不一样的地方，就是 concat 不会改变原始数组，而是返回一个新的数组

    var arr = [1, 2, 3]

// 使用 concat 方法拼接数组
var newArr = arr.concat([4, 5, 6])

console.log(arr) // [1, 2, 3]
console.log(newArr) // [1, 2, 3, 4, 5, 6]
    • 注意： concat 方法不会改变原始数组

数组常用方法之 join

  • join 是把数组里面的每一项内容链接起来，变成一个字符串

  • 可以自己定义每一项之间链接的内容 join(要以什么内容链接)

  • 不会改变原始数组，而是把链接好的字符串返回

    var arr = [1, 2, 3]

// 使用 join 链接数组
var str = arr.join('-')

console.log(arr) // [1, 2, 3]
console.log(str) // 1-2-3
    • 注意： join 方法不会改变原始数组，而是返回链接好的字符串

数组常用方法之 slice

  • 语法: 数组.slice(开始索引, 结束索引) [开始的索引,结束的索引)
    • 参数特点:
      => 包前不包后, 包含开始索引位置数据, 不包含结束索引位置数据
      => 开始所以不填, 默认是 0, 结束索引不填, 默认是 length
      => 可以填写负整数, 表示倒数第几个, 其实就是 length + 负整数
    • 作用: 截取数据的部分内容
    • 返回值: 必然是一个新数组
      => 内部就是截取出来的部分内容
    • 和 splcie 的区别
      => 改变原始数组
      -> splice 改变原始数组
      -> slice 不改变原始数组
      => 参数
      -> splice(开始索引, 多少个)
      -> slice(开始索引, 结束索引)
      slice() //索引支持负数 返回的是一个新数组

var arr1 =  ['李白','安琪拉','猪八戒','韩信','李信','小乔','武则天']
    var res = arr1.slice(2,3);
    var res = arr1.slice(-6,-4); //截取的时候一定是从左往右截取 -6,-4
    var res = arr1.slice(-1); // 截取数组的最后一个元素
    var res = arr1.slice(-1,0); //默认是从左往右 -1 到0 是从右往左所以结果是空 

    var res = arr1.slice(0,arr1.length);
    var res1 = arr1.slice(0);// 有头无尾 不写尾代表你全要

数组常用方法之 indexOf()

  • 语法：

​ => 数组.lastIndexOf(数据)

​ => 数组.lastIndexOf(数据, 开始索引)

  • 作用: 从前往后检索该数据第一次在该数组内出现的位置

​ + 返回值:

  • => 如果在数组内找到了该数据, 那么就是该数据第一次出现的索引位置

​ => 如果在数据内没有找到该数据, 那么就是 -1

 var arr1 =  ['李白','安琪拉','猪八戒','李白','杜甫','韩信','李信','小乔','武则天']
    元素的下标永不变 不管从哪里找 找到他 就是他不变的下标
    var res = arr1.indexOf('杜甫',5) // 从左往右找 第一次出现的位置  1 如果找不到 返回-1
    // 如果指定了第二个参数 表示从下标五开始往右查找 找不到 -1 
    var res1 = arr1.lastIndexOf('杜甫',5) // 从右往左找 第一次出现的位置 3 如果找不到 返回-1
    // 如果指定了第二个参数 表示从下标五开始往左查找 返回 找到返回元素所在数组的下标 找不到 -1     
    alert(res) 
    alert(res1)

    var balls = [3,19,34,22]
    var num1 = 6
    if(balls.indexOf(num1)== -1){
        balls.push(num1)
    }

数组常用方法之 indexOf()

  • 语法:

​ => 数组.lastIndexOf(数据)

​ => 数组.lastIndexOf(数据, 开始索引)

  • 作用: 从后向前检索该数据第一次在该数组内出现的位置

  • 返回值:

​ => 如果在数组内找到了该数据, 那么就是该数据第一次出现的索引位置

​ => 如果在数据内没有找到该数据, 那么就是 -1

冒泡排序

  • 先遍历数组，让挨着的两个进行比较，如果前一个比后一个大，那么就把两个换个位置

  • 数组遍历一遍以后，那么最后一个数字就是最大的那个了

  • 然后进行第二遍的遍历，还是按照之前的规则，第二大的数字就会跑到倒数第二的位置

  • 以此类推，最后就会按照顺序把数组排好了

    1. 我们先来准备一个乱序的数组

      var arr = [3, 1, 5, 6, 4, 9, 7, 2, 8]
      • 接下来我们就会用代码让数组排序

    2. 先不着急循环，先来看数组里面内容换个位置

      // 假定我现在要让数组中的第 0 项和第 1 项换个位置
// 需要借助第三个变量
var tmp = arr[0]
arr[0] = arr[1]
arr[1] = tmp

    3. 第一次遍历数组，把最大的放到最后面去

      for (var i = 0; i < arr.length; i++) {
  // 判断，如果数组中的当前一个比后一个大，那么两个交换一下位置
  if (arr[i] > arr[i + 1]) {
    var tmp = arr[i]
    arr[i] = arr[i + 1]
    arr[i + 1] = tmp
  }
}

// 遍历完毕以后，数组就会变成 [3, 1, 5, 6, 4, 7, 2, 8, 9]
      • 第一次结束以后，数组中的最后一个，就会是最大的那个数字
      • 然后我们把上面的这段代码执行多次。数组有多少项就执行多少次

    4. 按照数组的长度来遍历多少次

      for (var j = 0; j < arr.length; j++) {
  for (var i = 0; i < arr.length; i++) {
    // 判断，如果数组中的当前一个比后一个大，那么两个交换一下位置
    if (arr[i] > arr[i + 1]) {
      var tmp = arr[i]
      arr[i] = arr[i + 1]
      arr[i + 1] = tmp
    }
  }
}

// 结束以后，数组就排序好了

选择排序

    1. 先假定数组中的第 0 个就是最小的数字的索引

    2. 然后遍历数组，只要有一个数字比我小，那么就替换之前记录的索引

    3. 知道数组遍历结束后，就能找到最小的那个索引，然后让最小的索引换到第 0 个的位置

    4. 再来第二趟遍历，假定第 1 个是最小的数字的索引

    5. 在遍历一次数组，找到比我小的那个数字的索引

    6. 遍历结束后换个位置

    7. 依次类推，也可以把数组排序好

      1. 准备一个数组

        var arr = [3, 1, 5, 6, 4, 9, 7, 2, 8]

      2. 假定数组中的第 0 个是最小数字的索引

        var minIndex = 0

      3. 遍历数组，判断，只要数字比我小，那么就替换掉原先记录的索引

        var minIndex = 0
for (var i = 0; i < arr.length; i++) {
  if (arr[i] < arr[minIndex]) {
    minIndex = i
  }
}

// 遍历结束后找到最小的索引
// 让第 minIndex 个和第 0 个交换
var tmp = arr[minIndex]
arr[minIndex] = arr[0]
arr[0] = tmp

      4. 按照数组的长度重复执行上面的代码

        for (var j = 0; j < arr.length; j++) {
  // 因为第一遍的时候假定第 0 个，第二遍的时候假定第 1 个
  // 所以我们要假定第 j 个就行
  var minIndex = j

  // 因为之前已经把最小的放在最前面了，后面的循环就不需要判断前面的了
  // 直接从 j + 1 开始
  for (var i = j + 1; i < arr.length; i++) {
    if (arr[i] < arr[minIndex]) {
      minIndex = i
    }
  }

  // 遍历结束后找到最小的索引
  // 第一堂的时候是和第 0 个交换，第二趟的时候是和第 1 个交换
  // 我们直接和第 j 个交换就行
  var tmp = arr[minIndex]
  arr[minIndex] = arr[j]
  arr[j] = tmp
}
javascript前端前端前端前端学习学习学习

相关文章

使用Nvdia显卡驱动自带的录屏功能录制游戏
显卡天梯图2024最新版 显卡性能天梯图2024最新排行榜
显卡天梯图2024最新版，显卡是电脑进行图形处理的重要设备，...
初始化电脑时出现问题怎么办 初始化电脑时出现问题解决方法
初始化电脑时出现问题怎么办，可以使用win系统的安装介质，连...
todesk远程开机怎么设置 todesk远程开机教程
todesk远程开机怎么设置，两台电脑要在同一局域网内，然后需...
油猴谷歌插件怎么安装 油猴谷歌插件安装教程
油猴谷歌插件怎么安装，可以通过谷歌应用商店进行安装，需要...
16g虚拟内存设置多少合适 16g虚拟内存最佳设置方法
虚拟内存这个名词想必很多人都听说过，我们在使用电脑的时候...