Javascript基本知识梳理（三）-对象、数组、字符串

• 对象
  1. 对象的创建方式
     1. 字面量创建

        var o = { }

     2. 内置构造函数创建：

        var o = new Object ()

  2. 对象的操作方法：增删改查

         // 0. 创建一个对象
         var o = {}
     
         console.table( o)
     
         // 1. 点语法操作对象
         // 1-1. 添加一个成员
         // 向对象里面添加了一个叫做 name 的成员, 值是 'Jack'
         o.name = 'Jack'
         o.age = 18
     
         console.table( o)
     
         // 1-2. 删除一个成员
         // 删除对象中的 name 成员
         delete o.name
     
         console.table( o)
     
         // 1-3. 修改一个成员
         // 把 o 对象内的 age 成员修改成 20
         o.age = 20
     
         // 1-4. 访问对象内的某一个成员
         // 我要拿到 o 对象内的 age 成员存储的值, 打印出来
         console.log(o.age)

  3. 循环便利对象： for in

         var obj = {
           name: 'jack',
           age: 18,
           gender: '男',
           score: 100
         }
     
         // for in 遍历对象
         for (var key in obj) {
           console.log('我执行了')
           console.log(key)
           // 当 key === 'name' 的时候, 就是 obj['name']
           // 当 key === 'age' 的时候, 就是 obj['age']
           console.log(obj[key])
         }

      

 

 

• 数组
1. 数组的创建方式：
   1. 字面量创建：

      var arr = [ ]

   2. 内置构造函数创建：

      var arr = new Array()

2. 冒泡排序

       for (var i = 0; i < arr.length - 1; i++) {
         for (var j = 0; j < arr.length - 1 - i; j++) {
           if (arr[j] > arr[j + 1]) {
             var tmp = arr[j]
             arr[j] = arr[j + 1]
             arr[j + 1] = tmp
           }
         }
       }

3. 计数排序

       var arr = [100, 87, 66, 92, 35, 35, 24, 11, 2, 3, 87, 91]
   
       // 1. 把原始数组的数字当作索引放到新数组里面
       var tmpArr = []
       for (var i = 0; i < arr.length; i++) {
         if (tmpArr[arr[i]] !== undefined) {
           tmpArr[arr[i]]++
         } else {
           tmpArr[arr[i]] = 1
         }
       }
   
       // 2. 把 tmpArr 里面的索引还原到 arr 里面
       arr.length = 0
       for (var i = 0; i < tmpArr.length; i++) {
         if (tmpArr[i] === undefined) continue
         for (var j = 1; j <= tmpArr[i]; j++) {
           arr[arr.length] = i
         }
       }
   
       console.log(arr)

4. 选择排序

       var arr = [9, 2, 6, 4, 3, 8, 5, 7, 1]
       
       for (var j = 0; j < arr.length - 1; j++) {
         var minIndex = j
         for (var i = j + 1; i < arr.length; i++) {
           if (arr[i] < arr[minIndex]) {
             minIndex = i
           }
         }
         var tmp = arr[j]
         arr[j] = arr[minIndex]
         arr[minIndex] = tmp
       }
   
       console.log(arr)
   

    

5. 数组的常用方法：push、pop、unshift、shift、reverse、sort、splice、concat、slice、join、indexOf、lastIndexOf、forEach、map、filter、find、every、some、

   copyWithin、fill、includes、flat、flatMap、findIndex

         1. push()
           => 语法: 数组.push(数据1, 数据2, 数据3, ...)
           => 作用: 把所有得参数按照顺序追加到数组得末尾位置
           => 返回值: 追加以后数组得长度
           => 直接操作原始数组
   
         2. pop()
           => 语法: 数组.pop()
           => 作用: 删除数组得最后一个数据
           => 返回值: 被删除得数据
           => 直接操作原始数组
   
         3. unshift()
           => 语法: 数组.unshift(数据1, 数据2, 数据3, ...)
           => 作用: 从数组得最前面插入一些数据
           => 返回值: 插入后得数组长度
           => 直接操作原始数组
   
         4. shift()
           => 语法: 数组.shift()
           => 作用: 删除数组得最前面一个数据
           => 返回值: 被删除得数据
           => 直接操作原始数组
   
         5. reverse()
           => 语法: 数组.reverse()
           => 作用: 反转数组
           => 返回值: 反转后得数组
           => 直接操作原始数组
   
         6. sort()
           => 语法:
             1. arr.sort()
               -> 按照每一个数据中得每一位数据得 ASCII 码进行排列
             2. arr.sort(function (a, b) { return a - b })
               -> 升序排列
             3. arr.sort(function (a, b) { return b - a })
               -> 降序排列
           => 作用: 数组排序
           => 返回值: 排序后得数组
           => 直接操作原始数组
   
         7. splice()
           => 语法:
             1. 数组.splice(开始索引, 多少个)
               -> 从开始索引, 截取多少个
               -> 第二个参数可以不写, 直接到末尾
             2. 数组.splice(开始索引, 多少个, 替换数据1, 替换数据2, 替换数据3, ...)
               -> 把替换数据按照顺序插入到你截取得位置
               -> 注意: **从哪个索引开始删除, 替换数据得第一个就插入哪个位置**
           => 作用: 有两个
             1. 截取数组
             2. 替换新内容
           => 返回值: 一定是一个数组
             -> 如果你截取多个数据, 数组里面有多个
             -> 如果你截取一个数据, 数组里面有一个
             -> 如果你一个都不截取, 那么是一个空数组
           => 直接操作原始数组
   
         8. concat()
           => 语法: 数组.concat(数组1, 数据2, ...)
           => 作用:
             -> 如果参数是数组, 那么把数组拆开, 里面每一项追加到原数组后面
             -> 如果参数数数据, 那么直接追加
           => 返回值: 追加好得数组
           => 不改变原始数组
   
         9. slice()
           => 语法:
             1. 数组.slice(开始索引, 结束索引) - 包前不包后
               -> 第一个参数可以不写, 表示从头
               -> 第二个参数可以不写, 表示到尾
             2. 数组.slice(开始索引, 结束索引) - 包前不包后
               -> 参数可以写一个负整数
               -> 当你书写了一个负整数以后, 表示 length + 负整数
           => 作用: 获取数组里面得某些数据
           => 返回值: 一个数组
             -> 如果你获取多个数据, 数组里面有多个
             -> 如果你获取一个数据, 那么数组里面有一个
             -> 如果你一个都不获取, 那么是个空数组
           => 不改变原始数组
   
         10. join()
           => 语法: 数组.join('连接符号')
             -> 不传递, 是按照 逗号(,) 连接
             -> 你传递什么, 按照什么连接
           => 作用: 把数组里面得每一个数据使用连接符号连接在一起
           => 返回值: 是一个连接好得内容, 是一个 String 类型
   
         11. indexOf()
           => 语法:
             1. 数组.indexOf(数据)
             2. 数组.indexOf(数据, 开始索引)
               -> 从哪个索引开始向后查找
           => 作用: 正向查看数组里面指定这个数据得索引
           => 返回值:
             -> 如果有这个数据, 是第一个满足条件得数据得索引
             -> 如果没有这个数据, 那么是 -1
   
         12. lastIndexOf()
           => 语法:
             1. 数组.lastIndexOf(数据)
             2. 数组.lastIndexOf(数据, 开始索引)
               -> 从哪一个索引开始向前查找
           => 作用: 反向查看数组里面指定这个数据得索引
           => 返回值:
             -> 如果有, 就是找到得第一个数据得索引
             -> 如果没有就是 -1
             -> 注意: 虽然是从后向前查找, 但是索引还是正常索引
   
         13. forEach()
           => 语法: 数组.forEach(function (item, index, arr) {})
             -> item: 数组得每一项
             -> index: 数组每一项得索引
             -> arr: 原始数组
           => 作用: 取代 for 循环得作用, 遍历数组
           => 没有返回值
   
         14. map()
           => 语法: 数组.map(function (item, index, arr) {})
             -> item: 数组得每一项
             -> index: 数组每一项得索引
             -> arr: 原始数组
           => 作用: 映射数组
           => 返回值: 是一个新的数组
             -> 里面是对原始数组每一个数据得操作
             -> 返回值数组, 一定和原始数组长度一样
           => 不改变原始数组
   
         15. filter()
           => 语法: 数组.filter(function (item, index, arr) {})
             -> item: 数组得每一项
             -> index: 数组每一项得索引
             -> arr: 原始数组
           => 作用: 过滤原始数组中得数据, 把满足条件得放在新数组里面
           => 返回值: 新数组, 里面是所有原始数组中满足条件得项
           => 不改变原始数组
   
         16. every()
           => 语法: 数组.every(function (item, index, arr) {})
             -> item: 数组得每一项
             -> index: 数组每一项得索引
             -> arr: 原始数组
           => 作用: 判断原始数组里面是不是每一个都满足条件
           => 返回值: 是一个布尔值
             -> 如果原始数组中每一个都满足条件, 那么返回 true
             -> 只要原始数组中有任意一个不满足条件, 那么就返回 false
   
         17. some()
           => 语法: 数组.some(function (item, index, arr) {})
             -> item: 数组得每一项
             -> index: 数组每一项得索引
             -> arr: 原始数组
           => 作用: 判断数组中是不是有某一个满足条件
           => 返回值: 一个布尔值
             -> 如果数组中有任意一个数据满足条件, 那么返回 true
             -> 如果数组中所有数据都不满足条件, 那么返回 false
   
         18. copyWithin()
           => 语法: 数组.copyWithin(目标位置, 开始索引, 结束索引)
             -> 目标位置: 当你替换内容得时候, 从哪一个索引位置开始替换
             -> 开始索引: 数组哪一个索引位置开始当作替换内容, 默认值是 0
             -> 结束索引: 数组哪一个索引位置结束当作替换内容, 默认是末尾
             -> 包前不包后
           => 作用: 使用数组里面得内容替换数组里面得内容
           => 返回值: 是一个新的数组
             -> 替换后得数组
   
         19. fill()
           => 语法: 数组.fill(要填充得数据, 开始索引, 结束索引)
             -> 要填充得数据: 你想用什么数据填充数组里面每一位
             -> 开始索引: 从哪一个索引开始填充, 默认值是 0
             -> 结束索引: 填充到哪一个索引位置, 默认值是 末尾
             -> 前提: 数组要有 length
             -> 包前不包后
           => 作用: 使用指定数据区填充数组
           => 返回值: 填充好得数组
   
         20. includes()
           => 语法: 数组.includes(数据)
           => 作用: 查看数组中是不是有某一个数据
           => 返回值: 一个布尔值
             -> 有这个数据, 就是 true
             -> 没有这个数据, 就是 false
   
         21. flat()
           => 语法: 数组.flat(数字)
             -> 数字: 表示扁平化多少层, 默认是 1
             -> 数字这个参数还可以填写 Infinity
           => 作用: 拍平数组
           => 返回值: 拍平以后得数组
   
         22. flatMap()
           => 语法: 数组.flatMap(function (item, index, arr) {})
           => 作用: 拍平数组, 但是只能拍一层
           => 返回值: 是一个新的数组
             -> 一边拍平, 一边映射
   
         23. find()
           => 语法: 数组.find(function (item) {})
           => 作用: 根据条件找到数组里面满足条件得数据
           => 返回值: 找到得那个 **数据**
   
         24. findIndex()
           => 语法: 数组.findIndex(function (item) {})
           => 作用: 根据条件找到数组里面满足条件得数据
           => 返回值: 找到得那个 **数据得索引**

6. 数组去重
   1. 方案一

          var arr = [1, 2, 3, 5, 6, 4, 3, 2, 1, 1, 2, 3, 4, 5]
      
          // 方案1:
          for (var i = 0; i < arr.length; i++) {
            // 第一个数字开始比较, 向后比较
            for (j = i + 1; j < arr.length; j++) {
              if (arr[i] === arr[j]) {
                arr.splice(j, 1)
                j--
              }
            }
          }
      
          console.log(arr)

      2.方案二

          /*
            方案2:
              1. 准备一个新的数组
              2. 遍历原始数组
                => 一个一个得向新数组里面添加
                => 只要新数组里面没有这个数据, 就加进去
                => 如果新数组里面有这个数据, 就算了
          */
      
          // 1. 准备一个新数组
          var newArr = []
      
          // 2. 遍历原始数组
          for (var i = 0; i < arr.length; i++) {
            // 查看原始数组里面有没有 arr[i] 这个数据
            // if (newArr.indexOf(arr[i]) === -1) {
            //   // 表示 newArr 里面没有这个数据
            //   // 放进去
            //   newArr.push(arr[i])
            // }
      
            if (!newArr.includes(arr[i])) {
              // 能执行 if 条件, 说明 !newArr.includes(arr[i]) 是个 true
              // newArr.includes(arr[i]) 是 false
              newArr.push(arr[i])
            }
          }

       

•  字符串

1. 字符串创建
   1. 字面量创建:

      var str = 'hello world'

       

   2. 内置构造函数创建

      var str = new String('hello world')

       

2. 字符串的常用方法：chartAt、charCodeAt、substr、substring、toLowerCase、toUpperCase、replace、concat　、slice、spilt　、indexOf、lastIndexOf、includes、search、match、trim、trimStart、