Core Function SPrintf

From Sputnik Wiki
Revision as of 12:38, 14 June 2015 by UberFoX (Talk | contribs)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search
SPrintf( <format control>, <params> )

Contents

Description

Returns a formatted string (similar to the C sprintf() function).

Parameters

format control

The format and flags to use (see Remarks).

This can be either a string or an array that will be converted into a string

params

Variables that will be output according to the "format control".

The variables can also be arrays with their own unique designated separator.

When using arrays you may have any/all/none of the following Keys (Case-Sensitive):

KEY              WHAT IT DOES
@Sep             Allows you to define a separator for each element in the array to use
@Begin           Allows you to define a string to add to the beginning of each element in the array
@End             Allows you to define a string to add to the end of each element in the array

See example for more information.

If there is just one param and it is a full dictionary using keys/values only then it will treated very differently see example for dictionary stuff.

Return Value

Success: Return the formatted string according to "variable format" defined in the "format control" parameter.

Failure: Returns "" (blank string).

Remarks

As with all Sputnik functions Sprintf() is fully Unicode so you don't need to worry about such things.

If you wish to immediately print to the console rather than return a string you should see Printf( <format control>, <params> ).

Unlike AutoIt (And similar programs) there is no buffer overflow chance, each "variable" is not limited to any amount characters it can be as big as it needs to be (Because Sputnik handles the entire sprintf parsing/operation/printing etc internally and does not use DLLs or APIs to accomplish it.

If you want to have "%" in the format control you must enter "%%".

"variable format" is; %[flags] [width] [.precision] type

       Width Specification

The second optional field of the format specification is the width specification. The width argument is a nonnegative decimal integer controlling the minimum number of characters printed. If the number of characters in the output value is less than the specified width, blanks are added to the left or the right of the values — depending on whether the – flag (for left alignment) is specified — until the minimum width is reached. If width is prefixed with 0, zeros are added until the minimum width is reached (not useful for left-aligned numbers).

The width specification never causes a value to be truncated. If the number of characters in the output value is greater than the specified width, or if width is not given, all characters of the value are printed (subject to the precision specification).

       Type Specification
Type        Variable type           Output format 
b           Integer/Float           Binary number (Detects if it should use Integer or Float based on value type). 
B           Long Integer/Float      Binary number (Detects if it should use Integer or Float based on value type). 
d, i        Integer                 Signed decimal integer. 
D           Long Integer            Signed decimal long integer. 
o           Integer                 Unsigned octal integer. 
O           Long Integer            Unsigned octal long integer. 
u           Integer                 Unsigned decimal integer. 
U           Long Integer            Unsigned decimal long integer. 
x           Integer                 Unsigned hexadecimal integer, using "abcdef". 
X           Integer                 Unsigned hexadecimal integer, using "ABCDEF". 
a           Float                   Hexadecimal floating point in lowercase, using "abcdef". 
A           Float                   Hexadecimal floating point in uppercase, using "ABCDEF". 
e           Float                   Signed value having the form [ - ]d.dddd e [sign]ddd where d is a single decimal
                                    digit, dddd is one or more decimal digits, ddd is exactly three decimal digits,
                                    and sign is + or -. 
E           Float                   Identical to the e format except that E rather than e introduces the exponent. 
f           Float                   Signed value having the form [ - ]dddd.dddd, where dddd is one or more decimal digits.
                                    The number of digits before the decimal point depends on the magnitude of the number,
                                    and the number of digits after the decimal point depends on the requested precision. 
g           Float                   Signed value printed in f or e format, whichever is more compact for the given value
                                    and precision. The e format is used only when the exponent of the value is less
                                    than -4 or greater than or equal to the precision argument. Trailing zeros are
                                    truncated, and the decimal point appears only if one or more digits follow it. 
G           Float                   Identical to the g format, except that E, rather than e, introduces the exponent
                                    (where appropriate). 
p           Pointer address         Prints the pointer address in hex with a 0x prefix.
P           Pointer address         Prints the pointer address in hex (UPPER CASE) with a 0x prefix.
s           String                  String. 
S           String                  String (Will force Binary/Arrays etc to print as String). 
c           Character               A single character (ASCII).
C           Character               A single character (UNICODE).
V           SV                      Interpret integer as Sputnik's standard integer type.
n           Nothing printed         The corresponding argument must be a variable to be used.
                                    The number of characters written so far will stored in the variable provided.
       Flag Specification
Flag       Meaning                                                            Default 
^          Format parameter index                                             No explicit index
           An explicit format parameter index, such as 2^.
           By default Sprintf() will format the next unused argument
           in the list, but this allows you to take the arguments out
           of order and even use the same argument multiple times.
           See the examples below.
'          Custom padding will replace the usual space/zero with              No padding.
           a custom padding of your choosing. You must enter the
           custom padding character immediately after the ' for
           example %'# will cause # to become the custom character.
           This padding by default will left and right sides of the
           input as the width specifies. 
`          Custom left align padding will replace the usual space/zero        No padding.
           that appear when you do a left alignment (or center) the
           custom character will appear visible on the right side
           after the item. Using a custom padding of your choosing.
           This is useful if you wish to use the usual custom padding
           on top of this padding to allow you to choose unique characters
           to surround both the left and right side of your input.           
           You must enter the custom padding character immediately after
           the ` for example %`# will cause # to become the custom character
!          Center align the result within the given field width.              Center align.
-          Left align the result within the given field width.                Right align. 
+          Prefix the output value with a sign (+ or -) if
           the output value is of a signed type.                              Sign appears only for negative signed
                                                                              values (-). 
0          If width is prefixed with 0, zeros are added until the
           minimum width is reached. If 0 and - appear, the 0 is
           ignored. If 0 is specified with an integer format
           (i, u, x, X, o, d) the 0 is ignored.                               No padding. 
Blank      Prefix the output value with a blank if the output value
           is signed and positive; the blank is ignored if both the
           blank and + flags appear.                                          No blank appears. 
#          When used with the o, x, or X format, the # flag prefixes
           any nonzero output value with 0, 0x, or 0X, respectively.          No blank appears. 
#          When used with the e, E, or f format, the # flag forces
           the output value to contain a decimal point in all cases.          Decimal point appears only if digits follow it. 
#          When used with the g or G format, the # flag forces the
           output value to contain a decimal point in all cases
           and prevents the truncation of trailing zeros.
           Ignored when used with c, d, i, u, or s.                           Decimal point appears only if digits follow it.
                                                                              Trailing zeros are truncated. 
       Width Specification
width             description
(number)	  Minimum number of characters to be printed. If the
                  value to be printed is shorter than this number,
                  the result is padded with blank spaces. The value
                  is not truncated even if the result is larger.
*	          The width is not specified in the format string, but
                  as an additional integer value argument preceding
                  the argument that has to be formatted.
       Precision Specification

The third optional field of the format specification is the precision specification. It specifies a nonnegative decimal integer, preceded by a period (.), which specifies the number of characters to be printed, the number of decimal places, or the number of significant digits (see Table below). Unlike the width specification, the precision specification can cause either truncation of the output value or rounding of a floating-point value. If precision is specified as 0 and the value to be converted is 0, the result is no characters output, as shown below:

sprintf( "%.0d", 0 ); /* No characters return */

        Specifiers

The length sub-specifier modifies the length of the data type. This is a chart showing the types used to interpret the corresponding arguments with and without length specifier (if a different type is used, the proper type promotion or conversion is performed, if allowed):

length          d i          u o x X          f F e E g G a A          c          s          p          n
(none)	        Int32	     UInt32           Double	               Int32      String     IntPtr     Ref
hh	        SByte        Byte                                                                       Ref
h	        Int16        UInt16                                                                     Ref
l	        Int32        UInt32           Float                    Char	  String                Ref
ll              Int64        UInt64                                                                     Ref
j	        Int64        UInt64                                                                     Ref
z	        Int64        UInt64                                                                     Ref
t	        Int64        UInt64                                                                     Ref
L                                             Double                                                    Ref

Some of the above are obsolete and may be removed later (hh, h, l, ll will stay forever though)

When you place a variable into the parameter and say the variable is a max size Int64 if you enter %hhd the variable size will be cut down to the the a byte you can use this as a form of casting instead of having to explicitly cast.

The "l" can be used to cast a show a double as if it was a float such as %ld similar to casting.

   How Precision Values Affect Type
Type                       Meaning                                         Default  
d, i, u, o, x, X           The precision specifies the minimum
                           number of digits to be printed. If the
                           number of digits in the argument is less
                           than precision, the output value is padded
                           on the left with zeros. The value is not
                           truncated when the number of digits exceeds
                           precision.                                      Default precision is 1.  
e, E                       The precision specifies the number of digits
                           to be printed after the decimal point.
                           The last printed digit is rounded.              Default precision is 6; if precision is 0
                                                                           or the period (.) appears without a number
                                                                           following it, no decimal point is printed.  
f                          The precision value specifies the number of
                           digits after the decimal point. If a decimal
                           point appears, at least one digit appears
                           before it. The value is rounded to the
                           appropriate number of digits.                   Default precision is 6; if precision is 0,
                                                                           or if the period (.) appears without a number
                                                                           following it, no decimal point is printed.  
g, G                      The precision specifies the maximum number of
                          significant digits printed.                      Six significant digits are printed, with any
                                                                           trailing zeros truncated.  
s                         The precision specifies the maximum number of
                          characters to be printed. Characters in excess
                          of precision are not printed.                    Characters are printed until a null character
                                                                           is encountered.  

Example

Before we begin

// Anything you can do in Printf you can return it as a string using Sprintf
// Like so..
$value = sprintf("%%e = '%e'\n", 777);
print($value); // Prints: 7.770000e+002

Format parameter index in this example we explicitly tell it to use parameter 2 where you would expect 1 to go and 1 where you would expect 2 to go

$value = sprintf('%2^d %1^d', 12, 32);
print($value);
// Prints
// 32 12

Format parameter index in this example we explicitly use the same parameter in multiple formats

$value = sprintf("As Int '%1^d' As Hex '%1^#x' As Char '%1^c'\n", 12);
print($value);
// Prints
// As Int '12' As Hex '0xc' As Char '♀'

Format parameter index of course everything still works such as padding

$value = sprintf("As Int '%1^6d' As Hex '%1^#-6x' As Char '%1^!6c'\n", 12);
print($value);
// Prints
// As Int '    12' As Hex '0xc   ' As Char '  ♀   '

A basic example

$d = 5;
$m = 11;
$y = 1990;
say sprintf("%02d/%02d/%04d", $d, $m, $y);
// 05/11/1990

Example of using custom padding

$s = '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("[%'#-10s]\n",   $s); // left-justification with custom padding '#'
printf("[%10.10s]\n", $t); // left-justification but with a cutoff of 10 characters
printf("[%'#10d]\n",  777); // use the custom padding character '#'
printf("[%'#10g]\n",  777.42); // use the custom padding character '#'
printf("[%'#-10d]\n",  777); // left-justification with custom padding '#'
printf("[%'#-10g]\n",  777.42); // left-justification with custom padding '#'
/*
[monkey]
[    monkey]
[monkey    ]
[0000monkey]
[####monkey]
[monkey####]
[many monke]
[#######777]
[####777.42]
[777#######]
[777.42####]
*/

Example of center alignment

// Normal spaces
printf("[%!20d]\n", 1);
printf("[%!20d]\n", 10);
printf("[%!20d]\n", 100);
printf("[%!20d]\n", 1000);
 
printf("[%!20g]\n", 1.1);
printf("[%!20g]\n", 10.2);
printf("[%!20g]\n", 100.3);
printf("[%!20g]\n", 1000.4);
 
printf("[%!20s]\n", "The");
printf("[%!20s]\n", "Quick");
printf("[%!20s]\n", "Brown");
printf("[%!20s]\n", "Fox");
 
// Custom padding
printf("[%'-!20d]\n", 1);
printf("[%'-!20d]\n", 10);
printf("[%'-!20d]\n", 100);
printf("[%'-!20d]\n", 1000);
 
printf("[%'-!20g]\n", 1.1);
printf("[%'-!20g]\n", 10.2);
printf("[%'-!20g]\n", 100.3);
printf("[%'-!20g]\n", 1000.4);
 
printf("[%'-!20s]\n", "The");
printf("[%'-!20s]\n", "Quick");
printf("[%'-!20s]\n", "Brown");
printf("[%'-!20s]\n", "Fox");
 
// Custom padding on left and right (different chars for each)
printf("[%'>`<!20d]\n", 1);
printf("[%'>`<!20d]\n", 10);
printf("[%'>`<!20d]\n", 100);
printf("[%'>`<!20d]\n", 1000);
 
printf("[%'>`<!20g]\n", 1.1);
printf("[%'>`<!20g]\n", 10.2);
printf("[%'>`<!20g]\n", 100.3);
printf("[%'>`<!20g]\n", 1000.4);
 
printf("[%'>`<!20s]\n", "The");
printf("[%'>`<!20s]\n", "Quick");
printf("[%'>`<!20s]\n", "Brown");
printf("[%'>`<!20s]\n", "Fox");
/*
[         1          ]
[         10         ]
[        100         ]
[        1000        ]
[      1.10000       ]
[      10.2000       ]
[      100.300       ]
[      1000.40       ]
[        The         ]
[       Quick        ]
[       Brown        ]
[        Fox         ]
[---------1----------]
[---------10---------]
[--------100---------]
[--------1000--------]
[------1.10000-------]
[------10.2000-------]
[------100.300-------]
[------1000.40-------]
[--------The---------]
[-------Quick--------]
[-------Brown--------]
[--------Fox---------]
[>>>>>>>>>1<<<<<<<<<<]
[>>>>>>>>>10<<<<<<<<<]
[>>>>>>>>100<<<<<<<<<]
[>>>>>>>>1000<<<<<<<<]
[>>>>>>1.10000<<<<<<<]
[>>>>>>10.2000<<<<<<<]
[>>>>>>100.300<<<<<<<]
[>>>>>>1000.40<<<<<<<]
[>>>>>>>>The<<<<<<<<<]
[>>>>>>>Quick<<<<<<<<]
[>>>>>>>Brown<<<<<<<<]
[>>>>>>>>Fox<<<<<<<<<]
*/

Example of using a variable to choose padding size

$t = 'f';
printf("right-justified variable width (padded-zeros): '%0*c'\n", 10, $t);
printf("left-justified variable width (padded-zeros): '%-'0*c'\n", 10, $t);
printf("right-justified variable width (padded-custom): '%'#*c'\n", 10, $t);
printf("left-justified variable width (padded-custom): '%-'#*c'\n", 10, $t);
// right-justified variable width: '         f'
// left-justified variable width : 'f         '
// right-justified variable width (padded-zeros): '000000000f'
// left-justified variable width (padded-zeros): 'f000000000'
// right-justified variable width (padded-custom): '#########f'
// left-justified variable width (padded-custom): 'f#########'

Example of printing integers and floats in hexadecimal

say "Hex of 32-bit Integer";
say sprintf('%x', @INT32_MAX);
say sprintf('%x', @INT32_MIN);
 
say "Hex of 64-bit Integer";
say sprintf('%llx', @INT64_MAX);
say sprintf('%llx', @INT64_MIN);
 
say "Hex of 32-bit Floating Point";
say sprintf('%a', 777.42);
say sprintf('%a', -777.42);
 
say "Hex of 64-bit Floating Point";
say sprintf('%la', 777.42);
say sprintf('%la', -777.42);
/*
Hex of 32-bit Integer
7fffffff
80000000
Hex of 64-bit Integer
7fffffffffffffff
8000000000000000
Hex of 32-bit Floating Point
44425ae1
c4425ae1
Hex of 64-bit Floating Point
40884b5c28f5c28f
c0884b5c28f5c28f
*/

Example %n

$text = "World !";
Printf("Hello%n %s\n%n", $val, $text, $val2);
Printf("%%n at first check was %d\n", $val);
Printf("%%n at second check was %d\n", $val2);
// Prints
// Hello World !
// %n at first check was 5
// %n at second check was 14

Example %p to print a memory address etc

$ptr = Alloc(500);
Printf("Pointer: %p\n", $ptr); // Pointer: 0x06d5bda8
Printf("Pointer: %P\n", $ptr); // Pointer: 0x06D5BDA8
free($ptr);

Large example

$n = 43951789;
$u = -43951789;
 
// notice the double %%, this prints a literal '%' character
Printf("%%d = '%d'\n", $n);             //'43951789'          standard integer representation
Printf("%%e = '%e'\n", $n);             //'4.395179e+07'     scientific notation
Printf("%%u = '%u'\n", $n);             //'43951789'          unsigned integer representation of a positive integer
Printf("%%u <0 = '%u'\n", $u);          //'4251015507'        unsigned integer representation of a negative integer
Printf("%%f = '%f'\n", $n);             //'43951789.000000'   floating point representation
Printf("%%.2f = '%.2f'\n", $n);         //'43951789.00'       floating point representation 2 digits after the decimal point
Printf("%%o = '%o'\n", $n);             //'247523255'         octal representation
Printf("%%s = '%s'\n", $n);             //'43951789'          string representation
Printf("%%x = '%x'\n", $n);             //'29ea6ad'           hexadecimal representation (lower-case)
Printf("%%X = '%X'\n", $n);             //'29EA6AD'           hexadecimal representation (upper-case)
 
Printf("%%+d = '%+d'\n", $n);           //'+43951789'         sign specifier on a positive integer
Printf("%%+d <0= '%+d'\n", $u);         //'-43951789'         sign specifier on a negative integer
 
 
$s = 'monkey';
$t = 'many monkeys';
 
Printf("%%s = [%s]\n", $s);             //[monkey]            standard string output
Printf("%%10s = [%10s]\n", $s);         //[    monkey]        right-justification with spaces
Printf("%%-10s = [%-10s]\n", $s);       //[monkey    ]        left-justification with spaces
Printf("%%010s = [%010s]\n", $s);       //[0000monkey]        zero-padding works on strings too
Printf("%%10.10s = [%10.10s]\n", $t);   //[many monke]        left-justification but with a cutoff of 10 characters
 
Printf("%04d-%02d-%02d\n", 2008, 4, 1);

If you are wondering how the hell to do a 64-bit signed integer

// Recommended way
Printf("Int64 value is: '%D' ok\n", @Int64_Max);
// Alternative
Printf("Int64 value is: '%lld' ok\n", @Int64_Max);

If you are wondering how the hell to do a 64-bit unsigned integer

// Recommended way
Printf("UInt64 value is: '%U' ok\n", @UInt64_Max);
// Alternative
Printf("UInt64 value is: '%llu' ok\n", @UInt64_Max);

Example of using arrays

$n = 777;
$t = array(100, 200, 300, 400);
Printf("Single value is '%d' but lets do an array of values '%d' cool huh?\n", $n, $t);

Example of using arrays with separator

$n = 777;
$t = array(@Sep => "-", 100, 200, 300, 400);
Printf("Single value is '%d' but lets do an array of values '%d' cool huh?\n", $n, $t);

Example of using arrays with separator but this time dont include the separator in the array

$n = 777;
$t = array(100, 200, 300, 400);
Printf("Array of values '%d'\n", [@Sep => "/"] . $t);
// Original array is intact
printr $t; // see
// Prints
// Array of values '100/200/300/400'
// ARRAY
// {
//         [0] => 100
//         [1] => 200
//         [2] => 300
//         [3] => 400
// }

Large example with arrays

$ints = array(@Sep => "-", 100, 200, 300, 400);
$floats = array(@Sep => "#", 100.2, 777.42, 133.77, 88.1);
$strings = array(@Sep => "#", "One", "Two", "Three");
Printf("Ints '%d' \nFloats '%g' \nStrings '%s'\n", $ints, $floats, $strings);

Example using @Sep, @Begin and @End

$arr = array(@Sep => "\n", @Begin => "0x", @End => "<-- Hex yup", 0..50);
Printf("Hex of the array\n%x\n", $arr);

More examples

Printf(  "%+d\n", 42   ); # "+42"
Printf(  "%4d\n", 42   ); # "  42"
Printf(  "%04d\n", 42   ); # "0042"
Printf(  "%X\n", 0x1337f00d   ); # "1337F00D"

Using an array as the format string

$arr = array("huey", "dewey", "louie");
say sprintf($arr); # 'huey dewey louie'
 
$arr = array(10, 11, 12);
say sprintf('%x', $arr); # 'abc'
 
$arr = array(@Sep => " ", 10, 11, 12);
say sprintf('%x', $arr); # 'a b c'
 
$arr = array(@Sep => " ", 65, 66, 67);
say sprintf('%c', $arr); # 'A B C'
 
$arr = array(@Sep => '; ', 1, 2, 3);
say sprintf('%02d', $arr); # '01; 02; 03'

Using an array as the format string with custom join

$arr = Join(array("huey", "dewey", "louie"),'-');
say sprintf($arr); # 'huey-dewey-louie'

Using an array (as a dictionary) as the format string

$arr = array("foo" => 1, "bar" => 2);
say sprintf($arr); # 'foo     1
                   #  bar     2'
 
$arr = array("foo" => 1, "bar" => 2, "testingFooBar" => 3);
say sprintf($arr); # 'foo               1
               #  bar               2
               #  testingFooBar     3'

Using an array (as a dictionary) as the format string with custom join

$arr = JoinKV(array("foo" => 1, "bar" => 2),"<BR>\n");
say sprintf($arr); # 'foo     1<BR>
                   #  bar     2'

Using an array (as a dictionary) as the only param

$arr = array("Apples" => 5, "Oranges" => 10);
say sprintf('%s cost %d euros', $arr);
             # 'Apples cost 5 euros
             #  Oranges cost 10 euros'
 
// Of course you can still use the @Sep
$arr = array(@Sep => ";", "Apples" => 5, "Oranges" => 10);
say sprintf('%s cost %d euros', $arr);
             # 'Apples cost 5 euros;Oranges cost 10 euros'
 
// Of course @Begin and @End are useable too
$arr = array(@Begin => ">>>", @End => "<<<", "Apples" => 5, "Oranges" => 10);
say sprintf('%s cost %d euros', $arr);
             # '>>>Apples cost 5 euros<<<
             #  >>>Oranges cost 10 euros<<<'
 
// Can use them all
$arr = array(@Sep => ";", @Begin => ">>>", @End => "<<<", "Apples" => 5, "Oranges" => 10);
say sprintf('%s cost %d euros', $arr);
             # '>>>Apples cost 5 euros<<<;>>>Oranges cost 10 euros<<<'
 
$arr = array(@Sep => " -- ", "huey" => 1, "dewey" => 2, "louie" => 3);
say sprintf('%s', $arr);
             # 'huey -- dewey -- louie'
 
$arr = array(@Sep => " -- ", "huey" => 1, "dewey" => 2, "louie" => 3);
say sprintf('%s(%d)', $arr);
             # 'huey(1) -- dewey(2) -- louie(3)'
 
say sprintf("%s is %.3f AU away from the sun", "Earth", 1);
             # Prints "Earth is 1.000 AU away from the sun"
 
say sprintf("%s is %.3f AU away from the sun", array("Earth" => 1));
             # Prints "Earth is 1.000 AU away from the sun"

Yet another example

$n =  43951789;
$u = -43951789;
$c = 65; // ASCII 65 is 'A'
 
// notice the double %%, this prints a literal '%' character
Printf("%%b = '%b'\n", $n); // binary representation (32 bit size)
Printf("%%B = '%B'\n", @Int64_Max); // binary representation (64 bit size)
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

Example of using %b to print the number in its binary form

Printf("Binary of Int32 value is: '%b'\n", @Int32_Max);
Printf("Binary of Int64 value is: '%B'\n", @Int64_Max);
Printf("Binary of Float value is: '%b'\n", @Float_Max);
Printf("Binary of Double value is: '%B'\n", @Double_Max);

// Printing a binary $variable

$binary = BinaryFromStr("Hello World!");
Printf("Binary variable to Hex = '%X'\n", $binary);
Printf("Binary variable to Hex (with spaces) = '%3X'\n", $binary);
Printf("Binary variable to Chars = '%c'\n", $binary);
Printf("Binary variable to Numbers = '%d'\n", $binary);
Printf("Binary variable to String = '%S'\n", $binary);
// Prints
// Binary variable to Hex = '48656C6C6F20576F726C6421'
// Binary variable to Hex (with spaces) = ' 48 65 6C 6C 6F 20 57 6F 72 6C 64 21'
// Binary variable to Chars = 'Hello World!'
// Binary variable to Numbers = '72101108108111328711111410810033'
// Binary variable to String = 'Hello World!'

Example of using %V

say "Now singles";
Printf("Value is: '%V' ok\n", (char)65);
Printf("Value is: '%V' ok\n", null);
Printf("Value is: '%V' ok\n", true);
Printf("Value is: '%V' ok\n", false);
Printf("Value is: '%V' ok\n", @SBYTE_MAX);
Printf("Value is: '%V' ok\n", @BYTE_MAX);
Printf("Value is: '%V' ok\n", @INT16_MAX);
Printf("Value is: '%V' ok\n", @INT32_MAX);
Printf("Value is: '%V' ok\n", @INT64_MAX);
Printf("Value is: '%V' ok\n", @UINT16_MAX);
Printf("Value is: '%V' ok\n", @UINT32_MAX);
Printf("Value is: '%V' ok\n", @UINT64_MAX);
Printf("Value is: '%V' ok\n", @FLOAT_MAX);
Printf("Value is: '%V' ok\n", @DOUBLE_MAX);
Printf("Value is: '%V' ok\n", "Hello");
 
say "Now arrays";
Printf("Value is: '%V' ok\n", array((char)65, (char)'a'));
Printf("Value is: '%V' ok\n", array(null, null, null));
Printf("Value is: '%V' ok\n", array(true, false, (bool)1, (bool)0));
Printf("Value is: '%V' ok\n", array((sbyte)77, (sbyte)11, (sbyte)22));
Printf("Value is: '%V' ok\n", array((byte)100, (byte)200, (byte)202));
Printf("Value is: '%V' ok\n", array((int16)777, (int16)778, (int16)778));
Printf("Value is: '%V' ok\n", array((int32)1337, (int32)7331, (int32)1373));
Printf("Value is: '%V' ok\n", array((int64)131, (int64)121, (int64)141));
Printf("Value is: '%V' ok\n", array((uint16)1, (uint16)2, (uint16)3));
Printf("Value is: '%V' ok\n", array((uint32)111, (uint32)222, (uint32)333));
Printf("Value is: '%V' ok\n", array((uint64)1110, (uint64)2220, (uint64)3330));
Printf("Value is: '%V' ok\n", array((float)777.77, (float)777.11, (float)777.22));
Printf("Value is: '%V' ok\n", array((float)42.77, (float)42.11, (float)42.22));
Printf("Value is: '%V' ok\n", array("Hello", "World", "ok"));
 
say "Now arrays with separator";
Printf("Value is: '%V' ok\n", array(@Sep => ", ", (char)65, (char)'a'));
Printf("Value is: '%V' ok\n", array(@Sep => ", ", null, null, null));
Printf("Value is: '%V' ok\n", array(@Sep => ", ", true, false, (bool)1, (bool)0));
Printf("Value is: '%V' ok\n", array(@Sep => ", ", (sbyte)77, (sbyte)11, (sbyte)22));
Printf("Value is: '%V' ok\n", array(@Sep => ", ", (byte)100, (byte)200, (byte)202));
Printf("Value is: '%V' ok\n", array(@Sep => ", ", (int16)777, (int16)778, (int16)778));
Printf("Value is: '%V' ok\n", array(@Sep => ", ", (int32)1337, (int32)7331, (int32)1373));
Printf("Value is: '%V' ok\n", array(@Sep => ", ", (int64)131, (int64)121, (int64)141));
Printf("Value is: '%V' ok\n", array(@Sep => ", ", (uint16)1, (uint16)2, (uint16)3));
Printf("Value is: '%V' ok\n", array(@Sep => ", ", (uint32)111, (uint32)222, (uint32)333));
Printf("Value is: '%V' ok\n", array(@Sep => ", ", (uint64)1110, (uint64)2220, (uint64)3330));
Printf("Value is: '%V' ok\n", array(@Sep => ", ", (float)777.77, (float)777.11, (float)777.22));
Printf("Value is: '%V' ok\n", array(@Sep => ", ", (float)42.77, (float)42.11, (float)42.22));
Printf("Value is: '%V' ok\n", array(@Sep => ", ", "Hello", "World", "ok"));
Personal tools
Namespaces
Variants
Actions
Navigation
Toolbox