前端技术分享

// 浏览器环境
console.log(this === window); // true

var name = 'globalName';
console.log(this.name); // 'globalName'

function showThis() {
  console.log(this);
}
showThis(); // 浏览器中输出 window

'use strict';
function showThisStrict() {
  console.log(this);
}
showThisStrict(); // undefined

const person = {
  name: 'Alice',
  greet: function() {
    console.log('Hello, ' + this.name);
  }
};
person.greet(); // Hello, Alice

// 如果将方法赋值给变量再调用，this 会丢失
const greetFn = person.greet;
greetFn(); // Hello, undefined (非严格模式下 this 指向 window)

function Person(name) {
  this.name = name;
}
const alice = new Person('Alice');
console.log(alice.name); // Alice

const obj = {
  name: 'obj',
  normalFunc: function() {
    console.log(this.name);
  },
  arrowFunc: () => {
    console.log(this.name);
  }
};

obj.normalFunc(); // 'obj'
obj.arrowFunc();  // undefined（箭头函数的 this 继承自全局/外层，此处外层是全局，所以 this 指向 window）

<button id="btn">Click me</button>
<script>
  const btn = document.getElementById('btn');
  btn.addEventListener('click', function() {
    console.log(this); // <button id="btn">Click me</button>
  });
</script>

function introduce(age, city) {
  console.log(`I'm ${this.name}, ${age} years old, from ${city}.`);
}

const user = { name: 'Bob' };

introduce.call(user, 25, 'New York');   // I'm Bob, 25 years old, from New York.
introduce.apply(user, [30, 'London']);  // I'm Bob, 30 years old, from London.

const boundIntroduce = introduce.bind(user, 28);
boundIntroduce('Paris'); // I'm Bob, 28 years old, from Paris.

const counter = {
  count: 0,
  increment: function() {
    console.log(this.count);
  }
};
setTimeout(counter.increment, 1000); // 输出 undefined（this 指向全局）
// 解决方法：使用箭头函数、bind 或包装函数
setTimeout(() => counter.increment(), 1000); // 0
setTimeout(counter.increment.bind(counter), 1000); // 0

const obj = {
  name: 'obj',
  outer: function() {
    console.log('outer this:', this.name); // 'obj'
    function inner() {
      console.log('inner this:', this.name); // undefined（非严格模式 window.name）
    }
    inner();
  }
};
obj.outer();
// 解决：使用箭头函数、保存 this 变量（const self = this）、bind

// CommonJS 导出 (a.js)
const name = 'CommonJS';
const greet = () => console.log('Hello');
module.exports = { name, greet };

// 或者
exports.name = 'CommonJS';
exports.greet = () => console.log('Hello');

// CommonJS 导入 (b.js)
const mod = require('./a.js');
console.log(mod.name); // 'CommonJS'
mod.greet();           // 'Hello'

// ES6 导出 (a.js)
export const name = 'ES6 Module';
export function greet() {
  console.log('Hello');
}
// 默认导出
export default function() {
  console.log('Default export');
}

// ES6 导入 (b.js)
import defaultFn, { name, greet } from './a.js';
console.log(name);      // 'ES6 Module'
greet();                // 'Hello'
defaultFn();            // 'Default export'

// 动态加载示例
const moduleName = './module-' + Math.random() + '.js';
const mod = require(moduleName); // 运行时确定路径

// 错误：import 不能在代码块中
if (condition) {
  import mod from './mod.js'; // 语法错误
}

// 正确：静态导入
import mod from './mod.js';

// counter.js
let count = 0;
module.exports = {
  count,
  increment() {
    count++;
    console.log('内部 count:', count);
  }
};

// main.js
const { count, increment } = require('./counter.js');
console.log(count); // 0
increment();        // 内部 count: 1
console.log(count); // 0 （count 仍为 0，并未改变）

// counter.js
export let count = 0;
export function increment() {
  count++;
  console.log('内部 count:', count);
}

// main.js
import { count, increment } from './counter.js';
console.log(count); // 0
increment();        // 内部 count: 1
console.log(count); // 1 （count 随内部变化）

// CommonJS 模块
console.log(this === module.exports); // true

// ES6 模块
console.log(this); // undefined

// a.js
exports.done = false;
const b = require('./b.js');
console.log('a 中 b.done =', b.done);
exports.done = true;
console.log('a 执行完毕');

// b.js
exports.done = false;
const a = require('./a.js');
console.log('b 中 a.done =', a.done);
exports.done = true;
console.log('b 执行完毕');

// main.js
const a = require('./a.js');
// 输出顺序：
// b 中 a.done = false
// b 执行完毕
// a 中 b.done = true
// a 执行完毕

// a.mjs
import { b } from './b.mjs';
export const a = 'a';
console.log('a 模块执行');

// b.mjs
import { a } from './a.mjs';
export const b = 'b';
console.log('b 模块执行, a =', a);

// 运行 a.mjs，输出：
// b 模块执行, a = undefined （因为 a 尚未初始化）
// a 模块执行

   ┌───────────────────────────┐
┌─>│          timers           │ 执行 setTimeout、setInterval 的回调
│  └───────────┬───────────────┘
│  ┌───────────▼───────────────┐
│  │     I/O callbacks         │ 执行延迟到下一轮的 I/O 回调
│  └───────────┬───────────────┘
│  ┌───────────▼───────────────┐
│  │     idle, prepare         │ 系统内部使用
│  └───────────┬───────────────┘
│  ┌───────────▼───────────────┐
│  │         poll              │ 检索新的 I/O 事件，执行 I/O 回调
│  └───────────┬───────────────┘
│  ┌───────────▼───────────────┐
│  │         check             │ 执行 setImmediate 回调
│  └───────────┬───────────────┘
│  ┌───────────▼───────────────┐
│  │    close callbacks        │ 执行 socket 等关闭事件的回调
│  └───────────────────────────┘
└──────────────┘

<!-- Node.js 环境 -->
setTimeout(() => console.log('setTimeout'), 0);
setImmediate(() => console.log('setImmediate'));

--> 执行结果可能不确定 ：
--> 1. 如果事件循环进入 timers 阶段时，定时器时间已到 → setTimeout 先执行。
--> 2. 如果准备时间较短，定时器还没到期 → 跳过 timers，进入 poll → check → setImmediate 先执行。

<!-- 固定顺序的技巧：将代码放在 I/O 回调内 -->
const fs = require('fs');
fs.readFile(__filename, () => {
  setTimeout(() => console.log('setTimeout'), 0);
  setImmediate(() => console.log('setImmediate')); // 总是先于 setTimeout
}); // 输出：setImmediate → setTimeout

--> 因为在 I/O 回调中，事件循环当前处于 poll 阶段，下一阶段是 check，所以 setImmediate 总是先执行 。

process.nextTick(() => console.log('nextTick'));
Promise.resolve().then(() => console.log('promise'));
setTimeout(() => console.log('setTimeout'), 0);

<!-- Node.js 输出顺序： -->
nextTick
promise
setTimeout

--> process.nextTick 优先级高于 Promise，且在所有阶段切换时都会执行 。

setTimeout(() => {
  console.log('timeout1');
  Promise.resolve().then(() => console.log('promise1'));
}, 0);

setTimeout(() => {
  console.log('timeout2');
  Promise.resolve().then(() => console.log('promise2'));
}, 0);

--> Node 10：timeout1 → timeout2 → promise1 → promise2（每个阶段内先清空所有宏任务，再执行微任务）
--> Node 11+ 及浏览器：timeout1 → promise1 → timeout2 → promise2（每个宏任务后执行微任务）

const obj1 = { a: 1, b: { c: 2 } };
const obj2 = { a: obj1.a, b: obj1.b }; // 浅拷贝
obj2.b.c = 100;
console.log(obj1.b.c); // 100 （相互影响）

const obj1 = { a: 1, b: { c: 2 } };
const obj2 = Object.assign({}, obj1);
obj2.b.c = 100;
console.log(obj1.b.c); // 100

const obj1 = { a: 1, b: { c: 2 } };
const obj2 = { ...obj1 };
obj2.b.c = 100;
console.log(obj1.b.c); // 100

const arr1 = [1, 2, { a: 3 }];
const arr2 = arr1.slice();
arr2[2].a = 100;
console.log(arr1[2].a); // 100

const arr2 = arr1.concat();

const arr2 = [...arr1];

const arr2 = Array.from(arr1);

const obj1 = {
  a: 1,
  b: { c: 2 },
  d: new Date(),
  e: undefined,
  f: function() {},
  g: Symbol('g')
};
const obj2 = JSON.parse(JSON.stringify(obj1));
console.log(obj2);
// { a: 1, b: { c: 2 }, d: "2024-01-25T..." }  // 函数、undefined、Symbol 丢失，Date 变成了字符串

function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') return obj;
  if (obj instanceof Date) return new Date(obj);
  if (obj instanceof RegExp) return new RegExp(obj);
  // 处理数组和普通对象
  const cloneObj = Array.isArray(obj) ? [] : {};
  for (let key in obj) {
    if (obj.hasOwnProperty(key)) {
      cloneObj[key] = deepClone(obj[key]);
    }
  }
  return cloneObj;
}

const obj1 = { a: 1, b: { c: 2 }, d: [1, 2, { e: 3 }] };
const obj2 = deepClone(obj1);
obj2.b.c = 100;
console.log(obj1.b.c); // 2

function deepClone(obj, hash = new WeakMap()) {
  if (obj === null || typeof obj !== 'object') return obj;
  if (hash.has(obj)) return hash.get(obj); // 处理循环引用

  const clone = Array.isArray(obj) ? [] : {};
  hash.set(obj, clone);

  // 处理 Symbol 属性
  const symKeys = Object.getOwnPropertySymbols(obj);
  if (symKeys.length) {
    symKeys.forEach(symKey => {
      clone[symKey] = deepClone(obj[symKey], hash);
    });
  }

  // 处理普通字符串属性
  for (let key in obj) {
    if (obj.hasOwnProperty(key)) {
      clone[key] = deepClone(obj[key], hash);
    }
  }
  return clone;
}

// 测试循环引用
const obj = { a: 1 };
obj.self = obj;
const cloned = deepClone(obj);
console.log(cloned.self === cloned); // true

const _ = require('lodash');
const obj2 = _.cloneDeep(obj1);

const obj1 = { a: 1, b: { c: 2 }, d: new Date() };
const obj2 = structuredClone(obj1);
console.log(obj2); // 正确深拷贝

// 原始对象
const original = {
  name: 'Alice',
  age: 25,
  address: {
    city: 'New York',
    zip: 10001
  },
  hobbies: ['reading', 'gaming']
};

// 浅拷贝
const shallowCopy = { ...original };

// 深拷贝（JSON 方法）
const deepCopy = JSON.parse(JSON.stringify(original));

// 修改浅拷贝的嵌套对象
shallowCopy.address.city = 'Los Angeles';
shallowCopy.hobbies.push('swimming');
console.log(original.address.city); // 'Los Angeles' （原对象被改变）
console.log(original.hobbies);      // ['reading', 'gaming', 'swimming'] （原对象被改变）

// 修改深拷贝的嵌套对象
deepCopy.address.city = 'Chicago';
deepCopy.hobbies.push('running');
console.log(original.address.city); // 仍为 'Los Angeles' （不受影响）
console.log(original.hobbies);      // 仍为 ['reading', 'gaming', 'swimming'] （不受影响）

function outer() {
  let x = 10;
  function inner() {
    console.log(x); // 内部函数引用外部变量
  }
  return inner;
}
const closure = outer();
closure(); // 10  // 闭包保留了 outer 的作用域

const counterModule = (function() {
  let count = 0; // 私有变量
  function changeBy(val) {
    count += val;
  }
  return {
    increment() {
      changeBy(1);
    },
    decrement() {
      changeBy(-1);
    },
    getCount() {
      return count;
    }
  };
})();

counterModule.increment();
console.log(counterModule.getCount()); // 1
console.log(counterModule.count); // undefined，无法直接访问私有变量

function fetchData(url) {
  const requestId = Math.random(); // 模拟请求ID
  setTimeout(function callback() {
    console.log(`请求 ${url} 完成，ID: ${requestId}`);
  }, 1000);
}

fetchData('/api/data');
// 一秒后输出：请求 /api/data 完成，ID: 0.123456...

function createMultiplier(factor) {
  return function (number) {
    return number * factor; // factor 被闭包捕获
  };
}

const numbers = [1, 2, 3];
const doubled = numbers.map(createMultiplier(2));
console.log(doubled); // [2, 4, 6]

const buttons = document.querySelectorAll('button');
for (var i = 0; i < buttons.length; i++) {
  buttons[i].addEventListener('click', function() {
    console.log(`按钮 ${i} 被点击`); // 闭包捕获 i
  });
}
// 但输出总是 '按钮 3 被点击'（如果使用 var）

for (var i = 0; i < buttons.length; i++) {
  (function(j) {
    buttons[j].addEventListener('click', function() {
      console.log(`按钮 ${j} 被点击`); // 闭包捕获 j
    });
  })(i);
}

const counter = (function() {
  let count = 0; // 闭包私有变量（模块化）

  function asyncIncrement(delay) {
    setTimeout(function callback() {
      count++; // 回调闭包访问 count
      console.log(`当前计数: ${count}`);
    }, delay);
  }

  function getCount() {
    return count;
  }

  return {
    asyncIncrement,
    getCount
  };
})();

counter.asyncIncrement(1000);
counter.asyncIncrement(1000);
// 一秒后依次输出：
// 当前计数: 1
// 当前计数: 2

function outer() {
  const message = 'Hello, Closure!';
  function inner() {
    console.log(message);
  }
  return inner;
}

const closureFn = outer();
closureFn(); // 输出 'Hello, Closure!'

function createCounter() {
  let count = 0;
  return {
    increment() {
      count++;
      console.log(count);
    },
    decrement() {
      count--;
      console.log(count);
    },
    getCount() {
      return count;
    }
  };
}

const counter = createCounter();
counter.increment(); // 1
counter.increment(); // 2
console.log(counter.getCount()); // 2
// 无法直接访问 count
console.log(counter.count); // undefined

function multiplyBy(factor) {
  return function(number) {
    return number * factor;
  };
}

const double = multiplyBy(2);
const triple = multiplyBy(3);
console.log(double(5)); // 10
console.log(triple(5)); // 15

for (var i = 0; i < 3; i++) {
  setTimeout(function() {
    console.log(i); // 输出 3 3 3
  }, 100);
}

for (var i = 0; i < 3; i++) {
  (function(j) {
    setTimeout(function() {
      console.log(j); // 输出 0 1 2
    }, 100);
  })(i);
}

for (let i = 0; i < 3; i++) {
  setTimeout(function() {
    console.log(i); // 输出 0 1 2
  }, 100);
}

var myModule = (function() {
  var privateVar = 'I am private';
  function privateMethod() {
    console.log('private method');
  }
  return {
    publicMethod: function() {
      console.log(privateVar);
      privateMethod();
    }
  };
})();

myModule.publicMethod(); // I am private \n private method

function heavyProcess() {
  const largeData = new Array(1000000).fill('data');
  return function() {
    console.log(largeData.length);
  };
}
const leak = heavyProcess(); // largeData 一直存在

leak = null; // 解除引用，允许垃圾回收

{
  /****** 根选项 ******/
  "include": ["./src/**/*"],  // 指定被编译文件所在的目录，** 表示任意目录，* 表示任意文件
  "exclude": [],              // 指定不需要被编译的目录
  files: ["demo.ts"],         // 指定被编译的文件

  
  /****** 项目选项 ******/
  "compilerOptions": {
    "target": "ES6",              // 目标语言的版本
    "module": "commonjs",         // 生成代码的模板标准
    "lib": ["DOM", "ES5", "ES6", "ES7", "ScriptHost"], // TS需要引用的库
    "outDir": "./dist",           // 指定输出目录
    "rootDir": "./",              // 指定输出文件目录(用于输出)，用于控制输出目录结构
    "allowJs": true,              // 允许编译器编译JS，JSX文件
    "checkJs": true,              // 允许在JS文件中报错，通常与allowJS一起使用
    "removeComments": true,       // 删除注释
    "esModuleInterop": true,      // 允许export=导出，由import from 导入

    /****** 严格检查选项 ******/
    "strict": true,               // 开启所有严格的类型检查
    "alwaysStrict": true,         // 在代码中注入'use strict'
    "noImplicitAny": true,        // 不允许隐式的any类型
    "noImplicitThis": true,       // 不允许this有隐式的any类型
    "strictNullChecks": true,     // 不允许把null、undefined赋值给其他类型的变量
    "strictBindCallApply": true,  // 严格的bind/call/apply检查
    "strictFunctionTypes": true,  // 不允许函数参数双向协变
    "strictPropertyInitialization": true,   // 类的实例属性必须初始化
  
    /****** 额外检查 ******/
    "noUnusedLocals": true,             //是否检查未使用的局部变量
    "noUnusedParameters": true,         //是否检查未使用的参数
    "noImplicitReturns": true,          //检查函数是否不含有隐式返回值
    "noImplicitOverride": true,         //是否检查子类继承自基类时，其重载的函数命名与基类的函数不同步问题
    "noFallthroughCasesInSwitch": true, //检查switch中是否含有case没有使用break跳出
    "noUncheckedIndexedAccess": true,   //是否通过索引签名来描述对象上有未知键但已知值的对象
    "noPropertyAccessFromIndexSignature": true, //是否通过" . “(obj.key) 语法访问字段和"索引”( obj[“key”])， 以及在类型中声明属性的方式之间的一致性
  
    /****** 实验选项 ******/
    "experimentalDecorators": true,     //是否启用对装饰器的实验性支持，装饰器是一种语言特性，还没有完全被 JavaScript 规范批准
    "emitDecoratorMetadata": true,      //为装饰器启用对发出类型元数据的实验性支持
  
    /****** 高级选项 ******/
    "forceConsistentCasingInFileNames": true,   //是否区分文件系统大小写规则
    "extendedDiagnostics": false,               //是否查看 TS 在编译时花费的时间
    "noEmitOnError": true,                      //有错误时不进行编译
    "resolveJsonModule": true,                  //是否解析 JSON 模块
  },
}

// 不使用泛型
function getName01(name: string): string {
  return name
}
console.log(getName01('翠花'))  // 翠花

// 使用泛型
function getName02<T>(name: T): T {
  return name
}
console.log(getName02<string>('翠花'))  // 翠花

// 不使用泛型
function getName01(name: string | number): string | number {
  return name
}
console.log(getName01('翠花'))   // 翠花
console.log(getName01(123))     // 123

// 使用泛型
function getName02<T>(name: T): T {
  return name
}
console.log(getName02<string>('翠花'))   // 翠花
console.log(getName02<number>(123))     // 123

function getName03<T>(name: T): T {
  return name
}
console.log(getName03<string>('隔壁老王'))  // 隔壁老王

interface GetName04 {
  <T>(name: T): T
}
function getName05<T>(name: T): T {
  return name
}
let my_name: GetName04 = getName05
console.log(my_name('小红'))  // 小红

interface GetName06 {
  <T>(name: T): T;
  <U>(age: U): U;
}
function getName07<T, U>(args: { name: T, age: U }) : { name: T, age: U } {
  return args
}
let my_name_age: GetName06 = getName07
console.log(my_name_age({ name: '小红', age: 18 }))  // { name: '小红', age: 18 }

class Add<T> {
  value: T;
  addFn: (a: T, b: T) => T
}
let add_a_b = new Add<number>()
add_a_b.value = 666
console.log(add_a_b.value)  // 666
add_a_b.addFn = (a, b) => {
  return a + b
}
console.log(add_a_b.addFn(2, 3))  // 5

function getName08<T>(name: T): T {
  return `我是${name}`  // 不能将类型“string”分配给类型“T”。
}
console.log(getName08<string>('隔壁老王'))

function getName08<T>(name: T): any {
  return `我是${name}`
}
console.log(getName08<string>('隔壁老王'))  // 我是隔壁老王

interface Str {
  name: String
}
function getName08<T extends Str>(person: T): any {
  return `我是${person.name}呀`
}
console.log(getName08({ name: '隔壁老王'}))  // 我是隔壁老王呀

function getObj<T, U extends keyof T>(obj: T, search: U) {
  return obj[search]
}
const students = {
  1: { name: '张三', age: 16 },
  2: { name: '李四', age: 17 },
  3: { name: '王五', age: 18 },
  4: { name: '赵六', age: 19 },
  5: { name: '老七', age: 20 }
}
console.log(getObj(students, 3)) // { name: '王五', age: 18 }
console.log(getObj(students, 5)) // { name: '老七', age: 20 }
console.log(getObj(students, 6)) // 类型“6”的参数不能赋给类型“2 | 3 | 1 | 4 | 5”的参数。

const a = Symbol()
console.log(typeof a) // symbol

let b = Symbol('key')
let c = Symbol('key')
console.log(b === c)  // false

let d = Symbol()
let e = {
  [d]: 'value'
}
console.log(e[d]) // value

const f = Symbol()
class G {
  [f]() {
    return 'value'
  }
}
const h = new G()
console.log(h[f]()) // value

const i = Symbol('i')
console.log(i.toString()) // Symbol(i)
console.log(Boolean(i))   // true

const name = Symbol('name')
const person = {
  [name]: '老王',
  age: 30,
  sex: '男'
}
let for_key = []
for (let key in person) {
  for_key.push(key)
}
console.log(for_key)    // [ 'age', 'sex' ]
console.log(Object.keys(person))  // [ 'age', 'sex' ]
console.log(Object.getOwnPropertyNames(person)) // [ 'age', 'sex' ]
console.log(JSON.stringify(person))   // {"age":30,"sex":"男"}

const name = Symbol('name')
const person = {
  [name]: '老王',
  age: 30,
  sex: '男'
}
console.log(Object.getOwnPropertySymbols(person)) // [ Symbol(name) ]

const name = Symbol('name')
const person = {
  [name]: '老王',
  age: 30,
  sex: '男'
}
console.log(Reflect.ownKeys(person))  // [ 'age', 'sex', Symbol(name) ]

// 当其他对象使用 instanceof 判断是否为这个对象的实例时，会调用你定义的这个方法，参数是其他的这个对象
const obj01 = {
  [Symbol.hasInstance](other: any) {
    console.log(other)    // { a: 'a' }
  }
}
console.log({ a: 'a' } instanceof (obj01 as any)) // false

let arr01 = [1, 2]
console.log(arr01.concat([3, 4]))   // [ 1, 2, 3, 4 ]
let arr02 = ['a', 'b'] as any
arr02[Symbol.isConcatSpreadable] = false
console.log(arr02.concat(['c', 'd'])) // [ [ 'a', 'b', [Symbol(Symbol.isConcatSpreadable)]: false ], 'c', 'd' ]
// 当数组arr02的 Symbol.isConcatSpreadable 设为 true 时，这个数组在数组的 concat 方法中不会被扁平化
arr02[Symbol.isConcatSpreadable] = true
console.log(arr02.concat(['e', 'f'])) // [ 'a', 'b', 'e', 'f' ]

const arr = [1, 2]
const iterator = arr[Symbol.iterator]()
console.log(iterator.next())  // { value: 1, done: false }
console.log(iterator.next())  // { value: 2, done: false }
console.log(iterator.next())  // { value: undefined, done: true }

const obj = {
  [Symbol.match](val: any) {
    return val.length
  }
}
console.log('abcdefg'.match(obj)) // 7

// 正则表达式用来匹配字符串
const str: any = /abcdefg/
str[Symbol.match] = false
console.log('/abc/'.startsWith(str))    // false
console.log('/abcdefg/'.endsWith(str))  // true

class obj02 {
  value: string
  constructor(value: any) {
    this.value = value
  } 
  [Symbol.replace](str: any) {
    return `${str}：${this.value}`
  }
}
const n: any = '姓名'
console.log(n.replace(new obj02('老王'))) // 姓名：老王

const error = () => {
  throw new Error('error')
}

const loop = () => {
  while(true) {}
}

const isTrue = (val: 'A' | 'B') => {
  switch(val) {
    case 'A': break;
    case 'B': break;
    default: const isFalse: never = val
  }
}

const fn = () => {}
console.log(fn()) // undefined

const fn = () => {}    // const fn: () => void
let aa: never = fn()   // 不能将类型“void”分配给类型“never”

type a = unknown | never  // unknown
type b = any | never      // any
type c = number | never   // number
type d = string | never   // string
type e = object | never   // object
type f = boolean | never  // boolean

type g = unknown & never  // never
type h = any & never      // never
type i = number & never   // never
type j = string & never   // never
type k = object & never   // never
type l = boolean & never  // never

let m: never
let n: unknown = m
let o: any = m
let p: number = m
let q: string = m
let r: object = m
let s: boolean = m

let t: never = 'a'      // 不能将类型“string”分配给类型“never”
let u: never = 123      // 不能将类型“number”分配给类型“never”
let v: never = { a: 1 } // 不能将类型“{ a: number; }”分配给类型“never”
let w: never = true     // 不能将类型“boolean”分配给类型“never”