Javascript: valor de búsqueda rápida en el objeto (como podemos con las propiedades)

Question

Tengo un objeto que tiene pares de valores de reemplazo utilizados para la codificación/decodificación simple (no por seguridad, solo por comodidad, demasiado complicado para explicarlo todo aquí) Está en la forma

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

donde 'x' es el valor cuando codifica y 'y' es el valor decodificado.

La decodificación es simple: recorro los caracteres de la cadena y busco el valor charAt(i) en el objeto mediante corchetes: obj[ str.charAt(i) ]. (Dejo fuera el cheque para ver si necesitamos una versión en mayúsculas o minúsculas (todas las claves/valores en el objeto son minúsculas), pero eso es bastante simple.)

Para codificar, por supuesto tengo que buscar el valor en el objeto, en lugar de la propiedad. Actualmente, estoy recorriendo las propiedades con un bucle for ... in ... y comprobando los valores con el valor charAt(i). Mi código actual es:

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); 

Innatamente siento que debería haber una forma más eficiente de hacerlo. (Por supuesto tener un objeto invertido, {y: x}, es una opción, pero no una buena). ¿Es esta la mejor manera, o hay una mejor? En esencia, me encantaría poder hacer var prop = obj[value] del mismo modo que puedo hacer var value = obj[prop].

Answer 1

Es más eficiente para recorrer sólo una vez antes para crear un mapa inversa:

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) 

En vez de hacer str.length * map.length, que' ll hacer map.length + str.length operaciones.

Answer 2

Puede crear una versión inversa de la asignación mediante programación (en lugar de a mano) y usarla en su lugar.

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

Answer 3

Si está buscando las teclas de matriz, marque aquí.

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

Un codificador inverso tendría más sentido, pero se puede escribir una función de reemplazar sin todos los 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; 
}); 

valor devuelto: (Cadena) Emxxz-Azixso