Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # TypeScript en AL2023 **nota** Este documento proporciona la información esencial sobre TypeScript y su entorno de ejecución basado en Node.js. También cubre un flujo de trabajo de desarrollo típico y explica cómo se empaqueta TypeScript en AL2023 para ofrecer un entorno de desarrollo coherente y reproducible. [https://www.typescriptlang.org/](https://www.typescriptlang.org/) (TS) es un lenguaje de programación basado en JavaScript (JS) que ofrece todas las funciones de JS y, además, [lo amplía con un sistema de tipos](https://www.typescriptlang.org/docs/handbook/typescript-in-5-minutes.html). En un escenario típico, los programas escritos en TS se traducen primero al código JS y luego se ejecutan como cualquier otro programa JS normalNode.js. En la terminología específica de TS, este proceso de traducción se denomina [“compilación” y lo realiza un “compilador”](https://www.typescriptlang.org/docs/handbook/typescript-tooling-in-5-minutes.html), llamado *tsc*. El propio compilador *tsc* está escrito en JS, por lo que, para ejecutarse, también necesita un entorno de ejecución de JS, como Node.js. A diferencia de otros entornos de ejecución de JS, Node.js actualmente solo tiene soporte TS experimental y ligero. La compatibilidad total con TS, incluida la verificación de tipos, aún requiere el uso de paquetes de terceros, como [TypeScript](https://www.npmjs.com/package/typescript). La forma esperada de obtener *tsc* (el compilador de TS) para el entorno de ejecución de Node.js es instalar el módulo de nodo Typescript. Esto se puede hacer usando uno de los administradores de paquetes, normalmente *npm*. Hay dos formas de instalar el compilador de TS usando *npm*: globalmente y en un proyecto. [El método recomendado oficialmente es instalar](https://www.typescriptlang.org/download/) el compilador de TS por proyecto, lo que garantiza la coherencia y la reproducibilidad de los proyectos a largo plazo. Sin embargo, instalar el compilador de TS de forma global puede seguir siendo útil, ya que proporciona la misma versión para todo el host y su entorno de ejecución de JS y, por lo tanto, para los proyectos que no tienen un compilador de TS instalado localmente. Así es precisamente como los paquetes RPM disponibles en Amazon Linux, como `nodejs20-typescript` o `nodejs22-typescript`, instalan un compilador de TS: globalmente en el nivel del sistema y por separado para cada versión de Node.js compatible. El *tsc* no depende directamente de ninguna versión de Node.js. El compilador espera un cierto nivel de características de tiempo de ejecución, que se definen en un archivo especial (*tsconfig.json*) a través de opciones tales como [target](https://www.typescriptlang.org/tsconfig/#target) y [lib](https://www.typescriptlang.org/tsconfig/#lib). Los valores de estas opciones representan una versión del estándar [ECMAScript](https://en.wikipedia.org/wiki/ECMAScript_version_history) (ES), que puede (o no) ser compatible con el entorno de ejecución JS. Las distintas versiones de Node.js admiten diferentes versiones de ES. Cuanto más reciente sea la versión de Node.js, más alta y completa será la compatible con la versión estándar de ES. Si *tsconfig.json* no existe en el directorio raíz de un proyecto, se utilizará el conjunto predeterminado de opciones de configuración. La tabla de compatibilidad con las distintas versiones de Node.js y las funciones compatibles de las distintas versiones estándar de ES está disponible en [node.green](https://node.green/). El *tsc* tiene más de 100 opciones diferentes, que se pueden definir en *tsconfig.json*. También se admite el encadenamiento de configuraciones cuando algunas opciones de configuración se definen en otro archivo y luego se incluyen en el archivo principal. Este enfoque permite instalar una [configuración TS base](https://github.com/tsconfig/bases) compatible con una versión determinada de y, a continuación, ampliarla con opciones específicas del proyecto. Afortunadamente, las configuraciones TS base de Node.js están disponibles como módulos de nodo que se pueden instalar en una carpeta de proyecto mediante *npm*. Este es el código fuente de la configuración para las versiones de Node.js [18](https://github.com/tsconfig/bases/blob/main/bases/node18.json), [20](https://github.com/tsconfig/bases/blob/main/bases/node20.json) y [22](https://github.com/tsconfig/bases/blob/main/bases/node22.json). El diseño del tiempo de ejecución de Node.js basado tiene una cierta debilidad: solo admite una versión del tiempo de ejecución en un host y requiere la reproducibilidad y la coherencia de todas las dependencias en el nivel del proyecto. Esto llevó al siguiente enfoque común de usar TypeScript: el compilador de TS, la configuración base de TS para la versión actual de Node.js y todas las dependencias de software se instalan localmente, dentro de un proyecto. Aunque se espera que los módulos de nodo instalados globalmente sean solo herramientas CLI, como *npm* y *tsc*, que también es una herramienta CLI, rara vez se instala globalmente. Afortunadamente, las instalaciones globales (en todo el sistema) y locales (dentro de un proyecto) de *tsc* pueden coexistir sin problemas y también pueden ser versiones diferentes que se utilizan de forma independiente. Tenga en cuenta que un *tsc* instalado localmente debe ejecutarse con la herramienta *npx*, que se instala junto con *npm*. Por lo tanto, incluso con un compilador TS de sistema, los usuarios tienen la oportunidad de elegir versiones de los componentes del motor de ejecución, por ejemplo Node.js (cambiando la versión activa por alternativas), un compilador de TS (instalándolo local o globalmente y también cambiando la versión activa a través de alternativas) y configurándolo según las necesidades específicas. Amazon Linux empaqueta un compilador de TS de la misma forma que otros módulos de nodos instalados globalmente, como *npm*, en una versión básica por versión de Node.js. Los paquetes y los binarios tienen espacios de nombres y contienen la versión principal de Node.js como parte de sus nombres. El nombre ejecutable predeterminado del compilador, *tsc*, lo administra en tiempo de ejecución la herramienta de alternativas y apunta a la versión actualmente activa de Node.js para la que se instaló y con la que se ejecutará. Esta selección no depende de la versión de tiempo de ejecución actual de Node.js. Es posible tener un ejecutable de *nodo* que apunte a Node.js 20 y que *tsc* esté configurado para ser interpretado por Node.js 22. También es posible utilizar los nombres con espacios de nombres de un compilador de TS, por ejemplo, *tsc- \$1MAJOR\$1VERSION\$1* independientemente de para qué esté configurado el nombre de *tsc* predeterminado. **Algunos comandos útiles para administrar la versión activa de un compilador de TS** 1. Compruebe para qué *alternativas* está configurada ``` alternatives --list ``` 1. Compruebe la configuración actual de *tsc* ``` alternatives --display tsc ``` 1. Cambie la versión de tsc de forma interactiva ``` alternatives --config tsc ``` 1. Cambie al modo manual y seleccione una versión específica ``` alternatives --set tsc /usr/bin/tsc-{MAJOR_VERSION} ``` 1. Vuelva al modo de selección automática de versión ``` alternatives --auto tsc ``` Un ejemplo de instalación y uso de varias versiones de Node y un compilador de TS en el mismo sistema: ``` # Check the AL2023 release $ cat /etc/amazon-linux-release Amazon Linux release 2023.9.20250929 (Amazon Linux) # Install a TypeScript compiler for Node.js 20 and 22 # Node.js 20 and 22 will be installed automatically $ sudo dnf install -qy nodejs20-typescript nodejs22-typescript # Check what was installed $ rpm -q nodejs20 nodejs20-typescript nodejs22 nodejs22-typescript nodejs20-20.19.5-1.amzn2023.0.1.x86_64 nodejs20-typescript-5.9.2-1.amzn2023.0.1.noarch nodejs22-22.19.0-1.amzn2023.0.1.x86_64 nodejs22-typescript-5.9.2-1.amzn2023.0.1.noarch # Check the active version of Node.js - it is version 20 $ alternatives --display node node - status is auto. link currently points to /usr/bin/node-20 /usr/bin/node-20 - priority 100 slave npmrc: /usr/lib/nodejs20/lib/node_modules/npm/npmrc slave npm: /usr/bin/npm-20 slave npx: /usr/bin/npx-20 slave node_modules: /usr/lib/nodejs20/lib/node_modules /usr/bin/node-22 - priority 100 slave npmrc: /usr/lib/nodejs22/lib/node_modules/npm/npmrc slave npm: /usr/bin/npm-22 slave npx: /usr/bin/npx-22 slave node_modules: /usr/lib/nodejs22/lib/node_modules Current 'best' version is /usr/bin/node-20. # Check the active JS runtime version for TypeScript # Currently, the tsc compiler will be executed by Node.js 22 $ alternatives --display tsc tsc - status is auto. link currently points to /usr/bin/tsc-22 /usr/bin/tsc-22 - priority 100 slave tsserver: /usr/bin/tsserver-22 /usr/bin/tsc-20 - priority 100 slave tsserver: /usr/bin/tsserver-20 Current 'best' version is /usr/bin/tsc-22. # Check versions printed by executables $ node -v v20.19.5 $ tsc -v Version 5.9.2 # while the node is 20, tsc is executed by node 22 anyway $ head -1 /usr/bin/tsc #!/usr/bin/node-22 # However, instead of default executable names, e.g. node or tsc, # we can use namespaced names to target any installed version $ node-20 -v v20.19.5 $ node-22 -v v22.19.0 $ tsc-20 -v Version 5.9.2 $ tsc-22 -v Version 5.9.2 $ head -1 /usr/bin/tsc-20 #!/usr/bin/node-20 $ head -1 /usr/bin/tsc-22 #!/usr/bin/node-22 ```