Variables - toviddfrei/javascript GitHub Wiki
¿Cuáles son las diferencias entre const, let y var?
Los diferentes tipos de declaración de variables en JS, vale comencemos por recordar que es y que hace una variable, cuál es su posible utilidad para un desarrollador, pensemos como desarrolladores, ¿qué podría hacer con variables en JavaScript?, de los tipos de variables que vemos, ¿cuál es la diferencia entre ellos?
Creo que lo mejor que podemos hacer con esta pregunta es recordar casi lo básico de JavaScript, como de cualquier lenguaje, teniendo claro que tanto const, let y var son tipos de declaración de variables que podemos utilizar en JavaScript, lo primero sería recordar que es una variable y para qué sirve, si partimos de esta premisa lo mejor es lo dicho lo básico.
JavaScript es un lenguaje, enfocado a la programación orientada a objetos, es un lenguaje case-sensitive, lo que nos dice que distingue entre mayúsculas y minúsculas y que utiliza el conjunto de caracteres Unicode. Algún dato más importante sería conocer los tipos de datos que maneja JavaScript, pero no hace mucho ya lo tocamos me imagino que lo tenemos presentes, number, string, object, null, undefined, creo que están todos, aunque ahí alguno nuevo como symbols, que está en la parrilla de ser devorado por mi agenda formativa, un apunte, para toda evolución, considero muy importante a título personal llevar una agenda, memoria de el antes y el después, ver tu evolución genera endorfinas o por lo menos a mí. Bueno que me voy, tenemos recordados todos estos conceptos. Vale uno más y nos posicionamos, las instrucciones en JavaScript se denominan declaraciones.
Buen repaso, ¿no?, entonces por situarnos, vamos a realizar un test de las opciones y funcionamiento que cada uno de estos tres tipos de declaración de variable nos proporciona, realizando declaraciones de las mismas y analizando su uso y sobre todo el entorno en el que funcionan, recalco el entorno por ser una de sus mayores diferencias y a su vez uno de los mayores mareos a la hora de profundizar en ellas. Empezamos por const si os parece.
Const variable
Entonces, por aclararnos, hay tres tipos de declaraciones de variables, o sea tres tipos de variables, pero solo dos formas de declarar las variables, según su ámbito o contexto de acción, como os comente, su entorno de funcionamiento es clave a la hora de ver las diferencias. Por lo tanto, const, según definición del siguiente enlace:
Las variables constantes presentan 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. Las constantes no se pueden redeclarar.
const numbertest = 7;
console.log(numbertest);
Averigüemos lo primero que significa de ámbito bloque o block scope, por sí solo nos agrupa en este tipo a let y a const, luego veremos la diferencia entre ellas, pero ahora mismo nos interesa agruparlas let y const son declaraciones de variables, o variables que son de ámbito bloque o actúan funcionan en un block scope. Seguimos.
Un block scope o sentencia block, se utiliza para agrupar cero o más sentencias o declaraciones. El grupo se delimita por un par de llaves. O sea.
{var a1 = 1; let a2= 2; const a3 = 3;} //agrupamiento de sentancias o declaraciones, en un block scope o sentencia block
Si estamos hasta aquí, perfecto, vale, consideremos que fuera de las llaves tal como nos dice fuera de la sentencia de block es el ámbito global, el mundo exterior, incluso dentro de nuestra aplicación, fuera del ámbito delimitado por las llaves lo que existe es desconocido, externo el ámbito global, tenemos pillado el tema. Dentro y fuera. Vale seguimos con const, un ejercicio sería ver la situación de extraer la declaración const fuera del ámbito donde está y seguir manteniéndola en el ámbito local dentro de las llaves, ver el retorno probando varias llamadas. Juguemos.
const a3 = 3;
{var a1 = 1; let a2= 2; const a3 = 3;}
console.log(a3);
Ahora mismo no sabríamos qué variable está retornado de las dos a3, lo que está claro es que nos permite tener la misma variable en ámbito global y en la sentencia block. Nos lo permite let y var, vamos a probarlo.
const a3 = 3;
var a1 = 1;
let a2 = 2;
{var a1 = 1; let a2= 2; const a3 = 3;}
console.log(a3);
console.log(a1);
console.log(a2);
Las tres declaraciones, nos permiten declararlas en ambos ámbitos, significa qué, ¿Tenemos seis variables, o solo tres?, ¿cómo nos podemos organizar así?, avancemos un poco y despejemos dudas, vamos a cambiar valores y vemos cuál está devolviendo, vamos a pasar los valores de la sentencia block a las decenas y dejamos igual las variables en el ámbito global, y vemos el resultado y analizamos, podríamos leer, y leer mucha documentación, pero sin ver los resultados en vivo creo que siempre falta algo, descubrir las diferencia por uno mismo y luego consultar documentación, también es viable, incluso en algunas ocasiones aconsejables bajo mi criterio, o por lo menos a mí me va bien, en este caso quiero utilizar este sistema, dejar claro el ámbito o contexto es fundamental, verlo con nuestros propios ojos creo que también. Seguimos, que me enrollo.
const a3 = 3;
var a1 = 1;
let a2 = 2;
{var a1 = 10; let a2= 20; const a3 = 30;}
console.log(a3);
console.log(a1);
console.log(a2);
Queda claro que hay una diferencia en el funcionamiento de const y let con el funcionamiento de var, saquemos conclusiones o mejor hipótesis de porque y porque no y luego consultamos la documentación, tenemos conceptos claros o debemos tenerlos, todo erradica en el ámbito de acción.
La variable o declaración var le da igual el ámbito donde está, sea global o sea local, sea dentro de la sentencia block o a campo abierto, asume el valor último secuencial que tenga, incluso si profundizamos un poco más, nos deja cambiar el valor, nos deja interactuar con ella, renombrarla. También se recomienda limitar su uso, pero bueno cuando lleguemos a su sección, profundizaremos mucho más, tiene un uso casi exclusivo y yo diría que necesario cuando queremos manejar la expresión this.
Seguimos con const, o casi diría con todo, pero creo que es la forma de verlo, luego trataremos a let y a var un poco individual, pero tanto una como otra actualmente tienen un uso menor, se recomienda el uso y disfrute de const como declaración de variable digamos diaria o de uso cotidiano. La verdad es que profundizar en const, y confirmara la recomendación.
Sigamos analizando, investigando, confirmando, corrigiendo. Pasas al parque de atracciones...
const a3 = 3;
var a1 = 1;
let a2 = 2;
{var a1 = 10; let a2= 20; const a3 = 30;}
//const a3 = 3;
var a1 = 100;
//let a2 = 2;
console.log(a3);
console.log(a1);
console.log(a2);
Visualmente, podemos confirmar lo dicho, si dejamos de comentar la segunda declaración de const y let en el ámbito global, se retornan errores SyntaxError en ambas variables, no deja renombrar, por supuesto menos cambiar valores o interactuar, concluimos y confirmamos let y const son dos variables de ámbito de bloque, pero el bloque no solo lo forman un entorno local como una función, también lo forma un Node como estamos utilizando en este documento. Nos podíamos quedar con la idea de que este Node tiene un ámbito global y un ámbito local, más claro, creamos una función que encerrara nuestro ámbito local y fuera de la función será nuestro ámbito global en el Node. Creo que ha quedado claro, la función se denominara localespace(), vale.
// Ambito global del Node
const a3 = 3;
var a1 = 1;
let a2 = 2;
function localespace(){
// Ambito local de la función
var a1 = 10;
let a2= 20;
const a3 = 30;
console.log(a3);
console.log(a1);
console.log(a2);
// vamos a retornar valores y eliminamos el undefined, recordamos funciones y su retorno
// recordemos el uso de comillas invertidas para transponer valores ...
return `${a3} ${a1} ${a2}`;
}
//const a3 = 3;
var a1 = 100;
//let a2 = 2;
console.log(a3);
console.log(a1);
console.log(a2);
console.log('Este es el resultado local : ' + localespace());
Analizando los resultados, podemos confirmar que tenemos seis variables distintas, mejor, aparte de que este hecho en una aplicación coherente seguro que desencadena un error o un problema, lo que debemos decir es que const y let nos permiten declararse en un ámbito de sentencia block, funcionando independiente para cada contexto, incluso con denominación igual, manteniendo valores distintos, por eso ahí que hacer hincapié, que se pueda realizar no quiere decir que sea la forma más alejada de buscarse problemas, la lógica nos indica otra cosa. Vamos a realizar un ejemplo colocando cada cosa en su sitio y buscando una lógica de nuestros pequeños almacenes de datos, recordemos una variable, almacena uno o más datos y de tipos distintos, si observamos hasta el momento, no hemos tenido que especificar que tipo, JavaScript es automático en este sentido, recordémoslo. Sigamos. Vamos a realizar el ejemplo.
//Ambito global
// Ventas global europa
const ventas = 'uno';
function localespacespain(variable){
// Ambito local
// Ventas local ubicado spain
const ventas = 1500;
console.log(typeof(variable));
console.log(typeof(ventas));
return ventas;
};
console.log(ventas);
console.log(localespacespain(ventas));
En evidente lo que vemos, manejamos dos variables distintas completamente, siendo la misma declaración, la diferencia es el ámbito, una está dentro de una función, con lo cual actúa en un ámbito local a la función y todo lo que está fuera es el ámbito global, y otra declaración de ámbito global al Node que estamos ejecutando. Ambas declaraciones son correctas, el intérprete las evalúa correctamente y tal como vemos tienen hasta distinto tipo de datos, pero ambas son funcionales que no quiere decir que sea lógico.
Tal como hemos dicho, no es positiva esta situación, recordemos que la denominación de las variables debe cumplir unas reglas básicas, pero ante todo debe ser descriptiva a la vez que lo más especifica posible, este tipo de denominación nos permitirá tener una lectura correcta de la aplicación o el script que estemos desarrollando, seamos mucho más estilistas.
Aunque probemos esta misma situación con var, por ejemplo, ya que si usáramos let con este ejemplo, obtendríamos el mismo resultado, ya que las dos son del mismo tipo, según estamos viendo. Por lo tanto, comparemos funcionamiento con var
//Ambito global
// Ventas global europa
var ventas = 'uno';
function localespacespain(variable){
// Ambito local
// Ventas local ubicado spain
var ventas = 1500;
console.log(typeof(variable));
console.log(typeof(ventas));
return ventas;
};
ventas = 3; // esta es una gran diferencia, poder interactuar con ella
var ventas = 9; // sin problema poder interactuar nuevamente con la declaración
console.log(ventas);
console.log(localespacespain(ventas));
/*output
9
number
number
1500
*/
Si apreciamos la salida nos habla por sí sola, la variable var ventas está en ámbito global al Node y, por lo tanto, está disponible para todos los ámbitos; sin embargo, la otra variable var ventas con valor 1500 está en ámbito local a la función y no está disponible para el ámbito global del Node, por eso nos permite funcionar de esta manera, reitero, estamos viendo como no debemos declarar variables, estamos mostrando sus ámbitos y el porqué de los retornos que nos ofrecen, tenemos que hacer el esfuerzo de seguir las directrices, consejos, la forma correcta y vistosa, cómoda de leer, costumbres más extendidas, en definitiva seguir la pauta y crecer en esa pauta, siempre, siempre, intentar poder explicar el porqué y el porqué no de la pauta sería un buen comienzo. Ahora veremos let.
//Ambito global
// Ventas global europa
let ventas = 'uno';
function localespacespain(variable){
// Ambito local
// Ventas local ubicado spain
let ventas = 1500;
console.log(typeof(variable));
console.log(typeof(ventas));
return ventas;
};
ventas = 3; // ok siempre que la tratemos como variable globlal, si la limitamos con let...nos avisa
//let ventas = 3; // SyntaxError: Identifier 'ventas' has already been declared
console.log(ventas);
console.log(localespacespain(ventas));
No hay que confundirse, si definir la declaración el intérprete maneja la variable let ventas iniciales como global, aunque es de tipo de sentencia block, por lo tanto, su ámbito es de bloque, tal como estamos comentando, pero al intentar renombrar la viable, nos retorna un error de sintaxis, advirtiendo que ya está creada esta variable para este ámbito. Y tal como vemos la modificación de la variable global ventas = 3, es el valor retornado, por lo tanto, interactúa con la variable creada inicialmente let ventas.
//Ambito global
// Ventas global europa
const ventas = 'uno';
function localespacespain(variable){
// Ambito local
// Ventas local ubicado spain
const ventas = 1500;
console.log(typeof(variable));
console.log(typeof(ventas));
return ventas;
};
//ventas = 3; // TypeError: Assignment to constant variable.
//const ventas = 3; // SyntaxError: Identifier 'ventas' has already been declared
console.log(ventas);
console.log(localespacespain(ventas));
Creo que queda visto, manejamos dos variables distintas por el ámbito donde están declaradas.
Hasta el momento, si nos damos cuentas, estamos mirando de fuera a dentro, declaramos global y comprobamos si en el mismo ámbito podemos seguir trabajando con las variables, pero que ocurre de ámbito inferior a superior por decirlo de alguna manera. Veámoslo. El mismo ejemplo pero con una visión desde local a global.
%%script Node
//Ambito global
// Ventas global europa
function localespacespain(variable){
// Ambito local
// Ventas local ubicado spain
const ventas = 1500;
//var ventas = 120;//SyntaxError: Identifier 'ventas' has already been declared
//let ventas = 10;//SyntaxError: Identifier 'ventas' has already been declared
return ventas;
};
//console.log(ventas); // ReferenceError: ventas is not defined
//console.log(localespacespain(ventas)); // ReferenceError: ventas is not defined
Podemos declarar una sola variable con la misma denominación, ya sea del tipo que sea, como se ve retorna SyntaxError en ambas ocasiones, y queda confirmado que const es de ámbito de bloque, nos devuelve no definido en el ámbito global, por lo tanto, fuera de su bloque de ámbito actual no existe. Vamos a probar la misma situación con var.
// Ambito global
// Ventas global europa
function localespacespain(variable){
// Ambito local
// Ventas local ubicado spain
//ventas = 1500; // variable declarada globalmente, no recomendado
var varventas = 100; // variable declarada localmente
//var ventas = 120;//SyntaxError: Identifier 'ventas' has already been declared
//let ventas = 10;//SyntaxError: Identifier 'ventas' has already been declared
return varventas;
};
//console.log(varventas); // ReferenceError: ventas is not defined
console.log(localespacespain(this.varventas));
//console.log(this);
Vemos que la posibilidad de extraer el valor de una variable var declarada dentro de una función es con su pareja de baile this. Donde establece la variable a ámbito global y nos permite gestionarla, tanto const como let, no admiten bailar con this, es evidente que si su ámbito es de bloque no tiene mucho sentido declararlas en un bloque y querer utilizarlas fuera de ese bloque ¿no?; sin embargo, var, es una variable de ámbito de función que solo nos permite utilizarla fuera del ámbito de la función bailando con this, como estamos viendo aquí arriba, está claro que hemos mezclado en esta sección todos los tipos y multitud de ejemplos, intentemos resumir lo que tenemos y pasar a definir claramente las diferencias, creo que lo mejor es montar un cuadro de diálogo, vamos a intentarlo.
variabletipo = 'let';
const contadorconst = 0;
var contadorvar = 0;
let contadorlet = 0;
if(variabletipo === 'var'){
// contadorconst++ ; // TypeError: Assignment to constant variable.
contadorvar++; // 1
contadorlet++; // 1
}else if(variabletipo === 'const'){
// contadorconst++ ; // TypeError: Assignment to constant variable.
contadorvar++; // 1
contadorlet++; // 1
}else if(variabletipo === 'let'){
// contadorconst++ ; // TypeError: Assignment to constant variable.
contadorvar++; // 1
contadorlet++; // 1
}else{
console.log('se acabo');
}
console.log(contadorconst);
console.log(contadorvar);
console.log(contadorlet);
Podéis comprobarlo por vosotros mismos, la declaración de variable const, permanece invariable desde su creación, no podemos modificarla, ni renombrarla, en su alcance de bloque, pero tanto var como let si es posible, veámoslo desde interior a exterior.
variabletipo = 'var';
if(variabletipo === 'var'){
// const contadorconst = 1;// ReferenceError: contadorconst is not defined
var contadorvar = 1; // 1
// let contadorlet = 1;// ReferenceError: contadorlet is not defined
}else if(variabletipo === 'const'){
// const contadorconst = 1;// ReferenceError: contadorconst is not defined
var contadorvar = 1; // 1
// let contadorlet = 1;// ReferenceError: contadorlet is not defined
}else if(variabletipo === 'let'){
// const contadorconst = 1;// ReferenceError: contadorconst is not defined
var contadorvar = 1; // 1
// let contadorlet = 1;// ReferenceError: contadorlet is not defined
}else{
console.log('se acabo');
}
// console.log(contadorconst); // ReferenceError: contadorconst is not defined
console.log(contadorvar); // 1
// console.log(contadorlet); // ReferenceError: contadorlet is not defined
Creo que ha quedado nítido, que var, es de diferente tipo, con sus peculiaridades, y sobre todo con su edad, pero difiere mucho de let y const. Tomemos las recomendaciones en serio y profundicemos con const. Ya hemos visto muchos ejemplos de const, var y let. Para cerrar esta sección resumiremos las cualidades de const y las diferencias con let y var, y a continuación lo mismo con let y con var. Vamos al tajo.
Const es la forma más adecuada y recomendada para declarar una variable en JavaScript, su enfoque a creación de objetos y a la programación orientada a los mismos, la hace ideal para trabajar con ellos, tiene algunas peculiaridades propias que la hacen diferente a la antigua forma de declarar variables de var, su ámbito de funcionamiento enfocado al bloque, sea cualquier bloque, función, objeto, clase, su funcionamiento encerrado entre llaves y no permitiendo su reasignación ni redeclaración nos otorgan un espacio en memoria fijo, de uso personal y controlado, profundizar en ellos te llevan a la conclusión que confirme siguiente, const aunque podríamos entenderlo como valor constante, lo que se refiere es a identificador constante de lo que tengamos dentro de la declaración de variables. Const nos permite construir un objeto en cero coma, nos permite actualizar el objeto, pero a su vez nos permite reservar ese objeto sin posibilitar su modificación. Lo dicho un juguete que forma parte de la caja de herramientas desde que dio a luz, desde la ES2015, versión que apareció con let para evolucionar la forma ya comentada que se utilizaba con var y sus problemas de reasignación, que podían y provocaban muchos errores al reasignar valores a variables que se podían duplicar.
Veamos un ejemplo final de const, y su forma de manejar objetos y matrices y por sí solo entenderemos que tiene que estar pegado a nuestros dedos, es el vehículo que arranca este viaje, recordemos otra vez que las variables guardar valores datos que solicitaremos en operaciones, funciones, recabaremos de API o bases de datos externas, si no tuviéramos vasos, beber sería una tarea bastante más complicada y embrutecida por el uso colectivo del flujo de agua, si no tuviéramos variables donde poder individualizar nuestros valores, matrices, objetos, manejar el flujo de datos sería una tarea imposible, desbordaría por todos los sitios. A mí me gusta completar la vajilla, quiero tener los mejores vasos, quiero conocer con la mayor profundidad posible mis contenedores de datos.
Bueno que me lio, al ejemplo. Hemos dicho de ver como maneja const las matrices y los objetos.
const constmatriz = [1,2,3,4,5];
function constandmatriz(){
for(variableiteradora of constmatriz){
console.log(variableiteradora);
}
}
constandmatriz();
const constobjeto = {
firstname: 'primerclave-valor',
secondname: 'segundoclave-valor',
tercero: 'tercerclave-valor'
}
console.log(constobjeto);
console.log(constobjeto.tercero);
Si alguna definición le puedo otorgar ahora a const es versátil, ¿qué hay por encima de navaja suiza?
let variable
Definir ahora let, que os parece si lo resumimos, let es una variable que si se deja reasignar, si se deja volver a ser declarada, es una variable que funciona en ámbito de bloque, por lo tanto, solo existe en el bloque declarado. Su uso es inferior a const, y la diferencia clave con const es la usabilidad, queremos algo fijo, inmutable, que queramos utilizar en muy distintos ámbitos, usamos const, queremos algo más flexible, que nos permita su uso en ámbitos diferentes manteniendo la declaración intacta, elegiremos let. Por ejemplo, creo que es más visible utilizar una variable let como contador en un bucle while que utilizar una variable const. Un ejemplo y terminamos.
let counter = 0;
while(counter<5){
console.log('Lo veo más usable en este caso');
counter++;
}
/*
const counter = 0;
while(counter<5){
console.log('Lo veo más usable en este caso');
// counter++; // TypeError: Assignment to constant variable.
}
*/
Evidente, hemos dicho que la variable const es inmutable, que no admite la reasignación, en ningún lugar nos valdría como opción para un contador, una variable que está hecha para ser dinámica modificando sus valores. Está visto ¿no?, vale, pues como llega la hora de var, démonos un final lógico, la diferencia entre let y var están más que expuestas, ya que let es hermanastra de const y casi todos los ejemplos de la sección anterior comparaban diferencias entre el tipo de var y el de const y let, vale, pues una gran diferencia y creo que fundamental, el uso de var no está recomendado desde el 2015 que aparecen let y const, hagamos caso a las recomendaciones de uso y evitemos var excepto en código anterior al 2015 que es evidente no teníamos otra opción. Ahora, si la tenemos, utilicémosla.
var variable
Pues pasa un poco lo mismo que con let, he vaciado todo el arsenal en const y casi no queda nada para esta sección, aunque quería resaltar un traer un código que ya hemos visto, lo pego y lo analizamos un segundo como final de esta pregunta.
var variablevar = 10;
function manejarvariablevar(numberpasado){
variablevar = variablevar + numberpasado;
return variablevar;
}
console.log(manejarvariablevar(1));
console.log(variablevar);
Si vemos este script, variable global var declarada y asignada, la función que pasa un número para sumar y un retorno de la variable, tenemos una miga de pan para la función pasando como parámetro un 1 uno tenemos también una salida por consola del valor de la variable actual. Vale, nos fijamos en la forma de declarar las variables y de la expresión del retorno. Vamos a modificar unas cosillas y veremos los resultados.
var variablevar = 10;
function manejarvariablevar(numberpasado){
var variablevar = variablevar + numberpasado;
return variablevar;
}
console.log(manejarvariablevar(1));
console.log(variablevar);
Este es el funcionamiento de var, no detecta el valor numérico de la variable interna al declararla local a la función, no podemos llamarla, de esta forma retornará que el tipo no es el esperado.
function manejarvariablevar(){
if(variablevar>25){
variablevar = 500;
return variablevar;
}else{
variablevar = 0;
return variablevar;
}
}
function seguirmanejandovariablevar(numberpasado){
variablevar = variablevar + numberpasado;
return manejarvariablevar();
}
//console.log(seguirmanejandovariablevar(1));
//console.log(variablevar);
Esta situación es la que pretendía mostrar, eliminamos del ámbito global la variable var, entonces nos devuelve error de variable var no definida, y tiene toda la razón, la hemos definido en dos funciones diferentes, sí que las funciones se llaman una a la otra, pero no pueden trasladarse valores de variables declaradas locales, para poder compartir esos valores y demás elementos de las funciones llamadas, debemos utilizar la expresión this, que recordemos es una lapa, se adhiere al objeto y nos proporciona un mapeo de su interior.
function manejarvariablevar(){
if(variablevar>25){
variablevar = 500;
return variablevar;
}else{
variablevar = 0;
return variablevar;
}
}
function seguirmanejandovariablevar(numberpasado){
variablevar = numberpasado;
manejarvariablevar();
return variablevar;
}
console.log(seguirmanejandovariablevar(36));
Con este ejemplo quiero terminar esta pregunta haciendo evidente que si se puede pasar valores de función en función sin preocuparnos de nada más declaramos todas la variable global y a disfrutar, y después de 400 líneas más de código, modificamos una variable que no toca y ale ahora si, a disfrutar, encuentra la aguja, tengamos un pajar lo mejor ordenado posible por aquello de que el que guarda siempre halla y mejor aún el que organiza siempre encuentra. Organicemos nuestra variable, utilicemos la que mayor rendimiento y opciones nos ofrezcan en cada momento, pero por encima de todo sigamos las recomendaciones tanto de uso como de denominación y seamos descriptivos y específicos, lo sufriremos menos seguro.
Este ejemplo es ejemplo de lo que no hay que hacer, al contrario, en este caso y lo veníamos comentando para trasladar flujos entre funciones y no salirnos de los ámbitos locales, pero poder disponer de los objetos entre funciones u otras estructuras necesitamos utilizar la expresión this como vimos no hace mucho. Así, espero que esta pregunta nos introduzca en la base de este lenguaje, controlando donde y como depositamos los datos, encaramos mejor el futuro, nos permite conocer el flujo desde la base, la primera entrada de un usuario, los datos que han llegado de la última conexión a la API, todo eso se debe guardar y estructurar en diferentes variables, como he dicho es el coche al que subirse para avanzar en la comprensión y entendimiento de como funciona JavaScript.
function manejarvariablevar(){
if(this.variablevar>25){
this.variablevar = 500;
return this.variablevar;
}else{
this.variablevar = 0;
return this.variablevar;
}
}
function seguirmanejandovariablevar(numberpasado){
this.variablevar = numberpasado;
manejarvariablevar();
return this.variablevar;
}
console.log(seguirmanejandovariablevar(36));