bindec

(PHP 4, PHP 5, PHP 7)

bindec — 二进制转换为十进制

说明

bindec ( string $binary_string ) : number

返回 binary_string 参数所表示的二进制数的十进制等价值。

bindec() 将一个二进制数转换成 integer，或者出于大小的需要，转换为 float 类型。

bindec() 将所有的 binary_string 值解释为无符号整数。这是由于 bindec() 函数将其最高有效位视为数量级而非符号位。

参数

binary_string

要转换的二进制字符串

Warning

参数必须为字符串。使用其他数据类型会导致不可预知的结果。

返回值

binary_string 的十进制数值

更新日志

版本 说明
4.1.0 本函数如今可以转换超过程序运行平台中 integer 类型最大值的数，此时其值会返回为 float 类型。

范例

Example #1 bindec() 例子

<?php
echo bindec('110011') . "\n";
echo bindec('000110011') . "\n";

echo bindec('111');
?>

以上例程会输出：

51
51
7

Example #2 bindec() 将输入解读为无符号整数

<?php
/*
 * The lesson from this example is in the output
 * rather than the PHP code itself.
 */

$magnitude_lower = pow(2, (PHP_INT_SIZE * 8) - 2);
p($magnitude_lower - 1);
p($magnitude_lower, 'See the rollover?  Watch it next time around...');

p(PHP_INT_MAX, 'PHP_INT_MAX');
p(~PHP_INT_MAX, 'interpreted to be one more than PHP_INT_MAX');

if (PHP_INT_SIZE == 4) {
    $note = 'interpreted to be the largest unsigned integer';
} else {
    $note = 'interpreted to be the largest unsigned integer
              (18446744073709551615) but skewed by float precision';
}
p(-1, $note);


function p($input, $note = '') {
    echo "input:        $input\n";

    $format = '%0' . (PHP_INT_SIZE * 8) . 'b';
    $bin = sprintf($format, $input);
    echo "binary:       $bin\n";

    ini_set('precision', 20);  // For readability on 64 bit boxes.
    $dec = bindec($bin);
    echo 'bindec():     ' . $dec . "\n";

    if ($note) {
        echo "NOTE:         $note\n";
    }

    echo "\n";
}
?>

以上例程在 32 位机器上的输出:

input:        1073741823
binary:       00111111111111111111111111111111
bindec():     1073741823

input:        1073741824
binary:       01000000000000000000000000000000
bindec():     1073741824
NOTE:         See the rollover?  Watch it next time around...

input:        2147483647
binary:       01111111111111111111111111111111
bindec():     2147483647
NOTE:         PHP_INT_MAX

input:        -2147483648
binary:       10000000000000000000000000000000
bindec():     2147483648
NOTE:         interpreted to be one more than PHP_INT_MAX

input:        -1
binary:       11111111111111111111111111111111
bindec():     4294967295
NOTE:         interpreted to be the largest unsigned integer

以上例程在 64 位机器上的输出:

input:        4611686018427387903
binary:       0011111111111111111111111111111111111111111111111111111111111111
bindec():     4611686018427387903

input:        4611686018427387904
binary:       0100000000000000000000000000000000000000000000000000000000000000
bindec():     4611686018427387904
NOTE:         See the rollover?  Watch it next time around...

input:        9223372036854775807
binary:       0111111111111111111111111111111111111111111111111111111111111111
bindec():     9223372036854775807
NOTE:         PHP_INT_MAX

input:        -9223372036854775808
binary:       1000000000000000000000000000000000000000000000000000000000000000
bindec():     9223372036854775808
NOTE:         interpreted to be one more than PHP_INT_MAX

input:        -1
binary:       1111111111111111111111111111111111111111111111111111111111111111
bindec():     18446744073709551616
NOTE:         interpreted to be the largest unsigned integer
              (18446744073709551615) but skewed by float precision

参见

User Contributed Notes

jpfstange at gmail dot com 09-Dec-2015 08:54
<?php

       //binfloat (For single precision floating point numbers)
       //IEE754
       //https://en.wikipedia.org/wiki/Single-precision_floating-point_format

        function binfloat(Array $num){

                $sign           =       $num[0] ? 1 : -1;                       //1 bit
                $exponent       =       pow(2,bindec(implode('',array_slice($num,1,8)))-127);
                $fraction       =       array_slice($num,9,count($num));        //23 bits
                $fracSum        =       1;

                for($i=0;$i<23;$i++){

                        $fracSum += $fraction[$i] * pow(2,-1-$i);

                }

                return $fracSum*$exponent;

        }

        $num    =       isset($_GET['num']) ? $_GET['num'] : '00111110001000000000000000000000';

        if(strlen($num)<32){

                echo "Invalid binary number $num\n";
                exit(1);

        }

        $num    =       str_split($num);

        echo sprintf('Num is: [%s]%s',implode('',$num),"\n");
        echo sprintf('Result is: %s%s',binfloat($num),"\n");
patrick dot boens at latosensu dot be 15-Jul-2012 01:14
Left-shift a string by a number of bytes
<?php
function STR_shl( $szStr,$nBits )
/*-----------------------------*/
{
    if ( $nBits < 1 || $nBits > 7 )                                     /* If not adequate number of bits */
    {
        return ( $szStr );                                              /* Return the original string */
    }   /* if ( $nBits < 1 || $nBits > 7 ) */

    if ( ( $iLength = strlen( $szStr ) ) <= 0 )                         /* If string empty */
    {
        return ( $szStr );                                              /* Return the original string */
    }   /* if ( ( $iLength = strlen( $szStr ) ) <= 0 ) */

    $szRetVal   = '';                                                   /* Create an empty string */

    $szBits     = STR_Binary( $szStr );                                 /* $szStr in bits */
    $szLostBits = STR_Left( $szBits,$nBits );                           /* The $nBits leftmost bits of the string */
    $szShifted  = substr( $szBits,$nBits ) . $szLostBits;               /* $szStr left shifted */

    for ( $i = 0;$i < $iLength;$i++ )                                   /* Treat the entire string (per slice of 8 bits) */
    {
        $szRetVal .= chr( bindec( substr( $szShifted,$i * 8,8 ) ) );    /* Concatenate the CHR to the result string */
    }   /* for ( $i = 0;$i < $iLength;$i++ ) */

    return ( $szRetVal );                                               /* Return result to caller */
}
?>

Right-shift a string by a number of bytes
<?php

function STR_shr( $szStr,$nBits )
/*-----------------------------*/
{
    if ( $nBits < 1 || $nBits > 7 )                                     /* If not adequate number of bits */
    {
        return ( $szStr );                                              /* Return the original string */
    }   /* if ( $nBits < 1 || $nBits > 7 ) */

    if ( ( $iLength = strlen( $szStr ) ) <= 0 )                         /* If string empty */
    {
        return ( $szStr );                                              /* Return the original string */
    }   /* if ( ( $iLength = strlen( $szStr ) ) <= 0 ) */

    $szRetVal   = '';                                                   /* Create an empty string */

    $szBits     = STR_Binary( $szStr );                                 /* $szStr in bits */
    $szLostBits = STR_Right( $szBits,$nBits );                          /* The $nBits rightmost bits of the string */
    $szShifted  = $szLostBits . substr( $szBits,0,-$nBits );            /* $szStr right shifted */

    for ( $i = 0;$i < $iLength;$i++ )                                   /* Treat the entire string (per slice of 8 bits) */
    {
        $szRetVal .= chr( bindec( substr( $szShifted,$i * 8,8 ) ) );    /* Concatenate the CHR to the result string */
    }   /* for ( $i = 0;$i < $iLength;$i++ ) */

    return ( $szRetVal );                                               /* Return result to caller */
}
?>

Additional functions used by the two preceding:
<?php
function STR_Binary( $szStr )
/*-------------------------*/
{
    $szRetVal = '';                                                     /* Ready to return an empty string */

    if ( ( $iLength = strlen( $szStr ) ) > 0 )                          /* If string NOT empty */
    {
        for ( $i = 0; $i < $iLength;$i++ )                              /* Treat each character of the string */
        {
            $szRetVal .= sprintf( '%08b',ord( $szStr[$i] ) );           /* Turn this char to a binary representation (8 bits) */
        }   /* for ( $i = 0; $i < $iLength;$i++ ) */
    }   /* if ( ( $iLength = strlen( $szStr ) ) > 0 ) */

    return ( $szRetVal );                                               /* Return result to caller */
}

function STR_Left( $szStr,$iCount = 1 )
/*----------------------------------*/
{
    return substr( $szStr,0,$iCount );
}   /* End of function strleft() */

function STR_Right( $szString,$iCount )
/*----------------------------------*/
{
    return substr( $szString,0 + strlen( $szString ) - $iCount,$iCount );
}
?>
info at rickdg dot nl 01-Apr-2010 04:40
Two functions to convert 16bit or 8bit binary to integer using two's complement. If input exceeds maximum bits, false is returned. Function is easily scalable to x bits by changing the hexadecimals.

<?php function _bin16dec($bin) {
    // Function to convert 16bit binary numbers to integers using two's complement
    $num = bindec($bin);
    if($num > 0xFFFF) { return false; }
    if($num >= 0x8000) {
        return -(($num ^ 0xFFFF)+1);
    } else {
        return $num;
    }
}

function _bin8dec($bin) {
    // Function to convert 8bit binary numbers to integers using two's complement
    $num = bindec($bin);
    if($num > 0xFF) { return false; }
    if($num >= 0x80) {
        return -(($num ^ 0xFF)+1);
    } else {
        return $num;
    }
} ?>
Nitrogen 21-Jul-2009 07:27
Binary to Decimal conversion using the BCMath extension..

<?php

function BCBin2Dec($Input='') {
  $Output='0';
  if(preg_match("/^[01]+$/",$Input)) {
    for($i=0;$i<strlen($Input);$i++)
      $Output=BCAdd(BCMul($Output,'2'),$Input{$i});
  }
  return($Output);
}

?>

This will simply convert from Base-2 to Base-10 using BCMath (arbitrary precision calculation).

See also: my 'BCDec2Bin' function on the 'decbin' document.
Enjoy,
Nitrogen.
nodarinodo at mail dot ru 08-Jan-2009 11:51
<?php   
// bindecfunc :)))) I think it works well too :)
function bindecc($str)
    {
        $str = str_replace(" ", "", $str);
        $strr = preg_match('/[^01]/', $str);
        if($strr == 1) { return "<b> Error ! only 1 and 0;</b>"; }
        $strsig = strlen($str);
        $strr1 = strrev($str);
        $strf = '';
        for($i = $strsig; $i >= 0; $i--)
        {
            $strf += ($strr1[$i] * pow(2, $i));
            #$strf += $str[$i];
        }
        return $strf;
    }
?>
flashpack at gmail dot com 16-Nov-2008 04:40
for converting fractions :
eg : 1001.1101

<?php
function BinaryToDecimal($binary){
  $binary=trim($binary);
  if (strstr($binary,'.')){
    $split=explode('.',$binary);
    $integer=$split[0];
    $fraction=$split[1];

    $digits=str_split($fraction);
    $num=sizeof($digits);
    for ($i=1; $i<=$num;$i++){
      if ($digits[$i-1]>1){
        echo '<script>alert("Enter Binary Digits Only {0,1}\n \n eg: 11001 or 11001.011");history.go(-1)</script> ';
      }
      $exponent=pow(2,-$i);
      $fraction_result+=$digits[$i-1]*$exponent;
    }

  }else{
    $integer=$binary;
  }

  $splits=str_split($integer);
  $num=sizeof($splits)-1;
  $i=$num;
  foreach($splits as $digits){
    if ($digits>1){
      echo '<script>alert("Enter Binary Digits Only {0,1}\n \n eg: 11001 or 11001.011");history.go(-1)</script> ';
    }
    $exponent=pow(2,$i);
    $integer_result+=$digits*$exponent;
    $i--;
  }
  if($fraction_result){
    $result=$integer_result+$fraction_result;
  }else {
    $result=$integer_result;
  }
  return $result ;
}
?>
mashematician at gmail dot com 13-Mar-2008 08:57
A binary to decimal conversion function that takes advantage of the BC library functions to return decimal values of arbitrary length.

Input type must be a string in order to work properly.

<?php

function binary_to_decimal($a) {
    $bin_array = str_split($a);

    $y=sizeof($bin_array)-1;
    for ($x=0; $x<sizeof($bin_array)-1; $x++) {
        if ($bin_array[$x] == 1) {
            $bin_array[$x] = bcpow(2, $y);
        }
        $y--;
    }
   
    for ($z=0; $z<sizeof($bin_array); $z++) {
        $result = bcadd($result, $bin_array[$z]);
    }
    echo $result;
}

binary_to_decimal('11111');

?>
alan hogan dot com slash contact 09-Nov-2007 01:34
The "smartbindec" function I wrote below will convert any binary string (of a reasonable size) to decimal.  It will use two's complement if the leftmost bit is 1, regardless of bit length.  If you are getting unexpected negative answers, try zero-padding your strings with sprintf("%032s", $yourBitString).

<?php
function twoscomp($bin) {
    $out = "";
    $mode = "init";
    for($x = strlen($bin)-1; $x >= 0; $x--) {
        if ($mode != "init")
            $out = ($bin[$x] == "0" ? "1" : "0").$out;
        else {
            if($bin[$x] == "1") {
                $out = "1".$out;
                $mode = "invert";
            }
            else
                $out = "0".$out;
        }
    }
    return $out;
}
function smartbindec($bin) {
    if($bin[0] == 1)
        return -1 * bindec(twoscomp($bin));
    else return (int) bindec($bin);
}
?>
gwbdome at freenet dot de 19-Aug-2004 02:43
i think a better method than the "shift-method" is my method ^^...
here it comes:

function convert2bin($string) {
     $finished=0;
     $base=1;
     if(preg_match("/[^0-9]/", $string)) {
         for($i=0; $string!=chr($i); $i++);
         $dec_nr=$i;
     }
     else $dec_nr=$string;
     while($dec_nr>$base) {
         $base=$base*2;
         if($base>$dec_nr) {
             $base=$base/2;
             break;
         }
     }
     while(!$finished) {
         if(($dec_nr-$base)>0) {
             $dec_nr=$dec_nr-$base;
             $bin_nr.=1;
             $base=$base/2;
         }
         elseif(($dec_nr-$base)<0) {
             $bin_nr.=0;
             $base=$base/2;
         }
         elseif(($dec_nr-$base)==0) {
             $bin_nr.=1;
             $finished=1;
             while($base>1) {   
                 $bin_nr.=0;
                 $base=$base/2;
             }
         }
     }
     return $bin_nr;
 }

=====================================================

if you want to reconvert it (from binary to string or integer) you can use this function:

function reconvert($bin_nr) {
     $base=1;
     $dec_nr=0;
     $bin_nr=explode(",", preg_replace("/(.*),/", "$1", str_replace("1", "1,", str_replace("0", "0,", $bin_nr))));
     for($i=1; $i<count($bin_nr); $i++) $base=$base*2;
     foreach($bin_nr as $key=>$bin_nr_bit) {
         if($bin_nr_bit==1) {
             $dec_nr+=$base;
             $base=$base/2;
         }
         if($bin_nr_bit==0) $base=$base/2;
     }
     return(array("string"=>chr($dec_nr), "int"=>$dec_nr));
 }
martin at punix dot de 29-May-2003 10:47
## calculate binary with "shift-method" ##

<?php
function dec2bin($decimal_code){
 for($half=($decimal_code);$half>=1;$half=(floor($half))/2){
   if(($half%2)!=0){
    $y.=1;
   }
   else{
    $y.=0;
   }
  }
 $calculated_bin=strrev($y);
 return $calculated_bin;
}
?>

## example ##

[bin] 123 = [dec] 1111011

e.g.
123/2 = 61,5 => 1
61/2  = 30,5 => 1
30/2  = 15   => 0
15/2  = 7,5  => 1
7/2   = 3,5  => 1
3/2   = 1,5  => 1
1/2   = 0,5  => 1
(0/2   = 0    finish)