TypeScript: TypeScript Arrays and Tuples

// Method 1：Type + square brackets（Recommendations，More intuitive）
let numbers: number[] = [1, 2, 3, 4, 5];
let names: string[] = ["Charlie", "Diana", "Eric"];

// Method 2：Generic Arrays（Commonly used in generic scenarios）
let scores: Array<number> = [90, 85, 95];
let items: Array<string> = ["a", "b", "c"];

let arr1 = [1, 2, 3];           // Inferred as number[]
let arr2 = ["a", "b", "c"];     // Inferred as string[]
let arr3 = [1, "hello", true];  // Inferred as (number | string | boolean)[]
let arr4 = [];                  // Inferred as any[]（Danger！）

let matrix: number[][] = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
];

// Accessing Elements
console.log(matrix[0][1]);  // 2

// Three-dimensional array
let cube: number[][][] = [[[1]]];

Average Score: 87.6
Subject with the Highest Score: English (95pts)

let fruits: string[] = ["Apple", "Banana", "Orange"];

// Add an element
fruits.push("Grapes");          // Add at the end
fruits.unshift("Strawberries");       // Add at the beginning

// Delete Element
let last = fruits.pop();      // Delete the end，Back "Grapes"
let first = fruits.shift();   // Delete the beginning，Back "Strawberries"

// Search
let index = fruits.indexOf("Banana");  // 0（The strawberries and grapes were removed.，The banana came in first）

// Iterate
fruits.forEach((fruit, i) => {
  console.log(`${i}: ${fruit}`);
});

0: Banana
1: Orange

let readonlyArr: readonly number[] = [1, 2, 3];

// readonlyArr[0] = 10;     // ❌ Read-only，Cannot be modified
// readonlyArr.push(4);     // ❌ Read-only，Cannot be added
// readonlyArr.length = 0;  // ❌ Read-only，The length cannot be changed

let normalArr: number[] = [1, 2, 3];
readonlyArr = normalArr;    // ✅ A regular array can be assigned to a read-only array
// normalArr = readonlyArr; // ❌ A read-only array cannot be assigned to a regular array.

let readonlyArr2: ReadonlyArray<string> = ["a", "b", "c"];
// and readonly string[] Equivalent

function printItems(items: readonly string[]) {
  items.forEach(item => console.log(item));
  // items.push("new");  // ❌ Compilation Error——The function is guaranteed not to be modified
}

let myItems = ["a", "b"];
printItems(myItems);  // Safety——myItems Will not be modified

// Defining Tuples：[Type1, Type2, ...]
let user: [string, number] = ["Charlie", 20];

// Access by Index
console.log(user[0]);  // "Charlie"（string Type）
console.log(user[1]);  // 20（number Type）

// Assignments must match in type and length
// user = [20, "Charlie"];  // ❌ Type order does not match
// user = ["Charlie"];      // ❌ Not long enough
// user = ["Charlie", 20, true];  // ❌ Exceeds the length limit

let pair: [string, number] = ["Apple", 5];

let [fruit, count] = pair;
console.log(fruit);   // "Apple"
console.log(count);   // 5

// Including remaining elements
let record: [string, number, ...boolean[]] = ["Test", 100, true, false, true];
let [name, score, ...flags] = record;
console.log(name);    // "Test"
console.log(score);   // 100
console.log(flags);   // [true, false, true]

let result: [string, number?] = ["Success"];

console.log(result[0]);  // "Success"
console.log(result[1]);  // undefined（Optional elements may be omitted.）

let user: [name: string, age: number] = ["Charlie", 20];
let point: [x: number, y: number, z?: number] = [1.0, 2.5];

// Tags are only for document purposes，Does not affect the type——But the code's readability has improved significantly
function getRange(): [min: number, max: number] {
  return [0, 100];
}

let [min, max] = getRange();
console.log(`Scope：${min} - ${max}`);  // Scope：0 - 100

// Tuples are ideal for representing the return values of functions."Multiple values"
function divide(a: number, b: number): [quotient: number, remainder: number] {
  return [Math.floor(a / b), a % b];
}

let [quotient, remainder] = divide(17, 5);
console.log(`Quotient：${quotient}，Remainder：${remainder}`);  // Quotient：3，Remainder：2

// A tuple represents a key-value pair
function entries(obj: Record<string, number>): [string, number][] {
  return Object.entries(obj) as [string, number][];
}

let scores = { Chinese Language: 90, Mathematics: 95, English: 88 };
for (let [subject, score] of entries(scores)) {
  console.log(`${subject}：${score}pts`);
}

Quotient：3，Remainder：2
Chinese Language：90pts
Mathematics：95pts
English：88pts

// Union Type Arrays：Each element in the array can be number or string
let mixed: (number | string)[] = [1, "two", 3, "four"];

// Union Types for Arrays：Either... or number[]，Either... or string[]
let uniform: number[] | string[] = [1, 2, 3];   // ✅
uniform = ["a", "b", "c"];                        // ✅
// uniform = [1, "two"];                          // ❌ Do not mix

let nums: number[] = [3, 1, 4, 1, 5];

// sort An explicit comparison function is required，Otherwise, sort by string
nums.sort((a, b) => a - b);     // ✅ Number Sorting：[1, 1, 3, 4, 5]

// map Automatic Inference of Return Types
let doubled = nums.map(n => n * 2);   // Inferred as number[]
let asStrings = nums.map(String);      // Inferred as string[]

// filter Automatically Infer Element Types
let big = nums.filter(n => n > 2);    // Inferred as number[]

let a: number[] = [1, 2];
let b: number[] = [3, 4];
let merged: number[] = [...a, ...b];  // [1, 2, 3, 4]

// Tuple Unpacking
let prefix: [string, number] = ["No.", 0];
let full: [string, number, ...number[]] = [...prefix, 1, 2, 3];
// full = ["No.", 0, 1, 2, 3]

// Represented as a tuple [Subject, Fractions]
type Score = [subject: string, score: number];

// Storing Multiple Grades in an Array
let scores: Score[] = [
  ["Chinese Language", 92],
  ["Mathematics", 88],
  ["English", 95],
  ["Physics", 78],
  ["Chemistry", 85]
];

// Calculate the average score
function average(scores: readonly Score[]): number {
  let total = scores.reduce((sum, [, score]) => sum + score, 0);
  return total / scores.length;
}

// Find the subject with the highest score
function topSubject(scores: readonly Score[]): Score {
  return scores.reduce((best, current) =>
    current[1] > best[1] ? current : best
  );
}

console.log("Average Score：" + average(scores).toFixed(1));
let [subject, score] = topSubject(scores);
console.log(`Subject with the Highest Score：${subject}（${score}pts）`);

Average Score：87.6
Subject with the Highest Score：English（95pts）