精华内容
下载资源
问答
  • Math是一个内置对象,它拥有一些数学常数属性和数学函数方法。Math 不是一个函数对象。Math 用于 Number 类型。 Math 不是一个构造器。Math 的所有属性与方法都是静态的。Math 的常量是使用 JavaScript 中的全精度...

    写在前面,最最常用几个方法:

    绝对值:Math.abs(x)
    最大值:Math.max([x[, y[,]]])
    最小值:Math.min([x[, y[,]]])
    随机值:Math.random()
    向上取整:Math.ceil(x)
    向下取整:Math.floor(x)
    四舍五入:Math.round(x)
    

    1.概述

    Math是一个内置对象,它拥有一些数学常数属性和数学函数方法。Math 不是一个函数对象。Math 用于 Number 类型。

    Math 不是一个构造器。Math 的所有属性与方法都是静态的。Math 的常量是使用 JavaScript 中的全精度浮点数来定义的。

    2.方法

    需要注意的是,三角函数 sin()cos()tan()asin()acos()atan()atan2()返回的值是弧度而非角度。

    若要转换,弧度除以 (Math.PI / 180) 即可转换为角度,同理,角度乘以这个数则能转换为弧度。

    很多 Math 函数都有一个精度,而且这个精度在不同实现中也是不相同的。这意味着不同的浏览器会给出不同的结果,甚至,在不同的系统或架构下,相同的 JS 引擎也会给出不同的结果!

    2.1 常用方法

    Math.abs(x)
      返回一个数的绝对值。

    Math.abs('-1');     // 1
    Math.abs(-2);       // 2
    Math.abs(null);     // 0
    Math.abs("string"); // NaN
    Math.abs();         // NaN
    

    Math.ceil(x)
      返回大于一个数的最小整数,即一个数向上取整后的值。

    Math.ceil(.95);		// expected output: 1
    Math.ceil(4);		// expected output: 4
    Math.ceil(7.004);	// expected output: 8
    Math.ceil(-7.004);	// expected output: -7
    

    Math.floor(x)
      返回小于一个数的最大整数,即一个数向下取整后的值。

    Math.floor( 45.95); 	// 45 
    Math.floor( 45.05);		// 45 
    Math.floor( 4 ); 		// 4 
    Math.floor(-45.05); 	// -46 
    Math.floor(-45.95); 	// -46
    

    Math.max([x[, y[, …]]])
      返回零到多个数值中最大值。

    Math.max(10, 20);   //  20
    Math.max(-10, -20); // -10
    Math.max(-10, 20);  //  20
    

    Math.min([x[, y[, …]]])
      返回零到多个数值中最小值。

    Math.max(10, 20);   //  10
    Math.max(-10, -20); // -20
    Math.max(-10, 20);  //  -10
    

    Math.random()
      返回一个 0 到 1 ([0, 1))之间的伪随机数。

    Math.random();			// eg:0.3807786079066584
    

    Math.round(x)
      返回四舍五入后的整数。

    Math.round(20.49);		// 20
    Math.round(20.5);		// 21
    Math.round(-20.5);		// -20
    Math.round(-20.51);		// -21
    
    2.2 其余方法

    Math.acos(x)
      返回一个数的反余弦值。

    Math.acos(-2);  // NaN
    Math.acos(-1);  // 3.141592653589793
    Math.acos(0);   // 1.5707963267948966
    Math.acos(0.5); // 1.0471975511965979
    Math.acos(1);   // 0
    Math.acos(2);   // NaN
    

    对于小于 -1 或大于 1 的值,Math.acos 返回 NaN

    Math.acosh(x)
      返回一个数的反双曲余弦值。

    Math.acosh(0.5); // NaN
    Math.acosh(1);   // 0
    Math.acosh(2);   // 1.3169578969248166
    

    当参数小于1时, Math.acosh()将返回NaN

    Math.asin(x)
      返回一个数的反正弦值。

    Math.asin(-2);  // NaN
    Math.asin(-1);  // -1.5707963267948966 (-pi/2)
    Math.asin(0);   // 0
    Math.asin(0.5); // 0.5235987755982989
    Math.asin(1);   // 1.570796326794897 (pi/2)
    Math.asin(2);   // NaN
    

    对于小于 -1 或大于 1 的参数值,Math.asin 返回 NaN

    Math.asinh(x)
      返回一个数的反双曲正弦值。

    Math.asinh(1);  // 0.881373587019543
    Math.asinh(0);  // 0
    

    Math.atan(x)
      返回一个数的反正切值。

    Math.atan(1);  // 0.7853981633974483
    Math.atan(0);  // 0
    

    Math.atanh(x)
      返回一个数的反双曲正切值。

    Math.atanh(-2);  // NaN
    Math.atanh(-1);  // -Infinity
    Math.atanh(0);   // 0
    Math.atanh(0.5); // 0.5493061443340548
    Math.atanh(1);   // Infinity
    Math.atanh(2);   // NaN
    

    对于大于1或是小于-1的值,函数返回 NaN

    Math.atan2(y, x)
      返回 y/x 的反正切值。

    Math.atan2(90, 15) // 1.4056476493802699
    Math.atan2(15, 90) // 0.16514867741462683
    
    Math.atan2( ±0, -0 )               // ±PI.
    Math.atan2( ±0, +0 )               // ±0.
    Math.atan2( ±0, -x )               // ±PI for x > 0.
    Math.atan2( ±0, x )                // ±0 for x > 0.
    Math.atan2( -y, ±0 )               // -PI/2 for y > 0.
    Math.atan2( y, ±0 )                // PI/2 for y > 0.
    Math.atan2( ±y, -Infinity )        // ±PI for finite y > 0.
    Math.atan2( ±y, +Infinity )        // ±0 for finite y > 0.
    Math.atan2( ±Infinity, x )         // ±PI/2 for finite x.
    Math.atan2( ±Infinity, -Infinity ) // ±3*PI/4.
    Math.atan2( ±Infinity, +Infinity ) // ±PI/4.
    

    Math.cbrt(x)
      返回一个数的立方根。cbrt 是 “cube root” 的缩写, 意思是立方根。

    Math.cbrt(NaN); // NaN
    Math.cbrt(-1); // -1
    Math.cbrt(-0); // -0
    Math.cbrt(-Infinity); // -Infinity
    Math.cbrt(0); // 0
    Math.cbrt(1); // 1
    Math.cbrt(Infinity); // Infinity
    Math.cbrt(null); // 0
    Math.cbrt(2);  // 1.2599210498948734
    

    Math.clz32(x)
    返回一个 32 位整数的前导零的数量。

    Math.clz32(1)                // 31
    Math.clz32(1000)             // 22 
    Math.clz32()                 // 32
    [NaN, Infinity, -Infinity, 0, -0, null, undefined, "foo", {}, []].filter(function (n) {
      return Math.clz32(n) !== 32
    })                           // []
    Math.clz32(true)             // 31
    Math.clz32(3.5)        
    

    Math.cos(x)
    返回一个数的余弦值。

    Math.cos(0);           // 1
    Math.cos(1);           // 0.5403023058681398
    Math.cos(Math.PI);     // -1
    Math.cos(2 * Math.PI); // 1
    

    Math.cosh(x)
    返回一个数的双曲余弦值。可通过函数模拟实现:

    Math.cosh = Math.cosh || function(x) {
      var y = Math.exp(x);
      return (y + 1 / y) / 2;
    };
    
    Math.cosh(0);  // 1
    Math.cosh(1);  // 1.5430806348152437
    Math.cosh(-1); // 1.543080634815243
    

    Math.exp(x)
    返回欧拉常数的参数次方,Ex,其中 x 为参数,E 是欧拉常数(2.718…,自然对数的底数)。

    Math.exp(-1); // 0.36787944117144233
    Math.exp(0);  // 1
    Math.exp(1);  // 2.718281828459045
    

    Math.expm1(x)
    返回 exp(x) - 1 的值。其中 x 是该函数的参数, E 是自然对数的底数 2.718281828459045.

    Math.expm1(1)     // 1.7182818284590453
    Math.expm1(-38)   // -1
    Math.expm1("-38") // -1
    Math.expm1("foo") // NaN
    

    Math.fround(x)
      返回最接近一个数的单精度浮点型表示。

    数字1.5可以在二进制数字系统中精确表示,32位和64位的值相同:

    Math.fround(1.5); // 1.5
    Math.fround(1.5) === 1.5; // true
    

    但是,数字1.337却无法在二进制数字系统中精确表示,所以32位和64位的值是不同的:

    Math.fround(1.337); // 1.3370000123977661
    Math.fround(1.337) === 1.337; // false
    

    在某些精度不高的场合下,可以通过将二个浮点数转换成32位浮点数进行比较,以解决64位浮点数比较结果不正确的问题:

    0.1 + 0.2 == 0.3;    //false
    function equal(v1, v2) {
        return Math.fround(v1) == Math.fround(v2);
    }
    equal(0.1 + 0.2, 0.3);   //true
    

    Math.hypot([x[, y[, …]]])
      返回其所有参数平方和的平方根。

    Math.hypot(3, 4);        // 5
    Math.hypot(3, 4, 5);     // 7.0710678118654755
    Math.hypot();            // 0
    Math.hypot(NaN);         // NaN
    Math.hypot(3, 4, 'foo'); // NaN, +'foo' => NaN
    Math.hypot(3, 4, '5');   // 7.0710678118654755, +'5' => 5
    Math.hypot(-3);          // 3, the same as Math.abs(-3)
    

    Math.imul(x, y)
      返回 32 位整数乘法的结果。

    Math.log(x)
      返回一个数的自然对数(㏒e,即 ㏑)。

    Math.log(-1); // NaN, out of range
    Math.log(0); // -Infinity
    Math.log(1); // 0
    Math.log(10); // 2.302585092994046
    

    Math.log1p(x)
      返回一个数加 1 的和的自然对数(㏒e,即 ㏑)。

    Math.log1p(Math.E-1)  // 1
    Math.log1p(0)         // 0
    Math.log1p("0")       // 0
    Math.log1p(-1)        // -Infinity
    Math.log1p(-2)        // NaN
    Math.log1p("foo")     // NaN
    

    如果参数的值小于 -1, 则返回 NaN

    Math.log10(x)
      返回一个数以 10 为底数的对数。

    Math.log10(10)   // 1
    Math.log10(100)  // 2
    Math.log10("100")// 2
    Math.log10(1)    // 0
    Math.log10(0)    // -Infinity
    Math.log10(-2)   // NaN
    Math.log10("foo")// NaN
    

    Math.log2(x)
      返回一个数以 2 为底数的对数。

    Math.log2(2)     // 1
    Math.log2(1024)  // 10
    Math.log2(1)     // 0
    Math.log2(0)     // -Infinity
    Math.log2(-2)    // NaN
    Math.log2("1024")// 10
    Math.log2("foo") // NaN
    

    Math.pow(x, y)
      返回一个数的 y 次幂。

    Math.pow(7, 3);		// 343
    Math.pow(4, 0.5);	// 2
    Math.pow(7, -2);	// 0.02040816326530612 (1/49)
    Math.pow(-7, 0.5);	// NaN
    

    Math.random()
      返回一个 0 到 1 ([0, 1))之间的伪随机数。

    Math.random();			// eg:0.3807786079066584
    

    Math.sign(x)
      返回一个数的符号,得知一个数是正数、负数还是 0。此函数共有5种返回值, 分别是 1, -1, 0, -0, NaN. 代表的各是正数, 负数, 正零, 负零, NaN

    Math.sign(3);     //  1
    Math.sign(-3);    // -1
    Math.sign("-3");  // -1
    Math.sign(0);     //  0
    Math.sign(-0);    // -0
    Math.sign(NaN);   // NaN
    Math.sign("foo"); // NaN
    Math.sign();      // NaN
    

    Math.sin(x)
      返回一个数的正弦值。

    Math.sin(0);           // 0
    Math.sin(1);           // 0.8414709848078965
    Math.sin(Math.PI / 2); // 1
    

    Math.sinh(x)
      返回一个数的双曲正弦值。
    双曲正弦的图像如下:
    双曲图像

    Math.sinh(0)      // 0
    Math.sinh(1)      // 1.1752011936438014
    Math.sinh("-1")   // -1.1752011936438014
    Math.sinh("foo")  // NaN
    

    Math.sqrt(x)
      返回一个数的平方根。

    Math.sqrt(9); // 3
    Math.sqrt(2); // 1.414213562373095
    
    Math.sqrt(1);  // 1
    Math.sqrt(0);  // 0
    Math.sqrt(-1); // NaN
    Math.sqrt(-0); // -0
    

    Math.tan(x)
    返回一个数的正切值。
    Math.tanh(x)
      返回一个数的双曲正切值。

    Math.tanh(0);        // 0
    Math.tanh(Infinity); // 1
    Math.tanh(1);        // 0.7615941559557649
    

    Math.toSource()
      返回字符串 “Math”。
    Math.trunc(x)
      返回一个数的整数部分,仅仅是删除掉数字的小数部分和小数点,不管参数是正数还是负数。传入该方法的参数会被隐式转换成数字类型。

    Math.trunc(13.37)    // 13
    Math.trunc(42.84)    // 42
    Math.trunc(0.123)    //  0
    Math.trunc(-0.123)   // -0
    Math.trunc("-1.123") // -1
    Math.trunc(NaN)      // NaN
    Math.trunc("foo")    // NaN
    Math.trunc()         // NaN
    

    3.属性

    Math.E
      欧拉常数,也是自然对数的底数,约等于 2.718。
    Math.LN2
      2 的自然对数,约等于 0.693。
    Math.LN10
      10 的自然对数,约等于 2.303。
    Math.LOG2E
      以 2 为底的 E 的对数,约等于 1.443。
    Math.LOG10E
      以 10 为底的 E 的对数,约等于 0.434。
    Math.PI
      圆周率,一个圆的周长和直径之比,约等于 3.14159。
    Math.SQRT1_2
      二分之一 ½ 的平方根,同时也是 2 的平方根的倒数,约等于 0.707。
    Math.SQRT2
      2 的平方根,约等于 1.414。

    展开全文
  • Math类的取整方法

    2021-10-12 15:55:05
    Math类中提供了三个与取整有关的方法:ceil,floor,round,这些方法的作用于它们的英文名称的含义相对应,例如: ceil的英文意义是天花板,该方法就表示向上取整Math.ceil(11.3)的结果为12,Math.ceil(-11.6)的...

    Math类中提供了三个与取整有关的方法:ceil,floor,round,这些方法的作用于它们的英文名称的含义相对应,例如:

    • ceil的英文意义是天花板,该方法就表示向上取整,Math.ceil(11.3)的结果为12,Math.ceil(-11.6)的结果为-11;
    • floor的英文是地板,该方法就表示向下取整,Math.floor(11.6)的结果是11,Math.floor(-11.4)的结果-12;
    • 最难掌握的是round方法,他表示“四舍五入”,算法为Math.floor(x+0.5),即将原来的数字加上0.5后再向下取整,所以,Math.round(11.5)的结果是12,Math.round(-11.5)的结果为-11.Math.round( )符合这样的规律:小数点后大于5全部加,等于5正数加,小于5全不加。
    展开全文
  • JS中有个全局对象 用于普通的计算Math 他有一些方法,用于平时的计算,这里详细介绍几个常用的 Math.floor(x) // 返回小于x的最大整数 Math.foor(12.2) // 12 Math.foor(15 / 2) // 7 Math.ceil(x) // 返回大于x...

     

    JS中有个全局对象 用于普通的计算 Math

    它有一些方法,用于平时的计算,这里详细介绍几个常用的

    Math.floor(x) // 返回小于x的最大整数

    Math.floor(12.2)  // 12

    Math.floor(15 / 2)  // 7

     

    Math.ceil(x) // 返回大于x的最小整数

    Math.ceil(12.2)  // 13

    Math.ceil(15 / 2)  // 8

     

    Math.round()   返回四舍五入后的整数

    Math.round(12.2)  // 12

    Math.round(15 / 2)  // 8

     

    Math.random()  返回0到1之间的伪随机数.

    Math.cos(x) 返回x的余弦值

    Math.sin(x) 返回x的正弦值

     

    写博客不容易,如果对你有帮助请点个赞吧。有时间的可以评论一下。

    展开全文
  • JavaScript Math取整方法

    2020-12-06 21:08:27
    1. Math.floor() 向下取整 floor 地板的意思 向下取整就是 向下找取距离最近的整数并返回(往最小了取值) 例: console.log(Math.floor(1.1)); // 1 console.log(Math.floor(1.9)); // 1 console.log(Math.floor(-...

    1. Math.floor() 向下取整
    floor 地板的意思
    向下取整就是 向下找取距离最近的整数并返回(往最小了取值)

    例:
    
    console.log(Math.floor(1.1)); // 1
    console.log(Math.floor(1.9)); // 1
    console.log(Math.floor(-1.4)); // -2
    

    2.Math.ceil() 向上取整
    ceil 天花板的意思
    向上取整就是 向上找取距离最近的整数并返回(往最大了取值)

    例:
    
    console.log(Math.ceil(1.1)); // 2
    console.log(Math.ceil(1.9)); // 2
    console.log(Math.ceil(-1.5)); // -1
    

    3.Math.round() 四舍五入取整
    想必有着小学水平的人都知道四舍五入
    小数点后面小于五的都舍掉 大于等于五的向前进一位

    例:
    
    console.log(Math.round(1.1)); // 1
    console.log(Math.round(1.5)); // 2
    console.log(Math.round(1.9)); // 2
    console.log(Math.round(-1.1)); // -1
    console.log(Math.round(-1.9)); // -2
    

    四舍五入有一个需要注意的地方
    如果输入的值是负数 并且小数点后是5的 会出现错误 注意避免

    例:
    
    console.log(Math.round(-1.5)); // -1
    console.log(Math.round(-3.5)); // -3
    
    展开全文
  • java中Math取整方法

    2019-01-22 17:40:52
    java中Math取整方法 ** Math.ceil方法:表示向上取整。 例: System.out.println(Math.ceil(1.01)); System.out.println(Math.ceil(-1.01)); System.out.println(Math.ceil(1.5)); System.out.println(Math.ceil...
  • Java Math取整

    2017-08-30 16:47:48
    Math类的5种取整方法
  • 一,取整 1,取整 parseInt(1.5) // 1 Math.trunc(1.5) // 1 2,向上取整 Math.ceil(1.5) // 2 Math.ceil(-1.5) // -1 3,向下取整 Math.floor(1.5) // 1 Math.floor(-1.4) // -2 4,四舍五入取整 Math....
  • JAVA Math函数向上取整和向下取整

    万次阅读 2017-11-02 13:31:57
    JAVA Math函数向上取整和向下取整,向上取整Math.ceil(double a)向下取整Math.floor(double a)举例:double a=35; double b=20; double c = a/b; System.out.println(“c===>”+c); //1.75 System.out....
  • Math的几种取整方法

    千次阅读 2019-06-13 13:49:03
    Math类中提供了三个与取整有关的方法: Ceil(向上取整); Floor(向下取整); Round(四舍五入)。 ceil的英文意义是天花板,该方法就表示向上取整Math.ceil(11.3)的结果为12,Math.ceil(-11.3)的结果是...
  • Math中的取整函数

    千次阅读 热门讨论 2016-05-07 18:08:57
     Math类中提供了三个与取整有关的方法,即ceil、floor和round。它们函数作用和其英文意义差不多对应,ceil是天花板的意思,该方法就表示向上取整,floor是地板的意思,该方法就表示向下取整,而round有点麻烦,是...
  • Math类中提供了5个与取整相关的函数,如下所示: static double ceil(double a):天花板函数,返回大于等于a的最小整数(但是以浮点数形式存储)。 static double floor(double a):地板函数,返回小于等于a的最大...
  • C#取整 之 Math取整

    2019-09-28 20:38:39
    C# 之 Math取整 主要用到 System 命名空间下的一个数据类 Math ,调用他的方法。 C#取整函数使用详解: 1、Math.Round是"就近舍入",当要舍入的是5时与"四舍五入"不同(取偶数),如: Math.Round(0.5,0)=0 ...
  • Math对象的取整方法和获取随机数方法(教辅).pdf
  • Java中Math类的取整方法

    千次阅读 2018-06-04 20:42:53
    Math类中主要提供了以下几种有关整数的方法:1.static double cell(double a):返回大于等于a的最小整数:2.static double floor(double a):返回小于等于a的最大整数3.static double rint(double a):返回与a最相近的...
  • Math对象向上向取整,下取整

    千次阅读 2018-10-18 23:20:53
  • 对一个数进行舍入 Math.ceil(n) 必需 必须是一个数值 大于等于n,并且是与它最接近的整数 floor() 对一个数进行下舍入 Math.floor(n) 必需 必须是一个数值或表达式 ...
  • Math.ceil向上取整

    千次阅读 2017-09-28 18:59:27
    public class T { public static void main(String []args) { int bidCount=52; double ceil = bidCount / 5; double temp = Math.ceil(ceil); System.out.println("temp=" + tem
  • 都是整数的话在python2.7中就默认是向下取整,,所以你用math.ceil() 函数向上取整是没有用的。  #向上取整 print "math.ceil---" print "math.ceil(2.3) => ", math.ceil(2.3) print...
  • 关于Math.round(()取整规则 Math.round()取整规则就是参数+0.5,然后向下取整,验证如下: 正数: System.out.println(Math.round(1.49));//1 System.out.println(Math.round(1.5));//2 System.out.println...
  • 主要介绍了详解Java中Math.round()的取整规则,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Math.random();随机数的取整

    千次阅读 2018-11-26 22:31:56
    今天搞背景色rbg的测试的时候发现Math这边的东西有点生疏了特来复习一下。 //向下取整 floor Math.floor(0.99) //输出0 Math.floor(-0.99) //输出-1 //向上取整 ceil Math.ceil(0.99)  //输出1 Math.ceil(-...
  • Math取整方法

    2016-04-11 16:40:35
    舍掉小数取整:Math.floor(2)=2 舍掉小数取整:Math.floor(2.1)=2 舍掉小数取整:Math.floor(-2.1)=-3 舍掉小数取整:Math.floor(-2.5)=-3 舍掉小数取整:Math.floor(-2.9)=-3 四舍五入取整:Math.rint(2)=2 四舍五...
  • Android中Math取整的三个方法

    万次阅读 2015-11-01 15:24:58
    Android中Math类中提供了三个与取整有关的方法: 分别是ceil、floor、round,这些方法的作用与它们的英文名称的含义相对应 ceil的英文解释是天花板,该方法就表示向上取整,所以,Math.ceil(16.2)的结果为16,Math.ceil...
  • Math.floor();表示向下取整,只能接收double类型,返回double类型。 Math.ceil();表示向上取整,只能接收double类型,返回double类型。 Math.round();表示四舍五入取整,接收double类型,返回long类型。接收float...
  • Java之Math取整操作

    2019-05-29 14:27:38
    Java中针对数据的取整操作,在此总结。 舍掉小数取整,floor向下取整 //正 Math.floor(2)=2.0 Math.floor(2.1)=2.0 Math.floor(2.5)=2.0 Math.floor(2.9)=-2.0 //负 Math.floor(-2)=-2.0 Math.floor(-2.1)=-3.0...
  • Math取整

    2017-04-05 18:03:19
    Math类中的三个与取整有关的方法 1、public static double ceil(double a)Returns the smallest (closest to negative infinity) double value that is greater than or equal to the argument and is equal to a ...
  • Math取整方法

    2018-01-12 21:32:30
    Math类中提供了三个与取整有关的方法:ceil、floor、round,这些方法的作用与它们的英文名称的含义相对应,例如,ceil的英文意义是天花板,该方法就表示向上取整Math.ceil(11.3)的结果为12,Math.ceil(-11.3)的结果...
  • JS 中的Math方法向上取整、向下取整、保留整数、绝对值、取最大值、最小值等 1.只保留整数部分(丢弃小数部分) parseInt(5.1234);// 5 2.向下取整(<= 该数值的最大整数)和parseInt()一样 Math.floor(5....
  • Math类之取整函数

    2014-05-10 11:28:04
    如同C语言提供了math.h一样,Java中提供了Math

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,115
精华内容 17,646
关键字:

math上取整