Javascript Avanzado en Español
  • Introducción
  • I- Up & Going
    • 0- Prefacio
    • 1- En la programación
      • 1.1 Código
      • 1.2 Inténtalo tú mismo
      • 1.3 Operadores
      • 1.4 Valores y Tipos
      • 1.5 Comentarios del Código
      • 1.6 Variables
      • 1.7 Bloques
      • 1.8 Condicionales
      • 1.9 Bucles
      • 1.10 Funciones
      • 1.11 Scope (Ámbito)
      • 1.12 Práctica
      • 1.13 - Revisión
    • 2- En Javascript
      • 2.1 Valores y Tipos
      • 2.2 Variables
      • 2.3 Condicionales
      • 2.4 Modo estricto
      • 2.5 Funciones como Valores
      • 2.6 Identificador This
      • 2.7 Prototypes
      • 2.8 Lo Viejo y Lo Nuevo
      • 2.9 Non-JavaScript
      • 2.10 Revisión
    • 3- En YDKJS
      • 3.1 Scope & Closures
      • 3.2 This & Object Prototypes
      • 3.3 Tipos & Gramática
      • 3.4 Async & Performance
      • 3.5 ES6 & Más allá
      • 3.6 Revisión
  • II- Scope & Closures
    • 0- Prefacio
    • 1- ¿Qué es el Scope?
      • 1.1 Teoría del Compilador
      • 1.2 Entendiendo el Scope
      • 1.3 Scopes Anidados
      • 1.4 Errores
      • 1.5 Revisión
    • 2- Lexical Scope
      • 2.1 Tiempo de Lex
      • 2.2 Trucos léxicos
      • 2.3 Revisión
    • 3- Function vs. Block Scope
      • 3.1 Ámbito de las funciones
      • 3.2 Ocultación en el ámbito común
      • 3.3 Funciones como ámbitos
      • 3.4 Bloques como ámbitos
      • 3.5 Revisión (TL; DR)
    • 4- Hoisting
      • 4.1 ¿El Huevo o la Gallina?
      • 4.2 El compilador pega de nuevo
      • 4.3 Funciones Primero
      • 4.4 Revisión
    • 5- Scope Closure
      • 5.1 Ilustración
      • 5.2 Nitty Gritty
      • 5.3 Ahora puedo ver
      • 5.4 Loops + Closure
      • 5.5 Módulos
      • 5.6 Revisión
    • 6- Scope Dinámico
    • 7- Ámbito de bloque de Polyfilling
      • 7.1 Traceur
      • 7.2 Bloques implícitos vs. explícitos
      • 7.3 Rendimiento
    • 8- Lexical-this
  • III- this & Object Prototypes
    • 0- Prefacio
    • 1- this o That?
      • 1.1 ¿Porque this?
      • 1.2 Confusiones
      • 1.3 ¿Que es this?
      • 1.4 Revisión
    • 2- this, todo tiene sentido ahora!
      • 2.1 Sitio de llamada
      • 2.2 Nada más que reglas
      • 2.3 Todo en orden
Powered by GitBook
On this page

Was this helpful?

  1. II- Scope & Closures
  2. 3- Function vs. Block Scope

3.1 Ámbito de las funciones

La respuesta más común a esas preguntas es que JavaScript tiene un alcance/ámbito/scope basado en funciones. Es decir, cada función que declara crea una nueva burbuja para sí misma, pero ninguna otra estructura crea sus propias burbujas de alcance. Como veremos más adelante, esto no es del todo cierto.

Pero primero, vamos a explorar el alcance de la función y sus implicaciones.

Considere este código:

function foo(a) {
    var b = 2;

    // some code

    function bar() {
        // ...
    }

    // more code

    var c = 3;
}

En este fragmento, la burbuja de alcance para foo(..) incluye los identificadores a, b, c y bar. No importa dónde en el ámbito de una declaración aparezca, la variable o función pertenece a la burbuja que contiene el ámbito, independientemente. Vamos a explorar cómo funciona eso exactamente en el próximo capítulo.

bar(..) tiene su propia burbuja de alcance. Lo mismo ocurre con el ámbito global, que tiene sólo un identificador adjunto a él: foo.

Debido a que a, b, c, y bar pertenecen todos a la burbuja de alcance de foo(..), no son accesibles fuera de foo(..). Es decir, el código siguiente resultaría en errores ReferenceError, ya que los identificadores no están disponibles para el ámbito global:

bar(); // fails

console.log( a, b, c ); // all 3 fail

Sin embargo, todos estos identificadores (a, b, c, foo y bar) son accesibles dentro de foo(..), y de hecho también disponible dentro de bar(..) (suponiendo que no hay declaraciones de identificador de sombra dentro de bar(..)).

El ámbito de la función fomenta la idea de que todas las variables pertenecen a la función y pueden utilizarse y reutilizarse a lo largo de toda la función (incluso accesibles a los ámbitos anidados). Este enfoque de diseño puede ser muy útil, y ciertamente puede hacer pleno uso de la naturaleza "dinámica" de las variables JavaScript para asumir valores de diferentes tipos según sea necesario.

Por otro lado, si no se toman precauciones cuidadosas, las variables existentes a través de la totalidad de un ámbito puede conducir a algunas trampas inesperadas.

Previous3- Function vs. Block ScopeNext3.2 Ocultación en el ámbito común

Last updated 6 years ago

Was this helpful?