Типізація Callback-функцій

(parameter1: Type1, parameter2: Type2) => ReturnType

type Formatter = (value: string) => string;

type Formatter = (value: string) => string;

const uppercase: Formatter = (value) => {
  return value.toUpperCase();
};

console.log(uppercase("typescript")); // TYPESCRIPT

function transform(
  value: string,
  callback: (value: string) => string
): string {
  return callback(value);
}

const result = transform("hello", (text) => text.toUpperCase());

console.log(result); // HELLO

type StringTransformer = (value: string) => string;

function transform(
  value: string,
  callback: StringTransformer
): string {
  return callback(value);
}

type ItemProcessor = (
  item: string,
  index: number
) => string;

function processItems(
  items: string[],
  processor: ItemProcessor
): string[] {
  return items.map(processor);
}

const result = processItems(
  ["apple", "banana", "orange"],
  (item, index) => `${index + 1}. ${item}`
);

console.log(result);
// ["1. apple", "2. banana", "3. orange"]

type Logger = (message: string) => void;

function runTask(task: Logger): void {
  task("Завдання виконано");
}

runTask((message) => {
  console.log(message);
});

type Action = () => void;

const action: Action = () => {
  return console.log("Дія виконана");
};

type Predicate<T> = (value: T) => boolean;

function findFirst<T>(
  items: T[],
  predicate: Predicate<T>
): T | undefined {
  for (const item of items) {
    if (predicate(item)) {
      return item;
    }
  }

  return undefined;
}

const firstLongWord = findFirst(
  ["cat", "elephant", "dog"],
  (word) => word.length > 3
);

console.log(firstLongWord); // elephant

const numbers = [10, 20, 30];

const result = numbers.map((number, index) => {
  return `${index}: ${number}`;
});

const result = numbers.map(
  (number: number, index: number): string => {
    return `${index}: ${number}`;
  }
);

const format = (value) => value.toUpperCase();
// Помилка за noImplicitAny: параметр value має неявний тип any

const format = (value: string): string => {
  return value.toUpperCase();
};

type Formatter = (value: string) => string;

const format: Formatter = (value) => {
  return value.toUpperCase();
};

function apply<T, R>(
  value: T,
  callback: (value: T) => R
): R {
  return callback(value);
}

const length = apply("TypeScript", (text) => text.length);
const isPositive = apply(10, (number) => number > 0);

console.log(length); // 10
console.log(isPositive); // true

function apply<T, R>(
  value: T,
  callback: (value: T) => R
): R {
  return callback(value);
}

// Помилка: callback очікує number, але apply отримує string
// const result = apply("hello", (value: number) => value * 2);

type AsyncHandler<T> = (value: T) => Promise<void>;

async function processValues<T>(
  values: T[],
  handler: AsyncHandler<T>
): Promise<void> {
  for (const value of values) {
    await handler(value);
  }
}

async function main(): Promise<void> {
  await processValues([1, 2, 3], async (value) => {
    console.log(`Оброблено: ${value}`);
  });
}

main();

type AsyncTransformer<T, R> = (value: T) => Promise<R>;

async function transformAsync<T, R>(
  value: T,
  callback: AsyncTransformer<T, R>
): Promise<R> {
  return callback(value);
}

async function main(): Promise<void> {
  const result = await transformAsync("hello", async (text) => {
    return text.toUpperCase();
  });

  console.log(result); // HELLO
}

main();

(value: string) => Promise<string>

type Formatter = (
  value: string,
  prefix?: string
) => string;

const format: Formatter = (value, prefix = "") => {
  return `${prefix}${value}`;
};

console.log(format("TypeScript")); // TypeScript
console.log(format("TypeScript", "Мова: ")); // Мова: TypeScript

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

type UserFilter = (user: User) => boolean;
type UserMapper<TResult> = (user: User) => TResult;

function selectUsers(
  users: User[],
  filter: UserFilter
): User[] {
  return users.filter(filter);
}

function mapUsers<TResult>(
  users: User[],
  mapper: UserMapper<TResult>
): TResult[] {
  return users.map(mapper);
}

const users: User[] = [
  { id: 1, name: "Олена", active: true },
  { id: 2, name: "Андрій", active: false },
  { id: 3, name: "Марія", active: true },
];

const activeUsers = selectUsers(
  users,
  (user) => user.active
);

const userNames = mapUsers(
  activeUsers,
  (user) => user.name
);

console.log(activeUsers);
// [
//   { id: 1, name: "Олена", active: true },
//   { id: 3, name: "Марія", active: true }
// ]

console.log(userNames);
// ["Олена", "Марія"]

// Помилка: властивості email немає в типі User
// const emails = mapUsers(users, (user) => user.email);

function execute(callback: string): void {
  // ...
}

function execute(callback: () => string): void {
  const result = callback();
  console.log(result);
}

function run(callback: (value: any) => any): any {
  return callback("value");
}

function run<T, R>(
  value: T,
  callback: (value: T) => R
): R {
  return callback(value);
}

type Handler = (value: string) => void;

// async-функція фактично повертає Promise<void>

type AsyncHandler = (value: string) => Promise<void>;

function calculate(
  value: number,
  callback: (value: number) => number
): number {
  return callback(value) * 2;
}

const result = calculate(5, (value) => value + 1);

console.log(result); // 12

const values = [1, 2, 3];

const doubled = values.map((value) => value * 2);

const double = (value: number): number => value * 2;

const doubled = values.map(double);