User-defined Type Guards

value is SomeType

function isSomeType(value: unknown): value is SomeType {
  // перевірки
}

interface User {
  id: number;
  name: string;
  email: string;
}

function isUser(value: unknown): value is User {
  if (typeof value !== "object" || value === null) {
    return false;
  }

  const user = value as Record<string, unknown>;

  return (
    typeof user.id === "number" &&
    typeof user.name === "string" &&
    typeof user.email === "string"
  );
}

function printUser(value: unknown): void {
  if (isUser(value)) {
    console.log(`${value.name} <${value.email}>`);
  } else {
    console.log("Значення не є коректним користувачем");
  }
}

interface Address {
  city: string;
  country: string;
}

interface User {
  id: number;
  name: string;
  address: Address;
}

function isAddress(value: unknown): value is Address {
  if (typeof value !== "object" || value === null) {
    return false;
  }

  const address = value as Record<string, unknown>;

  return (
    typeof address.city === "string" &&
    typeof address.country === "string"
  );
}

function isUser(value: unknown): value is User {
  if (typeof value !== "object" || value === null) {
    return false;
  }

  const user = value as Record<string, unknown>;

  return (
    typeof user.id === "number" &&
    typeof user.name === "string" &&
    isAddress(user.address)
  );
}

function isArrayOf<T>(
  value: unknown,
  itemGuard: (item: unknown) => item is T
): value is T[] {
  return Array.isArray(value) && value.every(itemGuard);
}

interface User {
  id: number;
  name: string;
}

function isUser(value: unknown): value is User {
  if (typeof value !== "object" || value === null) {
    return false;
  }

  const user = value as Record<string, unknown>;

  return (
    typeof user.id === "number" &&
    typeof user.name === "string"
  );
}

function isArrayOf<T>(
  value: unknown,
  itemGuard: (item: unknown) => item is T
): value is T[] {
  return Array.isArray(value) && value.every(itemGuard);
}

function printUserNames(value: unknown): void {
  if (!isArrayOf(value, isUser)) {
    console.log("Очікувався масив користувачів");
    return;
  }

  for (const user of value) {
    console.log(user.name);
  }
}

interface Address {
  city: string;
  country: string;
}

interface User {
  id: number;
  name: string;
  address: Address;
}

function isAddress(value: unknown): value is Address {
  if (typeof value !== "object" || value === null) {
    return false;
  }

  const address = value as Record<string, unknown>;

  return (
    typeof address.city === "string" &&
    typeof address.country === "string"
  );
}

function isUser(value: unknown): value is User {
  if (typeof value !== "object" || value === null) {
    return false;
  }

  const user = value as Record<string, unknown>;

  return (
    typeof user.id === "number" &&
    typeof user.name === "string" &&
    isAddress(user.address)
  );
}

function isArrayOf<T>(
  value: unknown,
  itemGuard: (item: unknown) => item is T
): value is T[] {
  return Array.isArray(value) && value.every(itemGuard);
}

const data: unknown = [
  {
    id: 1,
    name: "Олена",
    address: {
      city: "Львів",
      country: "Україна",
    },
  },
  {
    id: 2,
    name: "Андрій",
    address: {
      city: "Київ",
      country: "Україна",
    },
  },
];

if (isArrayOf(data, isUser)) {
  for (const user of data) {
    console.log(`${user.name}: ${user.address.city}`);
  }
} else {
  console.log("Дані мають неправильну структуру");
}

interface SuccessResponse {
  status: "success";
  data: string[];
}

interface ErrorResponse {
  status: "error";
  message: string;
}

type ApiResponse = SuccessResponse | ErrorResponse;

function isSuccessResponse(
  value: unknown
): value is SuccessResponse {
  if (typeof value !== "object" || value === null) {
    return false;
  }

  const response = value as Record<string, unknown>;

  return (
    response.status === "success" &&
    Array.isArray(response.data) &&
    response.data.every((item) => typeof item === "string")
  );
}

function handleResponse(value: unknown): void {
  if (isSuccessResponse(value)) {
    for (const item of value.data) {
      console.log(item);
    }
  } else {
    console.log("Помилка або некоректна відповідь");
  }
}

type Guard<T> = (value: unknown) => value is T;

function filterValid<T>(
  values: unknown[],
  guard: Guard<T>
): T[] {
  return values.filter(guard);
}

const values: unknown[] = [
  "TypeScript",
  42,
  "JavaScript",
  null,
];

const strings = filterValid(values, (value): value is string => {
  return typeof value === "string";
});

console.log(strings);
// ["TypeScript", "JavaScript"]

function isString(value: unknown): boolean {
  return typeof value === "string";
}

function printValue(value: unknown): void {
  if (isString(value)) {
    // value усе ще має тип unknown
    // console.log(value.toUpperCase());
  }
}

function isString(value: unknown): value is string {
  return typeof value === "string";
}

function printValue(value: unknown): void {
  if (isString(value)) {
    console.log(value.toUpperCase());
  }
}

function isNumber(value: unknown): value is number {
  return true;
}

const value: unknown = "text";

if (isNumber(value)) {
  // TypeScript вважає value числом,
  // хоча під час виконання це рядок
  console.log(value.toFixed(2));
}

function isObject(value: unknown): value is object {
  return typeof value === "object";
}

typeof value === "object" && value !== null

function hasName(value: unknown): boolean {
  return (
    typeof value === "object" &&
    value !== null &&
    "name" in value
  );
}

function isNamedObject(
  value: unknown
): value is { name: string } {
  if (typeof value !== "object" || value === null) {
    return false;
  }

  const object = value as Record<string, unknown>;

  return typeof object.name === "string";
}

interface Product {
  id: number;
  title: string;
  price: number;
}

// Недостатня перевірка для повного типу Product
function isProduct(value: unknown): value is Product {
  return typeof value === "object" && value !== null;
}