TypeScript

declare global {
  interface String {
    endsWith(suffix: string): boolean;
  }
}

// method 1
import './foo'
import './bar'
// method 2
require('./foo')
require('./bar')
// method 3
import foo = require('./foo')
import bar = require('./bar')
const ensureImport: any = foo || bar

// 编译前
namespace Utility {}
// 编译后
(function (Utility) {
})(Utility || Utility = {});

interface Window { foo: number; }
interface Window { bar: string; }
// Window 等同于 { foo: number; bar: string }

enum Tristate {
  False = 5,
  True,
  Unknown = "Unknown"
}

var Tristate;
(function (Tristate) {
    Tristate[Tristate["False"] = 5] = "False";
    Tristate[Tristate["True"] = 6] = "True";
    Tristate["Unknown"] = "Unknown";
})(Tristate || (Tristate = {}));

enum Status {
  Ready,
  Waiting
}
enum Color {
  Red,
  Blue,
  Green
}
const [myStatus, myColor] = [Status.Ready, Color.Red]
//@ts-expect-error
console.log(myStatus === myColor) // -> true

type LongHandAllowsOverloadDeclarations = {
  (a: number): number;
  (a: string): string;
}

function identity<T extends string>(arg: T): T {
  return arg;
}

type WrapNaked<T> = T extends any ? { o: T } : never
type WrapUnNaked<T> = { o: T } extends any ? { o: T } : never

type Foo = WrapNaked<string | number | boolean>
// { o: string } | { o: number } | { o: boolean }

type Bar = WrapUnNaked<string | number | boolean>
// { o: string | number | boolean }

interface Person {
  name: string
}
const printPerson = (p: Person) => console.log(p.name)
//@ts-expect-error
printPerson({ name: 'Alice', age: 18 })
//@ts-expect-error
const p1: Person = { name: 'Alice', age: 18 }
const p2 = { name: 'Alice', age: 18 }
// ok
printPerson(p2)

template <int N>
struct Fib {
    static constexpr int value = Fib<N-1>::value + Fib<N-2>::value;
};
template <>
struct Fib<1> { static constexpr int value = 1; };
template <>
struct Fib<0> { static constexpr int value = 0; };

constexpr int f10 = Fib<10>::value; // 编译期常量 = 55

// 1. 通用模板
template<typename T>
void process(T val) { /* 通用实现 */ }
// 2. 针对 int 优化
template<>
void process<int>(int val) { /* 针对 int 的高效实现 */ }

{
  "compilerOptions": {
    "composite": true,
    "outDir": "./dist"
  },
  "references": [
    { "path": "../other-project" }
  ]
}

{
  "compilerOptions": {

    /* 基本选项 */
    "target": "es5",                       // 指定 ECMAScript 目标版本: 'es3', 'es5', 'es2015', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'es2021', 'es2022', 'esnext' 或 'latest'
    "module": "commonjs",                  // 决定输出的模块类型: 'commonjs', 'amd', 'system', 'umd' or 'es2015'
    "lib": [],                             // 指定要包含在编译中的库文件
    "allowJs": true,                       // 允许编译 javascript 文件
    "checkJs": true,                       // 报告 javascript 文件中的错误
    "jsx": "preserve",                     // 指定 jsx 代码的生成: 'preserve', 'react-native', or 'react'
    "declaration": true,                   // 生成相应的 '.d.ts' 文件
    "sourceMap": true,                     // 生成相应的 '.map' 文件
    "outFile": "./",                       // 将输出文件合并为一个文件
    "outDir": "./",                        // 指定输出目录
    "rootDir": "./",                       // 用来控制输出目录结构 --outDir.
    "removeComments": true,                // 删除编译后的所有的注释
    "noEmit": true,                        // 不生成输出文件
    "importHelpers": true,                 // 从 tslib 导入辅助工具函数
    "isolatedModules": true,               // 将每个文件作为单独的模块 （与 'ts.transpileModule' 类似）.

    /* 严格的类型检查选项 */
    "strict": true,                        // 启用所有严格类型检查选项
    "noImplicitAny": true,                 // 在表达式和声明上有隐含的 any类型时报错
    "strictNullChecks": true,              // 启用严格的 null 检查
    "noImplicitThis": true,                // 当 this 表达式值为 any 类型的时候，生成一个错误
    "alwaysStrict": true,                  // 以严格模式检查每个模块，并在每个文件里加入 'use strict'

    /* 额外的检查 */
    "noUnusedLocals": true,                // 有未使用的变量时，抛出错误
    "noUnusedParameters": true,            // 有未使用的参数时，抛出错误
    "noImplicitReturns": true,             // 并不是所有函数里的代码都有返回值时，抛出错误
    "noFallthroughCasesInSwitch": true,    // 报告 switch 语句的 fallthrough 错误。（即，不允许 switch 的 case 语句贯穿）

    /* 模块解析选项 */
    "moduleResolution": "node",            // 模块解析策略： 'node' (Node.js) or 'classic' (TypeScript pre-1.6)
    "baseUrl": "./",                       // 用于解析非相对模块名称的基目录
    "paths": {},                           // 模块名到基于 baseUrl 的路径映射的列表
    "rootDirs": [],                        // 根文件夹列表，其组合内容表示项目运行时的结构内容
    "typeRoots": [],                       // 包含类型声明的文件列表
    "types": [],                           // 需要包含的类型声明文件名列表
    "allowSyntheticDefaultImports": true,  // 允许从没有设置默认导出的模块中默认导入。

    /* Source Map Options */
    "sourceRoot": "./",                    // 指定调试器应该找到 TypeScript 文件而不是源文件的位置
    "mapRoot": "./",                       // 指定调试器应该找到映射文件而不是生成文件的位置
    "inlineSourceMap": true,               // 生成单个 sourcemaps 文件，而不是将 sourcemaps 生成不同的文件
    "inlineSources": true,                 // 将代码与 sourcemaps 生成到一个文件中，要求同时设置了 --inlineSourceMap 或 --sourceMap 属性

    /* 其他选项 */
    "experimentalDecorators": true,        // 启用装饰器
    "emitDecoratorMetadata": true          // 为装饰器提供元数据的支持
  }
}

npm install --save-dev @types/lodash

const c = (() => {}) as any as {
  (foo: string, bar?: number, ...others: string[]): number;
}
//@ts-expect-error
c('123', '23')

const c = (() => {}) as any as {
  (foo: string, bar?: number, ...others: string[]): number;
  (foo: string, ...others: string[]): number;
}

type Nested = { value: number } | { nested: Nested }

function isNested(obj: any): obj is { nested: Nested } {
  return obj && typeof obj === 'object' && 'nested' in obj
}
function getValue(obj: Nested): number {
  if ('value' in obj) {
    return obj.value
  }
  if (isNested(obj)) {
    return getValue(obj.nested)
  }
  throw new Error('Invalid structure')
}

interface Foo {
  readonly [x: number]: number
}
const foo: Foo = { 0: 123, 2: 345 }
//@ts-expect-error
foo[0] = 456
//@ts-expect-error
delete foo[0]

type Foo = {
  [index: number]: { b: string }
  [index: string]: { a?: string, b: string }
}

type Shape = 
  | { kind: 'circle'; radius: number }
  | { kind: 'square'; side: number }
// 当新增一种 Shape 时，由于 getArea 中没有处理这种情况，
// 会抛类型错误，但不会影响运行时
//| { kind: 'new'; side: number }

function getArea(shape: Shape): number {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2
    case 'square':
      return shape.side ** 2
    default:
      const _never: never = shape
      return _never
  }
}

interface UserIdBrand { readonly __brand: "UserId" }
type UserId = string & UserIdBrand

interface ProductIdBrand { readonly __brand: "ProductId" }
type ProductId = string & ProductIdBrand

declare const userId: UserId
declare const productId: ProductId
getUserPosts(userId)      // OK
getUserPosts(productId)   // Type Error! 不能传 ProductId