关于javascript:JS中的Math-和-Date

3次阅读

共计 6968 个字符，预计需要花费 18 分钟才能阅读完成。

Math 和 Date

  • Math 是 js 的一个内置对象，提供了一堆的办法帮忙咱们操作 数字
  • Date 是 js 的一个内置构造函数，提供了一堆的办法帮忙咱们操作 工夫

Math

  • 没有什么多余的货色，就是一堆的办法来操作数字

random

  • Math.random() 这个办法是用来生成一个 0 ~ 1 之间的随机数
  • 每次执行生成的数字都不一样，然而肯定是 0 ~ 1 之间的

  • 生成的数字蕴含 0，然而不蕴含 1

    var num = Math.random()
console.log(num) // 失去一个随机数

round

  • Math.round() 是将一个小数 四舍五入 变成一个整数 

    var num = 10.1
console.log(Math.round(num)) // 10

var num2 = 10.6
console.log(Math.round(num2)) // 11

abs

  • Math.abs() 是返回一个数字的绝对值 

    var num = -10
console.log(math.abs(num)) // 10

ceil

  • Math.ceil() 是将一个小数 向上取整 失去的整数 

    var num = 10.1
console.log(Math.ceil(num)) // 11

var num2 = 10.9
console.log(Math.ceil(num2)) // 11

floor

  • Math.floor() 是将一个小数 向下取整 的到的整数 

    var num = 10.1
console.log(Math.floor(num)) // 10

var num2 = 10.9
console.log(Math.floor(num2)) // 10

max

  • Math.max() 失去的是你传入的几个数字之中最大的那个数字 

    console.log(Math.max(1, 2, 3, 4, 5)) // 5

min

  • Math.min() 失去的是你传入的几个数字之中最小的那个数字 

    console.log(Math.min(1, 2, 3, 4, 5)) // 1

PI

  • Math.PI 失去的是 π 的值，也就是 3.1415936...

    console.log(Math.PI) // 3.141592653589793
    • 因为计算机的计算精度问题，只能失去小数点后 15 位
    • 应用 Math.PI 的时候，是不须要加 () 的

数字转换进制

  1. toString() 办法能够在数字转成字符串的时候给出一个进制数

    • 语法：toString(你要转换的进制)

      var num = 100
console.log(num.toString(2)) // 1100100
console.log(num.toString(8)) // 144
console.log(num.toString(16)) // 64

  2. parseInt() 办法能够在字符串转成数字的时候把字符串当成多少进制转成十进制

    • 语法：parseInt(要转换的字符串，当作几进制来转换)

      var str = 100
console.log(parseInt(str, 8)) // 64 把 100 当作一个 八进制 的数字转换成 十进制 当前失去的
console.log(parseInt(str, 16)) // 256 把 100 当作 十六进制 的数字转换成 十进制 当前失去的
console.log(parseInt(str, 2)) // 4 把 100 当作 二进制 的数字转换成 十进制 当前失去的

Date

  • js 提供的内置构造函数，专门用来获取工夫的

new Date()

  • new Date() 在不传递参数的状况下是默认返回以后工夫 

    var time = new Date()
console.log(time) // 以后工夫 Fri Mar 01 2019 13:11:23 GMT+0800 (中国规范工夫)

  • new Date() 在传入参数的时候，能够获取到一个你传递进去的工夫 

    var time = new Date('2019-03-03 13:11:11')
console.log(time) // Sun Mar 03 2019 13:11:11 GMT+0800 (中国规范工夫)

  • new Date() 传递的参数有多种状况

    1. 传递两个数字，第一个示意年，第二个示意月份 

      var time = new Date(2019, 00) // 月份从 0 开始计数，0 示意 1 月，11 示意 12 月
console.log(time) // Tue Jan 01 2019 00:00:00 GMT+0800 (中国规范工夫)

    2. 传递三个数字，前两个不变，第三个示意该月份的第几天，从 1 到 31

      var time = new Date(2019, 00, 05) 
console.log(time) // Sat Jan 05 2019 00:00:00 GMT+0800 (中国规范工夫)

    3. 传递四个数字，前三个不变，第四个示意当天的几点，从 0 到 23

      var time = new Date(2019, 00, 05, 22) 
console.log(time) // Sat Jan 05 2019 22:00:00 GMT+0800 (中国规范工夫)

    4. 传递五个数字，前四个不变，第五个示意的是该小时的多少分钟，从 0 到 59

      var time = new Date(2019, 00, 05, 22, 33) 
console.log(time) // Sat Jan 05 2019 22:33:00 GMT+0800 (中国规范工夫)

    5. 传递六个数字，前五个不变，第六个示意该分钟的多少秒，从 0 到 59

      var time = new Date(2019, 00, 05, 22, 33, 55) 
console.log(time) // Sat Jan 05 2019 22:33:55 GMT+0800 (中国规范工夫)

    6. 传入字符串的模式 

      console.log(new Date('2019')) 
// Tue Jan 01 2019 08:00:00 GMT+0800 (中国规范工夫)
console.log(new Date('2019-02')) 
// Fri Feb 01 2019 08:00:00 GMT+0800 (中国规范工夫)
console.log(new Date('2019-02-03')) 
// Sun Feb 03 2019 08:00:00 GMT+0800 (中国规范工夫)
console.log(new Date('2019-02-03 13:')) 
// Sun Feb 03 2019 13:00:00 GMT+0800 (中国规范工夫)
console.log(new Date('2019-02-03 13:13:')) 
// Sun Feb 03 2019 13:13:00 GMT+0800 (中国规范工夫)
console.log(new Date('2019-02-03 13:13:13')) 
// Sun Feb 03 2019 13:13:13 GMT+0800 (中国规范工夫)

将日期字符串格式化成指定内容

  • 比方咱们失去的工夫字符串是 Sun Feb 03 2019 13:13:13 GMT+0800 (中国规范工夫)
  • 我指向失去这个日期中是那一年，咱们就要靠截取字符串的模式失去
  • 然而当初 js 为咱们提供了一系列的办法来失去外面的指定内容

getFullYear

  • getFullYear() 形式是失去指定字符串中的哪一年 

    var time = new Date(2019, 03, 03, 08, 00, 22)
console.log(time.getFullYear()) // 2019

getMonth

  • getMonth() 办法是失去指定字符串中的哪一个月份 

    var time = new Date(2019, 03, 03, 08, 00, 22)
console.log(time.getMonth()) // 3
    • 这里要有一个留神的中央
    • 月份是从 0 开始数的
    • 0 示意 1 月，1 示意 2 月，依此类推

getDate

  • getDate() 办法是失去指定字符串中的哪一天 

    var time = new Date(2019, 03, 03, 08, 00, 22)
console.log(time.getDate()) // 3

getHours

  • getHours() 办法是失去指定字符串中的哪小时 

    var time = new Date(2019, 03, 03, 08, 00, 22)
console.log(time.getHours()) // 8

getMinutes

  • getMinutes() 办法是失去指定字符串中的哪分钟 

    var time = new Date(2019, 03, 03, 08, 00, 22)
console.log(time.getMinutes()) // 0

getSeconds

  • getSeconds() 办法是失去指定字符串中的哪秒钟 

    var time = new Date(2019, 03, 03, 08, 00, 22)
console.log(time.getSeconds()) // 22

getDay

  • getDay() 办法是失去指定字符串以后日期是一周中的第几天（周日是 0，周六是 6）

    var time = new Date(2019, 03, 08, 08, 00, 22)
console.log(time.getDay()) // 1

getTime

  • getTime() 办法是失去执行工夫到 格林威治工夫 的毫秒数 

    var time = new Date(2019, 03, 08, 08, 00, 22)
console.log(time.getTime()) // 1554681622000

获取时间差

  • 是指获取两个工夫点之间相差的工夫
  • 在 js 中是不能用工夫间接做 减法 的
  • 咱们须要一些非凡的操作
  • 在编程的世界外面，有一个非凡的工夫，是 1970 年 01 月 01 日 00 时 00 分 00 秒
  • 这个工夫咱们叫做 格林威治工夫
  • 所有的编程世界外面，这个工夫都是一样的，而且 格林威治工夫 的数字是 0
  • 从 格林威治工夫 开始，每通过 1 毫秒，数字就会 + 1
  • 所以咱们能够获取到任意一个工夫节点到 格林威治工夫 的毫秒数
  • 而后在用两个毫秒数相减，就能失去两个工夫点之间相差的毫秒数
  • 咱们在通过这个毫秒数失去精确的工夫

计算时间差

  • 例如：咱们当初计算一下 2019-01-01 00:00:00 到 2019-01-03 04:55:34 的时间差

  1. 先获取两个工夫点到 格林威治工夫 的毫秒数 

    var time1 = new Date('2019-01-01 00:00:00')
var time2 = new Date('2019-01-03 04:55:34')

time1 = time1.getTime()
time2 = time2.getTime()

console.log(time1) // 1546272000000
console.log(time2) // 1546462534000

  2. 两个工夫相减，失去两个工夫点之间相差的毫秒数 

    var differenceTime = time2 - time1
console.log(differenceTime) // 190534000
    • 当初咱们计算出了两个工夫点之间相差的毫秒数

  3. 把咱们计算的毫秒数换算成工夫

    • 先计算出有多少天
    • 认为一天是 1000 * 60 * 60 * 24 毫秒

    • 用总的毫秒数除以一天的毫秒数，就能失去多少天了 

      var time1 = new Date('2019-01-01 00:00:00')
var time2 = new Date('2019-01-03 04:55:34')
time1 = time1.getTime()
time2 = time2.getTime()
var differenceTime = time2 - time1

// 计算整的天数
var day = differenceTime / (1000 * 60 * 60 * 24) // 2.20525462962963
day = Math.ceil(day) // 2
      • 因为失去的是有小数的天数，咱们向下取整，失去有多少个整的天数
    • 应用 differenceTime 减去两天所蕴含的毫秒数，剩下的就是不够一天的毫秒数
    • 用不够一天的毫秒数计算出有多少个小时
    • 因为一个小时是 1000 * 60 * 60 毫秒

    • 用不够一天的毫秒数除以一小时的毫秒数，就能失去多少小时了 

      var time1 = new Date('2019-01-01 00:00:00')
var time2 = new Date('2019-01-03 04:55:34')
time1 = time1.getTime()
time2 = time2.getTime()
var differenceTime = time2 - time1

// 计算整的天数
var day = differenceTime / (1000 * 60 * 60 * 24) // 2.20525462962963
day = Math.floor(day) // 2

// 计算整的小时数
var afterHours = differenceTime - (1000 * 60 * 60 * 24 * 2)
var hours = afterHours / (1000 * 60 * 60)
hours = Math.floor(hours) // 4
      • 和方才一样的情理，咱们须要向下取整
    • 同理，应用 afterHours – 4 个小时蕴含的毫秒数，剩下的就是不够一个小时的毫秒数
    • 用不够一个小时的毫秒数计算出有多少分钟
    • 因为一分钟是 1000 * 60 毫秒

    • 用不够一个小时的毫秒数除以一分钟的毫秒数就能失去多少分钟了 

      var time1 = new Date('2019-01-01 00:00:00')
var time2 = new Date('2019-01-03 04:55:34')
time1 = time1.getTime()
time2 = time2.getTime()
var differenceTime = time2 - time1

// 计算整的天数
var day = differenceTime / (1000 * 60 * 60 * 24) // 2.20525462962963
day = Math.floor(day) // 2

// 计算整的小时数
var afterHours = differenceTime - (1000 * 60 * 60 * 24 * 2)
var hours = afterHours / (1000 * 60 * 60)
hours = Math.floor(hours) // 4

// 计算整分钟数
var afterMinutes = afterHours - (1000 * 60 * 60 * 4)
var minutes = afterMinutes / (1000 * 60)
minutes = Math.floor(minutes) // 55

    • 和之前一样的情理计算出秒 

      var time1 = new Date('2019-01-01 00:00:00')
var time2 = new Date('2019-01-03 04:55:34')
time1 = time1.getTime()
time2 = time2.getTime()
var differenceTime = time2 - time1

// 计算整的天数
var day = differenceTime / (1000 * 60 * 60 * 24) // 2.20525462962963
day = Math.floor(day) // 2

// 计算整的小时数
var afterHours = differenceTime - (1000 * 60 * 60 * 24 * 2)
var hours = afterHours / (1000 * 60 * 60)
hours = Math.floor(hours) // 4

// 计算整分钟数
var afterMinutes = afterHours - (1000 * 60 * 60 * 4)
var minutes = afterMinutes / (1000 * 60)
minutes = Math.floor(minutes) // 55

// 计算整秒数
var afterSeconds = afterMinutes - (1000 * 60 * 55)
var seconds = afterSeconds / 1000
seconds = Math.floor(seconds) // 34

    • 最初，同理减去整秒的数，剩下的就是毫秒数 

      var time1 = new Date('2019-01-01 00:00:00')
var time2 = new Date('2019-01-03 04:55:34')
time1 = time1.getTime()
time2 = time2.getTime()
var differenceTime = time2 - time1

// 计算整的天数
var day = differenceTime / (1000 * 60 * 60 * 24) // 2.20525462962963
day = Math.floor(day) // 2

// 计算整的小时数
var afterHours = differenceTime - (1000 * 60 * 60 * 24 * 2)
var hours = afterHours / (1000 * 60 * 60)
hours = Math.floor(hours) // 4

// 计算整分钟数
var afterMinutes = afterHours - (1000 * 60 * 60 * 4)
var minutes = afterMinutes / (1000 * 60)
minutes = Math.floor(minutes) // 55

// 计算整秒数
var afterSeconds = afterMinutes - (1000 * 60 * 55)
var seconds = afterSeconds / 1000
seconds = Math.floor(seconds) // 34

// 计算毫秒数
var milliSeconds = afterSeconds - (1000 * 34) // 0

    • 最初咱们把后果输入一下就能够了 

      document.write('2019-01-01 00:00:00 和 2019-01-03 04:55:34 之间相差')
document.write(day + '天' + hours + '小时' + minutes + '分钟' + seconds + '秒' + milliSeconds + '毫秒')
正文完
javascript
发表至： javascript
2021-08-18
 0
关于javascript:关于作者
关于javascript:在vue中封装的弹窗组件使用队列模式实现
关于javascript:JavaScript-运行机制-串联一堆散装概念
关于javascript:用调度场算法计算表达式的值javascript实现
-「」

Just My Socks（注册教程 内含优惠码）

Just My Socks