1.数组进行放大十倍

封装函数, 把数组进行放大十倍的操作
要求: 函数的返回值需要是一个新数组

   var arr = [100,200,300]
   console.log('原始数组:',arr)
   function fn(fnArr){
    var newFnArr = []
    //需要将形参这个数组,进行放大十倍的操作
    for(var i = 0; i < fnArr.length; i++){
      // newFnArr.push(fnArr[i]*10)
      // console.log(fnArr[i])
      // newFnArr[i] = 666
      newFnArr[i] = fnArr[i] * 10
      /**
       * newFnArr[i] = 666
       * 第一轮循环 i === 0  newFnArr[i] = 666  ->  newFnArr[0] = 666
       * 第二轮循环 i === 1  newFnArr[i] = 666  ->  newFnArr[1] = 666
       * 第三轮循环 i === 2  newFnArr[i] = 666  ->  newFnArr[2] = 666
      */
      }
    
      return newFnArr
     }
     var newArr = fn(arr)
     console.log('放大后的数组:', newArr)

2.使用 JS 生成一个数组

要求: 数组内存储的数据是从 2 开始 的所有 偶数, 要求数组的长度为 30

  var arr = new Array(30)
  for(var i = 0; i < arr.length; i++){
    /**
     * i === 0 1 2 3 4 5 6 ...29
     * 需求:拿到从2 开始的所有偶数
     * 但是目前只能拿到0~29
     * (i + 1) * 2
     * 第一轮i === 0  (i + 1) * 2   (0 + 1) * 2   2
     * 第二轮i === 1  (i + 1) * 2   (1 + 1) * 2   4
     * 第三轮i === 2  (i + 1) * 2   (2 + 1) * 2   6
    */
    // console.log(arr[i])
    arr[i] = (i + 1) * 2
  }
  console.log(arr)

3.利用2 生成的数组, 每 5 个数字求一个平均值, 放在新数组内

  var sum = 0 //累加器
  var count = 0  //计数器
  var newArr = []  //新数组内存储平均值
  for(var k = 0 ; k < arr.length ; k++){
    sum += arr[k]  //累加器每次去和数组的值相加
    count++  //每累加一次,那么计数器自增1,用来记录当前累加了几次
    if(count === 5){
      //当前分支执行的时候,说明累加了5次
      newArr.push(sum / 5)  //计算出平均值,然后插入到新数组内
      count = 0  //计数器清零
      sum = 0  //累加器清零
    }
  }
  console.log('新数组:',newArr)

4.计算数组的和

   //1.计算数组的和 var arr = [1,2,3,4,5]
    var arr = [1, 2, 3, 4, 5]
    //方法1:使用forEach
    var sum = 0
    // arr.forEach(function (item) {
    //   sum += item
    // })

    //2.map
    arr.map(function (item) {
      sum += item
    })
    console.log(sum)
    
    //3.使用reduce
    var newArr = arr.reduce(function(prev,item,index,origin){
      return prev + item
    },0)
    console.log(newArr)

5.将数组的值 放大 10 倍 并返回一个新数组

   //方法1:使用forEach
    var arr = [1,2,3,4,5]
    // var num
    var arr1 = []
    arr.forEach(function(item,index,origin){
      // num = item * 10
      // arr1.push(num)
      arr1[arr1.length] = item * 10
    })
    console.log(arr1)

    //方法2:map
    var newArr = arr.map(function(item,index,origin){
      return item * 10
    })
    console.log(newArr)

6.过滤数组, 让数组内的值只有偶数

   var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    //方法1:使用filter方法
    var newArr = arr.filter(function(item,index,origin){
      return item % 2 === 0
    })
    console.log(newArr)

    //方法2:使用forEach方法
    var newArr = []
    arr.forEach(function (item){
      if(item % 2 === 0){
        newArr.push(item)
      }
    })
    console.log(newArr)

    //方法3:使用map方法
    var newArr = []
    arr.map(function (item){
      if(item % 2 === 0){
        newArr.push(item)
      }
    })
    console.log(newArr)

7.数组去重

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

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

    function fn(){
      //求0~10之间的随机整数
      var num1 = Math.random()
      // var num2 = Math.round(num1 * 10)//四舍五入
      var num2 = Math.floor(num1 * 11)//向下取整
      return num2
    }
    var num = fn()
    console.log(num)