JavaScript: Besoin des fonctions permettant de convertir une chaîne de caractères contenant le binaire en hexadécimal, puis convertis en binaire

Permet de dire que j'ai une chaîne de caractères en JavaScript avec des données binaires. Il peut ressembler à ceci:

var binary = '00001000010001000101010100001110';

J'ai besoin de quelques fonctions fiables afin de le convertir en une chaîne hexadécimale, puis de les convertir en retour, hexadécimal, binaire, corde à nouveau. Je sais que sur les fonctions suivantes

//Convert binary to hexadecimal
var hex = parseInt(binaryCharacters, 2).toString(16);

//Convert hexadecimal to binary
var binary = parseInt(hex, 16).toString(2)

Mais je ne suis pas sûr de la façon de convertir l'ensemble de la chaîne à la fois. Suis-je en droit de comprendre j'ai besoin de convertir chaque binaire 4 bits à la fois en un seul caractère hexadécimal? Alors pour en revenir aux binaires je boucle sur chaque caractère hexadécimal et le convertir en binaire de nouveau?

J'ai chassé pour quelques exemples simples de faire cela en JavaScript, mais ne trouvez pas tout.

Merci beaucoup

stackoverflow.com/questions/7695450/..., gist.github.com/ghalimi/4525262, phpjs.org/functions/bin2hex. Oh Google, votre meilleur ami...
Le dernier (bin2hex fonction) ne fonctionne pas. Il me donne de sortie comme 3030303031303030303130303031303030313031303130... et qui ne regarde pas à droite. Pourquoi est-il les valeurs de remplissage, avec une longueur de moins de 2 avec un supplément '0' char? J'ai pensé qu'il était censé convertir sur un quartet (4 bits) par grignoter et chaque grignoter va créer un seul hex char???

OriginalL'auteur user2503552 | 2013-06-20

Essayez cette jsfiddle.

Les fonctions plus intéressantes pour vous ici. Pas nécessairement le plus propre ou plus efficaces, mais oui:

//converts binary string to a hexadecimal string
//returns an object with key 'valid' to a boolean value, indicating
//if the string is a valid binary string.
//If 'valid' is true, the converted hex string can be obtained by
//the 'result' key of the returned object
function binaryToHex(s) {
var i, k, part, accum, ret = '';
for (i = s.length-1; i >= 3; i -= 4) {
//extract out in substrings of 4 and convert to hex
part = s.substr(i+1-4, 4);
accum = 0;
for (k = 0; k < 4; k += 1) {
if (part[k] !== '0' && part[k] !== '1') {
//invalid character
return { valid: false };
}
//compute the length 4 substring
accum = accum * 2 + parseInt(part[k], 10);
}
if (accum >= 10) {
//'A' to 'F'
ret = String.fromCharCode(accum - 10 + 'A'.charCodeAt(0)) + ret;
} else {
//'0' to '9'
ret = String(accum) + ret;
}
}
//remaining characters, i = 0, 1, or 2
if (i >= 0) {
accum = 0;
//convert from front
for (k = 0; k <= i; k += 1) {
if (s[k] !== '0' && s[k] !== '1') {
return { valid: false };
}
accum = accum * 2 + parseInt(s[k], 10);
}
//3 bits, value cannot exceed 2^3 - 1 = 7, just convert
ret = String(accum) + ret;
}
return { valid: true, result: ret };
}
//converts hexadecimal string to a binary string
//returns an object with key 'valid' to a boolean value, indicating
//if the string is a valid hexadecimal string.
//If 'valid' is true, the converted binary string can be obtained by
//the 'result' key of the returned object
function hexToBinary(s) {
var i, k, part, ret = '';
//lookup table for easier conversion. '0' characters are padded for '1' to '7'
var lookupTable = {
'0': '0000', '1': '0001', '2': '0010', '3': '0011', '4': '0100',
'5': '0101', '6': '0110', '7': '0111', '8': '1000', '9': '1001',
'a': '1010', 'b': '1011', 'c': '1100', 'd': '1101',
'e': '1110', 'f': '1111',
'A': '1010', 'B': '1011', 'C': '1100', 'D': '1101',
'E': '1110', 'F': '1111'
};
for (i = 0; i < s.length; i += 1) {
if (lookupTable.hasOwnProperty(s[i])) {
ret += lookupTable[s[i]];
} else {
return { valid: false };
}
}
return { valid: true, result: ret };
}

Cool merci! Qui fonctionne bien. Je suis venu avec quelques fonctions pour faire aussi bien après que j'ai compris comment faire, vérifier ma réponse. Je pense que nous pourrions probablement juste utiliser directement des tables/tableaux pour convertir au format hexadécimal et le transformer à nouveau en binaire être honnête, pourrait être beaucoup plus rapide que de le faire manuellement. Ce que tu vois?
Cela a fonctionné comme un charme. merci beaucoup bro. +1 pour cette.

OriginalL'auteur yanhan

Eh bien j'ai trouvé un algorithme ici qui l'a aidé à expliquer comment le faire. Aussi cette page sur Wikipédia contribué à confirmer la 4-bit binaire à l'hexadécimal mappages. Je suis venu avec le code suivant pour le faire. D'autres extraits de code que j'ai trouvé sur le web ne fonctionne pas du tout. Laissez-moi savoir si vous voulez faire toutes les améliorations. Vous pourriez même faire une droite de la table de vraiment l'aide de cette information à partir de Wikipédia qui serait plus rapide.

var tools = {
/**
* Converts binary code to hexadecimal string
* @param {string} binaryString A string containing binary numbers e.g. '01001101'
* @return {string} A string containing the hexadecimal numbers
*/
convertBinaryToHexadecimal: function(binaryString)
{
var output = '';
//For every 4 bits in the binary string
for (var i=0; i < binaryString.length; i+=4)
{
//Grab a chunk of 4 bits
var bytes = binaryString.substr(i, 4);
//Convert to decimal then hexadecimal
var decimal = parseInt(bytes, 2);
var hex = decimal.toString(16);
//Uppercase all the letters and append to output
output += hex.toUpperCase();
}
return output;      
},
/**
* Converts hexadecimal code to binary code
* @param {string} A string containing single digit hexadecimal numbers
* @return {string} A string containing binary numbers
*/
convertHexadecimalToBinary: function(hexString)
{
var output = '';
//For each hexadecimal character
for (var i=0; i < hexString.length; i++)
{
//Convert to decimal
var decimal = parseInt(hexString.charAt(i), 16);
//Convert to binary and add 0s onto the left as necessary to make up to 4 bits
var binary = this.leftPadding(decimal.toString(2), '0', 4);
//Append to string         
output += binary;
}
return output;
},
/**
* Left pad a string with a certain character to a total number of characters
* @param {string} inputString The string to be padded
* @param {string} padCharacter The character that the string should be padded with
* @param {string} totalCharacters The length of string that's required
* @returns {string} A string with characters appended to the front of it
*/
leftPadding: function(inputString, padCharacter, totalCharacters)
{
//If the string is already the right length, just return it
if (!inputString || !padCharacter || inputString.length >= totalCharacters)
{
return inputString;
}
//Work out how many extra characters we need to add to the string
var charsToAdd = (totalCharacters - inputString.length)/padCharacter.length;
//Add padding onto the string
for (var i = 0; i < charsToAdd; i++)
{
inputString = padCharacter + inputString;
}
return inputString;
}
};

OriginalL'auteur user2503552

2

Pourquoi ne pas utiliser Tableau.le prototype.réduire?
```
var binstr = "00001000010001000101010100001110"
function bin2hex(b) {
return b.match(/.{4}/g).reduce(function(acc, i) {
return acc + parseInt(i, 2).toString(16);
}, '')
}
function hex2bin(h) {
return h.split('').reduce(function(acc, i) {
return acc + ('000' + parseInt(i, 16).toString(2)).substr(-4, 4);
}, '')
}
console.log(binstr);
> 00001000010001000101010100001110
console.log(bin2hex(binstr));
> 0844550e
console.log(hex2bin(bin2hex(binstr)));
> 00001000010001000101010100001110
```
Lien vers jsfiddle ici.

Notes:
1. Dans bin2hex, si vous voulez convertir aussi les de fuite des segments de moins de 4 bits en hexadécimal, remplacer {4} avec {1,4}. Cependant, convertir le résultat en binaire, va produire une chaîne de caractères qui diffère de l'original. Par exemple, la conversion de l'avant et l'arrière "111101" serait de produire des "11110001".
2. Dans hex2bin, les valeurs binaires sont de gauche complétée par des zéros, de façon à avoir 4 chiffres binaires pour chaque chiffre hexadécimal.
OriginalL'auteur Giancarlo Sportelli

Vous devez vous connecter pour publier un commentaire.