Javascript: Szybko szukam wartości w obiekcie (jak możemy z właściwościami)

Question

Mam obiekt, który ma pary wartości zastępczych używanych do prostego kodowania/dekodowania (nie dla bezpieczeństwa, tylko dla wygody, zbyt skomplikowane, aby wyjaśnić to wszystko tutaj). To jest w postaci

var obj = {x: y, 
      x: y, 
      ... 
      }; 

gdzie „x” ma wartość zakodowania i „r” jest wartością dekodowane.

Dekodowanie jest proste: przechodzę przez znaki ciągu znaków i sprawdzam wartość charAt(i) w obiekcie za pomocą nawiasów: obj[ str.charAt(i) ]. (Pomijam czek, aby sprawdzić, czy potrzebujemy wersji wielkiej lub małej (wszystkie klawisze/wartości w obiekcie są małe), ale to dość proste.)

Do kodowania, oczywiście muszę szukać wartość w obiekcie, a nie właściwość. Obecnie przeglądam właściwości pętli for ... in ... i sprawdzam wartości pod kątem wartości charAt(i). Mój aktualny kod to:

var i, j, 
    output = '', 
    str = 'Hello World!', 
    obj = {'s':'d', 
      'm':'e', 
      'e':'h', 
      'x':'l', 
      'z':'o', 
      'i':'r', 
      'a':'w', 
      'o':'!', 
      '-':' '}; 
for (i = 0; i < str.length; i++) { 
    for (j in obj) { 
     if (Object.prototype.hasOwnProperty.call(obj, j) && 
      Object.prototype.propertyIsEnumerable.call(obj, j)) { 
      if (obj[j] === str.charAt(i)) { 
       output += j; 
       break; 
      } else if (obj[j].toUpperCase() === str.charAt(i)) { 
       output += j.toUpperCase(); 
       break; 
      } 
     } 
    } 
} 
alert(output); 

Jestem przekonany, że powinien istnieć skuteczniejszy sposób robienia tego. (Oczywiście posiadanie odwróconego obiektu, {y: x}, jest opcją, ale niezbyt dobrą.) Czy to najlepszy sposób, czy jest lepszy? Zasadniczo, chciałbym móc zrobić var prop = obj[value] tak jak mogę zrobić var value = obj[prop].

Answer 1

Jest bardziej wydajny pętli tylko raz wcześniej stworzyć odwrotny mapę:

var str = "Hello World!", 
    output = '', 
    map = { 
     "s":"d", "m":"e", 
     "e":"h", "x":"l", 
     "z":"o", "i":"r", 
     "a":"w", "o":"!", 
     "-":" " 
    }, 
    reverseMap = {} 

for (j in map){ 
    if (!Object.prototype.hasOwnProperty.call(map, j)) continue 
    reverseMap[map[j]] = j 
} 

output = str.replace(/./g, function(c){ 
    return reverseMap[c] || reverseMap[c.toLowerCase()].toUpperCase() 
}) 

console.log(output) 

Zamiast robić str.length * map.length, ty” Zajmę się operacjami map.length + str.length.

Answer 2

Możesz utworzyć odwróconą wersję mapowania programowo (zamiast ręcznie) i użyć go zamiast tego.

var rev = {} 
for (key in obj) 
    rev[obj[key]] = key 

Answer 3

Jeśli szukasz kluczy do tablic, sprawdź tutaj.

https://raw.github.com/kvz/phpjs/master/functions/array/array_keys.js

function array_keys (input, search_value, argStrict) { 
    var search = typeof search_value !== 'undefined', tmp_arr = [], strict = !!argStrict, include = true, key = ''; 

    if (input && typeof input === 'object' && input.change_key_case) { 
     return input.keys(search_value, argStrict); 
    } 

    for (key in input) { 
     if (input.hasOwnProperty(key)) { 
      include = true; 
      if (search) { 
       if (strict && input[key] !== search_value) include = false; 
       else if (input[key] != search_value) include = false; 
      } 
      if (include) tmp_arr[tmp_arr.length] = key; 
     } 
    } 

    return tmp_arr; 
} 

Answer 4

Odwrotną koder byłoby bardziej sensowne, ale można napisać funkcję zastąpić bez wszystkich etc.tests hasOwnProperty.

var str= 'Hello World!', 
obj={ 
    's':'d', 
    'm':'e', 
    'e':'h', 
    'x':'l', 
    'z':'o', 
    'i':'r', 
    'a':'w', 
    'o':'!', 
    '-':' ' 
} 
str= str.replace(/./g, function(w){ 
    for(var p in obj){ 
     if(obj[p]=== w) return p; 
     if(obj[p]=== w.toLowerCase()) return p.toUpperCase(); 
    }; 
    return w; 
}); 

Zwrócona wartość: (String) Emxxz-Azixso