JS数组的数学方法(数组去重和生成随机整数案例)

49、数组的数学方法

数学的方法
 * 
 * 在JS中Math对象给我们提供J操作数据的些方法( 教学的方法)
 * 

* !1.random

 * 语法：Math.random()
 * 作用：得到一个随机数，每次生成的数 字都不一样，但一定是0~1之间的，
                     包含0，不包含1， 也就是 说最大值可能是0. 99999...
 ```js
     var num = Math.random()
     console.log(num)
 ```

* 2.round

 *    * 语法：Math.round(数字)
 *    * 作用：将这个数字(小数)，按照四舍五入的形式变成整数
 ```js
     var num1 = Math.round(4.499999)
     var num2 = Math.round(4.5)
     console.log(num1) //4
     console.log(num2) //5
 ```

* !3.ceil

 *    * 语法：Math.cei- l(数字)
 *    * 作用：将这个数字(小数)向上取整
 ```js
     var num1 = Math.ceil(1.00001)
     var num2 = Math.ceil(1.99999)
     console.log(num1) //2
     console.log(num2) //2
 ```

* !4.floor

 * 语法：Math.floor(数字)
 * 作用：将这个数字(小数)向下取整
 ```js
     var num1 = Math.floor(1.00001)
     var num2 = Math.floor(1.99999)
     console.log(num1) //1
     console.log(num2) //1
 ```

* 5.abs

 * 语法：Math.abs(数字)
 * 作用：返回这个数字的绝对值
 ```js
     var num1 = Math.abs(1.23)
     var num2 = Math.abs(-1.23)
     console.log(num1) //1.23
     console.log(num2) //1.23
 ```

* 6.sqrt

 * 语法：Math.sqrt(数字)
 * 作用：求平方根
 ```js
     var num = Math.sqrt(16)
     console.log(num) //4
 ```

* 7.pow

 * 语法：Math.pow(基数, 幂)
 * 作用：返回基数的几次幂
  ```js
     var num = Math.pow(2, 3)
     console.log(num) //8
 ```

* 8.max

 * 语法：Math.max(数字1,数字2...)
 * 作用：返回传入的数字中最大的那一个
 ```js
     var num = Math.max(100, 500, 123, 87, 9)
     console.log(num) //500
 ```

* 9.min

 * 语法：Math.min(数字1,数字2...)
 * 作用：返回传入的数字中最小的哪一个
 ```js
     var num = Math.min(100, 500, 123, 87, 9)
     console.log(num) //9
 ```

* 10.PI

 * 语法：Math.PI
 * 作用：返回π
 ```js
     var num = Math.PI
     console.log(num) //3.141592653589793
 ```

50、数组的数学方法课堂案例

①.数组去重

 *      var arr  = [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5]
 * 处理完毕后的arr === [1, 2, 3, 4, 5]

   // 1.数组去重 var arr  = [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5] 
   //处理完毕后的arr === [1, 2, 3, 4, 5]
   var arr  = [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5]

   // 1.遍历数组,拿到数组的每一项
   for (var i = 0; i < arr.length; i++) {
     // console.log(arr[i])
     // 2.判断数组内，除了当前项之外，后续有没有和当前项相同的项
     if(arr.indexOf(arr[i], i + 1) !== -1) { //如果当前分支语句成立，那么代表数组后续一定有与当前重复的值
       arr.splice(i, 1) //分支成立时，将当前项删掉，达到去重的目的
       i-- //直接使用splice会出现 数组塌陷的情况，会导致去重无法清除干净，加上i--，解决数组塌陷
     }
   }
   console.log(arr)

②.封装一个函数，函数返回一个0~10之间的随机整数 0 1 2 3 4 5 6 7 8 9 10

• 公式：Math.floor(Math.random()*(max-min+1)+min);

  • ps： max - 范围内的最大值，min - 单位内的最小值
  • 注意：如果是负数范围的随机数，要进行符号转换的
    • 比如-30（这里是说减去三十），转换符号后变成-。不转换符号，会出现报错！

    function fn() {
      // var fnNum1 = Math.random() //得到了一个0-1的随机数
      // var fnNum2 = fnNum1 * 10 //得到了一个0-10的随机数
      // var fnNum3 = Math.ceil(fnNum2)// 通过向上取整，将这个随机数改变为随机整数
      // var fnNum3 = Math.round(fnNum2) //通过四舍五入，将这个随机数改变为随机整数
      // console.log(fnNum3)

      /**
     * 目前 随机数取整的方式为 四舍五入 ，会出现概率问题
     * */ 
      // var fnNum3 = Math.round(Math.random() * 10)

      // 当前四舍五入的形式有问题，我们现在要么改为向上取整，要么改为向下取整
      //      如果说使用向上取整，数字应该计算为: -0.999~9.999向上取整后为0~10
      //      如果说使用向下取整，数字应该计算为: 0~10.999 向下取整后为0~10
      //       通过分析认为向下取整比较好计算，所以我们的取整方式更改为向下取整
      //       计算公式       Math.floor(随机数 * (10 + 1))   
      /**
       * 目前的随机数取整方式为向下取整
       * 0~0.999      0
       * ...
       * 9~9.999      9
       * 10~10.999    10
       * */ 
      var fnNum3 = Math.floor(Math.random() * (10 + 1))
      return fnNum3
    }
    var num = fn()
    console.log('num是一个随机数:' , num)

    var obj = {}
    for(var i = 0; i <= 10000; i++) {
      var sum = fn() //1.循环开始 先拿到的随机数的值
      if(obj[sum] === undefined) {
        obj[sum] = 1 //代表 当前这个随机数 第一次出现
      } else {
        obj[sum]++ 
        //如果执行的else分支，表明sum不是第一次出现具体出现的次数我们不知道，所以直接让他的属性
      }
    }
    console.log(obj) //得出概率问题的结论