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 … 🤔

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

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

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

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.

Usar let y const en la mayor medida posible

En resumen…

• Nunca usar Var
• Let y Const si

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

Sería que no se pueden reasignar o redeclarar?

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

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

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"
	}

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

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

easy!!!

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;

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.

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

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

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

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

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

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

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…

La variable fruit esta en el ámbito Function Scope

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

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

pero si podríamos hacer esto:

let y = 1
y=2```

Ok, buena recomendación.

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.

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.

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

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

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

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

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.

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

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

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

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

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

A var le da igual todo 😅

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

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

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

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

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

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

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

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

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

• Var… you are dangerous!!

var: :’(

En JavaScript se puede obviar el uso del punto y coma ( ; )

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;

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

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.

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

🎥Mas informacion
📄Mas informacion

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

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```

• 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

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