Pascal.CodeCompared.To/TypeScript

TypeScript (like JavaScript) runs a top-level script with no boilerplate. Pascal requires a program Name; header and an explicit begin...end. block with a trailing period. TypeScript uses console.log for standard output; Pascal uses the built-in writeln procedure. Single-quoted strings are standard Pascal; TypeScript uses double or single quotes interchangeably.

Pascal offers three comment syntaxes. The brace style ({ }) is the most traditional; (* *) predates it; // is a Free Pascal extension from C. TypeScript uses the same // and /* */ as JavaScript. TypeScript also supports JSDoc comments (/** */) for IDE tooling and type inference from JavaScript.

Pascal compiles to a native binary — no runtime required on the target machine. TypeScript compiles to JavaScript, which then runs on Node.js or in a browser. The tsx tool (used by this site's test runner) runs TypeScript directly without a separate compile step, similar to how Free Pascal's fpc compiles and outputs a binary in one step.

Pascal requires all variables to be declared in a var block before any code runs, with explicit types. TypeScript allows inline declarations anywhere using let (mutable) or const (immutable). Pascal uses := for assignment and = for comparison; TypeScript uses = for assignment and === for strict equality. Pascal's Boolean literals are True/False (capitalised); TypeScript uses lowercase true/false.

TypeScript infers the type from the initialiser when you use const or let without an explicit annotation. The type is still fixed at compile time — TypeScript is statically typed, not dynamically typed. Pascal has no type inference; every variable requires an explicit type annotation in the var block. Prefer const over let in TypeScript when the value will not be reassigned.

Pascal groups constants in a const block before the main body; they are untyped and the compiler infers their type from the value. TypeScript's const keyword declares an immutable binding — the compiler infers a narrow literal type (100 rather than number). Both are truly immutable: any reassignment is a compile-time error.

Pascal provides fixed-width integer types (ShortInt, Integer, Int64, Cardinal). TypeScript has a single number type (IEEE 754 double-precision float), which can represent integers exactly only up to 2⁵³−1. For integers larger than that, TypeScript offers BigInt (suffixed with n). There is no overflow checking in either language's default integer arithmetic.

Pascal booleans are True/False (printed as TRUE/FALSE) and use English words for operators: and, or, not, xor. TypeScript uses lowercase true/false and C-style operators: &&, ||, !. TypeScript's && and || short-circuit; Pascal's and/or do not by default (use and then/or else in Free Pascal for short-circuit evaluation).

Pascal uses conversion functions from SysUtils: IntToStr, StrToInt, Trunc. TypeScript provides global functions (Number(), String(), parseInt(), parseFloat()) and Math.trunc(). TypeScript will also coerce values implicitly in some contexts (e.g. string concatenation with + converts the number automatically), unlike Pascal which always requires explicit conversion.

Pascal uses + for concatenation but requires explicit numeric-to-string conversion (IntToStr). TypeScript's + automatically converts numbers when one operand is a string. TypeScript also supports template literals (backtick strings) with ${expression} interpolation — much more readable than Pascal's Format function for mixed-type strings.

Pascal string functions are free-standing procedures from SysUtils (Trim(s), UpperCase(s)); TypeScript strings are objects with methods called via dot notation (s.trim(), s.toUpperCase()). TypeScript strings are immutable — all methods return new strings. Pascal strings can be mutated in place using Insert, Delete, and direct character assignment.

Pascal's Pos returns a 1-based position (0 if not found); TypeScript's indexOf returns a 0-based position (-1 if not found). Pascal's Copy(str, start, length) uses 1-based indexing; TypeScript's slice(start, end) uses 0-based indices with an optional end (exclusive). TypeScript's includes is cleaner than checking indexOf >= 0 for simple membership tests.

Pascal's SplitString (from StrUtils) returns a zero-indexed TStringDynArray. TypeScript's split returns a native string[] that integrates directly with array methods. TypeScript's join re-combines the array with a separator — Pascal requires a manual loop for the equivalent.

Pascal fixed arrays use a 1-based index by default (array[1..5]), declared and assigned separately. TypeScript arrays are always 0-based, and can be declared and initialised with an array literal in one line. TypeScript arrays are objects with rich methods (push, pop, map, filter, reduce); Pascal arrays are plain memory regions with no methods.

Pascal's dynamic array (array of T) is resized with SetLength. TypeScript arrays grow automatically with push, pop, shift, unshift, and splice. There is no SetLength equivalent — the array manages its own memory. TypeScript arrays are backed by JavaScript's dynamic array model, not a fixed-size block of typed memory.

TypeScript arrays have built-in functional methods — reduce, map, filter, find, some, every — that replace manual loops. Pascal has none of these; every aggregation requires an explicit loop. The spread operator (...) in TypeScript copies an array before sorting, since sort mutates in place.

Pascal uses records to group heterogeneous data. TypeScript has native tuple types: fixed-length arrays where each position has a specific type. TypeScript 4 added named tuple elements ([x: number, y: number]) for documentation purposes. Tuples are useful for multiple return values — a pattern that in Pascal requires either a record or var parameters.

Standard Pascal has no built-in key-value map. TypeScript's Map<K, V> provides O(1) lookups, iteration in insertion order, and a clean API. Plain TypeScript objects ({ Alice: 95, Bob: 87 }) also serve as key-value stores for string keys. Map is preferred when keys are not known at compile time or when iteration order matters.

The if/else structure is nearly identical. Pascal requires then after the condition; TypeScript requires parentheses around the condition and uses curly braces for multi-statement bodies. Pascal places a semicolon before else only in specific cases — a common source of Pascal syntax errors. TypeScript's optional braces follow the same rules as C.

Pascal's case...of never falls through between branches. TypeScript's switch does fall through unless you add break — a common source of bugs. Multiple values share a branch in Pascal with comma syntax (4, 5:); TypeScript uses stacked case labels with fall-through. For a more Pascal-like no-fall-through construct, TypeScript developers often use if/else chains or object lookups instead.

Pascal has no ternary expression — an if/else statement must be used to conditionally assign a variable. TypeScript inherits JavaScript's condition ? thenValue : elseValue ternary operator, which is an expression that can appear anywhere a value is expected. For more complex conditions TypeScript also has the nullish coalescing operator (value ?? default), which Pascal has no equivalent for.

Pascal's for counter := 1 to 5 do is always step-by-1; downto is step-by-(-1). There is no variable step size. TypeScript's C-style for loop is more flexible: any initialiser, condition, and increment are valid. TypeScript also provides for...of for iterating values and for...in for iterating keys.

Pascal has no foreach construct — iterating a collection always uses a numeric for loop with an explicit index variable. TypeScript's for...of iterates over the values of any iterable (arrays, strings, Sets, Maps, generators) without needing an index. Array.entries() provides both the index and value when you need both.

Pascal's while maps directly to TypeScript's while. Pascal's repeat...until condition (exit when true) maps to TypeScript's do...while (condition) (exit when false) — the exit condition is the logical inverse. Pascal's built-in Inc(count) procedure increments a variable; TypeScript uses the count++ or count += 1 operators.

Pascal distinguishes procedures (no return value) from functions (with a return value) as separate keywords. TypeScript uses a single function keyword and marks no-return-value functions with the void return type. The : void annotation is optional but recommended in TypeScript for clarity. TypeScript's string.repeat(n) replaces Pascal's manual character-printing loop.

Pascal functions use Result := value to set the return value; the function body can contain any number of assignments to Result before returning. TypeScript uses return value which exits the function immediately. Both languages require the return type to be declared in the function signature.

Pascal supports passing functions as values using typed function pointers, but they must be named functions referenced with the @ operator. TypeScript arrow functions ((param) => expression) define anonymous functions inline. TypeScript arrow functions are also closures — they capture variables from the surrounding scope. Function types in TypeScript are written as (param: Type) => ReturnType.

Both languages support default parameter values with identical syntax. TypeScript additionally has optional parameters marked with ? — they can be omitted entirely and arrive as undefined inside the function. The nullish coalescing operator (??) provides a default for undefined or null values. Pascal has no optional parameters; every parameter must be supplied.

Pascal's open array parameter (const values: array of T) accepts an array of any size and is the closest equivalent to variadic parameters — but callers must pass an explicit array literal. TypeScript's rest parameter (...values: T[]) lets callers pass any number of individual arguments, which are collected into an array inside the function.

Pascal class bodies separate declaration (in the type block) from implementation (method bodies written below). TypeScript classes are self-contained. Pascal requires manual Free to destroy objects; TypeScript uses garbage collection. Pascal private fields use the F prefix by convention (FName); TypeScript uses the private keyword or the #name private field syntax.

Inheritance syntax differs in key ways. Pascal uses class(ParentClass) for the base class and the virtual; abstract; directive pair; overrides require override. TypeScript uses extends, the abstract keyword on both the class and the method, and override is optional (recommended with noImplicitOverride). TypeScript's constructor parameter shorthand (private radius: number) declares and assigns the field in one step.

Both languages have private, protected, and public access modifiers with identical semantics. Pascal access modifiers are section headers inside the class declaration (private followed by members); TypeScript uses per-member keywords. TypeScript also has readonly and #field (truly private at runtime, unlike private which is only a compile-time check).

Interfaces work similarly in both languages. Pascal requires class implementations to inherit from TInterfacedObject; TypeScript uses the implements keyword. A key difference: TypeScript interfaces support structural typing — any object with the required shape satisfies the interface, even without an explicit implements declaration. Pascal uses nominal typing — the explicit declaration is required.

Pascal's type block creates named type aliases and new structured types (record). TypeScript's type keyword creates aliases for any type — primitives, objects, unions, intersections, or tuples. TypeScript object types ({ x: number; y: number }) are structurally typed: any object with those properties satisfies the type, regardless of how it was created.

Pascal uses variant records (a record with a discriminant tag and overlapping fields) to represent values of multiple types. TypeScript has first-class union types (number | string | boolean) which are checked with typeof guards. TypeScript discriminated unions (type Shape = { kind: "circle", radius: number } | { kind: "square", side: number }) are the idiomatic equivalent of Pascal's variant records — and much cleaner to use.

Both languages support generics with type parameters. Free Pascal uses generic and specialize keywords; TypeScript uses angle-bracket syntax consistently. TypeScript generics are erased at runtime (like Java), while Pascal generics generate separate compiled code per type (like C++ templates). TypeScript generic constraints use extends: function largest<T extends { length: number }>(items: T[]).

Both languages use try/catch (Pascal calls it try/except). Pascal supports typed catches with on ErrorVar: ExceptionClass do; TypeScript's catch receives an unknown type that must be narrowed with instanceof. Note that TypeScript's parseInt does not throw on invalid input — it returns NaN — so explicit validation is often needed, unlike Pascal's StrToInt which throws EConvertError.

Custom exceptions follow the same pattern in both languages: extend the base exception class, add properties, and call the parent constructor. Pascal's convention names exception classes with an E prefix (EValidationError); TypeScript's convention uses an Error suffix (ValidationError). Setting this.name in TypeScript is recommended so error.name identifies the type correctly in logs.

Both languages support finally blocks that execute regardless of whether an exception was raised. Pascal's try...finally is structurally separate from try...except — to both handle an exception and clean up, you must nest them or use try...except...finally (Free Pascal supports this). TypeScript combines catch and finally in a single try block naturally.

Pascal's uses clause imports entire units; all their exported identifiers become available in the current scope. TypeScript uses ES module syntax: import { name } from "module" for named exports, import Default from "module" for a default export, and import * as ns from "module" to import everything under a namespace. TypeScript modules are files — each file is its own module.

Pascal units have a strict interface/implementation split: the interface section declares what is public; the implementation section provides the bodies (and can also contain private helpers not in the interface). TypeScript exports individual declarations with the export keyword. Types, functions, classes, constants, and variables can all be exported; anything without export is private to the file.