Math对象、数组、日期函数

一、Math习题练习

Math是JavaScript的内置对象，提供一系列数学常数和数学方法。该对象不是构造函数，不能生成实例，所有的属性和方法都必须在Math对象上调用。

new Math()
// TypeError: object is not a function

上面代码表示，Math不能当作构造函数用。

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

function Random(min,max) {
    var val= Math.floor(Math.random()*(max-min))+min;
    return val;
}
Random(15,25) //22

------------------------------------------------------------------------
function rand(min, max){
  var count = 10000;
  var obj = {};
  for(var i=0; i<count; i++){
    var randInt = Math.floor(Math.random()*(max - min))+min;
    var key = randInt;
    if(obj[key] === undefined){
      obj[key] = 1;
    }else{
      obj[key]++;
    }
  }
  for(key in obj){
    obj[key] = obj[key] / count;
  }
    console.log(obj);
}

rand(15, 25)

/* 运行10000次，随机整数的概率
15: 0.0997
16: 0.102
17: 0.1058
18: 0.103
19: 0.1005
20: 0.1014
21: 0.0987
22: 0.094
23: 0.0935
24: 0.1014
包括 min 不包括 max，符合要求
*/

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

function rand2(min, max){
    var randInt = Math.floor(Math.random()*(max + 1 - min))+min;
    return randInt;
}

rand2(15, 25)   // 23
-----------------------------------------------------------------------------------
检验函数符不符合要求，运行10000次测试随机整数的概率
function rand2(min, max){
  var count = 10000;
  var obj = {};
  for(var i=0; i<count; i++){
    var randInt = Math.floor(Math.random()*(max + 1 - min))+min;
    var key = randInt;
    if(obj[key] === undefined){
      obj[key] = 1;
    }else{
      obj[key]++;
    }
  }
  for(key in obj){
    obj[key] = obj[key] / count;
  }
    console.log(obj);
}

rand2(15, 25)

/*运行10000次，随机整数的概率
15: 0.0894
16: 0.0905
17: 0.0872
18: 0.0913
19: 0.0904
20: 0.0904
21: 0.0883
22: 0.0916
23: 0.0971
24: 0.0933
25: 0.0905
包括 min 也包括 max 符合要求
*/

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

function randomStr(n){
  var dict = "0123456789" + 
             "abcdefghijklmnopqrstuvwxyz" + 
             "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  var str = "";
  for(var i=0; i<n; i++){
    str += dict[Math.floor(Math.random()*dict.length)];
  }
  return str;
}

randomStr(10)    
// "ybF5F5BOPS" 随机生成一个长度为 10 的字符串

var count = 5;
for(var j=0; j<count; j++){
  console.log(randomStr(10));
}
/*运行5次，生成5个这样的字符串
anqWd8gy78
EN48PbSroF
8fZQMYU4DB
Gi6p5e4aIf
k5nkUM8Xms
*/

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

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

var count = 5;
for(var j=0; j<count; j++){
  ip = getRandIP()
  console.log(ip)
}
/*运行5次，产生5个随机ip
14.26.217.81
45.88.162.135
114.152.134.49
23.225.5.197
43.189.153.7
*/

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

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

var count = 5;
for(var j=0; j<count; j++){
  color = getRandColor();
  console.log(color);
}
/*运行5次，产生5个随机颜色字符串
#881727
#21db5d
#8f7fd1
#8e0535
#465030
*/

二、数组习题练习

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

push()

push方法用于在数组的末端添加一个或多个元素，并返回添加新元素后的数组长度。注意，该方法会改变原数组。

var a = [];

a.push(1) // 1
a.push('a') // 2
a.push(true, {}) // 4
a // [1, 'a', true, {}]

如果需要合并两个数组，可以这样写。

var a = [1, 2, 3];
var b = [4, 5, 6];

Array.prototype.push.apply(a, b)
// 或者
a.push.apply(a, b)

// 上面两种写法等同于
a.push(4, 5, 6)

a // [1, 2, 3, 4, 5, 6]

push方法还可以用于向对象添加元素，添加后的对象变成类似数组的对象，即新加入元素的键对应数组的索引，并且对象有一个length属性。

var a = {a: 1};

[].push.call(a, 2);
a // {a:1, 0:2, length: 1}

[].push.call(a, [3]);
a // {a:1, 0:2, 1:[3], length: 2}

pop()

pop方法用于删除数组的最后一个元素，并返回该元素。注意，该方法会改变原数组。

var a = ['a', 'b', 'c'];

a.pop() // 'c'
a // ['a', 'b']

对空数组使用pop方法，不会报错，而是返回undefined。

[].pop() // undefined

push和pop结合使用，就构成了“后进先出”的栈结构（stack）。

shift()

shift方法用于删除数组的第一个元素，并返回该元素。注意，该方法会改变原数组。

var a = ['a', 'b', 'c'];

a.shift() // 'a'
a // ['b', 'c']

shift方法可以遍历并清空一个数组。

var list = [1, 2, 3, 4, 5, 6];
var item;

while (item = list.shift()) {
  console.log(item);
}

list // []

push和shift结合使用，就构成了“先进先出”的队列结构（queue）。

unshift()

unshift方法用于在数组的第一个位置添加元素，并返回添加新元素后的数组长度。注意，该方法会改变原数组。

var a = ['a', 'b', 'c'];

a.unshift('x'); // 4
a // ['x', 'a', 'b', 'c']

unshift方法可以在数组头部添加多个元素。

var arr = [ 'c', 'd' ];
arr.unshift('a', 'b') // 4
arr // [ 'a', 'b', 'c', 'd' ]

join()

join方法以参数作为分隔符，将所有数组成员组成一个字符串返回，原数组不变。如果不提供参数，默认用逗号分隔。

var a = [1, 2, 3, 4];

a.join(' ') // '1 2 3 4'
a.join(' | ') // "1 | 2 | 3 | 4"
a.join() // "1,2,3,4"
a //[1,2,3,4]

如果数组成员是undefined或null或空位，会被转成空字符串。

[undefined, null].join('#')
// '#'

['a',, 'b'].join('-')
// 'a--b'
['a','', 'b'].join('-')
"a--b"
['a',' ', 'b'].join('-')
"a- -b" //" "双引号中间有一个空格的字符串被转换后为一个空格

通过call方法，这个方法也可以用于字符串。

Array.prototype.join.call('hello', '-')
// "h-e-l-l-o"

join方法也可以用于类似数组的对象。

var obj = { 0: 'a', 1: 'b', length: 2 };
Array.prototype.join.call(obj, '-')
// 'a-b'

slice()

slice方法用于提取原数组的一部分，返回一个新数组，原数组不变。

它的第一个参数为起始位置（从0开始），第二个参数为终止位置（但该位置的元素本身不包括在内）。如果省略第二个参数，则一直返回到原数组的最后一个成员。

// 格式
arr.slice(start_index, upto_index);

// 用法
var a = ['a', 'b', 'c'];

a.slice(0) // ["a", "b", "c"]
a.slice(1) // ["b", "c"]
a.slice(1, 2) // ["b"]
a.slice(2, 6) // ["c"]
a.slice() // ["a", "b", "c"]

如果slice()方法的参数中有一个负数，则用数组长度加上该负数来确定相应的位置。例如，在一个包含5项的数组上调用slice(-2，-1)与调用slice(3,4)得到的结果相同。

var b = [1,2,3,4,5];

b.slice(-2,-1) //4
b.slice(3,4) //4

如果参数值大于数组成员的个数，或者第二个参数小于第一个参数，则返回空数组。

var a = ['a', 'b', 'c'];
a.slice(4) // []
a.slice(2, 1) // []

slice方法的一个重要应用，是将类似数组的对象转为真正的数组。

Array.prototype.slice.call({ 0: 'a', 1: 'b', length: 2 })
// ['a', 'b']

Array.prototype.slice.call(document.querySelectorAll("div"));
Array.prototype.slice.call(arguments);

上面代码的参数都不是数组，但是通过call方法，在它们上面调用slice方法，就可以把它们转为真正的数组

splice()

splice方法用于删除原数组的一部分成员，并可以在被删除的位置添加入新的数组成员，返回值是被删除的元素。注意，该方法会改变原数组。

splice的第一个参数是删除的起始位置，第二个参数是被删除的元素个数。如果后面还有更多的参数，则表示这些就是要被插入数组的新元素。

// 格式
arr.splice(index, count_to_remove, addElement1, addElement2, ...);

// 用法
var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(4, 2) // ["e", "f"]
a // ["a", "b", "c", "d"]

上面代码从原数组4号位置，删除了两个数组成员。

var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(4, 2, 1, 2) // ["e", "f"]
a // ["a", "b", "c", "d", 1, 2]

上面代码除了删除成员，还插入了两个新成员。

起始位置如果是负数，就用数组的长度加上该负数来确定相应的起始位置位置。

var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(-4, 2) // ["c", "d"]
//等同于
var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(2,2) // ["c", "d"]

如果只是单纯地插入元素，splice方法的第二个参数可以设为0。

var a = [1, 1, 1];

a.splice(1, 0, 2) // []
a // [1, 2, 1, 1]

如果只提供第一个参数，等同于将原数组在指定位置拆分成两个数组。

var a = [1, 2, 3, 4];
a.splice(2) // [3, 4]
a // [1, 2]

用splice函数实现push、pop、shift、unshift方法
实现push方法:

function push(arr,ele){
  arr.splice(-1,0,ele);
  return arr.length;
}

实现pop方法:

function pop(arr){
  return arr.splice(-1,1);
}

实现shift方法:

function shift(arr){
  return arr.splice(0,1);
}

实现unshift方法:

function unshift(arr,ele){
  arr.splice(0,0,ele);
  return arr.length;
}

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

function squareArr(arr){
}
var arr = [2, 4, 6]
squareArr(arr)
console.log(arr) // [4, 16, 36]
---------------------------------------------------
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 arr = [3, -1,  2,  '前端', true]
var newArr = filterPositive(arr)
console.log(newArr) //[3, 2]
console.log(arr) //[3, -1,  2,  '前端', true]
---------------------------------------------------------
function filterPositive(arr){
    var newArr = []
    for(var i=0; i<arr.length; i++) {
        if(typeof arr[i] ==='number' && arr[i]>0){
             newArr.push(arr[i]);
        } 
    }
    return newArr;
}
var arr = [3, -1,  2,  '前端', true]
var newArr = filterPositive(arr)
console.log(newArr) //[3, 2]
console.log(arr) //[3, -1,  2,  '前端', true]

三、Data习题练习

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

var str = getChIntv("2018-02-15");
console.log(str);  // 距除夕还有 20 天 15 小时 20 分 10 秒
-----------------------------------------------------------
function getChIntv(timeStr){
    var timeEnd = new Date(timeStr).getTime();
    var timeStart = new Date().getTime();
    var offsetTime = timeEnd - timeStart;
    var days = parseInt(offsetTime / (24*60*60*1000));
    var seconds = offsetTime % (24*60*60*1000);
    var hours =  parseInt(offsetTime % (24*60*60*1000) / (60*60*1000));
    var minutes = parseInt(offsetTime % (24*60*60*1000) % (60*60*1000) / (60*1000));
    var second = parseInt(offsetTime % (24*60*60*1000) % (60*60*1000) % (60*1000) / 1000);
    var str = '距除夕还有'+days+'天'+hours+'小时'+minutes+'分'+second+'秒';
    return str;
}
var str = getChIntv("2018-02-15");
console.log(str);

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

var str = getChsDate('2015-01-08');
console.log(str);  // 二零一五年一月八日
-------------------------------------------------------
function getChsDate(str) {
    var arr = str.split('-');
    var yearStr = arr[0];
    var monthStr = arr[1];
    var dayStr = arr[2];
    var dict = ["零","一","二","三","四","五","六","七","八","九","十","十一","十二","十三","十四","十五","十六","十七","十八","十九","二十","二十一","二十二","二十三","二十四","二十五","二十六","二十七","二十八","二十九","三十","三十一"];
    var newyears = dict[parseInt(yearStr[0])]+dict[parseInt(yearStr[1])]+dict[parseInt(yearStr[2])]+dict[parseInt(yearStr[3])]+'年';
    var newmonths = dict[parseInt(monthStr)]+'月';
    var newdays = dict[parseInt(dayStr)]+'日';
    var Str = newyears+newmonths+newdays;
    return Str;
}
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 str = friendlyDate( '1484286699422' ) //  1分钟前
var str2 = friendlyDate('1483941245793') //4天前
--------------------------------------------------------------------
function friendlyDate(time){
    var timeStart = new Date().getTime();
    var offTime = time - timeStart;
    if (offTime < (60*1000)) {
        console.log('刚刚');
    } else if (offTime < (60*60*1000)) {
        console.log('3分钟前');
    } else if (offTime < (24*60*60*1000)) {
        console.log('8小时前');
    } else if (offTime < (30*24*60*60*1000)) {
        console.log('3天前');
    } else if (offTime < (12*30*24*60*60*1000)) {
        console.log('2个月前');
    } else {
        console.log('8年前');
    }
}
var str = friendlyDate( '1484286699422' ) //  刚刚
var str2 = friendlyDate('1483941245793') // 8年前