TypeScript 从第一行开始

console.log("你好，TypeScript！");

node hello.ts

// 这一行写给读代码的人
console.log("2 + 3");
console.log(2 + 3);
console.log("总计", 2 + 3);

const title: string = "整理笔记";
let count: number = 1;
const ready: boolean = true;

count = count + 2;
console.log(title, count, ready);

let score = 10;
score = score + 5;
const label = "得分";
console.log(label, score);
console.log(typeof score, typeof label, typeof false);

const name = "小林";
const done = 2;
console.log(`${name}已经完成 ${done + 1} 项。`);

const score = 72;

if (score >= 90) {
  console.log("优秀");
} else if (score >= 60) {
  console.log("通过");
} else {
  console.log("待练习");
}
console.log("评估结束");

const mode: string = "preview";
const count = 2;
console.log(count === 2);
console.log(count !== 2);
console.log(mode === "preview" && count > 0);
console.log(mode === "run" || count > 0);

const tasks: string[] = ["读资料", "写笔记"];
console.log(tasks[0]);
console.log(tasks[1]);
tasks.push("做练习");
console.log(tasks.length);

const costs = [2, 4, 3];
let total = 0;
for (const cost of costs) {
  total = total + cost;
  console.log("当前总计", total);
}
console.log("最终总计", total);

const tasks = ["读资料", "写笔记"];
for (let i = 0; i < tasks.length; i = i + 1) {
  console.log(i + 1, tasks[i]);
}

let remaining = 3;
while (remaining > 0) {
  console.log(remaining);
  remaining = remaining - 1;
}
console.log("开始");

function add(a: number, b: number): number {
  return a + b;
}

const sum = add(2, 3);
console.log(sum);
console.log(add(sum, 1));

const twice = (n: number) => n * 2;
const triple = (n: number) => {
  return n * 3;
};
console.log(twice(4), triple(4));

const task = { title: "整理笔记", done: false };
console.log(task.title, task.done);
task.done = true;
console.log(task.title, task.done);

type Task = {
  title: string;
  done: boolean;
};

function describe(task: Task): string {
  if (task.done) {
    return `已完成：${task.title}`;
  }
  return `待处理：${task.title}`;
}

const tasks: Task[] = [
  { title: "读资料", done: true },
  { title: "做练习", done: false },
];

for (const task of tasks) {
  console.log(describe(task));
}

console.log(5 / 2, Math.floor(-5 / 2));
console.log(-5 % 2);
console.log(Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2);
console.log(String(9007199254740993n));
console.log("🚀".length, [..."🚀"].length);
console.log(Number("oops"), Number.isNaN(Number("oops")));

let retries = 3;              // 推断为 number
const mode = "dry-run";       // 推断为字面量 "dry-run"
let stage: "new" | "done" = "new";
stage = "done";
console.log(retries, mode, stage);

const configured: { retries?: number; name?: string | null } = {
  retries: 0,
  name: "",
};
console.log(configured.retries || 3);
console.log(configured.retries ?? 3);
console.log(JSON.stringify(configured.name?.trim() ?? "anonymous"));
console.log(({ name: null }).name ?? "anonymous");
const { retries = 5 } = configured;
console.log(retries);

const names = ["a", "b"];
for (const value of names) console.log(value);
for (const key in names) console.log(typeof key, key);
const count = names.length;
console.log(count > 0 ? "work" : "idle");

const defaults = { name: "runner", retries: 2, nested: { log: false } };
const settings = { ...defaults, retries: 0 };
const { name: label, retries, ...rest } = settings;
settings.nested.log = true;
console.log(label, retries, JSON.stringify(rest));
console.log(defaults.retries, defaults.nested.log);

const counts = new Map<string, number>();
for (const name of ["read", "read", "write"]) {
  counts.set(name, (counts.get(name) ?? 0) + 1);
}
const tags = [...new Set(["ts", "node", "ts"])];
console.log(JSON.stringify([...counts]));
console.log(counts.get("missing"), JSON.stringify(tags));
const empty: string[] = [];
console.log(empty[0]);

type Transform = (value: string) => string;
const upper: Transform = value => value.toUpperCase();
const asEntry = (value: string) => ({ value, size: value.length });
const list = (...values: string[]) => values.map(upper).map(asEntry);
console.log(JSON.stringify(list("ts", "node")));

function counter(start = 0) {
  let n = start;
  return () => ++n;
}
const a = counter(10);
const b = counter();
console.log(a(), a(), b());

const job = {
  name: "read",
  run() { return this.name.toUpperCase(); },
};
const bound = job.run.bind(job);
const wrapped = () => job.run();
console.log(bound(), wrapped());

function format(input: string): string;
function format(input: number): string;
function format(input: string | number): string {
  return typeof input === "number" ? input.toFixed(1) : input.trim();
}
console.log(format(3), format(" hi "));

interface Job {
  readonly id: string;
  retries?: number;
}
function describe(job: Job): string {
  return `${job.id}/${job.retries ?? 0}`;
}
const task = { id: "read", owner: "Lin" };
console.log(describe(task));
// describe({ id: "read", owner: "Lin" }); // 多余属性检查

interface Identified { id: string }
interface NamedJob extends Identified { name: string }
type Timed = { timeoutMs: number };
type TimedJob = NamedJob & Timed;
const job: TimedJob = { id: "a", name: "read", timeoutMs: 500 };
console.log(job.name, job.timeoutMs);

function normalize(id: string | number): string {
  if (typeof id === "string") {
    return id.trim();
  }
  return id.toString(10);
}
console.log(normalize("  abc "), normalize(42));

type Result =
  | { kind: "ok"; value: number }
  | { kind: "error"; message: string };

function unreachable(value: never): never {
  throw new Error(`Unexpected result: ${JSON.stringify(value)}`);
}
function show(result: Result): string {
  switch (result.kind) {
    case "ok": return `value=${result.value}`;
    case "error": return `error=${result.message}`;
    default: return unreachable(result);
  }
}
console.log(show({ kind: "ok", value: 0 }));
console.log(show({ kind: "error", message: "timeout" }));

type Job = { kind: "read" | "write"; path: string };
const loose = { kind: "read", path: "in.txt" }; // kind 推断为 string
const exact = { kind: "read", path: "in.txt" } satisfies Job;
const fixed = ["read", "write"] as const;
console.log(exact.kind, fixed[1]);

function get<T extends object, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
const job = { name: "read", retries: 2 };
const name = get(job, "name");       // string
const retries = get(job, "retries"); // number
console.log(name.toUpperCase(), retries + 1);
// get(job, "retry");               // 不在 keyof T 中

type Outcome<T, E = string> =
  | { ok: true; value: T }
  | { ok: false; error: E };

function parseCount(text: string): Outcome<number> {
  if (!/^\d+$/.test(text)) return { ok: false, error: "expected digits" };
  const count = Number(text);
  if (!Number.isSafeInteger(count)) return { ok: false, error: "unsafe integer" };
  return { ok: true, value: count };
}
for (const raw of ["0", "x", "9007199254740993"]) {
  const result = parseCount(raw);
  console.log(result.ok ? result.value : result.error);
}

const actions = ["read", "write"] as const;
type Action = (typeof actions)[number];
type Handler = (path: string) => string;

const handlers = {
  read: path => `read ${path}`,
  write: path => `write ${path}`,
} satisfies Record<Action, Handler>;

console.log(actions.map(action => handlers[action]("a.txt")).join("\n"));

type Settings = { path: string; retries: number };
type Readers<T> = {
  [K in keyof T]: () => T[K];
};
const readers: Readers<Settings> = {
  path: () => "out.txt",
  retries: () => 3,
};

type Item<T> = T extends readonly (infer U)[] ? U : never;
type Name = Item<readonly ["read", "write"]>;
const action: Name = "read";
console.log(readers.path(), readers.retries(), action);

type Job = { name: string; retries: number };

function isJob(value: unknown): value is Job {
  return typeof value === "object" && value !== null
    && "name" in value && typeof value.name === "string"
    && "retries" in value && typeof value.retries === "number"
    && Number.isSafeInteger(value.retries) && value.retries >= 0;
}

function parseJob(text: string): Job {
  const raw: unknown = JSON.parse(text);
  if (!isJob(raw)) throw new Error("invalid job shape");
  return raw;
}

for (const text of ['{"name":"read","retries":0}', '{"name":"read"}', '{']) {
  try {
    console.log(parseJob(text).name.toUpperCase());
  } catch (err: unknown) {
    if (err instanceof SyntaxError) console.log("invalid JSON");
    else console.log(err instanceof Error ? err.message : String(err));
  }
}

const raw: unknown = "42";
const asserted = raw as number;
const converted = Number(raw);
console.log(typeof asserted, asserted + 1);
console.log(typeof converted, converted + 1);

console.log("A: sync start");

setTimeout(() => console.log("D: timer"), 0);
Promise.resolve().then(() => console.log("C: promise"));

console.log("B: sync end");

function delayed(value: string, ms: number): Promise<string> {
  return new Promise(resolve => setTimeout(() => resolve(value), ms));
}
async function main() {
  const results = await Promise.all([delayed("slow", 25), delayed("fast", 5)]);
  console.log(JSON.stringify(results));
}
void main();

type Progress =
  | { kind: "chunk"; text: string }
  | { kind: "done" };

async function* stream(): AsyncGenerator<Progress> {
  yield { kind: "chunk", text: "hello" };
  await Promise.resolve();
  yield { kind: "chunk", text: " world" };
  yield { kind: "done" };
}

async function main() {
  let message = "";
  for await (const event of stream()) {
    if (event.kind === "chunk") message += event.text;
    else console.log(message);
  }
}
void main();

import { setTimeout as delay } from "node:timers/promises";

const controller = new AbortController();

async function run(signal: AbortSignal) {
  try {
    await delay(1000, undefined, { signal });
    console.log("finished");
  } catch (err) {
    if (err instanceof Error && err.name === "AbortError") {
      console.log("cancelled");
      return;
    }
    throw err;
  }
}

const pending = run(controller.signal);
controller.abort();
await pending;

const names: string[] = [];
const first = names[0];
console.log(first.toUpperCase());

mkdir ts-task-lab
cd ts-task-lab
npm.cmd init -y
npm.cmd install -D typescript@5.9.3 @types/node@24
mkdir src

{
  "name": "ts-task-lab",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "scripts": {
    "check": "tsc --noEmit",
    "build": "tsc",
    "start": "node --enable-source-maps dist/main.js"
  },
  "devDependencies": {
    "@types/node": "^24.0.0",
    "typescript": "5.9.3"
  }
}

{
  "compilerOptions": {
    "target": "ES2022",
    "lib": ["ES2022"],
    "types": ["node"],
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "verbatimModuleSyntax": true,
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "noEmitOnError": true,
    "sourceMap": true,
    "rootDir": "src",
    "outDir": "dist"
  },
  "include": ["src/**/*.ts"]
}

export type Task =
  | { kind: "count"; items: string[] }
  | { kind: "echo"; text: string };

function isStringArray(value: unknown): value is string[] {
  return Array.isArray(value) &&
    value.every((item: unknown) => typeof item === "string");
}

export function parseTask(value: unknown): Task {
  if (typeof value !== "object" || value === null || !("kind" in value)) {
    throw new Error("expected a task object");
  }

  switch (value.kind) {
    case "count":
      if ("items" in value && isStringArray(value.items)) {
        return { kind: "count", items: value.items };
      }
      break;
    case "echo":
      if ("text" in value && typeof value.text === "string") {
        return { kind: "echo", text: value.text };
      }
      break;
  }
  throw new Error("invalid task fields");
}

function unreachable(task: never): never {
  throw new Error(`Unexpected task: ${JSON.stringify(task)}`);
}

export function execute(task: Task): string {
  switch (task.kind) {
    case "count": return `count=${task.items.length}`;
    case "echo": return `echo=${task.text}`;
    default: return unreachable(task);
  }
}

import { readFile } from "node:fs/promises";
import { execute, parseTask, type Task } from "./task.js";

async function main(): Promise<void> {
  const path = process.argv[2];
  if (path === undefined) {
    throw new Error("usage: npm start -- task.json");
  }

  const text = await readFile(path, "utf8");
  const raw: unknown = JSON.parse(text);
  const task: Task = parseTask(raw);
  console.log(execute(task));
}

main().catch((error: unknown) => {
  console.error(error instanceof Error ? error.message : String(error));
  process.exitCode = 1;
});

{"kind":"count","items":["read","write","test"]}

{"kind":"count","items":[1]}

npm.cmd run check
npm.cmd run build
node --enable-source-maps dist/main.js task.json
node --enable-source-maps dist/main.js bad-task.json
$LASTEXITCODE