Nome di più chiavi, stesso valore di coppia

Question

Sto tentando di impostare un oggetto letterale in uno script JavaScript con una chiave con più nomi. riferimento allo stesso valore di oggetto vale a dire qualcosa come questi che ho già provato:

var holidays: { 
    "thanksgiving day", "thanksgiving", "t-day": { 
     someValue : "foo" 
    } 
} 

var holidays: { 
    ["thanksgiving day", "thanksgiving", "t-day"]: { 
     someValue : "foo" 
    } 
} 

C'è un modo per ottenere questo risultato?

Answer 1

Un altro approccio è quello di fare un po 'di post-elaborazione

function expand(obj) { 
    var keys = Object.keys(obj); 
    for (var i = 0; i < keys.length; ++i) { 
     var key = keys[i], 
      subkeys = key.split(/,\s?/), 
      target = obj[key]; 
     delete obj[key]; 
     subkeys.forEach(function(key) { obj[key] = target; }) 
    } 
    return obj; 
} 

var holidays = expand({ 
    "thanksgiving day, thanksgiving, t-day": { 
     someValue : "foo" 
    } 
}); 

Answer 2

Credo che si potrebbe fare qualcosa di simile:

var holidays = { 
    'thanksgiving day': { 
    foo: 'foo' 
    } 
}; 

holidays.thanksgiving = holidays['t-day'] = holidays['thanksgiving day']; 

Se vedere voi stessi facendo questo spesso o si dispone di più valori considerano questo modello:

'thanksgiving, t-day, thanks, thank, thank u'.split(',').forEach(function(key) { 
    holidays[key] = holidays['thanksgiving day']; 
}); 

Un approccio migliore sarebbe quello di elaborare i tuoi dati in anticipo invece di aggiungere duplicati.

Answer 3

JSON non offre questa funzionalità, né i valori letterali degli oggetti Javascript.

Potreste essere in grado di fare che fare con qualcosa di simile:

holidays = { 
    thanksgiving: {foo: 'foo'}, 
    groundhogDay: {foo: 'bar'}, 
    aliases: { 
     'thanksgiving day': 'thanksgiving', 
     't-day': 'thanksgiving', 
     'Bill Murrays nightmare': 'groundhogDay' 
    } 
} 

e quindi è possibile controllare

holidays[name] || holidays[holidays.aliases[name]] 

per i dati.

Non è una soluzione meravigliosa. Ma non sarebbe troppo difficile da scrivere un po 'la funzione che ha creato questa sorta di oggetto di una rappresentazione come:

[ 
    { 
     names: ['thanksgiving', 'thanksgiving day', 't-day'], 
     obj: {foo: 'foo'} 
    }, 
    { 
     names: ['groundhogDay', 'Bill Murrays nightmare'], 
     obj: {foo: 'bar'} 
    }, 
] 

se questo sarebbe più facile da mantenere.

Answer 4

Ho avuto questo problema e questo è ciò che mi si avvicinò con

function objectDive(parent, str){ 
    if(typeof str === 'object'){ 
    if(str.length){ 
     var str0 = str.shift(); 
     return objectDive(parent[str0], str); 
    }else{ 
     return parent; 
    } 
    }else{ 
    if(typeof str === 'string'){ 
     return objectDive(parent,str.split('.')); 
    } 
    } 
} 

Answer 5

Ora, questo può essere eccessivo per voi, ma qui è una funzione generica che creerà un oggetto con "chiavi multiple". Quello che effettivamente fa è avere una proprietà reale con il valore effettivo, e quindi definisce getter e setter per inoltrare le operazioni dalle chiavi virtuali alla proprietà effettiva.

function multiKey(keyGroups) { 
    let obj = {}; 
    let props = {}; 

    for (let keyGroup of keyGroups) { 
     let masterKey = keyGroup[0]; 
     let prop = { 
      configurable: true, 
      enumerable: false, 

      get() { 
       return obj[masterKey]; 
      }, 

      set(value) { 
       obj[masterKey] = value; 
      } 
     }; 

     obj[masterKey] = undefined; 
     for (let i = 1; i < keyGroup.length; ++i) { 
      if (keyGroup.hasOwnProperty(i)) { 
       props[keyGroup[i]] = prop; 
      } 
     } 
    } 

    return Object.defineProperties(obj, props); 
} 

Questo è meno impreciso quanto ci si aspetterebbe, ha fondamentalmente nessuna penalità prestazioni una volta che l'oggetto viene creato, e si comporta bene con l'enumerazione (for...in loop) e il controllo di appartenenza (in operatore). Ecco alcuni esempio di utilizzo:

let test = multiKey([ 
    ['north', 'up'], 
    ['south', 'down'], 
    ['east', 'left'], 
    ['west', 'right'] 
]); 

test.north = 42; 
test.down = 123; 

test.up; // returns 42 
test.south; // returns 123 

let count = 0; 
for (let key in test) { 
    count += 1; 
} 

count === 4; // true; only unique (un-linked) properties are looped over 

Tratto da my Gist, che si può sborsare.

Answer 6

che dovrebbe funzionare come previsto:

function getItem(_key) { 
    items = [{ 
     item: 'a', 
     keys: ['xyz','foo'] 
    },{ 
     item: 'b', 
     keys: ['xwt','bar'] 
    }]; 

    _filtered = items.filter(function(item) { 
     return item.keys.indexOf(_key) != -1 
    }).map(function(item) { 
     return item.item; 
    }); 
    return !!_filtered.length ? _filtered[0] : false; 
} 

Answer 7

//create some objects(!) you want to have aliases for..like tags 
var {learn,image,programming} = 
["learn", "image", "programming"].map(tag=>({toString:()=>tag })); 


//create arbitrary many aliases using a Map 
var alias = new Map(); 
alias.set("photo", image); 
alias.set("pic", image); 
alias.set("learning", learn); 
alias.set("coding", programming); 

//best put the original tagNames in here too.. 
//pretty easy huh? 

// returns the image object 
alias.get("pic"); 

// ;) 

Answer 8

Un'altra soluzione, se lo può permettere l'esecuzione RegExp, e ES6 Proxy:

let align = new Proxy({ 

    'start|top|left': -1, 
    'middle|center': 0, 
    'end|bottom|right': 1, 

}, { 

    get: function(target, property, receiver) { 

     for (let k in target) 
      if (new RegExp(k).test(property)) 
       return target[k] 

     return null 

    } 

}) 

align.start  // -1 
align.top  // -1 
align.left  // -1 

align.middle // 0 
align.center // 0 

align.end  // 1 
align.bottom // 1 
align.right  // 1 

vedi Documentazione:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/get

Answer 9

Stessa risposta (Proxy ES6, RegExp), ma in un più breve modo (e significativamente meno leggibile)

let align = new Proxy({ 

    'start|top|left': -1, 
    'middle|center': 0, 
    'end|bottom|right': 1, 

}, { get: (t, p) => Object.keys(t).reduce((r, v) => r !== undefined ? r : (new RegExp(v).test(p) ? t[v] : undefined), undefined) }) 

align.start  // -1 
align.top  // -1 
align.left  // -1 

align.middle // 0 
align.center // 0 

align.end  // 1 
align.bottom // 1 
align.right  // 1