LearningTS Chapter 15 - YDP-SPLOUNGE-CLUB/typescript-study GitHub Wiki

// example
type NewType = {
  [K in OriginalType]: NewProperty;
}

type Animals = "alligator" | "baboon" | "cat";

type AnimalCounts = {
  [K in Animals]: number;
};

interface AnimalVariants {
  aliigator: boolean;
  baboon: number;
  cat: string;
}

type AnimalCounts = {
  [K in keyof AnimalVariants]: number;
}

interface BirdVariants {
  dove: string;
  eagle: boolean;
}

type NullableBirdVarinats = {
  [K in keyof BirdVariants]: BirdVariants[K] | null;
}

interface Researcher {
  researchMethod(): void;
  researchProperty: () => string;
}

type JustProperties<T> = {
  [K in typeof T]: T[K]
};

type ResearcherProperties = JustProperties<Researcher>;

// 다음과 같다.
// {
//   researchMethod: () => void;
//   researchProperty: () => string;
// }

interface Enviromentalist{
  area: string;
  name: string;
}

type ReadOnlyEnviromentalist = {
  readonly [K in keyof Enviromentalist]: Enviromentalist[K];
};

// 다음과 같음
// {
//   readonly area: string;
//   readonly name: string;
// }

type OptionalReadOnlyEnviromentalist = {
  [K in keyof ReadOnlyEnviromentalist]?: Enviromentalist[K];
};

interface Conservationist {
  name: string;
  catchphrase?: string;
  readonly born: number;
  readonly died?: number;
}

type WrtableConservationist = {
  -readonly [K in keyof Conservationist]: Conservationist[K];
};

// 다음과 같음.
// {
//   name: string;
//   catchprase?: string;
//   born: number;
//   died?: number;
// }

type RequireWritableConservationist = {
  [K in keyof WrtableConservationist]-?: WrtableConservationist[K];
};

type MakeReadonly<T> = {
  readonly [K in keyof T]: T[K];
}

interface Species {
  genus: string;
  name: string;
}

type ReadonlySpecies = MakeReadonly<Species>;

interface GenusData {
  family: string;
  name: string;
}

type MakeOptinal<T> = {
  [K in keyof T]?: T[K];
}

function createGenusData(overrides?: MakeOptinal<GenusData>): GenusData {
  return {
    family: 'unknown',
    name: 'unknown',
    ...overrides,
  }
}

LeftType extends RightType ? IfTrue : IfFalse;

type CheckStringAginstNumber = string extends number ? true : false;

type CheckAgaubstNumber<T> = T extends number ? true : false;

// 타입 : false
type CheckString = CheckAgaubstNumber<'parakeet'>;

// 타입 : true
type CheckString = CheckAgaubstNumber<1111>;

// 타입 : true
type CheckString = CheckAgaubstNumber<number>;

interface QuertOptions {
  thorwIfNotFound: boolean;
}

type QueryResult<Options extends QuertOptions> = 
  Options["thorwIfNotFound"] extends true ? string : string | undefined;

declare function retrieve<Options extends QuertOptions>(
  key: string,
  options?: Options,
): Promise<QueryResult<Options>>;

// 반환 타입 string | undefined;
await retrieve("Mary");

// string | undefined;
await retrieve("Jane", { thorwIfNotFound: Math.random() > 0.5 });

// string
await retrieve("Dian", { thorwIfNotFound: true });

type ArrayifUnlessString<T> = T extends string ? T: T[];

// string | number[]
type HalfArrayified = ArrayifUnlessString<string | number>;

type ArrayItems<T> = 
  T extends (infer item)[]
    ? item
    : T;

// string
type StringItem = ArrayItems<string>;

// string
type StringArrayItem = ArrayItems<string[]>;

// string[]
type String2DItem = ArrayItems<string[][]>;

// infer 와 같은 위치에 있는 string 타입을 R 변수에 선언한다.
type ArrType<T> = T extends (infer R)[] ? R : unknown;

type arr = ArrType<string[]>;	// string 타입이다.
type arr2 = ArrType<string>;	// unknown 타입이다.

type MakeAllMembersfunctions<T> = {
  [K in keyof T]: T[K] extends (...args: any[]) => any
      ? T[K]
      : () => T[K]
};

type MemberFunctions = MakeAllMembersfunctions<{
  alreadyFunction: () => string,
  notYetFunction: number;
}>

//
// {
//   alreadyfunction: () => string;
//   notYetFUnction: () => number;
// }

type Greeting = `Hello${string}`;

let matches: Greeting = "Hello, world!"; // OK

let outOfOrder: Greeting = "World! Hello"; // Error

type Brightness = "dark" | "light";
type Color = "blue" | "red";

type BrightnessAndColor = `${Brightness}-${Color}`;

let colorOk: BrightnessAndColor = "dark-blue";

type FormalGreeting = Capitalize<"hello,">; // Hello,

const config = {
  location: 'unknown',
  name: "annoymous",
  year: 0,
}

type LayValues = {
  [K in keyof typeof config as `${K}Lazy`]: () => Promise<typeof config[K]>;
};

async function withLazyValues(configGetter: LayValues) {
  await configGetter.locationLazy; // string
  
  await configGetter.missingLazy; // Error Propery missingLazy does not exist
}

type TurnIntoGettersDirect<T> = {
  [K in keyof T as `get${K}`]: () => T[K]
  // Error
}

const someSymbol = Symbol("");

interface HasStringAndSymbol {
  Stringkey: string;
  [someSymbol]: number;
}

type TurnIntoGetters<T> = {
  [K in keyof T as `get${string & K}`]: () => T[K]
};

type GettersJustString = TurnIntoGetters<HasStringAndSymbol>;

// 다음과 같음.
// {
//   getStringkey: () => string;
// }