JS该写分号结尾吗

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// eg1.
let a = 1
let b = 2 
// 解析到 let a = 1 后，行尾没有分号，解析器会继续看下行开头的 let，尝试判断 “let a = 1 let b = 2” 是否为合法语法
// 由于 JavaScript 中 “赋值表达式（let a = 1）” 后不能直接跟 “变量声明语句（let b = 2）”，整个连续语句语法无效
// 此时 ASI 被触发，在 1 后插入分号，将代码拆分为 let a = 1; let b = 2（合法语法）。

// eg2.到这里就能看出我之前的代码为什么产生错误了
  for (let row = 0; row < n; row++) {
        for (let col = 0; col < n / 2; col++) {
            const symmetryCol = n - col - 1
            [matrix[row][col], matrix[row][symmetryCol]] =[matrix[row][symmetryCol], matrix[row][col]] 
        }
    }
// 解析器会尝试将两行连起来解析：const symmetryCol = n - col - 1[matrix[row][col], matrix[row][symmetryCol]] = ...
// 这里的 1[xxx] 语法本身是合法的，虽然 1[matrix[...]] 最终会导致运行时错误，但语法解析阶段会认为 “1[xxx] 是符合语法规则的结构”
// 最终代码会被解析为赋值表达式链，导致 symmetryCol 被赋值为 (n - col - (1[...]))，同时触发解构赋值，代码报错

1
2
3
4
5
6
7

// eg1.一个很常见的情景：return后的语句全部作废
return
1  // "1" 是 restricted token，将在return后插入分号

// eg2.
let fn = (x)
=> x + 1  // "=>" 是 restricted token，触发 ASI：在 (x) 后插入分号，解析为 let fn = (x); => x + 1，导致语法错误

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// src\parsing\parser-base.h
void ExpectSemicolon() {
    // 这是一个“预读”函数，它查看下一个将要被解析的token是什么，但不消耗它（不移动扫描指针）
    Token::Value tok = peek();
    // 情况1: 下一个token是分号，则调用 Next() 消耗掉它
    if (V8_LIKELY(tok == Token::kSemicolon)) {
      Next();
      return;
    }
    // 情况2: 触发ASI机制【核心】
    // 通过“换行判断 + 自动分号token判断”的组合逻辑，实现上述的三条规则
    if (V8_LIKELY(scanner()->HasLineTerminatorBeforeNext() ||
                  Token::IsAutoSemicolon(tok))) {
      return;
    }
    // 情况3: 特殊错误处理 (await)
    if (scanner()->current_token() == Token::kAwait && !is_async_function()) {
      if (flags().parsing_while_debugging() == ParsingWhileDebugging::kYes) {
        ReportMessageAt(scanner()->location(),
                        MessageTemplate::kAwaitNotInDebugEvaluate);
      } else {
        ReportMessageAt(scanner()->location(),
                        MessageTemplate::kAwaitNotInAsyncContext);
      }
      return;
    }
    // 以上情况都不是，报告语法错误，同时消耗掉导致错误的token，防止解析器无限循环或卡死
    ReportUnexpectedToken(Next());
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

// src\parsing\scanner.h
// 这个函数只是一个简单的读取缓存的函数，读取下一个 token 的 after_line_terminator 字段
bool HasLineTerminatorBeforeNext() const { 
    return next().after_line_terminator;
}

// Next() -> Scan() -> ScanSingleToken() -> SkipWhiteSpace()
Token::Value Scanner::Next() {
  // 轮换 Token 缓冲区：current_ 切换到 next_，next_ 切换到 next_next_ 或新扫描的 Token
  TokenDesc* previous = current_;
  current_ = next_;

  if (V8_LIKELY(next_next().token == Token::kUninitialized)) {
    next_ = previous;
    // 每次切换 next_（下一个 Token）时，会先重置其 after_line_terminator 为 false，
    // 再通过 Scan() 扫描 Token 并更新该字段。
    previous->after_line_terminator = false;  
    Scan(previous);  
  } else {
    // （其他缓冲区轮换逻辑，略）
  }
  return current().token;
}

// SkipWhiteSpace()是词法分析器跳过空格、换行等空白字符的函数
// 只要在跳过的字符中存在至少一个换行符，就会将 next().after_line_terminator 设为 true（即使有多个换行，也只会标记一次为 true）
V8_INLINE Token::Value Scanner::SkipWhiteSpace() {
  if (!IsWhiteSpaceOrLineTerminator(c0_)) return Token::kIllegal;
  if (!next().after_line_terminator && unibrow::IsLineTerminator(c0_)) {
    next().after_line_terminator = true;  // 遇到换行符，标记为true
  }

  base::uc32 hint = ' ';
  AdvanceUntil([this, &hint](base::uc32 c0) {
    if (V8_LIKELY(c0 == hint)) return false;
    if (IsWhiteSpaceOrLineTerminator(c0)) {
      if (!next().after_line_terminator && unibrow::IsLineTerminator(c0)) {
        next().after_line_terminator = true;  // 连续换行时，保持标记为true
      }
      hint = c0;
      return false;
    }
    return true;
  });

  return Token::kWhitespace;
}

1
2
3
4
5

// src\parsing\token.h
// 判断当前 token 是否为 “可触发自动分号插入的 token”，如遇到文件结束
static bool IsAutoSemicolon(Value token) { 
    return base::IsInRange(token, kSemicolon, kEos);
}