C贸mo funciona el Global Scope

2/12
Recursos
Transcripci贸n

El scope es cada uno de los entornos donde las variables tienen alcance dentro del c贸digo de JavaScript. En otras palabras, determina que valor tendr谩 la variable dependiendo d贸nde se encuentre.

Imagina que pierdes algo importante (llaves, dinero, etc.), comienzas a buscar este objeto por los lugares m谩s cercanos en que te encuentras; si no lo encuentras, buscas en los lugares m谩s lejanos y as铆 sucesivamete hasta encontrarlo. En JavaScript sucede algo similar.

Si haces referencia a una variable, el motor de JavaScript buscar谩 su declaraci贸n en el entorno m谩s cercano, y seguir谩 buscando en entornos m谩s lejanos hasta llegar a la l铆nea de c贸digo que la variable est茅 declarada. A este proceso se lo denomina cadena de scope (scope chaining).

Se dice que JavaScript tiene un scope l茅xico (lexical scope), porque para determinar el scope de una variable es necesario leer el c贸digo, sin ejecutarlo.

Tipos de scope

Existen dos tipos de scope: global y local. El scope local puede ser de funci贸n o de bloque.

Un bloque es toda porci贸n de c贸digo que est谩 encerrada entre llaves {}, estos pueden ser los bloques: funci贸n, if, else, while, y for.

Representaci贸n de los tipos de scope

En la imagen anterior, el entorno m谩s cercano para la variable saludo es el scope de bloque, luego el scope de funci贸n y finalmente el scope global. Este es un ejemplo del recorrido que sigue JavaScript hasta encontrar la variable que se hace referencia.

Declaraci贸n y asignaci贸n de variables

La declaraci贸n de una variable en el c贸digo es crearla mediante var, let o const y un identificador. La asignaci贸n es proveer de un valor a la variable creada.

var nombre // declaraci贸n
nombre = "Andres" // asignaci贸n

La declaraci贸n y la asignaci贸n se puede realizar en la misma l铆nea de c贸digo.

var nombre = "Andres"

Declaraci贸n de variables con var, let y const

Hasta ahora aprendiste a declarar variables con var, sin embargo, a partir de la especificaci贸n de ECMAScript 6 se agregaron nuevas formas para la declaraci贸n de variables.

Let y const resuelven varios problemas con var como el hoisting, variables globales, re-declaraci贸n y re-asignaci贸n de variables. En el tema del scope, que es el que nos interesa, se diferencian porque let y const tienen un scope de bloque y var no.

Variables re-declaradas y re-asignadas

La re-declaraci贸n es volver a declarar una variable, y la re-asignaci贸n es volver a asignar un valor.

  • Una variable declarada con var puede ser re-declarada y re-asignada.
  • Una variable declarada con let puede ser re-asignada, pero no re-declarada.
  • Una variable declarada con const no puede ser re-declarada, ni re-asignada. Su declaraci贸n y asignaci贸n debe ser en una l铆nea, caso contrario habr谩 un error.

Existe un curso de ECMAScript 6+ para que descubras las nuevas caracter铆sticas que agregan al lenguaje.

Scope Global

Las variables globales son aquellas que se encuentran declaradas fuera de los bloques de c贸digo o funciones y no importa si son declaradas con var, let o const.

El scope global es el entorno donde las variables globales pueden ser accedidas desde cualquier lugar de nuestro programa.

En el siguiente ejemplo, mira el c贸digo y piensa qu茅 mostrar谩 en consola. Una vez tengas las respuestas, abre la consola. 驴Qu茅 sucedi贸?

var saludoVar = "Hola var" 
let saludoLet = "Hola let" 
const saludoConst = "Hola const"

function saludar() {
  var saludoVar = "Chao var";
  console.log(saludoVar)
  console.log(saludoLet)
  console.log(saludoConst)
}

saludar()

Con este ejemplo podemos concluir que: el valor "Chao var" prevalece para el valor global "Hola var", y los dem谩s valores globales si se muestran en consola. Una variable global puede ser accedida en cualquier parte, porque el scope global es el 煤ltimo entorno en el que JavaScript busca una variable. Recuerda esto cu谩ndo se hable de scope local.

Buenas pr谩cticas de Scope

  • Declarar las variables con el scope m谩s reducido posible.
  • Siempre declarar variables. (empieza dejar de usar var)
  • Nunca realizar una doble declaraci贸n. Por ejemplo: let nombre = animal = "gatito"

*Contribuci贸n creada con los aportes de Andr茅s Guano.

Aportes 171

Preguntas 47

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

Scope: Es el alcance que va a tener una variable dentro del c贸digo. En otras palabras, el Scope se encargar谩 de decidir a que bloques de c贸digo va a acceder una variable.

Global Scope : No est谩n dentro de funciones o bloques, por lo tanto se puede acceder a ellas de manera global.

  • Con var podemos re-asignar una variable pero es una mala pr谩ctica.

  • Con let y const no podemos, aparecer谩 un error.

  • Es una mala pr谩ctica crear una variable sin las palabras reservadas: var, let y const.
    Si se asigna una variable dentro de una funci贸n sin las palabras reservadas ser谩 una variable global.

  • La doble asignaci贸n de una variable tambi茅n es una mala pr谩ctica.

Al declarar la variable con var podemos declarar nuevamente la variable.

// Esto no causa error
var hVar = 'hVar'
var hVar = 'hVar...'

No as铆 cuando se utiliza let o const.

// Esto genera un SyntaxError debido a que la variable hlet se intenta declarar por segunda vez.
let hlet = 'hlet'
let hlet = 'hlet...'

Pero si podemos asignar un nuevo valor

let hlet = 'hlet'
hlet = 'hlet_update'

Con const no podemos declarar la variable nuevamente y tampoco podemos asignar valor por segunda vez

// error
const hconst = 'hlet'
const hconst = 'hlet'
// error
const hconst = 'hlet' 
hconst = 'hlet'

hay un error en el minuto 10:50? let si se puede reasiganar, lo que no puedes es volver a declararla con el mismo nombre.

quizas se ha equivocado al decir redeclarar

Adem谩s de la extensi贸n recomendada por Oscar en esta clase, pueden usar nodemon para ejecutar sus programas de JavaScript de manera instant谩nea al guardar el archivo 馃槂

Si son tan nuevos como yo y probablemente est茅n siguiendo la ruta del JS Challenge, les recomiendo much铆simo complementar las clases de Scope con este video del gran Sacha Lifszyc 馃槃

Al final de las clases y del video, tendr谩n una mejor perspectiva sobre qu茅 es scope, tipos de scope e incluso nuevos conceptos como el Scope Chain o el Variable Shadowing. Recuerden Sacha tambi茅n es profesor de Platzi, dejo aqu铆 sus cursos por si alguno le interesa:

隆Buena suerte Platzi-nautas!

Que es el Scope:
El scope puede definirse como el alcance que una variable tendr谩 en tu c贸digo. En otras palabras, el scope decide a qu茅 variables tienes acceso en cada parte del c贸digo.

Qu茅 es el Scope Global
Se dice que una variable est谩 en el sope global cuando est谩 declarada fuera de una funci贸n o de un bloque. Tambi茅n son conocidas como variables globales. Puedes acceder a este tipo de variables desde cualquier parte de tu c贸digo, ya sea dentro o fuera de una funci贸n.

const soyEstudiante = true;

function platzi() {
	console.log(soyEstudiante);
}

platzi(); //true
console.log(soyEstudiante); //true

A pesar de que JavaScript nos permite declarar una variable como global, no es una buena pr谩ctica. Una de las razones es porque tenemos la posibilidad de declarar dos variables globales en distintas partes del c贸digo con el mismo nombre sin notarlo.

Scope: determina la accesibilidad (visibilidad) de las variables.

En JavaScript hay dos tipos de alcance:

  • Alcance local
  • Alcance global
    JavaScript tiene un alcance de funci贸n: cada funci贸n crea un nuevo alcance.

El alcance determina la accesibilidad (visibilidad) de estas variables.

Las variables definidas dentro de una funci贸n no son accesibles (visibles) desde fuera de la funci贸n.

By: https://www.w3schools.com/js/js_scope.asp

De hecho hoy en d铆a ya casi que es una mala pr谩ctica usar 鈥渧ar鈥, se debe tratar de usar 鈥渓et鈥 o 鈥渃onst鈥 por eso mismo, 鈥渧ar鈥 a la larga puede dar MUCHOS probemas

el comando para dejar todo por defecto en npm init es: npm init -y

Para profundizar en por qu茅 sucede todo esto, les recomiendo el libro 鈥淵ou don鈥檛 know JavaScript yet鈥 que lo encuentran gratis en Github. Es denso pero vale la pena

Para los que tienen **windows **deben tener instalador node antes de ejecutar el comando npm init

link de descarga
https://nodejs.org/en/download/

Espero les sirva de apoyo.
https://github.com/Jasaron1997/Platzi-Closures-Scope-JavaScript
Es el codigo de las clases.

驴Qu茅 es el scope?


Es el alcance que tendr谩 tu variable dentro de tu c贸digo, o en otras palabras el scope es qui茅n se encargar谩 de decidir a que bloques de c贸digo va a acceder una variable. Tenemos dos tipos de scope:

  • Scope local
  • Scope global

Al establecer la variable de la siguiente forma podemos acceder durante todo el tiempo a esta, ya que est谩 asignada de forma global.

var hello = 'Hello'
console.log(`${hello}`)

Con var podemos reasignar el valor de la variable pero esto se consider谩 una mala pr谩ctica y debe evitarse a toda costa.

var hello = 'Hello'
var hello = 'Hello +'

console.log(`${hello}`)

Si tratamos de reasignar un valor a una variable con let la consola no dir谩 que hay un error en nuestro c贸digo, ya que no se le puede asignar un nuevo valor. Igualmente pasa lo mismo con const.

var hello = 'Hello'
let world = 'Hello world'
let world = 'Hello'
const helloWorld = 'Hello world!!!'
const helloWorld = 'Hello!!!'

const antherFunction = () => {
    console.log(`${hello}`)
    console.log(`${world}`)
    console.log(`${helloWorld}`)
}

antherFunction();

Podemos crear variables dentro de funciones que pueden ser accedidas desde fuera de la funci贸n de la siguiente forma, aunque esto considerado una mala pr谩ctica. Adem谩s, si se asigna una variable dentro de una funci贸n sin las palabras reservadas ser谩 una variable global.

const helloWorldFunction = () => {
    globalVar = 'im global'
}

helloWorldFunction()
console.log(globalVar)

Buena clase pero me parece que hay un peque帽o error, el profe dice que no se puede reasignar un valor a un let sin embargo veo muchos ejercicios donde en un ciclo for utilizar let i = 0 como valor iterador donde le suman 1 cada ciclo i++, eso no ser铆a reasignar el valor de un let? Mmmm

Usen NPM init -y si no van a cambiar ning煤n valor por defecto (equivalente a enter enter enter enter)

Var, una mala practica, copiado 馃槃

El profesor se equivoc贸, una variable tipo let si se le puede reasignar, solo que no se bebe colocar nuevamente la palabra reservada let. En el caso de este video ser铆a as铆

let world = 'Hello World'
world = 'Ahora se rasigno a esto';
console.log(world);

驴Cual es el Theme que el profesor tiene instalado en VScode? Me gusto bastante 馃槃

eh visto los videos dos veces, y ya puedo decir que NO S EXPLICA EL PORQUE DE LAS COSAS, simplemente se poenen ejemplos pero no se dice porque una variable no delcarada con la palabra reservada var, se convierte en global si es declarada dentro de la funcion

la verdad creo que este curso aunque tiene buen contenido

no esta bien explicado.

Hola Platzicoders, aqu铆 mi aporte.
.

.
Espero que les pueda ayudar.
(鈱愨枲_鈻)

Les dejo esta peque帽a tabla y recomiendo que vean este video ya que aclara muchas dudas sobre las diferencias entre var, let y const

Mala pr谩ctica: dejar el control del alcance de mis variables a JS.
Para evitar esto es necesario saber.-

  • var permitir谩 declarar variables con el mismo nombre, es peligroso porque podemos cometer errores, perderemos datos.
  • let no permite crear variables con el mismo nombre.
  • const no permite crear variables con el mismo nombre, no permite reasignar valores a la variable.
  • (omitir el tipo de declaraci贸n) JS lo interpretar谩 como una variable global.

Scopes de:

  • var puede sobrescribir la declaraci贸n y asignaci贸n de una variable y alterar su valor
  • let no permite volver a declarar una variable con el mismo nombre pero permite la asignaci贸n de un nuevo valor
  • const tampoco permite reasignar una declaraci贸n ni asignaci贸n de un nuevo valor

Una variable sin var, let o const, dentro de una funci贸n puede ser reconocida como una variable global pero esto es una mala pr谩ctica.

Les comparto el c贸digo de la clase un poco con mi estilo y anotaciones

//Scope Global
// Var se puede reasignar pero es una mala pr谩ctica, en cambio
//Let y const no se pueden reasignar
var hello = 'Hello';
let world = 'Hello World';
const helloWorld = 'Hello World';


const anotherFunction = () =>{
    console.log(hello);
    console.log(world);
    console.log(helloWorld);
}

anotherFunction();

/*Malas pr谩cticas a tener en cuenta, no crear variables GLOBALES
dentro de funciones*/
const holaMundo = () =>{
    globalVar = 'im global';
}
holaMundo();
console.log(globalVar);

//

const otraFuncion = () =>{
    var localVar = globalVar = 'Im Global';
}

//Antes de generar la variable global globalVar es necesario ejecutar la funci贸n
otraFuncion();
console.log(globalVar);```

Para quien le sea 煤til el c贸digo escrito en este curso:

var hello = 'Hello';
var hello = 'Hello +';
let world = 'Hello World';
let world = 'Hello';
const helloWorld = 'Hello World!';

const anotherFunction = () => {
    console.log(hello);
    console.log(world);
    console.log(helloWorld);
}

anotherFunction();

const helloWorld = () => {
    globalVar = 'im global'
}

helloWorld();
console.log(globalVar)

const anotherFunction = () => {
    var localVar = globalVar = 'Im Global';
}

anotherFunction();
console.log(globalVar);

No me gusta como ense帽a Oscar, va demasiado r谩pido y no te explica el por que de las cosas. Tuve que ir a otros lados para buscar una explicaci贸n sencilla.
-Las variables globales se pueden llamar desde cualquier parte de nuestro c贸digo.
-Existen dos errores comunes al llamar una variable global en una funci贸n
1.- Cuando no colocamos 鈥渧ar鈥 鈥渓et鈥 贸 鈥渃onst鈥

variableGlobal = 'Esto es una variable global'

2.- Cuando colocamos un solo 鈥渧ar鈥 para igualar dos variables

var variableLocal = variableGlobal = 'Variable Global';

**- Las variables locales solo viven dentro de una funci贸n **
**Y por 煤ltimo las variables de bloque se introdujeron con el ES2015 鈥渃onst鈥 y 鈥渓et鈥 van a vivir dentro de un bloque. **

Al intentar ejecutar dentro de Visual Studio me aparece lo siguiente:

[Running] node "c:\Users\jocaf\desktop\joaquin\platzi\Platzi - Curso de Closures y Scope en JavaScript\src\Scope\tempCodeRunnerFile.js"
'node' is not recognized as an internal or external command,
operable program or batch file.

[Done] exited with code=1 in 0.077 seconds```

Donde puedo entender toda esta config de entorno que hizo para iniciar un proyecto, lo de git lo se, pero lo de npm no

//----------SCOPE GLOBAL------------
var hello = "Hello";
var hello = "Hello +"; // Se puede reasignar (Pero es mala pr谩ctica)
let world = "Hello World";
let world = "Hello"; // Se puede reasignar pero no se puede re-declarar
const helloWorld = "Hello World!"; // No se puede reasignar

const anotherFuction = () => {
  console.log(hello);
  console.log(world);
  console.log(helloWorld);
};

anotherFuction();
//S铆 se puede acceder a todas las variables ya que son globales

const helloWorld = () => {
  globalVar = "im global";
};

helloWorld();
console.log(globalVar);

const anotherFuction = () => {
  var localVar = globalVar = "Im Global";
};
//Si se crea una variable sobre una variable tambi茅n se puede acceder a ella

anotherFuction();
console.log(globalVar);

Recordar la diferencia entre declarar e inicializar una variable

  • var : se puede volver a declarar y asignarle otro valor(inicializar)

  • let: no se puede volver a declarar pero si se puede cambiar el valor.

  • const (consistente): no se puede volver a declarar ni cambiarle el valor.

Mis notas 馃槂

//馃寧 ALCANCE GLOBAL (Global Scope) y REASIGNACION

//VAR
var hello = "Hello"; // 馃寧Puedo acceder a esta var desde cualquier parte
// console.log(hello)
var hello = "Hello declaracion y reasignacion"; // 馃寧 Puedo reasignar la var desde cualquier parte (solo var puede ser redeclarado y reasignado)

//LET
let world = "Hello World";
//let world = "Hello World declaracion y reasignacion" //鉂 no puedo volver a declarar un let
//console.log(world) 

//CONST
const helloWorld = "Hello World!";
//const helloWorld = "Hello World! declaracion y reasignacion"; //鉂 no puedo volver a decalarar ni reasignar un const

const anotherFunction = () => {
  console.log(hello);
  console.log(world);
  console.log(helloWorld);
};

anotherFunction();

//鉂 Es mala practica no inicializar una variable en un bloque porque pasa a tener scope global
const helloWorld = () => {
  globalVar = "im global";
};

helloWorld();
console.log(globalVar);

const anotherFunction = () => {
  var localVar = (globalVar = "Im Global");
};

anotherFunction();
console.log(globalVar);
  • Scope, es el alcance que tiene una variable.
  • El Scope global, es cuando se definen las variables fuera de un bloque de c贸digo, funciones, etc. y pueden ser accedidas desde el bloque del c贸digo.

Con var se puede reasignar una variable, pero con let no.
Es mala pr谩ctica declarar variables sin las palabras reservadas var, let, const dentro de un bloque de c贸digo, estas variables ser谩n consideradas como globales.

Como tip (lo m谩s probable que el profesor lo mencione), es crear variables de forma local, esto quiere decir dentro de funciones y no de forma global, porque el control para esta variable se volver谩 dif铆cil de trackear mientras el programa vaya creciendo.

npm init -y

Hola, por si a alguien le pasa, resulta que en algunas distros de linux vs code tiene un bug, y este es que si intentas dar click derecho en alguna parte de tu ventana dentro de vs code, este te seleccionar谩 por autom谩tico la opci贸n sobre la que est茅 el cursor, esto no lo sab铆a ya que no hab铆a tenido la necesidad de usar el click derecho hasta ahora con la extensi贸n code runner. Esto solo pasa en vs code en algunas distros de linux, ni en mac ni en widows esto pasa.
Esto lo s茅 gracias a este link
De momento no he encontrado una soluci贸n, solo es para avisar por si te pasa que sepas que se trata de un error de vs code.

var-lef-const --> video

Apuntes

Apuntes

Encontr茅 un peque帽o error en lo que dice el profesor.

脡l dice, que no se pueden reasignar las variables que son de tipo let y const, haciendo el siguiente ejemplo:

let world = "Hello world";
let world = "Hello";

Lo cual estar铆a mal el uso de palabras que uso y podr铆a generar confusiones m谩s adelante.

Si se puede reasignar un valor de una variable tipo let, de la siguiente manera:

let world = "Hello world";
world = "this is an another value";

Lo que creo que el profesor quiso decir, fue que no se puede declarar otra variable con el mismo nombre de una variable de tipo let o const que ya fue declarada.

Esto es lo que tengo entendido, si algui茅n tiene alguna informaci贸n adicional o estoy equivocado, lo/a invito/a a que comente y generemos debate.

Si ah alguien le pasa lo de node desc谩rguenlo para Windows y no mediante terminal almenos a mi mediante terminal no me sirvi贸 鈥 y despu茅s reinicien el computador鈥 espero les sirva

Hasta ECMASCRIPT 5 las variables se declaraban con la palabra reservada var nombreVariable. La sentencia var tiene un ambito global y se le aplica el hoisting. Tiene las siguientes caracteristicas:

  • Se puede reinicializar.
  • Su valor es variable, por lo tanto, es reasignable.
  • Su alcance es global.

Las palabras reservadas const y let son las formas de declarar variables desde ECMASCRIPT 6, no se les aplica hoisting.

La sentencia const crea una variable de tipo constante, y tiene las siguientes caracter铆sticas:

  • No se puede reinicializar.
  • Es inmutable, su valor no puede ser cambiado.
  • Son block-scoped, solo existe en el bloque en donde fue declarada.

La sentencia let declara una variable que puede ser modificada, tiene las siguientes caracteristicas:

  • No se puede reinicializar.
  • Su valor es mutable, puede cambiar.
  • Es block-scoped, solo existe en su contexto de ejecuci贸n.

Creo que con una buena estructuracion de codigo y nombres de variables, se evitara El scope, no he estado aun en un gran proyecto para entender porque sucede, pero se que lo estare, y debo estar preparado

Cuando el profesor dice que una variable let no puede ser asignada se refiere es que no puede ser declara nuevamene, es una error de conceptos, para tenerlo en cuenta para el examen o entrevista

Esta clase me pareci贸 genial!!

Scope: alcance que tendra las variables dentro de mi codigo

Una explicaci贸n genial del scope global.

//Puede declarar la variable de nuevo y asignar un nuevo valor, pero es una mala practica.
var hello = "Hola var"; 
var hello = "Bye var";

// No podemos declararla por segunda vez, pero podemos asignar un nuevo valor.
let letHello = "Let Hello";
letHello = "Bye let";
// No podemos declararla por segunda vez ni asignar un nuevo valor.
const constHello = "Const Hello"; 

Saludos platzinautas.

鈥淐ode language not supported or defined.鈥

Me paso que el CodeRun no funcionaba, y era porque el tipo de codigo a ejecutar no era el activo para la extension.

Como solucionar?
Muy sencillo, miren este video de 1 minutos y listo鈥 (regalen un like, no es mio, creo debemos ayudar)
https://www.youtube.com/watch?v=T7tXN9PtO9A

Espero les sirva. Saludos.

Preguntica de examen! let y const no permiten reestablecer valores previamente establecidos

para que puedan usar el npm al inicio en ubuntu se usa utiliza
sudo apt install npm

Por lo que veo en el video, lo mejor es usar siempre let y const y olvidarnos del var.
As铆 he venido trabajando desde hace un par de meses y no he necesitado el var para nada.

  • var No siempre tiene un scope global, puede ser reasignada y declarada m谩s de una vez.
  • let Esta tiene un scope local, solo puede ser declarada una vez pero puede ser reasignada.
  • const Esta tiene un scope local y no puede ser declarada m谩s de una vez ni reasignada.

Scope global
Las variables accesibles desde cualquier lugar en nuestro c贸digo, est谩n dentro del scope global
Mas info

es la primera clase, pero me parece que Oscar tiene el timing y las expresiones perfectas para dar un curso de programacion, ojala sean mas cursos de su autoria los que esten en la ruta Backend de JS

QUE ES SCOPE Y COMO FUNCIONA 馃槃


/* 
    Scope es el alcance de las variables que estamos asignando

   Cuando establecemos una variable con var podremos acceder a ella desde cualquier
   Punto de la aplicacion porque esta asignada Globalmente
   
   
   */
var hello = "hello";


console.log(hello);




let world = "Hello World";
const helloWorld = 'Hello world';


//Creamos una funcion para acceder a las variables
// Podremos acceder a ellas en la funcion ya que estan definidas en Scope Global
const anotherFunction = () => {

    console.log(hello);
    console.log(world);
    console.log(helloWorld);

}
anotherFunction();

//Podremos reagsinar el valor de una variable solo con let o var

hello = "otra cosa";
world = "cambio xd";


console.log(hello);
console.log(world);

/*
    Es una mala pr谩ctica crear una variable sin las palabras reservadas: 
    var, let y const.
    Si se asigna una variable dentro de una funci贸n sin las palabras 
    reservadas ser谩 una variable global.
*/

const helloWorld = () => {

    globalVar = 'im global'

}

helloWorld();
console.log(globalVar); // podremos acceder a la variable

//Doble asignacion de una variable es mala practica

const anotherFunction = () => {

    var localVar = globalVar = 'Im Global'


}```

Scope: Es el que se encarga de a que bloque de codigo va acceder una variables.

Local Scope:permite acceder a una variable solamente en este bloque de codigo.

let聽persona=聽()=>{
//local聽scope
let聽nombre='victor';
return nombre;}
//global聽scope
//la聽variabe聽nombre聽esta聽definida聽en聽la聽funcion聽osea聽que聽se聽accede聽a聽la聽funcion聽persona聽para聽imprimir聽la聽variable
console.log(persona());
//este聽codigo聽da聽error聽por聽que聽la聽variable聽no聽esta聽definida聽en聽global聽scope
console.log(nombre);

Global Scope:el global scope tiene alcance directo a las variables o funciones ya que no se declaran adentro de bloques de codigo.

//Global聽scope
let聽numero=18;
//Se聽accede聽directamente聽ala聽variable聽ya聽que聽se聽declara聽enelglobal聽scope

console.log(numero);

Ambito Lexico: Cuando yo declaro dos variables del mismo tipo las llamo de forma igual como estas pueden convivir en el codigo sin modificar una a la otra, gracias al ambito lexico esto se refiere a que las dos variables pueden convivir en el mismo codigo si una esta declarada en un ambito diferente de la otra.

//Global scope
let nombre='victor';

function persona() {
    //local scope
    let nombre='carlos';
    return nombre;
}
//imprimira la variable que esta declarada en global scope
console.log(nombre);

//imprimira la varible declarada en local scope 
console.log(persona());

//las dos variables conviven juntas pero en dos ambitos diferentes

creo que el profesor tuvo un error con let se puede asignar un valor nuevo lo que no se puede es re declarar la variable 鈥

este video es del sacha es la mejor explicaci贸n de las diferencia que hay
https://www.youtube.com/watch?v=ojrvxYcKeYg

El Scope se define como el alcance que tendr谩 una variable dentro del c贸digo. En otras palabras, el Scope se encargar谩 de decidir a qu茅 bloques de c贸digos va a acceder una variable.

Si declaramos una variable con var al inicio de un archivo y esta no est谩 dentro de ninguna funci贸n o bloque, ser谩 una variable con scope global. Con el scope global podemos acceder a las variables dentro de funciones.

Si declaramos una variable con var, esta puede ser re declarada sin ning煤n error

Mientras que si intentamos esto mismo pero con let y const, nos lanzar谩 un error, ya que las variables declaradas de esta manera no pueden ser reasignadas.

Tanto la re declaraci贸n de variables como la creaci贸n de variables globales dentro de funciones o bloques es considerado una mala pr谩ctica.

Cuando Oscar, menciona 鈥榓signar鈥 realmente se esta refiriendo a 鈥榙eclarar鈥, asignar es ponerle un valor, declarar es definirla con var/let/cons

var se puede declarar y asignar una y otra vez

let una vez declarada solo se puede asignar valores

const es m谩s estricto porque una vez declaras no cambias el valor

#Scope

Es el alcance que tiene una variable dentro del c贸digo, define a los bloques de c贸digo a los que tendr谩 acceso una variable.

El scope tiene dos definiciones global y local

Global scope

La variables globales son a las que se puede acceder desde cualquier parte durante la ejecuci贸n de nuestro c贸digo, estas variables no se encuentran definidas dentro de funciones o bloques.

las variables pueden ser declaradas con las palabras reservadas var, let y const

  • var: nos permite declarar variables y su valor puede cambiar durante el tiempo de ejecuci贸n. Se puede re asignar una variable volvi茅ndola a declarar, esto es una mala pr谩ctica.
  • let: nos permite declarar variables y su valor puede cambiar durante el tiempo de ejecuci贸n. No se puede re asignar una variable volvi茅ndola a declarar, esto genera un error.
  • const: nos permite declarar variables y su valor no puede cambiar durante el tiempo de ejecuci贸n. No se puede re asignar una variable volvi茅ndola a declarar, esto genera un error.

Una mala pr谩ctica es establecer variables dentro de una funci贸n sin utilizar las palabras reservadas para su declaraci贸n lo que las vuelve globales.

// Global Scope

var hello = "Hello";
// var hello = "Hello +";
let world = "Hello World";
// let world = "Hello +";

const helloWorld = "Hello World!";

const anotherFunction = () => {
  console.log(hello);
  console.log(world);
  console.log(helloWorld);
};

anotherFunction();

// Bad practice declaring global vars

const helloWorldBadPractice = () => {
  globalVar = "I'm global.";
};
helloWorldBadPractice();
console.log(globalVar);

const anotherFunctionBadPractice = () => {
  var localVar = (globalVar = "I'm global.");
};
anotherFunctionBadPractice();
console.log(globalVar);

Usar siempre const a menos que debas modificar el contenido de la variable entonces usa let

Var esta ah铆 para el c贸digo que se hacia antes pero que con el avance de javascript (2020) let y const son soportados en todos los entornos principales.

Con este link a esta p谩gina me quedo claro el concepto de var,let y const. Espero les sirva.

https://estradawebgroup.com/Post/Var--Let-y-Const-en-JavaScript---cual-es-la-diferencia-/20375

El scope es el que se encarga de decidir a que bloques de codigo puede acceder una variable.

Existe el scope local y el scope global

El scope global nos permite acceder a las variables que son definidas en ese scope global, como pueden ser variables que fueron definidas fuera de funciones
ej:

var hello = "Hello";
let world = "Hello World";
const helloWorld = "Hello World!"

const anotherFunction = ()=>{
    console.log(hello)
    console.log(world)
    console.log(helloWorld)
}

anotherFunction()

Algo a tomar en encuenta es que de las tres variables que creamos, solo la variable var pueder ser reasignado

ej:

var hola = 'hola'
var hola = 'hi'

y eso no nos dara ningun error, ya que var nos permite hacer eso.

Una mala practica al momento de desarrollar es que podemos crear varibles globales dentro del scope de una funcion.

const globalVar = () =>{
    test = 'hola';
}

// ejecutamos la funcion
globalVar();


// hacemos un console log de la variable que creamos dentro de la funcion
console.log(test);
// pinta el 'hola'

Es bueno entender estos conceptos, ya que son muy frecuentes este tipo de malas pr谩cticas, son problemas comunes, pero representan un problema a la larga

Tengo una duda veo que el profe en los ejemplos de globalVar en el primero una el mismo nombre de la variable const helloWorld y el segundo ejemplo usa el mismo nombre de la funci贸n anotherFunction y le funciona bien no le afecta con las anteriores. Yo lo hice asi y me sale un error y si les cambio el nombre si me funciona bien

Correcci贸n: Con let no se puede volver a declarar una variable pero si se puede reasignar su valor. Es decir, solamente se puede usar "let var = 鈥榟ello world鈥 " una sola vez. Con var se puede hacer m谩s de una vez.

[Running] node 鈥渃:\Users\EQUIPO\OneDrive\Escritorio\platzi java\closures y scope\tempCodeRunnerFile.js鈥
鈥渘ode鈥 no se reconoce como un comando interno o externo,
programa o archivo por lotes ejecutable.

me sale eso error y no se como mejorarlo

Muchas gracias Profesor, Mucho m谩s claro para m铆 esta definici贸n de Scope global.

馃く馃く Que gran clase.

  1. let no permite crear o asignar una nueva variable con un nombre que ya a sido asignado, pero si permite cambiar su valor.

  2. Es importante utilizar la palabra reservada (Let, const, var) al momento de declarar una variable, si no JS la entedera como una variable global

驴Cual ser谩 el tema que esta utilizando el profe en visual studio code? esta genial 馃槃

//MALAS PRACTICAS:
// Declarar solo nombre de variables sin su  tipo.
const helloWorlds = () => {
  global = 'helloooo'
}
helloWorlds()
console.log(global)

// Declarar la variable dentro de la funci贸n dos veces:
const helloWorlds = () => {
  var global1 = (globalVar = 'helloooo luis')
}
helloWorlds()
console.log(globalVar)

var let y const pueden usarse para crear variables globales, pero solamente var puede ser reasignada.

estableciendo una variable sin las palabras reservadas var let const se puede asignar una variable global dentro de una funci贸n, es una MALA PRACTICA

me sale este error 鈥渘ode鈥 no se reconoce como un comando interno o externo,
programa o archivo por lotes ejecutable.

Necesito una aclaraci贸n!, entre 8:15 y 8:32 dice que solo var puede ser reasignada y que con let y const no vamos a poder asignar ningun valor a lo que ya hemos establecido!
Aclarenme, por que para mi let si deja reasignar valores, solo const es la que no!

var permite volver a declarar y reasignar una variable, let permite reasignar el valor de una variable pero no declararla de nuevo y const no permite que la variable sea reasignada o declarada de nuevo con excepci贸n de objetos los cuales pueden ser mutados en sus propiedades a煤n si est谩n declarados con const

Definitivamente let y const fueron los mejores inventos de ECMAscript 6, evitan much铆simos errores y mejoran mucho el desarrollo.

El scope va a decidir a que bloque de codigo esta disponible

Entonces, si yo asigno una variable dentro de una funci贸n al ejecutarla, 驴la variable pasa a vivir dentro del entorno global?

No entiendo, como puede crear la variable globalVar, si no utiliza ninguna de las palabras reservas (LET; VAR, CONST), como hace para crearla?

Hola profe! hay un peque帽o error鈥 dice que no se puede reasignar, pero lo que no se puede es redeclarar鈥 es decir si de puede asignar otro valor cuando se declara con var y con let lo que no se puede es volver a declarar una variable que ya fue declarada con let鈥

Scope: Es el alcance que tiene una variable, habitando dentro de una funci贸n o bloque. Es concretamente, qui茅n permite a las variables acceder a funciones o bloques de c贸digo

Scope Global es donde habita todo, porque sencillamente no se encuentra en ning煤n bloque de c贸digo o funci贸n.

Variables var : pueden ser reasignadas, pero es una muy mala pr谩ctica.
Variables let | const : no pueden ser reasignadas, porque la palabra ya ha sido reservada

Variables dentro de una funci贸n : Si se define una variable sin alguno de los prefijos var, let o const , 茅sta variable ser谩 global

Me gustan estos cursos, donde profundizamos detalladamente en ciertas generalidades de JavaScript

Apunte:

La variable de tipo var se puede re asignar un valor (Aunque es mala pr谩ctica).
La variable de tipo let y const NO se le puede re asignar un valor.

Consulta acerca de la doble asignaci贸n:

const anotherFunction = () => {
    var variableLocal = variableglobal = 'Im am global';
}

es igual a:

const anotherFunction = () => {
    var variableLocal = 'I am Local';
    variableglobal = 'I am global';
}

EL Scope hace referecia al lugar de validez de una variable. Podriamos decir que el scope es el alcance que determina la accesibilidad de las variables en cada parte de nuestro c贸digo.

Se define como el alcance que va a tener la variable dentro de nuestro codigo. Se encargara en decidir a que bloque de codigo accedera nuestra variable.

Hay dos formas, que son el Scope local y el Scope Global.

Si tenemos variables globales, queremos decir que cualquier funcion desde cualquier parte en nuestro codigo, puede acceder a estas y utilizarlas.

Es una mala practica cuando nosotros tenemos alguna variable tipo var y las reasignamos en su valor, en el caso de let y const esto nos marca un error.

Es una mala practica el hecho de declarar variables sin las palabras reservadas . La doble asignacion de variables al igual es una mala practica.

Con let se puede re-asignar el valor mas no re-declarar la variable, un ejemplo seria:

Forma Valida

let hello = 'Hello';
hello = 'World';

Forma Err贸nea

let hello = 'Hello';
let hello = 'World';

Con const no se puede reasignar de ninguna de las dos formas

No me dej贸 colocar la licencia MIT, por lo que tuve que dejar la que aparec铆a por defecto, la ISC. Est谩 bien eso o me puede generar problemas despu茅s?

tengo entendido que para windows es node.js pero es que nose como hace con eso de las carpetas donde aparece platzi-courses

Lo mas recomendable es usar let y const para evitar problemas con variables que podr铆an llegar a tener el mismo nombre.

SCOPE
El alcance que va a tener la variable dentro de tu c贸digo.
Es el que se encargar谩 de decidir a qu茅 bloques de c贸digos va a acceder una variable.

鈥> **Code Runner **鈥> CTRL + ALT + N

Global Scope: Una variable se encuentra en el Global Scope cuando son definidas fuera de una funciones o bloques de c贸digo, entonces podemos acceder a ellas desde cualquier parte del c贸digo.

En resumen todo lo que abre y cierra un parentesis es un escope

En resumen scope es: {
	Soy un scope:
	if (escope dentro de un scope) {
		si.
		tambien es un scope
	}
	for (i = 0; .........)  {
		esto tambien es un escope
	}
}
// var puede ser reasignado en scope function con esa sintaxis
// si la reasignamos sin el 'var' se reasigna global
var chao = 'chao'
const bye = () => {
    var chao = 'buenas noches'
    console.log(chao)
}
bye()
console.log(chao)


// al igal que var, let puede ser reasignada, si se agrega 'let'
// solo reasigna en function scope, si es sin let global scope
let hola = 'hola'
const hello = () => {
    hola = 'como estas'
    console.log(hola)
}
hello()
console.log(hola)

Variables o constates que pueden ser consultadas a los largo del app son globales, pero las que declaramos en una funci贸n son locales y solo se pueden ser consultadas mientras la funci贸n viva.

![](