No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Function Scope

4/12
Recursos

El scope local de funci贸n es el entorno donde las variables locales solo se pueden acceder desde una funci贸n del programa.

En este scope no importa que las variables sean declaradas con var, let o const. Sin embargo, ten presente que se puede re-declarar una variable con var, pero no con let y const.

Siguiendo el principio ya aprendido de cadena de scope. Si existe una funci贸n dentro de otra funci贸n, la funci贸n hijo podr谩 acceder a las variables de la funci贸n padre, pero no en viceversa.

Representaci贸n de los tipos de scope

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

Aportes 104

Preguntas 10

Ordenar por:

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

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 鈥渆rror: 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 鈥渞easignar variables, quiere decir 鈥渞edeclarar 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 鈥渞edeclarar鈥 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
No s茅 que tanto aporta esta clase, no porque no sea importante, sino que ya se ha visto eso en var铆as clases y cursos de javascript. Entonces repetir tanto no le veo sentido.

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 鈥渓et鈥 y 鈥渃onst鈥 fue un regalo por parte de los que manienen a JavaScript para nosotros jaja, recuerdo la cantidad de bugs que tuve antes por usar 鈥渧ar鈥 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 鈥渞e-declarar鈥 y 鈥渞e-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 鈥榶鈥 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?

<h1>Function Scope</h1>

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=鈥極scar鈥

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 鈥淰alor鈥 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 鈥渞easignarle鈥 el valor a una variable. Lo que generaria un error seria 鈥渞edeclararla鈥
.
.
馃 como se ve en este ejemplo de abajo se presenta un error si se intenta volver a 鈥渄eclarar鈥 una variable que fue declarada con 鈥渓et鈥

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

鈥淚dentifier 鈥榵鈥 has already been declared鈥 literalmente dice que el identificador 鈥渪鈥 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 鈥渪鈥, asignar, es decir que valor tiene la variable 鈥渪鈥. 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 鈥淰AR鈥 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

Una peque帽a aclaraci贸n con respecto a las variables con let: est谩s variables no se pueden volver a definir pero si se le puede asignar valores m煤ltiples veces.

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.