Delicious Bookmark this on Delicious Share on Facebook SlashdotSlashdot It! Digg! Digg

PHP : Function Reference : String Functions : sprintf


Return a formatted string (PHP 4, PHP 5)
string sprintf ( string format [, mixed args [, mixed ...]] )

Returns a string produced according to the formatting string format.



The format string is composed of zero or more directives: ordinary characters (excluding %) that are copied directly to the result, and conversion specifications, each of which results in fetching its own parameter. This applies to both sprintf() and printf().

Each conversion specification consists of a percent sign (%), followed by one or more of these elements, in order:

  1. An optional sign specifier that forces a sign (- or +) to be used on a number. By default, only the - sign is used on a number if it's negative. This specifier forces positive numbers to have the + sign attached as well, and was added in PHP 4.3.0.
  2. An optional padding specifier that says what character will be used for padding the results to the right string size. This may be a space character or a 0 (zero character). The default is to pad with spaces. An alternate padding character can be specified by prefixing it with a single quote ('). See the examples below.
  3. An optional alignment specifier that says if the result should be left-justified or right-justified. The default is right-justified; a - character here will make it left-justified.
  4. An optional number, a width specifier that says how many characters (minimum) this conversion should result in.
  5. An optional precision specifier that says how many decimal digits should be displayed for floating-point numbers. When using this specifier on a string, it acts as a cutoff point, setting a maximum character limit to the string.
  6. A type specifier that says what type the argument data should be treated as. Possible types:

    % - a literal percent character. No argument is required.
    b - the argument is treated as an integer, and presented as a binary number.
    c - the argument is treated as an integer, and presented as the character with that ASCII value.
    d - the argument is treated as an integer, and presented as a (signed) decimal number.
    e - the argument is treated as scientific notation (e.g. 1.2e+2). The precision specifier stands for the number of digits after the decimal point since PHP 5.2.1. In earlier versions, it was taken as number of significant digits (one less).
    u - the argument is treated as an integer, and presented as an unsigned decimal number.
    f - the argument is treated as a float, and presented as a floating-point number (locale aware).
    F - the argument is treated as a float, and presented as a floating-point number (non-locale aware). Available since PHP 4.3.10 and PHP 5.0.3.
    o - the argument is treated as an integer, and presented as an octal number.
    s - the argument is treated as and presented as a string.
    x - the argument is treated as an integer and presented as a hexadecimal number (with lowercase letters).
    X - the argument is treated as an integer and presented as a hexadecimal number (with uppercase letters).

The format string supports argument numbering/swapping. Here is an example:

Example2432.Argument swapping

= 'There are %d monkeys in the %s';
printf($format, $num, $location);

This might output, "There are 5 monkeys in the tree". But imagine we are creating a format string in a separate file, commonly because we would like to internationalize it and we rewrite it as:

Example2433.Argument swapping

= 'The %s contains %d monkeys';
printf($format, $num, $location);

We now have a problem. The order of the placeholders in the format string does not match the order of the arguments in the code. We would like to leave the code as is and simply indicate in the format string which arguments the placeholders refer to. We would write the format string like this instead:

Example2434.Argument swapping

= 'The %2$s contains %1$d monkeys';
printf($format, $num, $location);

An added benefit here is that you can repeat the placeholders without adding more arguments in the code. For example:

Example2435.Argument swapping

= 'The %2$s contains %1$d monkeys.
That\'s a nice %2$s full of %1$d monkeys.'
printf($format, $num, $location);


Return Values

Returns a string produced according to the formatting string format.


Version Description
4.0.6 Support for argument numbering/swapping was added


Example2436.printf(): various examples

= 43951789;
$u = -43951789;
$c = 65; // ASCII 65 is 'A'

// notice the double %%, this prints a literal '%' character
printf("%%b = '%b'\n", $n); // binary representation
printf("%%c = '%c'\n", $c); // print the ascii character, same as chr() function
printf("%%d = '%d'\n", $n); // standard integer representation
printf("%%e = '%e'\n", $n); // scientific notation
printf("%%u = '%u'\n", $n); // unsigned integer representation of a positive integer
printf("%%u = '%u'\n", $u); // unsigned integer representation of a negative integer
printf("%%f = '%f'\n", $n); // floating point representation
printf("%%o = '%o'\n", $n); // octal representation
printf("%%s = '%s'\n", $n); // string representation
printf("%%x = '%x'\n", $n); // hexadecimal representation (lower-case)
printf("%%X = '%X'\n", $n); // hexadecimal representation (upper-case)

printf("%%+d = '%+d'\n", $n); // sign specifier on a positive integer
printf("%%+d = '%+d'\n", $u); // sign specifier on a negative integer

The above example will output:

%b = '10100111101010011010101101'
%c = 'A'
%d = '43951789'
%e = '4.39518e+7'
%u = '43951789'
%u = '4251015507'
%f = '43951789.000000'
%o = '247523255'
%s = '43951789'
%x = '29ea6ad'
%X = '29EA6AD'
%+d = '+43951789'
%+d = '-43951789'

Example2437.printf(): string specifiers

= 'monkey';
$t = 'many monkeys';

printf("[%s]\n", $s); // standard string output
printf("[%10s]\n", $s); // right-justification with spaces
printf("[%-10s]\n", $s); // left-justification with spaces
printf("[%010s]\n", $s); // zero-padding works on strings too
printf("[%'#10s]\n", $s); // use the custom padding character '#'
printf("[%10.10s]\n", $t); // left-justification but with a cutoff of 10 characters

The above example will output:

[ monkey]
[monkey ]
[many monke]

Example2438.sprintf(): zero-padded integers

= sprintf("%04d-%02d-%02d", $year, $month, $day);

Example2439.sprintf(): formatting currency

= 68.75;
$money2 = 54.35;
$money = $money1 + $money2;
// echo $money will output "123.1";
$formatted = sprintf("%01.2f", $money);
// echo $formatted will output "123.10"

Example2440.sprintf(): scientific notation

= 362525200;

sprintf("%.3e", $number); // outputs 3.625e+8

Related Examples ( Source code ) » sprintf

Code Examples / Notes » sprintf

rene dot leonhardt

Your cutzero function could be faster ;-)
  return (double)$value;
But if you must have a function:
  return preg_replace('/0+$/', '', $value);


When using sprintf with padding, it's important to note that specifying the length of your padding does not restrict the length of your output.
For example:
$var = 'test';
$output sprintf("%03s", $var);
print $output;
This may seem intuitive for working with numbers, but not neccesarily when working with strings.


Well I came up with this one, extremely simple. instead of writing <span class="class">hello</a>
you can write: print class('class','hello'); using sprintf
function class_ ($class, $text=false)
return sprintf ("<span class=\"%s\">%s</span>",
($text ? $text : $class)


Watch out the mysterious rounding rule.
$a = 4.5;
$b = sprintf("%d",$a);
$c = 4.5;
$d = sprintf("%.0f",$c);
$e = 0.45;
$f = sprintf("%.1f",$e);
print ("$b,$d,$f\n");
The code above prints "4,5,0.5".
(Perl version prints "4,4,0.5".)


Using sprintf to force leading leading zeros
foreach (range(1, 10) as $v) {echo "
.. etc

no dot email dot address

Using argument swapping in sprintf() with gettext: Let's say you've written the following script:
$var = sprintf(gettext("The %2\$s contains %1\$d monkeys"), 2, "cage");
Now you run xgettext in order to generate a .po file. The .po file will then look like this:
#: file.php:9
#, ycp-format
msgid "The %2\\$s contains %1\\$d monkeys"
msgstr ""
Notice how an extra backslash has been added by xgettext.
Once you've translated the string, you must remove all backslashes from the ID string as well as the translation, so the po file will look like this:
#: file.php:9
#, ycp-format
msgid "The %2$s contains %1$d monkeys"
msgstr "Der er %1$d aber i %2$s"
Now run msgfmt to generate the .mo file, restart Apache to remove the gettext cache if necessary, and you're off.


trying to fix the multibyte non-compliance of sprintf, I came to that :
function mb_sprintf($format) {
$argv = func_get_args() ;
array_shift($argv) ;
return mb_vsprintf($format, $argv) ;
function mb_vsprintf($format, $argv) {
$newargv = array() ;

preg_match_all("`\%('.+|[0 ]|)([1-9][0-9]*|)s`U", $format, $results, PREG_SET_ORDER) ;

foreach($results as $result) {
list($string_format, $filler, $size) = $result ;
$filler = substr($filler, 1) ;
while(!is_string($arg = array_shift($argv)))
$newargv[] = $arg ;
$pos = strpos($format, $string_format) ;
$format = substr($format, 0, $pos)
     . ($size ? str_repeat($filler, $size-strlen($arg)) : '')
   . str_replace('%', '%%', $arg)
   . substr($format, $pos+strlen($string_format))

return vsprintf($format, $newargv) ;
handle with care :
1. that function was designed mostly for utf-8. i guess it won't work with any static mb encoding.
2. my configuration sets the mbstring.func_overload configuration directive to 7, so you may wish to replace substr, strlen, etc. with mb_* equivalents.
3. since preg_* doesn't complies with mb strings, I used a '.+' in the regexp to symbolize an escaped filler character. That means, %'xy5s pattern will match, unfortunately. It is recomended to remove the '+', unless you are intending to use an mb char as filler.
4. the filler fills at left, and only at left.
5. I couldn't succeed with a preg_replace thing : the problem was to use the differents lengths of the string arguements in the same replacement, string or callback. That's why the code is much longuer than I expected.
6. The pattern wil not match any %1\$s thing... just was too complicated for me.
7. Although it has been tested, and works fine within the limits above, this is much more a draft than a end-user function. I would enjoy any improvment.
The test code below shows possibilities, and explains the problem that occures with an mb string argument in sprintf.
header("content-type:text/plain; charset=UTF-8") ;
$mb_string = "xéxàx" ;
echo sprintf("%010s", $mb_string), " [octet-size: ", str_sizeof($mb_string) , " ; count: ", strlen(sprintf("%010s", $mb_string)), " characters]\n" ;
echo mb_sprintf("%010s", $mb_string), " [octet-size: ", str_sizeof($mb_string) , " ; count: ", strlen(mb_sprintf("%010s", $mb_string)), " characters]\n" ;
echo "\n" ;
echo mb_sprintf("%''10s\n%'010s\n%'û10s\n%10d\n%'x10s\n%010s\n% 10s\n%010s\n%'1s\n", "zero", "one", "two", 3, "four", "ƒîve", "%s%i%x", "šéveñ", "eight") ;


Took me a while to find this out.
hope will save someones time.
$x = sprintf("%'x-10s", "a");
echo $x;


To make's excellent function work on signed numbers you must change the first line to:
$e = floor(log10(abs($x)));


To jrust at, note that if you're using a double-quoted string and *don't* escape the dollar sign with a backslash, $s and $d will be interpreted as variable references. The backslash isn't part of the format specifier itself but you do need to include it when you write the format string (unless you use single quotes).


To have a string with leading zeros use this:
$string_i = sprintf("%04s",$value)
Gives you an output with leading zeros and 4 digits.
an so on


Time ? Format
$v_Dur = "66";
$v_Dur = floor($v_Dur/60) . ":" .  number_format( fmod(($v_Dur/60)*60,60) )  ;
echo "HH:MM========" . $v_Dur;
echo "
$v_Dur = "66";
$v_Dur = floor($v_Dur/60) . ":" .  sprintf("%02s",number_format( fmod(($v_Dur/60)*60,60) )  );
echo "HH:MM========" . $v_Dur;


The format of floating values has been previously reporting as depending on platform (linux / windows) yet I see it changes within two linux systems depending on the version:
In V4.2.2 "%3.2" displays 3 integers and two decimals (i.e. the first digit represents just the number of integer digits), on V4.4.1 the same displays (and justifies the string to) a three character string (i.e. the first digit is the total lenght of the number, including the decimal dot).
Maybe someone may better specify which version this happens from.

fredrik rambris in the com top domain

The C implementation of printf (alteast in glibc) can handle field length as arguments like this:
printf("[%-*s]\n", (int)20, "Hello");
To have the same result in PHP you need to run
printf("[%s]\n, str_pad("Hello", 20) );
It would be nice if one could use the field length directly like in C.

radu dot rendec

The 'e' format specifier is not documented. However, it seems to work, but without showing the exponential part of the number.
This is a function to get the scientific representation of a number:
function sci($x, $d=-1) {
   return sprintf("%".$fmt."fe%s",$x,$e);
It takes the number as the first parameter and the precision as the second. The precision is optional. The default precision for the 'f' format specifier is used if no precision is specified.


Regarding the previous posting:
I just wanted to give an explanation. This should be because the float to string / integer to string conversion (you are using a string, multiplying it with a float value what php automatically causes to convert the string to a float value). This is a general "problem" (or not), but not that hard to explain.
Where an integer or float starts with 0, in a string it does obviously with 1. So if you are using a string your value will increase by one (You started with a string, so it does not increase but contain the real result. If you start using a float value by not using '' around the value, you have to output the float value as well. This is just the PHP conversion.)
Try putting
$x = strval( $x );
$x = $x * 100;
and using your example again. You will see that the output will change to 13664 = 13664 because of the general string conversion. It seems that PHP is converting a float to a string by inceasing by one. By doing the same with intval instead of strval the output changes to 13663 = 13663.
! sprintf seems to behave wrong when using the conversation to an integer value and NOT doing the conversation at all. So use intval to convert to an integer value or strval to convert to a string value BEFORE using sprintf. This should be solving the problems.


Previously submitted sci() function to get scientific representation of a number is not working with 0 and negative numbers. So, here is the modified version:
function sci($x, $d=-1) {
   return sprintf("$min%".$fmt."fe%s",$x,$e);

thomas breuss

If you want to use % in sprintf, you have to "quote" it like %%.
echo sprintf("Green => %d%%'", 50);
Green => 50%


Note, if you are just looking for something to pad out a string consider str_pad.
From testing, it seems faster and was more intuitive to use (for example, making it pad the begining or end of a string... with sprintf you would have to use negative indexes)


Note that when using the argument swapping, you MUST number every argument, otherwise sprintf gets confused. This only happens if you use number arguments first, then switch to a non-numbered, and then back to a numbered one.
$sql = sprintf( "select * from %1\$s left join %2\$s on( %1\$ = %2\$s.midpoint ) where %1\$ like '%%%s%%' and %2\$s.tagname is not null", "table1", "table2", "bob" );
// Wont work:
// Sprintf will complain about not enough arguments.
$sql = sprintf( "select * from %1\$s left join %2\$s on( %1\$ = %2\$s.midpoint ) where %1\$ like '%%%3\$s%%' and %2\$s.tagname is not null", "table1", "table2", "bob" );
// Will work: note the %3\$s


Note that the documentation is unclear about the details of the sign specifier. First of all, the character for this is "+".
Also note that the following does NOT print "+00.00" as you might expect:
   printf('%+02.2f', 0);
The sign is included in the width. This can't be solved by increasing the width:
   printf('%+03.2f', 0);
This will put the padding 0 before the sign.
Here is a possible solution:
   $value = 0;
   printf('%s%02.2f', ($value < 0) ? '-' : '+', abs($value));


Note that in PHP5 (.1.4 for me) sprintf will not use the __toString function of an object.
class pr{
private $l;
public function __construct($l)
public function __toString()
return $this->l;
echo new pr('This works!!'); //This will display 'This works!!'
echo sprintf(new pr('This doesnt')); // will display 'Object'
Be careful with that!

henke dot andersson

Mind that it doesn't allow you to use a array as multiple arguments like this:
printf('%s %s',array('a','b')) ?>


Little note about sprintf and its ilk.
if you attempt something like
$string = "dingy%sflem%dwombat";
$nbr = 5;
$name = "voudras";
$msg = sprintf("%d $string %s", $nbr, $name);
sprintf will complain about a lack in the number of arguments, this would be because of the %'s in the actual string. This can be a great benifit, but is also rather confusing if you dont realize this feature, and are passing questionable variables to sprintf (for, say perhaps logging). One way around this is using
ereg_replace("%","%%", $string); before
sending it off to sprintf. This is actually how i came across this as a problem - i had realized some time ago that i would have to test my $string for
%'s, but when running the %->%% replacement on a very large serialized object, my application timed out.
My solution was to use
sprintf("%d %s %s", $nbr, $string, $name);
but, there was a reason i originally had done this the other way - i suppose i'll find out soon enough

ian dot w dot davis

Just to elaborate on downright's point about different meanings for %f, it appears the behavior changed significantly as of 4.3.7, rather than just being different on different platforms. Previously, the width specifier gave the number of characters allowed BEFORE the decimal. Now, the width specifier gives the TOTAL number of characters. (This is in line with the semantics of printf() in other languages.) See bugs #28633 and #29286 for more details.


Just thought I'd give a heads up for anyone doing cross platform applications.
sprintf spacing is different numerically with Windows and Linux.
Linux aligned correctly:
$ol = sprintf ("%-6s|%11.2f|%11.2f|%11.2f|%11.2f|%11.2f|%11.2f|%11.2f|%11.2f\n",
Windows aligned correctly:
$ol = sprintf ("%-6s|%14.2f|%14.2f|%14.2f|%14.2f|%14.2f|%14.2f|%14.2f|%14.2f\n",
As you can see the strings are fine for spacing, however, the numbers need a difference of 3 in order to have the same amount of spaces.
I noticed this after using sprintf to format a header for a web app I was working on.  On windows it fit, however, when it came to linux it was MUCH larger than the header.


Just a reminder for beginners : example 6 'printf("[%10s]\n",    $s);' only works (that is, shows out the spaces) if you put the html '<pre></pre>' tags ( head-scraping time saver ;-).

It is worth noting that "%5.2f" will result in a string 8 characters long (5 then the '.' then 2), not 5 characters as you might expect.

29-jan-2007 06:15

In response to juan at ecogomera dot com:
I think what you want is:
$x = 3327
echo $y."
$z = sprintf("%012d", $x);
echo $z;
Right? You were double-converting the number. First to binary, then again to decimal. You should be converting the source number directly into the required base.


In response to Fredrik Rambris in the com top domain:
//Your code:
printf("[%s]\n", str_pad('Hello', 20));
//Is the same as:
printf("[%-20s]\n", 'Hello');


In response to Anonymous, who claimed that:
 printf("[%s]\n", str_pad('Hello', 20));
 printf("[%-20s]\n", 'Hello');
are the same thing: you've missed the point.
They're only the same when the amount of padding is a known constant. When its a variable (or an expression), its often much more convenient to be able to write:
 printf("[%-*s]\n", 3*$n+2, "Hello");
than what you have to go through now, which is either:
 $t = 3*$n+2;
 printf("[%s]\n", str_pad('Hello', 3*$n+2));


If you want to format a phonenumber with spaces, use chunk_split() which splits a string into smaller chunks. It's much simpler than using sprintf.
$phone = "12345678";
chunk_split ($phone, 2);
will return 12 34 56 78


If you want to cut all the zeros off the end of a float, but not losing any sensitive information, use this:
function cutzero($value) {
   return preg_replace("/(\.\d+?)0+$/", "$1", $value)*1;
Some examples:
cutzero("4.7600");     // returns 4.76
cutzero("4.7604")      // returns 4.7604
cutzero("4.7000");     // returns 4.7
cutzero("4.0000");     // returns 4

tim dot brouckaert dot nospam

If you want to center align some text using the printf or sprintf functions, you can just use the following:
function center_text($word){
$tot_width = 30;
$symbol = "-";
$middle = round($tot_width/2);
$length_word = strlen($word);
$middle_word = round($length_word / 2);
$last_position = $middle + $middle_word;
$number_of_spaces = $middle - $middle_word;
$result = sprintf("%'{$symbol}{$last_position}s", $word);
for ($i = 0; $i < $number_of_spaces; $i++){
$result .= "$symbol";
return $result;
$string = "This is some text";
print center_text($string);
off course you can modify the function to use more arguments.


If you are going to create a counter which uses _symbols_ before actual digits (see, f.e., counters - they are filling space with "." before, so the count like 12345 looks like "........12345"), you can use the following:
$txt = "Abracadabra"; // actual string
$fit = 16; // how many digits to use
$fill = "."; // what to fill
$digits = sprintf ("%'{$fill}{$fit}s", $txt);
Paul (a.k.a. Mr.Prolix)


Hey folks, don't forget to prefix a precision specifier with a period '.'!
Thus, to print a floating point number,
say $x, with two digits after the decimal point you would write:
printf( "%.2f", $x );


Here a litle function that might come handy one time:
It gives back a String and adds a
(you can change it to <br />) to every line end. And it adds $num blanks to the front of the next line.
function nl2brnl($text, $num)
  return preg_replace("/\\r\\n|\\n|\\r/", sprintf("% -".(5+$num)."s","
\\n"), $text);
$a = " one\\n two\\r\\n three";
$b = nl2brnl($a, 2);
/* output will be:
string(30) " one
echo "  

\\n   ";
echo $b
/* output will be:


Is helpfull for avouding code_soup.


henke dot andersson
You can accomplish feeding it array if you use call_user_func_array. Not exactly a `clean' option, but it does work.


Display an binary string like an Hex Editor.
function BinToHexView($binstr) {
$HexView = "";
$binpos = 0;
$binsize = strlen($binstr);
$binr = ( ($binsize-$binpos-16) > 16 ? 16 : $binsize-$binpos-16 );
while ($binr > 0) {
$hline = "";
$dline = "";
$HexView .= sprintf("%04x", $binpos);
for ($c=0;$c<$binr;$c++) {
$hline .= sprintf("%02x",ord($binstr[$binpos+$c]))." ";
for ($c=0;$c<$binr;$c++) {
$ord = ord($binstr[$binpos+$c]);
$dline .= ( $ord<32 || $ord>126 ? "." : $binstr[$binpos+$c] );
$HexView .= sprintf("  %-48s  %-16s\n", $hline, $dline);
$binpos += $binr;
$binr = ( ($binsize-$binpos-16) > 16 ? 16 : $binsize-$binpos-16 );
return $HexView;


decision within sprintf:
$a = "today";
$b = sprintf('This is %s', $a=='today' ? 'today':'not today');
echo $b;
// result: This is today

05-mar-2004 06:54

both of your cut-zero functions are just way too complicated. if it's a string where only the zeros at the end should be truncated, why not use a syntax as simple as rtrim("4.7000","0") ?


Be careful if you use the %f modifier to round decimal numbers as it (starting from 4.3.10) will no longer produce a float number if you set certain locales, so you can't accumulate the result. For example:
setlocale(LC_ALL, 'es_ES');
echo(sprintf("%.2f", 13.332) + sprintf("%.2f", 14.446))
gives 27 instead of 27.78, so use %F instead.

andrew dot wright

An error in my last example:
$b = sprintf("%30.s", $a);
will only add enough spaces before $a to pad the spaces + strlen($a) to 30 places.
My method of centering fixed text in a 72 character width space is:
$a = "Some string here";
$lwidth = 36; // 72/2
$b = sprintf("%".($lwidth + round(strlen($a)/2)).".s", $a);


A really working one:
function cutzero($value) {
  return preg_replace("/(\.?)0+$/", "", $value);

moritz dot geselle

a little note to the argument swapping examples which took me a while to get:
if you use single quotes for the format string (like you should do, since there aren't any variable conversions to do as long as you don't need any special chars), the given examples won't work because of the backslash before the $ (needs to be escaped in double quoted strings - but not in single quoted!)
so this:
$format = "The %2\$s contains %1\$d monkeys";
with a single quoted format string would look like this:
$format = 'The %2$s contains %1$d monkeys';
(no escapes)
I hope that helps to avoid confusion ;)


@ henke dot andersson at comhem dot se: Use vprintf()/vsprintf() for that.


This function returns a formated  string with the legnth you specify
@string holds the string which you want to format
@len holds the length you want to format
function formatString($string, $len)
if (strlen($string) < $len)
$addchar=($len - strlen($string)) ;
for ($i = 0; $i < $addchar; $i++)
$string=sprintf("$string%s", "0");

if (strlen($string) > $len)

return $string;

ulf wostner

# Viewing Two's Complement using sprintf formatting.
# Systems using Two's Complements have exactly one number that equals its own Two's Complement.
# On a 32-bit system look at  1000 0000 0000 0000  for  -2147483648
# Take the one's complement, to get 0111 1111 1111 1111, add 1
# to get the Two's Complement: 1000 0000 0000 0000
#  We are back to the original number, the so-called Weird Number for 32-bits.
# For a 64-bit system, format that number as binary, width 64, padded with 0's.
printf("%064b\n", -2147483648);
# Output with added spaces:
# 11111111 11111111 11111111 11111111 10000000 00000000 00000000 00000000
# And here is the Two's Complement on a 64-bit system.
printf("%064b\n", +2147483648);
# Output with added spaces:
# 00000000 00000000 00000000 00000000 10000000 00000000 00000000 00000000
# They share those last 32 bits, accounting for the 32-bit Weird Number.
# Is PHP running  32-bit or 64-bit?
# Sure, we can look at the max int, but  The Weird Number  also tells if we are in 32-bit, 64-bit, or ...
function getBitCount() {
 $how_many_bits = 1;  $n = 2;
 while(True) {
   $how_many_bits += 1;   $n *= 2;  # powers of 2
   # matches its own two's complement?  
   if( sprintf("%b", $n) == sprintf("%b", -$n)  )
     return 1 + $how_many_bits;


* [string or int] vprint ( string $format [, mixed $ary [, bool $return]] )
* Closely mimics the functionality of sprintf(), printf(), vprintf(), and vsprintf().
* Replaces %[bcdeufFosxX] with each element of $ary
* See for details on replacement types.
* If there are not enough elements in $ary (or it is left out) to satisfy $format,
* it will be padded to the correct length.
* Since v*printf() doesn't mind having too many elements in the array, $format will be left alone.
* If $ary is a string, it will be recast into an array.
* If $return is set to a value considered to be false (0, '', null, false, and array()),
* then the output will be sent to STDOUT and the strlen() of the output string will be returned;
* otherwise, the output string will be returned.
* It's buggy when using the argument swapping functionality, unless you do it propperly.
* May break when using modifiers (%.4e, %02s, etc), unless you do it propperly.
function vprint($format, $ary = array(), $return = true) {
// Sanity?!
if (!is_array($ary)) $ary = array($ary);
// Find %n$n.
preg_match_all('#\\%[\\d]*\\$[bcdeufFosxX]#', $format, $matches);
// Weed out the dupes and count how many there are.
$counts = count(array_unique($matches[0]));
// Count the number of %n's and add it to the number of %n$n's.
$countf = preg_match_all('#\\%[bcdeufFosxX]#', $format, $matches) + $counts;
// Count the number of replacements.
$counta = count($ary);
if ($countf > $counta) {
// Pad $ary if there's not enough elements.
$ary = array_pad($ary, $countf, "&nbsp;");
if ($return) {
return vsprintf($format, $ary);
} else {
return vprintf($format, $ary);


$a = 5;
// $a is a int
echo $5;
// Outputs:"5";
// If you would like to print $a as a bin,(101) like: 00000101 (8 digits)
sprintf("%8b", $a) // Witch returns exatly 00000101 (8 digits)
// My function looked like:
 // By DrRex - - 15/04-2001 //
 // string bin(int dec)                  //
 function bin($dec){
   $bin = sprintf("%8b", $dec);
   return $bin;
// Very short exampels how to use bin()
 echo "\n1. 128(10) == ".bin(128)."(2)";
 $hits = 100;
 echo "\n2. Loaded ".bin($hits)."(2) times! Bib!";
// Not very usefull, nobody understands the number, exept if small counters like this one. If it wasn't 8(2) but FFFFFF(16) digits. I would give up...
// This would output:
 1. 128(10) == 10000000(2)
 2. Loaded 01100100(2) times! Bib!
Greetings from Christiania, Copenhagen, Denmark!
All code by DrRex

Change Language

Follow Navioo On Twitter
eXTReMe Tracker