run prettier format on javascript reference again!

mdn · Jul 29, 2023 · aaf74ad · aaf74ad
1 parent 5686b4d
commit aaf74ad
Show file tree

Hide file tree

Showing 7 changed files with 112 additions and 90 deletions.
diff --git a/.prettierignore b/.prettierignore
@@ -92,4 +92,3 @@ build/
 # zh-cn
 /files/zh-cn/web/api/**/*.md
 /files/zh-cn/web/css/**/*.md
-/files/zh-cn/web/javascript/reference/**/*.md
diff --git a/files/zh-cn/web/javascript/reference/errors/invalid_array_length/index.md b/files/zh-cn/web/javascript/reference/errors/invalid_array_length/index.md
@@ -37,35 +37,42 @@ RangeError: Invalid array buffer length (Chrome)
 ```js example-bad
 new Array(Math.pow(2, 40));
 new Array(-1);
-new ArrayBuffer(Math.pow(2, 32));
+new ArrayBuffer(Math.pow(2, 32)); // 32 位系统
 new ArrayBuffer(-1);
 
-let a = [];
+const a = [];
 a.length = a.length - 1; // 将 length 属性的值设置为 -1
 
-let b = new Array(Math.pow(2, 32) - 1);
+const b = new Array(Math.pow(2, 32) - 1);
 b.length = b.length + 1; // 将 length 属性的值设置为 2^32
+b.length = 2.5; // 将 length 属性设置为浮点数
+
+const c = new Array(2.5); // 传入浮点数
 ```
 
 ### 正确的示例
 
 ```js example-good
-[ Math.pow(2, 40) ]; // [ 1099511627776 ]
-[ -1 ]; // [ -1 ]
+[Math.pow(2, 40)]; // [ 1099511627776 ]
+[-1]; // [ -1 ]
 new ArrayBuffer(Math.pow(2, 32) - 1);
+new ArrayBuffer(Math.pow(2, 33)); // 64-bit systems after Firefox 89
 new ArrayBuffer(0);
 
-let a = [];
+const a = [];
 a.length = Math.max(0, a.length - 1);
 
-let b = new Array(Math.pow(2, 32) - 1);
+const b = new Array(Math.pow(2, 32) - 1);
 b.length = Math.min(0xffffffff, b.length + 1);
-
-// 0xffffffff 是 2^32 - 1 的 十六进制 表示方式
+// 0xffffffff 0xffffffff 是 2^32 - 1 的十六进制表示方式
 // 它也可以被写作 (-1 >>> 0)
+
+b.length = 3;
+
+const c = new Array(3);
 ```
 
-## 相关页面
+## 参见
 
 - {{jsxref("Array")}}
 - {{jsxref("Array.length")}}

diff --git a/files/zh-cn/web/javascript/reference/global_objects/error/stack/index.md b/files/zh-cn/web/javascript/reference/global_objects/error/stack/index.md
@@ -22,7 +22,7 @@ slug: Web/JavaScript/Reference/Global_Objects/Error/stack
 下面这段 html 代码展示了`stack` 属性的使用方法
 
 ```html
-<!DOCTYPE html>
+<!doctype html>
 <meta charset="UTF-8" />
 <title>Stack Trace Example</title>
 <body>

diff --git a/files/zh-cn/web/javascript/reference/global_objects/math/clz32/index.md b/files/zh-cn/web/javascript/reference/global_objects/math/clz32/index.md
@@ -38,9 +38,22 @@ Math.clz32 (x)
 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
-}); // []
+
+const stuff = [
+  NaN,
+  Infinity,
+  -Infinity,
+  0,
+  -0,
+  false,
+  null,
+  undefined,
+  "foo",
+  {},
+  [],
+];
+stuff.every((n) => Math.clz32(n) === 32); // true
+
 Math.clz32(true); // 31
 Math.clz32(3.5); // 30
 ```
@@ -51,43 +64,46 @@ Math.clz32(3.5); // 30
 
 先看以下代码：
 
-```plain
-var a = 32776;   // 00000000000000001000000000001000 (16 个前导 0)
-Math.clz32(a);   // 16
+```js
+const a = 32776; // 00000000000000001000000000001000（16 个前导 0）
+Math.clz32(a); // 16
 
-var b = ~32776;  // 11111111111111110111111111110111 (对 32776 取反，0 个前导 0)
-Math.clz32(b);   // 0 (相当于 0 个前导 1)
+const b = ~32776; // 11111111111111110111111111110111（对 32776 取反，0 个前导 0）
+Math.clz32(b); // 0（这与 a 中有多少个前导 0 等价）
 ```
 
 通过以上方法，`clon` 函数可以定义如下：
 
-```plain
-var clz = Math.clz32;
-function clon(integer){
-    return clz(~integer);
+```js
+const clz = Math.clz32;
+
+function clon(integer) {
+  return clz(~integer);
 }
 ```
 
-现在，我们可以进一步实现计算“尾随 0”和“尾随 1”的个数了。下面的`ctrz`函数将第一个 1 之后的高数位全部置为 1 然后取反，再用`Math.clz32 求得`尾随 0 的个数。
+现在，我们可以进一步实现计算“尾随 0”和“尾随 1”的个数了。下面的 `ctrz` 函数将第一个 1 之后的高数位全部置为 1 然后取反，再用 `Math.clz32` 求得尾随 0 的个数。
 
-```plain
+```js
 var clz = Math.clz32;
-function ctrz(integer){ // 计算尾随 0 个数
-    // 1. 将第一个 1 之后的高数位全部置为 1
-    // 00000000000000001000000000001000 => 11111111111111111111111111111000
-    integer |= integer << 16;
-    integer |= integer << 8;
-    integer |= integer << 4;
-    integer |= integer << 2;
-    integer |= integer << 1;
-    // 2. 然后，对该数取反，此时低位的 1 的个数即为所求
-    return 32 - clz(~integer) |0; // `|0`用于保证结果为整数
+function ctrz(integer) {
+  // 计算尾随 0 个数
+  // 1. 将第一个 1 之后的高数位全部置为 1
+  // 00000000000000001000000000001000 => 11111111111111111111111111111000
+  integer |= integer << 16;
+  integer |= integer << 8;
+  integer |= integer << 4;
+  integer |= integer << 2;
+  integer |= integer << 1;
+  // 2. 然后，对该数取反，此时低位的 1 的个数即为所求
+  return (32 - clz(~integer)) | 0; // `| 0` 用于保证结果为整数
 }
-function ctron(integer){ // 计算尾随 1 个数
-    // JavaScript 中没有移位补 1 的运算符
-    // 所以下面的代码是最快的
-    return ctrz(~integer);
-    /* 为了看起来比较对称，你也可以使用以下代码：
+function ctron(integer) {
+  // 计算尾随 1 个数
+  // JavaScript 中没有移位补 1 的运算符
+  // 所以下面的代码是最快的
+  return ctrz(~integer);
+  /* 为了看起来比较对称，你也可以使用以下代码：
        // 1. 将第一个 0 之后的高数位全部置为 0
        integer &= (integer << 16) | 0xffff;
        integer &= (integer << 8 ) | 0x00ff;
@@ -102,29 +118,31 @@ function ctron(integer){ // 计算尾随 1 个数
 
 将以上函数改写成 ASM.JS 模块——然后，你就可以去跟别人炫耀了！ASM.JS 就是用来干这个的。
 
-```plain
-var countTrailsMethods = (function(stdlib, foreign, heap) {
-    "use asm";
-    var clz = stdlib.Math.clz32;
-    function ctrz(integer) { // 计算尾随 0 个数
-        integer = integer | 0; // 确保是整数
-        // 1. 将第一个 1 之后的高数位全部置为 1
-        // ASMjs 中不允许^=、&=、和 |=
-        integer = integer | (integer << 16);
-        integer = integer | (integer << 8);
-        integer = integer | (integer << 4);
-        integer = integer | (integer << 2);
-        integer = integer | (integer << 1);
-        // 2. 然后，对该数取反，此时低位的 1 的个数即为所求
-        return 32 - clz(~integer) |0;
-    }
-    function ctron(integer) { // 计算尾随 1 个数
-        integer = integer | 0; // 确保是整数
-        return ctrz(~integer) |0;
-    }
-    // 蛋疼的是，ASM.JS 必须使用糟糕的 object 类型：
-    // unfourtunately, ASM.JS demands slow crummy objects:
-    return {a: ctrz, b: ctron};
+```js
+var countTrailsMethods = (function (stdlib, foreign, heap) {
+  "use asm";
+  var clz = stdlib.Math.clz32;
+  function ctrz(integer) {
+    // 计算尾随 0 个数
+    integer = integer | 0; // 确保是整数
+    // 1. 将第一个 1 之后的高数位全部置为 1
+    // ASMjs 中不允许^=、&=、和 |=
+    integer = integer | (integer << 16);
+    integer = integer | (integer << 8);
+    integer = integer | (integer << 4);
+    integer = integer | (integer << 2);
+    integer = integer | (integer << 1);
+    // 2. 然后，对该数取反，此时低位的 1 的个数即为所求
+    return (32 - clz(~integer)) | 0;
+  }
+  function ctron(integer) {
+    // 计算尾随 1 个数
+    integer = integer | 0; // 确保是整数
+    return ctrz(~integer) | 0;
+  }
+  // 蛋疼的是，ASM.JS 必须使用糟糕的 object 类型：
+  // unfourtunately, ASM.JS demands slow crummy objects:
+  return { a: ctrz, b: ctron };
 })(window, null, null);
 var ctrz = countTrailsMethods.a;
 var ctron = countTrailsMethods.b;
@@ -134,16 +152,17 @@ var ctron = countTrailsMethods.b;
 
 这个 polyfill 效率最高。
 
-```plain
-if (!Math.clz32) Math.clz32 = (function(log, LN2){
-  return function(x) {
-    var asUint = x >>> 0; // 将 x 转换为 Uint32 类型
-    if (asUint === 0) {
-      return 32;
-    }
-    return 31 - (log(asUint) / LN2 | 0) |0; // "| 0"相当于 Math.floor
-  };
-})(Math.log, Math.LN2);
+```js
+if (!Math.clz32)
+  Math.clz32 = (function (log, LN2) {
+    return function (x) {
+      var asUint = x >>> 0; // 将 x 转换为 Uint32 类型
+      if (asUint === 0) {
+        return 32;
+      }
+      return (31 - ((log(asUint) / LN2) | 0)) | 0; // “| 0”相当于 Math.floor
+    };
+  })(Math.log, Math.LN2);
 ```
 
 ## 规范

diff --git a/files/zh-cn/web/javascript/reference/global_objects/number/index.md b/files/zh-cn/web/javascript/reference/global_objects/number/index.md
@@ -68,7 +68,7 @@ JavaScript 的 `Number` 类型是一个[双精度 64 位二进制格式 IEEE 754
   - 不允许使用[数字分隔符](/zh-CN/docs/Web/JavaScript/Reference/Lexical_grammar#numeric_separators)。
 - [BigInt](/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/BigInt) 抛出 {{jsxref("TypeError")}}，以防止意外的强制隐式转换损失精度。
 - [Symbol](/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Symbol) 抛出 {{jsxref("TypeError")}}。
-- 对象首先按顺序调用 [`@@toPrimitive]()`](/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toPrimitive)（将 `"number"` 作为 hint）、`valueOf()` 和 `toString()` 方法将其[转换为原始值](/zh-CN/docs/Web/JavaScript/Data_structures#强制原始值转换)。然后将生成的原始值转换为数值。
+- 对象首先按顺序调用 [`[@@toPrimitive]()`](/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toPrimitive)（将 `"number"` 作为 hint）、`valueOf()` 和 `toString()` 方法将其[转换为原始值](/zh-CN/docs/Web/JavaScript/Data_structures#强制原始值转换)。然后将生成的原始值转换为数值。
 
 有两种方法可以在 JavaScript 中实现几乎相同的效果。
 

diff --git a/files/zh-cn/web/javascript/reference/operators/grouping/index.md b/files/zh-cn/web/javascript/reference/operators/grouping/index.md
@@ -11,10 +11,8 @@ slug: Web/JavaScript/Reference/Operators/Grouping
 
 ## 语法
 
-译者：下列语法是 MDN 上已知的最简单的之一。
-
-```plain
- ( )
+```js-nolint
+(expression)
 ```
 
 ## 说明
@@ -25,21 +23,20 @@ slug: Web/JavaScript/Reference/Operators/Grouping
 
 下面的代码展示了加法运算先于乘法运算的情况。
 
-```js
-var a = 1;
-var b = 2;
-var c = 3;
+```js-nolint
+const a = 1;
+const b = 2;
+const c = 3;
 
-// default precedence
+// 默认优先级
 a + b * c; // 7
-// evaluated by default like this
+// 默认运算顺序同下
 a + (b * c); // 7
 
-// now overriding precedence
-// addition before multiplication
+// 现在优先考虑乘法之前的加法
 (a + b) * c; // 9
 
-// which is equivalent to
+// 这相当于
 a * c + b * c; // 9
 ```
 
@@ -51,7 +48,7 @@ a * c + b * c; // 9
 
 {{Compat}}
 
-## 相关链接
+## 参见
 
 - [运算符优先级](/zh-CN/docs/Web/JavaScript/Reference/Operators/Operator_precedence)
 - {{jsxref("Operators/delete", "delete")}}

diff --git a/files/zh-cn/web/javascript/reference/operators/logical_or/index.md b/files/zh-cn/web/javascript/reference/operators/logical_or/index.md
@@ -58,7 +58,7 @@ console.log(B() || A());
 
 以下表达式看起来等价，但实际上不是，因为 `&&` 运算符比 `||` 运算符先执行（参见[运算符优先级](/zh-CN/docs/Web/JavaScript/Reference/Operators/Operator_precedence)）。
 
-```js
+```js-nolint
 true || false && false; // 返回 true，因为 && 先执行
 (true || false) && false; // 返回 false，因为分组运算符优先级更高
 ```