Cómo funciona el Global Scope

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 😄

• https://www.youtube.com/watch?v=s-7C09ymzK8

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:

• Fundamentos de JavaScript 2018
• Curso de Bootstrap 4

¡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 “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

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

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 “var” “let” ó “const”

variableGlobal = 'Esto es una variable global'

2.- Cuando colocamos un solo “var” 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 “const” y “let” 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.

“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!

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.

![](