JavaScript 中的数学常量和函数

那些疯狂到认为自己能够改变世界的人，才能真正改变世界。——<史蒂夫·乔布斯>

作者：Ashish Lahoti
译者：cl9000
来源：https://codingnconcepts.com/javascript/math-constants-and-functions-in-javascript/

在本教程中，我们将学习在 JavaScript 中的数学对象，这使得我们可以用数学常量，如 π，e，√2 和数字如进行数学运算 pow()，sqrt()，max()，min()，random()，abs()，ceil()，floor()，round()，和 truc()。

1. 数学常量

Math.E        // returns 2.718281828459045  (Euler's number)
Math.PI       // returns 3.141592653589793  (PI)
Math.SQRT2    // returns 1.4142135623730951 (square root of 2)
Math.SQRT1_2  // returns 0.7071067811865476 (square root of 1/2)
Math.LN2      // returns 0.6931471805599453 (natural logarithm of 2)
Math.LN10     // returns 2.302585092994046  (natural logarithm of 10
Math.LOG2E    // returns 1.4426950408889634 (base 2 logarithm of E)
Math.LOG10E   // returns 0.4342944819032518 (base 10 logarithm of E)

1.1. 计算圆的周长

让我们使用Math.PI常量来计算2πr给定半径的圆的周长r：

function calculateCircumference(radius) {
  return 2 * Math.PI * radius;
}

calculateCircumference(10); // returns 62.83185307179586

2. Math Pow

该 Math.pow(a, b) 函数将 a（基数） 返回 b（指数）的幂，即 a^b。

Math.pow(4, 3);      
// returns 64 i.e. 4×4×4

Math.pow(-4, 3);     
// returns -64 i.e. (-4)×(-4)×(-4)

Math.pow(4, -3);     
// returns 0.015625 i.e. 1 ÷ (4 × 4 x 4) 

Math.pow(64, 0.5);   
// returns 8 i.e. 2√64

Math.pow(-64, 0.5);  
// returns NaN i.e. 2√-64 square root number cannot be negative

Math.pow(64, -0.5);  
// returns 0.125 i.e. 1 ÷ 2√64 = 1/8

让我们对以上示例的结果进行细分，以清楚地理解：

Math.pow(a，b)	一^b	分解	结果
Math.pow(4，3)	4^3	4×4 x 4	64
Math.pow(-4，3)	(-4)^3	(-4)×(-4)x(-4)	-64
Math.pow(4，-3)	4^(-3)	1÷(4×4 x 4)	0.015625
Math.pow(64，0.5)	64^0.5 2√64	8
Math.pow(-64，0.5)	(-64)^0.5	2√-64	N
Math.pow(64，-0.5)	64^(-0.5)	1÷2√64	0.125

2.1. 求幂运算符(**)

非常有趣的是 JavaScript ES6 提供 ** 也称为幂运算符的简写语法。因此，Math.pow示例与以下示例相同：

console.log(4 ** 3);       // returns 64
console.log((-4) ** 3);    // returns -64
console.log(4 ** -3);      // returns 0.015625
console.log(64 ** 0.5);    // returns 8
console.log((-64) ** 0.5); // returns NaN
console.log(64 ** -0.5);   // returns 0.125

请注意，如果使用了简略表达式-ve base一起，则必须将其包装在()括号中，以避免SyntaxError。

➤ -4 ** 3
Uncaught SyntaxError: Unary operator used immediately before exponentiation expression. Parenthesis must be used to disambiguate operator precedence
➤ (-4) ** 3
-64

2.2. 使用幂运算符创建平方和立方体方法

我们使用幂运算符创建一些数学幂方法 ** ：

onst square = x => x ** 2;
const cube = x => x ** 3;

square(4); // returns 16
cube(3);   // returns 27

3. Math.sqrt

Math.sqrt(x) 函数返回给定数字的平方根

Math.sqrt(0);     // returns 0
Math.sqrt(null);  // returns 0

Math.sqrt(25);    // returns 5
Math.sqrt(1);     // returns 1
Math.sqrt(0.5);   // returns 0.7071067811865476

Math.sqrt(-5);    // returns NaN as number cannot be negative
Math.sqrt(NaN);   // returns NaN as number cannot be NaN

3.1. 创建我们自己的平方根方法

我们创建自己的 squareroot 使用 ES6 幂运算符方法 ** ：

const squareroot = x => x ** 0.5;

squareroot(0);      // returns 0
squareroot(null);   // returns 0
squareroot(25);     // returns 5
squareroot(1);      // returns 1
squareroot(0.5);    // returns 0.707106781186547
squareroot(-5);     // returns NaN as number cannot be negative
squareroot(NaN);    // returns NaN as number cannot be NaN

请记住，在实数集合中不存在负数的平方根，因此 JavaScript 会返回 NaN。负数的平方根是由表示的虚数 i 即 √-1 = i

4. Math Max

Math.max(value1, value2, value3, ...) 函数返回给定值中的最大值。

1 2	Math.max(1, 3, 2, 0, -1); // returns 3

如果任何参数不能转换为数字，则返回 NaN。

Math.max(1, 3, 2, '0', -1);    
// returns 3 as '0' is converted to numeric 0

Math.max(1, 3, 2, 'zero', -1); 
// returns NaN as 'zero' cannot be converted to numeric value

4.1. 从数组中找到最大的数字

我们使用Math.max函数以三种方式从数组中查找最大数：-
① 使用 扩展(…) 运算符

1
2
3

const numbers = [1, 2, 3, 4, 5];
Math.max(...numbers);          
// returns 5

②使用函数原型 apply() 法

1
2
3

const numbers = [1, 2, 3, 4, 5];
Math.max.apply(null, numbers);  
// returns 5

③使用 Array.reduce() 方法

1
2
3

const numbers = [1, 2, 3, 4, 5];
numbers.reduce((a,b) => Math.max(a,b));  
// returns 5

但是，如果数组中的元素过多，则 spread (...) 和 apply() 都将失败或返回错误的结果，因为它们会尝试将数组元素作为函数参数进行传递。该 Array.reduce() 方法不存在此问题。

5. Math Min

Math.min(value1, value2, value3, ...) 函数返回给定值中的最小值。

的用法示例 Math.min 与 Math.max 功能相同。

Math.min(1, 3, 2, 0, -1);               // returns -1
Math.min(1, 3, 2, '0', -1);             // returns -1
Math.min(1, 3, 2, 'zero', -1);          // returns NaN

const numbers = [1, 2, 3, 4, 5];  
Math.min(...numbers);                   // returns 1
Math.min.apply(null, numbers);          // returns 1
numbers.reduce((a,b) => Math.min(a,b)); // returns 1

6. Math Random

Math.random() 函数返回0（含）到1（不含）之间的浮点随机数

0 ≤ Math.random() < 1

让我们使用 Math.random() 函数创建一些有用的方法：

6.1. 给定最大范围，生成一个随机整数

首先创建一个方法getRandomInt，该方法在给定最大范围的情况下返回一个随机整数

1	const getRandomInt = (max) => Math.floor(Math.random() * max) + 1;

让我们使用此方法从给定数组中查找随机用户名

const userList = ["Alice", "Bob", "Charlie", "David", "Eric", "Franklin", "Gavin", "Harry", "Iris", 
                "Joey", "Kate", "Leo", "Monica", "Nancy", "Oscar", "Phoebe", "Quinn", "Ross", 
                "Sofia", "Tyler", "Umar", "Victor", "Wilson", "Xena", "Yasmine", "Zara"];

const getRandomUser = () => userList[getRandomInt(userList.length)];

console.log(getRandomUser()); // Wilson
console.log(getRandomUser()); // Charlie
console.log(getRandomUser()); // Leo
console.log(getRandomUser()); // Joey
console.log(getRandomUser()); // Gavin

6.2. 生成两个值（包括两个值）之间的随机整数

首先创建一个方法getRandomIntInclusive，该方法返回两个值（包括两个值）之间的随机整数

const getRandomIntInclusive = (min, max) => {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min + 1)) + min;
};

让我们使用此方法来生成由10个元素组成的数组，这些元素具有两位随机数，即10到99之间

var numbers = [];
var min = 10;
var max = 99;

for ( var i = 0; i < 10; i++ ) {
    numbers.push(getRandomIntInclusive(min, max));
}

console.log(numbers);
// [25, 55, 95, 51, 47, 10, 74, 86, 74, 77]

6.3. 随机排列数组的元素

Math.random() 函数与 Array.sort() 函数的使用非常有趣，可以对数组的元素进行混洗。让我们创建我们的 shuffleElements 方法：

1	const shuffleElements = (list) => list.sort(() => Math.random() - 0.5);

这里的想法是使用 Math.random() -0.5到0.5之间的值生成随机数，并将其提供给 Array.sort() 函数，该函数根据返回值是+ ve或0或-ve来对数组进行排序

让我们使用这种方法：

const list = [1, 2, 3, 4, 5, 6, 7, 8, 9];

console.log(shuffleElements(list));
// [6, 1, 2, 4, 3, 9, 5, 8, 7]

console.log(shuffleElements(list));
// [9, 6, 8, 1, 2, 7, 4, 5, 3]

console.log(shuffleElements(list));
// [6, 7, 3, 1, 2, 5, 8, 9, 4]

7. Math Abs

Math.abs(x) 函数返回绝对值，即 | X |

Math.abs('-1');     // 1
Math.abs(-2);       // 2
Math.abs(null);     // 0
Math.abs('');       // 0
Math.abs([]);       // 0
Math.abs([2]);      // 2
Math.abs([1,2]);    // NaN
Math.abs({});       // NaN
Math.abs('string'); // NaN
Math.abs();         // NaN

7.1. 找出两个数字之间的绝对差

让我们使用它Math.abs()来查找两个给定数字之间的绝对差：

const difference = (a, b) => Math.abs(a-b);

console.log(difference(3, 5)); // 2
console.log(difference(5, 3)); // 2

8. Math.ceil

Math.ceil(x) 功能用于将给定的数字四舍五入到上限表示向上的方向取整。

x ≤ Math.ceil(x) ≤ x+1
Math.ceil(0.95);    // 1
Math.ceil(45.95);   // 46
Math.ceil(45.05);   // 46
Math.ceil(-0.95);   // -0
Math.ceil(-45.05);  // -45 
Math.ceil(-45.95);  // -45

Math.ceil(null);    // 0

9. `Math.floor

Math.floor(x) 功能用于将给定的数字四舍五入到下限表示向下的方向取整。

x-1 ≤ Math.floor(x) ≤ x
Math.floor(0.95);    // 0
Math.floor(45.95);   // 45
Math.floor(45.05);   // 45
Math.floor(-0.95);   // -1
Math.floor(-45.05);  // -46 
Math.floor(-45.95);  // -46

Math.floor(null);    // 0

9.1. 得到数字的一小数据部分

让我们创建一个fraction使用 Math.floor() 和 Math.abs()函数获取数字的一小数部分的方法：

const fraction = (x) => Math.abs(x) - Math.floor(Math.abs(x));

fraction(45.95);   // 0.95
fraction(45.05);   // 0.05
fraction(-45.95);  // 0.95
fraction(-45.05);  // 0.05

9.2. 求商和两个整数除法的余数

Math.floor() 和 % 可以分别用来求两个整数的除法的商和余数:

var dividend = 14;
var divisor = 3;

console.log("quotient", Math.floor(dividend/divisor));
console.log("remainder", dividend % divisor);
// quotient 4
// remainder 2

10. Math Round

Math.round(x) 函数用于将给定数字在向上或向下的任何方向上四舍五入为最接近的整数。

console.log(Math.round(0.9));
// 1

console.log(Math.round(5.95), Math.round(5.5), Math.round(5.05));
// 6 6 5

console.log(Math.round(-5.05), Math.round(-5.5), Math.round(-5.95));
// -5 -5 -6

11. Math Trunc

Math.trunc(x) 函数通过删除小数部分来返回数字的整数部分。

Math.trunc(0.123);   // 0
Math.trunc(12.34);   // 12
Math.trunc(-0.123);  // -0
Math.trunc(-12.34);  // -12
Math.trunc('foo');   // NaN

注意，该 Math.trunc(x) 函数不应用任何舍入逻辑，而只是截断数字的点和小数部分。

11.1. 创建我们自己的截断方法

我们truncate使用Math.ceil()和Math.floor()函数创建自己的方法：

const truncate = (x) => x < 0 ? Math.ceil(x) : Math.floor(x);

truncate(0.123);   // 0
truncate(12.34);   // 12
truncate(-0.123);  // -0
truncate(-12.34);  // -12
truncate('foo');   // NaN

12. 剩余的数学函数

我们已经详细介绍了 JavaScript 中大多数常用的Math Object函数。这些是复杂数学计算中可能需要的其余Math函数的列表。

方法	描述
acos(x)	返回 x 的反余弦值
acosh(x)	返回 x 的反双曲余弦值
asin(x)	返回 x 的反正弦值
asinh(x)	返回 x 的反双曲正弦值
atan(x)	返回值 x 的反正切值
atan2(y, x)	返回 y/x 的反正切值
atanh(x)	返回 x 的反双曲正切值
cbrt(x)	返回 x 的立方根值
cos(x)	返回 x 的余弦值
cosh(x)	返回 x 的双曲余弦值
exp(x)	返回欧拉常数的参数次方，Ex，其中 x 为参数，E 是欧拉常数（2.718…，自然对数的底数）
expm1(x)	返回 exp(x) - 1 的值
log(x)	返回 x 的自然对数（㏒e，即㏑）
sin(x)	返回 x 的正弦值
sinh(x)	返回 x 的双曲正弦值
tan(x)	返回 x 角的正切值
tanh(x)	返回 x 的双曲正切值

参考

关注【公众号】，了解更多。
关注【公众号】，了解更多。
关注【公众号】，了解更多。

赏

支付宝打赏

微信打赏

赞赏一下坚持原创技术分享，您的支持将鼓励我继续创作！