ES5数组字符串 Date

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

• 思路：
  产生随机数要用到Math.random；
  返回整数且保证概率相等要用到Math.floor；
  先利用Math.foor(Math.random()*(math-min)得到[0,max-min)，即随机数介于0和max-min之间，包括0，不包括max-min；
  [0,max-min)+min得到[min,max)。
• 测试代码如下：

function randomNum(min,max){
  return Math.floor(Math.random()*(max-min))+min
}
console.log(randomNum(1,10))　　//产生1~10的随机数，包括1不包括10

• 考虑到如果min、max手误输入相反位置，优化代码如下：

function randomNum(min,max){
  var temp
  if (min > max) {
        temp = min
        min = max
        max = temp
    }
  return Math.floor(Math.random()*(max-min))+min
}
console.log(randomNum(1,10))

• 延伸：
  如果需要返回的是：[min,max]，则
  return Math.floor(Math.random() * (max - min + 1))+min;
  如果需要返回的是：(min,max]，则
  return Math.ceil(Math.random()*(max-min))+min;
  如果需要返回的是：(min,max)，则
  return Math.ceil(Math.random()*(max-min-1))+min;

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

function getRandStr(len){
  //补全函数
}
var str = getRandStr(10); // 0a3iJiRZap

思路：建立一个字符库，一个空字符，每次随机的抽取一个字符以空字符为基础进行拼接，一共执行n次。

function getRandStr(len){
  var randomStr='';
  var Str='0123456789abcdefghigklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
  function randomIndex(){
    return Math.floor(Math.random()*Str.length)
  }
  for(var i=0;i<len;i++){
    randomStr += Str[randomIndex()]
  }
  return randomStr;
}
console.log(getRandStr(10))

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

function getRandIP(){
  //补全
}
var ip = getRandIP()
console.log(ip) // 10.234.121.45

function getRandIP(){
  function randomNum(){
    return Math.floor(Math.random()*256)
  }
  var ip = randomNum()
  var i =0
  while(i<3){
    ip += '.' + randomNum()
    i++
  }
  return ip
}
var ip = getRandIP()
console.log(ip) // 如：10.234.121.45

也可以利用数组的 join 方法，先用一个数组容纳各个数字，然后用 ' . ' 分隔并返回字符串。

function getRandIP(){
  function randomNum(){
    return Math.floor(Math.random()*256)
  }
  var ip = []
  var i =0
  while(i<4){
    ip[i] = randomNum()
    i++
  }
  return ip.join('.')
}
var ip = getRandIP()
console.log(ip) // 如：10.234.121.45

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

function getRandColor(){
}
var color = getRandColor()
console.log(color)   // #3e2f1b

方法一：列出每一位所有可能自取值，然后循环随机抽取并拼接。

function getRandColor(){
  function randomIndex(){
    return Math.floor(Math.random()*16)
  }
  var Str = '0123456789abcdef'
  var randColor='#'
  var i=0
  while(i<6){
    randColor += Str[randomIndex()]
    i++
  }
  return randColor
}
var color = getRandColor()
console.log(color)   // #3e2f1b

方法二：每一位的取值为[0,16)，但需要转换为16进制。

function getRandColor(){
  function randomNum(){
    return Math.floor(Math.random()*16)
  }
  var randColor='#'
  var i=0
  while(i<6){
    randColor += randomNum().toString(16)
    i++
  }
  return randColor
}
var color = getRandColor()
console.log(color)   // #3e2f1b

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

Ex:

flatten([1, [2], [3, [[4]]]]) => [1, 2, 3, 4];

function flatten(arr){
  var newArr= []
  for(var i=0;i<arr.length;i++){
    if(typeof arr[i] !== 'object'){
      newArr[i]=arr[i] 
    }
    else{
      newArr = newArr.concat(flatten(arr[i]))
    }
  }
  return newArr
}
console.log(flatten([1,[2],[3,[[4]]]]))　　//输出：[1,2,3,4]

也可以用reduce方法：

function flatten(arr){
  return arr.reduce(function(){
    return arguments[0].concat(Array.isArray(arguments[1])?
    flatten(arguments[1]):arguments[1])
  },[])
}
console.log(flatten([1,[2],[3,[[4]]]]))　　//输出：[1,2,3,4]

6、实现一个reduce函数，作用和原生的reduce类似 Ex：var sum = reduce([1, 2, 3], function(memo, num){ return memo + num; }, 0); => 6

基础方法：

• reduce是用来依次操作数组的各个元素。
• 对于' + '操作，如果数组元素都是数值，则依次相加；如果某一个元素为不是数值，则此元素和它之后的元素都转换为字符串与之前的结果拼接。
• 先判断初始值是否存在，决定循环初始值和循环次数。

function reduceDiy(arr,func,value){
  if(typeof value === 'undefined'){
    var result=arr[0]
    for(var i=1;i<arr.length;i++){
      var pre=result
      var next=arr[i]
      result =func(pre,next)
    }
  }
  else{
    var result=value
    for(var i=0;i<arr.length;i++){
      var pre=result
      var next=arr[i]
      result =func(pre,next)
    }
  }
  return result
}
var sum = reduce([1, 2, 3], function(memo, num){ return memo + num; }, 0); 
console.log(sum)　　　//输出：6

以上代码可用三元运算符简写为：

function reduceDiy(arr,func,value){
  var i,value
  typeof value === 'undefined' ? (i=1,result=arr[0]) : (i=0,result=value)
  for(var j=i;j<arr.length;j++){
    var pre=result
    var next=arr[j]
    result =func(pre,next)
  }
  return result
}
var sum = reduceDiy([1, 2, 3], function(memo, num){ return memo + num;},0); 
console.log(sum)　　　//输出：6

拓展方法：

• 先判断是否存在 value，并将它拼接arr组成新的数组
• 如果只有新数组1位，直接返回第一位
• 如果有两位以上，用func操作前两位，获取结果并替换这两位，依次执行直到剩一位

function reduceDiy(arr,func,value){
  var arr2 = (value === undefined?[]:[value]).concat(arr)
  while(arr2.length >1){
    arr2.splice(0,2, func(arr2[0],arr2[1]))
  }
  return arr2[0]
}
var sum = reduceDiy([1, 2, 3], function(memo, num){ return memo + num;},0); 
console.log(sum)　　　//输出：6

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

var str = getChIntv("2017-02-08 10:30:24");
console.log(str);

基础方法：把指定日期和当前时期到标准时间间隔的毫秒数相减，然后转换成天数、时分秒数等。

function getChIntv(timeStr){
  var interval = new Date()-new Date(timeStr);
  return '间隔时间为：'+Math.floor(interval/(24*60*60*1000))+'天，'
  +Math.floor((interval%(24*60*60*1000))/(60*60*1000))+'时，'
  +Math.floor((interval%(60*60*1000))/(60*1000))+'分，'
  +Math.floor((interval%(60*1000))/1000)+'秒，'
  +interval%1000+'毫秒。'; 
}
var str = getChIntv("2017-02-08 10:30:24");
console.log(str);　　//输出："间隔时间为：208天，4时，56分，24秒，120毫秒。"

可以加入变量简化计算：

function getChIntv(timeStr){
  var interval = new Date()-new Date(timeStr);
  var milliSecond = interval%1000;
  var seconds = Math.floor(interval/1000);
  var second = seconds%60;
  var minutes = Math.floor(seconds/60);
  var minute = minutes%60;
  var hours = Math.floor(minutes/60);
  var hour = hours%24;
  var days = Math.floor(hours/24);
  return '时间间隔为：'+days+'天，'+hour+'时，'+minute+'分，'+second+'秒，'
+milliSecond+'毫秒。'
}
var str = getChIntv("2017-02-08 10:30:24");
console.log(str);输出："间隔时间为：208天，4时，56分，40秒，110毫秒。"

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

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

function queryTime(t){
  var interval=Date.now()-t;
  switch(true){
    case interval<0:
      console.log('在未来');
      break;
    case interval>=0&&interval<(60*1000):
      console.log('刚刚');
      break;
    case interval>=(60*1000)&&interval<(60*60*1000):
      console.log('3分钟前');
      break;
    case interval>=(60*60*1000)&&interval<(24*60*60*1000):
      console.log('8小时前');
      break;
    case interval>=(24*60*60*1000)&&interval<(30*24*60*1000):
      console.log('3天前');
      break;
    case interval>=(30*24*60*1000)&&interval<(12*30*24*60*1000):
      console.log('2个月前');
      break;
    case interval>=(12*30*24*60*1000):
      console.log('8年前');
      break;
  }
}
queryTime('1504513587883');　　//输出："刚刚"
console.log(Date.now())　　//输出：1504513614540