ts node
1.0.0
TypeScript -Ausführung und Repl für node.js, mit Quellkarte und nativem ESM -Unterstützung.
Die neueste Dokumentation finden Sie auch auf unserer Website: https://typestong.org/ts-node
nodeTSErrorSyntaxErrorERR_REQUIRE_ESMERR_UNKNOWN_FILE_EXTENSIONnode_modulesTS-NODE ist eine TypeScript-Ausführungs-Engine und Repling für Node.js.
Es transformiert TypeScript in JavaScript und ermöglicht es Ihnen, Typscript direkt auf Node.js ohne Vorkompetenz auszuführen. Dies wird erreicht, indem das Modul des Knotens das Laden von APIs anhängt, sodass es neben anderen Knoten -Js -Tools und -Bibliotheken nahtlos verwendet werden kann.
tsconfig.json Parsing
# Locally in your project.
npm install -D typescript
npm install -D ts-node
# Or globally with TypeScript.
npm install -g typescript
npm install -g ts-node
# Depending on configuration, you may also need these
npm install -D tslib @types/node TIPP: Installieren von Modulen lokal können Sie die Versionen über package.json steuern und freigeben. TS-NODE wird den Compiler immer von cwd auflösen, bevor er sich in Bezug auf seine eigene Installation überprüft.
# Execute a script as `node` + `tsc`.
ts-node script.ts
# Starts a TypeScript REPL.
ts-node
# Execute code with TypeScript.
ts-node -e ' console.log("Hello, world!") '
# Execute, and print, code with TypeScript.
ts-node -p -e ' "Hello, world!" '
# Pipe scripts to execute with TypeScript.
echo ' console.log("Hello, world!") ' | ts-node
# Equivalent to ts-node --transpileOnly
ts-node-transpile-only script.ts
# Equivalent to ts-node --cwdMode
ts-node-cwd script.ts
# Equivalent to ts-node --esm
ts-node-esm script.ts Um Skripte mit maximaler Portabilität zu schreiben, geben Sie Optionen in Ihrem tsconfig.json an und lassen Sie sie vom Shebang weg.
#!/usr/bin/env ts-node
// ts-node options are read from tsconfig.json
console . log ( "Hello, world!" ) Das Einschließen von Optionen in das Shebang erfordert das env -S -Flag, das für neuere Versionen von env verfügbar ist. (Kompatibilität)
#!/usr/bin/env -S ts-node --files
// This shebang works on Mac and Linux with newer versions of env
// Technically, Mac allows omitting `-S`, but Linux requires it Um Ihre Version von env auf Kompatibilität mit -S zu testen:
# Note that these unusual quotes are necessary
/usr/bin/env --debug ' -S echo foo bar ' Sie können TS-NODE registrieren, ohne unsere CLI: node -r ts-node/register und node --loader ts-node/esm zu verwenden
In vielen Fällen ermöglicht das Einstellen NODE_OPTIONS ts-node in anderen Knoten-Tools, untergeordneten Prozessen und Worker-Threads. Dies kann mit anderen Knotenflags kombiniert werden.
NODE_OPTIONS= " -r ts-node/register --no-warnings " node ./index.tsOder wenn Sie einen nativen ESM -Unterstützung benötigen:
NODE_OPTIONS= " --loader ts-node/esm " Dadurch werden alle Knotenprozesse angezeigt, die diese Umgebungsvariable empfangen, um die Hooks von ts-node zu installieren, bevor Sie einen anderen Code ausführen.
Wenn Sie direkt den Knoten aufrufen, können Sie die Umgebungsvariable vermeiden und diese Flags an den Knoten übergeben.
node --loader ts-node/esm --inspect ./index.ts Sie können TS-NODE benötigen und den Loader für die zukünftige Anforderungen registrieren, indem require('ts-node').register({ /* options */ }) .
Weitere Funktionen finden Sie in unserer API.
TS-NODE unterstützt eine Vielzahl von Optionen, die über tsconfig.json , als CLI-Flags, als Umgebungsvariablen oder programmatisch angegeben werden können.
Eine vollständige Liste finden Sie in Optionen.
TS-Knoten-CLI-Flags müssen vor dem Einstiegspunkt-Skript kommen. Zum Beispiel:
$ ts-node --project tsconfig-dev.json say-hello.ts Ronald
Hello, Ronald ! TS-NODE findet und lädt automatisch tsconfig.json . Die meisten TS-Knotenoptionen können in einem "ts-node" -Objekt unter Verwendung ihrer programmatischen Kamelcase-Namen angegeben werden. Wir empfehlen dies, weil es auch dann funktioniert, wenn Sie node --require ts-node/register CLI-Flags übergeben können, z.
Verwenden Sie --skipProject , um das Laden von tsconfig.json zu überspringen. Verwenden Sie --project , um den Pfad explizit zu einem tsconfig.json anzugeben.
Bei der Suche wird es mit demselben Suchverhalten wie tsc behoben. Standardmäßig wird diese Suche relativ zum Einstiegspunkt -Skript durchgeführt. In --cwdMode oder wenn kein Eintragspunkt angegeben ist -beispielsweise bei Verwendung der Repl -, wird die Suche relativ zu --cwd / process.cwd() durchgeführt.
Sie können diese Beispielkonfiguration als Ausgangspunkt verwenden:
{
// This is an alias to @tsconfig/node16: https://github.com/tsconfig/bases
"extends" : "ts-node/node16/tsconfig.json" ,
// Most ts-node options can be specified here using their programmatic names.
"ts-node" : {
// It is faster to skip typechecking.
// Remove if you want ts-node to do typechecking.
"transpileOnly" : true ,
"files" : true ,
"compilerOptions" : {
// compilerOptions specified here will override those declared below,
// but *only* in ts-node. Useful if you want ts-node and tsc to use
// different options with a single tsconfig.json.
}
} ,
"compilerOptions" : {
// typescript options here
}
}Unser gebündeltes JSON -Schema listet alle kompatiblen Optionen auf.
@Tsconfig/Basen verwaltet die empfohlenen Konfigurationen für mehrere Knotenversionen. Als Bequemlichkeit werden diese mit TS-Knoten gebündelt.
{
"extends" : "ts-node/node16/tsconfig.json" ,
// Or install directly with `npm i -D @tsconfig/node16`
"extends" : "@tsconfig/node16/tsconfig.json" ,
} Wenn kein tsconfig.json von der Festplatte geladen wird, verwendet TS-NODE die neuesten empfohlenen Standardeinstellungen von @Tsconfig/Bases, die mit Ihren node und typescript Versionen kompatibel sind. Mit dem neuesten node und typescript ist dies @tsconfig/node16 .
Ältere Versionen von typescript sind mit @tsconfig/node16 unvereinbar. In diesen Fällen verwenden wir eine ältere Standardkonfiguration.
Im Zweifelsfall protokolliert ts-node --showConfig die verwendete Konfiguration, und ts-node -vv protokolliert node und typescript Versionen.
node node müssen direkt an node übergeben werden. Sie können weder an den TS-Knoten-Binär übergeben werden noch in tsconfig.json angegeben werden
Wir empfehlen, die Umgebungsvariable NODE_OPTIONS zu verwenden, um Optionen an node zu übergeben.
NODE_OPTIONS= ' --trace-deprecation --abort-on-uncaught-exception ' ts-node ./index.ts Alternativ können Sie node direkt aufrufen und TS -NODE über --require / -r installieren
node --trace-deprecation --abort-on-uncaught-exception -r ts-node/register ./index.ts Alle Befehlszeilenflags unterstützen sowohl --camelCase als auch --hyphen-case .
Die meisten Optionen können in Ihrem tsconfig.json: Konfiguration über tsconfig.json deklariert werden
ts-node unterstützt --print ( -p ), --eval ( -e ), --require ( -r ) und --interactive ( -i ) ähnlich dem Node.js cli.
ts-node unterstützt --project und --showConfig ähnlich dem TSC CLI.
Umgebungsvariablen, sofern verfügbar, befinden sich in ALL_CAPS
ts-node --helpDruckt den Hilfstext
ts-node -v
ts-node -vvv Druckt die Version. -vv enthält Knoten- und Typscript -Compiler -Versionen. -vvv enthält absolute Pfade zu TS-NODE- und Typscript-Installationen.
ts-node -e < typescript code >
# Example
ts-node -e ' console.log("Hello world!") 'Code bewerten
ts-node -p -e < typescript code >
# Example
ts-node -p -e ' "Hello world!" ' Druckergebnis von --eval
ts-node -iÖffnet die Wiederholung, auch wenn Stdin kein Terminal zu sein scheint
ts-node --esm
ts-node-esmBootstrap mit dem ESM -Loader und ermöglicht die vollständige ESM -Unterstützung
ts-node -P < path/to/tsconfig >
ts-node --project < path/to/tsconfig >Pfad zur Tsconfig -Datei.
Beachten Sie den Großbuchstaben -P . Dies unterscheidet sich von -p/--project von tsc .
Umgebung: TS_NODE_PROJECT
ts-node --skipProjectÜberspringen Sie die Auflösung und das Laden von Projektkonfigurationen
Standard: false
Umgebung: TS_NODE_SKIP_PROJECT
ts-node -c
ts-node --cwdMode
ts-node-cwdKonfiguration relativ zum aktuellen Verzeichnis anstelle des Verzeichnisses des Einstiegspunkt -Skripts auflösen
ts-node -O < json compilerOptions >
ts-node --compilerOptions < json compilerOptions >JSON -Objekt, um mit Compiler -Optionen zusammenzuarbeiten
Umgebung: TS_NODE_COMPILER_OPTIONS
ts-node --showConfig Drucken Sie gelöst tsconfig.json , einschließlich ts-node -Optionen, und beenden Sie
ts-node -T
ts-node --transpileOnly Verwenden Sie die schnellere transpileModule von TypeScript
Standard: false
Umgebung: TS_NODE_TRANSPILE_ONLY
ts-node --typeCheck Gegenteil von --transpileOnly
Standard: true
Umgebung: TS_NODE_TYPE_CHECK
ts-node -H
ts-node --compilerHostVerwenden Sie die Compiler -Host -API von TypeScript
Standard: false
Umgebung: TS_NODE_COMPILER_HOST
ts-node --files Laden Sie files , include und exclude von tsconfig.json zum Start. Dies kann bestimmte typechende Fehler vermeiden. Weitere Informationen finden Sie in fehlenden Typen.
Standard: false
Umgebung: TS_NODE_FILES
ts-node -D < code,code >
ts-node --ignoreDiagnostics < code,code >Ignorieren
Umgebung: TS_NODE_IGNORE_DIAGNOSTICS
ts-node -I < regexp matching ignored files >
ts-node --ignore < regexp matching ignored files >Überschreiben Sie die Pfadmuster, um die Kompilierung zu überspringen
Standard: /node_modules/
Umgebung: TS_NODE_IGNORE
ts-node --skipIgnoreÜberspringen Sie Ignorieren Sie Schecks
Standard: false
Umgebung: TS_NODE_SKIP_IGNORE
ts-node -C < name >
ts-node --compiler < name >Geben Sie einen benutzerdefinierten TypeScript -Compiler an
Standard: typescript
Umgebung: TS_NODE_COMPILER
ts-node --swc Mit SWC transpilieren. Impliziert --transpileOnly
Standard: false
ts-node --transpiler < name >
# Example
ts-node --transpiler ts-node/transpilers/swcVerwenden Sie einen nicht-typschechnischen Transpiler von Drittanbietern
ts-node --preferTsExtsDateiverlängerungen nachbestellen, damit TypeScript-Importe bevorzugt werden
Standard: false
Umgebung: TS_NODE_PREFER_TS_EXTS
ts-node --logErrorProtokolliert TypeScript -Fehler bei Stderr anstatt Ausnahmen zu werfen
Standard: false
Umgebung: TS_NODE_LOG_ERROR
ts-node --prettyVerwenden Sie hübsches diagnostisches Formatierer
Standard: false
Umgebung: TS_NODE_PRETTY
TS_NODE_DEBUG=true ts-nodeAktivieren Sie die Debug -Protokollierung
ts-node -r < module name or path >
ts-node --require < module name or path >Erfordern Sie vor der Ausführung ein Knotenmodul
ts-node --cwd < path/to/directory >Verhalten Sie sich wie in diesem Arbeitsverzeichnis aufgerufen
Standard: process.cwd()
Umgebung: TS_NODE_CWD
ts-node --emit Senden Sie Ausgabedateien in das Verzeichnis .ts-node aus. Benötigt --compilerHost
Standard: false
Umgebung: TS_NODE_EMIT
ts-node --scope Scope Compiler für Dateien innerhalb von scopeDir . Alles außerhalb dieses Verzeichnisses wird ignoriert.
Standard: false
Umgebung: TS_NODE_SCOPE
ts-node --scopeDir < path/to/directory > Verzeichnis, in dem Compiler begrenzt ist, wenn scope aktiviert ist.
Standard: Erster von: tsconfig.json "rootDir", falls angegeben, Verzeichnis mit tsconfig.json oder cwd, wenn keine tsconfig.json geladen wird.
Umgebung: TS_NODE_SCOPE_DIR
Überschreiben Sie den Modultyp bestimmter Dateien und ignorieren Sie das Feld " package.json "type" . Weitere Informationen finden Sie unter Modultypüberschreibungen.
Standard: folgt package.json "type" und tsconfig.json "module"
Kann nur über tsconfig.json oder api angegeben werden.
TS_NODE_HISTORY= < path/to/history/file > ts-nodePfad zur Verlaufsdatei für Reply
Standard: ~/.ts_node_repl_history
ts-node --noExperimentalReplAwait Deaktivieren Sie in Repl. Entspricht den Node --no-experimental-repl-await
Standard: Aktiviert, wenn die TypeScript -Version 3.8 oder höher ist und das Ziel ES2018 oder höher ist.
Umgebung: TS_NODE_EXPERIMENTAL_REPL_AWAIT setzen Sie false , um deaktiviert zu werden
Aktivieren Sie experimentelle Haken, die Importe neu machen und Anrufe zur Unterstützung erfordern:
import "./foo.js" wird foo.ts ausführen. Derzeit werden die folgenden Erweiterungen abgebildet:.js zu .ts , .tsx oder .jsx.cjs zu .cts.mjs zu .mts.jsx zu .tsxIn Zukunft wird dieser Haken auch unterstützen:
baseUrl , pathsrootDirsoutDir to rootDir Mappings für zusammengesetzte Projekte und MonoreposWeitere Informationen finden Sie unter #1514.
Standard: false , wird aber wahrscheinlich standardmäßig in einer zukünftigen Version aktiviert
Kann nur über tsconfig.json oder api angegeben werden.
ts-node --experimentalSpecifierResolution node Wie Node's --experimental-specifier-resolution , kann aber auch zur Bequemlichkeit in Ihrem tsconfig.json festgelegt werden. Erfordert, dass esm aktiviert werden kann.
Standard: explicit
Die API enthält zusätzliche Optionen, die hier nicht angezeigt werden.
Die SWC-Unterstützung wird über das Flag --swc oder "swc": true TsConfig-Option eingebaut.
SWC ist ein in Rost implementiertes TypeScript-kompatibler Transpiler. Dies macht es zu einer Größenordnung schneller als Vanille transpileOnly .
Um es zu verwenden, installieren Sie zuerst @swc/core oder @swc/wasm . Wenn Sie importHelpers verwenden, installieren Sie auch @swc/helpers . Wenn target kleiner als "ES2015" ist und async / await oder Generatorfunktionen verwendet, installieren Sie auch regenerator-runtime .
npm i -D @swc/core @swc/helpers regenerator-runtime Fügen Sie dann Folgendes zu Ihrem tsconfig.json hinzu.
{
"ts-node" : {
"swc" : true
}
}SWC verwendet
@swc/helpersanstelle vontslib. Wenn SieimportHelpersaktiviert haben, müssen Sie auch@swc/helpersinstallieren.
TypeScript wird fast immer unter Verwendung der modernen import geschrieben, aber es wird auch transformiert, bevor sie von der zugrunde liegenden Laufzeit ausgeführt wird. Sie können sich entweder in CommonJs verwandeln oder die native import unter Verwendung der nativen ESM -Unterstützung des Knotens erhalten. Die Konfiguration ist jeweils unterschiedlich.
Hier ist ein kurzer Vergleich der beiden.
| Commonjs | Native ECMascript -Module |
|---|---|
Schreiben Sie native import | Schreiben Sie native import |
Transformiert import in require() | Transformiert import nicht |
| Knoten führt Skripte mit dem klassischen CommonJS -Loader aus | Knoten führt Skripte mit dem neuen ESM -Loader aus |
Verwenden Sie eine von:ts-nodenode -r ts-node/registerNODE_OPTIONS="ts-node/register" noderequire('ts-node').register({/* options */}) | Verwenden Sie eine von:ts-node --esmts-node-esmSetzen Sie "esm": true in tsconfig.jsonnode --loader ts-node/esmNODE_OPTIONS="--loader ts-node/esm" node |
Die Umwandlung in CommonJs ist typischerweise einfacher und häufiger unterstützt, da es älter ist. Sie müssen "type": "module" von package.json und "module": "CommonJS" in tsconfig.json entfernen.
{
// This can be omitted; commonjs is the default
"type" : "commonjs"
} {
"compilerOptions" : {
"module" : "CommonJS"
}
} Wenn Sie "module": "ESNext" für tsc , WebPack oder ein anderes Build-Tool behalten müssen, können Sie eine Überschreibung für TS-NODE festlegen.
{
"compilerOptions" : {
"module" : "ESNext"
} ,
"ts-node" : {
"compilerOptions" : {
"module" : "CommonJS"
}
}
} Die ESM -Laderhaken des Knotens sind experimentell und ändern sich. Die ESM-Unterstützung von TS-Node ist so stabil wie möglich, stützt sich jedoch auf APIs, die Node in neuen Versionen des Knotens einbrechen können und wird . Daher wird es für die Produktion nicht empfohlen.
Für die vollständige Nutzung, Einschränkungen und Feedback finden Sie #1007.
Sie müssen "type": "module" in package.json und "module": "ESNext" in tsconfig.json .
{
"type" : "module"
} {
"compilerOptions" : {
"module" : "ESNext" // or ES2015, ES2020
} ,
"ts-node" : {
// Tell ts-node CLI to install the --loader automatically, explained below
"esm" : true
}
} Sie müssen auch sicherstellen, dass der Knoten übergeben wird --loader . Die TS-Knoten-CLI erledigt dies automatisch mit unserer esm Option.
HINWEIS:
--esmmuss einen Kinderprozess hervorbringen, um es zu bestehen--loader. Dies kann sich ändern, wenn der Knoten die Möglichkeit hinzufügt, Laderhaken in den aktuellen Prozess zu installieren.
# pass the flag
ts-node --esm
# Use the convenience binary
ts-node-esm
# or add `"esm": true` to your tsconfig.json to make it automatic
ts-nodeWenn Sie unsere CLI nicht verwenden, übergeben Sie das Laderflag zum Knoten.
node --loader ts-node/esm ./index.ts
# Or via environment variable
NODE_OPTIONS= " --loader ts-node/esm " node ./index.ts TS-NODE verwendet vernünftige Standardkonfigurationen, um die Kesselplatte zu reduzieren und gleichzeitig tsconfig.json zu respektieren, wenn Sie eine haben. Wenn Sie sich nicht sicher sind, welche Konfiguration verwendet wird, können Sie sie mit ts-node --showConfig protokollieren. Dies ist ähnlich wie tsc --showConfig , enthält jedoch auch "ts-node" -Optionen.
TS-NODE respektiert auch Ihre lokal installierte typescript Version, die globalen Installationen fällt jedoch auf das global installierte typescript zurück. Wenn Sie sich nicht sicher sind, welche Versionen verwendet werden, protokolliert ts-node -vv sie.
$ ts-node -vv
ts-node v10.0.0
node v16.1.0
compiler v4.2.2
$ ts-node --showConfig
{
" compilerOptions " : {
" target " : " es6 " ,
" lib " : [
" es6 " ,
" dom "
],
" rootDir " : " ./src " ,
" outDir " : " ./.ts-node " ,
" module " : " commonjs " ,
" moduleResolution " : " node " ,
" strict " : true,
" declaration " : false,
" sourceMap " : true,
" inlineSources " : true,
" types " : [
" node "
],
" stripInternal " : true,
" incremental " : true,
" skipLibCheck " : true,
" importsNotUsedAsValues " : " error " ,
" inlineSourceMap " : false,
" noEmit " : false
},
" ts-node " : {
" cwd " : " /d/project " ,
" projectSearchDir " : " /d/project " ,
" require " : [],
" project " : " /d/project/tsconfig.json "
}
} Es ist wichtig, zwischen Fehlern von TS-Knoten, Fehlern vom TypeScript-Compiler und Fehlern vom node zu unterscheiden. Es ist auch wichtig zu verstehen, wann Fehler durch einen Typfehler in Ihrem Code, einen Fehler in Ihrem Code oder einen Fehler in Ihrer Konfiguration verursacht werden.
TSError Typ -Fehler aus dem Compiler werden als TSError geworfen. Dies sind die gleichen wie Fehler, die Sie von tsc erhalten.
SyntaxError Jeder Fehler, der kein TSError ist, stammt von Node.js (EG SyntaxError ) und kann nicht durch Typscript oder TS-NODE fixiert werden. Dies sind Fehler in Ihrem Code oder Ihrer Konfiguration.
Ihre Version des node unterstützt möglicherweise nicht alle JavaScript -Syntax, die von TypeScript unterstützt werden. Der Compiler muss diese Syntax über "Downleveling" transformieren, die von der Option "target" von Tsconfig gesteuert wird. Andernfalls wird Ihr Code gut kompiliert, aber der Knoten wirft eine SyntaxError .
Zum Beispiel versteht node 12 das nicht ?. Optionaler Kettenbetreiber. Wenn Sie "target": "esnext" , dann die folgende Typscript -Syntax:
const bar : string | undefined = foo ?. bar ;wird in dieses JavaScript kompilieren:
const a = foo ?. bar ; Wenn Sie versuchen, diesen Code auszuführen, werfen Node 12 eine SyntaxError . Um dies zu beheben, müssen Sie zu "target": "es2019" oder niedriger, damit TypeScript transformiert ?. in etwas node kann verstehen.
ERR_REQUIRE_ESM Dieser Fehler wird vom Knoten geworfen, wenn ein Modul require() d, aber der Knoten glaubt, dass es als native ESM ausgeführt werden sollte. Dies kann aus einigen Gründen passieren:
webpack.config.ts , die als CommonJS ausgeführt werden müssen.cts umERR_UNKNOWN_FILE_EXTENSIONDieser Fehler wird vom Knoten geworfen, wenn ein Modul eine nicht erkannte Dateierweiterung oder überhaupt keine Erweiterung hat und als native ESM ausgeführt wird. Dies kann aus einigen Gründen passieren:
mocha .ts-node-esm , ts-node --esm oder "ts-node": {"esm": true} zu Ihrem tsconfig.json. Dokumentewebpack.config.ts , die als CommonJS ausgeführt werden müssen.cts um TS-NODE lädt files nicht eifrig, include oder standardmäßig exclude . Dies liegt daran, dass eine große Mehrheit der Projekte nicht alle Dateien in einem Projektverzeichnis (z. B. Gulpfile.ts , Laufzeit und Tests) verwendet und jede Datei für die Typen an die Startzeit verlangsamt. Stattdessen startet TS-NODE mit der Skriptdatei (z. B. ts-node index.ts ) und TypeScript löst Abhängigkeiten basierend auf Importe und Referenzen auf.
Gelegentlich führt diese Optimierung zu fehlenden Typen. Glücklicherweise gibt es andere Möglichkeiten, sie in die typechende Einbeziehung einzubeziehen.
Für globale Definitionen können Sie die Option typeRoots Compiler verwenden. Dies erfordert, dass Ihre Typdefinitionen als Typpakete strukturiert werden (keine losen Typ -Definitionsdateien). Weitere Details dazu finden Sie im Typbuch "Typenschriften".
Beispiel tsconfig.json :
{
"compilerOptions" : {
"typeRoots" : [ "./node_modules/@types" , "./typings" ]
}
}Beispiel Projektstruktur:
<project_root>/
-- tsconfig.json
-- typings/
-- <module_name>/
-- index.d.ts
Beispielmodulerklärungsdatei:
declare module '<module_name>' {
// module definitions go here
} Für Moduldefinitionen können Sie paths verwenden:
{
"compilerOptions" : {
"baseUrl" : "." ,
"paths" : {
"custom-module-type" : [ "types/custom-module-type" ]
}
}
} Eine weitere Option sind Triple-Slash-Richtlinien. Dies kann hilfreich sein, wenn Sie es vorziehen, Ihre compilerOptions nicht zu ändern oder Ihre Typdefinitionen für typeRoots zu strukturieren. Im Folgenden finden Sie ein Beispiel für eine Dreifach-Slash-Richtlinie als relativer Weg in Ihrem Projekt:
/// <reference path="./types/lib_greeter" />
import { Greeter } from "lib_greeter"
const g = new Greeter ( ) ;
g . sayHello ( ) ; Wenn keines der oben genannten Funktionen funktioniert und Sie files verwenden, die Option unserer files include oder exclude können .
Bei der Ausführung von TypeScript mit npx oder yarn dlx befindet sich der Code in einem temporären node_modules -Verzeichnis.
Der Inhalt von node_modules wird standardmäßig ignoriert. Wenn die Ausführung fehlschlägt, aktivieren Sie skipIgnore .
Diese Tricks machen den Ts-Knoten schneller.
Es ist oft besser, als Teil Ihrer Tests oder Linien zu typten. Sie können tsc --noEmit dafür ausführen. In diesen Fällen kann TS-NODE TYPECKING überspringen, was es viel schneller macht.
Um typechend in TS-NODE zu überspringen, machen Sie eine der folgenden:
transpileOnly , um das typecing ohne SWC zu überspringen Wenn Sie unbedingt in Ts-Node tazipiert werden müssen:
require() , die wiederholtes Tippfehler auslösen kann. bevorzugen import--files ; Man kann je nach Projekt schneller seintsc --showConfig ; Stellen Sie sicher, dass alle ausgeführten Dateien enthalten sindskipLibCheck aktivierentypes -Array ein, um das Laden unnötig @types zu vermeiden TS-NODE funktioniert, indem sie Hooks für .ts , .tsx , .js und/oder .jsx Erweiterungen registrieren.
Der node lädt .js , indem er Code von der Festplatte liest und ihn ausführt. Unser Haken wird in der Mitte ausgeführt und den Code von TypeScript in JavaScript verwandelt und das Ergebnis an node zur Ausführung übergeben. Diese Transformation wird Ihren tsconfig.json respektieren, als hätten Sie über tsc zusammengestellt.
Wir registrieren auch einige andere Hooks, um Sourcemaps auf Stapel von Spuren und Remap von .js -Importen auf .ts anzuwenden.
TS-NODE transformiert bestimmte Dateien und ignoriert andere. Wir bezeichnen diesen Mechanismus als "Scoping". Es gibt verschiedene Optionen zum Konfigurieren von Scoping, sodass TS-NODE nur die Dateien in Ihrem Projekt verwandelt.
Warnung:
Eine ignorierte Datei kann weiterhin von node.js. ausgeführt werden. Wenn wir eine Datei ignorieren, transformieren wir sie nicht von TypeScript in JavaScript, verhindern jedoch keine Ausführung.
Wenn eine Datei eine Transformation erfordert, aber ignoriert wird, kann der Knoten sie entweder nicht beheben oder versuchen, sie als Vanille -JavaScript auszuführen. Dies kann zu Syntaxfehlern oder anderen Fehlern führen, da der Knoten weder die Syntax der TypeScript-Typ noch die ECMAScript-Funktionen von Blutungen versteht.
.js und .jsx werden nur transformiert, wenn allowJs aktiviert ist.
.tsx und .jsx werden nur transformiert, wenn jsx aktiviert ist.
Warnung:
Wenn TS-NODE mit
allowJsverwendet wird, werden alle nicht ignorierten JavaScript-Dateien durch TS-NODE transformiert.
node_modules Standardmäßig vermeidet TS-NODE aus drei Gründen das Kompilieren von Dateien in /node_modules/ aus drei Gründen:
Wenn Sie nicht kompiliertes Typenkript in node_modules importieren müssen, verwenden Sie --skipIgnore oder TS_NODE_SKIP_IGNORE um diese Einschränkung zu umgehen.
Wenn eine kompilierte JavaScript -Datei mit demselben Namen wie eine Typscript -Datei vorhanden ist, wird die TypeScript -Datei ignoriert. TS-NODE importiert das vorkompilierte JavaScript.
Verwenden Sie, um die Typscript-Quelle, nicht das vorkompilierte JavaScript, zu erzwingen, um --preferTsExts zu importieren.
Unsere Optionen für scope und scopeDir beschränken die Transformation in Dateien innerhalb eines Verzeichnisses.
Unsere Option ignore ignoriert Dateien, die einem oder mehreren regulären Ausdrücken übereinstimmen.
Sie können TS-NODE zusammen mit Tsconfig-Pfaden verwenden, um Module gemäß dem paths in tsconfig.json zu laden.
{
"ts-node" : {
// Do not forget to `npm i -D tsconfig-paths`
"require" : [ "tsconfig-paths/register" ]
}
} Das offizielle Handbuch für Typscript -Handbuch erläutert den beabsichtigten Zweck für "paths" in "zusätzlichen Modulauflösungsflags".
Der TypsScript -Compiler verfügt über eine Reihe von zusätzlichen Flags, um den Compiler über Transformationen zu informieren , von denen erwartet wird, dass sie den Quellen zur Erzeugung der endgültigen Ausgabe erfolgen.
Es ist wichtig zu beachten, dass der Compiler keine dieser Transformationen ausführt. Es wird nur diese Informationen verwendet, um den Prozess der Lösung eines Modulimports in seine Definitionsdatei zu leiten.
Dies bedeutet, dass "paths" Zuordnungen beschreiben sollen, die das Build -Tool oder die Laufzeit bereits ausführen, um das Build -Tool oder die Laufzeit nicht mitzuteilen, wie Module auflösen. Mit anderen Worten, sie beabsichtigen, dass wir unsere Importe auf eine Weise schreiben, node bereits versteht. Aus diesem Grund ändert TS-NODE das Modulauflösungsverhalten von node nicht, um "paths" -Abzuordnungen zu implementieren.
Einige Projekte erfordern einen Patched TypeScript -Compiler, der zusätzliche Funktionen hinzufügt. Zum Beispiel fügen ttypescript und ts-patch die Möglichkeit hinzu, benutzerdefinierte Transformatoren zu konfigurieren. Dies sind ein Drop-In-Ersatz für das Vanille- typescript -Modul und implementieren dieselbe API.
Fügen Sie beispielsweise ttypescript und ts-transformer-keys zu Ihren tsconfig.json hinzu:
{
"ts-node" : {
// This can be omitted when using ts-patch
"compiler" : "ttypescript"
} ,
"compilerOptions" : {
// plugin configuration is the same for both ts-patch and ttypescript
"plugins" : [
{ "transform" : "ts-transformer-keys/transformer" }
]
}
} TS-NODE unterstützt Drittanbietertranspiler als Plugins. Transpiler wie SWC können TypeScript viel schneller in JavaScript umwandeln als der TypeScript -Compiler. Sie profitieren weiterhin von der automatischen tsconfig.json Discovery, der Sourcemap-Unterstützung und dem globalen TS-Node CLI. Plugins leiten automatisch eine geeignete Konfiguration von Ihrem vorhandenen tsconfig.json ab, wodurch die Projektkesselplatte vereinfacht wird.
Was ist der Unterschied zwischen einem Compiler und einem Transpiler?
Für unsere Zwecke implementiert ein Compiler die API von TypeScript und kann Typecing durchführen. Ein Drittanbieter-Transpiler nicht. Beide transformieren Typscript in JavaScript.
Die transpiler Option ermöglicht die Verwendung von Drittanbieter-Transpiler-Plugins mit TS-Knoten. transpiler muss den Namen eines Moduls erhalten, das require() d. Das eingebaute swc -Plugin wird als ts-node/transpilers/swc freigelegt.
Um beispielsweise ein hypothetisches " @cspotcode/fast-ts-compiler" zu verwenden, installieren Sie ihn zuerst in Ihr Projekt: npm install @cspotcode/fast-ts-compiler
Fügen Sie dann Folgendes zu Ihrem Tsconfig hinzu:
{
"ts-node" : {
"transpileOnly" : true ,
"transpiler" : "@cspotcode/fast-ts-compiler"
}
}Um Ihr eigenes Transpiler -Plugin zu schreiben, überprüfen Sie unsere API -Dokumente.
Plugins werden von TS-Node require() d, sodass sie ein lokales Skript oder ein Knotenmodul sein können, das an NPM veröffentlicht wurde. Das Modul muss eine von unserer TranspilerModule -Schnittstelle beschriebene create exportieren. create wird von TS-NODE beim Start aufgerufen, um eine oder mehrere Transpilerinstanzen zu erstellen. Die Instanzen werden verwendet, um Typenkript in JavaScript zu transformieren.
Für ein funktionierendes Beispiel finden Sie unser gebündeltes SWC-Plugin: https://github.com/typestong/ts-node/blob/main/src/transpilers/swc.ts
Nach Möglichkeit wird empfohlen,
NodeNextoderNode16-Modus von TypeScript anstelle der in diesem Abschnitt beschriebenen Optionen zu verwenden. Einstellen"module": "NodeNext"und die Verwendung der.cts-Dateierweiterung sollte für die meisten Projekte gut funktionieren.
Bei der Entscheidung, wie eine Datei als CommonJS oder natives ECMAScript-Modul kompiliert und ausgeführt werden sollte, übereinstimmt TS-NODE node und tsc Verhalten. Dies bedeutet, dass TypeScript -Dateien gemäß Ihrer Option "module" tsconfig.json transformiert und gemäß den Regeln des Knotens für das Feld "type" package.json " ausgeführt werden. Setzen Sie "module": "NodeNext" und alles sollte funktionieren.
In seltenen Fällen müssen Sie dieses Verhalten für einige Dateien möglicherweise außer Kraft setzen. Einige Tools lesen beispielsweise einen name-of-tool.config.ts und verlangen, dass diese Datei als CommonJS ausgeführt wird. Wenn Sie package.json mit "type": "module" und tsconfig.json mit "module": "esnext" , ist die Konfiguration standardmäßig natives ECMAScript und erhöht einen Fehler. Sie müssen die Konfiguration und alle unterstützenden Skripte zum Ausführen als CommonJS erzwingen.
In diesen Situationen kann unsere Option moduleTypes bestimmte Dateien als CommonJS oder ESM überschreiben. Ähnliches Überschreiben .mjs .cjs .cts indem .mts moduleTypes erzielen den gleichen Effekt für .ts und .js -Dateien und überschreiben auch Ihre tsconfig.json "module" -Konfiguration angemessen.
Das folgende Beispiel fordert TS-NODE an, eine Webpack-Konfiguration als CommonJS auszuführen:
{
"ts-node" : {
"transpileOnly" : true ,
"moduleTypes" : {
"webpack.config.ts" : "cjs" ,
// Globs are also supported with the same behavior as tsconfig "include"
"webpack-config-scripts/**/*" : "cjs"
}
} ,
"compilerOptions" : {
"module" : "es2020" ,
"target" : "es2020"
}
} Jeder Schlüssel ist ein GLOB -Muster mit derselben Syntax wie Tsconfigs "include" -Array. Wenn mehrere Muster derselben Datei übereinstimmen, hat das letzte Muster Vorrang.
cjs -Überstände übereinstimmen die übereinstimmenden Dateien, um als CommonJS zu kompilieren und auszuführen.esm überschreibt die Übereinstimmung mit Dateien, um sie als native ECMascript -Module zu kompilieren und auszuführen.package setzt eines der oben genannten Standard -Verhaltensweisen zurück, das package.json "type" und tsconfig.json "module" -Optionen folgt. Dateien mit einem überschriebenen Modultyp werden mit den gleichen Einschränkungen wie isolatedModules transformiert. Dies wirkt sich nur auf seltene Fälle aus, wie const enum preserveConstEnums
Diese Funktion soll Szenarien ermöglichen, in denen normale compilerOptions und package.json nicht möglich sind. Beispielsweise kann ein webpack.config.ts kein eigenes package.json erhalten, um "type" zu überschreiben. Wo immer möglich, sollten Sie die Konfigurationen traditioneller package.json und tsconfig.json bevorzugen.
Die vollständige API von TS-Knode ist hier dokumentiert: API-Dokumente
Hier sind einige Highlights dessen, was Sie erreichen können:
create() erstellt den Compiler-Dienst von Ts-Knode, ohne Hooks zu registrieren.createRepl() erstellt eine Instanz unseres Reply-Dienstes, sodass Sie Ihre eigenen typecript-angetriebenen Repliten erstellen können.createEsmHooks() erstellt unsere ESM -Laderhaken, die zum Komponieren mit anderen Ladern geeignet sind oder mit zusätzlichen Funktionen erweitert werden.TS-NODE konzentriert sich auf das Hinzufügen von erstklassigem Typecript-Unterstützung zum Knoten. Das Ansehen von Dateien und Code -Nachladen ist für das Projekt nicht mehr in den Rahmen.
Wenn Sie den ts-node -Prozess in der Dateiänderung neu starten möchten, arbeiten vorhandene Node.js-Tools wie Nodemon, Onchange und Node-dev.
Es gibt auch ts-node-dev , eine modifizierte Version von node-dev die ts-node zur Kompilierung verwendet, die den Prozess in der Dateiänderung neu startet. Beachten Sie, dass ts-node-dev mit unserem nativen ESM-Lader unvereinbar ist.
Angenommen, Sie konfigurieren AVA über Ihr package.json , fügen Sie eine der folgenden Konfigurationen hinzu.
Verwenden Sie diese Konfiguration, wenn Ihr package.json nicht "type": "module" .
{
"ava" : {
"extensions" : [
"ts"
] ,
"require" : [
"ts-node/register"
]
}
} Diese Konfiguration ist erforderlich, wenn Ihr package.json "type": "module" hat.
{
"ava" : {
"extensions" : {
"ts" : "module"
} ,
"nonSemVerExperiments" : {
"configurableModuleFormat" : true
} ,
"nodeArguments" : [
"--loader=ts-node/esm"
]
}
} Die TS-Knotenunterstützung ist in Gulp integriert.
# Create a `gulpfile.ts` and run `gulp`.
gulpSiehe auch: https://gulpjs.com/docs/en/getting-started/javaScript-and-gulpfiles#transpilation
Erstellen Sie eine neue Konfiguration von node.js und fügen Sie -r ts-node/register zu "Knotenparametern" hinzu.
Hinweis: Wenn Sie das Argument --project <tsconfig.json> Befehlszeilen gemäß den Konfigurationsoptionen" verwenden und dieses Verhalten beim Start in IntelliJ anwenden möchten, geben Sie unter "Umgebungsvariablen": TS_NODE_PROJECT=<tsconfig.json> an.
mocha --require ts-node/register --extensions ts,tsx --watch --watch-files src ' tests/**/*.{ts,tsx} ' [...args]Oder geben Sie Optionen über Ihre Mokka -Konfigurationsdatei an.
{
// Specify "require" for CommonJS
"require" : "ts-node/register" ,
// Specify "loader" for native ESM
"loader" : "ts-node/esm" ,
"extensions" : [ "ts" , "tsx" ] ,
"spec" : [
"tests/**/*.spec.*"
] ,
"watch-files" : [
"src"
]
}Siehe auch: https://mochajs.org/#configuring-mocha-nodejs
mocha --require ts-node/register --watch-extensions ts,tsx " test/**/*.{ts,tsx} " [...args] HINWEIS: --watch-extensions werden nur im --watch -Modus verwendet.
ts-node node_modules/tape/bin/tape [...args] Erstellen Sie eine neue Node.js -Debug -Konfiguration, fügen Sie -r ts-node/register zu Knoten -Args und verschieben Sie das program in die args -Liste (so VS -Code sucht nicht nach outFiles ).
{
"configurations" : [ {
"type" : "node" ,
"request" : "launch" ,
"name" : "Launch Program" ,
"runtimeArgs" : [
"-r" ,
"ts-node/register"
] ,
"args" : [
"${workspaceFolder}/src/index.ts"
]
} ] ,
} Hinweis: Wenn Sie das Befehlszeilenargument --project <tsconfig.json> gemäß den Konfigurationsoptionen verwenden und das gleiche Verhalten beim Start in VS -Code anwenden möchten, fügen Sie eine "env" -Staste in die startkonfiguration hinzu: "env": { "TS_NODE_PROJECT": "<tsconfig.json>" } .
In vielen Fällen ermöglicht das Einstellen NODE_OPTIONS ts-node in anderen Knoten-Tools, untergeordneten Prozessen und Worker-Threads.
NODE_OPTIONS= " -r ts-node/register "Oder wenn Sie einen nativen ESM -Unterstützung benötigen:
NODE_OPTIONS= " --loader ts-node/esm " Dadurch werden alle Knotenprozesse angezeigt, die diese Umgebungsvariable empfangen, um die Hooks von ts-node zu installieren, bevor Sie einen anderen Code ausführen.
TS-NODE ist unter der MIT-Lizenz lizenziert. MIT
TS-NODE enthält Quellcode von node.js, der unter der MIT-Lizenz lizenziert ist. Node.js Lizenzinformationen
TS-NODE enthält Quellcode aus dem TypeScript-Compiler, der unter der Apache-Lizenz 2.0 lizenziert wird. Typenschrift -Lizenzinformationen
