写一个函数，返回从min到max之间的 随机整数，包括min不包括max

function getRandomArbitrary(min,max){
    return Math.floor(Math.random()*(max-min)+min);
}
console.log(getRandomArbitrary(1,20))

写一个函数，生成一个长度为 n 的随机字符串，字符串字符的取值范围包括0到9，a到 z，A到Z。

var dict = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
function randomStr(len){
     var str = ''
       for(i = 0;i < len; i++){
        var index = Math.floor(Math.random()*dict.length);
         str += dict[index];
    }
    return str
}
var index = randomStr(n)
console.log(index)

写一个函数，生成一个随机 IP 地址，一个合法的 IP 地址为 0.0.0.0~255.255.255.255

function randomIP(){
   var ip = [];
   for(i = 0; i < 4; i++){
        ip.push(Math.floor(Math.random()*256))
         }
   return ip.join('.')
}
var IP = randomIP()
console.log(IP)

写一个函数，生成一个随机颜色字符串，合法的颜色为#000000~ #ffffff

function getRandColor(){
    var dict = '0123456789abcdef'
    var str = [];
    for(i = 0; i < 6; i++){
       var index = Math.floor(Math.random()*dict.length)
        str += dict[index]
    }
     return str = '#' + str
}
var color = getRandColor()
console.log(color)   

实现一个flatten函数，将一个嵌套多层的数组 array（数组） (嵌套可以是任何层数)转换为只有一层的数组，数组中元素仅基本类型的元素或数组，不存在循环引用的情况。

方法一：
function flaten(arr){
    var arr2 = [];
   arr.forEach(function(val){
     if (Array.isArray(val)){
        arr2 = arr2.concat(flaten(val))
     } else{
        arr2.push(val)
     }
   })
   return arr2
}

方法二：
function flaten(arr){
   return arr.reduce(function(initArr,currentArr){
      return initArr.concat(Array.isArray(currentArr)?flaten(currentArr):currentArr)
   },[])
}
var arr = [3, [2, -4, [5, 7]], -3, ['aa', [['bb']]]]
var arr2 = flaten(arr)
console.log(arr2)  //[3, 2, -4, 5, 7, -3, "aa", "bb"]

实现一个reduce函数，作用和原生的reduce类似

function reduce(arr, iteratee, initValue){
    var tmpArr = (initValue === undefined ? [] : [initValue]).concat(arr);
    while(tmpArr.length > 1){
        tmpArr.splice(0,2,iteratee(tmpArr[0],tmpArr[1]))
    }
    return tmpArr[0]
}
var sum = reduce([1, 2, 3], function(memo, num){ return memo + num; }, 0)
console.log(sum)   //6

写一个函数getChIntv，获取从当前时间到指定日期的间隔时间

function getChIntv(specifiedDate){
     return Math.abs(Date.now() - Date.parse(specifiedDate))
}
var str = getChIntv("2017-02-08 10:30:24");
console.log(str);
var str = getChIntv("2017-02-08 10:30:24");
console.log(str);

写一个函数，参数为时间对象毫秒数的字符串格式，返回值为字符串。假设参数为时间对象毫秒数t，根据t的时间分别返回如下字符串:

• 刚刚（ t 距当前时间不到1分钟时间间隔）
• 3分钟前 (t距当前时间大于等于1分钟，小于1小时)
• 8小时前 (t 距离当前时间大于等于1小时，小于24小时)
• 3天前 (t 距离当前时间大于等于24小时，小于30天)
• 2个月前 (t 距离当前时间大于等于30天小于12个月)
• 8年前 (t 距离当前时间大于等于12个月)

function friendlyDate(time){
    var intervalTime = Math.abs(Date.now() - time)
    if(intervalTime < 1*60*1000){
        return '刚刚'
    } else if(1*60*1000 <= intervalTime && intervalTime < 1*60*60*1000){
        return Math.floor(intervalTime/1000/60) + '分钟前'
    } else if(1*60*60*1000 <= intervalTime && intervalTime < 24*1*60*60*1000){
        return Math.floor(intervalTime/1000/60/60) + '小时前'
    } else if(24*1*60*60*1000 <= intervalTime && intervalTime < 30*24*1*60*60*1000){
        return Math.floor(intervalTime/1000/60/60/24) + '天前'
    } else if(30*24*1*60*60*1000 <= intervalTime && intervalTime < 12*30*24*1*60*60*1000){
        return Math.floor(intervalTime/1000/60/60/24/30) + '个月前'
    } else if(12*30*24*1*60*60*1000 <= intervalTime ){
        return Math.floor(intervalTime/1000/60/60/24/30/12) + '年前'
    }
}
var str = friendlyDate(Date.now()) //  刚刚
var str2 = friendlyDate('1483941245793') 
console.log(str)
console.log(str2)

方法二：
function getFriendlyDate(timeStr){
  var interval = Date.now() - parseInt(timeStr)
  var ch = interval > 0 ? '前': '后'
  var str
  interval = Math.abs(interval)
  switch (true){
    case interval < 60*1000:
      str = '刚刚'
      break
    case interval < 60*60*1000:
      str = Math.floor(interval/(60*1000)) + '分钟' + ch
      break
    case interval < 24*60*60*1000:
      str = Math.floor(interval/(60*60*1000)) + '小时' + ch
      break
    case interval < 30*24*60*60*1000:
      str = Math.floor(interval/(24*60*60*1000)) + '天' + ch
      break
    case interval < 12*30*24*60*60*1000:
      str = Math.floor(interval/(30*24*60*60*1000)) + '个月' + ch
      break    
    default:  
      str = Math.floor(interval/(12*30*24*60*60*1000)) + '年' + ch
  }
  return str
}
console.log( getFriendlyDate('1505122360640') )  //"7分钟前"
console.log( getFriendlyDate('1503122360640') )  //"23天前"
console.log( getFriendlyDate('1203122360640') )  //"9年前"
console.log( getFriendlyDate('1508122360640') )  //"1个月后"