qunzi0214 / blog Goto Github PK

第一部分附录

动态作用域

function foo() {
  console.log(a); // 2
}

function bar() {
  var a = 3;
  foo();
}

var a = 2;

bar();

如果javascript具有动态作用域，则应该在调用处获得变量 a 的值（3）。而javascript中的 this 的机制和动态作用域很像

Traceur编译器

实际上，谷歌维护的 Traceur 编译器会把块级作用域编译成 try...catch （在es5或以下环境）

显式 let 声明

非官方标准

let (a = 2) {
  console.log(a); // 2
}

console.log(a); // ReferenceError

第二部分附录

es6 class 解决的问题

class Person {
  constructor(sex) {
    this.sex = sex;
  }

  speak() {
    console.log(`hi, i'm a person`);
  }
}

class Rango extends Person {
  constructor(sex, age, name) {
    super(sex);
    this.age = age;
    this.name = name;
  }

  speak() {
    super.speak();
    console.log(`hi, i'm ${this.name}`);
  }
}

const r = new Rango('male', 18, 'Rango');

r.speak();

1. 不会再引用杂乱的prototype
2. 可以通过 super 来实现相对多态
3. 可以通过 extends 很自然的扩展子类型，甚至是内置对象

es6 class 的陷阱

本质上是 prototype 机制的语法糖，子类仍然不是父类的复制，而是委托。同时 super 的绑定机制存在问题（待测试）。

一些个人理解

关于正确使用this机制

书中提倡正确包涵 this 机制（比如通过bind显式声明），而不是使用箭头函数等方式来混淆 this 绑定规则和词法作用域。个人觉得大同小异...

关于类风格和委托风格

书中对于强行将 javascript 的对象委托机制实现为类风格提出了批评。考虑到目前绝大多数前端框架仍然会使用类风格来编写程序，此处存疑，还需要后续知识储备更完善后重新判断

string, number, boolean

在 Typescript 存在3个常用的基本类型：string , number , boolean 。它们的命名和 Javascript 中对一个变量使用 typeof 操作符获得的值相同

使用 string number boolean 来做类型声明而非通过 String Number Boolean，因为后三者是某些场景下特定的内置类型

Arrays

想要指定一个数组的元素类型（比如 [1, 2, 3]），可以使用以下两种语法：

• number[]
• Array<number>

需要注意，[number] 是完全不同的东西，这种语法是用来声明元组的（确定元素数量与类型的数组）

any

在 Typescript 中存在一个特殊类型：any ，一旦某个变量被声明为 any ，Typescript 会在编译阶段放弃对它进行类型检查

这同时意味着，可以读写这个变量的任意属性、函数调用该变量、将任何类型的值复制给该变量或将该变量赋值给任意类型的其他变量

let obj: any = { x: 0 };
// None of the following lines of code will throw compiler errors.
// Using `any` disables all further type checking, and it is assumed 
// you know the environment better than TypeScript.
obj.foo();
obj();
obj.bar = 100;
obj = "hello";
const n: number = obj;

需要注意，一旦你没有指定某个变量的类型且 Typescript 无法通过上下文对其进行类型推论，编译器会默认该变量类型为 any。如果需要避免这种情况，可以设置 noImplicitAny 选项

Type Annotations on Variables

如果通过 var let const 来声明一个变量，那么类型注释是可选的：

• 通过类型注释显式声明变量类型

let myName: string = "Alice";

• Typescript 自动对变量进行类型推论

// No type annotation needed -- 'myName' inferred as type 'string'
let myName = "Alice";

Functions

在 Typescript 中，允许你同时指定函数参数以及返回值的类型：

• 参数类型注释

// Parameter type annotation
function greet(name: string) {
  console.log("Hello, " + name.toUpperCase() + "!!");
}

// Would be a runtime error if executed!
greet(42);

• 函数返回值类型注释

function getFavoriteNumber(): number {
  return 26;
}

和变量类似，通常不需要对函数返回值进行类型注释，因为 Typescript 会根据 return 语句进行类型推论

匿名函数会有些不同，Typescript 会根据匿名函数如何被调用来决定此函数入参的类型：

// No type annotations here, but TypeScript can spot the bug
const names = ["Alice", "Bob", "Eve"];

// Contextual typing for function
names.forEach(function (s) {
  console.log(s.toUppercase());
// Property 'toUppercase' does not exist on type 'string'. Did you mean 'toUpperCase'?
});

// Contextual typing also applies to arrow functions
names.forEach((s) => {
  console.log(s.toUppercase());
// Property 'toUppercase' does not exist on type 'string'. Did you mean 'toUpperCase'?
});

Object Types

对象类型是除基本类型之外最常见的类型，定义一个对象类型，只需简单的罗列出它的属性和属性类型：

// The parameter's type annotation is an object type
function printCoord(pt: { x: number; y: number }) {
  console.log("The coordinate's x value is " + pt.x);
  console.log("The coordinate's y value is " + pt.y);
}
printCoord({ x: 3, y: 7 });

定义对象类型，使用 ; 或 , 分隔符都是合法的

可选属性：

function printName(obj: { first: string; last?: string }) {
  // ...
}
// Both OK
printName({ first: "Bob" });
printName({ first: "Alice", last: "Alisson" });

在 Javascript 中，如果在对象上访问一个不存在的属性，会得到值 undefined 而不是一个运行时报错。鉴于此，在使用可选属性时，需要考虑到 undefined：

function printName(obj: { first: string; last?: string }) {
  // Error - might crash if 'obj.last' wasn't provided!
  console.log(obj.last.toUpperCase());
  // Object is possibly 'undefined'.
  if (obj.last !== undefined) {
    // OK
    console.log(obj.last.toUpperCase());
  }

  // A safe alternative using modern JavaScript syntax:
  console.log(obj.last?.toUpperCase());
}

Union Types

一种方式结合不同的类型是使用联合类型：

function printId(id: number | string) {
  console.log("Your ID is: " + id);
}
// OK
printId(101);
// OK
printId("202");
// Error
printId({ myID: 22342 });
// Argument of type '{ myID: number; }' is not assignable to parameter of type 'string | number'.
// Type '{ myID: number; }' is not assignable to type 'number'.

当在 Typesccript 中使用联合类型，只有当联合类型的每个成员都拥有某个方法和属性时，才允许访问：

function printId(id: number | string) {
  console.log(id.toUpperCase());
  // Property 'toUpperCase' does not exist on type 'string | number'.
  // Property 'toUpperCase' does not exist on type 'number'.
}

解决办法是通过代码 narrow（变窄） 联合类型。Narrowing 通常发生在 Typescript 能通过代码结构确定一个更特定的类型时：

function printId(id: number | string) {
  if (typeof id === "string") {
    // In this branch, id is of type 'string'
    console.log(id.toUpperCase());
  } else {
    // Here, id is of type 'number'
    console.log(id);
  }
}

另一个例子是 Array.isArray：

function welcomePeople(x: string[] | string) {
  if (Array.isArray(x)) {
    // Here: 'x' is 'string[]'
    console.log("Hello, " + x.join(" and "));
  } else {
    // Here: 'x' is 'string'
    console.log("Welcome lone traveler " + x);
  }
}

如果联合类型中的成员同时具有某个方法或属性，不需要通过 Narrowing 也可以直接访问：

// Return type is inferred as number[] | string
function getFirstThree(x: number[] | string) {
  return x.slice(0, 3);
}

Type Aliases

类型别名仅仅是给希望多次使用的任意类型一个名字，语法如下：

type Point = {
  x: number;
  y: number;
};

// Exactly the same as the earlier example
function printCoord(pt: Point) {
  console.log("The coordinate's x value is " + pt.x);
  console.log("The coordinate's y value is " + pt.y);
}

printCoord({ x: 100, y: 100 });

可以给任意类型赋予一个类型别名，不仅仅是对象类型。比如给联合类型赋予别名：

type ID = number | string;

需要注意，别名仅仅是别名，无法通过别名给同样的类型定义一个不同的、有区别的版本。

Interfaces

另一种方式给一个对象类型起名是通过接口定义：

interface Point {
  x: number;
  y: number;
}

function printCoord(pt: Point) {
  console.log("The coordinate's x value is " + pt.x);
  console.log("The coordinate's y value is " + pt.y);
}

printCoord({ x: 100, y: 100 });

Type Aliases 和 Interfaces 大多数情况非常类似，主要区别是别名无法通过重复定义的方式来新增属性：

• 扩展 interface

interface Animal {
  name: string
}

interface Bear extends Animal {
  honey: boolean
}

const bear = getBear() 
bear.name
bear.honey

• 扩展 type （通过交集）

type Animal = {
  name: string
}

type Bear = Animal & { 
  honey: Boolean 
}

const bear = getBear();
bear.name;
bear.honey;

• 给已存在的 interface 新增字段：

interface Window {
  title: string
}

interface Window {
  ts: TypeScriptAPI
}

const src = 'const a = "Hello World"';
window.ts.transpileModule(src, {});

• 给已存在的 type 新增字段：

type Window = {
  title: string
}

type Window = {
  ts: TypeScriptAPI
}

 // Error: Duplicate identifier 'Window'.

Type Assertions

某些情况下，你会比 Typescript 更了解某个值的类型信息。例如通过 document.getElementById ，Typescript 只知道会返回一个 HTMLElement 类型的值，但是你可能知道你的页面上会返回一个 HTMLCanvasElement 类型的值。

这种场景下，可以使用类型断言来指定一个更特定的类型：

const myCanvas = document.getElementById("main_canvas") as HTMLCanvasElement;

和类型注释一样，类型断言会被编译器移除，不会影响代码运行时

另一种方式使用类型断言是通过尖括号语法（ .tsx 文件不适用）：

const myCanvas = <HTMLCanvasElement>document.getElementById("main_canvas");

Typescript 仅允许通过类型断言将类型转换为更具体或更不具体的类型。该规则可防止出现“不可能”的强制转换：

const x = "hello" as number;
// Conversion of type 'string' to type 'number' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first.

有时候，这条规则过于保守，禁止了一些更复杂但有效的强制转换。解决办法是通过两次类型断言（先断言为 any 或 unknown）：

const a = (expr as any) as T;

Literal Types

除了基本类型 string 和 number，有时候需要指定某个更具体的字符串或数字

一种方式是 const：

let changingString = "Hello World";
changingString = "Olá Mundo";
// Because `changingString` can represent any possible string, that
// is how TypeScript describes it in the type system
// let changingString: string

const constantString = "Hello World";
// Because `constantString` can only represent 1 possible string, it
// has a literal type representation
// const constantString: "Hello World"

鉴于通常一个可变的变量不会只持有一个值，以下这种方式不是很有价值：

let x: "hello" = "hello";
// OK
x = "hello";
// Type '"howdy"' is not assignable to type '"hello"'.
x = "howdy";

如果通过联合类型结合字面量类型，可以表达出一个非常有用的概念：例如函数只能接受某些确定的值

function printText(s: string, alignment: "left" | "right" | "center") {
  // ...
}
printText("Hello, world", "left");
printText("G'day, mate", "centre");
// Argument of type '"centre"' is not assignable to parameter of type '"left" | "right" | "center"'.

数字的字面量类型工作方式是一样的：

function compare(a: string, b: string): -1 | 0 | 1 {
  return a === b ? 0 : a > b ? 1 : -1;
}

当然，也可以结合字面量类型和非字面量类型：

interface Options {
  width: number;
}
function configure(x: Options | "auto") {
  // ...
}
configure({ width: 100 });
configure("auto");
configure("automatic");
// Argument of type '"automatic"' is not assignable to parameter of type 'Options | "auto"'.

还有最后一种字面量类型：布尔值字面量类型，类型 boolean 本身就是布尔值字面量类型 true | false 的别名

在定义一个对象时，Typescript 不会将该对象的属性推论为字面量类型，例如以下例子中 counter 被推论为 number 类型而不是 0 类型：

const obj = { counter: 0 };
if (someCondition) {
  obj.counter = 1;
}

考虑如下场景，req.method 被推论为 string，在 req 被初始化，和 handleRequest 被调用之间，该值可能会被重新赋予一个字符串，Typescript会认为这是个错误：

function handleRequest(url: string, method: "GET" | "POST")

const req = { url: "https://example.com", method: "GET" };
handleRequest(req.url, req.method);
// Argument of type 'string' is not assignable to parameter of type '"GET" | "POST"'.

解决办法如下：

1. 通过类型断言改变类型推论：

// Change 1:
const req = { url: "https://example.com", method: "GET" as "GET" };
// Change 2
handleRequest(req.url, req.method as "GET");

Change 1 表示，req.method 会保持持有字面量类型 GET，此字段被重新赋值 GUESS 是不可能发生的（如果发生了编译会不通过）
Change 2 表示，我能确定因为某些原因，req.method 肯定持有值 GET

2. 使用 as const 将整个对象所有属性转变为字面量类型：

const req = { url: "https://example.com", method: "GET" } as const;
handleRequest(req.url, req.method);

null and undefined

在 Javascript 中，有两个基本值 null 、undefined 代表缺省或未初始化，Typescript 中同样有两个名字一致相应的类型，这两种类型如何表现取决于 strictNullChecks 选项是否打开。

• 当 strictNullChecks 关闭时：

null 、undefined值可以正常访问，也可以用来赋予声明为任意类型的变量或属性。然而缺少了类型检查，这些值会导致大量bug，推荐打开 strictNullChecks 选项

• 当 strictNullChecks 打开时：

当一个值是 null 或 undefined，在使用这个值之前必须确保这个值拥有相应的属性或方法，类似于通过 Narrowing 来使用可选属性：

function doSomething(x: string | null) {
  if (x === null) {
    // do nothing
  } else {
    console.log("Hello, " + x.toUpperCase());
  }
}

Non-null 类型断言操作符：

Typescript 中有一个特殊的语法，用来移除某个类型的 null 和 undefined，即表示，此值不可能为 null 或 undefined：

function liveDangerously(x?: number | null) {
  // No error
  console.log(x!.toFixed());
}

和其他类型断言一样，这段代码不会对运行时产生影响，因此在使用 ! 操作符前，必须确保你知道这个值真的不可能是 null 或 undefined

Enums

枚举类型是对 Javascript 的一个扩展，允许给一组可以命名的值增加描述（太绕了，看例子），和其他 Typescript 特性不同，枚举类型是一个运行时的特性：

enum Color { Red, Blue, Green }

编译后的 Javascript ：

var Color;
(function (Color) {
  Color[Color["Red"] = 0] = "Red";
  Color[Color["Blue"] = 1] = "Blue";
  Color[Color["Green"] = 2] = "Green";
})(Color || (Color = {}));

Less Common Primitives

bigint：ES2020之后，推出的一个新基本类型，用来存储一个非常大的整数

// Creating a bigint via the BigInt function
const oneHundred: bigint = BigInt(100);

// Creating a BigInt via the literal syntax
const anotherHundred: bigint = 100n;

symbol：通过 Symbol() 函数创建一个全局独一无二的引用类型：

const firstName = Symbol("name");
const secondName = Symbol("name");

if (firstName === secondName) {
// This condition will always return 'false' since the types 'typeof firstName' and 'typeof secondName' have no overlap.
  // Can't ever happen
}

内置类型

• 空值（null）
• 未定义（undefined）
• 布尔值（boolean）
• 数字（number）
• 字符串（string）
• 对象（object）
• 符号（symbol）

复习下字面量和构造初始化区别：boolean、string、number字面量与对应的内置对象不等同，null和undefined没有构造形式，而Object、Array、Function和RegExp无论使用字面量还是构造形式来声明，他们都是对象。同时，javascript在操作基本类型的时候自动将之转化为内置对象

可以用 typeof 操作符来查看值的类型
typeof 对 null 的处理有问题，但是这个bug由来已久，今后也未必会修复

typeof undefined   // 'undefined'
typeof true   // 'boolean'
typeof 42   // 'number'
typeof '42'   // 'string'
typeof {}   // 'object'
typeof Symbol()   // 'symbol'
typeof null   // 'object'

函数和数组都是 object 的子类型。函数是可调用对象，不仅如此，函数同样可以拥有属性

typeof [1, 2, 3] // 'object'

typeof function a (b, c) {} // 'function'

a.length // 2 (参数的个数)

值和类型

javascript中变量是没有类型的，只有值才有。变量在未持有值的时候是 undefined 。此时 typeof 返回 "undefined" 。而没有在作用域中声明的变量，是 undeclared 的（运行时会报错）。同时，typeof 有一个特殊的安全防范机制，可以使其对 undeclared 的变量进行操作时同样返回 undefined 而不报错，可以利用这个机制来处理变量是否存在的问题

var helper = (typeof doSomething !== 'undefined')
  ? doSomething
  : function() { /* do something */ }

helper()

还有一种方式是，通过全局对象 window 属性访问的方式来避免报错，只不过这种方式不适用于多 javascript 环境，因为此时无法保证全局对象是 window

var helper = window.doSomething
  ? window.doSomething
  : function() { /* do something */ }

helper()

作用域是什么

var 关键字会导致变量提升的本质：

javascript是在运行前极短的时间内被编译的，var a = 2 实际上是两个动作：编译器会在当前作用域声明变量a（如果之前没被声明过），紧接着运行时引擎在作用域内寻找该变量，如果能找到就对它进行赋值。

LHS 和 RHS

var a = 2 // 此时对变量a是LHS查询，即找到变量本身的容器
console.log(a) // 此时对变量a是RHS查询，即找到变量对应的值（引用）

关于左右侧查询的异常

function foo(a) {
  console.log(a + b); // ReferenceError: 对b进行RHS报错
  b = a; // 对b进行LHS会在全局创建一个b
}

foo(2);

// 严格模式下对未声明的变量进行 LHS 或 RHS 都会报错

ReferenceError 和作用域判别失败相关，而 TypeError 代表作用域判别成功了，但是对结果的操作是非法的

词法作用域

词法阶段

1. 词法作用域查找从内向外，找到第一个匹配的标识符停止
2. 可以通过 window.a 的方式访问那些被同名变量遮蔽的全局变量
3. 函数的词法作用域只由函数被声明时的位置决定
4. 词法作用域只会查找一级标识符，foo.bar.baz 只会查找到 foo ，后续会交给对象属性访问规则

欺骗词法（eval 和 with）

function foo(str, a) {
  eval(str); // 严格模式下有自己的词法作用域
  console.log(a, b);
}

var b = 2;

foo('var b = 3;', 1);

function foo(obj) {
  with(obj) {
    a = 2;
  }
}

var obj1 = { a: 1 };
foo(obj1);
console.log(obj1.a); // 2
console.log(a); // ReferenceError
var obj2 = { b: 3 };
foo(obj2);
console.log(obj2.a); // undefined
console.log(a); // 2

// with会基于传入的对象生成一个全新的词法作用域，当obj2作为作用域时，其中没有a标识符，因此进行了正常的LHS查找，最终在全局创建了一个变量a

词法分析阶段基本能够知道全部的标识符在什么位置，从而可以预测以及优化运行时对它们的查找。因此欺骗词法会导致性能问题

函数作用域、块作用域

函数声明与函数表达式

如果function是声明中的第一个词，那么就是一个函数声明，否则是一个函数表达式。它们的区别是函数声明会将函数绑定在所在作用域中，而函数表达式会将函数绑定在自身的函数中。

为什么不推荐匿名函数

1. 在函数调用栈中没有函数名，会导致调试困难
2. 当函数需要引用自身时，只能使用已经过期的 arguments.callee （递归或是事件监听器需要解绑）
3. 代码失去可读性

块级作用域对垃圾回收机制的优化

function process(data) {
  // do something
}

{
  let bigData = {};
  process(bigData);
}

var btn = document.getElementById('btn');
btn.addEventListener('click', function click(e) {
  // do something
}, false);

回调函数 click 形成了一个覆盖整个作用域的闭包，javascript引擎极有可能在 process 函数执行后还保留着
bigData （？！）。如果使用块级作用域，可以告诉引擎不需要保留 bigData 了

作用域闭包

定义

当函数可以记住并访问所在的词法作用域时，就产生了闭包，即使函数是在当前词法作用域之外执行。

闭包和模块模式运用

var foo = (function CoolModule(id) {
  function change() {
    publicAPI.identify = identify2;
  }

  function identify1() {
    console.log(id);
  }

  function identify2() {
    console.log(id.toUpperCase());
  }

  var publicAPI = {
    change: change,
    identify: identify1,
  };

  return publicAPI;
})('some string');

foo.identify(); // some string
foo.change();
foo.identify; // SOME STRING

requireJS原理

var MyModule = (function Manager() {
  var modules = {};

  function define(name, deps, impl) {
    for (var i = 0; i < deps.length; i++) {
      deps[i] = modules[deps[i]];
    }
    modules[name] = impl.apply(impl, deps);
  }

  function get(name) {
    return modules[name];
  }

  return {
    define: define,
    get: get,
  };
})();

MyModule.define('bar', [], function () {
  function hello(who) {
    return 'hello ' + who;
  }

  return {
    hello: hello,
  }
});

MyModule.define('foo', ['bar'], function (bar) {
  function awesome() {
    console.log(bar.hello('Rango').toUpperCase());
  }

  return {
    awesome: awesome,
  }
});

var foo = MyModule.get('foo');
foo.awesome(); // HELLO RANGO

TODO：等手上有闲置机器来折腾，先用macOS继续学习

题目如下：

给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, ...）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。

示例 1:

输入: n = 12
输出: 3 
解释: 12 = 4 + 4 + 4.
示例 2:

输入: n = 13
输出: 2
解释: 13 = 4 + 9.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/perfect-squares
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路一（BFS）：

1. 找到小于 n 的所有平方数，存入数组 squaresNum ；
2. 将组合 '0000...' (长度等于squaresNum长度) 入队；
3. 出队；
4. 如果当前出队组合计算后等于 n 终止循环；
5. 找到所有当前出队组合任意位置 + 1后的新组合；
6. 如果新组合已经存在 visited 中或计算后大于 n ，跳过。否则加入队列；
7. 重复操作 3 - 6；

var numSquares = function(n) {
    
    const squaresNum = []; // 找出所有小于n的平方数
    
    let i = 1;
    while(i * i <= n) {
        if(i * i === n) {
            return 1;
        }
        
        squaresNum.push(i * i);
        i++;
    }
    
    const visited = new Set();
    const queue = [];
    let countStr = new Array(squaresNum.length).fill(0).join('');
    queue.push(countStr);
    visited.add(countStr);
    
    while(queue.length) {
        const currentStr = queue.shift();
        
        if(calculateSum(squaresNum, currentStr, n) === 0) {
            countStr = currentStr;
            break;
        }
        
        for(let i = 0; i < currentStr.length; i++) {
            const nextStr = getNextStr(currentStr, i);
            if(calculateSum(squaresNum, nextStr, n) <= 0 && (!visited.has(nextStr))) {
                queue.push(nextStr);
                visited.add(nextStr);
            }
        }
    }
    
    return countStr.split('').reduce((a, b) => parseInt(a) + parseInt(b));
};

// 计算总值和目标值关系 大于返回1， 等于返回0， 小于返回-1
function calculateSum(squaresNum, countStr, target) {
    let sum = 0;
    for(let i = 0; i < squaresNum.length; i++) {
        sum += squaresNum[i] * parseInt(countStr[i]);
    }
    return sum === target ? 0 : sum > target ? 1 : -1;
}

// 生成下一轮字符串
function getNextStr(currentStr, index) {
    const arr = currentStr.split('');
    arr[index] = parseInt(arr[index]) + 1 + '';
    return arr.join('');
}

问题：当传入n足够大时，每次出队组合对应的新组合太多，会超时

解题思路二（DP）：

类似斐波那契数列优化后，用迭代代替递归计算第 n 位的数字
保存中间值以免反复计算

1. 初始化 dp 为长度 n+1 的数组，并填充0；
2. dp[0] = 0 对应了0是0个平方数的和，即0的最优解为0；
3. 从第1位开始遍历数组；
4. 遍历当前位置 i 时，先假设最优解 dp[i] = i (i个1的和) ；
5. 找到所有小于 i 的平方数 k ， dp[i] = min(dp[i - k] + 1); ∀k∈小于等于i的平方数 ；
6. 更新 dp[i]

动态转移方程的理解：
对于正整数 i ，它的最优解肯定是之前某一整数（包括0）的最优解加上1（之前某一整数加一个平方数），遍历所有小于 i 的平方数 k，找到最小的那个 dp[i - k] ，那么加上1就是 i 的最优解

var numSquares = function(n) {
    if(n === 0) {
        return 0;
    }
    
    const dp = new Array(n + 1).fill(0);
    
    for(let i = 1; i <= n; i++) {
        dp[i] = i; // 最坏的情况 3 = 1 + 1 + 1
        for(let j = 1; i - j * j >= 0; j++) {
            dp[i] = Math.min(dp[i], dp[i - j * j] + 1);
        }
    }
    return dp[n];
};

用户组

用户的三种身份

• 文件拥有者
• 用户组
• 其他人

文件权限概念

文件属性

使用命令 ls -al 查看当前目录所有文件以及详细属性

$ ls -al
drwxr-xr-x   8 rango  staff    256 11 18 14:36 .npm

文件权限：

第一个字符代表文件类型：

• d(directory) 目录
• - 常规文件
• l(link) 链接文件
• c(character) 设备文件里面串行端口设备（键盘、鼠标）
• b(block) 设备文件里面可供存储的周边设备（硬盘）
• s(socket) 数据接口文件
• p(pipe) 数据传送文件，FIFO(first in fisrt out)

接下来的字符三个为一组，切均为 rwx 三个字母的组合，代表可读（read）、可写（write）、可执行（execute），如果显示为 - ，则代表不具备此权限

• 第一组为文件拥有者权限
• 第二组为加入用户组后的权限
• 第三组为其他人权限

权限对文件/目录的含义

修改文件属性与权限

chgrp change group

修改文件所属用户组，要被修改的组名必须要在 /etc/group 中存在，-R 选项代表递归修改目录下子目录及文件的用户组

$ chgrp [-R] groupname filename/dirname

chown change owner

修改文件拥有者，要被修改的用户必须要在 /etc/passwd 中存在，-R 选项代表递归修改目录下子目录及文件的拥有者。这条命令还可以一次性同时修改拥有者和用户组

$ chown [-R] username filename/dirname
$ chown [-R] username:groupname filename/dirname

chmod 修改权限

使用数字的方式：

• 权限对应数值：r 的值是4， w 的值是2， x 的值是1
• 每一组权限最终的值，是3个权限的数值和
• 例子： -rwxrw---x 对应的权限数字是 761（owner = 4 + 3 + 1 = 7, group = 4 + 2 = 6, other = 1）

$ chmod [-R] 777 filename/dirname    #将该文件/目录权限设置为 -rwxrwxrwx

使用符号的方式：

• 权限组符号： u user， g group， o others， a all
• 设置符号： + 加入权限， - 减去权限， = 设置权限

$ chmod u=rwx,go=rx filename/dirname    #-rwxr-xr-x
$ chmod a+w filename/dirname    #-rwxrwxrwx

Linux 目录配置

目录配置依据FHS(Filesystem Hierarchy Standard)

• 可分享：可以分享给网络上其他主机挂载用的目录
• 不可分享：自己机器上面运行的设备文件或是与程序相关的socket文件等
• 不变：函数库、文件说明、主机服务配置文件等不会经常变动的文件
• 可变动：日志文件、一般用户可自行接收的新闻组等经常修改的数据

实际上，FHS针对目录仅定义出三层目录下面应该放置什么数据：

• /（root，根目录） ：与启动系统有关
• /usr（unix software resource） ：与软件安装/执行有关
• /var（variable） ：与系统的运行过程有关

/（root）

/usr

/var

第一部分 作用域和闭包
第二部分 this和对象原型
附录及个人理解

题目如下：

给定一个非空字符串 s，最多删除一个字符。判断是否能成为回文字符串。

示例 1:

输入: "aba"
输出: True
示例 2:

输入: "abca"
输出: True
解释: 你可以删除c字符。
注意:

字符串只包含从 a-z 的小写字母。字符串的最大长度是50000。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/valid-palindrome-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路一：

对于这个加强版验证回文，首先很容易想到的就是在判别普通回文方法的基础上升级。
当字符串不符合回文格式时，遍历每一个字符串删除后是否符合回文格式。

很显然的问题是，极大提高了时间复杂度，有没有更好的方式呢？

解题思路二：

设定左右两个游标，通过逐一比对的方式验证是否满足回文格式，同时如果不满足，左或者右游标可以跳过一次当前字符（即删除当前字符）。

同时考虑一下边界情况，如果left = right - 1 且 删除机会并没有使用，那么意味着前面的比对都通过了，且字符串长度为偶数，那么任意删除当前左右游标的字符，肯定能生成一个满足回文格式的字符串。代码如下

var validPalindrome = function(s) {
    let left = 0;
    let right = s.length - 1;
    let chance = 1;
    while(left < right - 1){
        if(s[left] === s[right]){
            left++;
            right--;
        }
        else if(s[left + 1] === s[right] && chance > 0){
            console.log('左边删除', s[left]);
            left++;
            chance--;
        }
        else if(s[right - 1] === s[left] && chance > 0){
            console.log('右边删除', s[right]);
            right--;
            chance--;
        }
        else {
            return false;
        }
    }
    return true;
};

然而事情并没有结束
其中一条没有通过的测试用例是这样的

"aguokepatgbnvfqmgmlcupuufxoohdfpgjdmysgvhmvffcnqxjjxqncffvmhvgsymdjgpfdhooxfuupuculmgmqfvnbgtapekouga"

提取出问题发生的核心位置，即：
"cuppucu"这个字符串。

很显然走我的判断函数，那么会删除掉左边的字符c，然后无法形成回文，但是如果删除右边的字符u，是可以生成回文的 (╬￣皿￣)

可以通过再次移动左右游标来排除这种情况，最终代码：

var validPalindrome = function(s) {
    let left = 0;
    let right = s.length - 1;
    let chance = 1;
    while(left < right - 1){
        if(s[left] === s[right]){
            left++;
            right--;
        }
        else if(s[left + 1] === s[right] && s[left + 2] === s[right - 1] && chance > 0){
            left++;
            chance--;
        }
        else if(s[right - 1] === s[left] && s[right - 2] === s[left + 1] && chance > 0){
            right--;
            chance--;
        }
        else {
            return false;
        }
    }
    return true;
};

附上结果：

想象下有个函数 padLeft，它要实现的功能是：如果参数 padding 是 number 类型，表示会在参数 input 前增加多少个空格。如果参数 padding 是 string 类型，直接加在参数 input 前：

function padLeft(padding: number | string, input: string) {
  return new Array(padding + 1).join(" ") + input;
  // Operator '+' cannot be applied to types 'string | number' and 'number'.
}

Typescript 报错，并提示 number 类型和 number | string 类型相加可能不是我们想要的结果。因此需要在使用前显式的检测参数 padding 是不是 number 类型：

function padLeft(padding: number | string, input: string) {
  if (typeof padding === "number") {
    return new Array(padding + 1).join(" ") + input;
  }
  return padding + input;
}

Typescript 会分析运行时代码并和静态类型结合：if/else 结构的控制流、三目表达式、循环等等。在上面的例子中，Typescript 在 if 语句中看到 typeof padding === "number" 并了解到这是一种叫 type guard 的特殊形式代码，并根据程序可能的执行路径分析出一个更具体的类型。类似这种特殊的检查被称为 Narrowing

typeof type guards

在 Javascript 中，typeof 操作符会在运行时返回操作值的基本类型信息字符串：

• string
• number
• bigint
• boolean
• symbol
• undefined
• object
• function

Typescript 甚至兼容了许多 Javascript 的“怪癖”，例如对 null 使用 typeof 操作符会返回 object：

function printAll(strs: string | string[] | null) {
  if (typeof strs === "object") {
    for (const s of strs) {
      // Object is possibly 'null'.
      console.log(s);
    }
  } else if (typeof strs === "string") {
    console.log(strs);
  } else {
    // do nothing
  }
}

在这个例子中，strs 仅仅被 narrow 至类型 string[] | null 而不是 string[]，因此 Typescript 会报错

Truthiness narrowing

在 Javascript 中，可以在条件判断语句（ if && || ! ）中使用任意表达式，例如 if 语句并不要求括号中必须是 boolean 类型，它会将括号中的值/语句强制类型转化为 boolean 类型的值去做判断。以下这些值会被转换为 false ：

• 0
• NaN
• ""
• 0n(the bigint version of zero)
• null
• undefined

而其他值都会被转换为 true。始终可以通过 Boolean 函数或者双重否定表达式 !! 来将某个值转化为 boolean 类型的值（需要注意的是，前者在 Typescript 中会被类型推论为 boolean，而后者会被推论为一个字面量布尔类型 true ?）

// both of these result in 'true'
Boolean("hello"); // type: boolean, value: true
!!"world";        // type: true,    value: true

这里自己测试结果是都推论为布尔类型，双重否定并没有推论为字面量布尔类型

修改上面的 printAll 函数，加入 truthiness narrowing，会发现 Typescript 的报错消失了：

function printAll(strs: string | string[] | null) {
  if (strs && typeof strs === "object") {
    for (const s of strs) {
      console.log(s);
    }
  } else if (typeof strs === "string") {
    console.log(strs);
  }
}

需要记住，对基本类型做真实性检查通常会引发错误，考虑以下代码：

function printAll(strs: string | string[] | null) {
  // !!!!!!!!!!!!!!!!
  //  DON'T DO THIS!
  //   KEEP READING
  // !!!!!!!!!!!!!!!!
  if (strs) {
    if (typeof strs === "object") {
      for (const s of strs) {
        console.log(s);
      }
    } else if (typeof strs === "string") {
      console.log(strs);
    }
  }
}

这里用一个真实性检查包裹了整个函数体，但是有一个微妙的问题：忽略了处理空字符串场景

对于不熟悉 Javascript 的人来说，这是需要注意的情况。Typescript 可以帮助我们更早的捕获错误，但是如果我们对某个值不做任何操作，它仅能在不过度规定的情况下做这么多（没看懂，个人理解是处理不了这种情况）。如果需要，可以使用类似 linter 这样的工具

最后一点关于 Truthiness narrowing，布尔否定 ! 时，Typescript 会从否定分支进行 narrowing：

function multiplyAll(
  values: number[] | undefined,
  factor: number
): number[] | undefined {
  if (!values) {
    return values;
  } else {
    return values.map((x) => x * factor);
  }
}

Equality narrowing

Typescript 同样会使用 switch 语句，相等检查例如 === !== == != 来进行 narrowing：

function example(x: string | number, y: string | boolean) {
  if (x === y) {
    // We can now call any 'string' method on 'x' or 'y'.
    x.toUpperCase();
    y.toLowerCase();
  } else {
    console.log(x);
    // (parameter) x: string | number
    console.log(y);
    // (parameter) y: string | boolean
  }
}

以上代码中，当我们确保 x 和 y 值和类型都相同时，Typescript 会发现它们只有一个公用类型 string，所以在此分支中，可以直接使用任意字符串方法

检查是否特定类型的字面量也是生效的，考虑如下代码，通过特定检查，Typescript 正确的将 null 类型从 strs 上过滤掉了：

function printAll(strs: string | string[] | null) {
  if (strs !== null) {
    if (typeof strs === "object") {
      for (const s of strs) {
        // (parameter) strs: string[]
        console.log(s);
      }
    } else if (typeof strs === "string") {
      console.log(strs);
      // (parameter) strs: string
    }
  }
}

Javascript 的宽松相等 == != 在 Typescript 中也可以正确的 narrowing。在宽松相等中，检查某个值是否 null 不仅仅是特定值 null 本身，同样也检查是否是 undefined，反之亦然（不管怎么说还是不要用宽松相等了...）：

interface Container {
  value: number | null | undefined;
}

function multiplyValue(container: Container, factor: number) {
  // Remove both 'null' and 'undefined' from the type.
  if (container.value != null) {
    console.log(container.value);
    // (property) Container.value: number

    // Now we can safely multiply 'container.value'.
    container.value *= factor;
  }
}

The in operator narrowing

在 Javascript 中，可以通过 in 操作符来判断某个属性是否存在一个对象中。Typescript 可以通过这种方式来 narrowing：

type Fish = { swim: () => void };
type Bird = { fly: () => void };

function move(animal: Fish | Bird) {
  if ("swim" in animal) {
    return animal.swim();
    // (parameter) animal: Fish
  }

  return animal.fly();
  // (parameter) animal: Bird
}

需要注意的是，可选属性在 narrowing 时，会同时存在于两边：

type Fish = { swim: () => void };
type Bird = { fly: () => void };
type Human = {  swim?: () => void, fly?: () => void };

function move(animal: Fish | Bird | Human) {
  if ("swim" in animal) { 
    animal
    // (parameter) animal: Fish | Human
  } else {
    animal
    // (parameter) animal: Bird | Human
  }
}

instanceof narrowing

在 Javascript 中，x instanceof Foo 可以检查 Foo.prototype 是否存在于 x 的原型链中。同样的，Typescript 中可以通过 instanceof 来 narrowing：

function logValue(x: Date | string) {
  if (x instanceof Date) {
    console.log(x.toUTCString());
    // (parameter) x: Date
  } else {
    console.log(x.toUpperCase());
    // (parameter) x: string
  }
}

Assignments

当我们给一个变量赋值时，Typescript 会分析赋值表达式右侧，并 narrowing 合适的左侧类型：

let x = Math.random() < 0.5 ? 10 : "hello world!";
// let x: string | number

x = 1;
console.log(x);
// let x: number

x = "goodbye!";
console.log(x);
// let x: string

x = true
// Type 'boolean' is not assignable to type 'string | number'.

这里需要注意，尽管在 x = 1 这个赋值表达式之后，可以观察到 x 的类型为 number ，但仍旧可以将 string 类型的值赋予 x 。这是因为 x 的声明类型（即最初的类型）是 string | number

Control flow analysis

基于“流程上是否可到达”的分析也被称作控制流分析。Typescript 会根据控制流 narrowing 类型 — 当变量遇到类型守卫或赋值表达式。当一个变量被分析时，控制流可能一次又一次的拆分或重新合并，在每一个拆分点或合并点，变量都会被观测到不同的类型：

function example() {
  let x: string | number | boolean;
  x = Math.random() < 0.5;
  console.log(x);
  // let x: boolean

  if (Math.random() < 0.5) {
    x = "hello";
    console.log(x);
    // let x: string
  } else {
    x = 100;
    console.log(x);
    // let x: number
  }

  return x;
  // let x: string | number
}

Using type predicates

截至目前，我们已经通过 Javascript 的结构来处理 narrowing，但是有时候我们可能想要更直接的在代码中操作类型变化

想要定义一个自定义 type guard，仅需要简单的定义一个返回值是 type predicate 的函数：

function isFish(pet: Fish | Bird): pet is Fish {
  return (pet as Fish).swim !== undefined;
}

此例中，pet is Fish 就是 type predicate（类型谓语？） ，类型谓语总是 parameterName is Type 这种形式（ parameterName 必须存在于当前函数签名中）

任何时候，当 isFish 被调用，Typescript 都可以进行 narrowing：

let pet = getSmallPet();
// let pet: Fish | Bird

if (isFish(pet)) {
  pet.swim();
  // let pet: Fish
} else {
  pet.fly();
  // let pet: Bird
}

也可以通过类型守卫 isFish 来过滤一个 Fish | Bird 数组，获得一个 Fish 数组：

const zoo: (Fish | Bird)[] = [getSmallPet(), getSmallPet(), getSmallPet()];
const underWater1: Fish[] = zoo.filter(isFish);
// or, equivalently
const underWater2: Fish[] = zoo.filter(isFish) as Fish[];

// The predicate may need repeating for more complex examples
const underWater3: Fish[] = zoo.filter((pet): pet is Fish => {
  if (pet.name === "sharkey") return false;
  return isFish(pet);
});

Discriminated unions

思考如下代码，定义一个 Shape 接口，kind 字段是一个联合字面量类型（防止拼写错误）。同时，当图形为圆时，我们关注的是 radius 字段，当图形为正方形时，则是 sideLength ，因此这两个字段是可选的：

interface Shape {
  kind: "circle" | "square";
  radius?: number;
  sideLength?: number;
}

当我们想要编写一个 getArea 函数（基于是圆形还是正方形计算面积）：

function getArea(shape: Shape) {
  return Math.PI * shape.radius ** 2;
  // Object is possibly 'undefined'.
}

如果设置了 strictNullChecks 配置项，会获得一个错误，radius 可能是没有定义的。如果我们尝试通过 kind 字段来优化这个问题呢？

function getArea(shape: Shape) {
  if (shape.kind === "circle") {
    return Math.PI * shape.radius ** 2;
    // Object is possibly 'undefined'.
  }
}

Typescript 依旧不会理解这里到底要做什么。在此处，我们对于类型的了解比 Typescript 要多，可以尝试用 non-null 断言告诉 Typescript radius 一定存在：

function getArea(shape: Shape) {
  if (shape.kind === "circle") {
    return Math.PI * shape.radius! ** 2;
  }
}

但是这种方式仍然不理想且容易出错。另外，如果不设置 strictNullChecks，虽然可以随意访问任何属性，但是也同样极容易导致错误（可选属性会被假设为始终存在）

问题在于类型检查器没有任何途径根据 kind 属性知道 radius 或 sideLength 是否存在，考虑到这个问题，可以换一种方式来定义 Shape：

interface Circle {
  kind: "circle";
  radius: number;
}

interface Square {
  kind: "square";
  sideLength: number;
}

type Shape = Circle | Square;

这里，我们拆分了 Shape 变成两个类型，同时 radius 和 sideLength 不再是可选属性，而是必选属性。此时如果访问 Shape 类型的 radius 属性：

function getArea(shape: Shape) {
  return Math.PI * shape.radius ** 2;
  // Property 'radius' does not exist on type 'Shape'.
  // Property 'radius' does not exist on type 'Square'.
}

当我们使用可选属性时，Typescript 仅能警告这条属性可能不存在。当联合两个接口时，Typescript 会告诉我们 Shape 有可能是 Square，而 Square 上不存在 radius 属性！

与此同时，如果再次尝试检查 kind 属性：

function getArea(shape: Shape) {
  if (shape.kind === "circle") {
    return Math.PI * shape.radius ** 2;
    // (parameter) shape: Circle
  }
}

错误消失了！当一个联合类型中的所有成员都有同一个属性时（此属性必须是字面量类型），Typescript 会认为这是一个 discriminated union，并可以根据此属性来 narrow 联合类型的成员，此例中 kind 会被认为是 Shape 的“区别属性”。同样的，switch 语句也可以正常生效：

function getArea(shape: Shape) {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
      // (parameter) shape: Circle
    case "square":
      return shape.sideLength ** 2;
      // (parameter) shape: Square
  }
}

The never type

如果我们通过 narrowing，在某个点排除了所有可能的类型，那么此时，Typescript 会使用 never 类型来表示这种不应该不存在的状态

Exhaustiveness checking

never 类型可以赋予任何类型，但是任何类型都不能赋予 never 类型（除了 never 本身），可以依靠这个特性，在 switch 语句中做一个是否穷尽判断：

type Shape = Circle | Square;

function getArea(shape: Shape) {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "square":
      return shape.sideLength ** 2;
    default:
      const _exhaustiveCheck: never = shape;
      return _exhaustiveCheck;
  }
}

如果在此时给联合类型新增一个成员，Typescript 会报错：

interface Triangle {
  kind: "triangle";
  sideLength: number;
}

type Shape = Circle | Square | Triangle;

function getArea(shape: Shape) {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "square":
      return shape.sideLength ** 2;
    default:
      const _exhaustiveCheck: never = shape;
      // Type 'Triangle' is not assignable to type 'never'.
      return _exhaustiveCheck;
  }
}

值类型转换

应该将JavaScript中的类型转换区分为：显式强制类型转换（发生在编译阶段）、隐式强制类型转换（发生在运行时）

强制类型转换总是返回基本类型值，不会返回对象或函数。为基本类型值（除 object ）封装一个相应类型的对象，并非严格意义上的强制类型转换

var a = 42
var b = a + '' // 隐式强制类型转换
var c = String(a) // 显式强制类型转换

除了字面意思意外，两种转换在行为特征上也有一定差别

抽象值操作

ToString

基本类型值的字符串化规则为：

• null 转化为 'null'

• undefined 转化为 'undefined'

• true 转化为 'true'

• 数字遵循通用规则，不过极大或极小的数字会使用指数形式

  var a = 1.07 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000
  a.toString() // '1.07e+21'

• 对于普通对象来说，除非自行定义，否则会调用 Object.prototype.toString() 返回内部属性 [[Class]] 的值

• 数组的 toString() 方法重新定义过

  [1, 2, 3].toString() // '1,2,3'

工具函数 JSON.stringify() 在将JSON对象序列化为字符串时也会调用 toString() ，但是它并非是严格意义上的强制类型转换。对于大多数简单值来说，JSON.stringify() 和 toString() 效果相同

JSON.stringify('aa') // ""aa""
JSON.stringify(42) // "42"
JSON.stringify(null) // "null"
JSON.stringify(true) // "true"

所有安全的JSON值（JSON-safe）都可以用 JSON.stringify() 字符串化。对于不安全的JSON值（ undefined function symbol 循环引用的对象 ）：

• 在对象中遇到 undefined function symbol 会自动忽略，在数组中遇到则返回 null

  JSON.stringify(undefined) // undefined
  JSON.stringify(() => {}) // undefined
  JSON.stringify([1, undefined, () => {}, 4]) // "[1,null,null,4]"
  JSON.stringify({ a: 1, b: () => {}, c: undefined }) // "{"a":1}"

• 对包含循环引用的对象，则会报错

• 如果要对含有非法JSON值的对象做字符串化，或者对象中的某些值无法被序列化时，需要定义 toJSON() 方法来返回一个安全的JSON值，JSON.stringify() 会先调用该方法并用它的返回值做序列化操作（toJSON() 应该返回一个可以被字符串化的安全的JSON值，而不是返回一个字符串）

  var o = {}
  var a = {
    b: 42,
    c: o,
    d: () => {}
  }
  
  // 创建一个循环引用
  o.e = a
  
  JSON.stringify(a) // TypeError: Converting circular structure to JSON
  
  a.toJSON = function() {
    return { b: this.b }
  }
  
  JSON.stringify(a) // "{"b":42}"

JSON.stringify() 可以传递两个可选参数

• replacer ：如果是数组，必须是字符串数组，包含需要序列化的属性名，其余属性会被忽略；如果是函数，会对对象本身调用一次，然后对对象中的每个属性各调用一次。如果要忽略某个键就返回 undefined ，否则返回指定的值。同时，如果遇到键对应的值也是对象，则递归调用

  var  a = {
    b: 42,
    c: '42',
    d: [1, 2, 3],
    e: {
      b: 1,
      c: 2
    }
  }
  
  JSON.stringify(a, ['b', 'c']) // "{"b":42,"c":"42"}"
  JSON.stringify(a, function (k, v) {
    if (k !== 'c') return v
  }) // "{"b":42,"d":[1,2,3],"e":{"b":1}}"

• space ：用来指定缩进格式，为整数时指定每一级缩进的字符数，为字符串时前十个字符被用于每一级的缩进

  var  a = {
    b: 42,
    c: '42',
    d: [1, 2, 3],
  }
  
  JSON.stringify(a, null, 3)
  
  // "{
  //    "b": 42,
  //    "c": "42",
  //    "d": [
  //       1,
  //       2,
  //       3
  //    ]
  // }"
  
  JSON.stringify(a, null, '-----')
  
  // "{
  // -----"b": 42,
  // -----"c": "42",
  // -----"d": [
  // ----------1,
  // ----------2,
  // ----------3
  // -----]
  // }"

ToNumber

如果需要将非数字值当做数字使用，遵循以下规则：

• true 转化为 1
• false 转化为 0
• undefined 转化为 NaN
• null 转化为 0
• 对于字符串，遵循数字常量的相关规则/语法，处理失败返回 NaN （报错？）
• 对象会首先被转化为基本类型值，如果非数字，则按照以上规则转化

ToPrimitive

为了将值转化为相应的基本类型值，首先会去检查该值是否有 valueOf() 方法，如果有且返回基本类型值，会使用该基本类型值进行强制类型转换。如果没有则使用 toString() 的返回值来进行强制类型转换。如果这两种方式都不返回基本类型值，会产生 TypeError 错误

使用 Object.create(null) 创建的对象 [[Prototype]] 属性为 null ，不存在 valueOf() 和 toString() 方法，因此无法进行强制类型转换

var a = {
  valueOf: () => '42',
}

var b = {
  toString: () => '42',
}

var c = [4, 2]
c.toString = function () {
  return this.join('')
}

Number(a) // 42
Number(b) // 42
Number(c) // 42
Number('') // 0
Number([]) // 0
Number(['abc']) // NaN

ToBoolean

Javascript规范具体定义了一小撮可以被强制类型转换为 false 的值，其余的则都是 true

假值列表：

• undefined
• null
• false
• +0 -0 NaN
• ''

显式强制类型转换

字符串和数字

字符串和数字的互相转换是通过 String() 和 Number() 两个内建函数来实现的

var a = 42
var b = String(a) // '42'

var c = '3.14'
var d = Number(c) // 3.14

// 注意这里没有new关键字，不会创建封装对象

一些其他的方式：

• + ：

  var a = 42
  var b = a.toString() // '42'
  
  var c = '3.14'
  var d = +c // 3.14
  
  // 不推荐用一元运算符来显式强制类型转换，会导致代码难以理解
  // 同时 + 还可以将日期对象转换为时间戳，同样不推荐
  
  var e = new Date('Mon, 18 Aug 2014 08:53:06 CDT')
  +e // 1408369986000

• ~：位操作符会通过抽象操作 ToInt32 强制操作数使用32位格式，位非 ~x 基本等于 -(x+1) 。对于正数，位反后拿到的是补码，需要转换为原码。对于负数，先取补码再位反。（MDN例子）

  补码的存在是为了正确计算负数的加法（借助溢出），以8位有符号位数字举例

  正数的补码是其本身，负数的补码符号位不变，其余按位取反并+1

  补码转换为原码同样是符号位不变，其余按位取反并+1

  	原码	补码
  1 + (-2)	00000001 + 10000010 1000011 = -3	00000001 + 11111110 11111111 = -1
  1 + (-1)	00000001 + 10000001 1000010 = -2	00000001 + 11111111 00000000 = 0（溢出8位，从0开始）

  在 -(x+1) 中唯一能得到 0 的 x 值是 -1，这是个哨位值，通常被赋予特殊含义，例如字符串 indexOf() 方法在没有找到相应字符串时返回 -1

  var a = 'Hello World'
  
  if (a.indexOf('lo') >= 0) {
    // 写法不好，抽象渗漏（暴露底层实现细节）
  }
  
  if (a.indexOf('lo') != -1) {
    // 写法不好，抽象渗漏（暴露底层实现细节）
  }
  
  if (~a.indexOf('lo')) {
    // 将结果强制类型转换为真假值！
  }

显式解析数字字符串

解析字符串中的数字，和将字符串强制类型转换为数字是有区别的：解析允许字符串中含有非数字字符，而转换不允许

var a = '42'
var b = '42px'

Number(a) // 42
parseInt(a) // 42
Number(b) // NaN
parseInt(b) // 42

ES5之前，parseInt() 如果不传递第二个参数指定进制，会自行根据字符串的第一个字符来决定进制。除此之外，不要传递非字符串的其他参数，如果传入参数非字符串，会先隐式转换为字符串

parseInt(1 / 0, 19) // parseInt('Infinity', 19) 第一个字符为'I'，以19位基数时值为18，第二个字符不是有效数字，解析结束
parseInt(0.000008) // 0
parseInt(0.0000008) // 8 '8e-7'
parseInt(false, 16) // 250 'fa' = 250
parseInt(parseInt, 16) // 15 'f' 来自于function () {...}
parseInt('0x10') // 16
parseInit('103', 2) // 2 到3停止，因为3不是有效的二进制数字

显式转换为布尔值

Boolean() （不带new）是显式的 ToBoolean 强制类型转换

var a = '0'
var b = []
var c = {}

var d = ''
var e = 0
var f = null
var g

Boolean(a) // true
Boolean(b) // true
Boolean(c) // true

Boolean(d) // false
Boolean(e) // false
Boolean(f) // false
Boolean(g) // false

但这种方式并不常用，一元运算符 ! 也可以将值显式强制类型转换为布尔值，因为 ! 还会反转真假值，因此最常用的方式是 !! ，在 if 语句中，会自动隐式的进行 ToBoolean 转换，建议用显式的方式让代码更易理解

隐式强制类型转换

因人而异，对于自己来说不够明显的强制类型转换都可以称作隐式强制类型转换，会导致代码晦涩难懂。但从另一个角度来看，也可以减少代码的冗余，让代码更简洁

字符串和数字之间的隐式强制类型转换

根据ES5规范，如果 + 的某个操作数是字符串或者能够通过以下步骤转换为字符串，则进行拼接操作：

• 对其进行 ToPrimitive 抽象操作
• 调用 [[DefaultValue]]

否则执行数字加法

var a = '42'
var b = '0'

a + b // '420'

var c = 42
var d = 0

c + d // 42

var e = [1, 2]
var f = [3, 4]

e + f // '1,23,4' 对数组进行ToPrimitive抽象操作，发现valueOf()方法不能返回基本类型值，转而使用toString()

通过 + 空字符串来隐式强制类型转换数字为字符串的场景非常多见，但和显式强制类型转换略有不同：

• a + '' 依据 ToPrimitive 抽象操作规则，先对 a 调用 valueOf() 方法，然后通过 ToString 抽象操作将返回值转换为字符串
• String(a) 则是直接调用 ToString 抽象操作

var a = {
  valueOf: () => 42,
  toString: () => 4
}

a + '' // '42'
String(a) // '4'

相应的，- * / 都是数字运算符，因此会将操作数强制类型转化为数字。

var a = 1
var b = '2'

b - a // 1
a * b // 2
b / a // 2

var c = [3]
var d = [1]

c - d // 2 c和d首先被转化为字符串，然后再转化为数字

布尔值到数字的隐式强制类型转换

将某些复杂的布尔逻辑转化为数字加法的时候可以派上大用场，但是情况非常罕见

function onlyOne() {
  var sum = 0
  for (var i = 0; i < arguments.length; i++) {
    if (arguments[i]) {
      sum += arguments[i]
    }
  }
  return sum == 1
}

var a = true
var b = false

onlyOne(b, a) // true
onlyOne(b, a, b, b, b, b) // true

隐式强制类型转换为布尔值

1. if() 语句中的条件判断表达式
2. for(..; ..; ..) 语句中的条件判断表达式（第二个）
3. while() 和 do..while() 循环中的条件判断表达式
4. ?: 语句中的条件判断表达式
5. 逻辑运算符 || 和 && 的左操作数

对于javascript中的逻辑运算符（实际上更像是操作数选择器运算符），并不是返回一个布尔值，而是返回两个操作数中的一个。 || 和 && 首先对第一个操作数进行 ToBoolean 抽象操作，然后再执行条件判断。对于 || ，如果第一个操作数判断结果为 true 则返回第一个操作数的值，为 false 则返回第二个操作数的值。而对于 && ，如果第一个操作数判断结果为 true 就返回第二个操作数的值，为 false 则返回第一个操作数的值

之所以我们在 if 或其他条件判断语句中可以用 && 和 ||，是因为这些语句本身会做隐式强制类型转换

宽松相等和严格相等

常见的误区：“ == 检查值是否相等，=== 检查值和类型是否相等”。正确的解释是：“ == 允许在相等比较中进行强制类型转换，而 === 不允许。”延伸出来的性能结论：实际上 == 比 === 在比较过程中做的事情更多（相比误区说法），所以性能上确实会慢上一点点（可以忽略不计）

抽象相等

ES5规范如下：

• 如果两个值类型相同，就仅比较他们是否相等（NaN 不等于 NaN，+0 等于 -0）
• 对象指向同一个值时，视为相等，不发生强制类型转换
• == 在比较两个不同类型的值时，会发生隐式强制类型转换，将其中之一或两者都转换为相同类型再比较，转换规则如下：
  • 如果 Type(x) 是数字，Type(y) 是字符串，则返回 x == ToNumber(y) 的结果，反之亦然
  • 如果 Type(x) 是布尔值，则返回 ToNumber(x) == y （Type(y) 亦然），因此不要使用布尔值的宽松相等，会和预期完全不符
  • null 和 undefined 在比较中可以相互强制类型转换，两者等价
  • 如果 Type(x) 是字符串或数字，Type(y) 对象，则返回 x == ToPrimitive(y) 的结果，反之亦然

比较少见的情况

更改对象原型

Number.prototype.valueOf = () => 3
new Number(2) == 3 // true
// 因为数字对象拆封涉及到ToPrimitive操作

假值的相等比较

false == 0 // true
// false优先转换为0，即 0 == 0
false == '0' // true
// false优先转换为0，即 0 == '0'，两个操作数分别是数字和字符串，转换为 0 == Number('0')
false == '' // true
// false优先转换为0，即 0 == ''，两个操作数分别是数字和字符串，转换为 0 == Number('')
false == [] // true
// false优先转换为0，[]通过ToPrimitive转换为''
[] == ![] // true
// 右侧进行了布尔值的显式强制类型转换，即 [] == false

总结：

• 如果比较的两个值存在布尔值，千万不要使用 ==
• 如果比较的两个值存在 0 '' [] ，尽量不要使用 ==
• 干脆就不要使用 == （个人理解）

抽象关系比较

根据ES5规范，首先对比较双方调用 ToPrimitive 操作

• 如果结果出现非字符串，就根据 ToNumber 将比较双方强制类型转换为数字比较
• 如果比较双方都是字符串，则按照字母顺序来比较

这里原本书中的例子有问题

var a = 42 
var b = '43'

a < b // true (42 < 43)

var a = ['42']
var b = ['043']

a < b // false ('42' < '043'，在字母顺序上，0小于4)

需要注意，根据规范，a <= b 会被处理成 b < a 再将结果反转。所以实际上JavaScript中 <= 是不大于的意思（而不是通常理解的小于等于），>= 同理。这会产生一些悖论：

var a = {}
var b = {}

a < b // false 都是 '[object object]'
a == b // false 指向地址不是一致的！
a > b // false

a <= b // true
a >= b // true

相等比较有严格相等，但是关系比较却没有严格关系比较，想要避免在关系比较中出现隐式强制类型转换，只能确保比较两者类型相同，别无他法

硬件

硬件支持

Red Hat 硬件支持
openSUSE 硬件支持
Linux 对笔记本电脑的支持

常见设备在Linux中的文件名

虚拟机相关

VirtualBox官网
Fedora官网教程

磁盘分区

MBR(Master Boot Record)

早期的硬盘第一个扇区（512B）包涵启动引导程序（446B）和分区表（64B）
分区表记录整个硬盘分区状态，64B最多仅能有四组记录区，每组记录区记录了该区的起始与结束柱面号码

假设硬盘设备文件名为 /dev/sda 那么这4个分区文件名在Linux系统中如下：

• P1: /dev/sda1
• P2: /dev/sda2
• P3: /dev/sda3
• P4: /dev/sda4

最初的四组分区记录，可以设置为主要分区和扩展分区（最多一个），而扩展分区可以继续拆分为逻辑分区
扩展分区的目的是用额外的扇区来记录分区信息，本身并不能拿来格式化
假设初始分区分为：P1(Primary) P2(Extended)，同时P2拆分为 L1、L2、L3(logical partition)
则在Linux系统中，设备文件名如下：（前面四个号码都是保留给主要分区和扩展分区使用的）

• P1: /dev/sda1
• P2: /dev/sda2
• L1: /dev/sda5
• L2: /dev/sda6
• L3: /dev/sda7

总结：

• 主要分区和扩展分区最多可以有4个；
• 扩展分区最多有1个；
• 逻辑分区是由扩展分区继续划分的分区；
• 能够格式化后存储数据的是主要分区和逻辑分区；
• 逻辑分区的数量限制依操作系统不同而不同
• 无法使用2.2TB以上的磁盘容量；
• MBR仅有一个扇区、若损坏，经常无法修复
• MBR内存放的启动引导程序仅446B，无法存储较多的程序代码

GPT(GUID partition table)

目前已经有4K的扇区设计出现，为了兼容所有硬盘，在扇区的定义上，会使用逻辑区块地址（LBA, Logical Block Address）
GPT将磁盘所有区块以LBA来规划，使用了34个LBA区块来记录分区信息，同时将磁盘最后34个LBA区块用来做备份

• LBA0（MBR兼容区块）存储了第一阶段的启动程序，用一个特殊标识符来表示此磁盘为GPT格式
• LBA1（GPT表头记录）记录分区表本身的位置和大小、备份区块的位置、分区表的校验码（CRC32）
• LBA2-33（实际记录的分区信息）每个LBA可以记录4组分区记录，所以默认总共可以有 4 * 32 = 128 组分区记录

BIOS和UEFI

BIOS搭配GPT/MBR启动流程：

• BIOS：启动主动执行的固件，会认识第一个可启动的设备；
• MBR：第一个可启动设备的第一个扇区内的主引导记录块，内涵启动引导代码；
• 启动引导程序（boot loader）：一个可读取内核文件来执行的软件；
• 内核文件：开始启动操作系统

Boot loader的主要任务：

• 提供选项：用户可以选择不同启动项，这也是多重引导的重要功能；
• 加载内核文件：直接指向可执行的程序来启动操作系统；
• 转交给其他启动引导程序（多系统）：启动引导程序除了可以安装在MBR以外，还可以安装在每个分区的启动扇区；

UEFI BIOS（Unified Extensible Firmware Interface, 统一可扩展固件接口）搭配GPT/MBR启动流程：

相比于传统的BIOS，UEFI更像一个小型操作系统。某些时候，需要将UEFI的安全启动功能（secure boot）关闭，才能正常启动Linux系统。虽然UEFI可以直接获取GPT分区表，但是最好有BIOS boot分区。为了与windows兼容，并且提供其他第三方厂商使用的UEFI存储空间，需要格式化一个FAT格式的文件系统分区，通常512MB - 1GB

Linux安装时，磁盘分区的选择

文件系统和目录树的关系

将磁盘分区的数据防止在某个目录下，进入该目录就可以读取分区，这个操作被称为“挂载”。整个Linux系统最终要的就是根目录 root(/) ，因此根目录一定会挂载个某个分区，其他目录则可以挂载在不同的分区。可以通过对路径反向追踪来判断某个文件在哪个分区：即哪一级目录先被查到是挂载点，则该文件属于这个挂载点对应的分区

挂载点与磁盘分区的规划

懒人划分：

• 划分“/”以及“交换分区”
• 预留一些磁盘容量作为备用

麻烦一点的划分：根据主机服务来确定硬盘的规划

主机服务规划与硬件关系

• NAT（IP分享器）：Linux NAT可以额外安装一些分析软件，控制带宽或者流量。通常对网卡要求较高
• SAMBA（网络邻居）：没有客户端数量限制、适合用于小型环境的文件服务器。通常需要注意网卡和硬盘的性能，/home
  这个目录可以考虑独立出来挂载，并加大容量
• Mail（邮件服务器）：通常需要注意网卡和硬盘的性能，/var这个目录可以考虑独立出来挂载，并加大容量
• Web（www服务器）：通常需要考虑CPU和内存的性能
• DHCP（提供客户端自动获取IP的功能）：对硬件要求不高
• FTP：通常需要注意网卡和硬盘的性能

内部属性[[Class]]

所有 typeof 返回为 'object' 的对象都包含一个内部属性 [[Class]] ，这个属性无法直接访问，一般通过 Object.prototype.toString 查看

多数情况下，内部 [[Class]] 属性和创建该对象的内建原生构造函数相对应

Object.prototype.toString.call([1]) // "[object Array]"
Object.prototype.toString.call(/^&/) // "[object RegExp]"

虽然 Null() 和 Undefined() 这样的原生构造函数并不存在，但是内部的 [[Class]] 属性仍然是 'Null' 和 'Undefined'

Object.prototype.toString.call(null) // "[object Null]"
Object.prototype.toString.call(undefined) // "[object Undefined]"

其他基本类型值的情况有所不同，通常称为“包装”，即被各自的封装对象自动包装

Object.prototype.toString.call('') // "[object String]"
Object.prototype.toString.call(1) // "[object Number]"
Object.prototype.toString.call(true) // "[object Boolean]"

封装对象包装

由于基本类型值既没有属性也没有方法，需要通过封装对象才能访问，例如 .length 或者 .toString() 。此时JavaScript会自动为基本类型值 wrap 一个封装对象，并在操作完成后重新拆封成基本类型

var a = 'abc'
a.length // 3
a.toUpperCase() // 'ABC'
a // 'abc'

通常不建议直接使用封装对象，浏览器已经为 .length 这样的常见情况作了性能优化，直接使用封装对象来“提前优化”代码反而会降低执行效率

使用封装对象时还需特别注意假值情况，因为对象始终是真值

var a = new Boolean(false)
if(!a) {
  console.log('xxx') // 不会执行到这里
}

如果想要自行封装基本类型值，除了使用对应的构造函数，还可以通过 Object() （不带new关键字）

var a = 'abc'
var b = new String(a)
var c = Object(a)

typeof b // 'object'
typeof c // 'object'

b instanceof String // true
c instanceof String // true

Object.prototype.toString.call(b) // '[object String]'
Object.prototype.toString.call(c) // '[object String]'

拆封

可以使用 valueOf() 函数来获得封装对象中的基本类型值

var a = new String('abc')
var b = new Number(42)
var c = new Boolean(true)

a.valueOf() // 'abc'
b.valueOf() // 42
c.valueOf() // true

如果需要用到封装对象中的基本类型值，会发生隐式拆封（强制类型转换）

var a = new String('abc')
var b = a + 'd'

b // 'abcd'
typeof a // 'object'
typeof b // 'string'

原生函数作为构造函数

对于数组、对象、函数、正则表达式，使用字面量和使用构造函数来创建没有任何区别，除非十分必要，否则应该避免使用构造函数来创建，因为它们经常产生意想不到的结果

构造函数 Array() 不要求必须带 new 关键字，不带时，它会被自动补上。同时，如果只传入一个数字参数，该参数会被作为数组的预设长度。问题是，在JavaScript中数组没有预设长度这个概念。如若一个数组没有任何单元，但 length 属性却显示有单元数量，会导致一些怪异的行为（不同版本不同浏览器的控制台显示结果也不尽相同）

var a = Array(3)
var b = [undefined, undefined, undefined]
a // [empty × 3] 最新版chrome
b // [undefined, undefined, undefined]

a.join('-') // "--"
b.join('-') // "--"
a.map((v, i) => i) // [empty × 3]
b.map((v, i) => i) // [0, 1, 2]

a.map() 之所以执行失败，是因为数组中并不存在任何单元，而 a.join() 不同，它会根据 length 的值来遍历数组中的元素。总之，永远不要创建和使用“稀疏数组”（包含至少一个空单元的数组）。

可以通过如下方式来创建包含 undefined 单元的数组（而非稀疏数组）

var a = Array.apply(null, { length: 3 })
a // [undefined, undefined, undefined]

原理如下：

1. Array.apply() 调用 Array() ，第一个参数作为上下文传入了 null 。第二个参数传入了一个类数组对象（array-like object）{ length: 3 }
2. 设想 apply() 在内部有一个 for 循环，从 0 开始循环到 length （即 0 1 2）
3. 假设在 apply() 内部该数组参数名为 arr ，for 循环就去参数中取 arr[0] arr[1] arr[2] 。然而，由于 { length: 3 } 中并没有数字键对应的值，得到的结果都是 undefined
4. apply() 将循环结束后获得的参数传入 Array() 得到 Array(undefined, undefined, undefined)

对于 Object() Function() RegExp() 来说，仅有需要动态定义正则表达式时才需要用到构造方式来创建，其余场景无论是从可读可维护性或是性能上来看，构造方式创建都不如用字面量创建

var name = 'Kyle'
var namePattern = new RegExp('\\b' + name + '\\b', 'ig')

var txt = 'kyle xxx'
namePattern.test(txt) // true

相比于其他原生构造函数，Date() 和 Error() 的使用场景要多很多，因为它们没有对应的字面量形式。创建一个错误对象可以获得当前运行栈的上下文 .stack 属性，包含函数调用栈以及错误代码行号等重要信息

function foo() {
  bar()
}

function bar() {
  var err = new Error('error!')
  console.log(err.stack)
}

foo()
// Error: error!
//     at bar (<anonymous>:6:13)
//     at foo (<anonymous>:2:3)
//     at <anonymous>:10:1

在ES6中新加入了一个基本类型 Symbol(符号) ，符号是具有唯一性的特殊值（并非绝对），可以用它作为对象的属性键从而避免命名重复。ES6中有一些预定义符号，以 Symbol 的静态属性形式出现，如 Symbol.iterator ，它们作为键时有特殊用途

var myIterable = {}
myIterable[Symbol.iterator] = function* () {
    yield 1;
    yield 2;
    yield 3;
}
// 给myIterable定义一个迭代器
[...myIterable] // [1, 2, 3]

可以使用原生构造函数来自定义符号，但是需要注意不能带 new

var mySymbol = Symbol('my symbol')
mySymbol // Symbol(my symbol)
mySymbol.toString() // 'Symbol(my symbol)'

var obj = {}
obj[mySymbol] = 'foo'
Object.getOwnPropertySymbols(obj) // [Symbol(my symbol)]

一些原生构造函数的原型并非普通对象

typeof Function.prototype // "function"
Function.prototype() // 空函数

RegExp.prototype.toString() // "/(?:)/" 空正则表达式

Array.isArray(Array.prototype) // true

可以考虑将原型作为声明变量时的默认值，这样的好处是，多处变量创建的默认值仅会被创建一次。但是需要注意，如果默认值随后会被更改，则不要使用这种方式，会引起一系列问题

var arr = arr || Array.prototype
arr.push(1)

Array.prototype // [1]

关于this

定义

this 实际上是在函数被调用时动态发生的绑定，它指向什么完全取决于函数在哪里被调用

this指向优先级

1. new 操作符（指向新创建对象）
2. 显式绑定（call、apply、bind）
3. 隐式绑定（foo.bar.methods() 指向bar）
4. 默认绑定（指向window或undefined）

柯里化的问题

当显式绑定传入第一个参数为null或者undefined的时候，this会被绑定至全局

function foo() {
  console.log(this.a);
}

var a = 2;

foo.call(null); // 2

当使用硬绑定来实现柯里化的时候，被绑定函数内部如果使用this，会导致操作全局对象

function foo(a, b) {
  this.a = 1;
  console.log(a + b);
}

var bar = foo.bind(null, 2);

bar(3); //5

console.log(a); // 1

一个好的处理方式是：需要在显式绑定忽略this时，传入 DMZ

function foo(a, b) {
  this.a = 1;
  console.log(a + b);
}

var ø = Object.create(null); // 不会创建Object.prototype委托，比{}更空

var bar = foo.bind(ø, 2);

bar(3); //5

console.log(a); // ReferenceError

软绑定

1. 避免函数引用时this会被绑定至全局或undefined
2. 保留隐式和显式修改this的能力

if (!Function.prototype.softBind) {
  Function.prototype.softBind = function (obj) {
    var fn = this;
    var curried = [].slice.call(arguments, 1);
    var bound = function () {
      return fn.apply(
        (!this || this === (window || global)) ? obj : this,
        curried.concat.apply(curried, arguments)
      );
    };

    bound.prototype = Object.create(fn.prototype);

    return bound;
  }
}

function foo() {
  console.log(this.name);
}

var obj = { name: 'obj' },
    obj2 = { name: 'obj2' },
    obj3 = { name: 'obj3' };

var bar = foo.softBind(obj);

bar(); // obj
obj2.foo = foo.softBind(obj);
obj2.foo(); // obj2
bar.call(obj3); // obj3
setTimeout(obj2.foo, 10); // obj

箭头函数

根据当前的词法作用域来决定this，继承外层函数调用的this指向
优先级高于new

function foo() {
  setTimeout(() => {
    console.log(this.a);
  }, 100);
}

foo.call({
  a: 1
}); // 1

对象

万物皆对象的说法是错误的

基本类型和对象子类型（或称内置对象，比如String）是不等同的，javascript会在操作基本类型的时候自动将之转化为内置对象

var str = 'abc';
var strObj = new String('abc');

console.log(str === strObj); // false
console.log(typeof str); // string
console.log(typeof strObj); // object
console.log(str instanceof String); // false
console.log(strObj instanceof String); // true

基本类型中：boolean、string、number字面量与对应的内置对象不等同，null和undefined没有构造形式，而Object、Array、Function和RegExp无论使用字面量还是构造形式来声明，他们都是对象。

对象内容的存储

对象内容并不是存储在对象内部，而是通过属性名（键）来指向内存某一位置的值

可计算属性名

最常用的场景是ES6的Symbol，因为Symbol不透明且无法预测

const key = Symbol('key');
const obj = {
  [key]: 1,
};

console.log(obj[key]);

Object.assign

Object.assign内部就是使用=操作符来赋值，以此实现浅拷贝。因此原对象属性的一些特性（writable等）不会被复制到目标对象

Object.defineProperty

var myObj = {};

Object.defineProperty(myObj, 'a', {
  value: 2,
  // 是否可写，如果改为false，修改值不生效，严格模式下报错 TypeError
  writable: true, 
  // 是否可配置，如果改为false，不可再通过Object.defineProperty来配置descriptor，也不能删除此属性。否则 TypeError
  configurable: true, 
  // 是否可枚举，如果改为false，不会出现在对象遍历中（如for...in）
  enumerable: true, 
});

如果目标对象引用了其他对象，这些属性特性的声明不会对子对象的内容产生作用

Object.preventExtensions()

var obj = {};

Object.preventExtensions(obj);

obj.a = 1; // 严格模式下报错
obj.a // undefined

Object.seal()

等于对现有对象调用Object.preventExtensions()，同时把所有现有属性设置为 configurable: false，即只能修改已有属性的值

Object.freeze()

等于对现有对象调用Object.seal()，同时把所有现有属性设置为 writable: false

getter 和 setter

当给一个属性定义getter，或setter或两者都有时，这个属性会被定义为”访问描述符“（区别于”数据描述符“），javascript会忽略它的value和writable特性，只关心set、get、configurable和enumerable（？实测会报错，不能同时设置get和value、writable）

var obj = {
  get a() {
    return 2;
  },
  _b_: 3,
};

Object.defineProperty(obj, 'b', {
  get() {
    return this._b_;
  },
  set(val) {
    this._b_ *= val;
  },
  enumerable: true,
});

console.log(obj.a); // 2
console.log(obj.b); // 3
obj.b = 3;
console.log(obj.b); // 9

in 和 Object.hasOwnProperty

in 操作符会检查属性名是否存在于对象或原型链中，而 Object.hasOwnProperty 只会检查属性是否存在对象中

propertyIsEnumerable

会检查属性名是否直接存在于对象上且可枚举

Object.keys

返回所有可枚举属性名的数组

Object.getOwnPropertyNames

返回一个数组，包含所有在对象上的属性，无论是否可枚举

iterator

var array = [1, 2, 3];
var it = array[Symbol.iterator]();

it.next(); // { value: 1, done: false }
it.next(); // { value: 2, done: false }
it.next(); // { value: 3, done: false }
it.next(); // { value: undefined, done: true }

Symbol.iterator 会指向一个'返回迭代器对象'的函数

for...of

for...of 会找到对象的 iterator 来处理遍历（每次调用next方法）
数组天生自带 iterator ，所以可以被for...of遍历，但是普通对象不行，可以手动给想遍历的对象定义 iterator

var obj = {
  a: 1,
  b: 2,
  c: 3,
};

Object.defineProperty(obj, Symbol.iterator, {
  enumerable: false,
  writable: false,
  configurable: true,
  value: function () {
    var o = this;
    var index = 0;
    var keys = Object.keys(o);
    return {
      next: function () {
        return {
          value: o[keys[index++]],
          done: index > keys.length
        }
      }
    }
  }
});

for (var item of obj) {
  console.log(item); // 1, 2, 3
}

类和原型

类是一种设计模式

javascript的机制其实和类完全不同，虽然可以用一般意义上的类来理解（比如实例化，继承等），但是javascript所做的一切本质上只是在操作对象

属性设置和屏蔽

obj.foo = 'bar';

1. 如果 obj 对象中包含名为 foo 的普通数据访问属性名，则这条赋值语句会修改已有属性值
2. 如果 foo 存在原型链的上层，并且没有被标记为只读（writable: true），会在 obj 上新增一条屏蔽属性
3. 如果 foo 存在原型链的上层，并且被设置为只读（writable: false），这条赋值语句会被忽略，严格模式下报错
4. 如果 foo 存在原型链的上层，并且它是一个 setter ，则会调用这个 setter ，不会在 obj 上产生屏蔽属性，也不会重新定义 setter

如果希望在3、4也屏蔽上层foo，就不能使用=操作符来赋值，可以通过Object.defineProperty()来添加 foo 属性

javascript”实例化“本质

在面向类的语言中，类可以被复制多次（类似用模具做东西）。但是在javascript中，并没有类似的复制方式，不能创建一个类的多个实例，只是创建了多个对象。它们的 prototype 关联的是同一个对象（引用），在默认情况下并不会复制。因此，在javascript中，”实例化的本质“是 —— 让两个对象相关联

new 操作符实际上并没有直接创建关联，这个关联只是个副作用（？！）

prototype.constructor

鉴于上述javascript实例化的本质，因此不能信任这条属性，不应该把它理解为”由...构造“。

function Foo() {

}

Foo.prototype = {};

var obj = new Foo();

console.log(obj.constructor === Object); // true

寻找路径：
obj不存在 constructor -> Foo.prototype不存在 constructor -> Object.prototype的 constructor 指向 Object
修正这种行为，必须显式的定义Foo.prototype.constructor

关于继承

重新指定 prototype.constructor 时

Bar.prototype = Foo.prototype; 
// 直接引用而不是创建新对象，会导致修改父类原型
Bar.prototype = new Foo();
// 基本能满足要求，但是有一些副作用：丢弃原本原型，同时调用constructor，导致原型属性变成对象属性
Bar.prototype = Object.create(Foo.prototype); 
// 正确做法（非原型属性用 Foo.call(this) 来继承），唯一缺点是会丢弃原本的原型，需要重新指定constructor

// es6
Object.setPrototypeOf(Bar.prototype, Foo.prototype); // 不需要抛弃原本的原型对象