keyof 操作符

keyof 操作符 会返回该对象属性名组成的一个字符串或者 字面量 的联合类型

  1. type Point = {x:number,y:number}
  2. type P = keyof Point //keyof Point

如果是 一个索引签名，则是 直接返回这些类型

  1. type Arraysh = {
  2.     [n:number]:unknown
  3. }
  4. type A = keyof Arraysh //number
  6. type Mapsh = {
  7.     [k:string]:boolean
  8. }
  9. type M = keyof Mapsh //string | number
  10. //这里之所以是 string | number， 是因为js中对象的属性名是会被强制转字符串的
  11. //所以obj[0] obj['0']一致
数字字面量联合类型
  1. const NumericObject = {
  2.     [1]: "冴羽一号",
  3.     [2]: "冴羽二号",
  4.     [3]: "冴羽三号"
  5.   };
  7. NumericObject作为值 是不能直接keyof ，先typeof 返回
  8. type result = {
  9.   1:string
  10.   2:string
  11.   3:string
  12. }
  13. 然后keyof 返回 1|2|3
  15.   type result = keyof typeof NumericObject
keyof应用
  1. function getProperty<T, K extends keyof T>(obj: T, k: K) {
  2.     return obj[k];
  3. }
  4. let x = { a: 1, b: 2 };
  6. getProperty(x, "a");
typeof操作符

typeof 用于获取类型 一般是和其他操作符搭配使用

  1. function f(){
  2.     return {x:10,y:3}
  3. }
  4. //需要先typeof得到 函数描述类型 再ReturnType
  5. //声明函数本身是一个值 而不是 类型
  6. type P = ReturnType<typeof f>
索引访问操作符
  1. const App = ['Taobao','Tmall','Alipay'] as const
  3. type app = typeof App[number]
  5. function getPhoto(app:app){}
  7. getPhoto('Tabobao') // 报错 不是符合的名称
  9. //-------------------
  10. const App = ['Taobao','Tmall','Alipay'] as const
  11. 这个相当于是 const App:readonly['Taobao','Tmall','Alipay']
  12. 它变成了一个字面量，此时再通过 typeof 得到所有索引 就变成一个字符串联合类型
映射类型
  1. type Opt<T> = {
  2.     [Property in keyof T]:boolean
  3. }
  5. type Fe = {
  6.     dm:()=>void
  7.     np:()=>void
  8. }
  10. //此时Fo 已经是 布尔结果的数据了
  11. type Fo = Opt<Fe>
映射修饰符
    • 操作符
  1. type Cm<T> = {
  2.     -readonly [p in keyof T]:T[p]
  3. }
  5. type lk = {
  6.     readonly id:string
  7.     readonly name:string
  8. }
  10. type uk = Cm<lk>
as映射
  1. type Getters<T> = {
  2. [p in keyof T as `get${Capitalize<string & p>}`]:()=>T[p]
  3. }
  5. interface Person{
  6. name:string
  7. age:number
  8. }
  10. type Lz = Getters<Person>
  13. type Rk<T> = {
  14. [p in keyof T as Exclude<p,'kind'>]:T[p]
  15. }
  17. interface Ce{
  18. kind:'cc'
  19. radius:number
  20. }
  22. type kc = Rk<Ce>
  1. type Ep<T> = {
  2.     [p in keyof T]:T[p] extends {pii:true}?true:false
  3. }
  5. type Dbf = {
  6.     id:{format:"inc"}
  7.     name:{type:string,pii:true}
  8. }
  10. type on = Ep<Dbf>