前端小栈

Appearance

Return to top
On this page

Math

属性

Math.E 自然对数的底数，即常量 e 的值

Math.LN10 10 的自然对数

Math.LN2 2 的自然对数

Math.LOG2E 以 2 为底的对数

Math.LOG110E 以 10 为底 e 的对数

Math.PI π 的值

Math.SQRT1_2 1/2 的平方根（即 2 的平方根的倒数）

Math.SQRT2 2 的平方根

方法

取最值

min()和max() 用于确定一组数值中的最小值和最大值，都可接受任意多个数值参数，改造为传递数组为参数

let array1 = [1, 2, 3]
Math.min.apply(Math / null, array1)
Math.max.apply(Math / null, array1)

四舍五入（小数取整）

Math.ceil() 向上取整

Math.floor() 向下取整

Math.round() 标准四舍五入

随机数

Math.random() 返回大于等于 0 小于 1 的随机数

从某个整数范围内随机选择一个值：

值 = Math.floor(Math.random() * 可能值得总数 + 第一个可能的值)
Math.floor(Math.random * 10 + 1) 从1到10之间去随机数，包括1和10

随机数通用函数

function selectFrom(lowerValue, upperValue) {
  var choices = upperValue - lowerValue + 1
  return Math.floor(Math.random() * choices + lowerValue)
}

其他方法

Math.abs() 绝对值

Math.pow() 函数返回基数（base）的指数（exponent）次幂

数字转字符串

toFixed() 参数为保留几位小数，不够 0 时自动补 0，自动四舍五入，如

var num1 = 10
console.log(num1.toFixed(2)) // "10.00"
var num2 = 10.005
console.log(num2.toFixed(2)) // "10.01"

数值、布尔值、对象和字符串都有toString()方法，但null和undefined没有，会报错

在不知道要转换的值是不是null或undefined的情况下，可以用转型函数String()，该函数转换规则如下：

  • 如果值有toString()方法，则调用该方法

  • 如果值为null，则返回null

  • 如果值为undefined，则返回undefined

任何涉及NaN的操作都会返回NaN，任何数值除以非数值都会返回 NaN，NaN 与任何值都不相等，包括它本身

字符串转换为数值

Number() 转型函数，可用于任何数据类型，转换规则过于复杂

parseInt() 专门用于字符串转数值，忽略前面的空格，直到找到第一个非空格字符，即若遇到小数点则停止解析，转换空字符串会返回NaN,第二个参数为转换的基数（即几进制，默认为十进制），例：

var num1 = parseInt('123blue') // 123
var num2 = parseInt('') // NaN
var num3 = parseInt(22.5) // 22
var num4 = parseInt('22.5') // 22
var num5 = parseFloat('0123') // 123

parseFloat 专门用于字符串转数值，忽略前面的空格，直到找到第一个无效的浮点数字字符位置，即可以字符中的第一个小数点是有效的，第二个小数点是无效的，无第二个参数，默认是十进制，例：

var num1 = parseFloat('123blue') // 123
var num2 = parseFloat(22.5) // 22.5
var num3 = parseFloat('22.5') // 22.5
var num4 = parseFloat('0123') // 123

工具函数 

const $h = {
  //除法函数，用来得到精确的除法结果
  //说明：javascript的除法结果会有误差，在两个浮点数相除的时候会比较明显。这个函数返回较为精确的除法结果。
  //调用：$h.Div(arg1,arg2)
  //返回值：arg1除以arg2的精确结果
  Div: function (arg1, arg2) {
    arg1 = parseFloat(arg1)
    arg2 = parseFloat(arg2)
    var t1 = 0,
      t2 = 0,
      r1,
      r2
    try {
      t1 = arg1.toString().split('.')[1].length
    } catch (e) {}
    try {
      t2 = arg2.toString().split('.')[1].length
    } catch (e) {}
    r1 = Number(arg1.toString().replace('.', ''))
    r2 = Number(arg2.toString().replace('.', ''))
    return this.Mul(r1 / r2, Math.pow(10, t2 - t1))
  },
  //加法函数，用来得到精确的加法结果
  //说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。
  //调用：$h.Add(arg1,arg2)
  //返回值：arg1加上arg2的精确结果
  Add: function (arg1, arg2) {
    arg2 = parseFloat(arg2)
    var r1, r2, m
    try {
      r1 = arg1.toString().split('.')[1].length
    } catch (e) {
      r1 = 0
    }
    try {
      r2 = arg2.toString().split('.')[1].length
    } catch (e) {
      r2 = 0
    }
    m = Math.pow(100, Math.max(r1, r2))
    return (this.Mul(arg1, m) + this.Mul(arg2, m)) / m
  },
  //减法函数，用来得到精确的减法结果
  //说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的减法结果。
  //调用：$h.Sub(arg1,arg2)
  //返回值：arg1减去arg2的精确结果
  Sub: function (arg1, arg2) {
    arg1 = parseFloat(arg1)
    arg2 = parseFloat(arg2)
    var r1, r2, m, n
    try {
      r1 = arg1.toString().split('.')[1].length
    } catch (e) {
      r1 = 0
    }
    try {
      r2 = arg2.toString().split('.')[1].length
    } catch (e) {
      r2 = 0
    }
    m = Math.pow(10, Math.max(r1, r2))
    //动态控制精度长度
    n = r1 >= r2 ? r1 : r2
    return ((this.Mul(arg1, m) - this.Mul(arg2, m)) / m).toFixed(n)
  },
  //乘法函数，用来得到精确的乘法结果
  //说明：javascript的乘法结果会有误差，在两个浮点数相乘的时候会比较明显。这个函数返回较为精确的乘法结果。
  //调用：$h.Mul(arg1,arg2)
  //返回值：arg1乘以arg2的精确结果
  Mul: function (arg1, arg2) {
    arg1 = parseFloat(arg1)
    arg2 = parseFloat(arg2)
    var m = 0,
      s1 = arg1.toString(),
      s2 = arg2.toString()
    try {
      m += s1.split('.')[1].length
    } catch (e) {}
    try {
      m += s2.split('.')[1].length
    } catch (e) {}
    return (Number(s1.replace('.', '')) * Number(s2.replace('.', ''))) / Math.pow(10, m)
  }
}