ts node
1.0.0
Ejecución de TypeScript y RePL para Node.js, con el mapa fuente y el soporte de ESM nativo.
La última documentación también se puede encontrar en nuestro sitio web: https://typestrong.org/ts-node
nodeTSErrorSyntaxErrorERR_REQUIRE_ESMERR_UNKNOWN_FILE_EXTENSIONnode_modulesTS-Node es un motor de ejecución de TypeScript y replica para Node.js.
JIT transforma TypeScript en JavaScript, lo que le permite ejecutar directamente TypeScript en Node.js sin precompilar. Esto se logra al enganchar las API de carga del módulo del nodo, lo que permite que se use sin problemas junto con otras herramientas y bibliotecas de nodo.js.
tsconfig.json
# 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 Consejo: Instalar módulos localmente le permite controlar y compartir las versiones a través de package.json . TS-Node siempre resolverá el compilador de cwd antes de verificar en relación con su propia instalación.
# 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 Para escribir scripts con máxima portabilidad, especifique opciones en su tsconfig.json y omitirlos del shebang.
#!/usr/bin/env ts-node
// ts-node options are read from tsconfig.json
console . log ( "Hello, world!" ) La inclusión de opciones dentro del shebang requiere la bandera env -S , que está disponible en versiones recientes de env . (compatibilidad)
#!/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 Para probar su versión de env su compatibilidad con -S :
# Note that these unusual quotes are necessary
/usr/bin/env --debug ' -S echo foo bar ' Puede registrar el nodo TS sin usar nuestro cli: node -r ts-node/register y node --loader ts-node/esm
En muchos casos, la configuración NODE_OPTIONS habilitará ts-node dentro de otras herramientas de nodo, procesos infantiles y hilos de trabajadores. Esto se puede combinar con otros indicadores de nodo.
NODE_OPTIONS= " -r ts-node/register --no-warnings " node ./index.tsO, si necesita soporte de ESM nativo:
NODE_OPTIONS= " --loader ts-node/esm " Esto indica cualquier proceso de nodo que reciba esta variable de entorno para instalar los ganchos de ts-node antes de ejecutar otro código.
Si está invocando el nodo directamente, puede evitar la variable de entorno y pasar esos indicadores al nodo.
node --loader ts-node/esm --inspect ./index.ts Puede requerir el nodo TS y registrar el cargador para futuras necesidades utilizando require('ts-node').register({ /* options */ }) .
Echa un vistazo a nuestra API para obtener más funciones.
El nodo TS admite una variedad de opciones que se pueden especificar a través de tsconfig.json , como indicadores CLI, como variables de entorno o programáticamente.
Para una lista completa, vea las opciones.
Los indicadores de CLI de nodo TS deben venir antes del script EntryPoint. Por ejemplo:
$ ts-node --project tsconfig-dev.json say-hello.ts Ronald
Hello, Ronald ! TS-Node encuentra automáticamente y carga tsconfig.json . La mayoría de las opciones de nodo TS se pueden especificar en un objeto "ts-node" utilizando sus nombres programáticos de camello. Recomendamos esto porque funciona incluso cuando no puede pasar las banderas de CLI, como node --require ts-node/register y cuando se usa shebangs.
Use --skipProject para omitir la carga de tsconfig.json . Use --project para especificar explícitamente la ruta a un tsconfig.json .
Al buscar, se resuelve utilizando el mismo comportamiento de búsqueda que tsc . De manera predeterminada, esta búsqueda se realiza en relación con el script EntryPoint. En --cwdMode o si no se especifica ningún punto de entrada, por ejemplo, cuando se usa el Repl, la búsqueda se realiza en relación con --cwd / process.cwd() .
Puede usar esta configuración de muestra como punto de partida:
{
// 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
}
}Nuestro esquema JSON Bundled enumera todas las opciones compatibles.
@tsconfig/bases mantiene configuraciones recomendadas para varias versiones de nodos. Como conveniencia, estos están inclinados con el nodo TS.
{
"extends" : "ts-node/node16/tsconfig.json" ,
// Or install directly with `npm i -D @tsconfig/node16`
"extends" : "@tsconfig/node16/tsconfig.json" ,
} Si no se carga tsconfig.json desde el disco, el nodo TS utilizará los valores predeterminados más recomendados de @tsconfig/bases compatibles con su node y versiones typescript . Con el último node y typescript , este es @tsconfig/node16 .
Las versiones más antiguas de typescript son incompatibles con @tsconfig/node16 . En esos casos utilizaremos una configuración predeterminada anterior.
En caso de duda, ts-node --showConfig registrará la configuración que se está utilizando, y ts-node -vv registrará las versiones node y typescript .
node Los indicadores node deben pasar directamente al node ; No se pueden pasar al binario de nodo TS ni se pueden especificar en tsconfig.json
Recomendamos utilizar la variable de entorno NODE_OPTIONS para pasar opciones al node .
NODE_OPTIONS= ' --trace-deprecation --abort-on-uncaught-exception ' ts-node ./index.ts Alternativamente, puede invocar node directamente e instalar el nodo TS a través de --require / -r
node --trace-deprecation --abort-on-uncaught-exception -r ts-node/register ./index.ts Todos los indicadores de línea de comandos admiten tanto --camelCase como --hyphen-case .
La mayoría de las opciones se pueden declarar en su configuración tsconfig.json: a través de tsconfig.json
ts-node admite --print ( -p ), --eval ( -e ), --require ( -r ) y --interactive ( -i ) similar al Node.js CLI.
ts-node admite --project y --showConfig similar al TSC CLI.
Las variables de entorno, donde están disponibles, están en ALL_CAPS
ts-node --helpImprime el texto de ayuda
ts-node -v
ts-node -vvv Imprime la versión. -vv incluye versiones de nodo y compilador mecanografiado. -vvv incluye rutas absolutas al nodo TS y las instalaciones de TypeScript.
ts-node -e < typescript code >
# Example
ts-node -e ' console.log("Hello world!") 'Evaluar código
ts-node -p -e < typescript code >
# Example
ts-node -p -e ' "Hello world!" ' Resultado de impresión de --eval
ts-node -iAbre el replic incluso si Stdin no parece ser un terminal
ts-node --esm
ts-node-esmBootstrap con el cargador ESM, que permite el soporte de ESM completo
ts-node -P < path/to/tsconfig >
ts-node --project < path/to/tsconfig >Ruta al archivo tsconfig.
Tenga en cuenta el mayúscula -P . Esto es diferente de la opción -p/--project tsc .
Medio ambiente: TS_NODE_PROJECT
ts-node --skipProjectOmita la resolución y carga de la configuración del proyecto
Valor predeterminado: false
Medio ambiente: TS_NODE_SKIP_PROJECT
ts-node -c
ts-node --cwdMode
ts-node-cwdResolver Config en relación con el directorio actual en lugar del directorio del script EntryPoint
ts-node -O < json compilerOptions >
ts-node --compilerOptions < json compilerOptions >JSON OBJETO para fusionarse con opciones de compilador
Medio ambiente: TS_NODE_COMPILER_OPTIONS
ts-node --showConfig Imprimir tsconfig.json resuelto, incluidas las opciones ts-node , y salir
ts-node -T
ts-node --transpileOnly Use transpileModule más rápido de TypeScript
Valor predeterminado: false
Medio ambiente: TS_NODE_TRANSPILE_ONLY
ts-node --typeCheck Opuesto de --transpileOnly
Valor predeterminado: true
Medio ambiente: TS_NODE_TYPE_CHECK
ts-node -H
ts-node --compilerHostUtilice la API de host del compilador de TypeScript
Valor predeterminado: false
Medio ambiente: TS_NODE_COMPILER_HOST
ts-node --files Cargue files , include y exclude de tsconfig.json al inicio. Esto puede evitar ciertas fallas de compensación de tipos. Consulte los tipos faltantes para más detalles.
Valor predeterminado: false
Medio ambiente: TS_NODE_FILES
ts-node -D < code,code >
ts-node --ignoreDiagnostics < code,code >Ignorar las advertencias de TypeScript por código de diagnóstico
Medio ambiente: TS_NODE_IGNORE_DIAGNOSTICS
ts-node -I < regexp matching ignored files >
ts-node --ignore < regexp matching ignored files >Anular los patrones de ruta para omitir la compilación
Predeterminado: /node_modules/
Medio ambiente: TS_NODE_IGNORE
ts-node --skipIgnoreSkip Ignore Checks
Valor predeterminado: false
Medio ambiente: TS_NODE_SKIP_IGNORE
ts-node -C < name >
ts-node --compiler < name >Especificar un compilador de mecanografiado personalizado
Valor predeterminado: typescript
Entorno: TS_NODE_COMPILER
ts-node --swc Transpile con SWC. Implica --transpileOnly
Valor predeterminado: false
ts-node --transpiler < name >
# Example
ts-node --transpiler ts-node/transpilers/swcUse un transpilador de terceros y no comprobando
ts-node --preferTsExtsReordenar las extensiones de archivos para que se prefieran las importaciones de TypeScript
Valor predeterminado: false
Medio ambiente: TS_NODE_PREFER_TS_EXTS
ts-node --logErrorRegistra errores de mecanografiado a stderr en lugar de lanzar excepciones
Valor predeterminado: false
Medio ambiente: TS_NODE_LOG_ERROR
ts-node --prettyUse un formateador de diagnóstico bonito
Valor predeterminado: false
Medio ambiente: TS_NODE_PRETTY
TS_NODE_DEBUG=true ts-nodeHabilitar el registro de depuración
ts-node -r < module name or path >
ts-node --require < module name or path >Requiere un módulo de nodo antes de la ejecución
ts-node --cwd < path/to/directory >Comportarse como si se invoque en este directorio de trabajo
Predeterminado: process.cwd()
Medio ambiente: TS_NODE_CWD
ts-node --emit Emitir archivos de salida en el directorio .ts-node . Requiere --compilerHost
Valor predeterminado: false
Medio ambiente: TS_NODE_EMIT
ts-node --scope Compilador de alcance a archivos dentro de scopeDir . Se ignora cualquier cosa fuera de este directorio.
Valor predeterminado: false
Medio ambiente: TS_NODE_SCOPE
ts-node --scopeDir < path/to/directory > Directorio dentro del cual el compilador está limitado cuando scope está habilitado.
Valor predeterminado: Primero de: tsconfig.json "rootdir" Si se especifica, el directorio que contiene tsconfig.json o cwd si no se carga tsconfig.json .
Medio ambiente: TS_NODE_SCOPE_DIR
Anule el tipo de módulo de ciertos archivos, ignorando el campo "type" package.json . Consulte las anulaciones del tipo de módulo para obtener más detalles.
Valor predeterminado: obedece package.json "type" y tsconfig.json "module"
Solo se puede especificar a través de tsconfig.json o API.
TS_NODE_HISTORY= < path/to/history/file > ts-nodeArchivo de ruta al historial para replica
Predeterminado: ~/.ts_node_repl_history
ts-node --noExperimentalReplAwait Desactive el nivel superior espera en repl. Equivalente al nodo --no-experimental-repl-await
Valor predeterminado: habilitado si la versión de TypeScript es 3.8 o superior y el objetivo es ES2018 o superior.
Medio ambiente: TS_NODE_EXPERIMENTAL_REPL_AWAIT establecer false para deshabilitar
Habilite los ganchos experimentales que vuelven a mapear las importaciones y requieren llamadas para soportar:
import "./foo.js" ejecutará foo.ts Actualmente se asignarán las siguientes extensiones:.js a .ts , .tsx o .jsx.cjs a .cts.mjs a .mts.jsx a .tsxEn el futuro, este gancho también admitirá:
baseUrl , pathsrootDirsoutDir to rootDir para proyectos compuestos y monoreposPara más detalles, consulte #1514.
Predeterminado: false , pero probablemente estará habilitado de forma predeterminada en una versión futura
Solo se puede especificar a través de tsconfig.json o API.
ts-node --experimentalSpecifierResolution node Al igual que el nodo, --experimental-specifier-resolution , pero también se puede configurar en su tsconfig.json por conveniencia. Requiere que esm esté habilitado.
Valor predeterminado: explicit
La API incluye opciones adicionales que no se muestran aquí.
El soporte SWC está integrado a través de la opción --swc o "swc": true opción TSCONFIG.
SWC es un transpilador compatible con TypeScript implementado en Rust. Esto lo convierte en un orden de magnitud más rápido que transpileOnly de vainilla.
Para usarlo, primero instale @swc/core o @swc/wasm . Si usa importHelpers , también instale @swc/helpers . Si target es inferior a "ES2015" y el uso de las funciones async / await o del generador, también instale regenerator-runtime .
npm i -D @swc/core @swc/helpers regenerator-runtime Luego agregue lo siguiente a su tsconfig.json .
{
"ts-node" : {
"swc" : true
}
}SWC usa
@swc/helpersen lugar detslib. Si ha habilitadoimportHelpers, también debe instalar@swc/helpers.
TypeScript casi siempre se escribe con la sintaxis import moderna, pero también se transforma antes de ser ejecutado por el tiempo de ejecución subyacente. Puede optar por transformarse en CommonJS o preservar la sintaxis import nativa, utilizando el soporte de ESM nativo de Node. La configuración es diferente para cada uno.
Aquí hay una breve comparación de los dos.
| Commonjs | Módulos nativos de ECMAScript |
|---|---|
Escribir sintaxis import nativa | Escribir sintaxis import nativa |
Transforma import en require() | No transforma import |
| Node ejecuta scripts utilizando el cargador clásico CommonJS | Nodo ejecuta scripts usando el nuevo cargador ESM |
Use cualquiera de:ts-nodenode -r ts-node/registerNODE_OPTIONS="ts-node/register" noderequire('ts-node').register({/* options */}) | Use cualquiera de:ts-node --esmts-node-esmEstablecer "esm": true en tsconfig.jsonnode --loader ts-node/esmNODE_OPTIONS="--loader ts-node/esm" node |
Transformarse en CommonJS es típicamente más simple y más ampliamente compatible porque es más antiguo. Debe eliminar "type": "module" de package.json y establecer "module": "CommonJS" en tsconfig.json .
{
// This can be omitted; commonjs is the default
"type" : "commonjs"
} {
"compilerOptions" : {
"module" : "CommonJS"
}
} Si debe mantener "module": "ESNext" para tsc , Webpack u otra herramienta de compilación, puede establecer una anulación para el nodo TS.
{
"compilerOptions" : {
"module" : "ESNext"
} ,
"ts-node" : {
"compilerOptions" : {
"module" : "CommonJS"
}
}
} Los ganchos de cargador ESM del nodo son experimentales y están sujetos a cambios. El soporte de ESM de TS-Node es lo más estable posible, pero se basa en API en qué nodo puede y romperá nuevas versiones de Node. Por lo tanto, no se recomienda para la producción.
Para uso completo, limitaciones y para proporcionar comentarios, consulte #1007.
Debe establecer "type": "module" en package.json y "module": "ESNext" en 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
}
} También debe asegurarse de que se pase el nodo --loader . La CLI del nodo TS lo hará automáticamente con nuestra opción esm .
Nota:
--esmdebe generar un proceso infantil para pasarlo--loader. Esto puede cambiar si el nodo agrega la capacidad de instalar ganchos del cargador en el proceso actual.
# 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-nodeSi no está usando nuestra CLI, pase el indicador del cargador al nodo.
node --loader ts-node/esm ./index.ts
# Or via environment variable
NODE_OPTIONS= " --loader ts-node/esm " node ./index.ts TS-Node utiliza configuraciones predeterminadas sensibles para reducir la calderera y al mismo tiempo respeta tsconfig.json si tiene una. Si no está seguro de qué configuración se utiliza, puede registrarla con ts-node --showConfig . Esto es similar a tsc --showConfig pero también incluye opciones de "ts-node" .
TS-Node también respeta su versión typescript instalada localmente, pero las instalaciones globales se retiran al typescript de instalación mundial. Si no está seguro de qué versiones se usan, ts-node -vv las registrará.
$ 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 importante diferenciar entre errores del nodo TS, errores del compilador TypeScript y errores del node . También es importante comprender cuándo los errores son causados por un error de tipo en su código, un error en su código o un defecto en su configuración.
TSError Los errores de tipo desde el compilador se arrojan como un TSError . Estos son lo mismo que los errores que obtienes de tsc .
SyntaxError Cualquier error que no sea un TSError es de node.js (por ejemplo, SyntaxError ), y no puede ser solucionado por mecanografiado o nodo TS. Estos son errores en su código o configuración.
Su versión de node puede no admitir toda la sintaxis de JavaScript compatible con TypeScript. El compilador debe transformar esta sintaxis a través de "nivelación baja", que está controlada por la opción TSCONFIG "target" . De lo contrario, su código se compilará bien, pero Node lanzará un SyntaxError .
Por ejemplo, node 12 no entiende el ?. Operador de encadenamiento opcional. Si usa "target": "esnext" , entonces la siguiente sintaxis de TypeScript:
const bar : string | undefined = foo ?. bar ;Se compilará en este JavaScript:
const a = foo ?. bar ; Cuando intentes ejecutar este código, el nodo 12 lanzará un SyntaxError . Para solucionar esto, debe cambiar a "target": "es2019" o más bajo, SO TypeScript se transforma ?. en algo que node puede entender.
ERR_REQUIRE_ESM Este error es lanzado por el nodo cuando un módulo es require() D, pero el nodo cree que debería ejecutarse como ESM nativo. Esto puede suceder por algunas razones:
webpack.config.ts , que debe ejecutarse como CommonJS.ctsERR_UNKNOWN_FILE_EXTENSIONEste error es lanzado por el nodo cuando un módulo tiene una extensión de archivo no reconocida, o ninguna extensión, y se está ejecutando como ESM nativo. Esto puede suceder por algunas razones:
mocha .ts-node-esm , ts-node --esm o agregue "ts-node": {"esm": true} a su tsconfig.json. Documentowebpack.config.ts , que debe ejecutarse como CommonJS.cts TS-Node no carga ansiosamente files , include ni exclude de forma predeterminada. Esto se debe a que una gran mayoría de los proyectos no usan todos los archivos en un directorio de proyectos (por ejemplo, Gulpfile.ts , Tiempo de ejecución frente a las pruebas) y analizar cada archivo para los tipos de tiempo de inicio. En su lugar, el nodo TS comienza con el archivo de script (por ejemplo ts-node index.ts ) y TypeScript resuelve dependencias basadas en importaciones y referencias.
Ocasionalmente, esta optimización conduce a tipos faltantes. Afortunadamente, hay otras formas de incluirlos en la compensación de la típica.
Para las definiciones globales, puede usar la opción del compilador typeRoots . Esto requiere que sus definiciones de tipo se estructuren como paquetes de tipo (no los archivos de definición de mecanografiado suelto). Más detalles sobre cómo esto funciona en el manual de TypeScript.
Ejemplo tsconfig.json :
{
"compilerOptions" : {
"typeRoots" : [ "./node_modules/@types" , "./typings" ]
}
}Ejemplo de estructura del proyecto:
<project_root>/
-- tsconfig.json
-- typings/
-- <module_name>/
-- index.d.ts
Archivo de declaración de módulo de ejemplo:
declare module '<module_name>' {
// module definitions go here
} Para las definiciones de módulos, puede usar paths :
{
"compilerOptions" : {
"baseUrl" : "." ,
"paths" : {
"custom-module-type" : [ "types/custom-module-type" ]
}
}
} Otra opción son las directivas de triple steble. Esto puede ser útil si prefiere no cambiar sus compilerOptions o estructurar sus definiciones de tipo para typeRoots . A continuación se muestra un ejemplo de una directiva de triple pendiente como una ruta relativa dentro de su proyecto:
/// <reference path="./types/lib_greeter" />
import { Greeter } from "lib_greeter"
const g = new Greeter ( ) ;
g . sayHello ( ) ; Si ninguno de los anteriores funciona, y debe usar files , include o exclude , habilitar nuestra opción files .
Al ejecutar TypeScript con npx o yarn dlx , el código reside dentro de un directorio temporal node_modules .
El contenido de node_modules se ignoran de forma predeterminada. Si la ejecución falla, habilite skipIgnore .
Estos trucos harán que el nodo TS sea más rápido.
A menudo es mejor tipo de tecnología como parte de sus pruebas o pelusas. Puede ejecutar tsc --noEmit para hacer esto. En estos casos, el nodo TS puede omitir la compensación de la típica, lo que lo hace mucho más rápido.
Para omitir la typeching en el nodo TS, haga uno de los siguientes:
transpileOnly para omitir la compensación de la tipografía sin SWC Si absolutamente debe Typecheck en el nodo TS:
require() que puede desencadenar la típica repetida; preferir import--files ; uno puede ser más rápido dependiendo de su proyectotsc --showConfig ; Asegúrese de que se incluyan todos los archivos ejecutadosskipLibChecktypes para evitar cargar innecesario @types El nodo TS funciona registrando ganchos para .ts , .tsx , .js y/o .jsx extensiones.
node de vainilla carga .js leyendo código del disco y ejecutándolo. Nuestro gancho se ejecuta en el medio, transformando el código de TypeScript a JavaScript y pasando el resultado al node para la ejecución. Esta transformación respetará su tsconfig.json como si hubiera compilado a través de tsc .
También registramos algunos otros ganchos para aplicar SourCeMaps para apilar trazas y reasignar de .js importaciones a .ts .
El nodo TS transforma ciertos archivos e ignora otros. Nos referimos a este mecanismo como "alcance". Hay varias opciones para configurar el alcance, de modo que el nodo TS transforma solo los archivos en su proyecto.
Advertencia:
Un archivo ignorado aún puede ser ejecutado por Node.js. Ignorar un archivo significa que no lo transformamos de TypeScript en JavaScript, pero no evita la ejecución.
Si un archivo requiere transformación pero se ignora, el nodo puede no resolverlo o intentar ejecutarlo como javascript de vainilla. Esto puede causar errores de sintaxis u otras fallas, porque el nodo no comprende la sintaxis de tipo TypeScript ni las características de ECMAScript de borde de sangrado.
.js y .jsx solo se transforman cuando allowJs se habilitan.
.tsx y .jsx solo se transforman cuando jsx está habilitado.
Advertencia:
Cuando se usa el nodo TS con
allowJs, todos los archivos JavaScript no ignorados se transforman por el nodo TS.
node_modules Por defecto, el nodo TS evita compilar archivos en /node_modules/ por tres razones:
Si necesita importar TypeScript no compilado en node_modules , use --skipIgnore o TS_NODE_SKIP_IGNORE para evitar esta restricción.
Si ya existe un archivo JavaScript compilado con el mismo nombre que un archivo TypeScript, se ignorará el archivo TypeScript. TS-Node importará el JavaScript precompilado.
Para forzar el nodo TS a importar la fuente TypeScript, no el JavaScript precompilado, use --preferTsExts .
Nuestro scope y las opciones scopeDir limitarán la transformación a archivos dentro de un directorio.
Nuestra opción ignore ignorará los archivos que coinciden con una o más expresiones regulares.
Puede usar el nodo TS junto con TsConfig-Path para cargar módulos de acuerdo con la sección paths en tsconfig.json .
{
"ts-node" : {
// Do not forget to `npm i -D tsconfig-paths`
"require" : [ "tsconfig-paths/register" ]
}
} El manual de TypeScript oficial explica el propósito previsto para "paths" en "indicadores de resolución de módulos adicionales".
El compilador TypeScript tiene un conjunto de indicadores adicionales para informar al compilador de transformaciones que se espera que ocurran con las fuentes para generar la salida final.
Es importante tener en cuenta que el compilador no realizará ninguna de estas transformaciones; Simplemente usa estas piezas de información para guiar el proceso de resolver un módulo de importación a su archivo de definición.
Esto significa que "paths" están destinadas a describir las asignaciones que la herramienta de compilación o el tiempo de ejecución ya realiza, no para decirle a la herramienta de compilación o tiempo de ejecución cómo resolver módulos. En otras palabras, tienen la intención de escribir nuestras importaciones de una manera que node ya entiende. Por esta razón, el nodo TS no modifica el comportamiento de resolución del módulo de node para implementar asignaciones "paths" .
Algunos proyectos requieren un compilador TypeScript parcheado que agrega características adicionales. Por ejemplo, ttypescript y ts-patch agregan la capacidad de configurar transformadores personalizados. Estos son reemplazos de entrega del módulo de Vanilla typescript e implementan la misma API.
Por ejemplo, para usar ttypescript y ts-transformer-keys , agregue esto a su tsconfig.json :
{
"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" }
]
}
} El nodo TS admite transpiladores de terceros como complementos. Los transpiladores como SWC pueden transformar TypeScript en JavaScript mucho más rápido que el compilador TypeScript. Todavía se beneficiará del descubrimiento automático de TS-Node tsconfig.json , SourCeMap Support y Global TS-Node CLI. Los complementos derivan automáticamente una configuración apropiada de su tsconfig.json existente que simplifica el boilerplate del proyecto.
¿Cuál es la diferencia entre un compilador y un transpilador?
Para nuestros propósitos, un compilador implementa la API de TypeScript y puede realizar una redacción de tipos. Un transpilador de terceros no. Ambos transforman TypeScript en JavaScript.
La opción transpiler permite usar complementos de transpilador de terceros con el nodo TS. transpiler debe recibir el nombre de un módulo que se puede require() d. El complemento swc incorporado está expuesto como ts-node/transpilers/swc .
Por ejemplo, para usar un hipotético " @cspotcode/fast-ts-compiler", primero instálelo en su proyecto: npm install @cspotcode/fast-ts-compiler
Luego agregue lo siguiente a su tsconfig:
{
"ts-node" : {
"transpileOnly" : true ,
"transpiler" : "@cspotcode/fast-ts-compiler"
}
}Para escribir su propio complemento de transpilador, consulte nuestros documentos de API.
Los complementos son require() D por nodo TS, por lo que pueden ser un script local o un módulo de nodo publicado a NPM. El módulo debe exportar una función create descrita por nuestra interfaz TranspilerModule . create es invocado por el nodo TS al inicio para crear una o más instancias de transpilador. Las instancias se utilizan para transformar TypeScript en JavaScript.
Para obtener un ejemplo de funcionamiento, consulte nuestro complemento SWC agrupado: https://github.com/typestrong/ts-node/blob/main/src/transpilers/swc.ts
Siempre que sea posible, se recomienda usar el modo
NodeNextoNode16de TypeScript en lugar de las opciones descritas en esta sección. Configuración de"module": "NodeNext"y el uso de la extensión del archivo.ctsdebería funcionar bien para la mayoría de los proyectos.
Al decidir cómo se debe compilar y ejecutar un archivo, como el módulo CommonJS o Ecmascript nativo, el nodo TS coincide con el comportamiento node y tsc . Esto significa que los archivos TypeScript se transforman de acuerdo con su opción "module" tsconfig.json y se ejecutan de acuerdo con las reglas de Node para el campo "type" package.json . JSON. Establezca "module": "NodeNext" y todo debería funcionar.
En casos raros, es posible que deba anular este comportamiento para algunos archivos. Por ejemplo, algunas herramientas leen un name-of-tool.config.ts y requieren que ese archivo se ejecute como CommonJS. Si tiene package.json configurado con "type": "module" y tsconfig.json con "module": "esnext" , la configuración es nativa ECMAScript de forma predeterminada y aumentará un error. Deberá forzar la configuración y cualquier scripts de soporte para ejecutar como CommonJS.
En estas situaciones, nuestra opción de moduleTypes puede anular ciertos archivos para que sean CommonJS o ESM. Es posible una primordial similar utilizando .mts , .cts , .cjs y .mjs Extensiones de archivos. moduleTypes logra el mismo efecto para archivos .ts y .js , y también anula su configuración de "module" tsconfig.json de manera adecuada.
El siguiente ejemplo le dice a TS-Node que ejecute una configuración de Webpack como CommonJS:
{
"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"
}
} Cada tecla es un patrón de globo con la misma sintaxis que la matriz "include" de TSCONFIG. Cuando múltiples patrones coinciden con el mismo archivo, el último patrón tiene prioridad.
cjs anula los archivos coincidentes para compilar y ejecutar como CommonJS.esm anula los archivos de coincidencia para compilar y ejecutar como módulos nativos de ECMAScript.package restablece cualquiera de los anteriores al comportamiento predeterminado, que obedece las opciones "type" "module" package.json y tsconfig.json . Los archivos con un tipo de módulo anulado se transforman con las mismas limitaciones que isolatedModules . Esto solo afectará casos raros, como el uso de const enum s con preserveConstEnums deshabilitados.
Esta característica está destinada a facilitar escenarios donde no es posible la configuración compilerOptions normales y package.json . JSON. Por ejemplo, un webpack.config.ts no se puede dar su propio package.json para anular "type" . Siempre que sea posible, debe favorecer el uso de configuraciones tradicionales package.json y tsconfig.json .
La API completa de TS-Node está documentada aquí: API Docs
Aquí hay algunos aspectos destacados de lo que puede lograr:
create() crea el servicio de compilador de Node TS sin registrar ningún gancho.createRepl() crea una instancia de nuestro servicio replica, por lo que puede crear sus propios REPLS propulsados por TypeScript.createEsmHooks() crea nuestros ganchos de cargadores ESM, adecuados para componer con otros cargadores o aumentar con características adicionales.TS-Node se centra en agregar soporte de primera clase TypeScript al nodo. Ver archivos y recargas de código está fuera de alcance para el proyecto.
Si desea reiniciar el proceso ts-node en el cambio de archivo, las herramientas node.js existentes como Nodemon, OnChange y Node-Dev funcionan.
También hay ts-node-dev , una versión modificada de node-dev que usa el ts-node para la compilación que reiniciará el proceso en el cambio de archivo. Tenga en cuenta que ts-node-dev es incompatible con nuestro cargador ESM nativo.
Suponiendo que está configurando AVA a través de su package.json , agregue una de las siguientes configuraciones.
Use esta configuración si su package.json no tiene "type": "module" .
{
"ava" : {
"extensions" : [
"ts"
] ,
"require" : [
"ts-node/register"
]
}
} Esta configuración es necesaria si su package.json tiene "type": "module" .
{
"ava" : {
"extensions" : {
"ts" : "module"
} ,
"nonSemVerExperiments" : {
"configurableModuleFormat" : true
} ,
"nodeArguments" : [
"--loader=ts-node/esm"
]
}
} El soporte de nodo TS está integrado en Gulp.
# Create a `gulpfile.ts` and run `gulp`.
gulpVer también: https://gulpjs.com/docs/en/getting-started/javascript-andgulpfiles#transpilation
Cree una nueva configuración Node.js y agregue -r ts-node/register a "parámetros de nodo".
Nota: Si está utilizando el argumento de línea de comandos --project <tsconfig.json> según las opciones de configuración, y desea aplicar este mismo comportamiento al iniciarlo en IntelliJ, especifique en "Variables de entorno": TS_NODE_PROJECT=<tsconfig.json> .
mocha --require ts-node/register --extensions ts,tsx --watch --watch-files src ' tests/**/*.{ts,tsx} ' [...args]O especifique las opciones a través de su archivo de configuración Mocha.
{
// 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"
]
}Ver también: https://mochajs.org/#configuring-mocha-nodejs
mocha --require ts-node/register --watch-extensions ts,tsx " test/**/*.{ts,tsx} " [...args] NOTA: --watch-extensions solo se usa en el modo --watch .
ts-node node_modules/tape/bin/tape [...args] Cree una nueva configuración de depuración de Node.js, agregue -r ts-node/register a Node Args y mueva el program a la lista args (por lo que VS Code no busca outFiles ).
{
"configurations" : [ {
"type" : "node" ,
"request" : "launch" ,
"name" : "Launch Program" ,
"runtimeArgs" : [
"-r" ,
"ts-node/register"
] ,
"args" : [
"${workspaceFolder}/src/index.ts"
]
} ] ,
} Nota: Si está utilizando el argumento de línea de comandos --project <tsconfig.json> según las opciones de configuración y desea aplicar este mismo comportamiento al iniciar en el código VS, agregue una clave "Env" en la configuración de lanzamiento: "env": { "TS_NODE_PROJECT": "<tsconfig.json>" } .
En muchos casos, la configuración NODE_OPTIONS habilitará ts-node dentro de otras herramientas de nodo, procesos infantiles y hilos de trabajadores.
NODE_OPTIONS= " -r ts-node/register "O, si necesita soporte de ESM nativo:
NODE_OPTIONS= " --loader ts-node/esm " Esto indica cualquier proceso de nodo que reciba esta variable de entorno para instalar los ganchos de ts-node antes de ejecutar otro código.
TS-Node tiene licencia bajo la licencia MIT. MIT
El nodo TS incluye el código fuente de Node.js, que tiene licencia bajo la licencia MIT. Información de la licencia Node.js
El nodo TS incluye el código fuente del compilador TypeScript que tiene licencia bajo la licencia de Apache 2.0. Información de la licencia mecanografiada
