4.语法

// 单行注释
/*
  多行
  注释
*/

// Booleans
true
false
// Numbers （JavaScript 的数字只有一种类型）
-123
1.414
// String （JavaScript 的字符没有对应的类型）
'abc'
"abc"

assert.equal(7 + 1, 8);

// 将值标准输出打印（另一种方法调用）
console.log("Hello!");

// 将错误信息标准输出打印
console.error('Something weng wrong!');

// 布尔运算符
assert.equal(true && false, false); // 与
assert.equal(true || false, true); // 或
// 数学运算符
assert.equal(3 + 4, 7);
assert.equal(5 - 1, 4);
assert.equal(3 * 4, 12);
assert.equal(9 / 3, 3);
// 字符串操作符
assert.equal('a' + 'b', 'ab');
assert.equal('I see ' + 3 + ' monkeys', 'I see 3 monkeys');
// 比较运算符
assert.equal(3 < 4, true);
assert.equal(3 <= 4, true);
assert.equal('abc' === 'abc', true);
assert.equal('abc' !== 'def', true);

let x;  // 声明 x（可变的）
x = 3 * 5;  // 给 x 赋值
let y = 3 * 5; // 声明变量并为其赋值
const z = 8; // 声明 y（不可变的）

// 条件语句
if (x < 0) { // x 小于 0？
  x = -x;
}

// add1() 有 a 和 b 两个参数
function add1(a, b) {
  return a + b;
}
// 调用函数 add1()
assert.equal(add1(5, 2), 7);

const add2 = (a, b) => a + b;
// 调用方法 add2()
assert.equal(add2(5, 2), 7);
const add3 = (a, b) => { return a + b };

// 主体为一个表达式的箭头函数
(a, b) => a + b
// 主体为一个代码块的箭头函数
(a, b) => { return a + b }

// 通过 object 符号（{}）创建一个对象
const obj = {
  first: 'Jane', // 属性
  last: 'Doe', // 属性
  getFullName() { // 属性（方法）
    return this.first + ' ' + this.last;
  },
};
// 获取某个属性值
assert.equal(obj.first, 'Jane');
// 设置某个属性的值
obj.first = 'Janey';
// 调用对象的方法
assert.equal(obj.getFullName(), 'Janey Doe');

// 通过 Array 符号（[]）创建一个数组
const arr = ['a', 'b', 'c'];
// 获取某个数组元素
assert.equal(arr[1], 'b');
// 设置某个数组元素的值
arr[1] = 'β';

file-tools.js
main.js

export function isTextFilePath(filePath) {
  return filePath.endsWith('.txt');
}

// 导入整个模块 `path`
import * as path from 'path';
// 导入模块 file-tools.js export的一个函数
import {isTextFilePath} from './file-tools.js';

• Unicode 字母：A - Z，a - z（等）
• $，_
• Unicode 数字：0 - 9（等）
• 变量名不能以数字开头

const if = 123;
// SyntaxError: Unexpected token if

> const obj = { if: 123 };
> obj.if
123

• 驼峰：threeConcatenatedWords
• 下划线（也称蛇形 ）：three_concatenated_words
• 分隔线（也称串形 ）：three-concatenated-words

• 函数，变量：myFunction
• 方法：obj.myMethod
• CSS：
  • CSS 实体：special-class
  • 对应的 JavaScript 变量：specialClass

• 类名：MyClass
• 常数：MY_CONSTANT
  • 常量也常用骆驼写成：myConstant

const x = 123;
func();

while (false) {
  // ···
} // 无分号
function func() {
  // ···
} // 无分号

// 函数声明后跟空语句
function func() {
  // ···
};

• Unicode 字母（包括é和ü等重音字符和非拉丁字母的字符，如α）
• $
• _

• 合法的首字符
• Unicode 数字（包括东方阿拉伯数字）
• 一些其他 Unicode 标记和标点符号

const ε = 0.0001;
const строка = '';
let _tmp = 0;
const $foo2 = true;

await break case catch class const continue debugger default delete do else export extends finally for function if import in instanceof let new return static super switch this throw try typeof var void while with yield

enum implements package protected interface private public

true false null

Infinity NaN undefined async

let myStr;
if (myBool) {
  myStr = 'Yes';
} else {
  myStr = 'No';
}

function twice(x) {
  return x + x;
}

let myStr = (myBool ? 'Yes' : 'No');

> 'ab' + 'cd'
'abcd'
> Number('123')
123
> true || false
true

• 函数体必须是一系列语句：

  function max(x, y) {
    if (x > y) {
      return x;
    } else {
      return y;
    }
  }
  

• 函数调用或方法调用的参数必须是表达式：

  console.log('ab' + 'cd', Number('123'));
  

console.log(bar());
bar();

function id(x) {
  return x;
}

const id = function me(x) {
  return x;
};

const obj = {};

{
}

• 如果语句以function开头：它是函数声明还是函数表达式？
• 如果语句以{开头：它是对象字面值还是代码块？

(function (x) { console.log(x) })('abc');
// Output:
// 'abc'

1. 我们首先通过函数表达式创建一个函数：

   function (x) { console.log(x) }
   

2. 然后我们调用该函数：('abc')

• 通过对象解构分配
• 从箭头函数

const x = 3;
someFunction('abc');
i++;

function foo() {
  // ···
}
if (y > 0) {
  // ···
}

const func = () => {}; // 分号！

while (condition)
  语句

while (a > 0) a--;

while (a > 0) {
  a--;
}

while (processNextItem() > 0);

while (processNextItem() > 0) {}

• 分号
• 行终止符后跟非法标记

return
{
  first: 'jane'
};

return;
{
  first: 'jane';
}
;

a = b + c
(d + e).print()

a = b + c(d + e).print();

a = b
/hi/g.exec(c).map(d)

a = b / hi / g.exec(c).map(d);

someFunction()
['ul', 'ol'].map(x => x + x)

const propKey = ('ul','ol');
assert.equal(propKey, 'ol'); // 因为逗号
someFunction()[propKey].map(x => x + x);

• 我喜欢它提供代码的视觉结构——你清楚地看到一个语句何时结束。
• 要记住的规则较少。
• 大多数 JavaScript 程序员使用分号。

• 自动代码格式化程序 Prettier 可以配置为不使用分号。然后它会自动修复问题。例如，如果它遇到以方括号开头的行，则它以分号为前缀。
• 静态检查器 ESLint 有一套你可以表述你的首选样式的规则（始终使用分号或尽可能少的分号），并向你对关键问题报警。

'use strict';

function functionInStrictMode() {
  'use strict';
}

function sloppyFunc() {
  unknownVar1 = 123;
}
sloppyFunc();
// Created global variable `unknownVar1`:
assert.equal(unknownVar1, 123);

function strictFunc() {
  'use strict';
  unknownVar2 = 123;
}
assert.throws(
  () => strictFunc(),
  {
    name: 'ReferenceError',
    message: 'unknownVar2 is not defined',
  });