nodejs écrire 64 bits entier non signé de la mémoire tampon

Je veux stocker un 64 bits (8 octets) entier à un nodejs tampon objet en big endian format.

Le problème à propos de cette tâche est de nodejs tampon prend uniquement en charge l'écriture des entiers 32 bits maximum (avec buf.write32UInt32BE(valeur de décalage)). Alors j'ai pensé, pourquoi ne pouvons-nous pas juste diviser le 64 bits entier?

var buf = new Buffer(8);

buf.fill(0) //clear all bytes of the buffer
console.log(buf); //outputs <Buffer 00 00 00 00 00 00 00 00>

var int = 0xffff; //as dezimal: 65535

buf.write32UInt32BE(0xff, 4); //right the first part of the int
console.log(buf); //outputs <Buffer 00 00 00 00 00 00 00 ff>

buf.write32UInt32BE(0xff, 0); //right the second part of the int
console.log(buf); //outputs <Buffer 00 00 00 ff 00 00 00 ff>

var bufInt = buf.read32UInt32BE(0) * buf.read32UInt32BE(4);
console.log(bufInt); //outputs 65025

Comme vous le voyez c'près des œuvres. Le problème est juste de fractionnement le 64 bits entier et de trouver les manquants 510 à lire. Quelqu'un voudrait-il l'esprit montrant les solutions à ces deux problèmes?

Depuis la dernière Node.js v12.0.0, vous pouvez maintenant utiliser buf.writeBigInt64BE

OriginalL'auteur bodokaiser | 2013-02-06

9

Je pense que ce que vous cherchez est:
```
var bufInt = (buf.readUInt32BE(0) << 8) + buf.readUInt32BE(4);
```
Maj le premier nombre par 8 bits, et ajouter (au lieu de multiplier), qui renvoie 65535

MODIFIER

Une autre façon d'écrire serait:
```
var buf = new Buffer(8);
buf.fill(0);

var i = 0xCDEF; //52719 in decimal

buf.writeUInt32BE(i >> 8, 0); //write the high order bits (shifted over)
buf.writeUInt32BE(i & 0x00ff, 4); //write the low order bits

console.log(buf); //displays: <Buffer 00 00 00 cd 00 00 00 ef>

var bufInt = (buf.readUInt32BE(0) << 8) + buf.readUInt32BE(4);
console.log(bufInt); //displays: 52719
```
oui, cela permettrait de résoudre le problème de lecture, mais ce qui est sur le fractionnement 0xffff en 0xff, 0xff?
voir mon edit. rappelez-vous que le changement est bizarre en javascript, il ne fonctionne qu'en 32 bits. Je ne pense pas que ce serait de travailler avec un certain nombre qui est la valeur ne peut pas être représentée par 32-bits.
Cela ne fonctionnera pas pour 64-bits. Vos changements sont aussi. Vous auriez besoin de passer par 32, pas 8, JS ne peut pas faire.
Pour clarifier, qui va travailler pour la valeur de 16 bits, il a mis dans sa question, mais pas pour le cas général. Vous êtes également perdre de l'espace à l'aide d'un Tampon avec 8 octets pour stocker 2 octets.
les opérations bit à bit sur les numéros de convertir les nombres de 32 bits.

OriginalL'auteur Chad

Je suis confus parce que votre exemple de valeur de 0xFFFF est de 16 bits uniquement, pas 64 bits.

Gardez à l'esprit que la JS number type est spécifié comme un IEEE754 valeur à virgule flottante, de sorte qu'il n'est pas garanti d'être en mesure de tenir 64 bits non signé valeur. Si vous voulez un vrai 64 bits de l'entier soutien, vous devez utiliser un module de lui fournir, comme bignum. Le fichier lisez-moi qui a des exemples de la lecture et de l'écriture des valeurs de tampons.

Des valeurs à virgule flottante ne peut que représenter des valeurs jusqu'à 2^53 - 1 sans perdre de précision. Vous pouvez voir que dans cet exemple, en utilisant la norme JS numéros:

var b = new Buffer([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF])
var firstHalf = b.readUInt32BE(0); //4294967295
var secondHalf = b.readUInt32BE(4); //4294967295

var val = firstHalf * 0x100000000 + secondHalf; //18446744073709552000

Le résultat de ceci est 18446744073709552000 lorsque la valeur correcte est 18446744073709551615.

var bignum = require('bignum');

var b = new Buffer([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF])
var val = bignum.fromBuffer(b);

Il en résulte une BigNum objet avec la valeur 18446744073709551615.

Aussi, de donner des précisions sur votre exemple de code, la valeur que vous utilisez est que de 16 bits, et que vous essayez de travailler avec elle à l'aide de fonctions de 32 bits. Il vous suffit de faire ceci:

var buf = new Buffer(2);

buf.fill(0) //clear all bytes of the buffer
console.log(buf); //outputs <Buffer 00 00>

var int = 0xffff; //as decimal: 65535

//Write it with a standard 16-bit function calls.
buf.writeUInt16BE(int);

//OR write it with 2 8-bit function calls.
buf.writeUInt8(int & 0xff, 0); //right the first part of the int
buf.writeUInt8((int >> 8) & 0xFF, 1); //right the second part of the int
console.log(buf); //outputs <Buffer ff ff>

//Read it as a 16-bit value.
var bufInt = buf.readUInt16BE(0);
console.log(bufInt);

//OR read it as two 8-bit values.
var bufInt = (buf.readUInt8(1) << 8) + buf.readUInt8(0);

OriginalL'auteur loganfsmyth

De la lecture et des écritures UINT les nombres jusqu'à Number.MAX_SAFE_INTEGER.

Cela fonctionne dans node.js seulement, n'est pas portable sur navigateur côté.

function uintToBase62(n) {
  if (n < 0) throw 'unsupported negative integer';

  let uintBuffer;
  if (n < 0x7FFFFFFF) {
    uintBuffer = new Buffer(4);
    uintBuffer.writeUInt32BE(n, 0);
  } else {
    //`~~` double bitwise operator
    //The most practical way of utilizing the power of this operator is to use it as a replacement
    //for Math.floor() function as double bitwise NOT performs the same operation a lot quicker.
    //You can use it, to convert any floating point number to a integer without performance overkill
    //that comes with Math.floor(). Additionally, when you care about minification of your code,
    //you end up using 2 characters (2 tildes) instead of 12.
    //http://rocha.la/JavaScript-bitwise-operators-in-practice
    const big = ~~(n / 0x0100000000);
    const low = (n % 0x0100000000);
    uintBuffer = new Buffer(8);
    uintBuffer.writeUInt32BE(big, 0);
    uintBuffer.writeUInt32BE(low, 4);
  }

  return uintBuffer.toString('hex');
}

convertir

function uintFromBase62(uintBuffer) {
  const n = parseInt(uintBuffer.toString('hex'), 16);
  return n;
}

OriginalL'auteur dash1e

//sending time
var sending_time = new Date().getTime();
buffer.writeInt32LE(parseInt(sending_time & 0xffffffff, 10), 16);
buffer.writeInt32LE(parseInt(sending_time / 0xffffffff, 10), 20);

OriginalL'auteur meil

0

Des opérations bit à bit en JavaScript/EcmaScript force du nombre (ou toute valeur vraiment) en un entier de 32 bits.

Vous vraiment besoin d'utiliser bignum pour les plus grandes valeurs si vous avez besoin d'une certaine précision, ou de traiter avec les tampons avec plus de 32-bits.
```
var bignum = require('bignum');

//max safe integer to big number
var num = bignum(Number.MAX_SAFE_INTEGER.toString());
var buf = num.toBuffer({endian:'big',size:8 /*8-byte /64-bit*/});

console.log(buf); //
```
L'exemple ci-dessus utilise Number.MAX_SAFE_INTEGER qui est Math.pow(2,53)-1. Si vous avez besoin d'utiliser un plus grand nombre, ils doivent être accessibles en tant que bignum chaînes... si vous pouvez rester à l'intérieur de la plage des Entiers en JS, vous pouvez les garder et de les convertir comme ci-dessus.

OriginalL'auteur Tracker1
0

De lecture /Écriture 64bit valeurs:
```
const int64 = Date.now()   //1456909977176 (00 00 01 53 36 9a 06 58)
const b = new Buffer(8)
const MAX_UINT32 = 0xFFFFFFFF

//write
const big = ~~(int64 / MAX_UINT32)
const low = (int64 % MAX_UINT32) - big

b.writeUInt32BE(big, 0)  //00 00 01 53 00 00 00 00
b.writeUInt32BE(low, 4)  //00 00 01 53 36 9a 06 58

//read
var time = parseInt(b.toString('hex'), 16)
time == int64 //true
```
J'utilise ce code sans des modules spéciaux.

Mise à JOUR

Ne fonctionne que pour les numéros de <= Number.MAX_SAFE_INTEGER

const low = int64 & MAX_UINT32 un peu plus court ^_^
Étant donné le nombre de ci-dessous: 18446744073709552000. ~~(18446744073709552000 / 0xFFFFFFFF) est de 1, (18446744073709552000 % 0xFFFFFFFF) - 1 est de 0. Ce code est cassé.
Oui, vous avez raison( C'est petit "hack" que worsk avec quelques chiffres. Je vais corriger mon code rapidement. Thx) Utilisation bignum.
Je pense que vous devriez diviser et modulo par 0x0100000000 à la place. Considérons le cas où int64 = 0xFFFFFFFF (=4294967295): la haute = 0, bas devrait = 4294967295, tampon doit = <00 00 00 00 ff ff ff ff> Mais dans votre cas, haut = 1, bas = -1, tampon = <00 00 00 01 00 00 00 00> C'est le bon code: const high = Math.trunc(int64 / 0x0100000000); const low = int64 % 0x0100000000; Ce sera aussi mal à chaque fois le plus bas int32 est FFFFFFFF. Si vous utilisez ce pour convertir une date alors peut frapper une erreur à chaque 49,7 jours.
Ce code ne fonctionne pas

OriginalL'auteur ReklatsMasters

Vous devez vous connecter pour publier un commentaire.