Ein Blog

Posts mit Tag "nodejs"

Nach den ganzen CVEs mal was anderes: Node.js bekommt vielleicht ein node:json-Modul.

Was sie machen wollen: JSON als readonly-Struktur laden und dann auch lazy parsen:

const { parse } = require('node:json');

const doc = parse(fs.readFileSync('twitter.json'));  // Buffer, no toString()
for (const status of doc.get('statuses')) {
  console.log(status.get('id'), status.get('user').get('screen_name'));
}
doc.atPointer('/statuses/0/user/name');   // JSON Pointer (RFC 6901)
doc.get('search_metadata').toObject();    // convert a subtree, like JSON.parse

ZusÀtzlich gibt es noch das:

const { decode } = require('node:json');

const User = {
  type: 'object',
  properties: {
    id: { type: 'integer' },
    login: { type: 'string' },
    followers: { type: 'integer', default: 0 },
  },
  required: ['id', 'login'],
};

decode(data, { type: 'array', items: User });
// TypeError [ERR_JSON_SCHEMA_VALIDATION]: Expected integer, got string at $[3].id

So kann man JSON-Daten nicht nur parsen, sondern auch direkt gegen ein Schema im selben Schritt validieren. Ist nicht nur schneller, sondern man hat auch keine AbhÀngigkeit zu ajv mehr.

Vor ein paar Jahren hatte ich mal ein Experiment. Da habe ich SQL zur Compile-Time ĂŒber TypeScript-Typen geparst und das Anttwortschema davon abgeleitet. Das lief komplett ohne externes Tooling und geht ohne Ă€nderungen am Buildprozess damit auch in JS-Anwendungen. Dadurch hat es auch keinen Runtime-Overhead. Hatte schon ein paar Vorteile. Die Nachteile sind: Das SQL zu parsen ist sehr aufwĂ€ndig. Alleine das Whitespace-Handling richtig zu machen, ist super schwer. Dazu kommt, dass TS in den Typableitungen eine Begrenzung in der Rekursionstiefe hat. Zwar sind TS-Typen quasi eine funktionale Programmiersprache, aber eine sehr umstĂ€ndliche.

Parallel dazu gab es bei TypeScript immer den Wunsch, sowas wie F# Type-Provider zu bauen. Das hat man ne lange Zeit als Out-Of-Scope angesehen, besonders, wenn da noch Codegen involviert ist.

Jetzt gibt es in TS 7.1 aber etwas, was quasi genau das ist: Content Mappers. Damit kann man fĂŒr bestimmte Imports definieren, dass ein externes Programm invoked wird, welches dann einen Code zurĂŒckgibt, der fĂŒr Typinferenz verwendet werden kann.

Das hat jetzt der Macher von Zod genommen und etwas fĂŒr SQL gebaut. Der Vorteil: Das ist auch komplett zur Build-Time. Es verbindet sich auch direkt mit der Datenbank und checkt die Query direkt gegen die native Datenbank, also die Ergebnisse sind garantiert richtig. Auch verschiedene SQL-Dialekte werden damit ordentlich gehandlet. Zwei nachteile: Jede Query muss in eine eigene Datei. Und man kann deshalb auch keine Querys dynamisch zusammenbauen, wie z. B: bei Kysely.

Node.js kann jetzt type-stripping in node_modules. Aber nur fĂŒr privat markierte module, wie man sie z. B. in Monorepos hat.

Eine GH Action ist bei mir gerade gefailt, weil setup-node mit node-version: latest plötzlich nach v27.0.0-alpha.0.0.0 aufgelöst hat. Das soll bestimmt nicht so sein, aber es stimmt: Node.js 27 ist in der Alpha draußen.

tldr neu:

  • Math.sumPrecise ist jetzt endlich da
  • asm.js wird jetzt nicht mehr nach WASM ĂŒberfĂŒhrt. Mozilla hat das auch schon gemacht. Vor WASM gab es asm.js, das jetzt eine zeit lang gar keinen separaten Optimizer mehr hatte, sondern einfach nach WASM ĂŒbersetzt wurde, um die Pipeline zu verwenden. Also wer jetzt noch asm.js benutzt, wird plötzlich ein bisschen langsameren Code haben
  • net/promises

Bun kann jetzt TypeScript checken. NatĂŒrlich nur als separaten Step, nicht zur Laufzeit. Da könnte man jetzt denken, dass sie einfach statisch gegen typescript-go linken. Aber nein, sie gehören jetzt ja Anthropic und haben typescript-go mit LLMs nach Rust portiert. Sie claimen 3-7x schneller als typescript-go zu sein. Zur Erinnerung: tsgo war allein schon 10x schneller als TypeScript 6, die JS-Version.

Wisst Ihr was? Theo hat tsc auch nach rust portiert. Auch vorher hat jemand schon tsc nach Rust portiert: tsz.

Mit LLMs ist open source quasi tot. Jeder baut alles selbst, Projekte haben keinen Wert mehr.

Sagte ich etwa, dass es Deno nicht so gut geht? Vielleicht doch nicht.

Oder etwa doch?

We will support the Deno runtime for another year with monthly releases containing bug fixes and security updates. After that year we will end our development of the Deno runtime. Deno will remain open source, and we welcome others who want to continue its development.

Also das open-source-Projekt ist jetzt wohl tot und den Rest verkauft Cloudflare in Zukunft als proprietÀren Teil ihrer Plattform.

Deno ist dann wohl quasi Legacy-Software.

VitePlus 1.0 ist da.

Edit: Ich habe mal 1-2 Projekte auf Vite+ umgestellt. Es sind rausgeflogen: oxlint, oxlint-tsgolint, oxfmt, Lefthook, vite/tsdown. Dadurch wurden 4 Configs durch eine einzige ersetzt. Die eine Config ist jetzt auch nicht sonderlich kompliziert. Vite+ benutzt unter der Haube ja genau diese Tools, die ich damit jetzt ersetzt habe, weshalb man die Configs von denen einfach in die vite.config.ts ĂŒbernehmen konnte. Positiv aufgefallen ist mir auch, dass es ein echter Vorteil ist, wenn der pre-commit-Manager im selben Tool wie der Linter und Formatter ist. Das war bei Lefthook manchmal fummelig aufzusetzen, dass der die richtigen Dateien an den Linter durchreicht. Dadurch, dass die 5 Tools jetzt durch 1 ersetzt wurden, hab ich auch deutlich weniger Noise durch Dependabot/Renovate.

Die Luete von Vite haben letztendlich das geschafft, woran die hinter Rome (spÀter Biome) pleite gegangen sind. Rome hatte grundsÀtzlich das gleiche Ziel, aber eine andere Strategie, es zu erreichen.

Neue util-Funktion in Node.js: markPromiseAsHandled als Ersatz fĂŒr promise.catch(() => {}), mit dem unterschied, dass es direkt in der Runtime als Handled markiert wird und man sich den Fake-Handler spart.

Und wo wir gerade bei Node.js waren: das zlib-Modul bekommt Support fĂŒr Zip-Files. Scheinbar sowohl zum Entpacken auf die Platte, als auch In-Memory. Das ist cool, dafĂŒr hab ich immer ein extra Modul gebraucht. Aktuell wohl noch komplett im JS-Userland implementiert und nicht nativ.

Jarred hat nun endlich den lang erwarteten Blogpost zu Buns Migration von Zig nach Rust veröffentlicht: Rewriting Bun in Rust.

Andrew Kelly (der Mensch hinter Zig) hat auch schon geantwortet: My Thoughts on the Bun Rust Rewrite.

Das nĂ€chste npm fĂŒhrt per default keine Install-Skripte mehr aus. Der Workflow ist jetzt Ă€hnlich zu dem, was man bei Bun macht: Eine Liste an erlaubten Paketen in der package.json, die besagte Skripte ausfĂŒhren dĂŒrfen.

npm 12 kommt bald raus. Die erste Version hat interessante Changes. Sie enternen npm shrinkwrap. Hat wahrscheinlich nie einer wirklich benutzt. Die meisten werden lockfiles benutzen, die aber fĂŒr Libarys im prinzip nutzlos sind, wenn in der package.json Semver-Specifier sind, die eine Range zulassen (z. B. ^ und ~). Man soll jetzt bundleDependencies in der package.json verwenden. Das tar enthĂ€lt dann alle Dependencys. Vielleicht ein bisschen suboptimal, wenn wir dann jetzt “left-pad” in derselben Version in der halben Registry mit bundlen. Aber immerhin könnte das die Supply-Chain-Risiken vermindern. Bisschen schade, dass man nicht auch einfach auf ne bestimmte Version locken kann, sodass npm immerhin noch deduplizierung anwenden kann.

Node.js 26 ist da. Hat jetzt Temporal-Support und die beiden neuen Methoden auf (Weak)Map.

Node.js Àndert seine Versionierung. Bisher: Jedes Jahr zwei Major-Versionen. Die gerade Nummer wird spÀter zum LTS promoted. Jetzt: Noch noch eine Major-Version im April, die dann im Oktober zur LTS wird.

Bei Node.js wurde gerade die Issue zu Temporal resolved. V8 benutzt eine Rust-Implementierung fĂŒr Temporal und Node.js konnte bisher nicht ordentlich gegen Rust-Projekte linken. Das mussten sie vorher noch fixen, was jetzt scheinbar passiert ist. Die nĂ€chste Node-Version wird dann wohl endlich mit Temporal kommen.

Node.js bekommt wohl ein vfs. Initiator dafĂŒr war das Single-Executable-Bestreben.

Die UI der npm-Registry hat ja schon lĂ€nger kein Update mehr bekommen, weil Microsoft das ganze nicht so preiorisiert. Da gibt’s jetzt ein anderes UI fĂŒr die Registry: npmx. Ein paar Sachen sind in meinen Augen besser gelungen, ein paar nicht. Mal gucken, ob ich das in Zukunft benutzen werde.

Wer hĂ€ufiger mal npm-Module anlegt, verwendet dafĂŒr vielleicht oft npm init.

Der Befehl ist seit Jahren standard, aber die Werte darin sind immer noch alt. Beispielsweise legt es das Projekt per Default als commonjs-Modul an. Das steht aktuell noch als Änderung aus, aber man kann die Defaults in der globalen Config setzen:

npm config set init-type module

DarĂŒber hinaus kann man auch ein paar andere Defaults setzen, die man sowieso immer setzt. FĂŒr mich sind das beispielsweise:

npm config set init-license MIT # defaults to ISC
npm config set init-author-email test@example.com
npm config set init-author-name "M. Mustermann"
npm config set init-author-url "https://github.com/mmustermann"
npm config set init-private true

Node.js hat einen internen Eventbus: node:diagnostics_channel:

import diagnostics_channel from 'node:diagnostics_channel';

// Create custom diagnostic channels
const dbChannel = diagnostics_channel.channel('app:database');
const httpChannel = diagnostics_channel.channel('app:http');

// Subscribe to diagnostic events
dbChannel.subscribe((message) => {
  console.log('Database operation:', {
    operation: message.operation,
    duration: message.duration,
    query: message.query
  });
});

// Publish diagnostic information
async function queryDatabase(sql, params) {
  const start = performance.now();

  try {
    const result = await db.query(sql, params);

    dbChannel.publish({
      operation: 'query',
      sql,
      params,
      duration: performance.now() - start,
      success: true
    });

    return result;
  } catch (error) {
    dbChannel.publish({
      operation: 'query',
      sql,
      params,
      duration: performance.now() - start,
      success: false,
      error: error.message
    });
    throw error;
  }
}

Node.js hat jetzt Codemods, um userland-code zu migrieren, damit man einfacher auf eine neue Node-Verison migrieren kann.

TIL sqlite3_set_authorizer. Damit kann man einen Callback definieren, den SQLite aufruft, wenn eine Query auf eine bestimmte Datenbank/Tabelle/Spalte zugreifen möchte.

Gefunden, weil node:sqlite das jetzt kann:

import { DatabaseSync, constants } from 'node:sqlite';
const db = new DatabaseSync(':memory:');

// Set up an authorizer that denies all table creation
db.setAuthorizer((actionCode) => {
  if (actionCode === constants.SQLITE_CREATE_TABLE) {
    return constants.SQLITE_DENY;
  }
  return constants.SQLITE_OK;
});

// This will work
db.prepare('SELECT 1').get();

// This will throw an error due to authorization denial
try {
  db.exec('CREATE TABLE blocked (id INTEGER)');
} catch (err) {
  console.log('Operation blocked:', err.message);
}

Node.js 25 ist da.

Neu ist:

  • Die base64/hex-APIs aus dem vorherigen Blogpost
  • Mehr sandboxing mit --allow-net
  • WebStorage (ich berichtete) ist jetzt per default eingeschaltet
  • JSON.stringify ist ein bisschen schneller
  • WebAssembly kann jetzt JSPI. Damit können WASM-Funktionen jetzt Promise-zurĂŒckgebende JS-Funktionen verwenden

15 Recent Node.js Features that Replace Popular npm Packages.

Bei den base64-Beispielen fehlen noch die neuen Funktionen fĂŒr Hex und Base64:

const a = Uint8Array.fromBase64("...");
console.log(a.toBase64();

const b = Uint8Array.fromHex("...");
console.log(b.toHex());

Kann auch url-safe base64 und das Handling von falschem Padding und Whitespace ist auch konfigurierbar.

VoidZero hat gerade Vite+ angekĂŒndigt. Kostenlos fĂŒr OSS-Projekte.

Es handelt sich um ein drop-in-Replacement fĂŒr Vite. Dazu kommt ein eslint-kompatibler Linter (ĂŒber oxlint) und ein prettier-kompatibler Formatter (ĂŒber oxfmt). Ein tsup ist auch dabei (ĂŒber tsdown und rolldown).

Vieles davoon waren auch die Ziele von biome.

Node.js hat ja schon SQLite eingebaut bekommen. In der neuen Node.js 24.9 gibt es dafĂŒr jetzt eine Erweiterung. Die API ist Ă€hnlich zu der von Bun oder den tagged-template-strings, die ich mal als PoC statisch typisiert habe.

Aussehen tut das so:

import { DatabaseSync } from 'node:sqlite';

const db = new DatabaseSync(':memory:');
const sql = db.createSQLTagStore();

db.exec('CREATE TABLE users (id INT, name TEXT)');

// Using the 'run' method to insert data.
// The tagged literal is used to identify the prepared statement.
sql.run`INSERT INTO users VALUES (1, 'Alice')`;
sql.run`INSERT INTO users VALUES (2, 'Bob')`;

// Using the 'get' method to retrieve a single row.
const id = 1;
const user = sql.get`SELECT * FROM users WHERE id = ${id}`;
console.log(user); // { id: 1, name: 'Alice' }

// Using the 'all' method to retrieve all rows.
const allUsers = sql.all`SELECT * FROM users ORDER BY id`;
console.log(allUsers);
// [
//   { id: 1, name: 'Alice' },
//   { id: 2, name: 'Bob' }
// ]

Die Querys werden intern prepared und in einem LRU-Cache abgelegt. In den Docs steht leider nicht, wie man Arrays oder Sub-Querys ĂŒbergibt. Das wird sicher bald bei den Typen nachgereicht.

Heute im Changelog von Bun gesehen: Node.js hat eine Histogram-API: createHistogram:

import { createHistogram } from "perf_hooks";

// Create a histogram that can record values between 1 and 1,000,000,
// maintaining 3 significant figures of precision.
const histogram = createHistogram({
  lowest: 1,
  highest: 1_000_000,
  figures: 3,
});

histogram.record(100);
histogram.record(200);
histogram.record(1000);
histogram.record(100); // Record a duplicate

console.log("Min:", histogram.min);
console.log("Max:", histogram.max);
console.log("Mean:", histogram.mean);
console.log("Standard Deviation:", histogram.stddev);
console.log("Total Count:", histogram.totalCount);
console.log("Percentile 50 (Median):", histogram.percentile(50));

Bun hat neulich ja einen S3-Client eingebaut (ich habe ĂŒbrigens auch gerade einen veröffentlicht). Jetzt haben sie auch noch einen Redis-Client dazu gelegt.

Matt Pocock hat frohe Kunde verbreitet und angekĂŒndigt, dass in der nĂ€chsten Node-Version das “Strip Types” nicht mehr hinter einem Flag ist. Das heißt, dass Node.js bald nativ TypeScript ausfĂŒhren kann. Die Types werden einfach rausgenommen und alles wie JS interpretiert. D.h. kein TS-Compiler-Check und keine Runtime-Checks. Ersteres ist quasi nicht möglich, ohne TSC in Node.js zu integrieren. Das ist etwas doof, weil TypeScript keine Spec hat, sondern nur eine Referenzimplementierung. Runtime-Checks haben dasselbe Problen und manche Typen sind in TS so komplex, dass allein das Type-Checken bspw. eines Funktionsparameters mehr Zeit in Anspruch nehmen kann, als die eigentliche Funktion. Insoweit gut, dass beides kein Teil hiervon ist.

Was bei ihm aber nicht steht und was durchaus wichtig ist:

Imports mĂŒssen auf .ts enden

Das geht gegen die bisherige Vorgehensweise von Node-Devs bei JS (die haben ĂŒblicherweise die Erweiterung weggelassen) und gegen die Empfehlung von TypeScript selbst (.js verwenden, auch, wenn es eine .ts-Datei ist). Die Empfehlung der TS-Leute ist aligned mit dem, was tatsĂ€chlich iim ESM-Standard steht. TypeScript hat bisher auch darauf verzichtet, Import-Pfade umzuschreiben.

Bun hat hierfĂŒr einen Resolution-Algorithmus, der bei einem Import von ./foo von ./foo.js ĂŒber ./foo.ts und ./foo.mts etc alles absucht. Hier kann es zu unerwartetem Verhalten kommen, wenn eine ./foo.js und eine ./foo.ts existiert. Aber hier ist es immerhin möglich, seine Imports zu lassen, wie sie sind. tsx (ein Node-Wrapper, der Ă€hnlich wie die jetzige Implementierung von Node-Type-Stripping funktioniert) kann das auch.

Path-Aliase

Node möchte hier jetzt .ts in Imports. TypeScript hat in den sauren Apfel gebissen und 2 Compiler-Flags dafĂŒr eingebaut: allowImportingTsExtensions und rewriteRelativeImportExtensions. Ersteres erlaubt .ts in imports. Letzteres macht nach dem Kompilieren ein .js aus .ts. Das ist praktisch, um nach dem Kompilieren noch validen JS-Code zu haben, denn sonst wĂŒrde dort in den Imports js .ts stehen.

Was nicht umgeschrieben wird, sind nicht-relative imports. D. h. alle Imports, die nicht mit ./ oder ../ beginnen, bleiben so.

Manche Projekte haben einen "#/*"-Path-Alias, der auf das Root-Verzeichnis des Projekts zeigt. Falls ihr das habt, könnt ihr also nicht auf Node.js mit TS-DirektausfĂŒhrung migrieren. DafĂŒr braucht man dann noch irgendeinen extra-loader wie bisher auch. Oder ihr benutzt Bun oder tsx. Damit das funktioniert, muss Node.js die tsconfig.json lesen und verarbeiten. Ich denke aktuell, dass das zu komplex wĂ€r, dass das Node-Team das umsetzt.

Bisher wird es auch dabei bleiben.

Also insgesamt leider noch ein ferner Traum, dass man TS fĂŒr bestehende Projekte einfach mit Node.js direkt ausfĂŒhren kann. DafĂŒr braucht man immer noch einen modifizierten Loader, bun, Deno, ts-node oder tsx.

Ich hab jetzt mal Node.js selbst gebaut, um das Feature mit der TS-AusfĂŒhrung zu testen und bin positiv ĂŒberrascht vom Bauprozess. Es ist:

git clone https://github.com/nodejs/node
cd node
./configure
make -j24

Es funktioniert einfach. Neben GCC und GNU/Make braucht man noch ein supportetes Python. Sind jetzt keine krassen Anforderungen. Hat (bis jetzt) auch noch keine Magic gemacht und irgendwelche Sachen aus dem Internet geladen oder global installiert.

Node.js kann bald TypeScript. Damit wĂ€re der grĂ¶ĂŸte Vorteil von Bun in Node.

Node.js kann jetzt SQLite. FĂŒr die WebStorage-API neulich haben sie es ja schon eingebaut. Jetzt exposen sie auch die interne API nach außen.

import { DatabaseSync } from 'node:sqlite';
const database = new DatabaseSync(':memory:');

// Execute SQL statements from strings.
database.exec(`
  CREATE TABLE data(
    key INTEGER PRIMARY KEY,
    value TEXT
  ) STRICT
`);
// Create a prepared statement to insert data into the database.
const insert = database.prepare('INSERT INTO data (key, value) VALUES (?, ?)');
// Execute the prepared statement with bound values.
insert.run(1, 'hello');
insert.run(2, 'world');

Sieht nur semi-kompatible mit dem SQLite von Bun aus.

Node.js 22.4.0 ist da und hat die Web Storage API hinter einem Flag. Bei Node kann man also jetzt localStorage und sessionStorage benutzen.

Ich habe ein bisschen damit gespielt.

Der sessionStorage ist fĂŒr eine Programmlaufzeit gĂŒltig. Ist also nach einem Neustart weg. localStorage geht auch ĂŒber Neustarts hinweg. DafĂŒr muss man aber eine explizite Datei angeben: node --localstorage-file foo. Die Datei ist einfach eine SQLIte-Datenbank (wie die anderen Browser das intern auch machen):

$ echo 'localStorage.setItem("hallo", "welt")' | node --experimental-webstorage --localstorage-file foo

$ sqlite3 foo 'select * from nodejs_webstorage'
key    value
-----  -----
hallo  welt

Ist also eine super Alternative fĂŒr Key-Value-Storage, wenn man nicht extra SQLite installieren will.

Storage Events scheinen (noch?) nicht zu funktionieren. Da wÀr auch die Frage, ob die bei localStorage nur innerhalb des selben Prozesses funktionieren, oder ob alle Node-Instanzen da kommunizieren, wenn sie einen Wert in dieselbe Datenbank schreiben.

Deno hat gerade eine Version mit der Temporal API geshippt. Das war schon sehr lange in Stage 3, aber durch AbhĂ€ngigkeit zu anderen Prozesse durften noch keine Implementierungen ohne Feature-Flag geshippt werden. Vor drei Wochen wurde der Hinweis dazu entfernt. Deno dĂŒrfte damit die erste Plattform sein, die es hat.

Hoffentlich ziehen die anderen nach, die API ist lange ĂŒberfĂ€llig.

Edit: Bei Deno ist es noch hinter einem Flag: --unstable-temporal. Ich glaube, sie sind trotzdem die ersten, die es ĂŒberhaupt shippen.

Bun kann mittlerweile nicht nur Rust und sonst irgendwie alles importieren, sondern auch SQLite-Datenbanken:

import db from './my.db' with { type: "sqlite" };

const { id } = db
  .query("SELECT id FROM users LIMIT 1")
  .get();

console.log(id); // 1

Man kann mit Bun seine Anwendung ja auch in eine einzige Binary bundlen. Wenn man das macht beim obigen, muss beim AusfĂŒhren die DB im aktuellen Verzeichnis liegen. Man kann die DB aber auch in dei Binary embedden:

import db from './my.db'
          with {
            type: "sqlite",
            // Embed the database into the executable
            embed: "true"
          };

const { id } = db
  .query("SELECT id FROM users LIMIT 1")
  .get();

console.log(id); // 1

Ob die DB da aber nur im Readonly-Modus geöffnet wird, wird im Blog nicht beschrieben. Ich gehe mla davon aus.

Node.js 21[hinweis].

Gibt keine wirklich spannenden Updates. Mein Highlight ist das hier: > A new experimental flag to flip module defaults (–experimental-default-type) – Node.js has two module systems: CommonJS modules and ECMAScript modules. Node.js treats files with a .js extension by default as CommonJS modules. This can now more easily be flipped.

Damit kann man jetzt immerhin ESM-Dateien ausfĂŒhren, ohne eine package.json anzulegen.

Node 20.6 ist da und kann nativ .env-Files laden. Damit kann man in einfachen FĂ€llen das dotenv-Package rauswerfen. Nicht nur das, denn die Env-File wird von Node selbst geladen, nicht von der Anwendung. Das heißt, damit kann man auch Env-Vars setzen, die das Verhalten von Node selbst beeinflussen (z. B. NODE_OPTIONS).

Node.js bekommt ein Permission-System, Àhnlich zu dem von Deno. Damit kann man Zugriff auf das Dateisystem oder Netzwerk einschrÀnken.

Falls es nicht nur an mir vorbei ging: Node.js 19.

npm 9 ist da.

Es gibt in HTTP nicht nur Header, sondern auch Trailer. Damit kann man Infos nachgelagert an den Client senden.

Wie es aussieht, implementieren die Browser das aber nur fĂŒr HTTP2+. Auf CanIUse sieht es merkwĂŒrdig aus.

Gefunden habe ich dies in diesem Artikel ĂŒber HTTP-Features[hinweis]. Dort wird auch ein Beispiel geliefert, wie die Trailer verwendet werden können, um Analyse-Timings an den Client auszuliefern:

const server = http.createServer(async function (req, res) {
  res.writeHead(200, {
    "Content-Type": "application/json",
    Trailer: "Server-Timing",
  });

  const dbStart = performance.now();
  const data = await db.getData();
  const dbTime = performance.now() - dbStart;

  res.write(JSON.stringify(data));

  res.addTrailers({ "Server-Timing": `db;dur=${dbTime}` });

  res.end();
});

Node.js bekommt ein rudimentĂ€res Command-Line-Parsing. Damit wĂ€ren fĂŒr viele kleineren Tools keine librarys mehr notwendig.

Node.js bekommt built-in Test-Runner[hinweis]. Aus dem Post:

const test = require('node:test');
const assert = require('assert');

test('synchronous passing test', (t) => {
  // This test passes because it does not throw an exception.
  assert.strictEqual(1, 1);

});

Wann kommt es?

Colin, the architect behind this initiative, has indicated that it will be available behind an experimental flag when Node 18 is pushed out, which is currently scheduled for April 19th.

It’s also available in nightly builds released after the 24th of March, 2022.

Wo wir gerade bei Node.js waren. Wir hatten schon ein paar mal den AbortController hier. Da gibt es jetzt eine Convenience-Method: AbortSignal.timeout(delay).

Node.js kann die ab Version 17 und 16.14.

Node.js kann jetzt Deep-Copys machen. Funktioniert mit structuredClone[hinweis], was auch die Browser schon können.

Nie wieder JSON.parse(JSON.stringify(a)) und sich ĂŒber kaputte Dates Ă€rgern.

Bei Node.js-Imports kann man jetzt node: als Protokoll vor ein Paketnamen schreiben[hinweis], um zu verdeutlichen, dass es ein Node-Builtin-Modul ist.

Ich habe heute gelernt, dass man bei npm init einen weiteren Parameter ĂŒbergeben kann, einen Initializer. Das ist ein Wrapper, der solche Dinge wie create-react-app automatisch ausfĂŒhrt. Ohne den Parameter nennt man das anscheinend “legacy init”.

Beispiel: FĂŒr ein ESM-kompatibles npm-Projekt macht man dann npm init esm (es wird create-esm ausgefĂŒhrt).

Node.js 17.

Neu:

import * as readline from 'node:readline/promises';
import { stdin as input, stdout as output } from 'process';

const rl = readline.createInterface({ input, output });

const answer = await rl.question('What do you think of Node.js? ');

console.log(`Thank you for your valuable feedback: ${answer}`);

rl.close();

Aus meiner HTML-/JS-Quicktips-Reihe: Es gibt eine coole, neue URL-API.

Node.js hat eine API fĂŒr einen asynchronen LocalStorage bekommen. Mal schauen, was es fĂŒr coole Use-Cases es fĂŒr den asyncLocalStorage gibt. Erinnert ein bisschen an Reacts useContext().

Falls Ihr Node.js/JavaScript und Promises verwendet: Diesen Talk solltet Ihr gesehen haben. Schickt ihn am besten auch an Eure Kollegen. PrÀmisse: Ihr benutzt wahrscheinlich Promises falsch. Kann man auch auf 1.25-facher Geschwindigkeit schauen.

Node.js 16 ist da

Spannende Neuerungen: Eigentlich keine.

Wer öfters mit Node.js und im Browser arbeitet, der wird on() bei Node.js und addEventListener() im Browser kennen.

Oft möchte man aber nur ein einziges Mal auf ein Event reagieren. Bei Node.js gibt es dafĂŒr once(). VerhĂ€lt sich wie on(), wird aber nur ein Mal aufgerufen.

Bisher dachte ich, dass man das bei addEventListener() immer manuell machen musste. Es geht aber so:

element.addEventListener("click", () => {}, {
    once: true,
});

MDN dazu

FĂŒr die console.log-Debugger: In JS gibt es console.table(), um Arrays (oder auch Objekte, wenn man will) darzustellen (MDN dazu):

console.table(["apples", "oranges", "bananas"]);

Funktioniert im Browser und in Node.js. Bei Node bekommt man diese Ausgabe:

Welcome to Node.js v15.11.0.
> // Bei Arrays:
> console.table(["apples", "oranges", "bananas"]);
┌─────────┬───────────┐
│ (index) │  Values   │
├─────────┌────────────
│    0    │ 'apples'  │
│    1    │ 'oranges' │
│    2    │ 'bananas' │
└─────────┮───────────┘

> // Bei Objekten:
> console.table({firstName: "Anders", lastName: "Hejlsberg"})
┌───────────┬─────────────┐
│  (index)  │   Values    │
├───────────┌──────────────
│ firstName │  'Anders'   │
│ lastName  │ 'Hejlsberg' │
└───────────┮─────────────┘

// Bei Arrays von Objekten:
> console.table([{firstName: "Anders", lastName: "Hejlsberg"}, {firstName: "Guido", lastName: "van Rossum"}])
┌─────────┬───────────┬──────────────┐
│ (index) │ firstName │   lastName   │
├─────────┌───────────┌───────────────
│    0    │ 'Anders'  │ 'Hejlsberg'  │
│    1    │  'Guido'  │ 'van Rossum' │
└─────────┮───────────┮──────────────┘

Zum Debuggen oder einfache Skriptausgabe reicht’s. Und bei Node.js hab ich auch schon ein NPM-Paket fĂŒr Tabellen in der Konsole damit abgelöst.