@babel/parser

Traducción Beta No Oficial

Esta página fue traducida por PageTurner AI (beta). No está respaldada oficialmente por el proyecto. ¿Encontraste un error? Reportar problema →

The Babel parser (previously Babylon) is a JavaScript parser used in Babel.

La última versión de ECMAScript habilitada por defecto (ES2020).
Vinculación de comentarios.
Soporte para JSX, Flow, TypeScript.
Soporte para propuestas experimentales del lenguaje (aceptamos PRs para cualquier propuesta al menos en stage-0).

Créditos

Basado en gran medida en acorn y acorn-jsx, gracias al increíble trabajo de @RReverser y @marijnh.

API

`babelParser.parse(code, [options])`

`babelParser.parseExpression(code, [options])`

parse() analiza el code proporcionado como un programa completo de ECMAScript, mientras que parseExpression() intenta analizar una única Expression con foco en el rendimiento. En caso de duda, usa .parse().

Opciones

History

Version	Changes
`v7.28.0`	Added `sourceType: "commonjs"`
`v7.27.0`	Added `allowYieldOutsideFunction`
`v7.26.0`	Added `startIndex`
`v7.23.0`	Added `createImportExpressions`
`v7.21.0`	Added `allowNewTargetOutsideFunction` and `annexB`
`v7.16.0`	Added `startColumn`
`v7.15.0`	Added `attachComment`
`v7.7.0`	Added `errorRecovery`
`v7.5.0`	Added `allowUndeclaredExports`
`v7.2.0`	Added `createParenthesizedExpressions`

allowImportExportEverywhere: Por defecto, las declaraciones import y export solo pueden aparecer en el nivel superior de un programa. Al establecer esta opción en true, se permiten en cualquier lugar donde se permita una sentencia.
allowAwaitOutsideFunction: Por defecto, el uso de await solo se permite dentro de una función asíncrona o, cuando el plugin topLevelAwait está habilitado, en el ámbito de nivel superior de los módulos. Establece esta opción en true para aceptarlo también en el ámbito de nivel superior de los scripts. Esta opción se desaconseja en favor del plugin topLevelAwait.
allowYieldOutsideFunction: Por defecto, el uso de yield solo se permite dentro de una función generadora. Establece esta opción en true para aceptarlo también en el nivel superior.
allowNewTargetOutsideFunction: Por defecto, el uso de new.target no está permitido fuera de una función o clase. Establece esta opción en true para aceptar dicho código.
allowReturnOutsideFunction: Por defecto, una sentencia return en el nivel superior genera un error. Establece esta opción en true para aceptar dicho código.
allowSuperOutsideMethod: Por defecto, el uso de super no está permitido fuera de métodos de clase u objeto. Establece esta opción en true para aceptar dicho código.
allowUndeclaredExports: Por defecto, exportar un identificador que no ha sido declarado en el ámbito del módulo actual generará un error. Si bien este comportamiento es requerido por la especificación de módulos ECMAScript, el parser de Babel no puede anticipar transformaciones posteriores en la cadena de plugins que podrían insertar las declaraciones apropiadas, por lo que a veces es importante establecer esta opción en true para evitar que el parser se queje prematuramente sobre exportaciones no declaradas que se agregarán más tarde.
attachComment: Por defecto, Babel vincula los comentarios a los nodos AST adyacentes. Cuando esta opción se establece en false, los comentarios no se vinculan. Puede proporcionar una mejora de rendimiento de hasta el 30% cuando el código de entrada tiene muchos comentarios. @babel/eslint-parser lo establecerá automáticamente. No se recomienda usar attachComment: false con la transformación de Babel, ya que elimina todos los comentarios en el código de salida, e inutiliza anotaciones como /* istanbul ignore next */.
annexB: Por defecto, Babel analiza JavaScript según la sintaxis del Anexo B de ECMAScript "Características Adicionales de ECMAScript para Navegadores Web". Cuando esta opción se establece en false, Babel analizará la sintaxis sin las extensiones específicas del Anexo B.
createImportExpressions: Por defecto, el analizador interpreta la importación dinámica import() como nodos de expresión de llamada. Cuando esta opción se establece en true, se crean nodos AST ImportExpression en su lugar. Esta opción será true por defecto en Babel 8.
createParenthesizedExpressions: Por defecto, el analizador establece extra.parenthesized en los nodos de expresión. Cuando esta opción se establece en true, se crean nodos AST ParenthesizedExpression en su lugar.
errorRecovery: Por defecto, Babel siempre lanza un error al encontrar código inválido. Cuando esta opción se establece en true, almacenará el error de análisis e intentará continuar analizando el archivo de entrada inválido. El AST resultante tendrá una propiedad errors que representa un arreglo con todos los errores de análisis. Nota: incluso con esta opción habilitada, @babel/parser podría lanzar errores irrecuperables.
plugins: Arreglo que contiene los plugins que deseas habilitar.
sourceType: Indica el modo en que debe analizarse el código. Puede ser "script", "commonjs", "module" o "unambiguous". Por defecto es "script". "unambiguous" hará que @babel/parser intente adivinar el modo basándose en la presencia de sentencias ES6 import o export. Los archivos con imports y exports ES6 se consideran "module"; en caso contrario, "script".

El modo "commonjs" indica que el código debe ejecutarse en un entorno CommonJS como Node.js. Es mayormente compatible con el modo "script", excepto que se permiten declaraciones return, new.target y using/await using en el nivel superior.
sourceFilename: Correlaciona los nodos AST de salida con su nombre de archivo fuente. Útil al generar código y mapas de fuente desde ASTs de múltiples archivos de entrada.
startColumn: Por defecto, el código analizado se trata como si comenzara en línea 1, columna 0. Puedes proporcionar un número de columna alternativo para iniciar. Útil para integración con otras herramientas de código fuente.
startLine: Por defecto, el código analizado se trata como si comenzara en línea 1, columna 0. Puedes proporcionar un número de línea alternativo para iniciar. Útil para integración con otras herramientas de código fuente.
startIndex: Por defecto, todos los índices fuente comienzan desde 0. Con esta opción puedes proporcionar un índice inicial alternativo. Para garantizar índices fuente AST precisos, siempre debe proporcionarse esta opción cuando startLine sea mayor que 1. Útil para integración con otras herramientas de código fuente.
strictMode: Por defecto, el código ECMAScript se analiza como estricto solo si está presente una directiva "use strict"; o si el archivo analizado es un módulo ECMAScript. Establece esta opción en true para analizar siempre archivos en modo estricto.
ranges: Añade una propiedad range a cada nodo: [node.start, node.end]
tokens: Añade todos los tokens analizados a una propiedad tokens en el nodo File

Salida

El analizador de Babel genera AST según el [formato AST de Babel][]. Se basa en la [especificación ESTree][] con las siguientes desviaciones:

El token Literal se reemplaza por StringLiteral, NumericLiteral, BigIntLiteral, BooleanLiteral, NullLiteral, RegExpLiteral
El token Property se reemplaza por ObjectProperty y ObjectMethod
MethodDefinition se reemplaza por ClassMethod y ClassPrivateMethod
PropertyDefinition se reemplaza por ClassProperty y ClassPrivateProperty
PrivateIdentifier se reemplaza por PrivateName
Program y BlockStatement contienen un campo adicional directives con Directive y DirectiveLiteral
Las propiedades del campo value en ClassMethod, ClassPrivateMethod, ObjectProperty y ObjectMethod se integran/coercionan en el nodo principal del método cuando se usan como FunctionExpression.
ChainExpression se reemplaza por OptionalMemberExpression y OptionalCallExpression
ImportExpression se reemplaza por una CallExpression donde callee es un nodo Import. Este cambio se revertirá en Babel 8.
ExportAllDeclaration con campo exported se reemplaza por una ExportNamedDeclaration que contiene un nodo ExportNamespaceSpecifier.

nota

El plugin estree puede revertir estas desviaciones. Úsalo solo si estás pasando el AST de Babel a otras herramientas compatibles con ESTree.

El AST para código JSX está basado en [Facebook JSX AST][].

Semver

El analizador de Babel sigue semver en la mayoría de situaciones. Lo único a destacar es que algunas correcciones de errores de conformidad con las especificaciones pueden publicarse en versiones de parche.

Por ejemplo: Corregimos un error para detectar previamente algo como #107 - múltiples exportaciones default por archivo. Esto se consideraría una corrección de error aunque hiciera fallar una compilación.

Ejemplo

JavaScript
require("@babel/parser").parse("code", {
  // parse in strict mode and allow module declarations
  sourceType: "module",

  plugins: [
    // enable jsx and flow syntax
    "jsx",
    "flow",
  ],
});

Plugins

Misceláneos

Name	Code Example
`estree` (repo)	n/a

Extensiones de lenguaje

History

Version	Changes
`v7.6.0`	Added `v8intrinsic`

Name	Code Example
`flow` (repo)	`var a: string = "";`
`flowComments` (docs)	`/:: type Foo = {...}; /`
`jsx` (repo)	`<a attr="b">{s}</a>`
`typescript` (repo)	`var a: string = "";`
`v8intrinsic`	`%DebugPrint(foo);`

Propuestas de ECMAScript

History

Version	Changes
`v7.23.0`	Added `sourcePhaseImports`, `deferredImportEvaluation`, `optionalChainingAssign`
`v7.22.0`	Enabled `regexpUnicodeSets` by default, added `importAttributes`
`v7.20.0`	Added `explicitResourceManagement`, `importReflection`
`v7.17.0`	Added `regexpUnicodeSets`, `destructuringPrivate`, `decoratorAutoAccessors`
`v7.15.0`	Added `hack` to the `proposal` option of `pipelineOperator`. Moved `topLevelAwait`, `privateIn` to Latest ECMAScript features
`v7.14.0`	Added `asyncDoExpressions`. Moved `classProperties`, `classPrivateProperties`, `classPrivateMethods`, `moduleStringNames` to Latest ECMAScript features
`v7.13.0`	Added `moduleBlocks`
`v7.12.0`	Added `classStaticBlock`, `moduleStringNames`
`v7.11.0`	Added `decimal`
`v7.10.0`	Added `privateIn`
`v7.9.0`	Added `recordAndTuple`
`v7.7.0`	Added `topLevelAwait`
`v7.4.0`	Added `partialApplication`
`v7.2.0`	Added `classPrivateMethods`

Name	Code Example
`asyncDoExpressions` (proposal)	`async do { await requestAPI().json() }`
`decimal` (proposal)	`0.3m`
`decorators` (proposal) `decorators-legacy`	`@a class A {}`
`decoratorAutoAccessors` (proposal)	`class Example { @reactive accessor myBool = false; }`
`deferredImportEvaluation` (proposal)	`import defer * as ns from "dep";`
`deprecatedImportAssert` (⚠️ deprecated, legacy syntax of import attributes) `importAssertions` (⚠️ deprecated)	`import json from "./foo.json" assert { type: "json" };`
`destructuringPrivate` (proposal)	`class Example { #x = 1; method() { const { #x: x } = this; } }`
`doExpressions` (proposal)	`var a = do { if (true) { 'hi'; } };`
`explicitResourceManagement` (proposal)	`using reader = getReader()`
`exportDefaultFrom` (proposal)	`export v from "mod"`
`functionBind` (proposal)	`a::b`, `::console.log`
`functionSent` (proposal)	`function.sent`
`importReflection` (proposal)	`import module foo from "./foo.wasm";`
`moduleBlocks` (proposal)	`let m = module { export let y = 1; };`
`optionalChainingAssign` (proposal)	`x?.prop = 2`
`partialApplication` (proposal)	`f(?, a)`
`pipelineOperator` (proposal)	`a \|> b`
`recordAndTuple` (proposal)	`#{x: 1}`, `#[1, 2]`
`sourcePhaseImports` (proposal)	`import source x from "./x"`
`throwExpressions` (proposal)	`() => throw new Error("")`

Latest ECMAScript features

The following features are already enabled on the latest version of @babel/parser, and cannot be disabled because they are part of the language. You should enable these features only if you are using an older version.

Name	Code Example
`asyncGenerators` (proposal)	`async function*() {}`, `for await (let a of b) {}`
`bigInt` (proposal)	`100n`
`classProperties` (proposal)	`class A { b = 1; }`
`classPrivateProperties` (proposal)	`class A { #b = 1; }`
`classPrivateMethods` (proposal)	`class A { #c() {} }`
`classStaticBlock` (proposal)	`class A { static {} }`
`dynamicImport` (proposal)	`import('./guy').then(a)`
`exportNamespaceFrom` (proposal)	`export * as ns from "mod"`
`logicalAssignment` (proposal)	`a &&= b`
`moduleStringNames` (proposal)	`import { "😄" as smile } from "emoji";`
`nullishCoalescingOperator` (proposal)	`a ?? b`
`numericSeparator` (proposal)	`1_000_000`
`objectRestSpread` (proposal)	`var a = { b, ...c };`
`optionalCatchBinding` (proposal)	`try {throw 0;} catch{do();}`
`optionalChaining` (proposal)	`a?.b`
`privateIn` (proposal)	`#p in obj`
`regexpUnicodeSets` (proposal)	`/[\p{Decimal_Number}--[0-9]]/v;`
`topLevelAwait` (proposal)	`await promise` in modules
`importAttributes` (proposal)	`import json from "./foo.json" with { type: "json" };`

Opciones de plugins

History

Version	Changes
`7.21.0`	The default behavior of the `decorators`' `decoratorsBeforeExport` option is to allow decorators either before or after the `export` keyword.
`7.19.0`	The `syntaxType` option of the `recordAndTuple` plugin defaults to `hash`; added `allowCallParenthesized` option for the `decorators` plugin.
`7.17.0`	Added `@@` and `^^` to the `topicToken` option of the `hack` pipeline operator
`7.16.0`	Added `disallowAmbiguousJSXLike` for `typescript` plugin. Added `^` to the `topicToken` option of the `hack` pipeline operators
`7.14.0`	Added `dts` for `typescript` plugin

nota

Cuando un plugin se especifica múltiples veces, solo se consideran las primeras opciones.

decorators:
- allowCallParenthesized (boolean, valor por defecto: true)
  
  Cuando es false, deshabilita decoradores en la forma @(...)() en favor de @(...()). La propuesta de decoradores etapa 3 usa allowCallParenthesized: false.
- decoratorsBeforeExport (boolean)
  
  Por defecto, los decoradores en clases exportadas pueden colocarse antes o después de la palabra clave export. Cuando se establece esta opción, los decoradores solo se permitirán en la posición especificada.
  JavaScript
```
// decoratorsBeforeExport: true
@dec
export class C {}

// decoratorsBeforeExport: false
export @dec class C {}
```
  precaución
  Esta opción está obsoleta y se eliminará en una versión futura. El código válido cuando esta opción se establece explícitamente como true o false también es válido cuando no se establece.
optionalChainingAssign:
- version (requerido, valores aceptados: 2023-07) Esta propuesta aún está en Etapa 1, por lo que es probable que sufra cambios con ruptura de compatibilidad. Debes especificar qué versión de la propuesta estás usando para garantizar que Babel continúe analizando tu código de manera compatible.
pipelineOperator:
- proposal (requerido, valores aceptados: fsharp, hack, ~~minimal~~, ~~smart~~ (obsoleto)) Existen varias propuestas diferentes para el operador pipeline. Esta opción elige qué propuesta usar. Consulta plugin-proposal-pipeline-operator para más información, incluyendo una tabla comparativa de su comportamiento.
- topicToken (requerido cuando proposal es hack, valores aceptados: %, #, ^, @@, ^^) La propuesta hack utiliza un marcador de posición "topic" en su pipeline. Existen dos opciones diferentes para este marcador de posición. Esta opción elige qué token usar para referirse al tema.

recordAndTuple:
- syntaxType (hash o bar, predeterminado: hash) Existen dos variantes sintácticas para recordAndTuple que comparten exactamente la misma semántica en tiempo de ejecución.
  SyntaxType Ejemplo de Record Ejemplo de Tuple
  "hash" #{ a: 1 } #[1, 2]
  "bar" {| a: 1 |} [|1, 2|]
  Consulta Ergonomía de #{}/#[] para más información.

SyntaxType	Ejemplo de Record	Ejemplo de Tuple
`"hash"`	`#{ a: 1 }`	`#[1, 2]`
`"bar"`	`{\| a: 1 \|}`	`[\|1, 2\|]`
Consulta Ergonomía de `#{}`/`#[]` para más información.

flow:
- all (boolean, predeterminado: false) Algunos códigos tienen significado diferente en Flow y en JavaScript estándar. Por ejemplo, foo<T>(x) se analiza como una expresión de llamada con un argumento de tipo en Flow, pero como una comparación (foo < T > x) según la especificación ECMAScript. Por defecto, babel-parser analiza estas construcciones ambiguas como tipos de Flow solo si el archivo comienza con el pragma // @flow. Establece esta opción en true para analizar siempre los archivos como si se hubiera especificado // @flow.
typescript
- dts (boolean, predeterminado false) Esta opción habilitará el análisis dentro de un contexto ambiental de TypeScript, donde ciertas sintaxis tienen reglas diferentes (como archivos .d.ts y dentro de bloques declare module). Consulta https://www.typescriptlang.org/docs/handbook/declaration-files/introduction.html y https://basarat.gitbook.io/typescript/type-system/intro para más información sobre contextos ambientales.
- disallowAmbiguousJSXLike (boolean, predeterminado false) Incluso cuando el plugin jsx no está habilitado, esta opción prohíbe usar sintaxis que sería ambigua con JSX (aseveraciones de tipo <X> y y argumentos de tipo <X>() => {}). Coincide con el comportamiento de tsc al analizar archivos .mts y .mjs.

importAttributes:
- deprecatedAssertSyntax (boolean, predeterminado: false)
  
  Cuando es true, permite analizar una versión antigua de los atributos de importación, que usaba la palabra clave assert en lugar de with.
  
  Esto coincide con la sintaxis originalmente soportada por el plugin de análisis importAssertions.

Códigos de error

History

Version	Changes
`v7.14.0`	Added error codes

Los códigos de error son útiles para manejar los errores lanzados por @babel/parser.

Existen dos códigos de error: code y reasonCode.

code
- Clasificación general de errores (ej. BABEL_PARSER_SYNTAX_ERROR, BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED).
reasonCode
- Clasificación detallada de errores (ej. MissingSemicolon, VarRedeclaration).

Ejemplo de uso de códigos de error con errorRecovery:

JavaScript
const { parse } = require("@babel/parser");

const ast = parse(`a b`, { errorRecovery: true });

console.log(ast.errors[0].code); // BABEL_PARSER_SYNTAX_ERROR
console.log(ast.errors[0].reasonCode); // MissingSemicolon

Preguntas frecuentes

¿Soportará el parser de Babel un sistema de plugins?

Incidencias anteriores: #1351, #6694.

Actualmente no estamos dispuestos a comprometernos a mantener la API para plugins ni el ecosistema resultante (ya hay suficiente trabajo manteniendo el propio sistema de plugins de Babel). No está claro cómo hacer que dicha API sea efectiva, y limitaría nuestra capacidad para refactorizar y optimizar la base de código.

Nuestra recomendación actual para quienes deseen crear su propia sintaxis personalizada es que los usuarios bifurquen (fork) el parser.

Para utilizar tu parser personalizado, puedes agregar un plugin en tus opciones para invocar al parser mediante su nombre de paquete npm o requerirlo si usas JavaScript,

JavaScript
const parse = require("custom-fork-of-babel-parser-on-npm-here");

module.exports = {
  plugins: [
    {
      parserOverride(code, opts) {
        return parse(code, opts);
      },
    },
  ],
};

Créditos​

API​

babelParser.parse(code, [options])​

babelParser.parseExpression(code, [options])​

Opciones​

Salida​

Semver​

Ejemplo​

Plugins​

Misceláneos​

Extensiones de lenguaje​

Propuestas de ECMAScript​

Latest ECMAScript features​

Opciones de plugins​

Códigos de error​

Preguntas frecuentes​

¿Soportará el parser de Babel un sistema de plugins?​

Créditos

API

`babelParser.parse(code, [options])`

`babelParser.parseExpression(code, [options])`

Opciones

Salida

Semver

Ejemplo

Plugins

Misceláneos

Extensiones de lenguaje

Propuestas de ECMAScript

Latest ECMAScript features

Opciones de plugins

Códigos de error

Preguntas frecuentes

¿Soportará el parser de Babel un sistema de plugins?