Core Function PrintfC

PrintfC( <expression>, <expressions>... )

Description

Create a formatted string.

expression

The format string and flags to use (see Remarks).

expressions

Variables that will be output according to the "Format Control".

Return Value

None.

Format Control

Formats are controlled by curly braces { }

So where as in C you would do  %d to define an int in the param here you would use {0:d} with the 0 being the param number which you wish to use so you could use the 10th param by typing {10:d} and place this anywhere in your string.

Since Sputnik makes use of { } in strings to define code you must escape it with \ for example: { } becomes \{ } this is vital however thats only if you use " " strings for example "Value is {0:d}" will fail because { } is treated as executable code "Value is \{0:d}" will work properly since now its defined properly 'Value is {0:d}' will work properly since the string is not parsed @"Value is {0:d}" will also work properly since the string is no longer parsed

Something to note is that params are counted from 0 for example

PrintfC("format string", "param0", "param1", "param2", "param3")

And so on so to use param0 in the format string

"format \{0}" or 'format {0}' or @"format {0}"

To use param 1

"format \{1}" or 'format {1}' or @"format {1}"

To use param 0 and 3

"format \{3}" or 'format {3}' or @"format {3}"

Now after you enter the param number you can a place a : then special formats as shown below for example to print a hex number

PrintfC("\{0:x4}\n", (int)1337)

See its using param 0 then : which means we want a special format then x to say we want to use a hex format then 4 to say we want the hex to be 4 chars long.

Strings

There really isn’t any formatting within a string, beyond it’s alignment. Alignment works for any argument being printed.

Example:

PrintfC("->\{0,10}<-\n", "Hello");
PrintfC("->\{0,-10}<-\n", "Hello");
// Generates
// ->     Hello<-
// ->Hello     <-

Numbers

Basic number formatting specifiers:

Custom number formatting:

The group separator is especially useful for formatting currency values which require that negative values be enclosed in parentheses. This currency formatting example at the bottom of this document makes it obvious:

Dates

Note that date formatting is especially dependent on the system’s regional settings; the example strings here are from my local locale.

The ‘U’ specifier seems broken; that string certainly isn’t sortable.

Custom date formatting:

Enumerations

Some Examples

PrintfC(@"{0:$#,##0.00;($#,##0.00);Zero}", 1243.50); // prints 1,243.50

PrintfC("\{0:(###) ###-####}", 8005551212); // prints (800) 555-1212

How do I show numbers with 5 fixed digits with leading zeroes

$num1 = 123;
$num2 = 45;
$num3 = 123456;
 
PrintfC("\{0:00000}\n", (int)$num1); // "00123"
PrintfC("\{0:00000}\n", (int)$num2); // "00045"
PrintfC("\{0:00000}\n", (int)$num3); // "123456"
 
PrintfC("\{0:d5}\n", (int)$num1); // "00123"
PrintfC("\{0:d5}\n", (int)$num2); // "00045"
PrintfC("\{0:d5}\n", (int)$num3); // "123456"

Substitute a string for a value

PrintfC("\{0:yes;;no}\n", (int)1); // This will print "no" if value is 0, "yes" if value is 1.
PrintfC("\{0:yes;;no}\n", (int)0); // This will print "no" if value is 0, "yes" if value is 1.

How to format as percentage without having the number multiplied by 100

PrintfC("\{0:##.00'%}\n", 1.23); // This will yield "1.23%".

How to use curly brackets within a formatted number

// Doubling them escapes them. For example:
PrintfC("\{\{SomeString}}=\{0}","Hello"); // will produce: "{SomeString}=Hellow"
PrintfC('{{SomeString}}={0}',"Hello"); // will produce: "{SomeString}=Hellow"
PrintfC(@"{{SomeString}}={0}","Hello"); // will produce: "{SomeString}=Hellow"

What’s a good way to format currency

$val = 4219.6;
PrintfC(@"{0:$#,#.00;Call Us;Call Us}", $val);
// This will return "$4,219.60". The .00 will
// force 2 decimals and the “;Call Us;Call Us” to show
// the text “Call Us” in place of negative and null
// values respectively. (Just in case)

How to format an integer, with commas for thousands

PrintfC("\{0:#,0}", (int)7770000); // 7,770,000

How to format a phone number to look like 800.555.1212

$tmp = fmt("\{0:###-###-####}", 8005551212);
$result = Replace($tmp, "-",".");
println($result); // Prints 800.555.1212

You could do it in one go example:

println(Replace(fmt("\{0:###-###-####}", 8005551212), "-",".")); // Prints 800.555.1212

Convert a number with a thousand separator to an int

$num = "1,000,000";
$val = (int)Replace($num, ",", "");
println($val); // Prints 1000000 and $val is now an int

Convert a number with a thousand separator to a double

$num = "1,000,000";
$val = (double)Replace($num, ",", "");
println($val); // Prints 1000000 and $val is now an double

How to convert from currency back to a number

This is not the best way to do it but i suppose it will do for now

$currency = 1337;
$str = fmt("\{0:c}", $currency); // Currency converted to string
$back = Replace(Replace(Replace($str, @CURRENCY, ""), ",", ""), ".", ""); // Currency converted back to string
println($str); // Print the currency
println($back); // Print the currency converted back to string

Remarks

If you wish to use a PrintfC more accurate to the C function printf() go see this function Printf( <format control>, <params> )

The console supports printing unicode however it's also possible that your choice of Console font does not support that particular character. Click on the Windows Toolbar Menu (icon like C:.) and select Properties -> Font. Try some other fonts to see if they display your character properly.

Warning: If you expect to use int, byte, float etc in the params then you must cast it as such for example:

$myint = 100;
$val = fmt("Value is 0x'\{0:x}'", (int)$myint); // The (int) will only take in $myint
 
$myint = 100;
$myint2 = 100;
$val = fmt("Value is 0x'\{0:x}'", (int)($myint + $myint2)); // The (int) will now take in $myint AND $myint2

Note how $myint was cast as an int? using (int)$myint this is vital since if you dont do that it might send a string or a float you never really know with $variables so its best to cast it.

There is an alternative method example:

$myint = 100;
$val = fmt("Value is 0x'\{0:x}'", int($myint));

Its up to you to decide which one to use.

If you wish to capture the output of PrintfC to create strings:

Go see fmt( <expression>, <expressions>... ) to PrintfC to strings.

Anything thats valid for PrintfC to print to console window is also valid for fmt to use to create strings.

Example

PrintfC("Value is 0x'\{0:x}'", (int)100);
// Prints 0x64 since the {0:x} is telling it to place param 0 as :x meaning hex