Projekt: eine Bibliothek mit Zählern und Formatierern aus Closures

// Each counter must keep its own count, starting at start and moving by step.
let count = 0;

export function makeCounter(start = 0, step = 1) {
  const increment = () => {
    count += 1;
    return count;
  };
  const decrement = () => {
    count -= 1;
    return count;
  };
  const value = () => count;
  const reset = () => {
    count = 0;
    return count;
  };
  return {increment, decrement, value, reset};
}

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {makeCounter} from './main.js';

test('zwei Zähler behalten ihren eigenen Stand', () => {
  const a = makeCounter();
  const b = makeCounter();
  a.increment();
  a.increment();
  b.increment();
  assert.equal(a.value(), 2, `nach zwei Erhöhungen ist a.value() ${a.value()}, erwartet 2`);
  assert.equal(b.value(), 1, `nach einer Erhöhung ist b.value() ${b.value()}, erwartet 1`);
});

test('ein Zähler beginnt bei start und bewegt sich um step', () => {
  const c = makeCounter(10, 5);
  assert.equal(c.value(), 10, `makeCounter(10, 5).value() ist ${c.value()}, erwartet 10`);
  const up = c.increment();
  assert.equal(up, 15, `das erste increment hat ${up} zurückgegeben, erwartet 15`);
});

test('decrement geht um step zurück', () => {
  const c = makeCounter(10, 5);
  c.decrement();
  const down = c.decrement();
  assert.equal(down, 0, `zwei decrement-Aufrufe von 10 um 5 haben ${down} zurückgegeben, erwartet 0`);
});

test('reset geht auf start zurück', () => {
  const c = makeCounter(3);
  c.increment();
  c.increment();
  const back = c.reset();
  assert.equal(back, 3, `reset() hat ${back} zurückgegeben, erwartet 3`);
  assert.equal(c.value(), 3, `nach reset() ist value() ${c.value()}, erwartet 3`);
});

{
  "type": "module"
}

// Return a function that formats a number with prefix, decimals and suffix.
export function makeFormatter(options = {}) {
  const prefix = options.prefix ?? "";
  const suffix = options.suffix ?? "";
  const decimals = options.decimals ?? 2;
  return (amount) => `${amount}`;
}

export const euro = makeFormatter({suffix: " EUR"});

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {makeFormatter, euro} from './main.js';

test('euro(4.5) ergibt 4.50 EUR', () => {
  assert.equal(euro(4.5), '4.50 EUR', `euro(4.5) hat ${JSON.stringify(euro(4.5))} zurückgegeben, erwartet "4.50 EUR"`);
});

test('ein Präfix steht vor der Zahl', () => {
  const dollar = makeFormatter({prefix: '$'});
  assert.equal(dollar(19.9), '$19.90', `der $-Formatierer hat ${JSON.stringify(dollar(19.9))} zurückgegeben, erwartet "$19.90"`);
});

test('decimals legt die Zahl der Nachkommastellen fest', () => {
  const percent = makeFormatter({suffix: '%', decimals: 1});
  assert.equal(percent(12.34), '12.3%', `percent(12.34) hat ${JSON.stringify(percent(12.34))} zurückgegeben, erwartet "12.3%"`);
});

test('ohne Optionen: zwei Nachkommastellen, nichts drumherum', () => {
  const plain = makeFormatter();
  assert.equal(plain(3), '3.00', `makeFormatter()(3) hat ${JSON.stringify(plain(3))} zurückgegeben, erwartet "3.00"`);
});

{
  "type": "module"
}

// Return a function that runs first, then second on first's result.
export const pipe = (first, second) => (value) => first(second(value));

const withVat = (net) => net * 1.19;
const euro = (amount) => `${amount.toFixed(2)} EUR`;

// A price tag: add VAT, then format.
export const priceTag = pipe(withVat, euro);

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {pipe, priceTag} from './main.js';

const addOne = (n) => n + 1;
const double = (n) => n * 2;
const square = (n) => n * n;

test('pipe führt zuerst first, dann second aus', () => {
  const got = pipe(addOne, double)(3);
  assert.equal(got, 8, `pipe(addOne, double)(3) hat ${got} zurückgegeben, erwartet 8`);
});

test('priceTag(10) ergibt 11.90 EUR', () => {
  assert.equal(priceTag(10), '11.90 EUR', `priceTag(10) hat ${JSON.stringify(priceTag(10))} zurückgegeben, erwartet "11.90 EUR"`);
});

test('eine verbundene Funktion lässt sich erneut verbinden', () => {
  const got = pipe(pipe(addOne, double), square)(1);
  assert.equal(got, 16, `pipe(pipe(addOne, double), square)(1) hat ${got} zurückgegeben, erwartet 16`);
});

{
  "type": "module"
}