typescript记录

//用于测试的类型
type User = {
  readonly name:string;
  age:number;
  sex:"男" | "女";
  height?:number;
}

// 把所有类型转换为readonly
type MyReadonly<T>= {
  +readonly [key in keyof T]:T[key]
}
const myTest2:MyReadonly<User> = {
  name:"张三",
  age:15,
  sex:"男"
}
myTest2.age = 18; //错误，无法为“age”赋值，因为它是只读属性

// 把所有类型转换为可选
type MyChoosable<T> = {
  [key in keyof T]+?:T[key]
} 
const myTest3:MyChoosable<User> = {}

// 把所有可选变成必选，所有只读变成可改
type MyNegation<T> = {
  -readonly [key in keyof T]-? : T[key]
}
const myTest4:MyNegation<User> = {  //错误，缺少height属性
  name:"张三",
  age:15,
  sex:"男",
}
myTest4.name = "李四"  //正确，不是只读属性

//限制对象的key取值，以及限制类型
type NyRerod<T extends keyof any,U>={
  [key in T] : U
}
type abc = "a" | "b" | "c"
const myTest5:NyRerod<abc,User> = {
  a:{name:"张三",age:18,sex:"女"},
  b:{name:"张三",age:18,sex:"女"},
  c:{name:"张三",age:18,sex:"女"},
}

// 在某个类型中选几个值生成新的类型
type MyPick<T,U extends keyof T> = {
  [key in  U]:T[key]
}
const myTest6:MyPick<User,"name" | "age"> = {
  name:"张三",
  age:18
}

// 将两个类型进行合并，相同键取后面的
type user1 = {
  name:string;
  age:number;
  sex:"男" | "女"
}
type user2 = {
  name:number;
  age:number;
  sex:"A" | "B"
  like:string;
}
type myMerge<T,U> = {
  [key in keyof T | keyof U] : key extends keyof U ? U[key] : key extends keyof T ? T[key] : never
}
type result = myMerge<user1,user2>

// 排除相同的类型
type MyExclude<T,U> = T extends U ? never : T;
type T0 = MyExclude<"a" | "b" | "c", "c">

// 取出共同的类型
type MyExtract<T,U> = T extends U ? T : never;
type T1 = MyExtract<"a" | "b" | "c", "c">

// 指定移除对象的某些健
type Todo = {
  title: string;
  description: string;
  completed: boolean;
  createdAt: number;
}
type myOmit<T,U extends string | number | symbol> = {
  [key in MyExclude<keyof T,U>]:T[key]
}
type TodoPreview = myOmit<Todo, "description">;

// 函数重载定义
function overloadedFunction(x: number): string;
function overloadedFunction(x: string): number;
function overloadedFunction(x: any): any {
    // 实现函数的通用部分
    if (typeof x === 'number') {
        // 处理x为number的情况
        return '这是一个数字: ' + x;
    } else {
        // 处理x为string的情况
        return x.length;
    }
}
 
// 使用函数
let result1 = overloadedFunction(5); // 返回类型是string
let result2 = overloadedFunction('Hello World'); // 返回类型是number

// 映射类型的属性过滤
type User = {
   readonly id:number;
    name:string;
    tel:string;
    address?:string;
}
type A<T,U extends keyof T> = {
    [key in keyof T as key extends U ? never : key] : T[key]
}
type B = A<User,"name" | "tel" >

// 只要类型为string的属性
type C<T, U> = {
    [key in keyof T as T[key] extends U ? key : never]: T[key];
}
type D = C<User, number>

//输入html元素获取它的的类型
type GetElementType<T extends keyof HTMLElementTagNameMap> = HTMLElementTagNameMap[T]
type E = GetElementType<"img">