Hoisting es un término para describir que las declaraciones de variables y funciones son desplazadas a la parte superior del scope más cercano, scope global o de función. Esto sucede solamente con las declaraciones y no con las asignaciones.
El código permanece igual, solo es una interpretación del motor de JavaScript. En el caso de las variables solamente sucede cuando son declaradas con var.
Hoisting en variables declaradas con var
En el siguiente código, la respuesta del console.log es undefined, porque al hacer referencia a una variable que no está declarada aún, JavaScript crea esta variable antes de declararla y le asigna un valor de undefined.
console.log(nombre)// undefinedvar nombre ="Andres"
// Hoistingvar nombre =undefinedconsole.log(nombre)nombre ="Andres"
Hoisting en scope de bloque
Mira el siguiente código y piensa cuál sería el resultado del console.log.
La respuesta es primero "hola" y luego un error de referencia. Esto sucede por el hoisting, la declaración de la variable saludo se eleva fuera del bloque en un scope superior, que puede ser un scope de función o global.
var saludo =undefinedif(true){ saludo ="hola"let despedida ="chao"}console.log(saludo)// "hola"console.log(despedida)// ReferenceError: despedida is not defined
Es por eso que var no tiene scope de bloque, y se debe tener cuidado porque puede provocar errores en el código.
Hoisting en funciones
Mira el siguiente código y piensa cuál sería el resultado del console.log.
La respuesta es "Hola", porque al invocar una función que no está declarada, JavaScript la eleva y por eso podemos invocar una función antes de declararla.
Pero, lo que realmente sucede es que JavaScript guarda la función en memoria en la fase de creación de un contexto de ejecución, no asigna undefined como con las variables.
Hoisting de variables dentro de una función
El hoisting desplaza las declaraciones a la parte superior del scope más cercano, en el caso de una función dentro de otra función, seguiría el siguiente comportamiento.
functionscope(){console.log(nombre)// undefinedconsole.log(edad)// undefinedconsole.log(i)// undefinedvar nombre ="Andres"var edad =20for(var i =0; i<6; i++){//...}}
JavaScript lo interpretaría como lo siguiente:
functionscope(){var nombre =undefinedvar edad =undefinedvar i =undefinedconsole.log(nombre)// undefinedconsole.log(edad)// undefinedconsole.log(i)// undefined nombre ="Andres" edad =20for( i =0; i<6; i++){//}}
Hosting en funciones asignadas a variables
Mira el siguiente código y piensa cuál sería el resultado del console.log.
La respuesta es un error de tipo porque si asignas una función a una variable declarada con var, y la invocas antes declararla, la variable será de tipo undefined y no de función por el hoisting.
var saludar =undefinedconsole.log(saludar())// TypeError: saludar is not a functionsaludar=functionsaludar(){return"hola"}
Hoisting con let y const
Aunque te haya dicho que el hoisting solo ocurre con declaraciones con var, no es totalmente cierto. El hoisting hará que el intérprete de JavaScript eleve las declaraciones con let y const a la Temporal Dead Zone.
La Temporal Dead Zone es una región del código donde la variable está declarada, pero no es posible acceder a esta, provocando un error de tipo ReferenceError.
console.log(nameVar)// undefinedconsole.log(nameLet)// ReferenceError: nameLet is not definedvar nameVar ="myVar"let nameLet ="myLet"
Buenas prácticas para usar hoisting
No utilices var en las declaraciones de variables.
Escribe primero las funciones y luego su invocación.
Hoisting es un término para describir que las declaraciones de variables y funciones son desplazadas a la parte superior del scope más cercano, scope global o de función. Esto sucede solamente con las declaraciones y no con las asignaciones.
El código permanece igual, solo es una interpretación del motor de JavaScript. En el caso de las variables solamente sucede cuando son declaradas con var.
Hoisting en variables declaradas con var
En el siguiente código, la respuesta del console.log es undefined, porque al hacer referencia a una variable que no está declarada aún, JavaScript crea esta variable antes de declararla y le asigna un valor de undefined.
console.log(nombre) // undefined
var nombre = "Andres"
// Hoisting
var nombre = undefined
console.log(nombre)
nombre = "Andres"
Hoisting en scope de bloque
Mira el siguiente código y piensa cuál sería el resultado del console.log.
if (true){
var saludo = "hola"
let despedida = "chao"
}
console.log(saludo)
console.log(despedida)
La respuesta es primero "hola" y luego un error de referencia. Esto sucede por el hoisting, la declaración de la variable saludo se eleva fuera del bloque en un scope superior, que puede ser un scope de función o global.
var saludo = undefined
if (true){
saludo = "hola"
let despedida = "chao"
}
console.log(saludo)
// "hola"
console.log(despedida)
// ReferenceError: despedida is not defined
Es por eso que var no tiene scope de bloque, y se debe tener cuidado porque puede provocar errores en el código.
Hoisting en funciones
Mira el siguiente código y piensa cuál sería el resultado del console.log.
console.log( saludar() )
function saludar() {
return "Hola"
}
La respuesta es "Hola", porque al invocar una función que no está declarada, JavaScript la eleva y por eso podemos invocar una función antes de declararla.
Pero, lo que realmente sucede es que JavaScript guarda la función en memoria en la fase de creación de un contexto de ejecución, no asigna undefined como con las variables.
Hoisting de variables dentro de una función
El hoisting desplaza las declaraciones a la parte superior del scope más cercano, en el caso de una función dentro de otra función, seguiría el siguiente comportamiento.
function scope() {
console.log(nombre) // undefined
console.log(edad) // undefined
console.log(i) // undefined
var nombre = "Andres"
var edad = 20
for (var i = 0; i< 6; i++) {
//...
}
}
JavaScript lo interpretaría como lo siguiente:
function scope() {
var nombre = undefined
var edad = undefined
var i = undefined
console.log(nombre) // undefined
console.log(edad) // undefined
console.log(i) // undefined
nombre = "Andres"
edad = 20
for ( i = 0; i< 6; i++) {
//
}
}
Hosting en funciones asignadas a variables
Mira el siguiente código y piensa cuál sería el resultado del console.log.
console.log( saludar() )
var saludar = function saludar() {
return "hola"
}
La respuesta es un error de tipo porque si asignas una función a una variable declarada con var, y la invocas antes declararla, la variable será de tipo undefined y no de función por el hoisting.
var saludar = undefined
console.log( saludar() ) // TypeError: saludar is not a function
saludar = function saludar() {
return "hola"
}
Hoisting con let y const
Aunque te haya dicho que el hoisting solo ocurre con declaraciones con var, no es totalmente cierto. El hoisting hará que el intérprete de JavaScript eleve las declaraciones con let y const a la Temporal Dead Zone.
La Temporal Dead Zone es una región del código donde la variable está declarada, pero no es posible acceder a esta, provocando un error de tipo ReferenceError.
console.log(nameVar) // undefined
console.log(nameLet) // ReferenceError: nameLet is not defined
var nameVar = "myVar"
let nameLet = "myLet"
Buenas prácticas para usar hoisting
No utilices var en las declaraciones de variables.
Escribe primero las funciones y luego su invocación.
El hosting solo aplica a variables declaradas con var, si intentamos hacer un ejemplo similar con let o const tendremos errores:
console.log(x); //❌ ReferenceError: Cannot access 'x' before initialization
let x = 5;
El hosting para funciones solo aplica para funciones declaradas usando la palabra reservada function, si intentamos aplicarlo a arrow functions tendremos errores también:
Es importante recalcar que el Hoisting en las funciones, solo afecta a aquellas que estén escritas con la sintaxis de "Function Declaration", si intentamos con otras sintaxis, arrow o function expression, nos mandará un error.
El concepto de Hoisting fue pensado como una manera general de referirse a cómo funcionan los contextos de ejecución en JavaScript (específicamente las fases de creación y ejecución).
Las Variables y las funciones se procesan antes de ejecutar el código
Las funciones antes que las Variables
Conceptualmente, por ejemplo, una estricta definición de hoisting sugiere que las declaraciones de variables y funciones son físicamente movidas al comienzo del código
Lo que sucede es que las declaraciones de variables y funciones son asignadas en memoria durante la fase de compilación, pero quedan exactamente en dónde las has escrito en el código.
Buenas Prácticas: Las funciones se deben de declarar al inicio del código
La recomendación es no usar var solo let y const eso es lo que se dice en ES6, y así evitar los errores del hoisting que son considerados una mala práctica o por lo menos es lo que se recomienda en mi empresa desde el primer día que entre.
Las variables declaradas con las palabras claves (let, const), entran a una zona conocida como zona muerta. Es decir, que todo el código que necesite de estas variables no se va a ejecutar hasta que están tengan un valor asignado.
El concepto de hoisting es que las funciones y las variables declaradas se "elevan", pero no lo hacen literalmente en el código, sino en la memoria de Javascript, es decir al momento que corremos nuestro código y este va a empezar a compilar JS "agarra" todas las variables y funciones(OJO: solo las declaraciones, ya que la inicialización de las variables lo hará de acuerdo a la ejecución del código) y las pone hasta el inicio y luego empieza a ejecutar el código,