fix some errors

files/zh-cn/web/javascript/reference/global_objects/undefined/index.md

@@ -3,11 +3,17 @@ title: undefined
 slug: Web/JavaScript/Reference/Global_Objects/undefined
 ---
 
-{{jsSidebar("Objects")}}全局属性 **`undefined`** 表示原始值`{{Glossary("Undefined", "undefined")}}。`它是一个 JavaScript 的 {{Glossary("Primitive", "原始数据类型")}} 。{{js_property_attributes(0,0,0)}}{{EmbedInteractiveExample("pages/js/globalprops-undefined.html")}}
+{{jsSidebar("Objects")}}
+
+全局属性 **`undefined`** 表示原始值 `{{Glossary("Undefined", "undefined")}}`。它是一个 JavaScript 的 {{Glossary("Primitive", "原始数据类型")}} 。
+
+{{js_property_attributes(0,0,0)}}
+
+{{EmbedInteractiveExample("pages/js/globalprops-undefined.html")}}
 
 ## 语法
 
-```plain
+```js-nolint
 undefined
 ```
 
@@ -30,21 +36,19 @@ test(); // 返回"undefined"
 
 一个函数如果没有使用 return 语句指定{{jsxref("Statements/return", "返回")}}值，就会返回一个 undefined 值。
 
-> **警告：** 但是它有可能在非全局作用域中被当作{{Glossary("Identifier", "标识符")}}（变量名）来使用 (因为 undefined 不是一个{{jsxref("Reserved_Words", "保留字")}}))，这样做是一个非常坏的主意，因为这样会使你的代码难以去维护和排错。
+> **警告：** 但是它有可能在非全局作用域中被当作{{Glossary("Identifier", "标识符")}}（变量名）来使用（因为 undefined 不是[保留字](/zh-CN/docs/Web/JavaScript/Reference/Lexical_grammar#保留字的使用)），这样做是一个非常坏的主意，因为这样会使你的代码难以去维护和排错。
 >
-> ```js
+> ```js example-bad
 > // 不要这样做！
 >
-> // 打印 'foo string' PS：说明 undefined 的值和类型都已经改变
-> (function () {
->   var undefined = "foo";
->   console.log(undefined, typeof undefined);
-> })()(
->   // 打印 'foo string' PS：说明 undefined 的值和类型都已经改变
->   function (undefined) {
->     console.log(undefined, typeof undefined);
->   },
-> )("foo");
+> (() => {
+>   const undefined = "foo";
+>   console.log(undefined, typeof undefined); // foo string
+> })();
+>
+> ((undefined) => {
+>   console.log(undefined, typeof undefined); // foo string
+> })("foo");
 > ```
 
 ## 示例

files/zh-cn/web/javascript/reference/lexical_grammar/index.md

@@ -203,11 +203,11 @@ JavaScript 的解释器会把它视为普通注释——只有当脚本直接在
 - `transient`
 - `volatile`
 
-另外，字面量 `null`、`true`和`false`同样不能被当成标识使用。
+另外，字面量 `null`、`true` 和 `false` 同样不能被当成标识使用。
 
 ### 保留字的使用
 
-事实上保留字是仅针对标识符（Identifier）的文法定义而言的（而不是标识符名（IdentifierName）的文法定义）。如 [es5.github.com/#A.1](http://es5.github.com/#A.1)中所描述的，这些都是不排斥保留字的标识符名。
+事实上保留字是仅针对标识符（Identifier）的文法定义而言的（而不是标识符名（IdentifierName）的文法定义）。如 [es5.github.com/#A.1](http://es5.github.com/#A.1) 中所描述的，这些都是不排斥保留字的标识符名。
 
 ```js
 a.import
@@ -225,32 +225,28 @@ function import() {} // Illegal.
 
 ### 空字面量
 
-更多信息可以参考 `null`
+更多信息可以参考 [`null`](/zh-CN/docs/Web/JavaScript/Reference/Operators/null)。
 
-```js
-null;
+```js-nolint
+null
 ```
 
 ### 布尔字面量
 
 更多信息可以参考[`Boolean`](/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Boolean)
 
-```js
-true;
-false;
+```js-nolint
+true
+false
 ```
 
 ### 数值字面量
 
 #### 十进制
 
-```js
-1234567890;
-42;
-
-// 谨慎使用 0 开头的数值：
-0888; // 转换为十进制 888
-0777; // 转换为八进制 777，十进制 511
+```js-nolint
+1234567890
+42
 ```
 
 请注意，十进制数值字面量可以以 0 开头，但是如果 0 以后的最高位比 8 小，数值将会被认为是八进制而不会报错。更多信息可以参考 [Firefox bug 957513](https://bugzil.la/957513) 和 [`parseInt()`](/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/parseInt#Octal_interpretations_with_no_radix)。
@@ -259,33 +255,29 @@ false;
 
 二进制表示为开头是 0 后接大写或小写的 B（`0b`或者`0B`）。这是 ECMAScript 6 中的新语法，可以参考下面的浏览器兼容性表格。如果`0b`之后有除了 0 或 1 以外的数字，将会抛出[`SyntaxError`](/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError)：“Missing binary digits after 0b”。
 
-```js
-var FLT_SIGNBIT = 0b10000000000000000000000000000000; // 2147483648
-var FLT_EXPONENT = 0b01111111100000000000000000000000; // 2139095040
-var FLT_MANTISSA = 0b00000000011111111111111111111111; // 8388607
+```js-nolint
+0b10000000000000000000000000000000 // 2147483648
+0b01111111100000000000000000000000 // 2139095040
+0B00000000011111111111111111111111 // 8388607
 ```
 
 #### 八进制
 
 八进制表示为开头是 0 后接大写或小写的 O（`0o`或`0O`）。这是 ECMAScript 6 中的新语法，可以参考下面的浏览器兼容性表格。如果有不在（01234567）中的数字，将会抛出[`SyntaxError`](/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError)：“Missing octal digits after 0o”。
 
-```js
-var n = 0o755; // 493
-var m = 0o644; // 420
-
-// 用 0 开头也可以实现（请查看上方十进制有关部分）
-0755;
-0644;
+```js-nolint
+0O755 // 493
+0o644 // 420
 ```
 
 #### 十六进制
 
 十六进制表示为开头是 0 后接大写或小写的 X（`0x`或`0X`）。如果有不在（0123456789ABCDEF）中的数字，将会抛出[`SyntaxError`](/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError)：“Identifier starts immediately after numeric literal”。
 
-```js
-0xfffffffffffffffff; // 295147905179352830000
-0x123456789abcdef; // 81985529216486900
-0xa; // 10
+```js-nolint
+0xFFFFFFFFFFFFFFFFF // 295147905179352830000
+0x123456789ABCDEF   // 81985529216486900
+0XA                 // 10
 ```
 
 ### 对象字面量
@@ -315,8 +307,8 @@ var o = { a: a, b: b, c: c };
 ### 字符串字面量
 
 ```js-nolint
-'foo';
-"bar";
+'foo'
+"bar"
 ```
 
 #### 十六进制转义序列
@@ -363,15 +355,15 @@ ECMAScript 6 新增特性。使用 Unicode 编码转义，任何字符都可以
 
 更多信息可以参考[template strings](/zh-CN/docs/Web/JavaScript/Reference/template_strings)。
 
-```js
-`string text`;
+```js-nolint
+`string text`
 
 `string text line 1
- string text line 2`;
+ string text line 2`
 
-`string text ${expression} string text`;
+`string text ${expression} string text`
 
-tag`string text ${expression} string text`;
+tag`string text ${expression} string text`
 ```
 
 ## 自动分号补全

files/zh-cn/web/javascript/reference/operators/object_initializer/index.md

@@ -234,15 +234,15 @@ const mergedObj = { ...obj1, ...obj2 };
 
 请注意，`__proto__` 键是标准化的语法，与非标准且性能不佳的 [`Object.prototype.__proto__`](/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/proto) 访问器不同。它在创建对象时设置了 `[[Prototype]]`，类似于 {{jsxref("Object.create")}}——而不是变更原型链。
 
-```js
+```js-nolint
 const obj1 = {};
 console.log(Object.getPrototypeOf(obj1) === Object.prototype); // true
 
 const obj2 = { __proto__: null };
 console.log(Object.getPrototypeOf(obj2)); // null
 
 const protoObj = {};
-const obj3 = { __proto__: protoObj };
+const obj3 = { "__proto__": protoObj };
 console.log(Object.getPrototypeOf(obj3) === protoObj); // true
 
 const obj4 = { __proto__: "not an object or null" };

files/zh-cn/web/javascript/reference/operators/right_shift/index.md

@@ -11,8 +11,8 @@ slug: Web/JavaScript/Reference/Operators/Right_shift
 
 ## 语法
 
-```js
-x >> y;
+```js-nolint
+x >> y
 ```
 
 ## 描述

files/zh-cn/web/javascript/reference/statements/return/index.md

@@ -64,8 +64,10 @@ a + b;
 
 为了避免这个问题（防止 ASI），你可以使用括号：
 
-```js
-return a + b;
+```js-nolint
+return (
+  a + b
+);
 ```
 
 ## 示例

files/zh-cn/web/javascript/reference/trailing_commas/index.md

@@ -17,8 +17,12 @@ JavaScript 一开始就支持数组字面量中的尾后逗号，随后向对象
 
 JavaScript 忽略数组中的尾后逗号：
 
-```js
-var arr = [1, 2, 3];
+```js-nolint
+const arr = [
+  1,
+  2,
+  3,
+];
 
 arr; // [1, 2, 3]
 arr.length; // 3
@@ -27,7 +31,7 @@ arr.length; // 3
 如果使用了多于一个尾后逗号，会产生省略（elision，或者间隙 hole）。带有间隙的数组叫做*稀疏*数组（_sparse_ 紧凑数组 _dense_ array 没有省略/间隙）。例如，当使用 {{jsxref("Array.prototype.forEach()")}} 或 {{jsxref("Array.prototype.map()")}} 迭代数组时，会跳过数组间隙。
 
 ```js
-var arr = [1, 2, 3, , ,];
+const arr = [1, 2, 3, , ,];
 arr.length; // 5
 ```
 
@@ -36,7 +40,7 @@ arr.length; // 5
 从 ECMAScript 5 开始，对象字面值中的尾后逗号也是符合语法的：
 
 ```js
-var object = {
+const object = {
   foo: "bar",
   baz: "qwerty",
   age: 42,
@@ -49,25 +53,25 @@ ECMAScript 2017 支持函数参数中的尾后逗号。
 
 ### 参数定义
 
-下面的两个函数定义都是合法的，并且互相等价。尾后逗号并不影响函数定义，或者其`arguments`对象的 `length`属性。
+下面的两个函数定义都是合法的，并且互相等价。尾后逗号并不影响函数定义，或者其 `arguments` 对象的 `length` 属性。
 
-```js
-function f(p) {}
+```js-nolint
 function f(p) {}
+function f(p,) {}
 
 (p) => {};
-(p) => {};
+(p,) => {};
 ```
 
 尾后逗号也可用于类或对象的[方法定义](/zh-CN/docs/Web/JavaScript/Reference/Functions/Method_definitions)。
 
-```js
+```js-nolint
 class C {
-  one(a,) {},
-  two(a, b,) {},
+  one(a,) {}
+  two(a, b,) {}
 }
 
-var obj = {
+const obj = {
   one(a,) {},
   two(a, b,) {},
 };
@@ -77,12 +81,12 @@ var obj = {
 
 下面的两个函数调用都是合法的，并且互相等价。
 
-```js
-f(p);
+```js-nolint
 f(p);
+f(p,);
 
 Math.max(10, 20);
-Math.max(10, 20);
+Math.max(10, 20,);
 ```
 
 ### 不合法的尾后逗号
@@ -102,22 +106,22 @@ function f(...p,) {} // SyntaxError: parameter after rest parameter
 
 在使用[解构赋值](/zh-CN/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment)时，尾后逗号也可以用于左侧：
 
-```js
+```js-nolint
 // 带有尾后逗号的数组解构
-[a, b] = [1, 2];
+[a, b,] = [1, 2];
 
 // 带有尾后逗号的对象解构
-var o = {
+const o = {
   p: 42,
   q: true,
 };
-var { p, q } = o;
+const { p, q, } = o;
 ```
 
 同样地，在使用剩余参数时，会抛出 {{jsxref("SyntaxError")}}：
 
-```js example-bad
-var [a, ...b] = [1, 2, 3];
+```js-nolint example-bad
+const [a, ...b,] = [1, 2, 3];
 // SyntaxError: rest element may not have a trailing comma
 ```
 
@@ -151,4 +155,4 @@ JSON.parse('{"foo" : 1 }');
 
 ## 参见
 
-- ECMAScript 初始提案： [函数的尾后逗号](https://github.com/tc39/proposal-trailing-function-commas)（由 Jeff Morrison 提出）
+- ECMAScript 初始提案：[函数的尾后逗号](https://github.com/tc39/proposal-trailing-function-commas)（由 Jeff Morrison 提出）