js基础知识——函数、数组、对象

一、函数的概念

• 首先一定要明确, 和数学中的函数完全是两回事
• 在 JS 中, 函数可以理解为 一段在程序(页面)中 多次出现的代码段 封装起来的盒子
  • 简单来说, JS 的函数就是一个盒子, 盒子里边装的是在当前页面中多次出现的较为复杂的代码段

1. 函数的定义

• 注：如果函数只调用不定义，毫无意义！！！
• 1.1声明式定义
  • 语法: function fn () {}
    • function: 关键字 -> 表明后续的是一段函数
    • fn:函数的名字 -> 将来函数调用的时候需要用到, 函数名自定义
    • ():内部填写参数
    • {}: 内部填写函数调用时要执行的代码段
• 1.2 赋值式定义
  • 语法: var fn = function () { }

      // 1.1 声明式定义函数
            function fn1() {
                console.log('我是 fn1 函数')
            }
             fn1()           //函数fn1的调用
       


      // 1.2 赋值式定义函数
            var fn2 = function () {
                console.log('我是 fn2 函数')
            }
             fn2()         //函数fn2的调用

2.函数的调用

• 调用语法: 函数名 () / 变量名 ()
• 不管是 声明式函数还是赋值式函数, 调用方式都是一样的
• 同一个函数，可以调用多次
• 声明式与赋值时的区别
  • 1. 写法不同
  • 2. 调用上略有不同
    • 声明式定义的函数, 可以在函数定义前去调用
    • 赋值式定义函数, 不能在函数定义前去调用
      • 原因： 赋值式定义, 其实就是声明一个变量, 然后给他赋值为一个函数
• !!! 在 JS 中, 如果在定义变量之前 使用变量的话, 那么变量的值为 undefined(变量提升)，函数的执行结果, 一般默认都是 undefined, 除非手动更改.

3.函数的参数

• 函数的参数书写形式：
  • 书写再 function 后的 小括号内
• 参数的作用?
• 如果一个函数没有书写参数, 那么这个函数的功能相对来说比较单一；如果书写了参数, 能够使我们这个函数的使用更加灵活
• 参数的书写, 分为形参和实参
  • 1. function 后的小括号内 书写的参数我们叫做 "形参"
    • 形参的作用: 书写之后, 相当于在函数内部创建了一个变量, 变量实际的值由 "实参" 传递
  • 2. 函数名后的小括号内 书写的参数我们叫做 "实参"
    • 实参的作用: 将自身的值, 按照一一对应的关系, 传递给形参

        function fn(a,b){     //(a形参，b形参)
          sum = a + b
          console.log(sum)    //打印a+b的和
        }
          fn(100,200)         //(100实参，200实参) 一一对应传给形参
          fn(300,400)
          fn(1,1)
          
     // 给形参一个默认值
        function fn1(q = 100,w = 'aaa'){
          console.log(q,w)
        }
        fn1()         //不给实参，打印出的q和w的值为形参给的默认值
        fn1(1,2)      //给了实参，打印出的q和w值为1和2
    

• 函数参数的注意事项
  • 形参 和 实参 两个的数量, 要一一对应
    1. 形参的数量如果大于实参
       • 如果 形参的数量大于实参的数量, 那么会将 实参按照顺序一一传递给 对应的形参，多出来的形参, 相当于变量只定义没赋值, 所以他们的值 是 undefined
    2. 实参的数量如果大于形参
       • 如果 实参的数量大于形参的数量, 那么会将 实参按照顺序 一一传递给对应的形参，多出来的实参, 无法在函数内部通过参数的方式调用。

4.函数的返回值（执行结果）

• JS 有一个规定: 在函数内部创建(定义)的变量, 只能在函数内部使用
• 如果想在函数外部得到函数内部的某一个值, 或者运算结果, 可以通过 return 这个关键字实现
• return注意事项

  • return ，因此将它放在函数的尾部

  • 在函数外部得到函数内部的某一个值或运算结果

        function fn(a, b) {    
        var sum = a + b         
        return sum              // 书写返回值
        }
        var num = fn(50, 50)    // 创建变量接收函数的返回值
        console.log('num 的值: ', num)       // num 的值: 100
    

5.函数的预解析

• 预解析是什么?
  • JS 在执行代码的时候, 会有一个 所谓的 解析阶段，解析阶段, 做了一件事——函数提升, 就是将声明式函数的定义, 提升到当前作用域的最顶端
  • 预解析的一个表现就是 声明式函数在定义前可以被调用

6.函数的作用域

• 什么是 作用域?
  • 就是变量可以起作用的范围
  • 作用域分为两个
    1. 全局作用域(直接在 script 内书写的代码)
       • 再此作用域创建的变量, 我们叫做全局变量, 在当前 script 标签内的哪里都能使用，在 JS 中, 全局作用域中有一个 提前给我们准备好的 对象(一种数据格式)，这个对象叫做 window，我们创建的全局变量, 会被自动添加到 window 对象中。
    2. 局部作用域(在 JS 中, 只有函数能够创建局部作用域)
       • 在此作用域创建的变量, 只能在当前作用域使用, 超出这个作用域(也就是在函数外边)去使用, 就会找不到变量

6.函数的作用域链

• 什么是 作用域链?
  • 作用域链就是在访问一个变量的时候, 如果当前作用域内没有，会去自己的父级作用域, 也就是上一层作用域内查找, 如果找到就直接使用, 如果没有找到继续向上层查找，直到查找到 最顶层的全局作用域, 如果找到了直接使用, 如果没找到 报错提示变量不存在(未定义)，我们将这个一层一层向上查找的规律, 叫做作用域链。
• 作用域链的赋值规则
  • 在给变量赋值的时候, 首先会去当前作用域查找, 如果有直接赋值, 并停止查找如果没有, 会去自己的父级查找, 在父级找到直接修改值然后停止查找, 如果没有继续向自己的父级查找, 直到找到全局作用域在全局作用域内, 找到直接赋值修改他的值, 如果没有找到, 那么会在全局作用域创建一个变量, 并赋值。

6.递归函数

• 本质上还是一个函数，当一个函数在函数的内部, 调用了自身, 那么就算是一个 所谓的 递归函数

          function fn(n){
            if(n === 1){
              return 1
            }
            return n*fn(n-1)    //递归函数
          }
    // 计算4的阶乘
          var sum = fn(4)
          console.log(sum)
  

二、对象

• 什么是对象
  • JS 中的一种数据格式, 对象在 JS 中的数据类型数据为: 引用数据类型(也叫 复杂数据类型)
• 如何向变量中 存储一个 叫做 对象的数据呢?
  • 语法1: var obj = {键值对}
    • 键值对 -> key: value
    • 如果对象内部有多个 键值对, 那么需要使用 逗号 间隔
  1.创建对象
• 创建对象 分为两种方式:
  • 1. 字面量的形式 (使用频率比较高)
    • 语法: var obj = {键值对}
  • 2. 内置构造函数的创建
    • 语法1: var obj1 = new Object() // 创建空对象
    • 语法2: var obj1 = new Object({a: 1, b: 2}) // 创建一个具有属性或者说具有键值对的 对象

  • 注意: new Object的 O 是大写的, 不是小写

    // 1. 字面量的方式
        var obj = {
            b: 2,
            a: 1,
            c: 0,
            r: function () {
                console.log('我是 obj 对象 内 r 这个属性 的 属性值, 我是一个函数')
            }
         }
        console.log(obj)
    
    // 2. 内置构造函数的方式
        var obj1 = new Object({
            a: 1,
            q: 777,
            w: 666,
            e: 'qwer'
        })
        console.log(obj1)
    

2.对象的操作（增删改查）

• 对象的操作：就是对内部的属性的操作

• 分为两种方式：点语法和中括号语法(数组语法)

       var obj = {
        a : 100 ,
        b : 200 ,
        c : 300 ,
        d : 'zxc' 
      }
      console.log(obj)
  
  // 1.点语法
        // 查询
        console.log(obj.a)
        // 新增
        obj.q = 'hjx'
        console.log('新增q之后的obj',obj)
        // 修改
        obj.a = 500
        console.log('修改a之后的obj',obj)
        // 删除
        delete obj.c
        console.log('删除c之后的obj',obj)
  
  //2.中括号语法
        // 查询
        console.log(obj['a'])
        // 新增
        obj['q'] = 'hjx'
        console.log('新增之后的obj',obj)
        // 修改
        obj['a'] = 500
        console.log('修改之后的obj',obj)
        // 删除
        delete obj['c']
        console.log('删除之后的obj',obj)
  

• 一般大部分情况下, 点语法与中括号语法, 作用相同, 怎么选择都可以,特殊情况下我们需要使用中括号语法

  1. 对象的属性名, 有纯数字或者特殊符号, 这个时候, 就只能使用中括号语法

  2. 如果涉及变量相关的时候, 也需要使用中括号

      // 情况一：对象的属性名，有纯数字或者特殊符号
           var obj = {
             100: '我的属性名时纯数字 100',
             '!': '我的属性名时纯数字 !',
             '@': '我的属性名时纯数字 @'
           }
           console.log(obj[100])
           console.log(obj['100'])
           // 需要将特殊符号用' '包裹
           console.log(obj['!'])
           console.log(obj['@'])
     
     // 情况二：涉及交量相关的时候
           var obj = {
             a: 1,
             b: 2,
             name: 'qw112'
           } 
           var myName = 'name'
           console.log(obj.myName)     // 点语法查询myName 输出 undefined 
            console.log(obj[myName])  //'qw112'
     

  • 对象关于key 的要求:
    1. 推荐使用符合变量命名规则与规范的名字
    2. 对象的 key 也可以使用 纯数字 来当作键名(属性名/key)
    3. 可以使用任何特殊符号 (但是需要使用引号包裹)

  3.for...in 循环遍历对象

• 语法: for (var i in 要遍历的对象) { 循环要执行的代码 }

      var obj = {
      a: 100,
      b:'asdf',
      c: undefined,
      d: 666
    }
    for (var i in obj){
      console.log(i)  //打印的是属性a b c d
      console.log(obj[i])     //打印的是属性对应的属性值
    }

三、数组

• 数组 是一种数据类型, 属于引用数据类型(复杂数据类型)
• 数组是存放一些数据的集合换句话说: 我们把数据放在一个盒子中, 这个盒子就叫做数组
• 注意! 数组内的数据是有顺序的！！

1.创建数组

• 创建数组共分两种方式

1. 字面量的方式
   • 语法: var arr = [1, 2, 3, 'q', 'w', 'e']
2. 内置构造函数的方式
   • 语法1: var arr = new Array() 创建一个空数组
   • 语法2: var arr = new Array(5) 创建一个有长度的数组
   • 语法3: var arr = new Array(1, 2, 3) 创建一个有内容的数组

2.数组的 length 属性

• length 翻译过来就是 长度的意思，代表 这个数组内, 有多少个成员
• 语法: 数组名.length

3.数组的索引

• 索引 也有人叫做 下标就是指一个数据, 在这个数组内排列在第几个 位置上
• 注意: 在 JS 中, 索引(下标) 是从 0 开始计算的，如果想要获取到数组指定位置的值, 可以通过下标来获取
• 语法: 数组名[下标] -> 能够获取到这个数组中对应下标的成员具体的值

4.遍历数组

• 想办法 拿到 数组的每一个成员，想拿到数组的所有成员, 需要先想办法拿到数组的所有下标
• 规律: 所有数组的下标都是从 0 开始的, 然后到 数组.length - 1 结束

// 创建数组
    // 方式一：字面量
        var arr = [1,2,3,'a','c','d']
        console.log(arr)

    // 方式二：内置构造函数
        // 1.创建一个空数组
        var arr1 = new Array()
        console.log(arr1)
        // 2.创建一个有长度的数组
        var arr2 = new Array(6)
        console.log(arr2)
        // 3.创建一个有内容的数组
        var arr3 = new Array(3,2,1,'q')
        console.log(arr3)


// 长度查询 语法：数组名.length
        var arr4 = [1,5,9,'h','j','x','good']
        console.log(arr4.length)

// 数组的索引 (某一个数据在数组的第几个位置上！从0开始)
        var arr5 = [1,2,3,'a','s','d','f']
        console.log(arr5)
        console.log(arr5[0])   //查看第1个数据
        console.log(arr5[5])   //查看第6个数据

// 遍历数组(规律：数组下标从0开始，数组名.length-1结束)
        var arr6 = ['a','s','d','f','g','h','j']
        for (var i = 0;i < arr6.length;i++){
          console.log(arr6[i])
        }

四、冒泡排序和选择排序

1.冒泡排序

    <script>
        var arr = [5,6,8,7,1,9,2]
        console.log('原始数据',arr)
        for (var k = 0;k < arr.length - 1;k++){    //循环length- 1次，进行顺序排序
          for (var i = 0;i < arr.length - 1 - k;i++){  //循环一轮，length-1次，找出最大值
            if (arr[i] > arr[i+1]){   //判断前一个数是否大于后一个数（从大到小排）
              var temp = arr[i]      //若前一个大于后一个，前后位置交换
              arr[i] = arr[i + 1]
              arr[i + 1] = temp
            }
          }
        }
    console.log('冒泡排序后的数组',arr)
  </script>

2.选择排序

<script>
      var arr = [9,5,6,4,7,3,8,2,1]
      console.log('原始数据',arr)
      for (var k = 0;k < arr.length;k++){
        var minIndex = k
        for (i = k + 1;i < arr.length;i++){
          if (arr[minIndex] > arr[i]){
            minIndex = i
          }
        }
        var temp = arr[k]
        arr[k] = arr[minIndex]
        arr[minIndex] = temp
      }
      console.log('选择排序后的数组',arr)
 </script>

五、数据类型的区别

• 数据类型分为两种
  • 基本数据类型(简单数据类型)
  • 引用数据类型(复杂数据类型)
  1. 存储
     • 变量的数据存储的地方是 内存中, 内存分为两个 栈内存, 堆内存
       • 基本数据类型存储在 栈内存中, 比如: string number undefined null boolean
       • 复杂数据类型, 将数据本体存放在堆内存中, 比如对象或者数组或者函数，然后将指向该内存的地址, 存放在数组名或者对象名或者函数名中，数组/对象/函数 名 存放在 栈内存中。
       • 基本数据类型内部存储的是值; 引用数据类型内部存储的是地址
  2. 赋值
     • 基本数据类型: 赋值以后, 两个变量之间没有任何关系, 相当于将我自己的某一个东西, 复制一份给你, 然后你的就是你的, 我的就是我的
     • 复杂数据类型: 因为变量内部存储的是指向堆内存的地址, 所以在赋值的时候, 其实是将 这个地址给到了另外一个变量，那么相当于这两个变量存储的是 同一个 钥匙, 所以操作其中一个变量的时候, 会影响另外一个变量
  3. 比较
     • 基本数据类型: 就是 值 的比较
     • 引用数据类型: 比较的时候 比较的是 存储地址
  4. 传参
     • 基本数据类型: 将值拷贝一份传递给形参, 在函数内修改不会影响外界
     • 引用数据类型: 将存储地址赋值给形参, 在函数内修改会影响外界

六、数组常用的方法

1. push

• 语法: 数组.push(数据)
• 作用: 向数组末尾添加数据
• 返回值: 追加数据后, 数组最新的长度(length)

    // 1.向末尾添加数据
    var arr = [1,5,6,1,300,2588]
    console.log('原始数组',arr)
    var len = arr.push(666)
    console.log('添加后的数组',arr) 
    console.log('添加后的数组长度',len) 

2. pop

• 语法: 数组.pop()
• 作用: 删除数组最后一条数据
• 返回值: 被删除的数据

    // 2.删除末尾数据
    var arr = [1,5,6,1,300,2588]
    console.log('原始数组',arr)
    var del = arr.pop(666)
    console.log('添加后的数组',arr) 
    console.log('显示被删除的数据',del) 

3. unshift

• 语法: 数组.unshift(数据)
• 作用: 向数组开头添加数据
• 返回值: 添加数据后, 数组最新的长度(length)

// 3.向开头添加数据
    var arr = [1,5,6,1,300,2588]
    console.log('原始数组',arr)
    var add = arr.unshift(999)
    console.log('添加后的数组',arr) 
    console.log('添加后的数组长度',add) 

4. shift

• 语法: 数组.shift()
• 作用: 删除数组第一条数据
• 返回值: 被删除的数据

// 4.删除开头数据
    var arr = [1,5,6,1,300,2588]
    console.log('原始数组',arr)
    var stDel = arr.shift(666)
    console.log('添加后的数组',arr) 
    console.log('显示被删除的数据',stDel)

5. reverse

• 语法: 数组.reverse()
• 作用: 反转数组
• 返回值: 反转后的数组

// 5.反转数组
    var arr = [1,5,6,9,8,7]
    console.log('原始数组',arr)
    var fz = arr.reverse()
    console.log('反转后的数组',arr) 
    console.log('显示反转后的数组',fz) //结果相同

6. sort

• 语法1: 数组.sort()
  • 作用: 会将数据转换为 字符串后, 一位一位的对比
• 语法2: 数组.sort(function (a, b) {return a - b})
  • 作用: 会按照数字大小升序排列
• 语法3: 数组.sort(function (a, b) {return b - a})
  • 作用: 会按照数字大小降序排列
• 返回值: 排序后的数组

  // 6.对数组进行排序
    // 情况1
          var arr = [1,100,1005,102,300,2588]
          console.log('原始数组',arr)
          var px1 = arr.sort()
          console.log('执行后的数组',arr) 
          console.log('显示排序后的数据',px1) 
            
      // 情况2 升序
          var arr = [99,10,6,2,300,2588]
          console.log('原始数组',arr)
          var px2 = arr.sort(function(a,b){return a - b})
          console.log('执行后的数组',arr) 
          console.log('显示排序后的数据',px2) 
            
      // 情况3 降序
          var arr = [888,5,6,62,300,2588]
          console.log('原始数组',arr)
          var px3 = arr.sort(function(a,b){return b - a})
          console.log('执行后的数组',arr) 
          console.log('显示排序后的数据',px3) 

7. splice

• 语法1: 数组.splice(开始索引, 多少个)
  • 作用: 截取数组部分内容
• 语法2: 数组.splice(开始索引, 多少个, 插入的数据1, 插入的数据2, 插入的数据3...)
  • 作用: 截取数组部分内容, 并插入新的数据
• 返回值: 截取出来的部分内容 组成的 数组
• 数组的方法 能够改变原数组的 就只有上边说的 7 个

// 7.截取数组(原数组改变)
      // 情况1
        var arr = [1,5,6,9,8,7,16,18]
        console.log('原始数组',arr)
        var jq1 = arr.splice(2,4)
        console.log('截取后的原数组',arr) 
        console.log('显示截取后的数组',jq1) 
      // 情况2
        var arr = [1,5,6,9,8,7,16,18]
        console.log('原始数组',arr)
        var jq2 = arr.splice(2,5,'a','b','666')
        console.log('截取后的原数组',arr) 
        console.log('显示截取后的数组',jq2) 

8. slice

• 语法: 数组.slice(开始索引, 结束索引)
• 参数:
  • 包前不包后: 包含开始索引位置的数据, 不包含结束索引位置的数据
  • 不写开始索引, 默认是0; 不写 结束索引, 默认是 数组的length
  • 参数支持写负数, 表示倒数第几个, 其实就是 length + 负数
• 作用: 截取数组部分内容
• 返回值: 截取出来的部分内容组成的新数组

    // 8.截取数组内部分内容(原数组不变)
      var arr = [4,5,6,9,8,7,16,18]
        console.log('原始数组',arr)
        var jq = arr.slice(2,5)
        console.log('截取后的原数组',arr) 
        console.log('显示截取后的数组',jq) 

9. concat

• 语法: 原始数组.concat(数组1, 数组2, ...., 数据1, 数据2, ....)
• 作用: 进行数据拼接, 把数组...数据之类的小括号里的内容, 拼接在原始数组中
• 返回值: 拼接好的数组

// 9.数据拼接(原数组不变)
      var arr = [4,5,6,9,8,7,16,18]
      var arr1 = [1,2,3]
      var arr3 = ['a','b','c']
        var pj = arr.concat(arr,arr1,arr3,2,5)
        // console.log('截取后的原数组',arr) 
        console.log('显示拼接后的数组',pj) 

10. join

• 语法: 数组.join('连接符')
• 作用: 使用 "连接符", 把数组内的每一个数据连接成一个字符串 (不写连接符, 默认使用的是 逗号)
• 返回值: 连接好的字符串

// 10.连接变为字符串(原数组不变)
      var arr = [4,5,6,9,8,7,16,18]
        console.log('原始数组',arr)
        var link = arr.join()
        // var link = arr.join(!)
        console.log('连接后的原数组',arr) 
        console.log('显示连接后的数组',link) 

11. indexOf

• 语法1: 数组.indexOf(要检查的数据)
  • 作用: 从前到后(从左到右) 检查该数据第一次在该数组内出现 索引
• 语法2: 数组.indexOf(要检查的数据, 开始索引)
  • 作用: 在开始索引的位置, 按照从左到右的顺序, 检查该数据第一次在该数组内出现的 索引
• 返回值: 找到数据的情况下, 会将该数据第一次出现的下标(索引)返回，没找到的情况下, 会直接返回一个 -1
  • 备注: 开始索引不写的时候 默认是0

// 11.检查数据下标值---正序(原数组不变)
      // 情况1
        var arr = [4,4,6,9,9,1,1,16,18]
        console.log('原始数组',arr)
        var jc1 = arr.indexOf(9)
        console.log('检查后的原数组',arr) 
        console.log('显示9的下标',jc1) 
      // 情况2
      var arr = [4,4,6,9,9,1,1,16,18]
        console.log('原始数组',arr)
        var jc2 = arr.indexOf(4,2)
        console.log('检测后的原数组',arr) 
        console.log('显示4的下标',jc2) 

12. lastIndexOf

• 语法1: 数组.lastIndexOf(要检查的数据)
  • 作用: 从后向前(从右向左), 检查该数据第一次在该数组内出现的 索引
• 语法2: 数组.lastIndexOf(要检查的数据, 开始索引)
  • 作用: 在开始索引的位置, 按照从右向左的顺序, 检查该数据第一次在该数组内出现的 索引
• 返回值: 找到数据的情况下, 返回第一次出现的下标(索引)，没找到的情况下, 直接返回一个 -1

    // 12.检查数据下标值---倒序(原数组不变)
      // 情况1
        var arr1 = [0,1,6,9,9,1,1,0,18]
        console.log('原始数组',arr)
        var jc3 = arr1.lastIndexOf (0)
        console.log('检查后的原数组',arr) 
        console.log('倒叙显示0的下标',jc3) 
      // 情况2
        var arr2 = [4,4,6,9,9,1,1,16,18]
        console.log('原始数组',arr)
        var jc4 = arr2.lastIndexOf(1,6)
        console.log('检测后的原数组',arr) 
        console.log('倒叙显示1的下标',jc4) 

七、数组遍历常用的方法

1. forEach

• 语法: 数组.forEach(function (item, index, origin) {})
  • item: 数组的每一项 的值
  • index: 数组的每一项 对应的下标
  • origin: 原始数组 (了解即可, 一般没人用)
• 作用: 遍历数组
• 返回值: 该方法永远没有返回值 (undefined)

   // 方法1.遍历数组 (forEach无返回值)
    var arr = [1,2,3,4,5,6]
    var bl1 = arr.forEach(function(item,index,origin){
      console.log(item,index,origin)
    })

2. map

• 语法: 数组.map(function (item, index, origin) {}) 三个参数的意义与 forEach 相同
• 作用: 映射数组
• 返回值: 返回一个和原数组长度相同的数组, 但是内部数据可以经过我们的映射加工
• 映射加工: 就是在函数内 以 return 的形式书写

 // 方法2.  (有返回值,映射出来的参数)
    var arr = [1,2,3,4,5,6]
    var bl2 = arr.map(function(item,index,origin){
      return item*3  //映射一个数组,长度与arr相同,值是arr的2倍
    })
    console.log(bl2)  //返回映射出的值

3. filter

• 语法: 数组.filter(function (item, index, origin) {}) 三个参数的意义与 forEach 相同
• 作用: 过滤数组
• 返回值: 返回一个新数组, 内部存储的是原始数组过滤出来的部分内容
• 过滤条件: 过滤条件以 return 的形式书写

    // 方法3.  过滤数组(有返回值,映射出来的参数)
    var arr = [1,2,3,4,5,6]
    var bl3 = arr.filter(function(item,index,origin){
      return item > 3 
    })
    console.log(bl3)  //返回映射出的值

4. find

• 语法: 数组.find(function (item, index, origin) {}) 三个参数的意义 与 forEach 相同
• 作用: 在数组内查找满足条件的第一项
• 返回值: 找到的数据, 如果没找到返回的是 undefined
• 查找条件以 return 的形式书写

    // 方法4.  查找满足条件的数据
    var arr = [1,2,3,4,5,6]
    var bl4 = arr.find(function(item,index,origin){
      return item > 4
    })
    console.log(bl4)  //返回符合条件的值

5. findIndex

• 语法: 数组.findIndex(function (item, index, origin) {}) 三个参数的意义 与 forEach 相同
• 作用: 在数组内查找满足条件的第一项 的下标
• 返回值: 找到的数据 的下标, 如果没找到返回的是 -1
• 查找条件以 return 的形式书写

     // 方法5.查找满足条件的第一项的下标  (有返回值)
    var arr = [1,2,3,4,5,6]
    var bl5 = arr.findIndex(function(item,index,origin){
      return item > 4
    })
    console.log(bl5)  //返回符合条件的下标值

6. some

• 语法: 数组.some(function (item, index, origin) {}) 三个参数的意义 与 forEach 相同
• 作用: 判断数组内是否有一个满足条件
• 返回值: 一个布尔值 true/false
• 判断条件以 return 的形式书写

 // 方法6. 判断是否有一个数据满足条件 (有返回值)
    var arr = [1,2,3,4,5,6]
    var bl6 = arr.some(function(item,index,origin){
      return item > 5
    })
    console.log(bl6)  //返回符合条件的值

7. every

• 语法: 数组.every(function (item, index, origin) {}) 三个参数的意义 与 forEach 相同
• 作用: 判断数组内是否全都满足条件
• 返回值: 一个布尔值 true/false
• 判断条件以 return 的形式书写

// 方法7. 判断数据是否全部满足条件 (有返回值)
    var arr = [1,2,3,4,5,6]
    var bl7 = arr.every(function(item,index,origin){
      return item > 1
    })
    console.log(bl7)  //返回布尔值

8. reduce

• 语法: 数组.reduce(function (prev, item, index, origin) {}, init)
  • prev: 表示初始值或者上一次的运算结果
  • item: 表示数组的每一项 的值
  • index: 表示数组的每一项 的下标(索引)
  • origin: 原始数组
• 作用: 用来实现叠加效果
• 返回值: 最终叠加的结果
  • 注意: 叠加条件以 return 的形式书写 prev 第一次的值, 如果你传递了 init, 就是 init 的值, 如果没有传递 init, 那么就是 数组[0] 的值，如果传递了 init, 循环执行 数组.length 次, 如果没有传递 init, 循环执行 数组.length - 1 次

       // 方法8. 实现数据叠加 (有返回值)
    var arr = [1,2,3,4,5,6]
    var bl7 = arr.reduce(function(prev,item,index,origin){
    return prev+item
     },0)       //写init的值

    var bl7 = arr.reduce(function(prev,item,index,origin){
      return prev+item
    })        //不写init的值

    console.log(bl7)  //返回和

八、数学的方法

• 在 JS 中 Math 对象给我们提供了操作数据的一些方法(数学的方法)

1. random

• 语法: Math.random()
• 作用: 得到一个随机数, 每次生成的数字都不一样, 但一定是0~1之间的, 包含0, 不包含1, 也就是说最大值可能是 0.99999....

    // 1.随机数
      var num = Math.random()
      console.log(num)

2. round

• 语法: Math.round(数字)
• 作用: 将这个数字(小数), 按照四舍五入的形式变成整数

    // 2.四舍五入
      var num = Math.round(4.569)
      var num1 = Math.round(4.236)
      console.log(num)
      console.log(num1)

3. ceil

• 语法: Math.ceil(数字)
• 作用: 将这个数字(小数) 向上取整

  // 3.向上取整
      var num = Math.ceil(3.569)
      var num1 = Math.ceil(2.00006)
      console.log(num)
      console.log(num1) 

4. floor

• 语法: Math.floor(数字)
• 作用: 将这个数字(小数) 向下取整

 // 4.向下取整
      var num = Math.floor(2.568001)
      var num1 = Math.floor(4.00006)
      console.log(num)
      console.log(num1) 

5. abs

• 语法: Math.abs(数字)
• 作用: 返回这个数字的绝对值

    // 5.取绝对值
      var num = Math.abs(-2.568001)
      var num1 = Math.abs(4.00006)
      console.log(num)
      console.log(num1)  

6. sqrt

• 语法: Math.sqrt(数字)
• 作用: 求 平方根

    // 6.求平方根
      var num = Math.sqrt(9)
      var num1 = Math.sqrt(16)
      console.log(num)
      console.log(num1) 

7. pow

• 语法: Math.pow(基数, 幂)
• 作用: 返回基数的几次幂

    // 7.一个数的n次幂
      var num = Math.pow(2,3)
      var num1 = Math.pow(3,2)
      console.log(num)
      console.log(num1) 

8. max

• 语法: Math.max(数字1, 数字2, 数字3...)
• 作用: 返回传入的数字中 最大的哪一个

    // 8.算最大值
      var num = Math.max(92,4,6,0.6,9,5)
      var num1 = Math.max(16,5,6,4,5,96,22)
      console.log(num)
      console.log(num1) 

9. min

• 语法: Math.min(数字1, 数字2, 数字3...)
• 作用: 返回传入的数字中 最小的哪一个

    // 9.算最小值
      var num = Math.min(92,4,6,0.6,9,5)
      var num1 = Math.min(16,5,6,4,5,96,22)
      console.log(num)
      console.log(num1) 

10. PI

• 语法: Math.PI
• 作用: 返回 π

    // 10.求Π
      var num = Math.PI
      console.log(num)