TypeScript Examples

121 copy-and-run snippets. Open one in Try TypeScript at /typescript/try, change a value, and run it again. Each language has its own shelf and its own editor.

Basics

console.log("Hello, TypeScript");

const name: string = "Ada";
console.log("Hello,", name);

const a: number = 8;
const b: number = 11;
console.log(a + b);

const seats = 12;
console.log(seats);

let count = 0;
count += 1;
const label = "ready";
console.log(count, label);

let year: number = 2026;
let ready: boolean = true;
console.log(year, ready);

const n = 7;
console.log(typeof n);

console.log(7 + 3, 7 * 3);

console.log(17 / 5, 17 % 5);

const sum = 8 + 11 + 5;
console.log(sum / 3);

const ready: boolean = true;
console.log(ready);

console.log(1 === 1, String(1) === "1");

const lang = "TypeScript";
console.log(`Learn ${lang}`);

const a = "Try ";
const b = "TypeScript";
console.log(a + b);

const word = "compiler";
console.log(word.length);

const word = "python";
console.log(word[0], word[word.length - 1]);

const word = "StudyGrid";
console.log(word.slice(0, 5));

const word = "banana";
console.log(word.indexOf("na"));

const word = "compiler";
console.log(word.split("").reverse().join(""));

console.log(Math.trunc(9.8));

Control

const n = 7;
if (n % 2 === 0) console.log("even");
else console.log("odd");

const score = 82;
if (score >= 90) console.log("A");
else if (score >= 80) console.log("B");
else console.log("C");

const n = 4;
console.log(n % 2 === 0 ? "even" : "odd");

const day = 3;
switch (day) {
  case 1:
    console.log("Mon");
    break;
  default:
    console.log("later");
}

for (let n = 1; n <= 5; n++) console.log(n);

const nums = [4, 17, 9];
for (const n of nums) console.log(n);

let n = 3;
while (n > 0) {
  console.log(n);
  n--;
}

let n = 0;
do {
  console.log(n);
  n++;
} while (n < 3);

for (let n = 0; n < 6; n++) {
  if (n % 2 === 0) continue;
  console.log(n);
}

for (let n = 1; n <= 15; n++) {
  if (n % 15 === 0) console.log("FizzBuzz");
  else if (n % 3 === 0) console.log("Fizz");
  else if (n % 5 === 0) console.log("Buzz");
  else console.log(n);
}

for (let r = 1; r <= 3; r++) {
  const row: number[] = [];
  for (let c = 1; c <= 3; c++) row.push(r * c);
  console.log(row.join(" "));
}

const a = 8, b = 11, c = 5;
console.log(Math.max(a, b, c));

const year = 2024;
const leap = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
console.log(leap ? "leap" : "common");

Containers

const nums: number[] = [8, 11, 5];
let sum = 0;
for (const n of nums) sum += n;
console.log(sum);

const nums = [4, 17, 9, 2, 13];
console.log(Math.max(...nums));

const grid: number[][] = [[1, 2, 3], [4, 5, 6]];
console.log(grid[1][0]);

const nums: number[] = [];
nums.push(4);
nums.push(17);
console.log(nums.length, nums[1]);

const nums = [1, 2, 3];
console.log(nums.map((n) => n * n).join(" "));

const nums = [1, 2, 3, 4];
console.log(nums.filter((n) => n % 2 === 0).join(" "));

const nums = [8, 11, 5];
console.log(nums.reduce((a, n) => a + n, 0));

const nums = [9, 2, 7, 1, 4];
nums.sort((a, b) => a - b);
console.log(nums.join(" "));

const nums = [4, 17, 9];
console.log(nums.find((n) => n === 9));

const nums = [3, 1, 3, 2, 3];
console.log(nums.filter((n) => n === 3).length);

const scores = new Map<string, number>();
scores.set("Mia", 95);
scores.set("Kai", 88);
console.log(scores.get("Mia"));

const scores = new Map([["Ada", 99], ["Kai", 88]]);
for (const [name, score] of scores) console.log(name, score);

const nums = new Set([3, 1, 3, 2]);
console.log([...nums].join(" "));

const tags = new Set(["html", "css"]);
console.log(tags.has("html"));

const pair: [string, number] = ["Ada", 2026];
console.log(pair[0], pair[1]);

const point = { x: 3, y: 4 };
console.log(point.x, point.y);

interface User { name: string; year: number }
const u: User = { name: "Ada", year: 2026 };
console.log(u.name);

type Point = { x: number; y: number };
const p: Point = { x: 1, y: 2 };
console.log(p.x + p.y);

function label(id: string | number): string {
  return "id-" + id;
}
console.log(label(7), label("ada"));

type Note = { text: string; tag?: string };
const n: Note = { text: "hi" };
console.log(n.tag ?? "none");

Functions and OOP

function add(a: number, b: number): number {
  return a + b;
}
console.log(add(8, 11));

function greet(name: string): void {
  console.log("Hi,", name);
}
greet("Kai");

function greet(name = "friend"): void {
  console.log("Hi,", name);
}
greet();
greet("Kai");

function title(name: string, honorific?: string): string {
  return honorific ? honorific + " " + name : name;
}
console.log(title("Ada"), title("Ada", "Dr"));

function add(a: number, b: number): number;
function add(a: string, b: string): string;
function add(a: number | string, b: number | string): number | string {
  if (typeof a === "number" && typeof b === "number") return a + b;
  return String(a) + String(b);
}
console.log(add(2, 3));
console.log(add("2", "3"));

function factorial(n: number): number {
  let result = 1;
  for (let i = 2; i <= n; i++) result *= i;
  return result;
}
console.log(factorial(5));

function fib(n: number): number {
  if (n < 2) return n;
  return fib(n - 1) + fib(n - 2);
}
console.log([0, 1, 2, 3, 4, 5, 6, 7, 8, 9].map(fib).join(" "));

const square = (n: number) => n * n;
console.log([1, 2, 3, 4].map(square).join(" "));

function bigger<T extends number | string>(a: T, b: T): T {
  return a > b ? a : b;
}
console.log(bigger(3, 9));
console.log(bigger("a", "z"));

class Total {
  private sum = 0;
  add(n: number): void { this.sum += n; }
  get(): number { return this.sum; }
}
const t = new Total();
t.add(4);
t.add(7);
console.log(t.get());

class User {
  constructor(private name: string) {}
  hello(): void { console.log("Hi,", this.name); }
}
new User("Ada").hello();

class Vault {
  private code = 7;
  reveal(): number { return this.code; }
}
console.log(new Vault().reveal());

class Temp {
  private c = 0;
  get celsius(): number { return this.c; }
  set celsius(n: number) { this.c = n; }
}
const t = new Temp();
t.celsius = 21;
console.log(t.celsius);

class Animal {
  speak(): void { console.log("..."); }
}
class Dog extends Animal {
  override speak(): void { console.log("woof"); }
}
new Dog().speak();

abstract class Shape {
  abstract area(): number;
}
class Square extends Shape {
  constructor(private side: number) { super(); }
  area(): number { return this.side * this.side; }
}
const s: Shape = new Square(3);
console.log(s.area());

class Counter {
  static count = 0;
  constructor() { Counter.count++; }
}
new Counter();
new Counter();
console.log(Counter.count);

abstract class Logger {
  abstract write(msg: string): void;
}
class ConsoleLogger extends Logger {
  write(msg: string): void { console.log(msg); }
}
new ConsoleLogger().write("ok");

interface Greeter { hello(): string }
class Host implements Greeter {
  hello(): string { return "welcome"; }
}
console.log(new Host().hello());

namespace studio {
  export function seats(): number { return 12; }
}
console.log(studio.seats());

function positive(n: number): number {
  if (n < 0) throw new Error("need a positive number");
  return n;
}
try {
  console.log(positive(-1));
} catch (err) {
  console.log((err as Error).message);
}

function sumOf(nums: readonly number[]): number {
  return nums.reduce((a, n) => a + n, 0);
}
console.log(sumOf([1, 2, 3]));

const roles = ["admin", "guest"] as const;
console.log(roles[0]);

const raw: unknown = "42";
const text = raw as string;
console.log(text.length);

type User = { name: string; year: number };
const patch: Partial<User> = { year: 2026 };
console.log(patch.year);

type User = { name: string; year: number; city: string };
const card: Pick<User, "name" | "city"> = { name: "Ada", city: "London" };
console.log(card.name);

const scores: Record<string, number> = { Mia: 95, Kai: 88 };
console.log(scores.Mia);

Library

console.log(Math.sqrt(64));

console.log(Math.pow(2, 10));

console.log(Math.abs(-12));

console.log(Math.round(2.5), Math.floor(2.9));

const d = new Date("2026-08-19T00:00:00Z");
console.log(d.getUTCFullYear(), d.getUTCMonth() + 1);

const start = Date.now();
const end = start + 5;
console.log(end - start);

const user = { name: "Ada", year: 2026 };
console.log(JSON.stringify(user));

const raw = '{"n":7}';
const data = JSON.parse(raw) as { n: number };
console.log(data.n);

console.log("a,b,c".split(",").join("-"));

console.log("TypeScript".includes("Script"));

console.log(String(7).padStart(3, "0"));

console.log((10 / 4).toFixed(2));

console.log(parseInt("42", 10) + 1);

console.log(Number("3.5") + 1);

console.log(Boolean(""), Boolean("hi"));

const n: number | null = null;
console.log(n ?? 0);

type User = { city?: { name: string } };
const u: User = {};
console.log(u.city?.name ?? "unknown");

enum Day { Mon, Tue, Wed }
const d: Day = Day.Tue;
console.log(d);

enum Color { Red = "red", Blue = "blue" }
console.log(Color.Red);

function seats(): number {
  return 12;
}
console.log(seats());

const a = [1, 2];
const b = [...a, 3];
console.log(b.join(" "));

const user = { name: "Ada", year: 2026 };
const { name, year } = user;
console.log(name, year);

function total(...nums: number[]): number {
  return nums.reduce((a, n) => a + n, 0);
}
console.log(total(1, 2, 3, 4));

const nums = [2, 4, 6];
console.log(nums.every((n) => n % 2 === 0), nums.some((n) => n > 5));

const nums = [1, 2, 3];
console.log([...nums].reverse().join(" "));

const nums = [4, 17, 9];
console.log(Math.min(...nums), Math.max(...nums));

const words = ["a", "b", "a"];
console.log(new Set(words).size);

const m = new Map<string, number>([["a", 1], ["b", 2]]);
console.log(m.size);

class Box {
  constructor(public value: number) {}
  bump(): this { this.value++; return this; }
}
console.log(new Box(1).bump().bump().value);

class Base {
  protected n = 3;
}
class Child extends Base {
  show(): number { return this.n; }
}
console.log(new Child().show());

function readLine(): string {
  return "Ada";
}
const name = readLine();
console.log("Hello,", name);

const n = 1; // kept
/* skipped */
console.log(n);

Projects

function add(a: number, b: number): number { return a + b; }
function divide(a: number, b: number): number {
  if (b === 0) throw new Error("divide by zero");
  return a / b;
}
console.log(add(10, 4));
console.log(divide(10, 4));

type Student = { name: string; score: number };
const classList: Student[] = [
  { name: "Mia", score: 91 },
  { name: "Kai", score: 88 },
  { name: "Ada", score: 99 },
];
const top = classList.reduce((a, s) => (s.score > a.score ? s : a));
console.log(top.name, top.score);

class Account {
  constructor(private balance: number) {}
  deposit(n: number): void { this.balance += n; }
  withdraw(n: number): boolean {
    if (n > this.balance) return false;
    this.balance -= n;
    return true;
  }
  get(): number { return this.balance; }
}
const a = new Account(50);
a.deposit(20);
console.log(a.withdraw(10), a.get());

type Q = { prompt: string; answer: string };
const quiz: Q[] = [
  { prompt: "2+2", answer: "4" },
  { prompt: "capital of France", answer: "Paris" },
];
const replies = ["4", "London"];
let score = 0;
quiz.forEach((q, i) => { if (replies[i] === q.answer) score++; });
console.log(score);

type Book = { title: string; author: string; year: number };
const shelf: Book[] = [
  { title: "Emma", author: "Austen", year: 1815 },
  { title: "Pride", author: "Austen", year: 1813 },
];
console.log(shelf.filter((b) => b.author === "Austen").map((b) => b.title).join(", "));

function cToF(c: number): number { return c * 9 / 5 + 32; }
console.log(cToF(0).toFixed(1), cToF(100).toFixed(1));

const board = ["X", "X", "X", "O", " ", " ", " ", "O", " "];
function winner(b: string[]): string {
  const lines = [[0, 1, 2], [3, 4, 5], [6, 7, 8], [0, 3, 6], [1, 4, 7], [2, 5, 8], [0, 4, 8], [2, 4, 6]];
  for (const [a, c, d] of lines) if (b[a] !== " " && b[a] === b[c] && b[c] === b[d]) return b[a];
  return "-";
}
console.log(winner(board));

const book = new Map<string, string>([["Ada", "555-0100"], ["Kai", "555-0142"]]);
console.log(book.get("Ada"));
for (const name of [...book.keys()].sort()) console.log(name);

function letter(n: number): string {
  if (n >= 90) return "A";
  if (n >= 80) return "B";
  if (n >= 70) return "C";
  return "D";
}
const scores = [91, 84, 76];
const avg = scores.reduce((a, n) => a + n, 0) / scores.length;
console.log(scores.map(letter).join(" "), avg.toFixed(1));

type Item = { name: string; qty: number; price: number };
const cart: Item[] = [
  { name: "Tea", qty: 2, price: 1.75 },
  { name: "Bread", qty: 1, price: 2.40 },
];
const total = cart.reduce((a, i) => a + i.qty * i.price, 0);
console.log(total.toFixed(2));