dechex
Returns a string containing a hexadecimal representation of the given unsigned num argument.
The largest number that can be converted is PHP_INT_MAX * 2 + 1 (or -1 ): on 32-bit platforms, this will be 4294967295 in decimal, which results in dechex() returning ffffffff .
Parameters
The decimal value to convert.
As PHP’s int type is signed, but dechex() deals with unsigned integers, negative integers will be treated as though they were unsigned.
Return Values
Hexadecimal string representation of num .
Examples
Example #1 dechex() example
The above example will output:
Example #2 dechex() example with large integers
// The output below assumes a 32-bit platform.
// Note that the output is the same for all values.
echo dechex (- 1 ). «\n» ;
echo dechex ( PHP_INT_MAX * 2 + 1 ). «\n» ;
echo dechex ( pow ( 2 , 32 ) — 1 ). «\n» ;
?>
The above example will output:
ffffffff ffffffff ffffffff
See Also
- hexdec() — Hexadecimal to decimal
- decbin() — Decimal to binary
- decoct() — Decimal to octal
- base_convert() — Convert a number between arbitrary bases
User Contributed Notes 34 notes
Be very careful calling dechex on a number if it’s stored in a string.
The max number it can handle is 4294967295 which in hex is FFFFFFFF, as it says in the documentation.
dechex(4294967295) => FFFFFFFF //CORRECT
BUT, if you call it on a string of a number, it casts to int, and automatically gives you the largest int it can handle.
dechex(‘4294967295’) => 7FFFFFFF //WRONG!
so you’ll need to cast to a float:
dechex((float) ‘4294967295’) => FFFFFFFF //CORRECT
This took me FOREVER to figure out, so hopefully I just saved someone some time.
Here are two functions that will convert large dec numbers to hex and vice versa. And I really mean LARGE, much larger than any function posted earlier.
// Input: A decimal number as a String.
// Output: The equivalent hexadecimal number as a String.
function dec2hex($number)
$hexvalues = array(‘0′,’1′,’2′,’3′,’4′,’5′,’6′,’7’,
‘8’,’9′,’A’,’B’,’C’,’D’,’E’,’F’);
$hexval = »;
while($number != ‘0’)
$hexval = $hexvalues[bcmod($number,’16’)].$hexval;
$number = bcdiv($number,’16’,0);
>
return $hexval;
>
// Input: A hexadecimal number as a String.
// Output: The equivalent decimal number as a String.
function hex2dec($number)
$decvalues = array(‘0’ => ‘0’, ‘1’ => ‘1’, ‘2’ => ‘2’,
‘3’ => ‘3’, ‘4’ => ‘4’, ‘5’ => ‘5’,
‘6’ => ‘6’, ‘7’ => ‘7’, ‘8’ => ‘8’,
‘9’ => ‘9’, ‘A’ => ’10’, ‘B’ => ’11’,
‘C’ => ’12’, ‘D’ => ’13’, ‘E’ => ’14’,
‘F’ => ’15’);
$decval = ‘0’;
$number = strrev($number);
for($i = 0; $i < strlen($number); $i++)
$decval = bcadd(bcmul(bcpow(’16’,$i,0),$decvalues[$number]), $decval);
>
return $decval;
>
A less elegant but (perhaps) faster way to pad is with substr with a negative length argument. I use it in this tiny function which formats computed rgb color codes for style sheets:
function toColor($n)
return(«#».substr(«000000».dechex($n),-6));
>
?>
Easiest 😛 way to create random hex color:
function rand_color () return substr ( ‘00000’ . dechex ( mt_rand ( 0 , 0xffffff )), — 6 );
>
?>
Here is a very small zeropadding that you can use for numbers:
function zeropad($num, $lim)
return (strlen($num) >= $lim) ? $num : zeropad(«0» . $num);
>
I was challenged by a problem with large number calculations and conversion to hex within php. The calculation exceeded unsigned integer and even float range. You can easily change it for your needs but it is, thanks to bcmath, capable of handling big numbers via string. This function will convert them to hex.
In this specific example though, since I use it for game internals that can only handle 32 bit numbers, it will truncate calculations at 8 digits. If the input is 1 for example it will be filled up with zeros. Output 00000001h.
Of course I don’t claim it to be a good one, but it works for me and my purpose. Suggestions on faster code welcome!
// Turns numbers into 32-bit hex string; Fills up zeros
function lrgDec2Hex ( $number )
<
$i = 0 ;
$hex = array();
while( $i < 8 ) <
if( $number == 0 ) <
array_push ( $hex , ‘0’ );
>
else <
array_push ( $hex , strtoupper ( dechex ( bcmod ( $number , ’16’ ))));
$number = bcdiv ( $number , ’16’ , 0 );
>
$i ++;
>
krsort ( $hex );
return implode ( $hex );
>
?>
If you need to generate random HEX-color, use this:
function random_hex_color () return sprintf ( «%02X%02X%02X» , mt_rand ( 0 , 255 ), mt_rand ( 0 , 255 ), mt_rand ( 0 , 255 ));
>
$hex = random_hex_color (); // 09B826
?>
Enjoy.
I was confused by dechex’s size limitation. Here is my solution to the problem. It supports much bigger values, as well as signs.
function dec_to_hex ( $dec )
<
$sign = «» ; // suppress errors
if( $dec
$hex = Array( 0 => 0 , 1 => 1 , 2 => 2 , 3 => 3 , 4 => 4 , 5 => 5 ,
6 => 6 , 7 => 7 , 8 => 8 , 9 => 9 , 10 => ‘a’ ,
11 => ‘b’ , 12 => ‘c’ , 13 => ‘d’ , 14 => ‘e’ ,
15 => ‘f’ );
do
<
$h = $hex [( $dec % 16 )] . $h ;
$dec /= 16 ;
>
while( $dec >= 1 );
If you need to convert a large number (> PHP_MAX_INT) to a hex value, simply use base_convert. For example:
base_convert(‘2190964402’, 10, 16); // 829776b2
Here’s how to use bitwise operations for RGB2hex conversion. This function returns hexadesimal rgb value just like one submitted by gurke@bigfoot.com above.
miguelmota / util.php
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters. Learn more about bidirectional Unicode characters
| function string2ByteArray ( $ string ) |
| return unpack( ‘C*’ , $ string ); |
| > |
| function byteArray2String ( $ byteArray ) |
| $ chars = array_map(» chr «, $ byteArray ); |
| return join( $ chars ); |
| > |
| function byteArray2Hex ( $ byteArray ) |
| $ chars = array_map(» chr «, $ byteArray ); |
| $ bin = join( $ chars ); |
| return bin2hex( $ bin ); |
| > |
| function hex2ByteArray ( $ hexString ) |
| $ string = hex2bin( $ hexString ); |
| return unpack( ‘C*’ , $ string ); |
| > |
| function string2Hex ( $ string ) |
| return bin2hex( $ string ); |
| > |
| function hex2String ( $ hexString ) |
| return hex2bin( $ hexString ); |
| > |
| ?> |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters. Learn more about bidirectional Unicode characters
| include ( ‘./util.php’ ); |
| $ byteArray = unpack( ‘C*’ , ‘hello’ ); |
| assert(string2ByteArray( ‘hello’ ) == $ byteArray ); |
| assert(byteArray2String( $ byteArray ) == ‘hello’ ); |
| assert(byteArray2Hex( $ byteArray ) == ‘68656c6c6f’ ); |
| assert(hex2ByteArray( ‘68656c6c6f’ ) == $ byteArray ); |
| assert(string2Hex( ‘hello’ ) == ‘68656c6c6f’ ); |
| assert(hex2String( ‘68656c6c6f’ ) == ‘hello’ ); |
| ?> |
bin2hex
Returns an ASCII string containing the hexadecimal representation of string . The conversion is done byte-wise with the high-nibble first.
Parameters
Return Values
Returns the hexadecimal representation of the given string.
Examples
Example #1 bin2hex() example
$hex = bin2hex ( ‘Hello world!’ );
var_dump ( $hex );
var_dump ( hex2bin ( $hex ));
?>
The above example will output:
string(24) "48656c6c6f20776f726c6421" string(12) "Hello world!"
See Also
User Contributed Notes 6 notes
This function is for converting binary data into a hexadecimal string representation. This function is not for converting strings representing binary digits into hexadecimal. If you want that functionality, you can simply do this:
$binary = «11111001» ;
$hex = dechex ( bindec ( $binary ));
echo $hex ;
?>
This would output «f9». Just remember that there is a very big difference between binary data and a string representation of binary.
A good option for creating strings with binary data for saving (for example saving an sql statement to a file) into text files or php code is to do the following:
$field = bin2hex ( $field );
$field = chunk_split ( $field , 2 , «\\x» );
$field = «\\x» . substr ( $field , 0 ,- 2 );
?>
this will convert your field (binary or not) into hex and then convert the hex into a string which may be placed in a php file:
Convenient way of generating API keys
$apikey = bin2hex ( random_bytes ( 32 )); // generates 64 characters long string /^[0-9a-f]$/
?>
In an attempt to dodge spam bots I’ve seen people (including myself) hex encode their email addresses in «mailto» tags. This is the small chunk of code I wrote to automate the process:
would produce the following address:
%70%65%64%72%61%6d%40%72%65%64%68%69%76%65%2e%63%6f%6d
I was just browsing the above and with a little modification,
came up with the following which I believe to be more flexible:
function bin2hex ( $data ) <
$corrected = ereg_replace ( «[^0-9a-fA-F]» , «» , $data );
return pack ( «H» . strlen ( $corrected ), $corrected );
>
?>
This will make sure that whatever you pass, even if it is padded
at the extremeties or between pairs, should return the desired data.
Here’s a function to check if a string contains any 7-bit GSM characters.
It might come useful for people working on SMS platforms.
function check_gsm ( $str )
<
$arr = array(
«0x00» , «0x01» , «0x02» , «0x03» , «0x04» , «0x05» , «0x06» , «0x07» , «0x08» , «0x09» ,
«0x0A» , «0x0B» , «0x0C» , «0x0D» , «0x0E» , «0x0F» , «0x10» , «0x11» , «0x12» , «0x13» ,
«0x14» , «0x15» , «0x16» , «0x17» , «0x18» , «0x19» , «0x1A» , «0x1B» , «0x1B0A» ,
«0x1B14» , «0x1B28» , «0x1B29» , «0x1B2F» , «0x1B3C» , «0x1B3D» , «0x1B3E» ,
«0x1B40» , «0x1B65» , «0x1C» , «0x1D» , «0x1E» , «0x1F» , «0x20» , «0x21» , «0x22» ,
«0x23» , «0x24» , «0x25» , «0x26» , «0x27» , «0x28» , «0x29» , «0x2A» , «0x2B» , «0x2C» ,
«0x2D» , «0x2E» , «0x2F» , «0x30» , «0x31» , «0x32» , «0x33» , «0x34» , «0x35» , «0x36» ,
«0x37» , «0x38» , «0x39» , «0x3A» , «0x3B» , «0x3C» , «0x3D» , «0x3E» , «0x3F» , «0x40» ,
«0x41» , «0x42» , «0x43» , «0x44» , «0x45» , «0x46» , «0x47» , «0x48» , «0x49» , «0x4A» ,
«0x4B» , «0x4C» , «0x4D» , «0x4E» , «0x4F» , «0x50» , «0x51» , «0x52» , «0x53» , «0x54» ,
«0x55» , «0x56» , «0x57» , «0x58» , «0x59» , «0x5A» , «0x5B» , «0x5C» , «0x5D» , «0x5E» ,
«0x5F» , «0x60» , «0x61» , «0x62» , «0x63» , «0x64» , «0x65» , «0x66» , «0x67» , «0x68» ,
«0x69» , «0x6A» , «0x6B» , «0x6C» , «0x6D» , «0x6E» , «0x6F» , «0x70» , «0x71» , «0x72» ,
«0x73» , «0x74» , «0x75» , «0x76» , «0x77» , «0x78» , «0x79» , «0x7A» , «0x7B» , «0x7C» ,
«0x7D» , «0x7E» , «0x7F» );
$strl = strlen ( $str );
for ( $i = 0 ; $i < $strl ; $i ++)
<
$char = ‘0x’ . bin2hex ( substr ( $str , $i , 1 ));
$pos = in_array ( $char , $arr );
if ( $pos == 1 )
<
$j ++;
>
>
sashabeton / util.php
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters. Learn more about bidirectional Unicode characters
| function string2ByteArray ( $ string ) |
| return unpack( ‘C*’ , $ string ); |
| > |
| function byteArray2String ( $ byteArray ) |
| $ chars = array_map(» chr «, $ byteArray ); |
| return join( $ chars ); |
| > |
| function byteArray2Hex ( $ byteArray ) |
| $ chars = array_map(» chr «, $ byteArray ); |
| $ bin = join( $ chars ); |
| return bin2hex( $ bin ); |
| > |
| function hex2ByteArray ( $ hexString ) |
| $ string = hex2bin( $ hexString ); |
| return unpack( ‘C*’ , $ string ); |
| > |
| function string2Hex ( $ string ) |
| return bin2hex( $ string ); |
| > |
| function hex2String ( $ hexString ) |
| return hex2bin( $ hexString ); |
| > |
| ?> |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters. Learn more about bidirectional Unicode characters
| include ( ‘./util.php’ ); |
| $ byteArray = unpack( ‘C*’ , ‘hello’ ); |
| assert(string2ByteArray( ‘hello’ ) == $ byteArray ); |
| assert(byteArray2String( $ byteArray ) == ‘hello’ ); |
| assert(byteArray2Hex( $ byteArray ) == ‘68656c6c6f’ ); |
| assert(hex2ByteArray( ‘68656c6c6f’ ) == $ byteArray ); |
| assert(string2Hex( ‘hello’ ) == ‘68656c6c6f’ ); |
| assert(hex2String( ‘68656c6c6f’ ) == ‘hello’ ); |
| ?> |