Termino traducción seccion "JavaScript Behind Scenes".

Termino la traducción.

Author: hamfree

es/behind-scenes/README.md

@@ -2,46 +2,37 @@
 layout: editorial
 chapter: 27
 pageNumber: 256
-description: JavaScript behind the scenes.
+description: JavaScript detrás de escena.
 ---
 
-## JavaScript Behind the Scenes
+# Capítulo 27
 
-JavaScript is a versatile language that runs in various environments, including browsers and servers. Understanding how
-JavaScript works behind the scenes can help you write more efficient and effective code. This guide covers key concepts
-such as the JavaScript engine, execution context, call stack, memory heap, runtime environment, and event loop.
+## JavaScript detrás de escena
 
-### JavaScript Engine
+JavaScript es un lenguaje versátil que se ejecuta en varios entornos, incluidos navegadores y servidores. Comprender cómo funciona JavaScript en segundo plano puede ayudarlo a escribir código más eficiente y eficaz. Esta guía cubre conceptos clave como el motor de JavaScript, el contexto de ejecución, la pila de llamadas, el montón de memoria, el entorno de ejecución y el bucle de eventos.
 
-A JavaScript engine is a program or interpreter that executes JavaScript code. Popular engines like V8 (used in Google
-Chrome and Node.js), SpiderMonkey (used in Firefox), and JavaScriptCore (used in Safari) parse the code into an Abstract
-Syntax Tree (AST), compile it into bytecode or machine code, and then execute it.
+### Motor de JavaScript
 
-### Execution Context
+Un motor de JavaScript es un programa o intérprete que ejecuta código JavaScript. Los motores populares como V8 (usado en Google Chrome y Node.js), SpiderMonkey (usado en Firefox) y JavaScriptCore (usado en Safari) analizan el código en un árbol de sintaxis abstracta (AST), lo compilan en código de bytes o código de máquina y luego lo ejecutan.
 
-An execution context is an environment where JavaScript code is evaluated and executed. There are three types: global,
-function, and eval. Each context has a creation phase, where variables, functions, and the `this` keyword are created,
-and an execution phase, where the code is executed line by line.
+### Contexto de ejecución
 
-### Call Stack
+Un contexto de ejecución es un entorno en el que se evalúa y ejecuta el código JavaScript. Hay tres tipos: global,
+función y evaluación. Cada contexto tiene una fase de creación, donde se crean las variables, las funciones y la palabra clave `this`, y una fase de ejecución, donde se ejecuta el código línea por línea.
 
-The call stack is a data structure that keeps track of function calls in a Last-In, First-Out (LIFO) manner. It helps
-the JavaScript engine manage the execution of multiple functions by pushing and popping function calls as they are
-invoked and completed.
+### Pila de llamadas
 
-### Memory Heap
+La pila de llamadas es una estructura de datos que realiza un seguimiento de las llamadas a funciones en el modo LIFO (último en entrar, primero en salir). Ayuda al motor de JavaScript a gestionar la ejecución de múltiples funciones al enviar y recibir llamadas a funciones a medida que se invocan y se completan.
 
-The memory heap is a region in memory where objects are stored. JavaScript uses garbage collection to manage memory,
-automatically freeing up memory that is no longer in use, thus preventing memory leaks and optimizing performance.
+### Montón de memoria
 
-### Runtime Environment
+El montón de memoria es una región de la memoria donde se almacenan los objetos. JavaScript utiliza la recolección de elementos no utilizados para administrar la memoria, liberando automáticamente la memoria que ya no se utiliza, lo que evita fugas de memoria y optimiza el rendimiento.
 
-The runtime environment provides the necessary resources for JavaScript to execute. In a browser, this includes the
-Document Object Model (DOM), Web APIs, and the JavaScript engine. In Node.js, it includes the file system, HTTP module,
-and other Node.js-specific APIs.
+### Entorno de ejecución
 
-### Event Loop
+El entorno de ejecución proporciona los recursos necesarios para que JavaScript se ejecute. En un navegador, esto incluye el
+modelo de objetos de documento (DOM), las API web y el motor de JavaScript. En Node.js, incluye el sistema de archivos, el módulo HTTP y otras API específicas de Node.js.
 
-The event loop allows JavaScript to perform non-blocking operations by offloading tasks to the system kernel whenever
-possible. It continuously checks the call stack and processes the callback queue, enabling asynchronous programming and
-efficient execution of code.
+### Bucle de eventos
+
+El bucle de eventos permite que JavaScript realice operaciones sin bloqueos al transferir tareas al núcleo del sistema siempre que sea posible. Verifica continuamente la pila de llamadas y procesa la cola de devolución de llamadas, lo que permite la programación asincrónica y la ejecución eficiente del código.

es/behind-scenes/call-stack.md

@@ -1,75 +1,75 @@
 ---
 chapter: 27
 pageNumber: 257
-description: Understanding Call Stacks in JavaScript 
+description: Comprensión de las pilas de llamadas en JavaScript
 ---
 
 
-## Understanding Call Stacks in JavaScript
+# Comprensión de las pilas de llamadas en JavaScript
 
-In JavaScript, a Call Stack is a data structure that uses the Last-In, First-Out (LIFO) principle to temporarily store and manage function invocation (call).
+En JavaScript, una pila de llamadas es una estructura de datos que utiliza el principio de último en entrar, primero en salir (LIFO) para almacenar y administrar temporalmente la invocación de una función (llamada).
 
-### What is a Call Stack?
+## ¿Qué es una pila de llamadas?
 
-A call stack is responsible for keeping track of function calls in your code. The call stack helps the JavaScript interpreter to keep track of what function is currently being run and what functions are called from within that function, and so on.
+Una pila de llamadas es responsable de realizar un seguimiento de las llamadas a funciones en su código. La pila de llamadas ayuda al intérprete de JavaScript a realizar un seguimiento de qué función se está ejecutando actualmente y qué funciones se invocan desde dentro de esa función, etc.
 
-When a script calls a function, JavaScript's interpreter adds that function to the call stack and then starts carrying out the function. Any functions that are called by that function are added to the call stack further up, and run where their calls are reached.
+Cuando un script llama a una función, el intérprete de JavaScript agrega esa función a la pila de llamadas y luego comienza a ejecutarla. Todas las funciones que son llamadas por esa función se agregan a la pila de llamadas más arriba y se ejecutan donde se alcanzan sus llamadas.
 
-When the current function is finished, the interpreter takes it off the stack and resumes execution where it left off in the last line of code that was run.
+Cuando finaliza la función actual, el intérprete la saca de la pila y reanuda la ejecución donde la dejó en la última línea de código que se ejecutó.
 
-### Example of a Call Stack
+### Ejemplo de una pila de llamadas
 
-Here's a basic example to understand how a call stack works:
+A continuación se muestra un ejemplo básico para comprender cómo funciona una pila de llamadas:
 
 ```javascript
-function firstFunction() {
-    console.log("First function is called.");
-    secondFunction();
-    console.log("First function is done.");
+function primeraFuncion() {
+    console.log("Se llama la primera función.");
+    segundaFuncion();
+    console.log("La primera función está realizada.");
 }
 
-function secondFunction() {
-    console.log("Second function is called.");
-    thirdFunction();
-    console.log("Second function is done.");
+function segundaFuncion() {
+    console.log("Se llama la segunda función.");
+    terceraFuncion();
+    console.log("La segunda función está realizada.");
 }
 
-function thirdFunction() {
-    console.log("Third function is called.");
+function terceraFuncion() {
+    console.log("Se llama la tercera función.");
 }
 
-firstFunction();
+primeraFuncion();
 ```
 
 **Output:**
-```
-First function is called.
-Second function is called.
-Third function is called.
-Second function is done.
-First function is done.
+
+```text
+Se llama la primera función.
+Se llama la segunda función.
+Se llama la tercera función.
+La segunda función está realizada.
+La primera función está realizada.
 ```
 
-### How the Call Stack Works
+## Cómo funciona la pila de llamadas
 
-1. When `firstFunction` is called, it is added to the call stack.
-2. Inside `firstFunction`, `secondFunction` is called, so it is added to the call stack.
-3. Inside `secondFunction`, `thirdFunction` is called, so it is added to the call stack.
-4. `thirdFunction` completes and is removed from the call stack.
-5. `secondFunction` resumes, completes, and is removed from the call stack.
-6. `firstFunction` resumes, completes, and is removed from the call stack.
+1. Cuando se llama a `primeraFuncion`, se agrega a la pila de llamadas.
+2. Dentro de `primeraFuncion`, se llama a `segundaFuncion`, por lo que se agrega a la pila de llamadas.
+3. Dentro de `segundaFuncion`, se llama a `terceraFuncion`, por lo que se agrega a la pila de llamadas.
+4. `terceraFuncion` se completa y se elimina de la pila de llamadas.
+5. `segundaFuncion` se reanuda, se completa y se elimina de la pila de llamadas.
+6. `primeraFuncion` se reanuda, se completa y se elimina de la pila de llamadas.
 
-### Stack Overflow
+## Desbordamiento de pila
 
-A stack overflow occurs when there are too many function calls in the call stack. This can happen with recursive functions that do not have a base case to stop the recursion.
+Un desbordamiento de pila ocurre cuando hay demasiadas llamadas de función en la pila de llamadas. Esto puede suceder con funciones recursivas que no tienen un caso base para detener la recursión.
 
 ```javascript
-function recursiveFunction() {
-    recursiveFunction();
+function funcionRecursiva() {
+    funcionRecursiva();
 }
 
-recursiveFunction();
+funcionRecursiva();
 ```
 
-This will result in a "Maximum call stack size exceeded" error.
-
+Esto generará un error "Se excedió el tamaño máximo de la pila de llamadas" (En la consola aparecerá el error en inglés: "RangeError: Maximum call stack size exceeded").

es/behind-scenes/engine.md

@@ -1,92 +1,93 @@
 ---
 chapter: 27
 pageNumber: 258
-description: Understanding JavaScript Engines and how they execute JavaScript code. 
+description: Comprender los motores de JavaScript y cómo ejecutan el código JavaScript. 
 ---
 
-## Understanding JavaScript Engines
+# Comprender los motores de JavaScript y cómo ejecutan el código JavaScript
 
-A JavaScript engine is a program or an interpreter that executes JavaScript code. The most well-known JavaScript engines are V8 (used in Google Chrome and Node.js), SpiderMonkey (used in Firefox), and JavaScriptCore (used in Safari).
+Un motor de JavaScript es un programa o intérprete que ejecuta código JavaScript. Los motores de JavaScript más conocidos son V8 (utilizado en Google Chrome y Node.js), SpiderMonkey (utilizado en Firefox) y JavaScriptCore (utilizado en Safari).
 
-### How JavaScript Engines Work
+## Cómo funcionan los motores de JavaScript
 
-JavaScript engines perform several key tasks to execute JavaScript code efficiently:
+Los motores de JavaScript realizan varias tareas clave para ejecutar el código JavaScript de manera eficiente:
 
-1. **Parsing**: The engine parses the JavaScript code into an Abstract Syntax Tree (AST).
-2. **Compilation**: The AST is then compiled into bytecode or machine code.
-3. **Execution**: The compiled code is executed by the engine.
+1. **Análisis**: El motor analiza el código JavaScript en un árbol de sintaxis abstracta (AST).
+2. **Compilación**: Luego, el AST se compila en código de bytes o código de máquina.
+3. **Ejecución**: El código compilado es ejecutado por el motor.
 
-### Example of JavaScript Engine Workflow
+### Ejemplo de flujo de trabajo del motor JavaScript
 
-Here's a simple example to illustrate the workflow of a JavaScript engine:
+A continuación se muestra un ejemplo sencillo para ilustrar el flujo de trabajo de un motor de JavaScript:
 
-```javascript
-function add(a, b) {
+````javascript
+function agrega(a, b) {
     return a + b;
 }
 
-console.log(add(2, 3)); // Output: 5
-```
-
-### Parsing
-
-The engine first parses the code into an AST. For the above code, the AST might look something like this:
-
-```
-Program
- ├── FunctionDeclaration (add)
- │   ├── Identifier (a)
- │   ├── Identifier (b)
- │   └── BlockStatement
- │       └── ReturnStatement
- │           └── BinaryExpression (+)
- │               ├── Identifier (a)
- │               └── Identifier (b)
- └── ExpressionStatement
-     └── CallExpression (console.log)
-         └── CallExpression (add)
+console.log(agrega(2, 3)); // Salida: 5
+````
+
+### Análisis
+
+El motor primero analiza el código y lo convierte en un AST. Para el código anterior, el AST podría verse así:
+
+```text
+Programacion
+ ├── DeclaracionFuncion (agrega)
+ │   ├── Identificador (a)
+ │   ├── Identificador (b)
+ │   └── SentenciaDeBloque
+ │       └── SentenciaReturn
+ │           └── ExpresionBinaria (+)
+ │               ├── Identificador (a)
+ │               └── Identificador (b)
+ └── SentenciaExpresion
+     └── LlamadaExpresion (console.log)
+         └── LlamadaExpresion (agrega)
              ├── Literal (2)
              └── Literal (3)
 ```
 
-### Compilation
+### Compilación
 
-The AST is then compiled into bytecode or machine code. This step involves optimizations to improve performance.
+Luego, el AST se compila en código de bytes o código de máquina. Este paso implica optimizaciones para mejorar el rendimiento.
 
-### Execution
+### Ejecución
 
-The compiled code is executed by the engine. In this case, the `add` function is called with arguments `2` and `3`, and the result `5` is logged to the console.
+El motor ejecuta el código compilado. En este caso, se llama a la función `add` con los argumentos `2` y `3`, y el resultado `5` se registra en la consola.
 
-### Just-In-Time (JIT) Compilation
+### Compilación Just-In-Time (JIT)
 
-Modern JavaScript engines use Just-In-Time (JIT) compilation to improve performance. JIT compilation involves compiling code at runtime, rather than before execution. This allows the engine to optimize the code based on actual usage patterns.
+Los motores de JavaScript modernos utilizan la compilación Just-In-Time (JIT) para mejorar el rendimiento. La compilación JIT implica compilar el código en tiempo de ejecución, en lugar de antes de la ejecución. Esto permite que el motor optimice el código en función de los patrones de uso reales.
 
-### Example of JIT Compilation
+### Ejemplo de compilación JIT
 
 ```javascript
-function multiply(a, b) {
+function multiplica(a, b) {
     return a * b;
 }
 
 for (let i = 0; i < 1000000; i++) {
-    multiply(2, 3);
+    multiplica(2, 3);
 }
 ```
 
-In this example, the `multiply` function is called repeatedly. A JIT compiler can optimize the function after detecting that it is a hot function (i.e., frequently called).
+En este ejemplo, la función `multiplica` se llama repetidamente. Un compilador JIT puede optimizar la función después de detectar que es una función activa (es decir, que se llama con frecuencia).
 
-### Garbage Collection
+### Recolección de basura
 
-JavaScript engines also include garbage collectors to manage memory. The garbage collector automatically frees up memory that is no longer in use, preventing memory leaks.
+Los motores de JavaScript también incluyen recolectores de basura para administrar la memoria. El recolector de basura libera automáticamente la memoria que ya no se utiliza, lo que evita fugas de memoria.
 
-### Example of Garbage Collection
+### Ejemplo de Recolección de Basura
 
 ```javascript
-function createObject() {
-    return { name: "Object" };
+function creaObjeto() {
+    return { nombre: "Objeto" };
 }
 
-let obj = createObject();
-obj = null; // The object is now eligible for garbage collection
+let obj = creaObjeto();
+obj = null; // El objeto ahora es elegible para la recolección de basura.
 ```
-In this example, the object created by `createObject` is eligible for garbage collection after `obj` is set to `null`.
+
+En este ejemplo, el objeto creado por `creaObjeto` es elegible para la recolección de basura después de que `obj` se establece en `null`.