00003-medium-omit

Back 

type MyOmit<T, K extends keyof T> = {
  [Key in keyof T as Key extends K ? never : Key] : T[Key]
};

Solution by tac-tac-go #35870 

// 你的答案
// 答案1：使用as键值重映射方法
type MyOmit1<T, K extends keyof T> = {
  [key in keyof T as key extends K ? never : key]: T[key]
}

// 答案2：使用Exclude方法(能通过全部测试用例)
type MyOmit<T, K extends keyof T> = {
  [key in keyof T as Exclude<key, K> ]:T[key]
}

// 答案3：使用Exclude方法(不能通过全部测试用例，因为不用as会丢失readonly/?等修饰符类型)
type MyOmit<T, K extends keyof T> = {
  [key in Exclude<keyof T, K>]: T[key]
}

Solution by song4613107 #35799 

// ============= Test Cases =============
import type { Equal, Expect } from './test-utils'

type cases = [
  Expect<Equal<Expected1, MyOmit<Todo, 'description'>>>,
  Expect<Equal<Expected2, MyOmit<Todo, 'description' | 'completed'>>>,
]

// @ts-expect-error
type error = MyOmit<Todo, 'description' | 'invalid'>

interface Todo {
  title: string
  description: string
  completed: boolean
}

interface Expected1 {
  title: string
  completed: boolean
}

interface Expected2 {
  title: string
}


// ============= Your Code Here =============
type MyOmit<T, K extends keyof T> = {
  [P in keyof T as P extends K ? never : P]: T[P]
}

Solution by hawkWang98 #35507 

type MyOmit<T, K extends keyof T> = { [P in keyof T as P extends K ? never : P]: T[P] };

Solution by gangnamssal #35497 

type MyReadonly2<T, K extends keyof T = keyof T> = {readonly [key1 in K] : T[key1]} & {
  [key2 in keyof T as key2 extends K ?  never : key2] : T[key2]
}

Solution by RanungPark #35448 

type MyOmit<T, K extends keyof T> = {
  [key in keyof T as key extends K ? never : key]: T[key];
};

Solution by RanungPark #35447 

// your answers
interface Todo {
    title: string;
    description: string;
    completed: boolean;
}

type MyOmit<T extends {}, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

const myTodo: MyOmit<Todo, "title" | "description"> = {
    completed: false,
};

Solution by Sathiyapramod #35409 

// your answers
type MyOmit<T, K> = Pick<T, Exclude<keyof T, K>>;

Solution by kdh3543 #35395 

type MyOmit<T, K extends keyof T> = Omit<T,K>

Solution by TaueFenCheng #35329 

type MyOmit<T extends Object, K extends keyof T> = {
  [P in keyof T as P extends K ? never: P]: T[P]
}

Solution by yujun96 #35284 

type MyOmit<T, K extends keyof T> = {
  [k in keyof T as Exclude<k, K>]: T[k];
};

Solution by wendao-liu #35158 

type MyOmit<T extends object, K extends keyof T> = Pick<T, Exclude<keyof T, K>>
type MyOmit<T extends object, K extends keyof T> = {
 [key in Exclude<keyof T, K>]: T[key]
 }
type MyOmit<T extends object, K extends keyof T> = {
  [key in K extends T? never: K]: T[key]
}

Solution by chenweiHuabi #35100 

type MyOmit<T, P extends keyof T> = {
	[K in keyof T as K extends P ? never : K]: T[K]
}

Solution by ClarityOfMind #35039 

type MyOmit<T, K extends keyof T> = {
  [P in Exclude<keyof T, K>]: T[P];
};

Solution by raeyoung-kim #34995 

type MyOmit<T, K extends keyof T> = {
  [P in keyof T as P extends K ? never : P]: T[P];
}

Solution by raeyoung-kim #34986 

type MyOmit<T, K extends keyof T> = Omit<T,K>

Solution by Niravkhetani #34983 

// your answers

type MyOmit<T, K extends keyof T> = {
  [key in keyof T as key extends K ? never :key]: key extends K ? never : T[key]
}

Solution by 2njeong #34965

type MyOmit<T, K> = { [key in keyof T as key extends K?never:key ]:T[key] }

// your answers

Solution by Xiaofan-song #34959

type MyOmit<T, K extends keyof T> = { [property in keyof T]: property extends K ? never : T[property]; };

why it doesn't work?

Solution by shx123qwe #34911 

type MyOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>

Solution by eunsukimme #34820 

// your answers
type MyOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

Solution by zeyuanHong0 #34752 

// 여기 풀이를 입력하세요
type MyOmit<T, K extends keyof T> = {
  [P in keyof T as P extends K ? never : P]: T[P];
};

Solution by LeeKangHyun #34587 

type MyOmit<T extends Record<string, any>, K extends keyof T> = {  [P in keyof T as (P extends K ? never : P)]: T[P] }
// your answers

Solution by Rustamaha #34586

We should check K's extends condition(keyof T) to pass @ts-expect-error. And, use as to restrict "not" extends K condition.

type MyOmit<T, K extends keyof T> = {
  [U in keyof T as (U extends K ? never: U)]: T[U];
}

Solution by dev-jaemin #34584 

type MyOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

Solution by Yunjaejo #34580 

type MyOmit<T, K extends keyof T> = {
  [Key in keyof T as Key extends K ? never : Key] : T[Key]; 
}

Solution by bkdragon0228 #34568 

type MyOmit<T, K> = {
  [P in keyof T as P extends K ? never : P]: T[P]
}

Solution by devshinthant #34553 

type Exclude<T, U> = T extends U ? never : T;

type MyOmit<T, K extends keyof T> = {
  [P in Exclude<keyof T, K>]: T[P]
}

Solution by wxh-cyber #34439 

type MyOmit<T extends object, K extends keyof T> = {
  [P in keyof T as P extends K ? never : P]: T[P];
}

Solution by ktim816 #34417

문제 설명

풀이

type MyOmit<T, K> = T extends K ? never : T;

다음과 같이 작성하였으나 이건 Excludes 처럼의 동작과 같아서 배제합니다. 오히려 Pick과 비슷하게 구현해야했습니다.

type MyOmit<T, K> = { [key in keyof T as key extends K ? never : key]: T[key] };

다소 복잡하지만 하나씩 하나씩 풀어서 해결해봅시다.

  1. keyof T는 객체 타입 T의 모든 키를 가져오는 TypeScript의 내장 기능입니다.
  2. [key in keyof T]는 T의 모든 키를 순회하면서, 새로운 객체 타입을 만드는 구문입니다.
  3. key extends K ? never : key 는 key가 K에 포함되는지 (extends K)를 검사하고, 만약 포함된다면 never를 반환합니다. 그렇지 않다면 key를 그대로 사용합니다.

Solution

/* _____________ 여기에 코드 입력 _____________ */

type MyOmit<T, K> = { [key in keyof T as key extends K ? never : key]: T[key] };

/* _____________ 테스트 케이스 _____________ */
import type { Equal, Expect } from "@type-challenges/utils";

type cases = [
	Expect<Equal<Expected1, MyOmit<Todo, "description">>>,
	Expect<Equal<Expected2, MyOmit<Todo, "description" | "completed">>>,
	Expect<Equal<Expected3, MyOmit<Todo1, "description" | "completed">>>
];

// @ts-expect-error
type error = MyOmit<Todo, "description" | "invalid">;

interface Todo {
	title: string;
	description: string;
	completed: boolean;
}

interface Todo1 {
	readonly title: string;
	description: string;
	completed: boolean;
}

interface Expected1 {
	title: string;
	completed: boolean;
}

interface Expected2 {
	title: string;
}

interface Expected3 {
	readonly title: string;
}

Solution by adultlee #34127