Bagaimana mengkonversi desimal ke heksadesimal dalam JavaScript


1479

Bagaimana Anda mengonversi nilai desimal ke ekuivalen heksadesimalnya dalam JavaScript?


7
Hanya peringatan di sini yaitu Anda mulai dari representasi string, sangat mudah kehilangan presisi ketika Anda mengubahnya menjadi Number sebagai bagian dari mengubahnya menjadi hex. Lihat danvk.org/wp/2012-01-20/… .
studgeek

Ini fungsi adalah apa yang Anda butuhkan
Mohammad Mousavi

Jawaban:


2475

Konversi angka menjadi string heksadesimal dengan:

hexString = yourNumber.toString(16);

Dan membalikkan proses dengan:

yourNumber = parseInt(hexString, 16);

42
yourNum adalah string hex dalam hal ini. Misalnya (255) .toString (16) == 'ff' && parseInt ('ff', 16) == 255
Prestaul

8
@ forste, Anda tidak akan "kehilangan presisi" jika Anda mengonversi Nomor javascript (yang merupakan objek Number, yang dalam skrip ECMA adalah Ganda) untuk hex dan kembali menggunakan teknik ini. Pertanyaan yang Anda tautkan secara khusus merujuk angka-angka yang terlalu besar untuk masuk ke dalam Dobel (karenanya representasi string dalam pertanyaan). Jika Anda punya Nomor maka ini akan berhasil. Jika Anda memiliki sesuatu yang terlalu besar untuk menjadi objek Nomor javascript (Dobel) maka Anda harus menemukan sesuatu yang lain.
Prestaul

12
@ Derek, saya memiliki masalah psikologis yang tidak memungkinkan saya untuk menoleransi tanda kurung yang tidak perlu ... @ semua orang-lain, yourNumberadalah sebuah variabel. Jika Anda ingin menggunakan numerik literal maka Anda harus melakukan sesuatu seperti (45).toString(16), tetapi jika Anda meng-coding angka maka silakan tulis saja sebagai string hex sendiri ... (45).toString(16)akan selalu sama '2d', jadi jangan buang cpu siklus untuk mencari tahu itu.
Prestaul

21
@ Prestaul "Jangan buang siklus cpu untuk mencari tahu" - itu disebut optimasi prematur. Kecuali jika JavaScript berjalan pada 286, saya meragukan masalah overhead. Lebih jauh lagi, '45' mungkin merupakan angka ajaib yang harus dapat dikenali oleh programmer (seperti durasi waktu habis dalam detik), sedangkan '2d', nah siapa yang akan mengenalinya?
Dejay Clayton

47
Jika Anda tidak suka tanda kurung, Anda bisa menggunakan titik tambahan:42..toString(16)
Thomas Watson

142

Jika Anda perlu menangani hal-hal seperti bidang bit atau warna 32-bit, maka Anda harus berurusan dengan angka yang ditandatangani. Fungsi JavaScript toString(16)akan mengembalikan angka heksadesimal negatif yang biasanya bukan yang Anda inginkan. Fungsi ini melakukan beberapa tambahan gila untuk membuatnya menjadi angka positif.

function decimalToHexString(number)
{
  if (number < 0)
  {
    number = 0xFFFFFFFF + number + 1;
  }

  return number.toString(16).toUpperCase();
}

console.log(decimalToHexString(27));
console.log(decimalToHexString(48.6));


5
Apakah itu pelengkap dari keduanya?
Julian

2
Konversi ini biasanya tidak diperlukan karena JavaScript dapat mewakili semua bidang bit 32-bit sebagai angka yang tidak ditandai (Lihat Number.MAX_SAFE_INTEGER). Untuk alasan yang sama konversi ke unsigned dapat ditulis sebagai:number = 0x100000000 + number;
Johannes Matokic

3
Catatan singkat pada komentar saya sebelumnya: Sementara representasi hex harus bekerja untuk angka hingga Number.MAX_SAFE_INTEGER ini tidak berlaku untuk operasi bitwise (yang sering digunakan untuk membuat warna 32-bit). Hasil dari operasi bitwise selalu merupakan bilangan bulat 32-bit yang ditandatangani. Oleh karena itu hasil bitwise> = 2 ^ 31 negatif dan 0x100000000 | 0 === 0.
Johannes Matokic

25
Anda dapat menggunakan >>>operator untuk mengonversi angka menjadi representasi yang tidak ditandatangani, misalnya ((-3253) >>> 0).toString(16)pengembalian "fffff34b".
csharpfolk

1
+1untuk tambahan yang bermanfaat, tetapi jika Anda mengonversi angka ke notasi yang berbeda, semua angka itu "biasanya" sudah positif, atau Anda ingin hasil negatif.
Carl Smith

82

Kode di bawah ini akan mengonversi nilai desimal d menjadi heksadesimal. Ini juga memungkinkan Anda untuk menambahkan bantalan ke hasil heksadesimal. Jadi 0 akan menjadi 00 secara default.

function decimalToHex(d, padding) {
    var hex = Number(d).toString(16);
    padding = typeof (padding) === "undefined" || padding === null ? padding = 2 : padding;

    while (hex.length < padding) {
        hex = "0" + hex;
    }

    return hex;
}

5
Ini tidak akan menangani nilai negatif dengan benar. decimalToHex (-6, 4) akan mengembalikan 00-6.
JonMR

3
Ini juga memiliki masalah dengan pelampung, tetapi menempatkan di Math.round () memperbaikinya. (+1d)
Michael - Di mana Clay Shirky

Saya "menarik" angka dari array ('255.0.55', dll) dan .toString (16) tidak berfungsi. Yang saya dapatkan hanyalah angka yang sama! Saya menambahkan fungsi "Nomor" ke depan, dan sekarang berfungsi! Hanya menghabiskan waktu sekitar empat jam untuk mencari solusinya !!
Cristofayre

65
function toHex(d) {
    return  ("0"+(Number(d).toString(16))).slice(-2).toUpperCase()
}

1
function hexRep(number, width) { return (number+Math.pow(16, precision)).toString(16).slice(-width); }
Lori

2
Tidak sulit untuk memperpanjangnya, Anda memotong angka terakhir dengan .slice (-number) di sana. Jika Anda menambahkan lebih banyak nol ke depan itu akan berfungsi dengan baik.
Tatarize

19
ES6 const hex = d => Number(d).toString(16).padStart(2, '0')😁
Ninh Pham

39

Untuk kelengkapan, jika Anda menginginkan representasi hexadecimal dua-pelengkap dari angka negatif, Anda dapat menggunakan operator shift nol-isi-kanan>>> . Contohnya:

> (-1).toString(16)
"-1"

> ((-2)>>>0).toString(16)
"fffffffe"

Namun ada satu batasan: operator bitwise JavaScript memperlakukan operan mereka sebagai urutan 32 bit , yaitu, Anda mendapatkan komplemen 32-bit two's.


2
sejauh ini ini adalah jawaban paling berharga untuk pertanyaan ini :)
albertjan

Menggali semua pertanyaan karena C# number to hexadecimalmenghasilkan hasil yang berbeda Javascript number to hexadecimal. Sepertinya Javascript memiliki masalah dengan angka negatif. Jawaban ini tampaknya menjadi solusi untuk masalah tersebut.
goamn

Ini sangat membantu, terima kasih! Saya menggunakan ini untuk warna RGB, jadi untuk mendapatkan varian 24-bit, memotong dua karakter pertama (FF tambahan) -((-2)>>>0).toString(16).substring(2)
antonyh

36

Dengan bantalan:

function dec2hex(i) {
   return (i+0x10000).toString(16).substr(-4).toUpperCase();
}

2
@Lucas Ini mengembalikan 4 karakter terakhir.
Gabriel

19

Tanpa loop:

function decimalToHex(d) {
  var hex = Number(d).toString(16);
  hex = "000000".substr(0, 6 - hex.length) + hex;
  return hex;
}

// Or "#000000".substr(0, 7 - hex.length) + hex;
// Or whatever
// *Thanks to MSDN

Juga bukankah lebih baik tidak menggunakan tes putaran yang harus dievaluasi?

Misalnya, alih-alih:

for (var i = 0; i < hex.length; i++){}

memiliki

for (var i = 0, var j = hex.length; i < j; i++){}

19

Menggabungkan beberapa ide bagus ini untuk fungsi RGB-value-to-hexadecimal (tambahkan tempat #lain untuk HTML / CSS):

function rgb2hex(r,g,b) {
    if (g !== undefined)
        return Number(0x1000000 + r*0x10000 + g*0x100 + b).toString(16).substring(1);
    else
        return Number(0x1000000 + r[0]*0x10000 + r[1]*0x100 + r[2]).toString(16).substring(1);
}

Terima kasih untuk ini! Saya ingin memberikan komentar sejak lama. Itu adalah kunci jawaban saya. stackoverflow.com/questions/5560248/…
Pimp Trizkit

16

Jawaban yang diterima tidak memperhitungkan satu digit kode heksadesimal yang dikembalikan. Ini mudah disesuaikan dengan:

function numHex(s)
{
    var a = s.toString(16);
    if ((a.length % 2) > 0) {
        a = "0" + a;
    }
    return a;
}

dan

function strHex(s)
{
    var a = "";
    for (var i=0; i<s.length; i++) {
        a = a + numHex(s.charCodeAt(i));
    }

    return a;
}

Saya percaya jawaban di atas telah diposting berkali-kali oleh orang lain dalam satu atau lain bentuk. Saya membungkus ini dalam fungsi toHex () seperti:

function toHex(s)
{
    var re = new RegExp(/^\s*(\+|-)?((\d+(\.\d+)?)|(\.\d+))\s*$/);

    if (re.test(s)) {
        return '#' + strHex( s.toString());
    }
    else {
        return 'A' + strHex(s);
    }
}

Perhatikan bahwa ekspresi reguler numerik berasal dari 10+ Fungsi Ekspresi Reguler JavaScript yang Berguna untuk meningkatkan efisiensi aplikasi web Anda .

Pembaruan: Setelah menguji hal ini beberapa kali saya menemukan kesalahan (tanda kutip ganda di RegExp), jadi saya memperbaikinya. NAMUN! Setelah sedikit pengujian dan setelah membaca posting oleh almaz - saya sadar saya tidak bisa mendapatkan angka negatif untuk bekerja.

Lebih lanjut - saya membaca beberapa tentang ini dan karena semua nomor JavaScript disimpan sebagai kata 64 bit tidak peduli apa - saya mencoba memodifikasi kode numHex untuk mendapatkan kata 64 bit. Tetapi ternyata Anda tidak bisa melakukan itu. Jika Anda memasukkan "3.14159265" AS A NUMBER ke dalam variabel - yang dapat Anda dapatkan adalah "3", karena bagian fraksional hanya dapat diakses dengan mengalikan angka dengan sepuluh (IE: 10.0) berulang kali. Atau dengan kata lain - nilai heksadesimal 0xF menyebabkan nilai floating point diterjemahkan ke dalam bilangan bulat sebelum ANDed yang menghapus semuanya di belakang periode. Daripada mengambil nilai secara keseluruhan (yaitu: 3.14159265) dan ANDing nilai floating point terhadap nilai 0xF.

Jadi hal terbaik yang harus dilakukan, dalam hal ini, adalah mengubah 3.14159265 menjadi sebuah string dan kemudian hanya mengonversi string tersebut. Karena hal di atas, itu juga memudahkan untuk mengkonversi angka negatif karena tanda minus hanya menjadi 0x26 di bagian depan nilai.

Jadi yang saya lakukan adalah menentukan bahwa variabel tersebut berisi angka - cukup konversikan ke string dan konversikan string. Ini berarti bagi semua orang bahwa di sisi server Anda harus mencopot pemasangan string yang masuk dan kemudian untuk menentukan informasi yang masuk adalah numerik. Anda dapat melakukannya dengan mudah dengan hanya menambahkan "#" ke depan angka dan "A" ke depan string karakter yang kembali. Lihat fungsi toHex ().

Selamat bersenang-senang!

Setelah satu tahun lagi dan banyak pemikiran, saya memutuskan bahwa fungsi "toHex" (dan saya juga memiliki fungsi "fromHex") benar-benar perlu dirubah. Seluruh pertanyaannya adalah "Bagaimana saya bisa melakukan ini dengan lebih efisien?" Saya memutuskan bahwa fungsi to / from hexadecimal seharusnya tidak peduli jika sesuatu merupakan bagian fraksional tetapi pada saat yang sama harus memastikan bahwa bagian fraksional termasuk dalam string.

Jadi kemudian pertanyaannya menjadi, "Bagaimana Anda tahu Anda bekerja dengan string heksadesimal?". Jawabannya sederhana. Gunakan informasi pra-string standar yang sudah dikenal di seluruh dunia.

Dengan kata lain - gunakan "0x". Jadi sekarang fungsi toHex saya terlihat untuk melihat apakah itu sudah ada dan apakah itu - hanya mengembalikan string yang dikirim ke sana. Kalau tidak, itu mengubah string, angka, apa pun. Berikut adalah fungsi toHex yang direvisi:

/////////////////////////////////////////////////////////////////////////////
//  toHex().  Convert an ASCII string to hexadecimal.
/////////////////////////////////////////////////////////////////////////////
toHex(s)
{
    if (s.substr(0,2).toLowerCase() == "0x") {
        return s;
    }

    var l = "0123456789ABCDEF";
    var o = "";

    if (typeof s != "string") {
        s = s.toString();
    }
    for (var i=0; i<s.length; i++) {
        var c = s.charCodeAt(i);

        o = o + l.substr((c>>4),1) + l.substr((c & 0x0f),1);
    }

    return "0x" + o;
}

Ini adalah fungsi yang sangat cepat yang memperhitungkan satu digit akun, angka floating point, dan bahkan memeriksa untuk melihat apakah orang tersebut mengirim nilai hex over untuk di-hexed lagi. Ini hanya menggunakan empat panggilan fungsi dan hanya dua dari mereka yang ada di loop. Untuk melepas hex nilai yang Anda gunakan:

/////////////////////////////////////////////////////////////////////////////
//  fromHex().  Convert a hex string to ASCII text.
/////////////////////////////////////////////////////////////////////////////
fromHex(s)
{
    var start = 0;
    var o = "";

    if (s.substr(0,2).toLowerCase() == "0x") {
        start = 2;
    }

    if (typeof s != "string") {
        s = s.toString();
    }
    for (var i=start; i<s.length; i+=2) {
        var c = s.substr(i, 2);

        o = o + String.fromCharCode(parseInt(c, 16));
    }

    return o;
}

Seperti fungsi toHex (), fungsi fromHex () pertama-tama mencari "0x" dan kemudian menerjemahkan informasi yang masuk menjadi string jika belum menjadi string. Saya tidak tahu bagaimana ini bukan string - tetapi untuk berjaga-jaga - saya periksa. Fungsi kemudian berjalan, mengambil dua karakter dan menerjemahkannya ke karakter ASCII. Jika Anda ingin menerjemahkan Unicode, Anda harus mengubah perulangan menjadi empat (4) karakter sekaligus. Tapi kemudian Anda juga perlu memastikan bahwa string TIDAK dibagi oleh empat. Jika - maka itu adalah string heksadesimal standar. (Ingat string memiliki "0x" di depannya.)

Skrip pengujian sederhana untuk menunjukkan bahwa -3.14159265, ketika dikonversi ke string, masih -3.14159265.

<?php

    echo <<<EOD
<html>
    <head><title>Test</title>
        <script>
            var a = -3.14159265;
            alert( "A = " + a );
            var b = a.toString();
            alert( "B = " + b );
        </script>
    </head>
    <body>
    </body>
</html>
EOD;

?>

Karena cara kerja JavaScript sehubungan dengan fungsi toString (), semua masalah tersebut dapat dihilangkan yang sebelumnya menyebabkan masalah. Sekarang semua string dan angka dapat dikonversi dengan mudah. Selanjutnya, hal-hal seperti objek akan menyebabkan kesalahan yang dihasilkan oleh JavaScript itu sendiri. Saya percaya ini tentang sebaik yang didapatnya. Satu-satunya peningkatan yang tersisa adalah untuk W3C untuk hanya menyertakan fungsi toHex () dan fromHex () dalam JavaScript.


Saya pikir Anda masih punya pekerjaan untuk dilakukan di sini ... if( s.substr(0,2)sebelum if (typeof s != "string")mungkin bukan yang Anda inginkan, misalnya. Apa yang telah saya kembalikan juga bukan yang saya harapkan ( toHex(0x1f635)memberi "0x313238353635"). Belum diselidiki lebih lanjut.
ruffin

Saya yakin Anda salah. Contoh Anda menggunakan string hex yang BUKAN string - tetapi angka. Karenanya 1f635 akan keluar seperti itu. Jika Anda telah memasukkan "0x1f635" itu akan keluar secara berbeda. (yaitu: rutin hanya akan mengembalikan nomor hex yang telah Anda kirim ke rutin.) :-)
Mark Manning

Poin pertama adalah bahwa Anda tidak dapat menggunakan substr& toLowerCasepada non-string ... sehingga typeofkebutuhan untuk datang lebih cepat, atau, jika Anda berharap toHexuntuk melemparkan non-string di sana, Anda harus menghapus typeofcek sepenuhnya. Masuk akal? Yaitu, jika saya menggunakan kode di sini tanpa suntingan, dan menelepon toHex(0x1f635), saya akan mendapatkannya Uncaught TypeError: s.substr is not a function. Jika saya memindahkan string yang dilemparkan sebelumnya, Anda benar, angka yang dilemparkan ke desimal pertama, mungkin, dan semuanya berjalan menyamping. Yang tentu saja berarti Anda tidak dapat melakukan pemeran sederhana di sini jika sbukan string.
ruffin

Sebenarnya, di bawah XP ini berfungsi dengan baik. Ada sejumlah pembaruan untuk Javascript yang membuat Javascript menjadi typecast. Yang akan membuang pengecualian. Di bawah XP itu hanya berfungsi. Setidaknya untuk saya. Dalam dunia typecast - menempatkan "if (typeof s ==" string "&& s.substr (0,2) ==" 0x ") {return s;}" sesuai. Tapi ox1f635 masih bukan string. :-)
Mark Manning

12
var number = 3200;
var hexString = number.toString(16);

16 adalah radix dan ada 16 nilai dalam angka heksadesimal :-)


12

Bagi siapa pun yang tertarik, inilah JSFiddle membandingkan sebagian besar jawaban yang diberikan untuk pertanyaan ini .

Dan inilah metode yang akhirnya saya gunakan:

function decToHex(dec) {
  return (dec + Math.pow(16, 6)).toString(16).substr(-6)
}

Juga, ingatlah bahwa jika Anda ingin mengonversi dari desimal ke heks untuk digunakan dalam CSS sebagai tipe data warna , Anda mungkin lebih suka mengekstraksi nilai RGB dari desimal dan menggunakan rgb () .

Misalnya ( JSFiddle ):

let c = 4210330 // your color in decimal format
let rgb = [(c & 0xff0000) >> 16,  (c & 0x00ff00) >> 8,  (c & 0x0000ff)]

// Vanilla JS:
document..getElementById('some-element').style.color = 'rgb(' + rgb + ')'
// jQuery:
$('#some-element').css('color', 'rgb(' + rgb + ')')

Ini menetapkan properti #some-elementCSS colormenjadi rgb(64, 62, 154).


10

Dibatasi / diisi ke sejumlah karakter:

function decimalToHex(decimal, chars) {
    return (decimal + Math.pow(16, chars)).toString(16).slice(-chars).toUpperCase();
}

2
Ini mengubah angka menjadi string hex DAN bantalan nol terkemuka, ini indah!
Gordon

10

Berikut ini adalah versi ECMAScript 6 yang dipangkas:

const convert = {
  bin2dec : s => parseInt(s, 2).toString(10),
  bin2hex : s => parseInt(s, 2).toString(16),
  dec2bin : s => parseInt(s, 10).toString(2),
  dec2hex : s => parseInt(s, 10).toString(16),
  hex2bin : s => parseInt(s, 16).toString(2),
  hex2dec : s => parseInt(s, 16).toString(10)
};

convert.bin2dec('111'); // '7'
convert.dec2hex('42');  // '2a'
convert.hex2bin('f8');  // '11111000'
convert.dec2bin('22');  // '10110'

Dalam ketidaksepakatan yang kuat dengan @HypersoftSystems, jika lingkungan atau situasi Anda memungkinkan Anda melakukannya, maka gunakan ES6. Tidak semua skrip perlu dijalankan dalam legleg bootleg interpreter, juga babel ada karena suatu alasan. Dan terakhir, ES6 jauh lebih mudah dibaca jika Anda mengetahuinya. Yang mengatakan memberikan jawaban JS standar dapat membantu lebih banyak orang tetapi mengingat ada jawaban lain untuk versi JS yang lebih tua, memiliki jawaban ES6 hanya menguntungkan, "ini adalah bagaimana saya melakukannya kembali pada hari" kata-kata kasar jelas tidak diperlukan.
WiR3D

Opini tidak membuat fakta, karena itu "argumen" Anda tidak valid. @ WiR3D
Hypersoft Systems

@HypersoftSystems sama validnya dengan milik Anda jika tidak lebih, karena milik Anda sama pendapatnya dan membatasi konteks pada konteks yang mungkin tidak valid di sebagian besar aplikasi modern.
WiR3D

kesalahan pengguna: "seperti pendapat", "mungkin" dan "sebagian besar".
Hypersoft Systems

9
function dec2hex(i)
{
  var result = "0000";
  if      (i >= 0    && i <= 15)    { result = "000" + i.toString(16); }
  else if (i >= 16   && i <= 255)   { result = "00"  + i.toString(16); }
  else if (i >= 256  && i <= 4095)  { result = "0"   + i.toString(16); }
  else if (i >= 4096 && i <= 65535) { result =         i.toString(16); }
  return result
}

1
+1 terima kasih! Saat bekerja dengan CSS, toString (16) penting agar Anda mendapatkan hasil seperti FF0000
Tyler Egeto

7
ketika bekerja dengan css (atau svg, yang menerima spesifikasi warna gaya css) Anda dapat menghindari seluruh masalah dengan menulis di color: rgb(r,g,b)mana rg dan b adalah angka desimal.
Telent

1
Seharusnya:function decimalToHexString(i) { var result = "00"; if (i >= 0 && i <= 15) { result += "000" + i.toString(16); } else if (i >= 16 && i <= 255) { result += "00" + i.toString(16); } else if (i >= 256 && i <= 4095) { result += "0" + i.toString(16); } else if (i >= 4096 && i <= 65535) { result += i.toString(16); } return result }
Aykut Çevik

9

Jika Anda ingin mengonversi angka menjadi representasi heksadesimal dari nilai warna RGBA, saya telah menemukan ini sebagai kombinasi paling berguna dari beberapa tips dari sini:

function toHexString(n) {
    if(n < 0) {
        n = 0xFFFFFFFF + n + 1;
    }
    return "0x" + ("00000000" + n.toString(16).toUpperCase()).substr(-8);
}

8

Komentar AFAIK 57807 salah dan harus seperti: var hex = Number (d) .toString (16); bukannya var hex = parseInt (d, 16);

function decimalToHex(d, padding) {
    var hex = Number(d).toString(16);
    padding = typeof (padding) === "undefined" || padding === null ? padding = 2 : padding;

    while (hex.length < padding) {
        hex = "0" + hex;
    }

    return hex;
}

6

Dan apakah angkanya negatif?

Ini versi saya.

function hexdec (hex_string) {
    hex_string=((hex_string.charAt(1)!='X' && hex_string.charAt(1)!='x')?hex_string='0X'+hex_string : hex_string);
    hex_string=(hex_string.charAt(2)<8 ? hex_string =hex_string-0x00000000 : hex_string=hex_string-0xFFFFFFFF-1);
    return parseInt(hex_string, 10);
}

5

Saya melakukan konversi ke string hex dalam loop yang cukup besar, jadi saya mencoba beberapa teknik untuk menemukan yang tercepat. Persyaratan saya adalah untuk memiliki string tetap-panjang sebagai hasilnya, dan menyandikan nilai negatif dengan benar (-1 => ff..f).

Sederhana .toString(16)tidak bekerja untuk saya karena saya membutuhkan nilai negatif untuk dikodekan dengan benar. Kode berikut adalah yang tercepat yang telah saya uji sejauh ini pada nilai 1-2 byte (perhatikan bahwa symbolsmendefinisikan jumlah simbol output yang ingin Anda dapatkan, yaitu untuk integer 4-byte harus sama dengan 8):

var hex = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
function getHexRepresentation(num, symbols) {
    var result = '';
    while (symbols--) {
        result = hex[num & 0xF] + result;
        num >>= 4;
    }
    return result;
}

Ia melakukan lebih cepat daripada .toString(16)pada angka 1-2 byte dan lebih lambat pada angka yang lebih besar (ketika symbols> = 6), tetapi masih harus mengungguli metode yang menyandikan nilai negatif dengan benar.


5

Seperti yang dinyatakan dalam jawaban yang diterima, cara termudah untuk mengkonversi dari desimal ke heksadesimal adalah var hex = dec.toString(16). Namun, Anda mungkin lebih suka menambahkan konversi string, karena memastikan bahwa representasi string suka "12".toString(16)bekerja dengan benar.

// Avoids a hard-to-track-down bug by returning `c` instead of `12`
(+"12").toString(16);

Untuk membalikkan proses Anda juga dapat menggunakan solusi di bawah ini, karena lebih pendek.

var dec = +("0x" + hex);

Tampaknya lebih lambat di Google Chrome dan Firefox, tetapi secara signifikan lebih cepat di Opera. Lihat http://jsperf.com/hex-to-dec .


5

Bagaimana mengkonversi desimal ke heksadesimal dalam JavaScript

Saya tidak dapat menemukan konversi desimal ke heksadesimal brutal yang bersih / sederhana yang tidak melibatkan kekacauan fungsi dan array ... jadi saya harus membuat ini untuk diri saya sendiri.

function DecToHex(decimal) { // Data (decimal)

    length = -1;    // Base string length
    string = '';    // Source 'string'

    characters = [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' ]; // character array

    do { // Grab each nibble in reverse order because JavaScript has no unsigned left shift

        string += characters[decimal & 0xF];   // Mask byte, get that character
        ++length;                              // Increment to length of string

    } while (decimal >>>= 4); // For next character shift right 4 bits, or break on 0

    decimal += 'x'; // Convert that 0 into a hex prefix string -> '0x'

    do
        decimal += string[length];
    while (length--); // Flip string forwards, with the prefixed '0x'

    return (decimal); // return (hexadecimal);
}

/* Original: */

D = 3678;    // Data (decimal)
C = 0xF;    // Check
A = D;        // Accumulate
B = -1;        // Base string length
S = '';        // Source 'string'
H = '0x';    // Destination 'string'

do {
    ++B;
    A& = C;

    switch(A) {
        case 0xA: A='A'
        break;

        case 0xB: A='B'
        break;

        case 0xC: A='C'
        break;

        case 0xD: A='D'
        break;

        case 0xE: A='E'
        break;

        case 0xF: A='F'
        break;

        A = (A);
    }
    S += A;

    D >>>= 0x04;
    A = D;
} while(D)

do
    H += S[B];
while (B--)

S = B = A = C = D; // Zero out variables
alert(H);    // H: holds hexadecimal equivalent

5
Oh my ... ini adalah cara yang sangat mengerikan, mengerikan untuk melakukan ini, dilakukan dengan gaya pengkodean yang bahkan lebih buruk. Jujur: apa yang salah dengan jeda baris dan indentasi? Variabel huruf tunggal? Betulkah?
Victor Schröder

1
Revisi itu. Apakah ini mengerikan? Dan apakah gayanya lebih baik ?? Saya awalnya berpikir akan lebih mudah untuk memahami dengan setiap langkah "secara harfiah" dijabarkan seperti itu dengan surat ... kadang-kadang saya bisa sangat bodoh
JonLikeSquirrel

4
Maaf ya, masih mengerikan. Kode Anda masih menggunakan banyak loop tidak efisien dan mencemari namespace global, di antara masalah lain. Pendekatan itu sendiri berlebihan untuk tugas yang dapat diselesaikan dengan pemanggilan fungsi sederhana. Jika Anda ingin meningkatkan gaya pengkodean dalam JS, saya sangat menyarankan Anda membaca materi seperti w3.org/wiki/JavaScript_best_practices dan google.github.io/styleguide/javascriptguide.xml . Hanya google tentang subjek.
Victor Schröder

1
Saya melakukan tes kecepatan di Chrome dan fungsi kerja keras saya sekitar 30% lebih cepat daripada .toString (16), sementara di Firefox fungsi saya 40% lebih lambat daripada .toString (16) ... Chrome membuktikan bahwa loop saya yang berlebihan lebih efisien daripada fungsi .toString (16) browser asli, sementara Firefox membuktikan mengapa lebih banyak orang lebih menyukai Chrome. Atau apakah itu mundur ?? Suatu hari Chrome bahkan dapat memperbarui ke .toString (16) yang lebih cepat membuat saya salah dalam kedua kasus! Either way aku tidak sepenuhnya salah, dan kamu tidak sepenuhnya benar. Selain ego saya, saya mendapatkan poin Anda setidaknya 30% dari itu. ;)
JonLikeSquirrel

2
Anda tidak perlu mendeklarasikan array string yang masing-masing berisi karakter tunggal. Hanya mendeklarasikan string karakter. Anda bisa mendapatkan karakter dari string seperti halnya menggunakan array, dengan menggunakan tanda kurung.
David Spector

3

Singkatnya semuanya;

function toHex(i, pad) {

  if (typeof(pad) === 'undefined' || pad === null) {
    pad = 2;
  } 

  var strToParse = i.toString(16);

  while (strToParse.length < pad) {
    strToParse = "0" + strToParse;
  }

  var finalVal =  parseInt(strToParse, 16);

  if ( finalVal < 0 ) {
    finalVal = 0xFFFFFFFF + finalVal + 1;
  }

  return finalVal;
}

Namun, jika Anda tidak perlu mengubahnya kembali ke integer di akhir (yaitu untuk warna), maka pastikan nilainya tidak negatif sudah cukup.


2

Saya belum menemukan jawaban yang jelas, tanpa cek apakah itu negatif atau positif, yang menggunakan komplemen dua (termasuk angka negatif). Untuk itu, saya menunjukkan solusi saya ke satu byte:

((0xFF + number +1) & 0x0FF).toString(16);

Anda dapat menggunakan instruksi ini untuk sejumlah byte, hanya Anda tambahkan FFdi tempat masing-masing. Misalnya, menjadi dua byte:

((0xFFFF + number +1) & 0x0FFFF).toString(16);

Jika Anda ingin melemparkan integer array ke string heksadesimal:

s = "";
for(var i = 0; i < arrayNumber.length; ++i) {
    s += ((0xFF + arrayNumber[i] +1) & 0x0FF).toString(16);
}

2

Jika Anda ingin mengonversi ke representasi JavaScript atau CSS 'lengkap', Anda dapat menggunakan sesuatu seperti:

  numToHex = function(num) {
    var r=((0xff0000&num)>>16).toString(16),
        g=((0x00ff00&num)>>8).toString(16),
        b=(0x0000ff&num).toString(16);
    if (r.length==1) { r = '0'+r; }
    if (g.length==1) { g = '0'+g; }
    if (b.length==1) { b = '0'+b; }
    return '0x'+r+g+b;                 // ('#' instead of'0x' for CSS)
  };

  var dec = 5974678;
  console.log( numToHex(dec) );        // 0x5b2a96

2

Anda dapat melakukan sesuatu seperti ini di ECMAScript 6 :

const toHex = num => (num).toString(16).toUpperCase();

1

Jika Anda mencari untuk mengonversi bilangan bulat Besar mis. Angka lebih besar dari Number.MAX_SAFE_INTEGER - 9007199254740991, maka Anda dapat menggunakan kode berikut

const hugeNumber = "9007199254740991873839" // Make sure its in String
const hexOfHugeNumber = BigInt(hugeNumber).toString(16);
console.log(hexOfHugeNumber)


1

Ini didasarkan pada solusi Prestaul dan Tod. Namun, ini adalah generalisasi yang memperhitungkan ukuran variabel yang bervariasi (mis. Parsing nilai yang ditandatangani dari log serial mikrokontroler).

function decimalToPaddedHexString(number, bitsize)
{ 
  let byteCount = Math.ceil(bitsize/8);
  let maxBinValue = Math.pow(2, bitsize)-1;

  /* In node.js this function fails for bitsize above 32bits */
  if (bitsize > 32)
    throw "number above maximum value";

  /* Conversion to unsigned form based on  */
  if (number < 0)
    number = maxBinValue + number + 1;

  return "0x"+(number >>> 0).toString(16).toUpperCase().padStart(byteCount*2, '0');
}

Skrip uji:

for (let n = 0 ; n < 64 ; n++ ) { 
     let s=decimalToPaddedHexString(-1, n); 
     console.log(`decimalToPaddedHexString(-1,${(n+"").padStart(2)}) = ${s.padStart(10)} = ${("0b"+parseInt(s).toString(2)).padStart(34)}`);
   }

Hasil tes:

decimalToPaddedHexString(-1, 0) =        0x0 =                                0b0
decimalToPaddedHexString(-1, 1) =       0x01 =                                0b1
decimalToPaddedHexString(-1, 2) =       0x03 =                               0b11
decimalToPaddedHexString(-1, 3) =       0x07 =                              0b111
decimalToPaddedHexString(-1, 4) =       0x0F =                             0b1111
decimalToPaddedHexString(-1, 5) =       0x1F =                            0b11111
decimalToPaddedHexString(-1, 6) =       0x3F =                           0b111111
decimalToPaddedHexString(-1, 7) =       0x7F =                          0b1111111
decimalToPaddedHexString(-1, 8) =       0xFF =                         0b11111111
decimalToPaddedHexString(-1, 9) =     0x01FF =                        0b111111111
decimalToPaddedHexString(-1,10) =     0x03FF =                       0b1111111111
decimalToPaddedHexString(-1,11) =     0x07FF =                      0b11111111111
decimalToPaddedHexString(-1,12) =     0x0FFF =                     0b111111111111
decimalToPaddedHexString(-1,13) =     0x1FFF =                    0b1111111111111
decimalToPaddedHexString(-1,14) =     0x3FFF =                   0b11111111111111
decimalToPaddedHexString(-1,15) =     0x7FFF =                  0b111111111111111
decimalToPaddedHexString(-1,16) =     0xFFFF =                 0b1111111111111111
decimalToPaddedHexString(-1,17) =   0x01FFFF =                0b11111111111111111
decimalToPaddedHexString(-1,18) =   0x03FFFF =               0b111111111111111111
decimalToPaddedHexString(-1,19) =   0x07FFFF =              0b1111111111111111111
decimalToPaddedHexString(-1,20) =   0x0FFFFF =             0b11111111111111111111
decimalToPaddedHexString(-1,21) =   0x1FFFFF =            0b111111111111111111111
decimalToPaddedHexString(-1,22) =   0x3FFFFF =           0b1111111111111111111111
decimalToPaddedHexString(-1,23) =   0x7FFFFF =          0b11111111111111111111111
decimalToPaddedHexString(-1,24) =   0xFFFFFF =         0b111111111111111111111111
decimalToPaddedHexString(-1,25) = 0x01FFFFFF =        0b1111111111111111111111111
decimalToPaddedHexString(-1,26) = 0x03FFFFFF =       0b11111111111111111111111111
decimalToPaddedHexString(-1,27) = 0x07FFFFFF =      0b111111111111111111111111111
decimalToPaddedHexString(-1,28) = 0x0FFFFFFF =     0b1111111111111111111111111111
decimalToPaddedHexString(-1,29) = 0x1FFFFFFF =    0b11111111111111111111111111111
decimalToPaddedHexString(-1,30) = 0x3FFFFFFF =   0b111111111111111111111111111111
decimalToPaddedHexString(-1,31) = 0x7FFFFFFF =  0b1111111111111111111111111111111
decimalToPaddedHexString(-1,32) = 0xFFFFFFFF = 0b11111111111111111111111111111111
Thrown: 'number above maximum value'

Catatan: Tidak terlalu yakin mengapa gagal di atas 32 bitsize


-3

Inilah solusi saya:

hex = function(number) {
  return '0x' + Math.abs(number).toString(16);
}

Pertanyaannya mengatakan: "Bagaimana mengkonversi desimal ke heksadesimal dalam JavaScript" . Sementara, pertanyaan tidak menentukan bahwa string heksadesimal harus dimulai dengan awalan 0x, siapa pun yang menulis kode harus tahu bahwa 0x ditambahkan ke kode heksadesimal untuk membedakan kode heksadesimal dari pengidentifikasi programatik dan angka lainnya (1234 dapat berupa heksadesimal, desimal, atau bahkan oktal).

Oleh karena itu, untuk menjawab pertanyaan ini dengan benar, untuk tujuan penulisan skrip, Anda harus menambahkan awalan 0x.

Fungsi Math.abs (N) mengubah negatif menjadi positif, dan sebagai bonus, itu tidak terlihat seperti seseorang menjalankannya melalui chipper kayu.

Jawaban yang saya inginkan, akan memiliki specifier lebar bidang, jadi kita bisa misalnya menunjukkan nilai 8/16/32/64-bit seperti yang Anda lihat dalam daftar aplikasi pengeditan heksadesimal. Itu, adalah jawaban yang sebenarnya dan benar.


1
Dalam praktik pengkodean umum, urutan alfa-numerik yang dimulai dengan huruf, BUKAN NOMOR. Sebagai contoh: ABCDEF012345678 adalah pengidentifikasi yang valid di hampir setiap bahasa pengkodean di planet ini.
Hypersoft Systems

1
Oh, dan awalan 0x bukan masalah untuk javascript: Number('0xFF') === 255;untuk semua orang di luar sana yang menginginkan operasi terbalik.
Hypersoft Systems
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.