keyof та Generics для доступу до властивостей

const validKey: UserKey = "name";

// Помилка: властивості "email" немає в типі User
// const invalidKey: UserKey = "email";

function getProperty(object: object, key: string) {
  return object[key];
}

function getProperty<T, K extends keyof T>(object: T, key: K): T[K] {
  return object[key];
}

type User = {
  id: number;
  name: string;
  isActive: boolean;
};

function getProperty<T, K extends keyof T>(object: T, key: K): T[K] {
  return object[key];
}

const user: User = {
  id: 42,
  name: "Олена",
  isActive: true,
};

const id = getProperty(user, "id");
const name = getProperty(user, "name");
const isActive = getProperty(user, "isActive");

console.log(id); // 42
console.log(name); // Олена
console.log(isActive); // true

// TypeScript визначає типи:
// id: number
// name: string
// isActive: boolean

// Помилка: "email" не є ключем типу User
// const email = getProperty(user, "email");

type Product = {
  title: string;
  price: number;
  inStock: boolean;
};

type ProductTitle = Product["title"];
// string

type ProductPrice = Product["price"];
// number

type ProductField = Product[keyof Product];
// string | number | boolean

function getProductTitle(product: Product): Product["title"] {
  return product.title;
}

function setProperty<T, K extends keyof T>(
  object: T,
  key: K,
  value: T[K],
): void {
  object[key] = value;
}

type Settings = {
  theme: "light" | "dark";
  fontSize: number;
  notificationsEnabled: boolean;
};

const settings: Settings = {
  theme: "light",
  fontSize: 16,
  notificationsEnabled: true,
};

setProperty(settings, "theme", "dark");
setProperty(settings, "fontSize", 18);
setProperty(settings, "notificationsEnabled", false);

console.log(settings);

// Помилка: значення має бути одним із "light" | "dark"
// setProperty(settings, "theme", "blue");

// Помилка: для fontSize очікується number
// setProperty(settings, "fontSize", "large");

// Помилка: такого ключа немає в Settings
// setProperty(settings, "language", "uk");

const product = {
  name: "Ноутбук",
  price: 35000,
};

function getValue<T, K extends keyof T>(object: T, key: K): T[K] {
  return object[key];
}

const productName = getValue(product, "name");
// string

const productPrice = getValue(product, "price");
// number

T = {
  name: string;
  price: number;
}

K = "name" | "price"

type Article = {
  title: string;
  views: number;
};

const article: Article = {
  title: "TypeScript Generics",
  views: 1200,
};

const key: keyof Article = "title";

const value = getProperty(article, key);

console.log(value);

string | number

const titleKey = "title" as const;

const title = getProperty(article, titleKey);
// string

const statuses = {
  draft: "Чернетка",
  published: "Опубліковано",
  archived: "Архів",
};

type StatusKey = keyof typeof statuses;
// "draft" | "published" | "archived"

function getStatusLabel(key: StatusKey): string {
  return statuses[key];
}

console.log(getStatusLabel("draft"));
console.log(getStatusLabel("published"));

// Помилка: такого ключа немає в об'єкті
// getStatusLabel("deleted");

function pick<T, K extends keyof T>(object: T, keys: K[]): Pick<T, K> {
  const result = {} as Pick<T, K>;

  for (const key of keys) {
    result[key] = object[key];
  }

  return result;
}

const user = {
  id: 7,
  name: "Андрій",
  isAdmin: false,
};

const publicData = pick(user, ["id", "name"]);

console.log(publicData);
// { id: 7, name: "Андрій" }

// Помилка: "password" не є ключем типу об'єкта
// const data = pick(user, ["id", "password"]);

function unsafeGet<T>(object: T, key: string) {
  // Такий підхід не гарантує, що key є ключем T
  return (object as Record<string, unknown>)[key];
}

function safeGet<T, K extends keyof T>(object: T, key: K): T[K] {
  return object[key];
}

function notSpecific<T, K extends keyof any>(object: T, key: K) {
  // Зв'язок між K та ключами T відсутній
  return object[key];
}

function specific<T, K extends keyof T>(object: T, key: K): T[K] {
  return object[key];
}

const key: string = "name";

// Помилка: тип string не гарантовано є ключем Article
// getProperty(article, key);

const key: keyof Article = "name";

const result = getProperty(article, key);

function badSet<T, K extends keyof T, V>(
  object: T,
  key: K,
  value: V,
): void {
  // V не пов'язаний із типом властивості T[K]
}

function goodSet<T, K extends keyof T>(
  object: T,
  key: K,
  value: T[K],
): void {
  object[key] = value;
}