Readonly-масиви та Spread/Rest

function printScores(scores: readonly number[]): void {
  for (const score of scores) {
    console.log(score);
  }
}

const scores = [10, 20, 30];

printScores(scores);
printScores([5, 15, 25]);

function printScores(scores: ReadonlyArray<number>): void {
  console.log(scores.join(", "));
}

function addScore(scores: readonly number[]): void {
  // scores.push(100); // Помилка компіляції
  // scores[0] = 100;  // Помилка компіляції

  console.log(scores.length);
  console.log(scores[0]);

  const doubled = scores.map((score) => score * 2);
  const filtered = scores.filter((score) => score >= 50);

  console.log(doubled);
  console.log(filtered);
}

const readonlyScores: readonly number[] = [20, 50, 80];

const copiedScores = readonlyScores.slice();
const increasedScores = readonlyScores.map((score) => score + 10);

console.log(copiedScores);
console.log(increasedScores);

const readonlyScores: readonly number[] = [20, 50, 80];

const increasedScores = readonlyScores.map((score) => score + 10);

increasedScores.push(100);

function getMaximum(values: readonly number[]): number {
  if (values.length === 0) {
    throw new Error("Колекція не може бути порожньою");
  }

  return Math.max(...values);
}

const mutableValues = [4, 9, 2];
const readonlyValues: readonly number[] = [7, 3, 8];

console.log(getMaximum(mutableValues));
console.log(getMaximum(readonlyValues));

function appendValue(values: number[], value: number): void {
  values.push(value);
}

const values: readonly number[] = [1, 2, 3];

// appendValue(values, 4); // Помилка: readonly-масив не можна передати як number[]

const values: readonly number[] = [1, 2, 3];
const mutableCopy = [...values];

appendValue(mutableCopy, 4);

console.log(mutableCopy);

type User = {
  name: string;
};

const users: readonly User[] = [
  { name: "Олена" },
];

users[0].name = "Ірина";

type User = {
  readonly name: string;
};

const users: readonly User[] = [
  { name: "Олена" },
];

// users[0].name = "Ірина"; // Помилка компіляції

const first = [1, 2, 3];
const second = [4, 5];

const combined = [...first, ...second];

console.log(combined);

const original = [1, 2, 3];
const copy = [...original];

copy.push(4);

console.log(original); // [1, 2, 3]
console.log(copy);     // [1, 2, 3, 4]

const readonlyValues: readonly number[] = [10, 20, 30];

const mutableValues = [...readonlyValues];

mutableValues.push(40);

console.log(mutableValues);

const readonlyValues: readonly number[] = [10, 20, 30];

const anotherReadonlyValues: readonly number[] = [
  ...readonlyValues,
  40,
];

// anotherReadonlyValues.push(50); // Помилка компіляції

function sum(first: number, second: number, third: number): number {
  return first + second + third;
}

const values: readonly [number, number, number] = [10, 20, 30];

console.log(sum(...values));

const userRecord: [number, string] = [101, "Олена"];

userRecord[0] = 102;

const userRecord: readonly [number, string] = [101, "Олена"];

// userRecord[0] = 102; // Помилка компіляції

const point = [10, 20] as const;

// Тип: readonly [10, 20]

function move(x: number, y: number): string {
  return `Точка: ${x}, ${y}`;
}

const point = [10, 20] as const;

console.log(move(...point));

function sumAll(...values: number[]): number {
  return values.reduce((total, value) => total + value, 0);
}

console.log(sumAll(1, 2, 3));
console.log(sumAll(10, 20, 30, 40));

function sortValues(...values: number[]): number[] {
  return values.sort((a, b) => a - b);
}

const original: readonly number[] = [30, 10, 20];
const sorted = sortValues(...original);

console.log(original);
console.log(sorted);

const values: readonly number[] = [2, 4, 6];

console.log(sumAll(...values));

function formatUser(...user: [number, string]): string {
  const [id, name] = user;
  return `${id}: ${name}`;
}

console.log(formatUser(101, "Олена"));

function addPrefix<T extends readonly unknown[]>(
  prefix: string,
  ...values: T
): [string, ...T] {
  return [prefix, ...values];
}

const coordinates = [10, 20] as const;
const result = addPrefix("point", ...coordinates);

console.log(result);

// Тип result: [string, 10, 20]

function average(values: readonly number[]): number {
  if (values.length === 0) {
    throw new Error("Неможливо обчислити середнє для порожньої колекції");
  }

  const total = values.reduce((sum, value) => sum + value, 0);
  return total / values.length;
}

function addScores(
  first: readonly number[],
  ...additional: number[]
): number[] {
  return [...first, ...additional];
}

const initialScores = [80, 90, 75] as const;
const allScores = addScores(initialScores, 88, 95);

console.log(allScores);
console.log(average(allScores));

function clear(values: readonly string[]): void {
  // values.length = 0; // Помилка компіляції
  // values.pop();      // Помилка компіляції
}

function clear(values: readonly string[]): string[] {
  const copy = [...values];
  copy.length = 0;
  return copy;
}

const values = [1, 2, 3];

values.push(4); // Дозволено

// values = [5, 6, 7]; // Помилка: переприсвоєння const

const values: readonly number[] = [1, 2, 3];

// values.push(4); // Помилка

type Product = {
  name: string;
};

const products: readonly Product[] = [
  { name: "Книга" },
];

// products.push({ name: "Ручка" }); // Помилка
products[0].name = "Зошит"; // Дозволено

const source: readonly number[] = [1, 2, 3];
const copy = [...source];

copy.push(4); // Дозволено, copy має тип number[]

const readonlyCopy: readonly number[] = [...source];

// readonlyCopy.push(4); // Помилка

function multiplyAll(...values: number[]): number {
  return values.reduce((result, value) => result * value, 1);
}

const values = [2, 3, 4];

console.log(multiplyAll(...values));