Обновления и коллекции в JavaScript

Question

Я пытаюсь понять, как использовать Immutables в JavaScript/TypeScript, не тратя весь день на это. Я не совсем готов погрузиться в Immutable.js, потому что он, кажется, оставляет вас сухим и высоким, насколько это безопасно.

Итак, давайте возьмем пример, где у меня есть массив, в котором все элементы имеют тип MyType. В моем классе у меня есть метод, который ищет массив и возвращает копию соответствующего элемента, поэтому мы не редактируем оригинал. Скажите теперь, что в более позднее время мне нужно посмотреть и посмотреть, находится ли объект в массиве, но у меня есть копия, а не оригинал.

Каков стандартный метод обработки этого? Любой метод, который я могу решить, чтобы определить, есть ли у меня этот элемент, будет принимать какую-то форму цикла через коллекцию и посещать каждый элемент, а затем выполнять неуклюжее совпадение равенства, независимо от того, превращает ли это их в строки или использует третий, партийной библиотеки.

Я хотел бы использовать Immutables, но я постоянно сталкиваюсь с такими ситуациями, которые делают их очень непривлекательными. Что мне не хватает?

Answer 1

Я подозреваю, что мое решение не является «... стандартным методом обработки этого». Тем не менее, я думаю, что это по крайней мере a способ делать то, что, я думаю, вы просите.

Вы пишете, что у вас есть метод, который «... возвращает копию соответствующего элемента, поэтому мы не редактируем оригинал». Не могли бы вы изменить этот метод, чтобы вместо этого вернуть и оригинал и копию?

В качестве примера приведенная ниже стратегия предполагает извлечение как исходного элемента из массива (который впоследствии может использоваться для поиска по ссылке), так и клона (который можно манипулировать по мере необходимости, не затрагивая оригинал). По-прежнему сохраняется стоимость клонирования оригинала во время извлечения, но по крайней мере вам не нужно делать такие преобразования для каждого элемента массива, когда вы позже будете искать массив. Более того, он даже позволяет различать элементы массива, которые идентичны по значению, что было бы невозможно, если бы вы только изначально получили копию элемента. Приведенный ниже код демонстрирует это, делая каждый элемент массива идентичным по значению (но, по определению, какие объекты являются разными по ссылке).

Я не знаю, нарушает ли это другие передовые практики непреложности, например, сохраняя копии ссылок на элементы (которые, я полагаю, оставляют код открытым для будущих нарушений неизменяемости, даже если они в настоящее время не нарушаются. .. хотя вы могли бы deep-freeze оригинал, чтобы предотвратить будущие мутации). Однако это, по крайней мере, позволяет вам сохранять все технически неизменным, сохраняя при этом возможность поиска по ссылке. Таким образом, вы можете мутировать ваш клон столько, сколько хотите, но все равно всегда держитесь за связанную копию по ссылке оригинала.

const retrieveDerivative = (array, elmtNum) => { 
 
    const orig = array[elmtNum]; 
 
    const clone = JSON.parse(JSON.stringify(orig)); 
 
    return {orig, clone}; 
 
}; 
 

 
const getIndexOfElmt = (array, derivativeOfElement) => { 
 
    return array.indexOf(derivativeOfElement.orig); 
 
}; 
 

 

 
const obj1 = {a: {b: 1}}; // Object #s are irrelevant. 
 
const obj3 = {a: {b: 1}}; // Note that all objects are identical 
 
const obj5 = {a: {b: 1}}; // by value and thus can only be 
 
const obj8 = {a: {b: 1}}; // differentiated by reference. 
 

 
const myArr = [obj3, obj5, obj1, obj8]; 
 

 
const derivedFromSomeElmt = retrieveDerivative(myArr, 2); 
 

 
const indexOfSomeElmt = getIndexOfElmt(myArr, derivedFromSomeElmt); 
 

 
console.log(indexOfSomeElmt);

Answer 2

Ситуация вы описали это один, где изменчивая структура данных имеет очевидные преимущества, но если вы в противном случае выгоды от использования immutables есть более эффективные подходы.

Сохраняя его неизменным, означает, что ваш новый обновленный объект совершенно новый, который разрезает оба пути: у вас может быть новый объект, но у вас также есть доступ к исходному объекту! Вы можете сделать много опрятных вещей с этим, например. объедините свои объекты, чтобы у вас была история отмены, и можете вернуться назад, чтобы отменить изменения.

Так что не используйте некоторые хакеры для поиска в массиве. Проблема с вашим примером заключается в том, что вы создаете новый объект в неподходящее время: не нужно возвращать функцию объекта. Попросите функцию вернуть исходный объект и вызовите обновление, используя исходный объект в качестве индекса.

let myThings = [new MyType(), new MyType(), new MyType()]; 

// We update by taking the thing, and replacing with a new one. 
// I'll keep the array immutable too 
function replaceThing(oldThing, newThing) { 
    const oldIndex = myThings.indexOf(oldThing); 
    myThings = myThings.slice(); 
    myThings[oldIndex] = newThing; 
    return myThings; 
} 

// then when I want to update it 
// Keep immutable by spreading 
const redThing = myThings.find(({ red }) => red); 
if (redThing) { 
    // In this example, there is a 'clone' method 
    replaceThing(redThing, Object.assign(redThing.clone(), { 
    newProperty: 'a new value in my immutable!', 
    }); 
} 

Все, что сказал, классы делают это намного сложнее. Гораздо проще сохранить простые объекты неизменяемыми, поскольку вы можете просто распространять старый объект на новый, например. { ...redThing, newProperty: 'a new value' }. Как только вы получите объект с более чем 1 высотой, вы можете найти immutable.js гораздо более полезным, так как вы можете mergeDeep.