Math数组Date

Math

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

  function random(a,b){
    return a+Math.floor(Math.random()*(b-a))
  }

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

  function random(a,b){
    return a+Math.floor(Math.random()*(b-a+1))
  }

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

  function random(a,b){
    return a+Math.floor(Math.random()*(b-a))
  }
  // 返回随机字符串
  function getRandStr(len){
     var dict='1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM'
     var str = ''
      for(var i = 0 ; i < len ;i++){
        str = str +dict[random(0,62)]
      }
      return str;
   }
   var str = getRandStr(10);
   console.log(str)  //随机输出一个10位的字符串

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

  function random(a,b){
    return a+Math.floor(Math.random()*(b-a))
  }
  // 随机获取ip
  function getRandIP(){
    var arr = []    //声明一个空数组
    for(var i =0;i<4;i++){
      arr.push(random(0,256))
    }
  return arr.join('.')    //每个数值中间添加'.'分割
  }
  var ip = getRandIP()
  console.log(ip) // 10.234.121.45

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

  function random(a,b){
    return a+Math.floor(Math.random()*(b-a))
  }
  function getRandColor(){
    var dict='0123456789ABCDEFabcdef'  //随机库
    var str = ''     
      for(var i = 0 ; i < 6 ;i++){
        str = str +dict[random(0,22)];
      }
        return '#' + str; 
      }
  var color = getRandColor()
  console.log(color)  //随机输出一个颜色

数组

1、数组方法里push、pop、shift、unshift、join、splice分别是什么作用？用 splice函数分别实现push、pop、shift、unshift方法

• push,pop(栈方法)

我们很多时候希望删除中间一个元素后，后面元素的index都自动减一，数组length同时减一，就好像在一个堆栈中拿去的一个，数组已经帮我们做好了这种操作方式，pop和push能够让我们使用堆栈那样先入后出使用数组。
作用：push用来在数组末尾添加数值；pop用来删除数组末尾一个数值

  var a = new Array(1,2,3);
  a.push(4);   //在末尾添加数值4
  console.log(a);//[1, 2, 3, 4]
  console.log(a.length);//4
  console.log(a.pop());//4
  console.log(a); //[1, 2, 3]
  console.log(a.length);//3

• shift,unshift(队列方法)

既然栈方法都实现了，先入先出的队列怎么能少，shift方法可以删除数组index最小元素，并使后面元素index都减一，length也减一，这样使用shift/push就可以模拟队列了，当然与shift方法对应的有一个unshift方法，用于向数组头部添加一个元素
作用：unshift往数组的第一个位置添加一个数值；shift删除数组的第一个数值

  var a=new Array(1,2,3);
  a.unshift(4);   //数组第一位添加数值4
  console.log(a);//[4, 1, 2, 3]
  console.log(a.length);//4    
  console.log(a.shift());//4    //删除数组第一位
  console.log(a); //[1, 2, 3]
  console.log(a.length);//3

• join

这个方法在C#等语言中也有，作用是把数组元素（对象调用其toString()方法）使用参数作为连接符连接成一字符串，不会修改原数组内容

  var a = new Array(1,2,3,4,5);
  console.log(a.join(',')); //1,2,3,4,5
  console.log(a.join(' ')); //1 2 3 4 5

• splice(终极神器)推荐指数：★★★★★

JavaScript提供了一个splice方法用于一次性解决数组添加、删除（这两种方法一结合就可以达到替换效果），方法有三个参数

• 1.开始索引
• 2.删除元素的位移
• 3.插入的新元素，当然也可以写多个
  splice方法返回一个由删除元素组成的新数组，没有删除则返回空数组

  var a = new Array(1,2,3,4,5);

删除

指定前两个参数，可以使用splice删除数组元素，同样会带来索引调整及length调整

  var a = new Array(1,2,3,4,5);
  console.log(a.splice(1,3));//[2, 3, 4]
  console.log(a.length);//2
  console.log(a);//[1,5]

如果数组索引不是从0开始的，那么结果会很有意思，有一这样数组

  var a = new Array();
  a[2]=2;
  a[3]=3;
  a[7]=4;
  a[8]=5;

console.log(a.splice(3,4)); //[3]
console.log(a.length); //5
console.log(a); //[2: 2, 3: 4, 4: 5]

上面例子可以看到，splice的第一个参数是绝对索引值，而不是相对于数组索引，第二个参数并不是删除元素的个数，而是删除动作执行多少次，并不是按数组实际索引移动，而是连续移动。同时调整后面元素索引，前面索引不理会

插入与替换

只要方法第二个参数，也就是删除动作执行的次数设为0，第三个参数及以后填写要插入内容就splice就能执行插入操作，而如果第二个参数不为0则变成了先在该位置删除再插入，也就是替换效果

  var a = new Array(1,2,3,4,5);
  a.splice(1,0,9,99,999);
  console.log(a.length); //8
  console.log(a);//[1, 9, 99, 999, 2, 3, 4, 5]
  a.splice(1,3,8,88,888);
  console.log(a.length);//8
  console.log(a);//[1, 8, 88, 888, 2, 3, 4, 5]

• 用 splice函数分别实现push、pop、shift、unshift方法

  var arr = [1,2,3,4,5,6,7]
  arr.splice(7,0,8)   //相当于arr.push（8）在末尾添加数值8
  arr.splice(7,1)   //8  相当于arr.pop()  删除最后一个数值 
  arr.splice(0,0,1)   // 相当于arr.unshift(0)  在数组首添加数值0 
  arr.splice(0,1)    // 相当于arr.shift() 删除数组首个数值
  

其他操作

• slice(start,end)

不要和splice方法混淆，slice方法用于返回数组中一个片段或子数组，如果只写一个参数返回参数到数组结束部分，如果参数出现负数，则从数组尾部计数（-3意思是数组倒第三个，一般人不会这么干，但是在不知道数组长度，想舍弃后n个的时候有些用，不过数组长度很好知道。。。。，好纠结的用法），如果start大于end返回空数组，值得注意的一点是slice不会改变原数组，而是返回一个新的数组
(通俗的来讲，抽出一个数组，start是开始的数组位置,end是结束的数组位置，如果end为负就是倒着数，start>end(除非为负值)，不会影响原数组)

  var a = new Array(1,2,3,4,5);
  console.log(a); //[1, 2, 3, 4, 5]
  console.log(a.slice(1,2));//2
  console.log(a.slice(1,-1));//[2, 3, 4]
  console.log(a.slice(3,2));//[]
  console.log(a); //[1, 2, 3, 4, 5]

• concat(array)

看起来像是剪切，但这个真不是形声字，concat方法用于拼接数组，a.concat(b)返回一个a和b共同组成的新数组，同样不会修改任何一个原始数组，也不会递归连接数组内部数组

  var a = new Array(1,2,3,4,5);
  var b = new Array(6,7,8,9);
  console.log(a.concat(b));//[1, 2, 3, 4, 5, 6, 7, 8, 9]
  console.log(a); //[1, 2, 3, 4, 5]
  console.log(b); //[6, 7, 8, 9]

• reverse()

方法用于将数组逆序，与之前不同的是它会修改原数组

  var a = new Array(1,2,3,4,5);
  a.reverse();
  console.log(a); //[5, 4, 3, 2, 1]

同样，当数组索引不是连续或以0开始，结果需要注意

  var a = new Array();
  a[2]=2;
  a[3]=3;
  a[7]=4;
  a[8]=5;

  a.reverse();

• sort

sort方法用于对数组进行排序，当没有参数的时候会按字母表升序排序，如果含有undefined会被排到最后面，对象元素则会调用其toString方法，如果想按照自己定义方式排序，可以传一个排序方法进去，很典型的策略模式，同样sort会改变原数组。

  var a=new Array(5,4,3,2,1);
  a.sort();
  console.log(a);//[1, 2, 3, 4, 5]

但是。。。

  var a=new Array(7,8,9,10,11);
  a.sort();
  console.log(a);//[10, 11, 7, 8, 9]

因为按照字母表排序，7就比10大了，这时候我们需要传入自定义排序函数

  var a = new Array(7,8,9,10,11);

  a.sort(function(v1,v2){
      return v1-v2;
  });
  console.log(a);//[7, 8, 9, 10, 11]

sort内部使用快速排序，每次比较两个元素大小的时候如果没有参数，则直接判断字母表，如果有参数，则把正在比较的两个参数传入自定义方法并调用（正在比较的两个数会传给自定义方法的v1、v2），如果返回值大于0表示v1 > v2，如果等于0，表示v1 = v2，如果小于0，表示v1 < v2，其实我们传入的方法就是告诉sort怎么比较两个元素谁大谁小，至于排序移动元素过程人家写好了

2、写一个函数，操作数组，数组中的每一项变为原来的平方，在原数组上操作

  function squareArr(arr){
    for(var i = 0 ; i<arr.length;i++){
      arr[i]=arr[i]*arr[i];
    }
    return arr
  }
  var arr = [2, 4, 6]
  squareArr(arr)
  console.log(arr) // [4, 16, 36]

3、写一个函数，操作数组，返回一个新数组，新数组中只包含正数，原数组不变

  function filterPositive(arr){
    var newArr = [];
    for(var i = 0; i < arr.length; i++){
        if(arr[i] > 0 && arr[i] !== true){
            newArr.push(arr[i]);
        }
    }
    return nweArr;
    }
  var arr = [3, -1,  2,  '饥人谷', true]
  var newArr = filterPositive(arr)
  console.log(newArr) //[3, 2]
  console.log(arr) //[3, -1,  2,  '饥人谷', true]

Date

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

  function getChintv(dateStr){
    var targetDate = new Date(dateStr);    //获取截止时间
    var presentDate = new Date();    //当前时间设置
    var offset = Math.abs(targetDate-presentDate);    
    //目标时间减去当前时间

    var totalSeconds = Math.abs(offset/1000);  //总毫秒转化为总秒数
    var second = Math.floor(totalSeconds%60);  //求余,得到秒数
    var totalMinutens = totalSeconds/60;    //总秒数转为总分钟
    var minuten = Math.floor(totalMinutens%60);  //求余，得到分钟
    var totalHours = totalMinutens/60;  //总分钟数转为总小时数
    var hours = Math.floor(totalHours%60);  //求余，得到小时
    var totalDays = totalHours/60;  //总小时数转为总天数
    var days = Math.floor(totalDays%24);  //求余，得到天数
    
    return days + '天' + hours + '小时' + minuten + '分' + second + '秒'
        }
  var d = getChintv('2017-10-8')
  console.log(d);  // 输出时间

2、把hh-mm-dd格式数字日期改成中文日期

  function getChsDate(str){
    var dict = ["零","一","二","三","四","五","六","七","八","九","十","十一",
    "十二","十三","十四","十五","十六","十七","十八","十九","二十","二十一",
    "二十二","二十三","二十四","二十五","二十六","二十七","二十八","二十九","三十",
    "三十一"];  //汉字数组
    var arr = str.split('-');    //去掉-，变为数组
    var totalYear = arr[0];    
    var totalMonth = arr[1];
    var totalDay = arr[2];

    var year = dict[totalYear[0]] + dict[totalYear[1]] + dict[totalYear[2]] 
               + dict[totalYear[3]] + '年';
    var month = dict[totalMonth[0]] + dict[totalMonth[1]] + '月';
    var day = dict[totalDay[0]] + dict[totalDay[1]]+'日'

    return year + month + day;
  }

  var str = getChsDate('2015-01-08');
  console.log(str);  // 二零一五年一月八日

3、写一个函数，参数为时间对象毫秒数的字符串格式，返回值为字符串。假设参数为时间对象毫秒数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 offset = Date.now()-time;
      if(offset<(60*1000)){
        console.log("刚刚")
      }else if(offset<(60*60*1000)){
        console.log(Math.floor(offset/(60*1000))+'分钟前')
      }else if(offset<(24*60*60*1000)){
        console.log(Math.floor(offset/(60*60*1000))+'小时前')
      }else if(offset<(30*24*60*60*1000)){
        console.log(Math.floor(offset/(24*60*60*1000))+'天前')
      }else if(offset<(12*30*24*60*60*1000)){
        console.log(Math.floor(offset/(30*24*60*60*1000))+'月前')
      }else{
        console.log(Math.floor(offset/(12*30*24*60*60*1000))+'年前')
      }
    }
  var str = friendlyDate( '1484286699422' ) //  6个月前
  var str2 = friendlyDate('1483941245793') //7个月前