A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Estado compartido o shared state

11/23
Recursos

Shared State significa que diferentes m茅todos trabajan a partir de una misma variable. y, as铆 como aprendimos en clases anteriores, cuando modificamos variables con el mismo objeto de referencia podemos encontrarnos con algunos problemas y obtener resultados inesperados a pesar de ejecutar el mismo c贸digo y recibir los mismos par谩metros:

// Intento #1
const a = {
        value: 2
}

const addOne = () => a.value += 1
const timesTwo = () => a.value *= 2

addOne()
timesTwo()

console.log(a.value) // 6

// Sin embargo, si ejecutamos las mismas funciones en orden invertido
// obtenemos resultados diferentes

timesTwo()
addOne()

console.log(a.value) // 5 !??

Para resolver este tipo de problemas debemos utilizar la programaci贸n funcional, en vez de modificar la variable original, nuestras funciones deben copiar y modificar sus argumentos:

const b = {
        value: 2
}

const addOne = x => Object.assign({}, x, { value: x.value + 1 })
const timesTwo = x => Object.assign({}, x, { value: x.value * 2 })

addOne(b)
timesTwo(b)

// El resultado siempre es el mismo a pesar de
// ejecutar las funciones en orden diferente

timesTwo(b)
addOne(b)

console.log(b.value)

Aportes 11

Preguntas 3

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

console.log(addOne(timesTwo(b))) // imprime 5

debido a que se ejecuta promero timesTwo() va ejeceutando de adentro hacia afuera de los par茅ntesis

Que diferencia hay entre el Object.assign y el spread syntax(鈥) para crear copias de los objetos?

//The problem of shared state.
//it becomes apparently pure function in impure  function, because are actually mutable functions (modified the original property), for that reason in long term that kind of function are not predictable.


//==================================Bad==================================
const myObject = {
  value: 2
}

const addOne = () => myObject.value += 1 ;
const twoTimes = () => myObject.value *= 2;

// I know the value is 2, in order to obtain 3 I add one.
addOne();//3
// I know the value is 2, so in order to obtain 4 i multiply by 2.
twoTimes();//6, i don't excepted it, and it actually add one, there is a side effect
console.log(myObject.value);
//returns: 6

// I know the value is 2, so in order to obtain 4 i multiply by 2.
twoTimes();//4
// I know the value is 2, in order to obtain 3 I add one.
addOne();//5, i don't excepted it, and it actually add one, there is a side effect
console.log(myObject.value);
//returns: 5

//the problem is that its not a real control about the original value, someone can modify it and get a side effect in the code.
//驴How i can prevent side effects in this case? Using copies.

//==================================Good==================================

const myObject2 = {
  value: 2
}

const addOne_good = (originalObj) => Object.assign({}, {value: originalObj.value + 1});
const twoTimes_good = (originalObj) => Object.assign({}, {value: originalObj.value * 2});

// I know the value is 2, so in order to obtain 4 i multiply by 2.
addOne_good(myObject2);//4
// I know the value is 2, in order to obtain 3 I add one.
twoTimes_good(myObject2);//3
console.log(myObject2.value);
//returns: 2, the original value.

// I know the value is 2, i want 6
let = result = twoTimes_good(addOne_good(myObject2));
console.log(result.value);// 6

Creo que la forma correcta de usar el assign en este contexto seria asi:

const addOne = x => Object.assign( {}, {value: x.value + 1 })
const timesTwo = x => Object.assign( {}, {value: x.value * 2 })

Pr谩cticamente lo que hac铆an las primeras funciones que creamos era mutar directamente la variable global (Pod铆an ser accedidas gracias a su scope), de la segunda forma lo que se hizo fue simplemente hacer que esa variable no se mutara globalmente, sino que la funci贸n crea su propia variable y retorna el resultado ^^

os datos deben ser inmutables para evitar shared state, side effects, impure functions鈥 Todo lo que hagamos ser谩 sobre copias y no sobre los datos compartidos con m谩s partes de la aplicaci贸n.

Mas informacion en este enlace Shared state

Estos temas son muy interesantes.

Muy interesante la duplicaci贸n de objetos

Me qued茅 un rato con el video pausado analizando porque estaba seguro que el resultado era 5 y no 6 馃槃 al final si era as铆.

Nota: Al igual que los objectos, los Arreglos tambi茅n se pasan por referencia.