Typescript Objects, Arrays, Tuples & Enums | Basics Tutorial

TypeScript Arrays and Union Types
📌 TypeScript infers array types: `string array` is inferred as an array of strings.
📌 The `guitars` array, containing strings and a number (e.g., "strat", 5150), is inferred as a union type: `(string | number)[]`.
📌 Attempting to add a disallowed type (e.g., pushing a `number` to a string array) results in a TypeScript error: "type number is not assignable to type string".
📌 When reassigning arrays, the structure must match: `guitars` (string | number)[] can be assigned to `string array` (string)[] only if the source structure is compatible (which it is not, based on the example where string array assignment failed for guitars). *Correction based on demonstration: `guitars` array could be assigned to `string array` because it contained strings, but `string array` could not be assigned to `guitars` if it tried to add an incompatible type later.* (Re-check: `guitars` could be set equal to `string array` because it accepts strings/numbers, but `string array` could not be set to `guitars` if `guitars` was narrower).

Empty Arrays and Type Declaration
📌 An empty array initialized with `let test = []` is inferred by TypeScript as type `any[]` (any type of data allowed).
📌 To enforce type safety for an empty array, explicitly annotate the type, e.g., `let bands: string[] = []`, which restricts future pushes to only strings.

Tuples vs. Arrays
📌 A tuple is a stricter array type that enforces a specific length and specific types at specific element positions (e.g., `[string, number, boolean]`).
📌 Assigning an array to a tuple fails if the array might have fewer elements than required by the tuple definition (e.g., `myTuple` requires 3 elements, but `mixed` array might have fewer).
📌 Attempting to add an element outside the defined tuple length results in an error, as the extra position is implicitly `undefined`.

Objects and Type Annotation
📌 TypeScript infers object types based on initial property assignments (e.g., `{ prop1: string, prop2: boolean }`).
📌 Types can be defined using the `type` keyword (e.g., `type Guitarist = { ... }`) to structure objects explicitly before instantiation.
📌 When defining a type, all listed properties are required by default; use a question mark (`?`) to make a property optional (e.g., `active?: boolean`).
📌 Assigning an object to a variable typed as a specific `type` prevents adding new, undeclared properties.

Interface vs. Type
📌 An `interface` can be used instead of a `type` to define object shapes and works identically for basic object definition and optional properties.
📌 Interfaces are often associated with defining structures similar to classes, while types can define unions, primitives, and other complex structures.

Function Parameter Typing and Narrowing
📌 Functions can accept parameters typed as custom types (e.g., `(guitarist: Guitarist)`).
📌 If an optional property is used within a function (like `.toUpperCase()` on an optional `name`), TypeScript requires narrowing (checking if the property exists, e.g., `if (guitarist.name)`) to avoid errors where the value might be `undefined`.

Enums
📌 Enums are features TypeScript adds to JavaScript at runtime, unlike most features which are purely type-level additions.
📌 By default, enum members are assigned numerical values starting from 0 (e.g., `Grade.U = 0`).
📌 Setting the first enum member to a specific number (e.g., `U = 1`) causes subsequent members to be sequentially numbered from that starting point.

Key Points & Insights
➡️ Always use explicit type annotations for empty arrays (`let data: string[] = []`) to avoid the default `any[]` inference.
➡️ Tuples enforce strict positional typing and length, making them useful for fixed data structures (like coordinates or records).
➡️ Use `type` aliases or `interface` definitions to pre-define object structures, ensuring required properties and correct data types are used consistently.
➡️ When dealing with optional properties in functions, use type narrowing (like `if (property)`) to satisfy TypeScript's requirement that methods are not called on possibly `undefined` values.

📸 Video summarized with SummaryTube.com on Dec 07, 2025, 15:40 UTC