Type Challenges: 00599-medium-merge Solution

// 你的答案
type Merge<F extends Record<any, any>, S extends Record<any, any>> = {
  [K in keyof F | keyof S]: K extends keyof S ? S[K] : F[K]
}

Solution by HelloGGG #33416

type Merge<F, S> = {
  [P in keyof (F & S)]: P extends keyof S ? S[P] : P extends keyof F ? F[P] : never
}

Solution by loevray #33265

// 你的答案
type Merge<T, T2> = {
  [K in keyof T | keyof T2]: K extends keyof T2 ? T2[K] : K extends keyof T ? T[K] : never;
};

Solution by 2531800823 #33247

type Merge<F, S> = {
  [key in keyof F | keyof S]: key extends keyof F & keyof S 
    ? S[key] : 
    key extends keyof F 
      ? F[key] 
      : key extends keyof S ? S[key] : never;
}

Solution by ZhipengYang0605 #32832

type Merge<
    F extends Record<keyof F, unknown>,
    S extends Record<keyof S, unknown>,
    I = F & S
> = {
    [K in keyof I]:
        K extends keyof S
            ? S[K]
            : K extends keyof F
                ? F[K]
                : never
}

Solution by ZhulinskiiDanil #32702

type Merge<F extends object, S extends object> = 
  { [K in (keyof F | keyof S)]: K extends keyof S ? S[K] : K extends keyof F ? F[K] : never }

Solution by dev-hobin #32415

type Flatten<T> = {
  [P in keyof T]: T[P]
}

type Merge<F, S extends Flatten<S>> = {
  [K in keyof Flatten<F & S>]: Flatten<F & S>[K] extends never ? S[K] : Flatten<F & S>[K]
};

Solution by keyurparalkar #32298

// your answers
type Merge<F, S> = {
  [K in keyof F | keyof S]: K extends keyof S
    ? S[K]
    : K extends keyof F
      ? F[K]
      : never
}

Solution by pea-sys #32218

type Merge<F, S> = Omit<F, keyof S> & S

Solution by rkamely #32062

type Merge<F extends Record<string, unknown>, S extends Record<string, unknown>> = {
	[K in keyof F | keyof S]: K extends keyof F & keyof S
		? S[K]
		: K extends keyof F
		? F[K]
		: K extends keyof S
		? S[K]
		: never;
};

Solution by gasmg #32015

type Merge<F, S> = {
  [P in keyof (F & S)] : P extends keyof (F | S) ? S[P] : (F & S)[P]
}

Solution by jinyoung234 #31814

type Merge<F, S> = {[key in keyof F | keyof S]: key extends keyof S ? S[key] : key extends keyof F ? F[key] : never }

Solution by kai-phan #31648

second argument overwrites first one

type Merge<F extends {}, S extends {}> = {[P in keyof (F & S)]: P extends keyof S ? S[P] : P extends keyof F ? F[P] : never}

Solution by ivannovazzi #31556

type Merge<F, S> = {
  [K in keyof F | keyof S]: K extends keyof S
    ? S[K]
    : K extends keyof F
    ? F[K]
    : never;
};

Solution by vipulpathak113 #31514

type Copy<T> = {
    [P in keyof T]: T[P];
}

type Merge<L, R> = Copy<Omit<L, keyof R> & R>;

Solution by RusJstudent #31436

type Merge<F, S> = {
  [K in keyof F | keyof S]: K extends keyof S
    ? S[K]
    : K extends keyof F
      ? F[K]
      : never
}

Solution by bicochan #31396

type Merge<F, S> = {
  [M in (keyof F) | (keyof S)]: M extends keyof S
    ? S[M]
    : M extends keyof F
    ? F[M]
    : never;
};

Solution by HeeYeonKim98 #31358

type Merge<F, S> = {
    [K in keyof F | keyof S]: K extends keyof S ? S[K] : K extends keyof F ? F[K] : never;
}

Solution by ricky-fn #31299

type Merge<F extends Record<string, any>, S extends Record<string, any>> = {
  [k in keyof F | keyof S]: k extends keyof S ? S[k] : k extends keyof F ? F[k] : never
}

Solution by eward957 #31250

// 解答をここに記入

type Flattern<T> = { [P in keyof T]: T[P] }

type Merge<F, S> =  Flattern<Omit<F, keyof (F | S)> & S>

keyof (F | S)とすることで、共通の key を抽出できるので、F からこれを Omit します。これと、S を結合すれば所望の型が得られます。

（※ Flatten は型一致のために必要なだけなので、この問題の本質ではありません）

Solution by Kakeru-Miyazaki #30869

type Merge<F, S> = Omit<Omit<F, keyof S> & S, never>

Solution by dreamluo-plus #30552

type Merge<F, S> = { [P in keyof F | keyof S]: P extends keyof S ? S[P] : P extends keyof F ? F[P] : never }

Solution by MrRabbit1993 #30465

type Merge<F, S> = {
  [K in keyof F | keyof S]:
    K extends keyof F & keyof S
      ? S[K]
     :  K extends keyof F
        ? F[K]
        : K extends keyof S
          ? S[K]
          : never;
}

Solution by wouldRewind #30394

type Merge<F, S> = {[K in keyof S | keyof F]: K extends keyof S ? S[K]: K extends keyof F ? F[K] : never}

Solution by kai-phan #30366

type Merge<F, S, L = F & S> = {
  [P in keyof L]: L[P] extends never
    ? P extends keyof S
      ? S[P]
      : never
    : L[P]
}

Solution by agus-wesly #30287

Omit<F, keyof S> & S

Solution by k4l4p #29926

type Plain<T> = {
  [P in keyof T]: T[P]
}
type Merge<F, S> = Plain<S & Omit<F, keyof S>>

這個解法可以確保field有完整被拆出來。

Solution by ethansnow2012 #29716

type Merge<F, S> = {
  [K in keyof F | keyof S]: K extends keyof S ? S[K] : (K extends keyof F ? F[K] : never);
};

Solution by maximallain #29675



type Foo = {
    name: string;
    age: string;
    sex: number;
}
type Coo = {
    age: number;
    sex: string;
    name: number;
}

type Merge<T extends Object, E extends Object> = {
    [k in keyof T | keyof E]: k extends keyof E ? E[k] : k extends keyof T ? T[k]: never;
}

type merRes = Merge<Foo, Coo>;
const merres: merRes = {
    name: 2,
    age: 1,
    sex: 's'
}

Solution by sundial-dreams #29455

type Merge<F, S> = {
  [K in (keyof F | keyof S)]: K extends keyof S ? S[K] : K extends keyof F ? F[K] : never
}

Solution by MohammadArasteh #29420