Básicamente, estoy tratando de crear un objeto de objetos únicos, un conjunto. Tuve la brillante idea de utilizar un objeto JavaScript con los objetos de la propiedad de los nombres. Tales como,

set[obj] = true;

Esto funciona, hasta cierto punto. Funciona muy bien con cadena y los números, pero con otros objetos, todos ellos parecen «hash» para el mismo valor y el mismo acceso a la propiedad. ¿Hay algún tipo de forma en que me puede generar un hash único valor para un objeto? Cómo hacer cadenas y números de hacerlo, ¿se puede anular el mismo comportamiento?

  • La razón de que los objetos de todos los ‘hash’ para el mismo valor es porque no se han anulado sus métodos toString. Desde claves son necesarias para ser cadenas, el método toString es llamado automáticamente para obtener una clave válida para todos los objetos que se están convirtiendo a la misma cadena por defecto: «[object object]».
  • JSON.stringify(obj) o obj.toSource() pueden trabajar para usted, dependiendo del problema y de la plataforma de destino.
  • JSON.stringify(obj), literalmente, sólo se convierte todo objeto en una cadena. Así que sería básicamente, sólo tiene que copiar el objeto en sí mismo. Esto es inútil, una pérdida de espacio y no es óptimo.
  • Verdadero, por lo que depende de cual sea tu problema. Cuando me enteré de esta cuestión a través de google mi solución final estaba llamando toSource() de los objetos. Otro método sería utilizar un convencionales hash en la fuente.
  • toSource no funciona en Chrome btw
InformationsquelleAutor Boog | 2008-10-11

19 Comentarios

  1. 32

    JavaScript los objetos sólo pueden utilizar cadenas de caracteres de las teclas (otra cosa es convertido a una cadena).

    Puede, alternativamente, mantener una matriz que los índices de los objetos en cuestión, y el uso de su índice de cadena como una referencia al objeto. Algo como esto:

    var ObjectReference = [];
    ObjectReference.push(obj);
    
    set['ObjectReference.' + ObjectReference.indexOf(obj)] = true;

    Obviamente es un poco detallado, pero podría escribir un par de métodos que manejar y obtener y establecer todos queramos o no.

    Edición:

    Su conjetura es un hecho — esto se define el comportamiento en JavaScript, específicamente un método toString se produce la conversión de significado que puede definir su propia función toString del objeto que va a ser utilizado como el nombre de la propiedad. – olliej

    Esto trae otro punto interesante; se puede definir un método toString en los objetos que desea hash, y que puede formar su hash identificador.

    • otra opción sería la de dar a cada objeto un valor aleatorio como es de hash – tal vez un número aleatorio + total de garrapatas – a continuación, tienen un conjunto de funciones para agregar/quitar el objeto de la matriz.
    • Esto se producirá si se agrega el mismo objeto dos veces. Se cree que es diferente.
    • «Esto se producirá si se agrega el mismo objeto dos veces. Se cree que es diferente.» Buen punto. Una solución podría ser subclase de Array para ObjectReference, enganchando un duplicado de verificación en push(). No tengo tiempo para editar esta solución ahora, pero espero que me recuerde más tarde.
    • Me gusta esta solución, ya que no necesita de propiedades en el objeto. Pero se trata de conseguir problemática, si intenta tener una limpia recolector de basura. En su enfoque va a guardar el objeto, aunque otras referencias ya estaban eliminados. Esto puede conducir a problemas en las grandes aplicaciones.
    • ¿Por qué es el aceptado la respuesta? Es el mal de muchas maneras.
    • ¿Cuál es el punto de la mezcla de los objetos, si cada vez que se refieren a ellos se necesita una exploración lineal de una matriz?

  2. 52

    Si quieres un hashCode() la función de Java en JavaScript, que es la suya:

    String.prototype.hashCode = function(){
        var hash = 0;
        for (var i = 0; i < this.length; i++) {
            var character = this.charCodeAt(i);
            hash = ((hash<<5)-hash)+character;
            hash = hash & hash; //Convert to 32bit integer
        }
        return hash;
    }

    Que es la forma de implementación en Java (operador bit a bit).

    • esto crea -hash, no perfecta
    • ¿Qué hay de malo con los números negativos?
    • es palabra reservada en JS y podría causar algunos problemas. Algún otro nombre sería mejor.
    • los valores hash son generalmente positivas
    • dice que? Es la primera vez que oí hablar de tal afirmación. Puede vincular algunos de origen? Hash se calcula normalmente el uso de tamaño fijo aritmética de enteros y las operaciones con bit, por lo que conseguir resultados positivos o negativos es algo que se espera.
    • Exigente, pero… «si (a esto.longitud == 0) return hash;» es redundante 🙂 Y cambiar personalmente «carácter» a «código».
    • y @szeryf: usted sólo tiene que tener cuidado de cómo usarlo. Por ejemplo, he tratado de hacer pickOne["helloo".hashCode() % 20] para una matriz pickOne con 20 elementos. Tengo undefined debido a que el código hash es negativo, por lo que este es un ejemplo en el que alguien (yo) supone implícitamente positivo códigos hash.

  3. 31

    La manera más fácil de hacer esto es dar a cada uno de los objetos de su propia y única toString método:

    (function() {
        var id = 0;
    
        /*global MyObject */
        MyObject = function() {
            this.objectId = '<#MyObject:' + (id++) + '>';
            this.toString= function() {
                return this.objectId;
            };
        };
    })();

    Yo tenía el mismo problema y se solucionó a la perfección para mí, con un mínimo de alboroto, y era mucho más fácil que volver a la implementación de algunas grasos Java estilo Hashtable y la adición de equals() y hashCode() a sus clases de objetos. Sólo asegúrese de que usted no también palo de una cadena de texto ‘<#MyObject:12> en su hash o borrar la entrada para salir de su objeto con el id.

    Ahora todos mis hashes son totalmente frío. También he publicado una entrada en el blog hace unos días,este mismo tema.

    • Pero este pierde el punto. Java ha equals() y hashCode() para que dos objetos equivalentes tienen el mismo valor de hash. Utilizando el método anterior significa que cada instancia de MyObject tendrá una única cadena, lo que significa que usted tendrá que mantener una referencia a ese objeto a la vez recuperar el valor correcto del mapa. Una clave es no tiene sentido, porque no tiene nada que ver con la singularidad de un objeto. Un útil toString() función tendrá que ser aplicada para el tipo específico de objeto que se utiliza como una clave.
    • puede implementar la toString para los objetos que se asigna directamente a una relación de equivalencia, de forma que dos objetos de crear la misma cadena iff son considerados «iguales».
    • A la derecha, y que es el sólo la forma correcta de utilizar toString() para permitir el uso de un Object como un Set. Creo que no he entendido tu respuesta como tratando de ofrecer una solución genérica para evitar la escritura de un toString() equivalente de equals() o hashCode() en una base de caso por caso.
    • Dowvoted. Esto no es lo que un código hash es, ver a mis respuestas a: stackoverflow.com/a/14953738/524126 Y una verdadera aplicación de una etiqueta: stackoverflow.com/a/15868654/524126
    • la pregunta no estaba preguntando acerca de una «verdadera» hashcode, sino más bien de cómo utilizar correctamente un objeto como un conjunto en JavaScript.
    • X Moore Y hacer que para los objetos que necesita para generar un código hash, 2 objetos (de referencia) con el mismo estado interno no debe estar en el conjunto, y esto es lo que un hash de los guardias contra. Normalmente esto se puede lograr simplemente con un UUID.
    • Y qué si los objetos son elementos DOM? Entonces usted tiene que reemplazar un montón de cosas que preferiría no reemplazar…

  4. 18

    La solución elegí es similar a la de Daniel, pero en lugar de utilizar un objeto de la fábrica y reemplazar el método toString, puedo agregar explícitamente el hash del objeto cuando se solicita por primera vez a través de un getHashCode función. Un poco desordenado, pero mejor para mis necesidades 🙂

    Function.prototype.getHashCode = (function(id) {
        return function() {
            if (!this.hashCode) {
                this.hashCode = '<hash|#' + (id++) + '>';
            }
            return this.hashCode;
        }
    }(0));
    • Dowvoted. Véase mi respuesta a Daniel: stackoverflow.com/a/885944/524126
    • Si quieres ir de esta manera, es mucho mejor para el conjunto de la etiqueta a través de Object.defineProperty con enumerable conjunto para false, por lo que no se cuelgue cualquier for .. in bucles.
  5. 18

    Lo que usted describe es cubierto por la Armonía WeakMaps, parte de la ECMAScript 6 especificación (en la próxima versión de JavaScript). Que es: un conjunto donde las claves puede ser cualquier cosa (incluyendo indefinido) y no es enumerable.

    Esto significa que es imposible obtener una referencia a un valor a menos que usted tenga una referencia directa a la clave (cualquier objeto!) que los links. Es importante para un montón de implementación del motor de razones relacionadas con la eficiencia y la recolección de basura, pero también es super cool en cuanto a que permite la nueva semántica como anularse los permisos de acceso y la transferencia de datos sin necesidad de exponer los datos del remitente.

    De MDN:

    var wm1 = new WeakMap(),
        wm2 = new WeakMap();
    var o1 = {},
        o2 = function(){},
        o3 = window;
    
    wm1.set(o1, 37);
    wm1.set(o2, "azerty");
    wm2.set(o1, o2); //A value can be anything, including an object or a function.
    wm2.set(o3, undefined);
    wm2.set(wm1, wm2); //Keys and values can be any objects. Even WeakMaps!
    
    wm1.get(o2); //"azerty"
    wm2.get(o2); //Undefined, because there is no value for o2 on wm2.
    wm2.get(o3); //Undefined, because that is the set value.
    
    wm1.has(o2); //True
    wm2.has(o2); //False
    wm2.has(o3); //True (even if the value itself is 'undefined').
    
    wm1.has(o1);   //True
    wm1.delete(o1);
    wm1.has(o1);   //False

    WeakMaps están disponibles en el actual Firefox, Chrome y Borde. También son admitidos en el Nodo v7 , y en v6 con el --harmony-weak-maps bandera.

    • ¿Cuál es la diferencia entre estos y Map?
    • WeakMap tiene limitaciones: 1) Toma sólo los objetos como llaves 2) No tamaño de la propiedad 3) No iterador o método forEach 4) No hay un método claro. La clave es objeto, de modo que cuando el objeto se elimina de la memoria de datos de WeakMap conectado con este objeto será eliminado también. Es muy útil cuando se quiere mantener la información, que debería existir solo mientras que el objeto existe. Así WeakMap sólo tiene métodos: establecer, eliminar para escribir y recibir, tiene para leer
    • Esto no es exactamente funciona correctamente… var m = new Map();m.set({},"abc"); console.log(m.get({}) //=>undefined sólo funciona si tienen la misma variable que originalmente se hace referencia en el comando set. E. G. var m = new Map();a={};m.set(a,"abc"); console.log(m.get(a) //=>undefined
  6. 13

    Para mi situación específica sólo me importa acerca de la igualdad de los objetos tan lejos como claves y valores primitivos ir. La solución que funcionó para mí fue convertir el objeto a su representación en JSON y usar eso como el hash. Hay algunas limitaciones, tales como el orden de definición de clave que potencialmente podrían ser inconsistentes; pero como he dicho, que trabajó para mí porque estos objetos fueron todos los que se generan en un solo lugar.

    var hashtable = {};
    
    var myObject = {a:0,b:1,c:2};
    
    var hash = JSON.stringify(myObject);
    //'{"a":0,"b":1,"c":2}'
    
    hashtable[hash] = myObject;
    //{
    //  '{"a":0,"b":1,"c":2}': myObject
    //}
  7. 8

    El JavaScript de la especificación define la propiedad indexado de acceso como la realización de un método toString de la conversión en el nombre de índice. Por ejemplo,

    myObject[myProperty] = ...;

    es el mismo que

    myObject[myProperty.toString()] = ...;

    Esto es necesario ya que en JavaScript

    myObject["someProperty"]

    es el mismo que

    myObject.someProperty

    Y sí, me pone triste, así 🙁

  8. 8

    Puse un pequeño JavaScript módulo hace un tiempo para producir hashcodes para las cadenas, objetos, arrays, etc. (Me acaba de comprometer a GitHub 🙂 )

    Uso:

    Hashcode.value("stackoverflow")
    //-2559914341
    Hashcode.value({ 'site' : "stackoverflow" })
    //-3579752159
    • Que está muy bien, pero se ahoga en las referencias circulares
    • No javascript GC de ahogar las referencias circulares demasiado?
    • Tiempo yo podría ir tan lejos como decir si tiene referencias circulares, entonces usted necesita para refactorizar el código 😉
    • Elementos del DOM tiene referencias circulares hasta el wazoo…
    • usted necesita para refactorizar el código» estás bromeando? Cada elemento de DOM padre y el hijo par que constituye una referencia circular.
    • Se hace un trabajo pobre de hash objetos que tienen propiedades numéricas, de devolver el mismo valor en muchos de los casos, es decir, var hash1 = Hashcode.value({ a: 1, b: 2 }); var hash2 = Hashcode.value({ a: 2, b: 1 }); console.log(hash1, hash2); de registro de 2867874173 2867874173

  9. 4

    Referencia: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol

    puede utilizar Es6 símbolo para crear la clave única de acceso y objeto.
    Cada símbolo de valor devuelto de Símbolo() es único. Un símbolo de valor puede ser utilizado como un identificador para las propiedades del objeto; este es el tipo de datos único propósito.

    var obj = {};
    
    obj[Symbol('a')] = 'a';
    obj[Symbol.for('b')] = 'b';
    obj['c'] = 'c';
    obj.d = 'd';
  10. 2

    Aquí está mi solución simple que devuelve un número entero único.

    function hashcode(obj) {
        var hc = 0;
        var chars = JSON.stringify(obj).replace(/\{|\"|\}|\:|,/g, '');
        var len = chars.length;
        for (var i = 0; i < len; i++) {
            //Bump 7 to larger prime number to increase uniqueness
            hc += (chars.charCodeAt(i) * 7);
        }
        return hc;
    }
    • La complejidad de esta situación socava la idea detrás de hashCode()
    • No me parece que esto unecessarily complejo. Era curioso, sin embargo: ¿por qué el reemplazo de la fase? Las exclusiones que de lo contrario habría devuelto bien en charCodeAt, ¿no?
  11. 1

    Mi solución introduce una función estática para el mundial de Object objeto.

    (function() {
        var lastStorageId = 0;
    
        this.Object.hash = function(object) {
            var hash = object.__id;
    
            if (!hash)
                 hash = object.__id = lastStorageId++;
    
            return '#' + hash;
        };
    }());

    Creo que esto es más conveniente con otro objeto de la manipulación de funciones en JavaScript.

    • Los objetos con la misma interno de valores hash para diferentes hashes, esto no es lo que un hash(código) que se hace.
    • En JavaScript (y creo que en casi todos los otros idiomas también) dos objetos creados con los mismos valores internos siguen siendo diferentes objetos, debido a que la inferior es de tipo de datos representados por una nueva instancia del objeto de cada uno. jsfiddle.net/h4G9f
    • Sí, pero eso no es lo que un código hash es para, hashcodes se utilizan para la comprobación de la igualdad de los objetos de estado. Como un hash, mismas entradas en (los valores de la variable) de un mismo hash que sale. Lo que usted está buscando es un UUID (que es lo que es su función).
    • Estás en lo correcto. Yo missunderstand la pregunta. Realmente malo, que la aceptó respuesta no proporciona una buena solución.
    • Tomando su función así, yo estaría inclinado a lo más como este: jsfiddle.net/xVSsd el Mismo resultado, más corto (LoC + caracteres), y, probablemente, un diminuto y pequeño poco más rápido 🙂
    • Siéntase libre de cambiar el código en mi respuesta en consecuencia.

  12. 0

    Si usted realmente desea configurar el comportamiento (yo voy por Java conocimiento), entonces usted va a ser difícil encontrar una solución en JavaScript. La mayoría de los desarrolladores se recomienda una clave única para representar cada objeto, pero esto es a diferencia de conjunto, en el que se puede obtener de dos objetos idénticos, cada uno con una clave única. La API de Java hace el trabajo de la comprobación de valores duplicados mediante la comparación de código hash de valores, no de las teclas, y ya que no hay valor de código hash de la representación de los objetos en JavaScript, es casi imposible hacer lo mismo. Incluso el Prototipo JS biblioteca admite esta deficiencia, cuando dice:

    «Hash puede ser considerado como una
    matriz asociativa, la unión de claves únicas
    a los valores (que no son necesariamente
    la única)…»

    http://www.prototypejs.org/api/hash

  13. 0

    Además eyelidlessness la respuesta, aquí es una función que devuelve un reproducible, IDENTIFICADOR único para cualquier objeto:

    var uniqueIdList = [];
    function getConstantUniqueIdFor(element) {
        //HACK, using a list results in O(n), but how do we hash e.g. a DOM node?
        if (uniqueIdList.indexOf(element) < 0) {
            uniqueIdList.push(element);
        }
        return uniqueIdList.indexOf(element);
    }

    Como usted puede ver, se utiliza una lista para ver cual es muy ineficiente, sin embargo, que el mejor que pude encontrar por ahora.

  14. 0

    Si desea utilizar los objetos como las claves que necesita para sustituir su Método toString, como algunos ya se ha mencionado aquí. Las funciones de hash que se utilizaron están todos muy bien, pero sólo trabajan para los mismos objetos, no por la igualdad de los objetos.

    He escrito una pequeña biblioteca que crea hashes de los objetos, que se puede utilizar para este propósito. Los objetos pueden incluso tener un orden diferente, el hash será el mismo. Internamente, se pueden utilizar distintos tipos de hash (djb2, md5, sha1, sha256, sha512, ripemd160).

    He aquí un pequeño ejemplo de la documentación:

    var hash = require('es-hash');
    
    //Save data in an object with an object as a key
    Object.prototype.toString = function () {
        return '[object Object #'+hash(this)+']';
    }
    
    var foo = {};
    
    foo[{bar: 'foo'}] = 'foo';
    
    /*
     * Output:
     *  foo
     *  undefined
     */
    console.log(foo[{bar: 'foo'}]);
    console.log(foo[{}]);

    El paquete puede ser usado ya sea en el navegador y en Node-Js.

    Repositorio: https://bitbucket.org/tehrengruber/es-js-hash

  15. 0

    Si quieres tener valores únicos en una búsqueda de objetos se puede hacer algo como esto:

    Creación de una búsqueda de objeto

    var lookup = {};

    La configuración de la etiqueta de la función

    function getHashCode(obj) {
        var hashCode = '';
        if (typeof obj !== 'object')
            return hashCode + obj;
        for (var prop in obj) //No hasOwnProperty needed
            hashCode += prop + getHashCode(obj[prop]); //Add key + value to the result string
        return hashCode;
    }

    Objeto

    var key = getHashCode({ 1: 3, 3: 7 });
    //key = '1337'
    lookup[key] = true;

    Matriz

    var key = getHashCode([1, 3, 3, 7]);
    //key = '01132337'
    lookup[key] = true;

    Otros tipos

    var key = getHashCode('StackOverflow');
    //key = 'StackOverflow'
    lookup[key] = true;

    Resultado Final

    { 1337: true, 01132337: true, StackOverflow: true }

    Tenga en cuenta que getHashCode no devolverá ningún valor cuando el objeto o matriz está vacío

    getHashCode([{},{},{}]);
    //'012'
    getHashCode([[],[],[]]);
    //'012'

    Esto es similar a @ijmacd solución sólo getHashCode no tiene la JSON dependencia.

    • Tienes que tener un problema con las referencias circulares con que
    • Gracias por dejarme saber. Usted podría fácilmente ampliar este código con sus necesidades, pero espero que la idea es algo claro 🙂
    • Esto producirá claves muy largas para objetos de gran tamaño que podría afectar la memoria y el rendimiento bastante duro
  16. 0

    Voy a tratar de ir un poco más profundo que el de otras respuestas.

    Incluso si JS había mejor hash apoyo no por arte de magia hash todo a la perfección, en muchos casos, usted tendrá que definir su propia función hash. Por ejemplo Java tiene un buen hash apoyo, pero usted todavía tiene que pensar y hacer algo de trabajo.

    Uno de los problemas es el término hash/hashcode … hay criptográficos hash y no criptográficos hash. El otro problema, es que tienen que entender por qué hashing es útil y cómo funciona.

    Cuando hablamos de hash en JavaScript o Java la mayoría del tiempo estamos hablando no criptográficos hash, por lo general alrededor de hash para hashmap/hashtable (a menos que estemos trabajando en la autenticación de claves o contraseñas, que usted podría hacer en el lado del servidor utilizando NodeJS …).

    Depende de lo que los datos que tienes y lo que quieres lograr.

    Sus datos tiene algunas natural «simple» singularidad:

    • El hash de un entero es … el entero, ya que es único, que suerte!!!
    • El hash de una cadena … depende de la cadena, si la cadena de caracteres que representa un identificador único, se puede considerar como un hash (por lo que no hashing es necesario).
    • Nada que indirectamente es prácticamente un número entero que es el caso más simple
    • Esto respecto: hashcode igual si los objetos son iguales

    Sus datos tiene algunas natural «compuesta» de la singularidad:

    • Por ejemplo con un objeto de la persona, se puede calcular un hash mediante nombre, apellidos, fecha de nacimiento, … ver cómo se hace el Java es: Buena Función Hash para las Cadenas, o utilizar algún otro ID de información que es barato y suficientemente especial para su caso de uso

    Usted no tiene idea de lo que sus datos serán:

    • Buena suerte … usted puede serializar a la cadena y hash Java estilo, pero eso puede ser costoso si la cadena es grande y no va a evitar colisiones, así como dicen que el hash de un entero (auto).

    No es por arte de magia eficiente hash técnica para datos desconocidos, en algunos casos es muy fácil, en otros casos puede que tenga que pensar dos veces. Así que incluso si JavaScript/ECMAScript añade más apoyo, no hay magia idioma solución para este problema.

    En la práctica, se necesitan dos cosas: suficiente singularidad, la velocidad suficiente

    Además de que es bueno tener: «hashcode igual si los objetos son iguales»

  17. 0

    He combinado las respuestas de eyelidlessness y KimKha.

    El siguiente es un angularjs servicio, y apoya a los números, cadenas y objetos.

    exports.Hash = () => {
    let hashFunc;
    function stringHash(string, noType) {
    let hashString = string;
    if (!noType) {
    hashString = `string${string}`;
    }
    var hash = 0;
    for (var i = 0; i < hashString.length; i++) {
    var character = hashString.charCodeAt(i);
    hash = ((hash<<5)-hash)+character;
    hash = hash & hash; //Convert to 32bit integer
    }
    return hash;
    }
    function objectHash(obj, exclude) {
    if (exclude.indexOf(obj) > -1) {
    return undefined;
    }
    let hash = '';
    const keys = Object.keys(obj).sort();
    for (let index = 0; index < keys.length; index += 1) {
    const key = keys[index];
    const keyHash = hashFunc(key);
    const attrHash = hashFunc(obj[key], exclude);
    exclude.push(obj[key]);
    hash += stringHash(`object${keyHash}${attrHash}`, true);
    }
    return stringHash(hash, true);
    }
    function Hash(unkType, exclude) {
    let ex = exclude;
    if (ex === undefined) {
    ex = [];
    }
    if (!isNaN(unkType) && typeof unkType !== 'string') {
    return unkType;
    }
    switch (typeof unkType) {
    case 'object':
    return objectHash(unkType, ex);
    default:
    return stringHash(String(unkType));
    }
    }
    hashFunc = Hash;
    return Hash;
    };

    Ejemplo De Uso:

    Hash('hello world'), Hash('hello world') == Hash('hello world')
    Hash({hello: 'hello world'}), Hash({hello: 'hello world'}) == Hash({hello: 'hello world'})
    Hash({hello: 'hello world', goodbye: 'adios amigos'}), Hash({hello: 'hello world', goodbye: 'adios amigos'}) == Hash({goodbye: 'adios amigos', hello: 'hello world'})
    Hash(['hello world']), Hash(['hello world']) == Hash(['hello world'])
    Hash(1), Hash(1) == Hash(1)
    Hash('1'), Hash('1') == Hash('1')

    Salida

    432700947 true
    -411117486 true
    1725787021 true
    -1585332251 true
    1 true
    -1881759168 true

    Explicación

    Como se puede ver el corazón del servicio es la función de hash creado por KimKha.He añadido tipos de cadenas para que la sturucture de que el objeto podría también afectar el valor de hash.Las claves son encriptado para evitar matriz|objeto de colisiones.

    eyelidlessness objeto de comparación se utiliza para prevenir el infinito recursividad por la auto hace referencia a objetos.

    Uso

    He creado este servicio para que yo pudiera tener un error de servicio que se accede con los objetos. Para que un servicio puede registrar un error con un determinado objeto y el otro puede determinar si se han encontrado errores.

    es decir

    JsonValidation.js

    ErrorSvc({id: 1, json: '{attr: "not-valid"}'}, 'Invalid Json Syntax - key not double quoted');

    UserOfData.js

    ErrorSvc({id: 1, json: '{attr: "not-valid"}'});

    Esto volvería:

    ['Invalid Json Syntax - key not double quoted']

    Mientras

    ErrorSvc({id: 1, json: '{"attr": "not-valid"}'});

    Esto volvería

    []
  18. 0

    Basado en el título, podemos generar un hash con js, puede ser utilizado para generar un hash único de un objeto, a una serie de parámetros, una cadena, o lo que sea.

    Después de indexación para así evitar cualquier posible coincidencia de errores, permitiendo recuperar un índice de la params (evitar la búsqueda/bucle en el objeto, etc):

    JS:

    async function H(m) {
    const msgUint8 = new TextEncoder().encode(m)                       
    const hashBuffer = await crypto.subtle.digest('SHA-256', msgUint8)          
    const hashArray = Array.from(new Uint8Array(hashBuffer))                    
    const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
    console.log(hashHex)
    }
    /* Examples ----------------------- */
    H("An obscure ....")
    H(JSON.stringify( {"hello" : "world"} ))
    H(JSON.stringify( [54,51,54,47] ))

    https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest#Converting_a_digest_to_a_hex_string

Dejar respuesta

Please enter your comment!
Please enter your name here