Qu'est-ce que la façon d'envoyer les valeurs de 64 bits sur JSON?

Certaines de mes données sont des entiers 64 bits. Je tiens à les envoyer à un programme JavaScript s'exécutant sur une page.

Cependant, autant que je peux dire, entiers, dans la plupart des implémentations de JavaScript sont de 32 bits signé quantités.

Mes deux options semblent être:

Envoyer les valeurs comme des chaînes
Envoyer des valeurs en virgule flottante de 64 bits des nombres

De l'Option (1) n'est pas parfait, mais l'option (2) semble beaucoup moins parfaite (perte de données).

Comment avez-vous géré cette situation?

InformationsquelleAutor Frank Krueger | 2008-10-16

23

Cela semble être moins un problème avec JSON et de plus en plus un problème avec le Javascript lui-même. Qu'allez-vous faire avec ces chiffres? Si c'est juste une magie jeton que vous avez besoin de passer sur le site web plus tard, par tous les moyens, il suffit d'utiliser une chaîne de caractères contenant la valeur. Si vous avez réellement à faire de l'arithmétique sur la valeur, vous pourriez peut-être écrire vos propres routines de Javascript pour la version 64 bits de l'arithmétique.

D'une manière que vous pourriez représenter les valeurs en Javascript (et donc JSON) serait en divisant les nombres en deux valeurs de 32 bits, par exemple.
```
  [ 12345678, 12345678 ]
```
De diviser une valeur de 64 bits en deux valeurs de 32 bits, faire quelque chose comme ceci:
```
  output_values[0] = (input_value >> 32) & 0xffffffff;
  output_values[1] = input_value & 0xffffffff;
```
Puis de recombiner les deux valeurs de 32 bits vers une version 64 bits de valeur:
```
  input_value = ((int64_t) output_values[0]) << 32) | output_values[1];
```
- Lorsque j'essaie de "input_value >> 32", je viens de revenir "input_value", comme si les 32 bits sont juste envelopper entièrement autour de. ">>>" a le même effet. Pourtant, quand j'essaie de "Maths.étage(input_value / 4294967296)" (4294967296 = Math.pow(2, 32)), j'obtiens le haut 32bit partie de "input_value"; Ce qui me manque?
- Vous ne dites pas quelle est la langue que vous utilisez, donc je vais supposer que vous êtes à l'aide de Java. Est 'input_value" d'une longue (ie. Entier 64 bits)? Si c'est un int (entier 32 bits), puis bitshifting à gauche 32-bits ne fonctionnera pas.
- désolé.. je devrais avoir été explicite. Je suis à l'aide de javascript (en nodejs) et a même été surpris de voir que bitshifting 32 bits vers la droite d'une certaine manière m'a donné le même nombre. Je ne suis pas entièrement comprendre toutes les conversions de types implicites en javascript et leurs représentations.
- - Il encore est JSON problème, pas un Javascript problème, dans ce JSON ne prend pas en charge les entiers avec plus de 9 chiffres après la virgule. Si elle le faisait, le Javascript de mise en œuvre seraient obligés de fournir un soutien pour elle en quelque sorte sous le capot.
- Je n'arrive pas à trouver une référence à l'une des 9 chiffres après la virgule déclaration. C'est qu'en quelque sorte d'une spec?
- C'est dans la version de la spécification (RFC 4627 & http://www.json.org) que j'ai inventé dans ma tête quand j'ai mal interprété la grammaire. 🙂
InformationsquelleAutor Simon Howard
8

Il est en fait une limitation au JavaScript/ECMAScript niveau de précision de 53 bits pour les entiers (ils sont stockés dans la mantisse d'un "double" comme de 8 octets de la mémoire tampon). Ainsi la transmission des grands nombres sous forme de JSON ne sera pas la désérialisation comme prévu par le client de JavaScript, ce qui permettrait de les tronquer ses 53 bits de résolution.
```
> parseInt("10765432100123456789")
10765432100123458000
```
Voir le Nombre.MAX_SAFE_INTEGER constante et Number.isSafeInteger() fonction:

La MAX_SAFE_INTEGER constante a une valeur de 9007199254740991. L'
le raisonnement derrière ce chiffre, c'est que JavaScript utilise double précision
à virgule flottante en forme de nombres, comme spécifié dans la norme IEEE 754 et ne peut
en toute sécurité représenter les nombres entre -(2^53 - 1) et 2^53 - 1.

Coffre-fort dans ce contexte, fait référence à la capacité de représenter des nombres entiers
exactement et correctement les comparer. Par exemple,
Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2 va
évaluer à true, ce qui est mathématiquement incorrect. Voir
Number.isSafeInteger() pour plus d'informations.

En raison de la résolution de flotteurs en JavaScript, en utilisant "64 bits des nombres à virgule flottante" comme vous l'avez proposé aurait à souffrir de la même restriction.

À mon humble avis, la meilleure option est de transmettre des valeurs telles que du texte. Il serait encore parfaitement lisible le contenu JSON, et il serait facile de faire un travail avec au JavaScript niveau.

Un "pur" chaîne de la représentation est ce OData indique, pour sa Edm.Int64 ou Edm.Décimal types.

Ce que l'API Twitter dans ce cas, est d'ajouter un spécifique ".._str": champ dans le JSON, en tant que tel:
```
{
   "id": 10765432100123456789,           //for JSON compliant clients
   "id_str": "10765432100123456789",     //for JavaScript
    ...
}
```
J'aime cette option beaucoup, puisqu'il serait toujours compatible avec int64 capable de clients. Dans la pratique, un tel contenu dupliqué dans le JSON n'aurez pas fait beaucoup de mal, si elle est dégonflé/format à l'adresse HTTP de niveau.

Une fois transmis en tant que chaîne de caractères, vous pouvez utiliser des bibliothèques comme strint – une bibliothèque JavaScript pour la chaîne codée entiers pour gérer de telles valeurs.
- Grande explication. J'ai juste rencontré, avec un JS frontend et C# api web back-end. Mon HttpResponseMessage serait sérialiser mes objets (qui contenait long id) et ils ont été tronqués. Ce qui était vraiment étrange, c'est qu'ils n'étaient pas tronqué jusqu'à ils ont atteint le navigateur. Si j'ai créé la réponse, puis analysé le contenu avant de l'envoyer, l'ID n'ont pas été tronqué. Il n'était pas jusqu'à ce que le navigateur a reçu et analysé la réponse qu'il allait magiquement obtenir tronquée. Votre explication m'a aidé à comprendre pourquoi. Merci! J'ai fini l'enregistrement d'un convertisseur personnalisé pour longtemps types.
InformationsquelleAutor Arnaud Bouchez
6

Javascript du type de Numéro (64 bits IEEE 754) ne dispose que d'environ 53 bits de précision.

Mais, si vous n'avez pas besoin de faire une addition ou la multiplication, alors vous pouvez garder la valeur 64 bits 4-les chaînes de caractères en JavaScript utilise UTF-16.

Par exemple, 1 peut être codé comme "\u0000\u0000\u0000\u0001". Ceci a l'avantage que la valeur de comparaison (==, >, <) travaille sur des chaînes comme prévu. Il semble aussi simple d'écrire les opérations sur les bits:
```
function and64(a,b) {
    var r = "";
    for (var i = 0; i < 4; i++)
        r += String.fromCharCode(a.charCodeAt(i) & b.charCodeAt(i));
    return r;
}
```
- C'est un moyen astucieux de rester économe avec des octets sur le fil, tout en étant capable de plus ou moins lire le numéro. Je serais intéressé de savoir s'il y a des problèmes avec cette approche.
InformationsquelleAutor David Leonard
2

La JS numéro de représentation est une norme ieee double, de sorte que vous ne pouvez pas représenter un entier de 64 bits. si vous obtenez peut-être 48 bits réels de l'int de précision en double, mais tous les JS bitops réduire à 32 bits de précision (c'est ce que la spécification exige. yay!!!) donc, si vous avez vraiment besoin d'un 64 bits int en js, vous aurez besoin de mettre en place votre propre 64 bits int logique de la bibliothèque.
- 53bits habituellement.
- 53 bits toujours, à l'exclusion de signe.
InformationsquelleAutor olliej
0

JSON lui-même ne se soucie pas de la mise en œuvre des limites.
votre problème, c'est que JS ne peut pas gérer vos données, pas le protocole.
En d'autres termes, votre JS code client à utiliser l'une de ces non-parfaite options.
- Pourriez-vous définir l'OIE. En D'Autres Termes?
- Oui, OIE==En d'Autres Termes.
InformationsquelleAutor Javier

Vous devez vous connecter pour publier un commentaire.