Functions

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26// A declaration.
function add(a: number, b: number): number {
  return a + b;
}

// An arrow function. Same annotations, different syntax.
const multiply = (a: number, b: number): number => a * b;

// A function that returns nothing uses void.
function log(message: string): void {
  console.log('log:', message);
}

// One that never returns at all uses never. More on this in lesson 12.
function fail(reason: string): never {
  throw new Error(reason);
}

console.log(add(2, 3), multiply(2, 3));
log('started');

try {
  fail('deliberate');
} catch (err) {
  console.log('caught:', (err as Error).message);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26// As a type alias, with arrow syntax.
type Comparator = (a: number, b: number) => number;

// Inline in a parameter position, which is the most common by far.
function sortWith(values: number[], compare: (a: number, b: number) => number): number[] {
  return [...values].sort(compare);
}

// As a property of an interface, when the function is part of a bigger shape.
interface Formatter {
  format: (value: number) => string;
  precision: number;
}

const ascending: Comparator = (a, b) => a - b;
const descending: Comparator = (a, b) => b - a;

console.log(sortWith([3, 1, 2], ascending));
console.log(sortWith([3, 1, 2], descending));

const currency: Formatter = {
  format: (value) => `£${value.toFixed(2)}`,
  precision: 2,
};

console.log(currency.format(9.5));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15// Optional: may be omitted, and is then undefined inside the function.
function greet(name: string, title?: string): string {
  return title ? `${title} ${name}` : name;
}

// Default: may be omitted, and is then the default. Note there is no `?` and
// no `| undefined` — the parameter type is just string inside the body.
function shout(name: string, punctuation: string = '!'): string {
  return `${name.toUpperCase()}${punctuation}`;
}

console.log(greet('Lovelace'));
console.log(greet('Lovelace', 'Ada'));
console.log(shout('hello'));
console.log(shout('hello', '?'));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15function total(...values: number[]): number {
  return values.reduce((sum, n) => sum + n, 0);
}

console.log(total());
console.log(total(1, 2, 3));
console.log(total(...[4, 5, 6]));

// Mixed: a required first argument, then any number more.
function join(separator: string, ...parts: string[]): string {
  return parts.join(separator);
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14function each(items: string[], visit: (item: string, index: number) => void): void {
  items.forEach((item, i) => visit(item, i));
}

// Uses both parameters.
each(['a', 'b'], (item, index) => console.log(index, item));

// Ignores the index entirely, and is accepted. This is not a bug in the
// checker; it is why `arr.map(x => x * 2)` does not force you to write
// `(x, i, arr) =>` every time.
each(['c', 'd'], (item) => console.log(item));

// Even a function taking nothing at all is fine.
each(['e'], () => console.log('called'));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24class Animal {
  constructor(public name: string) {}
}
class Dog extends Animal {
  constructor(name: string, public breed: string) { super(name); }
}

// Method syntax. Checked bivariantly, so a narrower parameter is accepted.
interface LooseHandler {
  handle(animal: Animal): string;
}

const loose: LooseHandler = {
  handle(dog: Dog) { return `${dog.name} is a ${dog.breed}`; },
};

// With a real Dog it works.
console.log(loose.handle(new Dog('Rex', 'collie')));

// With a plain Animal it reads .breed on something that has none. The types
// said this was fine; the answer is wrong and nothing warned you.
console.log(loose.handle(new Animal('Generic')));
console.log('');
console.log('Same code with property syntax would not have compiled.');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17// The signatures callers see.
function parse(input: string): string[];
function parse(input: string, asNumbers: true): number[];

// The implementation. It must be compatible with every signature above, and
// it is NOT itself callable — callers only see the two declarations.
function parse(input: string, asNumbers?: boolean): string[] | number[] {
  const parts = input.split(',').map((p) => p.trim());
  return asNumbers === true ? parts.map(Number) : parts;
}

// Each call gets a precise return type, with no narrowing needed.
const words = parse('a, b, c');
const numbers = parse('1, 2, 3', true);

console.log(words.map((w) => w.toUpperCase()));
console.log(numbers.reduce((a, b) => a + b, 0));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28interface Counter {
  count: number;
  increment(this: Counter, by: number): number;
}

const counter: Counter = {
  count: 0,
  // The first parameter named `this` is not a real parameter — it is erased,
  // and it tells the compiler what the function expects to be called on.
  increment(this: Counter, by: number): number {
    this.count += by;
    return this.count;
  },
};

console.log(counter.increment(1));
console.log(counter.increment(5));

// Arrow functions have no `this` of their own, which is usually what you want
// inside a method and is the reason they are preferred for callbacks.
const timer = {
  label: 'build',
  report(): string {
    const inner = () => `${this.label} done`;
    return inner();
  },
};
console.log(timer.report());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23// Annotate the resolved type; the Promise wrapper is part of the signature.
async function fetchTitle(id: number): Promise<string> {
  // Pretend this is a network call.
  await Promise.resolve();
  return `Document ${id}`;
}

// Inference works here too: this is Promise<number> without being told.
async function count() {
  await Promise.resolve();
  return 42;
}

async function main(): Promise<void> {
  console.log(await fetchTitle(7));
  console.log(await count());

  // Promise.all preserves the tuple of types, which is genuinely clever.
  const [title, n] = await Promise.all([fetchTitle(1), count()]);
  console.log(title, n);
}

await main();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15const results: string[] = [];

// `visit` is declared as returning void.
function each(items: string[], visit: (item: string) => void): void {
  for (const item of items) visit(item);
}

// This callback returns a string. It is accepted, because a void return type
// on a callback means "I will ignore whatever comes back", not "you must
// return nothing". Without this rule, `items.forEach(x => arr.push(x))` would
// be an error, since push returns a number.
each(['a', 'b'], (item) => results.push(item));

console.log(results);
console.log('push returned values, and each() discarded them.');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41interface RetryOptions {
  attempts?: number;
  delayMs?: number;
  onRetry?: (attempt: number, error: Error) => void;
}

async function withRetry<T>(
  operation: () => Promise<T>,
  options: RetryOptions = {},
): Promise<T> {
  const attempts = options.attempts ?? 3;
  const delayMs = options.delayMs ?? 0;

  let lastError: Error = new Error('no attempts made');

  for (let attempt = 1; attempt <= attempts; attempt++) {
    try {
      return await operation();
    } catch (err) {
      lastError = err instanceof Error ? err : new Error(String(err));
      options.onRetry?.(attempt, lastError);
      if (delayMs > 0) await new Promise((r) => setTimeout(r, delayMs));
    }
  }

  throw lastError;
}

let calls = 0;
const flaky = async (): Promise<string> => {
  calls++;
  if (calls < 3) throw new Error(`attempt ${calls} failed`);
  return `succeeded on attempt ${calls}`;
};

console.log(
  await withRetry(flaky, {
    attempts: 5,
    onRetry: (attempt, error) => console.log(`  retrying after: ${error.message}`),
  }),
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28async function withRetry(operation, options = {}) {
    const attempts = options.attempts ?? 3;
    const delayMs = options.delayMs ?? 0;
    let lastError = new Error('no attempts made');
    for (let attempt = 1; attempt <= attempts; attempt++) {
        try {
            return await operation();
        }
        catch (err) {
            lastError = err instanceof Error ? err : new Error(String(err));
            options.onRetry?.(attempt, lastError);
            if (delayMs > 0)
                await new Promise((r) => setTimeout(r, delayMs));
        }
    }
    throw lastError;
}
let calls = 0;
const flaky = async () => {
    calls++;
    if (calls < 3)
        throw new Error(`attempt ${calls} failed`);
    return `succeeded on attempt ${calls}`;
};
console.log(await withRetry(flaky, {
    attempts: 5,
    onRetry: (attempt, error) => console.log(`  retrying after: ${error.message}`),
}));