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 chenweiCwCw #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] };

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

keyof T는 객체 타입 T의 모든 키를 가져오는 TypeScript의 내장 기능입니다.
[key in keyof T]는 T의 모든 키를 순회하면서, 새로운 객체 타입을 만드는 구문입니다.
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

type Exclude<TKey, KKey> = TKey extends KKey ? never : TKey;

type MyPick<T, K extends keyof T> = {
	[TK in K]: T[TK];
};

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

Solution by ProvorovOleksii #34099

// 你的答案
type Key<TK, K extends TK> = TK extends K ? never : TK;
type MyOmit<T, K extends keyof T> = {
  [P in Key<keyof T, K>]: T[P];
};

Solution by yyl134934 #34081

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

Solution by ouzexi #33978

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

Solution by G00syara #33959

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

Solution by G00syara #33958

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

Solution by lidongyun120398 #33915


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

Solution by ckdwns9121 #33901

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

Solution by notsecret32 #33886

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

意外とつまづいた。最初は以下の回答にしていたがreadonlyのプロパティが残らずパスできなかった。

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

Solution by okabe-yuya #33876

// 你的答案

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

Solution by QHCLF #33797

00003-medium-omit

문제 설명

풀이

Solution