// 基本语法
type Result = TypeA extends TypeB ? TrueType : FalseType;

// 示例：判断 'linbudu' 是否为 string 的子类型
type Result = 'linbudu' extends string ? 1 : 2; // 返回 1，说明成立

// 声明变量
declare let source: string;
declare let anyType: any;
declare let neverType: never;

// 赋值测试
anyType = source;    // ✅ 成立：string 可以赋值给 any

// ❌ 错误：不能将类型"string"分配给类型"never"
neverType = source;  // 不成立，会抛出类型错误

// 类比示例：狗、柯基、橘猫的类型关系
declare let dog: Dog;
declare let corgi: Corgi;  // 柯基（狗的子类）
declare let cat: Cat;      // 猫（不是狗）

// ✅ 正确：柯基是一种狗，可以赋值
dog = corgi;

// ❌ 错误：猫不是狗，不能赋值
dog = cat; // 类型错误！

// 1. 字符串字面量类型 < string 类型
type Result1 = "linbudu" extends string ? 1 : 2; // 1 ✅

// 2. 数字字面量类型 < number 类型
type Result2 = 1 extends number ? 1 : 2; // 1 ✅

// 3. 布尔字面量类型 < boolean 类型
type Result3 = true extends boolean ? 1 : 2; // 1 ✅

// 4. 对象字面量类型 < object 类型
type Result4 = { name: string } extends object ? 1 : 2; // 1 ✅
type Result5 = { name: 'linbudu' } extends object ? 1 : 2; // 1 ✅

// 5. 数组字面量类型 < object 类型
type Result6 = [] extends object ? 1 : 2; // 1 ✅

// 1. 数字字面量 < 包含该字面量的联合类型
type Result7 = 1 extends 1 | 2 | 3 ? 1 : 2; // 1 ✅

// 2. 字符串字面量 < 包含该字面量的联合类型
type Result8 = 'lin' extends 'lin' | 'bu' | 'du' ? 1 : 2; // 1 ✅

// 3. 布尔字面量 < 包含该字面量的联合类型
type Result9 = true extends true | false ? 1 : 2; // 1 ✅

// string 类型是包含 string 的联合类型的子类型
type Result10 = string extends string | false | number ? 1 : 2; // 1 ✅

// 所有成员都是字符串字面量 → 该联合类型是 string 的子类型
type Result11 = 'lin' | 'bu' | 'budu' extends string ? 1 : 2; // 1 ✅

// 所有成员都是对象类型 → 该联合类型是 object 的子类型
type Result12 = {} | (() => void) | [] extends object ? 1 : 2; // 1 ✅

// 验证完整层级链
type Result13 = 'linbudu' extends 'linbudu' | '599'
  ? 'linbudu' | '599' extends string
    ? 2  // ✅ 所有条件成立，返回 2
    : 1
  : 0;

// 1. 原始类型 < 装箱类型
type Result14 = string extends String ? 1 : 2; // 1 ✅

// 2. 装箱类型 < 空对象类型（结构化类型系统）
type Result15 = String extends {} ? 1 : 2; // 1 ✅

// 3. 空对象字面量 < object 类型
type Result16 = {} extends object ? 1 : 2; // 1 ✅

// 4. object < Object
type Result18 = object extends Object ? 1 : 2; // 1 ✅

interface String {
  replace: (search: string, replaceValue: string) => string;
  replaceAll: (search: string, replaceValue: string) => string;
  startsWith: (searchString: string) => boolean;
  endsWith: (searchString: string) => boolean;
  includes: (searchString: string) => boolean;
  // ... 更多方法
}

// ❌ 错误理解：认为 string extends object
type Tmp = string extends object ? 1 : 2; // 2，不成立！

// ✅ 正确理解：string -> String -> {} -> object（但不是直接的父子关系）

// 从类型信息层面：{} 是 object 的字面量类型
type Result16 = {} extends object ? 1 : 2; // 1 ✅

// 从结构化类型系统：{} 是所有对象类型的基类
type Result18 = object extends {} ? 1 : 2; // 1 ✅

// 类似地
type Result17 = object extends Object ? 1 : 2; // 1 ✅
type Result20 = Object extends object ? 1 : 2; // 1 ✅

type Result19 = Object extends {} ? 1 : 2; // 1 ✅
type Result21 = {} extends Object ? 1 : 2; // 1 ✅

// 完整层级示例
type TypeLevel = string extends String
  ? String extends Object
    ? 'string → String → Object'
    : never
  : never; // 'string → String → Object'

// Object 是 any 的子类型
type Result22 = Object extends any ? 1 : 2; // 1 ✅

// Object 是 unknown 的子类型
type Result23 = Object extends unknown ? 1 : 2; // 1 ✅

// 反向判断：any extends Object ?
type Result24 = any extends Object ? 1 : 2; // 1 | 2 ⚠️

// 反向判断：unknown extends Object ?
type Result25 = unknown extends Object ? 1 : 2; // 2 ❌

type Result26 = any extends 'linbudu' ? 1 : 2; // 1 | 2
type Result27 = any extends string ? 1 : 2; // 1 | 2
type Result28 = any extends {} ? 1 : 2; // 1 | 2
type Result29 = any extends never ? 1 : 2; // 1 | 2

declare let anyType: any;
declare let unknownType: unknown;
declare let str: string;

// ✅ any 可以赋值给任何类型（不安全！）
str = anyType; // 编译通过，但运行时可能出错

// ❌ unknown 不能赋值给其他类型
str = unknownType; // Error: 不能将类型"unknown"分配给类型"string"

// ✅ unknown 只能赋值给 any 或 unknown
anyType = unknownType; // ✅
unknownType = anyType; // ✅

// any 可以是任何类型的子类型
type Result31 = any extends unknown ? 1 : 2; // 1 ✅
type Result32 = unknown extends any ? 1 : 2; // 1 ✅

// 这意味着 any 和 unknown 互为子类型！

// unknown 是安全的未知类型
type Result33 = unknown extends Object ? 1 : 2; // 2，不成立
type Result34 = unknown extends string ? 1 : 2; // 2，不成立

// 但所有类型都是 unknown 的子类型
type Result35 = string extends unknown ? 1 : 2; // 1 ✅
type Result36 = Object extends unknown ? 1 : 2; // 1 ✅

function processValue(value: unknown) {
  // ❌ 直接使用会报错
  // value.toUpperCase(); // Error: 'value' 是一个 'unknown' 类型

  // ✅ 类型收窄后使用
  if (typeof value === 'string') {
    console.log(value.toUpperCase()); // 安全！
  } else if (typeof value === 'number') {
    console.log(value.toFixed(2)); // 安全！
  }
}

// ❌ 不推荐
function processData(data: any) {
  return data.name.toUpperCase(); // 不安全！
}

// ✅ 推荐
function processDataSafe(data: unknown) {
  if (typeof data === 'object' && data !== null && 'name' in data) {
    return (data as { name: string }).name.toUpperCase();
  }
  throw new Error('Invalid data');
}

// never 是任何类型的子类型
type Result33 = never extends 'linbudu' ? 1 : 2; // 1 ✅
type Result34 = never extends string ? 1 : 2; // 1 ✅
type Result35 = never extends number ? 1 : 2; // 1 ✅
type Result36 = never extends any ? 1 : 2; // 1 ✅

// never 类型的变量无法赋值
declare let neverType: never;

neverType = 'anything'; // ❌ Error: 不能将类型"string"分配给类型"never"
neverType = 123; // ❌ Error
neverType = null; // ❌ Error
neverType = undefined; // ❌ Error

// 总是抛出错误的函数
function throwError(message: string): never {
  throw new Error(message);
}

// 无限循环
function infiniteLoop(): never {
  while (true) {
    // 死循环
  }
}

type Shape = 'circle' | 'square' | 'triangle';

function getArea(shape: Shape): number {
  switch (shape) {
    case 'circle':
      return Math.PI * 1 * 1;
    case 'square':
      return 1 * 1;
    case 'triangle':
      return 0.5 * 1 * 1;
    default:
      // 如果未来添加了新的形状，这里会报错
      const _exhaustiveCheck: never = shape;
      return _exhaustiveCheck;
  }
}

// 过滤掉 never 类型
type NonNever<T> = T extends never ? never : T;

// 示例
type Result = NonNever<string | never | number>; // string | number

// null、undefined、void 都不是其他类型的子类型
type Result37 = undefined extends 'linbudu' ? 1 : 2; // 2 ❌
type Result38 = null extends 'linbudu' ? 1 : 2; // 2 ❌
type Result39 = void extends 'linbudu' ? 1 : 2; // 2 ❌

// void、undefined、null 都是切实存在、有实际意义的类型
// 它们和 string、number、object 处于同一层级

// void: 函数没有显式返回值
function logMessage(message: string): void {
  console.log(message);
  // 没有 return 语句，或 return;
}

// null: 明确表示"空"
let emptyValue: null = null;

// undefined: 表示"未定义"
let notDefined: undefined = undefined;

// never: 永远不会发生的类型
function fail(): never {
  throw new Error('This never returns');
}

// 1. 联合类型中的 never 会被吸收
type Union1 = never | string; // string
type Union2 = never | number | boolean; // number | boolean

// 2. 交集类型中的 never 会导致结果为 never
type Intersect1 = never & string; // never
type Intersect2 = never & number; // never

// 3. 条件类型中的 never
type Conditional = never extends string ? true : false; // true

type TypeChain = never extends 'linbudu'
  ? 'linbudu' extends 'linbudu' | '599'
  ? 'linbudu' | '599' extends string
  ? string extends String
  ? String extends Object
  ? Object extends any
  ? any extends unknown
  ? unknown extends any
  ? 8  // ✅ 所有条件成立，返回 8
  : 7
  : 6
  : 5
  : 4
  : 3
  : 2
  : 1
  : 0;

never → 'linbudu' → 'linbudu' | '599' → string → String → Object → any → unknown

type VerboseTypeChain = never extends 'linbudu'
  ? 'linbudu' extends 'linbudu' | 'budulin'
  ? 'linbudu' | 'budulin' extends string
  ? string extends {}
  ? string extends String
  ? String extends {}
  ? {} extends object
  ? object extends {}
  ? {} extends Object
  ? Object extends {}
  ? object extends Object
  ? Object extends object
  ? Object extends any
  ? Object extends unknown
  ? any extends unknown
  ? unknown extends any
  ? 8  // ✅ 所有条件成立
  : 7
  : 6
  : 5
  : 4
  : 3
  : 2
  : 1
  : 0
  : -1
  : -2
  : -3
  : -4
  : -5
  : -6
  : -7
  : -8;

层级（从高到低）          类型                  说明
════════════════════════════════════════════════════════════════
    Top Type         any / unknown         顶层类型，所有类型的父类型
                       ↓
    装箱对象            Object              包含所有除 Top Type 外的类型
                       ↓
    对象类型          object / {}           所有非原始类型
                       ↓
    装箱类型           String 等            原始类型的装箱对象
                       ↓
    原始类型      string / number 等        基础数据类型
                       ↓
    联合类型      'a' | 'b' | 'c'           同一基础类型的联合
                       ↓
    字面量类型     'linbudu' / 1 等          具体的值类型
                       ↓
   Bottom Type          never               底层类型，所有类型的子类型

// Object 是 any 和 unknown 的子类型
Object extends any       // ✅
Object extends unknown   // ✅

// any 和 unknown 的关系
any extends unknown      // ✅
unknown extends any      // ✅（特殊规则）

// 原始类型 → 装箱类型 → Object
string extends String    // ✅
String extends Object    // ✅

// 空对象类型 {} 的特殊性
String extends {}        // ✅（结构化类型系统）
{} extends object        // ✅（类型信息层面）
object extends {}        // ✅（结构化类型系统）

// never 是所有类型的子类型
never extends string     // ✅
never extends any        // ✅
never extends unknown    // ✅

┌─────────────────────────────────────────┐
│           Top Type (顶层类型)             │
│                                         │
│    ┌─────────┐        ┌──────────┐     │
│    │   any   │ ←────→ │ unknown  │     │
│    └─────────┘        └──────────┘     │
│           ↑                ↑            │
│           │                │            │
└───────────┼────────────────┼───────────┘
            │                │
┌───────────┼────────────────┼───────────┐
│           │                │            │
│    ┌──────┴──────┐         │            │
│    │   Object    │ ←───────┘            │
│    └──────┬──────┘                      │
│           │                             │
│    ┌──────┴──────┐                      │
│    │   object    │                      │
│    └──────┬──────┘                      │
│           │                             │
│    ┌──────┴──────┐                      │
│    │   String    │   (装箱类型)          │
│    └──────┬──────┘                      │
│           │                             │
│    ┌──────┴──────┐                      │
│    │   string    │   (原始类型)          │
│    └──────┬──────┘                      │
│           │                             │
│    ┌──────┴──────┐                      │
│    │  'literal'  │   (字面量类型)        │
│    └──────┬──────┘                      │
│           │                             │
└───────────┼─────────────────────────────┘
            │
┌───────────┼─────────────────────────────┐
│    ┌──────┴──────┐                      │
│    │    never    │   (底层类型)          │
│    └─────────────┘                      │
│         Bottom Type                      │
└─────────────────────────────────────────┘

class Animal {
  name: string = '';
  age: number = 0;
}

class Dog extends Animal {
  breed: string = '';
  bark(): void {
    console.log('Woof!');
  }
}

// 派生类是基类的子类型
type IsSubtype = Dog extends Animal ? true : false; // true ✅

// 函数参数类型协变
function feedAnimal(animal: Animal): void {
  console.log(`Feeding ${animal.name}`);
}

const dog = new Dog();
feedAnimal(dog); // ✅ Dog 是 Animal 的子类型，可以安全传递

// 数组类型的协变
const dogs: Dog[] = [new Dog()];
const animals: Animal[] = dogs; // ✅ 在 TypeScript 中允许（但有风险）

// 规则：联合类型 A extends 联合类型 B
// 当且仅当 A 的所有成员都在 B 中存在

type Result40 = 1 | 2 | 3 extends 1 | 2 | 3 | 4 ? 1 : 2; // 1 ✅
type Result41 = 2 | 4 extends 1 | 2 | 3 | 4 ? 1 : 2; // 1 ✅
type Result42 = 1 | 2 | 5 extends 1 | 2 | 3 | 4 ? 1 : 2; // 2 ❌ (5 不在目标中)
type Result43 = 1 | 5 extends 1 | 2 | 3 | 4 ? 1 : 2; // 2 ❌ (5 不在目标中)

A extends B 成立 ⟺ A 的成员 ⊆ B 的成员

// 类型收窄
type Status = 'pending' | 'processing' | 'completed' | 'failed';
type SuccessStatus = 'completed';
type ProcessingStatus = 'pending' | 'processing';

function handleStatus(status: Status): void {
  if (status as ProcessingStatus extends Status) {
    // 类型收窄为 ProcessingStatus
    console.log('Still working...');
  }
}

// 工具类型：判断子集
type IsSubset<A, B> = A extends B ? true : false;

type Check1 = IsSubset<'a' | 'b', 'a' | 'b' | 'c'>; // true
type Check2 = IsSubset<'a' | 'd', 'a' | 'b' | 'c'>; // false

// 1. 元组 vs 数组
type Result44 = [number, number] extends number[] ? 1 : 2; // 1 ✅
type Result45 = [number, string] extends number[] ? 1 : 2; // 2 ❌

// 2. 元组 vs 联合类型数组
type Result46 = [number, string] extends (number | string)[] ? 1 : 2; // 1 ✅

// 3. 空元组
type Result47 = [] extends number[] ? 1 : 2; // 1 ✅
type Result48 = [] extends unknown[] ? 1 : 2; // 1 ✅

// 4. 数组之间的协变
type Result49 = number[] extends (number | string)[] ? 1 : 2; // 1 ✅

// 5. 特殊类型的数组
type Result50 = any[] extends number[] ? 1 : 2; // 1 ✅
type Result51 = unknown[] extends number[] ? 1 : 2; // 2 ❌
type Result52 = never[] extends number[] ? 1 : 2; // 1 ✅

// 元组转联合类型
type TupleToUnion<T extends any[]> = T[number];

type Result = TupleToUnion<[1, 2, 3]>; // 1 | 2 | 3

// 固定长度数组的约束
type FixedArray<T, N extends number> = N extends N 
  ? number extends N 
    ? T[] 
    : _FixedArray<T, N, []>
  : never;

type _FixedArray<T, N extends number, R extends T[]> = 
  R['length'] extends N 
    ? R 
    : _FixedArray<T, N, [...R, T]>;

type ThreeNumbers = FixedArray<number, 3>; // [number, number, number]

// 参数逆变，返回值协变
type Func1 = (x: string) => void;
type Func2 = (x: 'hello') => void;

// 参数类型：'hello' extends string → 函数参数逆变 → Func2 extends Func1
type Result53 = Func2 extends Func1 ? true : false; // false（实际是 true，但有严格模式）

// 返回值协变
type Func3 = () => string;
type Func4 = () => 'hello';

type Result54 = Func4 extends Func3 ? true : false; // true ✅

// 分布式条件类型
type Result55 = 1 | 2 | 3 extends 1 | 2 ? true : false; // false

// 等价于：
type Distributed = 
  | (1 extends 1 | 2 ? true : false)  // true
  | (2 extends 1 | 2 ? true : false)  // true
  | (3 extends 1 | 2 ? true : false); // false
// 结果：true | true | false = true | false = boolean

// 另一个例子
type Filter<T, U> = T extends U ? T : never;

type Result56 = Filter<1 | 2 | 3 | 4, 1 | 2>; // 1 | 2

// 定义 API 响应类型
type ApiResponse<T> = 
  | { success: true; data: T }
  | { success: false; error: string };

// 处理响应
function handleResponse<T>(response: ApiResponse<T>) {
  if (response.success) {
    // TypeScript 自动收窄类型为 { success: true; data: T }
    console.log('Data:', response.data);
  } else {
    // TypeScript 自动收窄类型为 { success: false; error: string }
    console.error('Error:', response.error);
  }
}

// 使用 unknown 处理未知响应
function parseApiResponse(json: string): unknown {
  try {
    return JSON.parse(json);
  } catch {
    return { error: 'Invalid JSON' };
  }
}

// 类型安全的数据提取
function extractData(response: unknown): string | null {
  if (typeof response === 'object' && response !== null) {
    if ('data' in response && typeof response.data === 'string') {
      return response.data;
    }
  }
  return null;
}

// 1. 基础类型守卫
function processValue(value: unknown) {
  if (typeof value === 'string') {
    // value 被收窄为 string 类型
    return value.toUpperCase();
  } else if (typeof value === 'number') {
    // value 被收窄为 number 类型
    return value.toFixed(2);
  }
  throw new Error('Unsupported type');
}

// 2. 自定义类型守卫
interface User {
  id: number;
  name: string;
  email: string;
}

function isUser(value: unknown): value is User {
  return (
    typeof value === 'object' &&
    value !== null &&
    'id' in value &&
    'name' in value &&
    'email' in value
  );
}

function greetUser(userOrId: User | number) {
  if (isUser(userOrId)) {
    // userOrId 被收窄为 User 类型
    console.log(`Hello, ${userOrId.name}!`);
  } else {
    // userOrId 被收窄为 number 类型
    console.log(`User ID: ${userOrId}`);
  }
}

// 3. 联合类型的穷尽性检查
type Role = 'admin' | 'user' | 'guest';

function getPermissions(role: Role): string[] {
  switch (role) {
    case 'admin':
      return ['read', 'write', 'delete'];
    case 'user':
      return ['read', 'write'];
    case 'guest':
      return ['read'];
    default:
      // 如果未来添加了新角色，这里会报错
      const _exhaustiveCheck: never = role;
      throw new Error(`Unknown role: ${_exhaustiveCheck}`);
  }
}

// 1. 深度 Required
type DeepRequired<T> = T extends object
  ? { [K in keyof T]-?: DeepRequired<T[K]> }
  : T;

interface User {
  name?: string;
  profile?: {
    age?: number;
    email?: string;
  };
}

type RequiredUser = DeepRequired<User>;
// { name: string; profile: { age: number; email: string } }

// 2. 类型过滤
type FilterType<T, U> = T extends U ? T : never;

type StringOrNumber = string | number | boolean;
type OnlyString = FilterType<StringOrNumber, string>; // string

// 3. 提取函数返回值类型
type ExtractReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

function getUser() {
  return { id: 1, name: 'Alice' };
}

type UserReturn = ExtractReturnType<typeof getUser>;
// { id: number; name: string }

// 4. 条件类型映射
type TypeName<T> = T extends string
  ? 'string'
  : T extends number
  ? 'number'
  : T extends boolean
  ? 'boolean'
  : T extends undefined
  ? 'undefined'
  : T extends Function
  ? 'function'
  : 'object';

type T1 = TypeName<string>; // 'string'
type T2 = TypeName<number[]>; // 'object'
type T3 = TypeName<() => void>; // 'function'

// 1. 约束对象属性
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const user = { name: 'Alice', age: 30 };
const name = getProperty(user, 'name'); // string
const age = getProperty(user, 'age'); // number
// getProperty(user, 'email'); // ❌ Error: 'email' 不是 'name' | 'age'

// 2. 约束数组元素类型
function createArray<T>(length: number, value: T): T[] {
  return Array(length).fill(value);
}

const strArray = createArray(3, 'hello'); // string[]
const numArray = createArray(2, 42); // number[]

// 3. 约束构造函数
function createInstance<T>(ctor: new (...args: any[]) => T, ...args: any[]): T {
  return new ctor(...args);
}

class Person {
  constructor(public name: string, public age: number) {}
}

const person = createInstance(Person, 'Bob', 25);
// person: Person

// 4. 条件约束
type NonNullable<T> = T extends null | undefined ? never : T;

type T4 = NonNullable<string | null>; // string
type T5 = NonNullable<number | undefined>; // number

// 定义配置类型
interface Config {
  apiUrl: string;
  timeout: number;
  retries: number;
  headers: Record<string, string>;
}

// 部分配置
type PartialConfig = Partial<Config>;

// 合并配置
function mergeConfig(defaults: Config, userConfig: PartialConfig): Config {
  return {
    ...defaults,
    ...userConfig,
    headers: {
      ...defaults.headers,
      ...userConfig.headers,
    },
  };
}

// 使用示例
const defaultConfig: Config = {
  apiUrl: 'https://api.example.com',
  timeout: 5000,
  retries: 3,
  headers: {
    'Content-Type': 'application/json',
  },
};

const userConfig: PartialConfig = {
  timeout: 10000,
  headers: {
    Authorization: 'Bearer token123',
  },
};

const finalConfig = mergeConfig(defaultConfig, userConfig);

// 定义状态类型
type State = {
  user: User | null;
  isLoading: boolean;
  error: string | null;
};

// 定义 Action 类型
type Action =
  | { type: 'FETCH_USER_START' }
  | { type: 'FETCH_USER_SUCCESS'; payload: User }
  | { type: 'FETCH_USER_ERROR'; payload: string };

// Reducer
function reducer(state: State, action: Action): State {
  switch (action.type) {
    case 'FETCH_USER_START':
      return {
        ...state,
        isLoading: true,
        error: null,
      };
    case 'FETCH_USER_SUCCESS':
      return {
        ...state,
        isLoading: false,
        user: action.payload,
      };
    case 'FETCH_USER_ERROR':
      return {
        ...state,
        isLoading: false,
        error: action.payload,
      };
    default:
      // 穷尽性检查
      const _exhaustiveCheck: never = action;
      return state;
  }
}

// ❌ 不推荐：使用 any
function parseJSONUnsafe(json: string): any {
  return JSON.parse(json);
}

const data = parseJSONUnsafe('{"name": "Alice"}');
data.foo.bar; // 运行时错误，但编译时不会报错

// ✅ 推荐：使用 unknown
function parseJSONSafe(json: string): unknown {
  return JSON.parse(json);
}

const safeData = parseJSONSafe('{"name": "Alice"}');
// safeData.foo.bar; // ❌ Error: 'safeData' 是一个 'unknown' 类型

// 正确的做法：类型收窄
if (typeof safeData === 'object' && safeData !== null && 'name' in safeData) {
  console.log((safeData as { name: string }).name);
}

// ❌ 不推荐：过度使用类型断言
const value = someData as string;

// ✅ 推荐：使用类型守卫
function isString(value: unknown): value is string {
  return typeof value === 'string';
}

if (isString(someData)) {
  console.log(someData.toUpperCase());
}

// ❌ 不推荐：复杂的条件嵌套
type ReturnType<T> = T extends (...args: any[]) => any 
  ? T extends (...args: any[]) => infer R 
    ? R 
    : any
  : any;

// ✅ 推荐：使用 infer 提取类型
type BetterReturnType<T extends (...args: any[]) => any> = 
  T extends (...args: any[]) => infer R ? R : any;

// ❌ 不推荐：过度嵌套
type BadTypeName<T> = 
  T extends string ? 'string' :
  T extends number ? 'number' :
  T extends boolean ? 'boolean' :
  T extends undefined ? 'undefined' :
  T extends Function ? 'function' :
  T extends null ? 'null' :
  'object';

// ✅ 推荐：使用映射和查找
type TypeNameMap = {
  string: 'string';
  number: 'number';
  boolean: 'boolean';
  undefined: 'undefined';
  function: 'function';
  null: 'null';
  object: 'object';
};

type BetterTypeName<T> = T extends keyof TypeNameMap 
  ? TypeNameMap[T]
  : 'object';

// ✅ 推荐：使用联合类型表示互斥状态
type Result = 
  | { status: 'success'; data: string }
  | { status: 'error'; error: Error };

function handleResult(result: Result) {
  if (result.status === 'success') {
    console.log(result.data); // ✅ 类型安全
  } else {
    console.error(result.error.message); // ✅ 类型安全
  }
}

// ✅ 推荐：使用交叉类型扩展对象
type BaseConfig = {
  apiUrl: string;
  timeout: number;
};

type ExtendedConfig = BaseConfig & {
  retries: number;
  headers: Record<string, string>;
};

// ✅ 推荐：使用 never 确保处理所有情况
type Shape = 'circle' | 'square' | 'triangle';

function getArea(shape: Shape): number {
  switch (shape) {
    case 'circle':
      return Math.PI;
    case 'square':
      return 1;
    case 'triangle':
      return 0.5;
    default:
      const _exhaustiveCheck: never = shape;
      throw new Error(`Unknown shape: ${_exhaustiveCheck}`);
  }
}

// 如果未来添加 'rectangle'，default 分支会报错
// 提醒开发者处理新情况

// ✅ 推荐：使用 never 过滤联合类型
type Filter<T, U> = T extends U ? T : never;

type OnlyStrings = Filter<string | number | boolean, string>; // string

// ✅ 推荐：编写可复用的类型守卫
function isDefined<T>(value: T | null | undefined): value is T {
  return value !== null && value !== undefined;
}

function isString(value: unknown): value is string {
  return typeof value === 'string';
}

function isNumber(value: unknown): value is number {
  return typeof value === 'number';
}

function isObject(value: unknown): value is Record<string, unknown> {
  return typeof value === 'object' && value !== null;
}

// 使用示例
const values: (string | number | null | undefined)[] = ['hello', 42, null, undefined];

const definedValues = values.filter(isDefined);
// (string | number)[]

const strings = values.filter(isString);
// string[]

// ❌ 不推荐：过度复杂的类型
type ComplexType<T> = T extends object
  ? T extends Array<infer U>
    ? U extends object
      ? DeepPartial<U>
      : U
    : { [K in keyof T]?: ComplexType<T[K]> }
  : T;

// ✅ 推荐：拆分为多个简单类型
type DeepPartial<T> = T extends object
  ? { [K in keyof T]?: DeepPartial<T[K]> }
  : T;

type ArrayElement<T> = T extends Array<infer U> ? U : T;

// ✅ 推荐：使用缓存避免重复计算
type DeepReadonlyCache = {
  object: { readonly [K in keyof any]: any };
  array: readonly any[];
};

type DeepReadonly<T> = T extends any[]
  ? readonly DeepReadonly<T[number]>[]
  : T extends object
  ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
  : T;

// ✅ 推荐：为复杂类型添加详细注释
/**
 * 从对象类型 T 中提取指定键 K 的类型
 * @template T - 源对象类型
 * @template K - 要提取的键，必须是 T 的键之一
 * @returns T[K] 的类型
 * @example
 * type User = { name: string; age: number };
 * type NameType = PickType<User, 'name'>; // string
 */
type PickType<T, K extends keyof T> = T[K];

// any: 完全不安全的类型
let anyValue: any = 'hello';
anyValue = 123; // ✅ 允许
anyValue.toUpperCase(); // ✅ 允许，但可能运行时错误
let str: string = anyValue; // ✅ 允许

// unknown: 类型安全的未知类型
let unknownValue: unknown = 'hello';
unknownValue = 123; // ✅ 允许
// unknownValue.toUpperCase(); // ❌ Error: 'unknownValue' 是一个 'unknown' 类型
// let str2: string = unknownValue; // ❌ Error

// 正确使用 unknown
if (typeof unknownValue === 'string') {
  console.log(unknownValue.toUpperCase()); // ✅ 类型安全
}

// 1. 表示永不返回的函数
function throwError(message: string): never {
  throw new Error(message);
}

function infiniteLoop(): never {
  while (true) {}
}

// 2. 穷尽性检查
type Shape = 'circle' | 'square';

function getArea(shape: Shape): number {
  switch (shape) {
    case 'circle':
      return Math.PI;
    case 'square':
      return 1;
    default:
      const _exhaustiveCheck: never = shape; // 如果添加新形状，这里会报错
      throw new Error(`Unknown shape: ${_exhaustiveCheck}`);
  }
}

// 3. 过滤联合类型
type NonNullable<T> = T extends null | undefined ? never : T;
type Result = NonNullable<string | null | undefined>; // string

type Result1 = string extends object ? true : false; // false ❌

// 但通过装箱类型和结构化类型系统，可以建立关系：
type Result2 = string extends String ? true : false; // true ✅
type Result3 = String extends {} ? true : false; // true ✅
type Result4 = {} extends object ? true : false; // true ✅

// null: 表示"空值"
let nullValue: null = null;

// undefined: 表示"未定义"
let undefinedValue: undefined = undefined;

// void: 表示"没有返回值"
function logMessage(message: string): void {
  console.log(message);
  // 没有 return，或 return;
}

// never: 表示"永不存在的值"
function fail(): never {
  throw new Error('Never returns');
}

// 类型层级：它们都是独立的类型，与其他类型同级
type T1 = null extends string ? true : false; // false
type T2 = undefined extends string ? true : false; // false
type T3 = void extends string ? true : false; // false

// 方法1：条件类型
type IsCompatible<A, B> = A extends B ? true : false;

type T1 = IsCompatible<string, any>; // true
type T2 = IsCompatible<'hello', string>; // true
type T3 = IsCompatible<string, 'hello'>; // false

// 方法2：赋值检查
declare let a: string;
declare let b: 'hello';

a = b; // ✅ 'hello' 是 string 的子类型
// b = a; // ❌ string 不是 'hello' 的子类型

type Result = any extends string ? 1 : 2; // 1 | 2

// 这不同于联合类型：
type UnionResult = string | number extends string ? 1 : 2; // 2

// 1. 你比 TypeScript 更了解类型
const element = document.getElementById('myId') as HTMLInputElement;
element.value = 'hello'; // ✅ 现在可以访问 value 属性

// 2. 类型缩窄（但优先使用类型守卫）
const value = someData as string; // ❌ 不推荐

// 推荐：
if (typeof someData === 'string') {
  const value = someData; // ✅ 类型安全
}

// 3. 临时解决方案（应尽快修复）
const result = someUnfinishedCode as any; // 临时方案

const str: string = "linbudu";

// 双重断言：先向上到 Top Type，再向下到目标类型
(str as (string | { handler: () => {} }) as { handler: () => {} }).handler();

// 深度 Partial
type DeepPartial<T> = T extends object
  ? { [K in keyof T]?: DeepPartial<T[K]> }
  : T;

interface User {
  name: string;
  profile: {
    age: number;
    email: string;
  };
}

type PartialUser = DeepPartial<User>;
// {
//   name?: string;
//   profile?: {
//     age?: number;
//     email?: string;
//   };
// }

// 提取 Promise 值类型
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;

type Result = UnwrapPromise<Promise<string>>; // string

// object: 所有非原始类型
// 包括：{}, [], () => void, Function 等
type T1 = {} extends object ? true : false; // true
type T2 = [] extends object ? true : false; // true
type T3 = (() => void) extends object ? true : false; // true

// Object: 所有除 Top Type 外的类型
// 包括：string, number, boolean, object 等
type T4 = string extends Object ? true : false; // true
type T5 = number extends Object ? true : false; // true

// 但不包括 Top Type
type T6 = any extends Object ? true : false; // boolean (any 的特殊性)
type T7 = unknown extends Object ? true : false; // false

// 1. 使用条件类型检查类型
type Debug<T> = { [K in keyof T]: T[K] };

type Result = Debug<{ name: string; age: number }>;
// 查看编译后的类型

// 2. 使用类型别名简化错误信息
type UserName = string;
type UserAge = number;

interface User {
  name: UserName;
  age: UserAge;
}

// 3. 分步构建复杂类型
type Step1<T> = { [K in keyof T]: T[K] };
type Step2<T> = Partial<Step1<T>>;
type Step3<T> = Readonly<Step2<T>>;

// 4. 使用工具类型进行测试
type TestEquals<A, B> = A extends B ? (B extends A ? true : false) : false;

type T1 = TestEquals<string, string>; // true
type T2 = TestEquals<string, number>; // false

never → 字面量类型 → 联合类型 → 原始类型 → 装箱类型 → Object → any/unknown

// 1. 类型层级核心链
never < 字面量 < 联合类型 < 原始类型 < 装箱类型 < Object < any/unknown

// 2. Top Type
any:     完全不安全，可以赋值给任何类型
unknown: 类型安全，需要类型收窄后使用

// 3. Bottom Type
never: 永不存在的值，用于错误处理和穷尽检查

// 4. 判断类型兼容性
// 方法1：条件类型
type IsSubtype<A, B> = A extends B ? true : false;

// 方法2：赋值检查
// a = b 成立 → b 的类型是 a 类型的子类型

// 5. 特殊规则
any extends T      → 1 | 2  (联合类型)
never | T          → T      (never 被吸收)
never & T          → never  (交集为 never)