再看JavaScript，那些遗漏或易混淆的知识点(1)

String(false); // 'false'
String(null); // 'null'

Number(undefined); // NaN
Number(null); // 0
Number(true); // 1
Number(false); // 0

Math.pow(4, 2); // 14
4**2; // 16
Math.pow(4, 1/2); // 2
4**(1/2); // 2

let a = (1 + 2, 3 + 4); // 7
let b = 1 + 2, 3 + 4; // Uncaught SyntaxError: Unexpected number

let a = 0;
Boolean(a); // false
let b = '0';
Boolean(b); // true

a == b; // true

null === undefined; // false

null == undefined; // true

null > 0; // false(1)
null == 0; // false(2)
null >= 0; // true(3)

undefined < 0; //false(1)
undefined > 0; //false(2)
undefined == 0; //false(3)

result = (a !== null && a !== undefined) ? a : b;
// 等同于
result = a ?? b;

// 这里的代码会先做这件事（……）然后做那件事（……）
// ……谁知道还有什么……
very;
complex;
code;

function showPrimes(n) {
  nextPrime:
  for (let i = 2; i < n; i++) {

    // 检测 i 是否是一个质数（素数）
    for (let j = 2; j < i; j++) {
      if (i % j == 0) continue nextPrime;
    }

    alert(i);
  }
}

function showPrimes(n) {

  for (let i = 2; i < n; i++) {
    if (!isPrime(i)) continue;

    alert(i);
  }
}

function isPrime(n) {
  for (let i = 2; i < n; i++) {
    if (n % i == 0) return false;
  }

  return true;
}

// 在这里我们添加威士忌
for(let i = 0; i < 10; i++) {
  let drop = getWhiskey();
  smell(drop);
  add(drop, glass);
}

// 在这里我们添加果汁
for(let t = 0; t < 3; t++) {
  let tomato = getTomato();
  examine(tomato);
  let juice = press(tomato);
  add(juice, glass);
}

addWhiskey(glass);
addJuice(glass);

function addWhiskey(container) {
  for(let i = 0; i < 10; i++) {
    let drop = getWhiskey();
    //...
  }
}

function addJuice(container) {
  for(let t = 0; t < 3; t++) {
    let tomato = getTomato();
    //...
  }
}

/**
 * 返回 x 的 n 次幂的值。
 *
 * @param {number} x 要改变的值。
 * @param {number} n 幂数，必须是一个自然数。
 * @return {number} x 的 n 次幂的值。
 */
function pow(x, n) {
  ...
}

let user = {
  name: "John",
  surname: "Smith"
};
user.age = 25; // 增加一个

// 非整数属性是按照创建的顺序来排列的
for (let prop in user) {
  alert( prop ); // name, surname, age
}

// Math.trunc 是内置的去除小数部分的方法。
alert( String(Math.trunc(Number("49"))) ); // "49"，相同，整数属性
alert( String(Math.trunc(Number("+49"))) ); // "49"，不同于 "+49" ⇒ 不是整数属性
alert( String(Math.trunc(Number("1.2"))) ); // "1"，不同于 "1.2" ⇒ 不是整数属性

let codes = {
  "49": "Germany",
  "41": "Switzerland",
  "44": "Great Britain",
  // ..,
  "1": "USA"
};

for(let code in codes) {
  alert(code); // 1, 41, 44, 49
}

let codes = {
  "+49": "Germany",
  "+41": "Switzerland",
  "+44": "Great Britain",
  // ..,
  "+1": "USA"
};

for (let code in codes) {
  alert( +code ); // 49, 41, 44, 1
}

let user = {
  name: "John",
  age: 30
};

let clone = {}; // 新的空对象

// 将 user 中所有的属性拷贝到其中
for (let key in user) {
  clone[key] = user[key];
}

// 现在 clone 是带有相同内容的完全独立的对象
clone.name = "Pete"; // 改变了其中的数据

alert( user.name ); // 原来的对象中的 name 属性依然是 John

let user = { name: "John" };

let permissions1 = { canView: true };
let permissions2 = { canEdit: true };

// 将 permissions1 和 permissions2 中的所有属性都拷贝到 user 中
Object.assign(user, permissions1, permissions2);

// 现在 user = { name: "John", canView: true, canEdit: true }

let user = { name: "John" };

Object.assign(user, { name: "Pete" });

alert(user.name); // 现在 user = { name: "Pete" }

比方说：

- 当前函数的局部变量和参数。
- 嵌套调用时，当前调用链上所有函数的变量与参数。
- 全局变量。
- （还有一些内部的）

这些值被称作 **根（roots）**。

function marry(man, woman) {
  woman.husband = man;
  man.wife = woman;

  return {
    father: man,
    mother: woman
  }
}

let family = marry({
  name: "John"
}, {
  name: "Ann"
});

delete family.father;
delete family.mother.husband;

family = null;

function User(name) {
  // this = {};（隐式创建）

  // 添加属性到 this
  this.name = name;
  this.isAdmin = false;

  // return this;（隐式返回）
}

function User() {
  alert(new.target);
}

// 不带 "new"：
User(); // undefined

// 带 "new"：
new User(); // function User { ... }

let user = {}; // 变量 user 没有 "address" 属性

alert(user.address.street); // Error!

alert( user && user.address && user.address.street ); // undefined（不报错）

let user = {}; // user 没有 address

alert( user?.address?.street ); // undefined （不报错）

let user = {}; // user 没有 address

alert( user.address?.street ); // undefined （不报错）

let user1 = {
  admin() {
    alert("I am admin");
  }
}

let user2 = {};

user1.admin?.(); // I am admin
user2.admin?.();

let user1 = {
  firstName: "John"
};

let user2 = null; // 假设，我们不能授权此用户

let key = "firstName";

alert( user1?.[key] ); // John
alert( user2?.[key] ); // undefined

alert( user1?.[key]?.something?.not?.existing); // undefined

let id1 = Symbol("id");
let id2 = Symbol("id");

alert(id1 == id2); // false

let id = Symbol("id");
alert(id); // Uncaught TypeError: Cannot convert a Symbol value to a string

let id = Symbol("myId");
alert(id.toString()); // Symbol('myId');

let id = Symbol("myId");
alert(id.description); // myId

// 从全局注册表中读取
let id = Symbol.for("id"); // 如果该 Symbol 不存在，则创建它

// 再次读取（可能是在代码中的另一个位置）
let idAgain = Symbol.for("id");

// 相同的 Symbol
alert( id === idAgain ); // true

let globalSymbol = Symbol.for("name");
let localSymbol = Symbol("name");

alert( Symbol.keyFor(globalSymbol) ); // name，全局 Symbol
alert( Symbol.keyFor(localSymbol) ); // undefined，非全局

alert( localSymbol.description ); // name

const object1 = {};
const a = Symbol('a');
const b = Symbol.for('b');
const c = 'notSymbol';

object1[a] = 'localSymbol';
object1[b] = 'globalSymbol';
object1[c] = 'notSymbol';

for (let key in object1) {
    console.log(key); // notSymbol
};

const object1 = {};
const a = Symbol('a');
const b = Symbol.for('b');
const c = 'notSymbol';

object1[a] = 'localSymbol';
object1[b] = 'globalSymbol';
object1[c] = 'notSymbol';

const objectSymbols = Object.getOwnPropertySymbols(object1);

console.log(objectSymbols.length);
// expected output: 2

const a = Symbol('a');
const b = Symbol.for('b');
const c = 'notSymbol';

const object1 = {
  [a]: 'localSymbol',
  [b]: 'globalSymbol',
  [c]: 'notSymbol'
};

const array1 = [];

console.log(Reflect.ownKeys(object1));
// expected output: Array ["notSymbol", Symbol(a), Symbol(b)]

console.log(Reflect.ownKeys(array1));
// expected output: Array ["length"]

let user = {
  name: "John",
  money: 1000,

  [Symbol.toPrimitive](hint) {
    alert(`hint: ${hint}`);
    return hint == "string" ? `{name: "${this.name}"}` : this.money;
  }
};

// 转换演示：
alert(user); // hint: string -> {name: "John"}
alert(+user); // hint: number -> 1000
alert(user + 500); // hint: default -> 1500

let user = {name: "John"};

alert(user); // [object Object]
alert(user.valueOf() === user); // true

let user = {
  name: "John",
  money: 1000,

  // 对于 hint="string"
  toString() {
    return `{name: "${this.name}"}`;
  },

  // 对于 hint="number" 或 "default"
  valueOf() {
    return this.money;
  }

};

alert(user); // toString -> {name: "John"}
alert(+user); // valueOf -> 1000
alert(user + 500); // valueOf -> 1500Symbol.toPrimitive

let user = {
  name: "John",

  toString() {
    return this.name;
  }
};

alert(user); // toString -> John
alert(user + 500); // toString -> John500

let a = { value : 0 };
a[Symbol.toPrimitive] = function(hint) {
	console.log(hint); // default
	return this.value += 1;
}
console.log(a == 1 && a == 2 && a == 3); // true

let a = { value : 0 };
a.valueOf = function() {
	return this.value += 1;
};
console.log(a == 1 && a == 2 && a == 3); // true

let a = { value : 0 };
a.toString = function() {
	return this.value += 1;
};
console.log(a == 1 && a == 2 && a == 3); // true