JavaScript Kümesi için nesne eşitliği nasıl özelleştirilir

Yeni ES 6 (Uyum) yeni Set nesnesini sunar. Set tarafından kullanılan kimlik algoritması ===operatöre benzer ve nesneleri karşılaştırmak için çok uygun değildir:

var set = new Set();
set.add({a:1});
set.add({a:1});
console.log([...set.values()]); // Array [ Object, Object ]

Derin nesne karşılaştırması yapmak için Set nesneleri için eşitlik nasıl özelleştirilir? Java gibi bir şey var mı equals(Object)?

ES6 Setnesnesinin karşılaştırma yöntemleri veya özel karşılaştırma genişletilebilirliği yoktur.

.has(), .add()Ve .delete()yöntemler sadece ilkel aynı gerçek nesne ya da aynı değerini kapalı çalışma içine fişi için bir araç ya da sadece mantığı yerine geçemez.

Sen muhtemelen bir kendi nesne elde edebileceğini Setve değiştirme .has(), .add()ve .delete()madde Set zaten mevcutsa derin nesne karşılaştırma yaptı şeyle yöntemleri ilk bulmaya, ancak altta yatan beri performans olasılıkla iyi olmaz Setnesne yardımcı olmaz hiç. Muhtemelen orijinali çağırmadan önce kendi özel karşılaştırmanızı kullanarak bir eşleşme bulmak için mevcut tüm nesneler boyunca kaba bir kuvvet yinelemesi yapmanız gerekir .add().

Bu makaleden bazı bilgiler ve ES6 özelliklerinin tartışılması :

5.2 Haritaların ve kümelerin anahtarları ve değerleri karşılaştırma şeklini neden yapılandıramıyorum?

Soru: Hangi harita anahtarlarını ve hangi set öğelerinin eşit kabul edileceğini yapılandırmanın bir yolu olsaydı iyi olurdu. Neden yok?

Yanıt: Düzgün ve verimli bir şekilde uygulanması zor olduğu için bu özellik ertelendi. Seçeneklerden biri, eşitliği belirleyen koleksiyonlara geri arama yapmaktır.

Java'da kullanılabilen başka bir seçenek de nesnenin uyguladığı bir yöntemle eşitliği belirtmektir (Java'da () eşittir). Ancak, bu yaklaşım değiştirilebilir nesneler için sorunludur: Genel olarak, bir nesne değişirse, koleksiyon içindeki “konumu” da değişmelidir. Ama Java'da olan bu değil. JavaScript büyük olasılıkla yalnızca özel sabit nesneler (değer nesneleri olarak adlandırılan) için değere göre karşılaştırmayı etkinleştirmek için daha güvenli bir yol izleyecektir. Değere göre karşılaştırma, içerikleri eşitse iki değerin eşit kabul edildiği anlamına gelir. İlkel değerler JavaScript'teki değerle karşılaştırılır.

Jfriend00'ün cevabında belirtildiği gibi , eşitlik ilişkisinin özelleştirilmesi muhtemelen mümkün değildir .

Aşağıdaki kod, hesaplama açısından verimli (ancak bellek açısından pahalı) bir geçici çözümün ana hatlarını sunar :

class GeneralSet {

    constructor() {
        this.map = new Map();
        this[Symbol.iterator] = this.values;
    }

    add(item) {
        this.map.set(item.toIdString(), item);
    }

    values() {
        return this.map.values();
    }

    delete(item) {
        return this.map.delete(item.toIdString());
    }

    // ...
}

Eklenen her öğenin toIdString()dize döndüren yöntemi uygulaması gerekir . İki nesne, yalnızca toIdStringyöntemleri aynı değeri döndürürse eşit kabul edilir .

En iyi yanıttan bahsedildiği gibi, eşitliği özelleştirmek değişebilir nesneler için sorunludur. İyi haber şu ki (ve henüz kimsenin bundan bahsetmediğine şaşırdım) , aradığınız derin değer eşitliği anlambilimini sağlayan zengin bir dizi değişmez tür sağlayan immutable-js adlı çok popüler bir kütüphane var .

İmmutable-js kullanarak örnek :

const { Map, Set } = require('immutable');
var set = new Set();
set = set.add(Map({a:1}));
set = set.add(Map({a:1}));
console.log([...set.values()]); // [Map {"a" => 1}]

Buradaki yanıtlara eklemek için, devam ettim ve özel bir karma işlevi, özel bir eşitlik işlevi alan ve eşdeğer (özel) karmaları olan farklı değerleri kovalarda saklayan bir Harita sarmalayıcısı uyguladım.

Tahmin edileceği gibi, czerny'nin string birleştirme yönteminden daha yavaş olduğu ortaya çıktı .

Tam kaynak burada: https://github.com/makoConstruct/ValueMap

Bunları doğrudan karşılaştırmak mümkün görünmüyor, ancak JSON.stringify anahtarlar sadece sıralanmışsa çalışır. Bir yorumda belirttiğim gibi

JSON.stringify ({a: 1, b: 2})! == JSON.stringify ({b: 2, a: 1});

Ancak özel bir stringify yöntemiyle bu sorunu çözebiliriz. İlk önce yöntemi yazıyoruz

Özel Stringify

Object.prototype.stringifySorted = function(){
    let oldObj = this;
    let obj = (oldObj.length || oldObj.length === 0) ? [] : {};
    for (let key of Object.keys(this).sort((a, b) => a.localeCompare(b))) {
        let type = typeof (oldObj[key])
        if (type === 'object') {
            obj[key] = oldObj[key].stringifySorted();
        } else {
            obj[key] = oldObj[key];
        }
    }
    return JSON.stringify(obj);
}

Set

Şimdi bir Set kullanıyoruz. Ama nesneler yerine bir dizi dizgi kullanıyoruz

let set = new Set()
set.add({a:1, b:2}.stringifySorted());

set.has({b:2, a:1}.stringifySorted());
// returns true

Tüm değerleri alın

Kümeyi oluşturduktan ve değerleri ekledikten sonra, tüm değerleri

let iterator = set.values();
let done = false;
while (!done) {
  let val = iterator.next();

  if (!done) {
    console.log(val.value);
  }
  done = val.done;
}

İşte hepsi bir dosyada bir bağlantı http://tpcg.io/FnJg2i

Belki JSON.stringify()derin nesne karşılaştırması yapmak için kullanmayı deneyebilirsiniz .

Örneğin :

const arr = [
  {name:'a', value:10},
  {name:'a', value:20},
  {name:'a', value:20},
  {name:'b', value:30},
  {name:'b', value:40},
  {name:'b', value:40}
];

const names = new Set();
const result = arr.filter(item => !names.has(JSON.stringify(item)) ? names.add(JSON.stringify(item)) : false);

console.log(result);

Typescript kullanıcıları için, başkalarının cevapları (özellikle czerny ) güzel tipte güvenli ve tekrar kullanılabilir bir temel sınıfa genelleştirilebilir:

/**
 * Map that stringifies the key objects in order to leverage
 * the javascript native Map and preserve key uniqueness.
 */
abstract class StringifyingMap<K, V> {
    private map = new Map<string, V>();
    private keyMap = new Map<string, K>();

    has(key: K): boolean {
        let keyString = this.stringifyKey(key);
        return this.map.has(keyString);
    }
    get(key: K): V {
        let keyString = this.stringifyKey(key);
        return this.map.get(keyString);
    }
    set(key: K, value: V): StringifyingMap<K, V> {
        let keyString = this.stringifyKey(key);
        this.map.set(keyString, value);
        this.keyMap.set(keyString, key);
        return this;
    }

    /**
     * Puts new key/value if key is absent.
     * @param key key
     * @param defaultValue default value factory
     */
    putIfAbsent(key: K, defaultValue: () => V): boolean {
        if (!this.has(key)) {
            let value = defaultValue();
            this.set(key, value);
            return true;
        }
        return false;
    }

    keys(): IterableIterator<K> {
        return this.keyMap.values();
    }

    keyList(): K[] {
        return [...this.keys()];
    }

    delete(key: K): boolean {
        let keyString = this.stringifyKey(key);
        let flag = this.map.delete(keyString);
        this.keyMap.delete(keyString);
        return flag;
    }

    clear(): void {
        this.map.clear();
        this.keyMap.clear();
    }

    size(): number {
        return this.map.size;
    }

    /**
     * Turns the `key` object to a primitive `string` for the underlying `Map`
     * @param key key to be stringified
     */
    protected abstract stringifyKey(key: K): string;
}

Örnek uygulama bu kadar basittir: sadece stringifyKeyyöntemi geçersiz kılın . Benim durumumda bazı uriözellikleri dize .

class MyMap extends StringifyingMap<MyKey, MyValue> {
    protected stringifyKey(key: MyKey): string {
        return key.uri.toString();
    }
}

Örnek kullanım o zaman bu normal bir durumdur Map<K, V>.

const key1 = new MyKey(1);
const value1 = new MyValue(1);
const value2 = new MyValue(2);

const myMap = new MyMap();
myMap.set(key1, value1);
myMap.set(key1, value2); // native Map would put another key/value pair

myMap.size(); // returns 1, not 2

Her iki kümenin birleşiminden yeni bir küme oluşturun, ardından uzunluğu karşılaştırın.

let set1 = new Set([1, 2, 'a', 'b'])
let set2 = new Set([1, 'a', 'a', 2, 'b'])
let set4 = new Set([1, 2, 'a'])

function areSetsEqual(set1, set2) {
  const set3 = new Set([...set1], [...set2])
  return set3.size === set1.size && set3.size === set2.size
}

console.log('set1 equals set2 =', areSetsEqual(set1, set2))
console.log('set1 equals set4 =', areSetsEqual(set1, set4))

set1 eşittir set2 = true

set1 eşittir set4 = yanlış

Bu soruyu Google'da (benim gibi) Anahtar olarak bir nesne kullanarak bir Harita değeri almak isteyen birine:

Uyarı: bu cevap tüm nesnelerle çalışmaz

var map = new Map<string,string>();

map.set(JSON.stringify({"A":2} /*string of object as key*/), "Worked");

console.log(map.get(JSON.stringify({"A":2}))||"Not worked");

Çıktı:

işlenmiş