Function Scope

Un pequeño resumen sobre como actúan las diferentes variables:

• Las variables escritas con la palabra clave var pueden ser redeclaradas, pero esto a futuro puede darnos problemas, así que es mejor no usarla.

• Las variables escritas con la palabra clave let no pueden ser redeclaradas, si lo haces mostrara un “error: esta variable ya ha sido declarada” , pero su valor puede ser reasignado:

let fruit = "apple";
fruit = "banana";

console.log(fruit); // banana

• Las variables escritas con la palabra clave const no pueden ser redeclaradas o reasignadas, ya que const quiere decir que su valor será constante, es decir que no va a cambiar.

Creo que hay un error de significado. SI se puede reasignar let, lo que no se puede es redeclarar.

Reasignar:
let a = 1;
a = 2 // correcto

Redeclarar:
let a = 1;
let a = 2; //incorrecto

var se puede tanto reasignar como redeclarar, y const no se puede ninguna de las dos

Yo creo el profe al decir que no se pueden “reasignar” variables, quiere decir “redeclarar” variables … 🤔

#CUIDADO
El prof. cae en el error de usar la palabra re-asignar. En realidad lo que no se puede hacer con let y const es re-declarar dentro de un mismo scope.

Para los que están batallando para comprender la diferencia entre los 3 tipos de declaración, les dejo esta pequeña explicación (Hasta rimó):

• var: Permite declarar, redeclarar y reasignar.
• let: Permite declarar, no permite redeclarar, y sí permite reasignar cuantas veces quieras.
• const: Permite declarar, no permite redeclarar, y no permite reasignar jamás.

Dicho lo anterior este código es correcto:

var mivariable = "Hola Mundo";
var mivariable = "Hola Universo";

Mientras que este otro código provocaría un error:

let miotravariable = "Hola Tierra";
let miotravariable = "Hola Marte";

Porque se intenta “redeclarar” una variable ya declarada por let. Pero sí se podría reasignar un valor:

let miotravariable = "Hola Tierra";
// Varias líneas de código más adelante ...
miotravariable = "Hola Marte";
// Otras líneas más adelante ...
miotravariable = "Hola Venus";
// 100 líneas más abajo ...
miotravariable = "Hola Mercurio";

Sin ningún problema. Por otro lado const no permitiría ninguna de las 2, sólo se declara e inicializa o asigna y ese será su valor para siempre:

const miconstante = "Soy Inmutable";
// La siguiente línea provocaría un error
const miconstante = "Intentaré redeclararte"; // ERROR
// La siguiente línea también provocaría un error
miconstante = "Intentaré reasignarte valor"; // ERROR

Espero a alguien le ayude esta pequeña explicación.

Siempre utilizar let y const, var es peligrosa. Gracias por esta clase.

// con este ejemplo estamos accediendo a una variable local dentro de una funcion
const fruits = () => {
    var fruit = 'Apple';
    console.log(fruit);
};

fruits();
//desde el entorno global no podemos acceder a una variable que fue definida en un entorno local de una funcion.
console.log(fruit);

const anotherFuncion = () => {
    var x = 1;
    var x = 2;
    let y = 1;
    // las variables declaradas con let o con const, no pueden ser declaradas nuevamente.
    //dentro del mismo ambito, como es el caso de la variabl y.
    //let y = 2; 
    console.log(x);
    console.log(y);
}

anotherFuncion();

En resumen…

• Nunca usar Var
• Let y Const si

Para mi let se puede reasignar, mas no volver a declarar una variable con el mismo nombre, const no permite reasignar un valor

Desde la llegada de let y const , es casi obligatorio usar estas keywords y dejar var en el olvido.

Function Scope:
Es el alcance que tienen las variables dentro de una función. Concretamente lo que se define para la existencia de dichas variables.
·
Accedemos a las variables que solamente habiten dentro de la función que no es establecida de forma global.
·
Se puede ver como el alcance que tienen variables que son declaradas dentro de una función.
((Recuerda: evita redeclarar en lo que más puedas. puedes reasignar, pero no redeclarar))

Para aclarar los conceptos.

1. Declarar. Nombrar una variable.
2. Asignar. Dar valor a la variable
3. Reasignar. Dar un nuevo valor a la variable que ya tiene un valor.
   Entonces las variables que son:
4. var se pueden declarar, asignar y reasignar en cualquier parte del script. Pero solo afecta su scope, por ejemplo si la variable es declarada global, en una función puede volver a ser declarada y asignarle un nuevo valor, pero su scope siendo local no afectará a la variable global.
5. let solo se pueden declarar en su scope una vez, y la única forma de volver a declarar una variable con el mismo nombre será en un scope diferente. Pero en cualquier scope está variable puede ser asignada y reasignada al gusto del desarrollador.
6. constsolo se pueden declarar en su scope una vez, y la única forma de volver a declarar una variable con el mismo nombre será en un scope diferente. Pero en cualquier scope está variable puede ser asignada y reasignada al gusto del desarrollador.

var nombre = "Dev";
let apellido = "Arias";
const age = 30;

function presentar() {
  var nombre = "David";
  var nombre = "Daniel";
  let apellido = "Fuentes";
  apellido = "Puerto";
  const age = 31;
  console.log(nombre + " " + apellido + " " + age + "\n");
}
apellido = "Castillo";
presentar();
console.log(nombre + " " + apellido + " " + age);

Esto daría el siguiente output:

Daniel Puerto 31

Dev Castillo 30

Si en el scope general o local nosotros intentamos declarar una variable let o const nos arrojaría error. Al igual que si llegamos a intentar reasignar el valor de una variable const.

Variables declaradas con let o const. Cuando declaramos una variable let o const dentro de un bloque, el alcance o scope que tendrá será sólo dentro de ese bloque. Además, si existe una colisión de nombres entre dos variables let o const recibiremos un mensaje de error. Esto hace que seamos menos susceptibles a cometer errores al utilizarlas, es por esto que desde que salió ES6 es más recomendable utilizar let o const a la hora de declarar una variable en lugar de usar var.

let platzi = 'Esto está fuera del bloque';

if (true) {
	let platzi = 'Esto está dentro del bloque';
	console.log(platzi); //Esto está dentro del bloque
}

console.log(platzi) //Esto está fuera del bloque

Yo creo que “let” y “const” fue un regalo por parte de los que manienen a JavaScript para nosotros jaja, recuerdo la cantidad de bugs que tuve antes por usar “var” xD

gente, tonces cual es la diferencia del function scope con el local scope?
O es que function scope es un local scope? 😅😅

Como el tema de las palabras “re-declarar” y “re-asignar” confunde un poco, les dejo mis notas por si les sirve!

const fruits = () => {
  var fruit = "apple";
  console.log(fruit);
};

fruits(); // resulta: apple (scope local dentro de la función)
console.log(fruit); // resulta error (no está definida en el scope global)

/*------------*/
const anotherFunction = () => {
  var fruit = "apple";
  var fruit = "banana";
  let color = "blue";
  // let color = 'yellow'; -> error
  color = "red";
  const number = 1;
  // number = 3; -> error
  console.log(fruit);
  console.log(color);
  console.log(number);
};

anotherFunction();
//resulta: banana red 1

/* - VAR permite re-declarar las asignaciones (MALA PRÁCTICA)
   - LET y CONST no permiten re-declarar asignaciones y arrojan error.
   - LET permite re-asignar un nuevo valor, pero CONST no y arroja error.
*/```

Mis notas (3) 😃

//🏭 Scope en una funcion (Function Scope)

//Scope 🔎
const fruits = () => {
  var fruit = "apple";
  console.log(fruit);
};

fruits();
console.log(fruits()); // ❌ No puedo acceder a una variable fuera de su scope

//Reasignacion y redeclaracion en scope 🔒 local (Function Scope)
const anotherfunction = () => {
  var x = 1;
  var x = 2;
  let y = 3;
  let y = 4; //❌ No puedo volver a redeclarar un let

  console.log(x);
  console.log(y);
};

Platzicoders, aquí un pequeño aporte de la clase:
.

.
Espero que les sirva.
(⌐■_■)

las variables declaradas con let si se pueden reasignar lo que no se puede hacer es volver a declarar.

Creo que tenemos un pequeño error de concepto que puede confundir.
Let si se puede re-asignar, lo que no se puede de re-declarar…

Para reescribir una variable con var no es necesario volver a escribir var, simplemente se escribe el nombre de la variable y se le asigna su nuevo valor:

var x = 1;
x = 2;

como le hace para comentar el codigo seleccinandolo sin poner directamente // o /**/?

No usar var
No usar var
No usar var

• Var… you are dangerous!!

var: :’(

Arrow Functions:

fuente: https://escuelavue.es/series/javascript-moderno/arrow-functions-funciones-flecha-que-son/

• Se utilizan principal mente en funciones que contienen una sola sentencia (una línea de código) sin utilizar las llaves: {}, o si la función tiene más de una línea de código, si se utilizan las llaves.

• Las Arrow Functions pueden o no aceptar argumentos.

• Las Arrow Funcions tienen el return implícito, no hace falta especificarlo.

Ejemplo:

// Función declarada
function sayHi1(name) {
    console.log(`Hi ${name}!`)
}

// Expresión funcional
const sayHi2 = function(name) {
    console.log(`name ${name}!`)
}

// Función flecha
const sayHi3 = (name) => console.log(`name ${name}!`)

la variable let no se puede redeclarar pero si se puede reasignar

Es decir no funciona:

let unaVariable = 'Hola';
let unaVariable = 'Mundo';
//error
Pero si funciona:

let unaVariable = 'Hola';
unaVariable = 'Hola Mundo';
//Hola Mundo

Porque se reasigna el valor.

empieza a quedar más claro las diff entre let y var

Estoy deacuerdo con los comentarios anteriores, hay una distincion entre reasignar y redeclarar.

REASIGNAR:

   var x = 1;
    var x = 2;
    let y = 3;
    y = 4;
    console.log(x)
    console.log(y)

Muestra: 2 y 4

REDECLARAR:

   var x = 1;
    var x = 2;
    let y = 3;
    let y = 4;
    console.log(x)
    console.log(y)

Muestra: Error en let y= 4 -> SyntaxError: Identifier ‘y’ has already been declared

• var siempre va a reasignar si esta se declara con otro valor dentro de su scope.

var x = 1; // X vale 1
var x = 2 // X deja de valer 1 y ahora vale 2

• let no permite que se vuelva a declarar una variable en el mismo scope, por lo cual no se reasigna de forma diferente.

let y = 1; // Y vale 1
let y = 2; // Error ya creaste una variable Y y vale 1  no puedes crearla de nuevo.
y = 2; //Y valiá 1 pero ahora vale 2

FUNCTION SCOPE APUNTES

const fruits = () =>{

    var fruit = 'apple';
    console.log(fruit);



};


fruits();
// si accedemos a esa variable que no esta definida en global si no en local
console.log(fruit); //saldra error diciendo que la variable no esta definida

//declaramos una funcion para trabar scope local
const anotheFuction = () =>{

    var x = 1;
    var x = 2;
    let y = 1;
    let y = 2
    console.log(x, y);

}

anotheFuction();

// al ejecutar nos dara error y nos dice que no podemos reasignar algo
// que ya esta asignado
// Este error solo pasa con const y let ya que no las podemos declarar
// y asinarle un valor distinto del que ya estaba asignado```

Les dejo el código de la clase

const fruits = () =>{
    var fruit = 'apple';
    console.log(fruit);
};

fruits();

const anotherFunction = () {
    var x = 1;
    var x = 2;
    let y = 1;
    //y no se pude volver a reasignar porque está declarada con let
    //let y = 2;
    console.log(x);
    console.log(y);
}

anotherFunction();```

entonces cada vez que reusamos una variable con var hay que escribirla con la keyword var?

Este nos permite acceder a una variable en un bloque de código o un a función pero solamente dentro de esta estructura.

const fruits = () => {
    let fruit = 'Pineapple'
    console.log(fruit)
}

fruits()
console.log(fruit)

Si queremos reasignar el valor de una variable tenemos que utilizar var, aunque esto es considerado una mala práctica. Si lo tratamos de hacer con let la consola nos lanzará un error

const anotherFruit = () => {
    var x = 1;
    var x = 2;
    let y = 1;
    // let y = 2;
    console.log(x)
    console.log(y)
}

anotherFruit()

Scope función
Este scope pone las variables disponibles a toda la función, si la variable es var, sera de función sin importar dónde esté (dentro de la función), pero si es let o const no puede estar dentro de otro bloque {} como un if o un bucle

// Caso cuando redeclaramos variables declaradas con var
function fruits () {
	var apple = 'apple'
	var apple = 'pear'
	console.log(apple);
}

fruits() // 'pear'

// Caso cuando redeclaramos variables declaradas con let

function fruits () {
	let apple = 'apple'
	let apple = 'pear'
	console.log(apple);
}

fruits() // SyntaxError: Identifier 'apple' has already been declared

// Let no se deja redeclarar pero si se puede reasignar

function fruits () {
	let apple = 'apple'
	apple = 'pear'
	console.log(apple);
}

fruits() // 'pear'

// Si las variables las declaramos con const no podran ser redeclaradas ni reasignadas

function fruits () {
	const apple = 'pear';
	apple = 'apple';
	console.log(apple);
}

fruits() // TypeError: Assignment to constant variable.

Por aca dejo mi código:

const func1 = () => {
  const fruit = "apple";
  console.log(fruit);
};
func1();

const func2 = () => {
  var x = 1; // No uses VAR si no quieres tener problemas más adelante insecto!!!
  var x = 2; // No uses VAR si no quieres tener problemas más adelante insecto!!!
  let y = 1;
  y = 2;
  console.log(x);
  console.log(y);
};
func2();

La recomendación es usar let y const y dejemos de usar esta asignación de var para la llamada de nuestras variables. 
Esto nos va a garantizar que nuestro código va a funcionar y que no vamos a rescribir absolutamente nada

codigo de la clase:

const fruit = () => {
    var  fruit = 'apple';
    console.log(fruit);
}

fruit();
console.log(fruit); //sale error


const anotherFunction = () => {
    var x = 1;
    var x = 2;
    let y = 1;
//    let y = 2;
    console.log(x);
    console.log(y);
}
anotherFunction(); //dentifier 'y' has already been declared

Los parámetros dentro de una función también son llamadas Function Scope

const anotherFunction = (mivariable) => {
  console.log(mivariable)
}

Por buenas practicas se recomienda usar

let : declara una variable de alcance local con ámbito de bloque(block scope), la cual, opcionalmente, puede ser inicializada con algún valor.

const probandoLet = () => {
    let valor1 = 5;
    for(let i = 0; i <= 5; i++) {
        // esto es el block scope
        let valor1 = i * 2;
        console.log("Valor 1(blockScope) => ", valor1);
    }
    console.log("Valor 1 => ",valor1);
}

probandoLet();

// salida 
Valor 1(blockScope) =>  0
Valor 1(blockScope) =>  2
Valor 1(blockScope) =>  4
Valor 1(blockScope) =>  6
Valor 1(blockScope) =>  8
Valor 1(blockScope) =>  10
Valor 1 =>  5

const : resentan un ámbito de bloque (block scope) tal y como lo hacen las variables definidas usando la instrucción let, con la particularidad de que el valor de una constante no puede cambiarse a través de la reasignación

//-----------FUNCTION SCOPE---------
const fruits = () => {
  var fruit = "Apple";
  console.log(fruit);
};

fruits();
console.log(fruit); // No se puede acceder a la variable fruit porque está declarada de forma local.

const anotherFunction = () => {
  var x = 1;
  var x = 2;
  let y = 1;
  let y = 2; // No se puede re-declarar
  console.log(x);
  console.log(y);
};

anotherFunction();

// Es recomendable siempre usar let y const y dejar a un lado var. Esto para estar seguros de no reasignar ninguna variable en nuestro código.

Redeclarar variables es lo que no se debe hacer, lastimosamente var lo permite dentro del mismo scope, por eso es mejor utilizar let que te ayuda a controlar mejor ese error en proyectos grandes.

Ahora reasignar es otro cuento y es pan de cada dia de un desarrollador

//esto es redeclarar
let x = 1
let x = 2
//esto es reasignar
let x = 1
x = 2

El problema que tenemos con declarar una variable con VAR es que si la declaramos por error con el mismo nombre, entonces JavaScript no detectará el error y permitirá que se reasignen nuevos valores en diferentes contextos. Entonces por prevención se sugiere usar LET y CONST.

diferencias en el uso de var, let y const. Excelente explicación con el scope local.

//Las variables de tipo var se pueden volver a declarar y reasignar, se puden sobre escribir. 
var a = 5;
var a = 8; 
console.log(a); // return 8

//las variables de tipo let, no se pueden volver a declarar pero si se pueden reasignar
let b = 5; 
let b = 8; //Error la variable ya esta declarada
let c = 5
c = 10 // Reasignando un nuevo valor a la variable c
console.log(c) // return 10

Tener en cuenta let a = 3 let a = 4 no funciona, pero si colocamos let a = 3 y a = 4 si va funcionar:

//otro ejemplo de reasinacion:
const antotherFunction = () => {
  var x = 1
  var x = 2
  let a = 3
  //error no se puede reasignar
  // let a = 4
  //una mala practica:
  a = 4
  console.log(x)
  console.log(a)
}
antotherFunction()

Como las variables locales solo se reconocen dentro de sus funciones, las variables con el mismo nombre se pueden usar en diferentes funciones.

Las variables locales se crean cuando se inicia una función y se eliminan cuando se completa la función.
By: https://www.w3schools.com/js/js_scope.asp

Javascript SI permite reasignar un valor a una variable declarada con let. Las siguientes líneas no botan error alguno:
let x=1
x=2
x=‘Oscar’

Lo que no permite es declararla de nuevo, más de una vez dentro del mismo scope:
let x=1
let x=2

El operador ‘=’ es un operador de asignación de valores.

Las variables con let y const no se pueden volver asignar, esto nos ayuda a no sobre escribir los valores de nuestras variables erróneamente. La desventaja de usar var es que si no se tiene cuidado puede sobrescribir valores en nuestra variable y se aconseja no usarla.

Cuando declaramos una variable

var example = 1
example = 2

let example1 = 1
example1 = 2

const example2 = 1
example2 = 2

La unica que no se puede reasignar un valor es a const

La variable fruit esta en el ámbito Function Scope

const fruits = () => {
    var fruit = 'apple'; 
    console.log(fruit); 
}
fruits();

Ayuda, cual es la diferencia…

const anotherFunction = () => {
    var x = 1;
    var x = 2;
    let y = 1;
    y = 2;
    console.log(x); // resultado = 2
    console.log(y); // resultado = 2
};
const anotherFunction = () => {
    var x = 1;
    var x = 2;
    let y = 1;
    let y = 2;
    console.log(x); // resultado = 2
    console.log(y); // Error
};

Si se puede reasignar lo que no se puede hacer es redeclarar.
al que no puedes reasignar ni redeclarar ni tocar es a const.
mas simple es definirlo de esta manera:
var y let = mutable,
const = inmutable

const fruit = () => {
    var fruta = "manzana";
    console.log(fruta)
}

const anotherFunction = () =>{
    /*Retomando un poco lo dicho en el aporte del video anterior, observemos que las variables
    'x' y 'y' son variables locales, esto quiere decir que al termino de su ejecucion dejan de 
    existir las referencias a estas.
    
    var por su lado permite asignar en mutiples ocasiones una direccion de memoria a nuestra variable
    haciendo que la información anterior sea "eliminada". Let por su parte permite la asignacion de 
    memoria una sola vez a la variable y esta seguira existiendo hasta que su scope se lo permita.
    */ 
    var x = 1;
    var x = 2;
    let y = 1;
    let y = 2;

    console.log(x)
    console.log(y)
}

anotherFunction()

Scope local en funciones : aplica para las variables declaradas dentro de una función y esta no pueden ser accedidas fuera de la misma.

Diferencias en las formas de declarar una variable:

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

Hablamos del Scope global en una funcion, donde esta solo es declarada dentro de una funcion, esta variable no puede ser usada y manipulada fuera de esta, solo dentro. Al igual vemos que el let y el const no puede re-delcarar el valor de una variable, solo el var.

El const POR SER CONSTANTE, no se puede RE ASIGNAR pero el let SI SE PUEDE RE ASIGNAR Pero de la siguiente forma:

MAL
let a = 4;
let a = 10;
BIEN
let a = 4;
a = 10;

const frutas = () => {
    var fruta = "apple";
}
frutas();

//Las variables declaradas con const y let no se pueden volover a cambiar el valo

Si quieren agregar un snippet rápido para crear la variable de tipo function como lo hace el profe, configuren su .json:

"Function Type 2":{
		"prefix": "Function2",
		"body": [
			"const ${1:name} = (${2:params}) => {",
				"\t",
			"}"
		],
		"description": "Variable type function"
	}

Ojo, hay una diferencia entre reasignar una variable y reasignar un valor de esa variable.
.
var: Si puede reasignar la variable y también su valor
let: No puede reasignar la variable y pero sí su valor
const: No se puede reasignar la variable y tampoco su valor,
.
Ejemplo:

var x = 25 // Declaramos variable y asignamos valor
var x = 12 // Reasignamos la variable y también el valor
x = 45 // Reasignamos el valor de la variable

Todo esto viene en las nuevas convenciones de ES6 en resumen es esto:

**let **: declara una variable de alcance local con ámbito de bloque(block scope), la cual, opcionalmente, puede ser inicializada con algún valor.
const : resentan un ámbito de bloque (block scope) tal y como lo hacen las variables definidas usando la instrucción let, con la particularidad de que el valor de una constante no puede cambiarse a través de la reasignación

const fruits = () =>{
    var fruits = 'apple'
    // se ejecuta en function scope o scope local
    console.log(fruits)
}
fruits()
// se ejecuta en scope global
console.log(fruits)

const hello = () => {
    var x = 1
    var x = 2 // var es reasignado
    let y = 1
    // y = 2 // podria ser reasignada pero solo globalmente
    console.log(x)
    console.log(y)
}
hello()

• scope local en bloque y scope local en funciones. var es una asignación de función y let y const son asignaciones de bloque.

Pero en Javascript al usar let no se puede volver a definir la variable, pero si a reasignar su valor.

//Local Scope
const anotherFunction = () => {
  var x = 1;
  var x = 2; 
  let y = 1;
  y = 2;
  
  console.log(x); //2
  console.log(y); //2
};

anotherFunction();

Resumen de la clase

// Esto arrojara un error ya que "fruit" no estadefinido de manera global
const fruits = () => {
    var fruit = 'apple';
    console.log(fruit);
}
fruits();
console.log(fruit);

const anotherFunction = () => {
    // Esto es un scope local
    // con var PODEMOS reasignar el valor de la variable pero puede darnos problemas a futuro
    // con let y const NO podemos reasignarlas
    var x = 1;
    var x = 2;
    let y = 1;
    let y = 2;
    console.log(x);
    console.log(y);
}
anotherFunction();

Las variables que tienen un scope de funcion Son accesibles dentro de toda la funcion, pero no fuera de la misma
Todas las variables que iniciemos con var tendran un scope de Funcion

Tengo entendido que declarar una variable comprende, llamarla y en uno que otro caso inicializarla con un valor

let nombreVariable; 

mientras que inicializar una variable comprende específicamente darle un valor

let nombreVariable = "Valor";

A lo cual me lleva a pensar que se esta confundiendo el termino REASIGNAR con REDECLARAR, ya que en mi concepto, Reasignar comprende darle un nuevo “Valor” y REDECLARAR sería volverla a llamar.

let nombreVariable;  ///Declarar una variable
let nombreVariable = "Valor";  /// inicializar una variable
let nombreVariable = "Valor2"; ///Reasignar una variable let

Siendo así, lo que el profe quiere decir es que const no permite reasignar, let si lo permite y var ni decirlo.
Si me equivoco por favor corríjanme 🤔

Usar let y const en la mayor medida posible

Sería que no se pueden reasignar o redeclarar?

const

• Es una señal de que una variable no debe ser Re-Asignada.
• Nos va a forzar a escribir código limpio.
• Scope: bloque. Uso mas cercano de la variable.

let

• La usamos para decir que una variable puede ser Re-Asignada.
• Generalmente lo usamos para iterar ciclos for o cuando no nos queda otra opción.
• Scope: bloque. Uso cercano de la variable.

Var

• No nos dice mucho. No no da ninguna señal de cómo debería usarse las variables.

• Puede representar una constante o una variable que se puede Re-Asignar.

• Puede servir para usar variables dentro de un bloque o dentro de una función, lo cuál es confuso y pude traer bugs.

🤔 creo que hay algo importante que aclarar. Si se puede “reasignarle” el valor a una variable. Lo que generaria un error seria “redeclararla”
.
.
🤓 como se ve en este ejemplo de abajo se presenta un error si se intenta volver a “declarar” una variable que fue declarada con “let”

let x = 2;
let y = 3;
let c = x + y;
let x = c + y
VM441:4 Uncaught SyntaxError: Identifier 'x' has already been declared

“Identifier ‘x’ has already been declared” literalmente dice que el identificador “x” ya ha sido declarado

let x = 2;
let y = 3;
let c = x + y;
x = c + y
8

😉 pero si se le reasigna un nuevo valor a la variable (lo cual es necesario para muchos tipos de iteraciones), javascript permite esto con variables declaradas como let
.
👉🏼.👈🏼 Aclaro esto por que me parecio que el profesor dijo que a las variables con let no se les puede cambiar su valor. Y que solo con las variables declaradas con var son capaces de esto, pero ambas pueden ser reasignadas.
.
.
espero que si tuviste la misma duda leer esto te haya servido 😄!

Creo que utiliza mal las palabras reasignar y redeclarar. Justo en donde es necesario tener cuidado con esto porque se está tratando de definir su signidficado. Declarar es decir que existe una veriable “x”, asignar, es decir que valor tiene la variable “x”. Redeclarar es solo posible con VAR, reasignar es posible con LET y VAR.

excelente clase!

Variables
El uso de cada tipo de variable es importante, ya que utilizar las variables declaradas con “VAR” es peligroso debido a que es posible re declararlas

var: Permite declarar, redeclarar y reasignar.

var x = 1;
var x = 2;

console.log(x)

>2

• let: Permite declarar, no permite redeclarar, y sí permite reasignar cuantas veces quieras.

let x = 1;
let x = 2;

console.log(x)
>SyntaxError: Identifier 'x' has already been declared

let x = 1;
x = 2;

>2

• const: Permite declarar, no permite redeclarar, y no permite reasignar jamás.

const x = 1;
const x = 2;

console.log(x)
>SyntaxError: Identifier 'x' has already been declared

let x = 1;
x = 2;

>TypeError: Assignment to constant variable.

Buena practica: Usar let y const dentro del bloque del codigo para evitar redeclarar valores.
Cabe mencionar que la let se puede reasignar pero no redeclarar, es decir.

let variableLocal = "soy una variable local";
variableLocal = "puedo ser reasignada";

console.log(variableLocal);


"puedo ser reasignada"

A ver, aquí el profesor no esta asignando de nuevo, está declarando una variable de nuevo, hay un error de concepto que no se puede tolerar, o eso al menos se llama así en todos los lenguajes de programación que conozco

var x; // Declarar
x = 5; // Asignar
var y = 6; // Declaro y asigno en la misma linea

Esto sí sería válido

let x = 5; // Declaro y asigno en la misma linea
x = 7; // Reasigno

This is my practice:
https://github.com/eliabjselvacruz/practice/commit/b5ea51fef70955a81c3b3073c83631e39b33de47

las variables var se pueden reasignar
las variables let y const ya no se pueden reasignar

la verdad creo que este curso no esta bien explicado

Mis notas

const fruits = () => {
    var fruit = "apple";
    console.log(fruit);
}

fruits();
// console.log(fruit); se da error porque esta definidio de forma local


const anotherFunction = () => {
    var x = 1;
    var x = 2; //Var si asigna un nuevo valor, por eso se debe dejar de usar esta variable para no reescribir nada
    let y = 1;
    // let y = 2; no se puede reasignar el valor de let y const
    console.log(x);
    console.log(y);
}

anotherFunction();

Este video es un gran apoyo para comprender el tema de **scope **lo comparto para quien como yo esté un poco confundido y quiera una ayudita extra😊💚🚀
Scope

Cuando iso el ejemplo de closure se me vino a la cabeza hacerlo con clases y quedo asi

class MoneyBox {

    constructor() {
        this.coins = 0
    }

    countCoins(coins) {
        this.coins += coins;
    }

    showCoins() {
        console.log(`Ahorro: $${this.coins}`);
    }
}

let moneyBoxSergio = new MoneyBox();
moneyBoxSergio.countCoins(4);
moneyBoxSergio.showCoins();
moneyBoxSergio.countCoins(6);
moneyBoxSergio.showCoins();
moneyBoxSergio.countCoins(10);
moneyBoxSergio.showCoins();

Y aqui el ejemplo con closure

const moneyBox = () => {
    let saveCoins = 0;
    const countCoins = (coins) => {
        saveCoins += coins;
        console.log(`MoneyBox: $${saveCoins}`);
    }
    return countCoins;
};

let myMoneyBox = moneyBox();
myMoneyBox(4);
myMoneyBox(6);
myMoneyBox(10);

las variables asignadas con let y const no son mutables

El shortcut para correr el codigo seleccionado es ctrl + alt + n
y si no seleccionan nada, ejecutara todo el archivo en el que esten

Muchas gracias ahora entiendo mejor la diferencia entre var y let

Para saber más de como funcionan ver, let y const les dejo un video de profe Sacha.
https://www.youtube.com/watch?v=bvkY9ey83yY

const fruits = () => {
    var fruit = 'apple';
    console.log(fruit);
};

fruits();
console.log(fruit);

/* Aqui tienes un error por que estas tratando de llamar a una variable local de la function fruits en un entorno global */

const anotherFunction = () => {
    var x = 1;
    var x = 2;
    let y = 1;
    let y = 2;
    console.log(x);
    console.log(y);
}
anotherFunction();

/* en este caso obtienes como resultado un error por que las variables let no pueden ser declradas dos veces con el mismo nombre, si tuvieramos solo let y = 1; el resultado de x seria 2 ya que con var si podemos declarar la misma variable x y se le asigna el nuevo valor  y en la variable y nos montraria el 1 */

/* Es una buena practicar declrar nuestras variable con let y const así garantizamos que no vamos a reescribir nada en nuestro codigo */

Dentro de una función, ó mejor dicho en un scope local lo mejor que podemos hacer es usar solo const y let para no sobrescribir cosas que si permite hacer var así se tiene mejor control del scope local.

const fruits = () => {
  var fruit = 'apple'
  console.log(fruit)
}

fruits()
// console.log(fruit) --> SyntaxError: fruit is not defined

const anotherFunction = () => {
  var x = 1 
  var x = 2
  let y = 1
  // let y = 2 --> SyntaxError: Identifier 'y' has already been declared
  console.log(x)
  console.log(y)
}

anotherFunction()

Dejo esta imagen cortesía de Leonidas, que creo que lo explica bastante bien.

Un saludo.

var x = 🐥;		
var x = 🍗;	// permitido

var y = 🐖;
y = 🥓;		// permitido

console.log(x);		// 🍗
console.log(y);		// 🥓

let x = 🐥;		
let x = 🍗;	// NO permitido

let y = 🐖;
y = 🥓;		//permitido

console.log(x);		// Error
console.log(y);		// 🥓

const x = 🐥;		
const x = 🍗;	// NO permitido

const y = 🐖;
y = 🥓;		// NO permitido

console.log(x);		// Error
console.log(y);		// Error

Lexical Environment:

example

Function SCOPE vs Global Variable

Las variables declaradas con let o const no se pueden reasignar! con var si se puede hacer

Muy buena clase, cada vez veo todo con más claridad. 👨🏻‍💻

easy!!!

pero si podríamos hacer esto:

let y = 1
y=2```

Ok, buena recomendación.