导航

⭐ 获取指定范围内的随机数

Math.round(num)：将 num 四舍五入取整
Math.floor(num)：将 num 向下取整，即返回 num 的整数部分。当然我们也可以使用 parseInt() 方法代替。
Math.ceil(num)：向上取整
思路：max 和 min 的差值，加上保底的 min

function fn(min, max) {
  return Math.round(Math.random() * (max - min - 2) + min + 1); // (min, max)
  return Math.round(Math.random() * (max - min) + min); // [min, max]
  return Math.ceil(Math.random() * (max - min) + min); // (min, max]
  return Math.floor(Math.random() * (max - min) + min); // [min, max)
}

参考：JS - 生成随机数的方法汇总（不同范围、类型的随机数）

⭐ 如何检查一个数字是否为整数？

将它对 1 进行取模，看看是否有余数。

function isInt(num) {
  return num % 1 === 0;
}

console.log(isInt(4)); // true
console.log(isInt(12.2)); // false
console.log(isInt(0.3)); // false

或者使用 Number.isInterger()

function isInt(num) {
  return Number.isInteger(num);
}

console.log(isInt(4)); // true
console.log(isInt(12.2)); // false
console.log(isInt(0.3)); // false

⭐ 为什么 0.1+0.2 不等于 0.3 ？在什么场景下遇到这个问题，如何解决？

二进制模拟十进制进行计算时的精度问题

JavaScript存在精度丢失问题，由于有些小数无法用二进制表示，所以只能取近似值，解决方法有：

先转大数，再变小数
使用 toFixed

// ES6的 Number.EPSILON ， 这个值无限接近于0。0.1+0.2的精度误差在这个值的范围内
function numbersEqual(a,b) {
    return Math.abs(a-b)<Number.EPSILON;
}
var a= 0.1 + 0.2， b = 0.3;
console.log(numbersEqual(a,b));    //true

// parseFloat + 内置函数toFixed
function formatNum(num, fixed = 10) {
    // a.toFixed(fixed) 先转为小数点10位的字符串 "0.3000000000"
    return parseFloat(num.toFixed(fixed)) // 然后通过parseFloat转为浮点数
}
var a = 0.1 + 0.2;
console.log(formatNum(a)); //0.3

// 内置函数toPrecision(中文：精确，精度)
// 参数是精度.比如5.1234，传2返回5.1，传1返回5；0.2+0.1传2返回0.30
(0.1 + 0.2).toPrecision(10) == 0.3 // true

封装方法：

function formatMoney(amount, precision = 2) {
  // 确保精度为非负整数
  if (precision < 0 || !Number.isInteger(precision)) {
    throw new Error('Precision must be a non-negative integer');
  }
  
  // 将金额转换为字符串，并根据精度截取小数部分
  const factor = Math.pow(10, precision);
  const formattedAmount = Math.round(amount * factor) / factor;
  
  return formattedAmount.toFixed(precision);
}

// 使用示例
console.log(formatMoney(0.1 + 0.2)); // 输出 "0.30"
console.log(formatMoney(0.1 + 0.2, 3)); // 输出 "0.300"
console.log(formatMoney(1234.5678, 2)); // 输出 "1234.57"
console.log(formatMoney(1234.5678, 0)); // 输出 "1235"

参考：

整数反转

输入: 123 输出: 321
输入: -123 输出: -321
输入: 120 输出: 21

var num = 123
function reverse(num) {
  var flag = num > 0 ? true : false
  var newNum = parseInt(Math.abs(num).toString().split("").reverse().join(""))
  if (newNum <= Math.pow(-2, 31) || newNum >= Math.pow(2, 31) - 1) { return 0 }
  return flag ? newNum : -newNum
}
console.log(reverse(num))

保留指定小数位

var num = 4.345678;
num = num.toFixed(4); // 4.3457 第四位小数位以四舍五入计算

⭐ 前端价格展示，保留 2 位小数。位数不够补零

function priceFormat(price) {
  return parseFloat(Math.round(price * 100) / 100).toFixed(2)
}

// or
function priceFormat(price, fixed = 2) {
	const factor = Math.pow(10, fixed);
  return parseFloat(Math.round(price * factor) / factor).toFixed(fixed);
}

⭐ ['1', '2', '3'].map(parseInt) 答案是多少?

第一眼看到这个题目的时候，脑海跳出的答案是 [1, 2, 3]，但是真正的答案是 [1, NaN, NaN]。

首先让我们回顾一下，map函数的第一个参数 callback ：

var new_array = arr.map(function callback(currentValue[, index[, array]]) { // Return element for new_array }[, thisArg])这个callback一共可以接收三个参数，其中第一个参数代表当前被处理的元素，而第二个参数代表该元素的索引。

而 parseInt 则是用来解析字符串的，使字符串成为指定基数的整数。parseInt(string, radix) 接收两个参数，第一个表示被处理的值（字符串），第二个表示为解析时的基数。
了解这两个函数后，我们可以模拟一下运行情况

parseInt('1', 0) //radix为0时，且string参数不以“0x”和“0”开头时，按照10为基数处理。这个时候返回1
parseInt('2', 1) //基数为1（1进制）表示的数中，最大值小于2，所以无法解析，返回NaN
parseInt('3', 2) //基数为2（2进制）表示的数中，最大值小于3，所以无法解析，返回NaN

map函数返回的是一个数组，所以最后结果为 [1, NaN, NaN]
最后附上MDN上对于这两个函数的链接，具体参数大家可以到里面看 https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/parseInthttps://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/map

题目来源：https://github.com/Advanced-Frontend/Daily-Interview-Question/issues/4

⭐️ 打印 100 以内的数，跳过能被 7 整除或者个位数是 7 的数

for (var i = 0; i <= 100; i++) {
	if (i % 7 === 0 || i % 10 === 7) {
  	continue;
  }
  console.log(i);
}

打印 0 - 100 内的数；() 中只能有一句话，不能写比较；{} 中不能出现 i++, i--

var i = 101;
for (; i--;) {
  console.log(i); // 从 1001 打印到 0
}

// hint: (i--) 的结果是 i = i - 1; (i--) 这个表达式的值是 i；
// 当 i = 100 时，(i--) 的结果 i = 100，但 (i--) 这个表达式的值此刻为 101
// 当 i = 1 时，(i--) 的结果 i = 0，但 (i--) 这个表达式的值此刻为 1
// 所以表达式还是个 true，执行循环体内容，此刻打印 i = 0；
// 最后一次表达式判断时，(i--) 的结果 i = -1，但 (i--) 这个表达式的值为 0，表达式结果 0 转
// 布尔值为 false，所以停止了 for 循环的执行，结束

10 的 n 次方

function fn(n) {
  var total = 1;
	for (var i = 0; i < n; i++) {
  	total *= 10;
  }
  return total;
}

n 的阶乘

function fn(n) {
	var total = 1;
  for (var i = 1; i <= n; i++) {
  	total *= i;
  }
  return total;
}

⭐ 打印 100 以内的质数

// 仅能被1和自身整除的数
var count = 0;
for (var i = 2; i <= 100; i++) {
	for (var j = 1; j <= i; j++) {
  	if (i % j === 0) { // 只要能被整除，count就+1
    	count++;
    }
  }
  if (count === 2) { // 从1到自身%完之后，如果计数仅有两次，代表为质数（1和自身）
  	console.log(i);
  }
  count = 0; // 计数清零
}

打印出 1 - 10000 之间的所有对称数

例如：121、1331 等

[...Array(10000).keys()].filter((x) => x.toString().length > 1 && x === Number(x.toString().split('').reverse().join('')));