Qué es el Scope y cómo funciona el Global Scope

2/12
Recursos
Transcripción

Aportes 144

Preguntas 33

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

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'

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 😃

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

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

Para profundizar en por qué sucede todo esto, les recomiendo el libro “You don’t know JavaScript yet” que lo encuentran gratis en Github. Es denso pero vale la pena

De hecho hoy en día ya casi que es una mala práctica usar “var”, se debe tratar de usar “let” o “const” por eso mismo, “var” a la larga puede dar MUCHOS probemas

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

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

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

¿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)

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

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

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);

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

¿Cual es el Theme que el profesor tiene instalado en VScode? Me gusto bastante 😄

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.

La palabra asignar puede sonar raro, creo que mas bien el instructor hace referencia a declarar, con la palabra var si se puede declarar de nuevo una variable, aunque eso es mala practica, pero con let no se puede declarar mas de una vez una variable dentro de un mismo scope, en cuanto a const aquí si no se puede asignar ni declarar por mas de 1 vez dentro de un mismo scope

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);

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

Hola Platzicoders, aquí mi aporte.
.

.
Espero que les pueda ayudar.
(⌐■_■)

//----------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.

//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.

“Code 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 a la variable ya que se declara en el global 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 ‘asignar’ realmente se esta refiriendo a ‘declarar’, 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 = ‘hello world’ " una sola vez. Con var se puede hacer más de una vez.

[Running] node “c:\Users\EQUIPO\OneDrive\Escritorio\platzi java\closures y scope\tempCodeRunnerFile.js”
“node” 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 “node” 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.

![](

Me parece mejor metodo saber como es la forma correcta o las mejores practicas. a ver los errores y las malas practicas…

Entendiendo el video queda la definición que “let” no podria reasignarse; pero para que quede claro; si puede modificarse el valor porque sino lo veriamos como una constante y este no es la naturaleza de “let”; lo que no puede es despues de una definición volverse a definir pero si puedes reutilizar la variable y cambiar el dato que almacena. Ejemplo:

  1. Caso uno volviendo a asignarse o definirse; causaria error:
    let hello=“hola”;
    let hello=“wordl”;
    VM204:2 Uncaught SyntaxError: Identifier ‘hello’ has already been declared

  2. Caso de reutilizar la variable
    let hello=“hola”;
    hello=“wordl”;
    // “wordl”

Scope es un conjunto de reglas para buscar variables por su nombre de identificador. Sin embargo, generalmente hay más de un ámbito a considerar.
Así como un bloque o función está anidado dentro de otro bloque o función, los ámbitos están anidados dentro de otros ámbitos. Por lo tanto, si no se puede encontrar una variable en el ámbito inmediato, el Motor de JavaScript consulta el siguiente ámbito externo que contiene, hasta que se encuentre o hasta que se alcance el acope más externo (aka, global).
Considere:

function foo(a) {
    console.log( a + b );
}
var b = 2;
foo( 2 ); // 4

La referencia RHS para b no se puede resolver dentro de la función foo, pero puede resolverse en el ámbito que lo rodea (en este caso, global).

Resumen de la clase

// Variables global
var hello        = 'Hello'; // --> SOLO var puede ser reasignada
let world        = 'Hello World'; // --> NO podemos asignar un valor a lo que hemos establecido
const helloWorld = 'Hello World!'; // --> NO podemos asignar un valor a lo que hemos establecido


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

// Esto seria una mala practica ya que estamos declarando una variable global
// dentro de una funcion y la estamos llamando fuera de su scope
const helloWorld = () => {
    globalVar = 'im global'
}
helloWorld();
console.log(globalVar);

// Esta otra practica tampoco es bueno hacerlo
const anotherFunction = () => {
    var localVar = globalVar = 'Im Global';
}
anotherFunction();
console.log(globalVar);

2.-¿Qué es el Scope y cómo funciona el Global Scope?

Básicamente es el alcance de una variable dentro de nuestro código, decide a que bloques de código va a acceder una variable.

Hay dos formas del scope:

  • Local: Solo se puede acceder dentro de un bloque en especifico.
  • Global: que siempre se puede acceder. Se pueden sobrescribir (no lo hagas) cuando usamos la palabra reservada “var”, cuando se usa “let” y “const” no nos deja sobrescribir y no se le puede asignar un nuevo valor. Todas pueden ser usadas globalmente pero solo var se puede sobrescribir.

Al establecerla de esta manera podemos acceder durante todo el tiempo porque está asignada de forma global.

Cuando dentro de una función se declara una variable sin alguna de las palabras reservadas automáticamente se toma como variable global a pesar de estar dentro de una función, esto es una mala práctica.

Tambien cuando dentro de una función hay una variable con doble asignación como

var localVar = globalVar = “I’m global”;

se hace una variable global.

//Esta variable esta asignada de manaera global
var hello = "Hola Mundo desde Js";
let world = "Hello world";
const helloWorld = "Hola Mundo"
console.log(hello);

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

//Con let no se puede cambiar el valor de una variable
let nombre = "Victor";
let nombre = "Juan";
console.log(nombre);

//Con var si se puede cambiar el valor de una variable
var nombreDos = "Victor Adrian";
var nombreDos = "Hola";
console.log(nombreDos);

//Malas practicas
const helloWorlds = () => {
    holaMundo = "Hola soy el mundo";  //Esto es una mala practica
}
helloWorlds()
console.log(holaMundo);

const anotherFunctions = () => {
    var localVar = holaMundo = "Hola ya no soy el mundo"; //Mala practica
}
anotherFunctions();
console.log(holaMundo);

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

Código de la clase:
Scope global con distintas declaraciones

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

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

Si no usar las palabras var, let o const se vuelve global la variable

const helloWorld = () =>{
    globalVar = 'im global'
}
helloWorld()
console.log(globalVar);

Me encanta como trabaja este profe :thu

Una aclaración muy importante en el minuto 8:10 dice que no se puede asignar otro valor cuando se usa let y en realidad si se puede.

cuando usas 2 veces la palabra let, SI da error.

Ejemplo:

Let world = "World";
Let world = "Mundo";
SyntaxError: Identifier 'world' has already been declared (3:4) 
  4 | const helloWorld = 'Hello World!'

pero, puedes cambiar el valor con:

Ejemplo:

Let world = "World";
world = "Mundo";   // SIN la palabra let

y en consola aparece Mundo como nuevo valor de world.

Otra extensión que pueden usar se llama QUOKKA y corre automáticamente sin tener que hacer click derecho.

Avanzando en JS, excelente!

Gracias a Oscar se me ocurrio este codigo despues de la explicacion:

<code> 
const hello = 120;
const hi = 100;
const world = 100;
const anotherFunction = () => {
  console.log(hello + (hi * world / 2));
};

anotherFunction();


[Running] node "/Users/juancortes/Documents/Platzi/scope-closure/src/scope/tempCodeRunnerFile.js"
5120

[Done] exited with code=0 in 0.177 seconds

¿Qué es el Scope según la Wikipedia?
En programación de computadoras, el ámbito (referido mediante su denominación en inglés scope) es el contexto que pertenece a un nombre dentro de un programa. El ámbito determina en qué partes del programa una entidad puede ser usada.

Esto sirve para que se pueda volver a definir una variable con un mismo nombre en diferentes partes del programa sin que haya conflictos entre ellos.
Leer más

Más claro todo 😃