Obis4SQL Wiki

Tato stránka je pouze pro čtení. Můžete si pouze prohlédnout zdrojový kód, ale ne ho měnit. Zeptejte se správce, pokud si myslíte, že něco není v pořádku.
===== Formátovací funkce =====


==== Format ====

Funkce **Format** v pascalu, pouzite napr. v \COUNTER() v fbutil

Format strings passed to the string formatting routines contain two types of
objects -- literal characters and format specifiers. Literal characters are
copied verbatim to the resulting string. Format specifiers fetch arguments from
the argument list and apply formatting to them.

Format specifiers have the following form:
<code>
"%" [index ":"] ["-"] [width] ["." prec] type
</code>
A format specifier begins with a % character. After the % come the following, in this order:
  * An optional argument zero-offset index specifier (that is, the first item has index 0), [index ":"]
  * An optional left justification indicator, ["-"]
  * An optional width specifier, [width]
  * An optional precision specifier, ["." prec]
  * The conversion type character, type

The following table summarizes the possible values for type: 

**d** Decimal. The argument must be an integer value. The value is converted to a
string of decimal digits. If the format string contains a precision specifier,
it indicates that the resulting string must contain at least the specified
number of digits; if the value has less digits, the resulting string is
left-padded with zeros.

**u** Unsigned decimal. Similar to 'd' but no sign is output.

**e** Scientific. The argument must be a floating-point value. The value is
converted to a string of the form "-d.ddd...E+ddd". The resulting string starts
with a minus sign if the number is negative. One digit always precedes the
decimal point.The total number of digits in the resulting string (including the
one before the decimal point) is given by the precision specifier in the format
string~Wa default precision of 15 is assumed if no precision specifier is
present. The "E" exponent character in the resulting string is always followed
by a plus or minus sign and at least three digits.

**f** Fixed. The argument must be a floating-point value. The value is converted to
a string of the form "-ddd.ddd...". The resulting string starts with a minus
sign if the number is negative.The number of digits after the decimal point is
given by the precision specifier in the format string~Wa default of 2 decimal
digits is assumed if no precision specifier is present. 

**g** General. The argument must be a floating-point value. The value is converted
to the shortest possible decimal string using fixed or scientific format. The
number of significant digits in the resulting string is given by the precision
specifier in the format string~Wa default precision of 15 is assumed if no
precision specifier is present.Trailing zeros are removed from the resulting
string, and a decimal point appears only if necessary. The resulting string
uses fixed point format if the number of digits to the left of the decimal
point in the value is less than or equal to the specified precision, and if the
value is greater than or equal to 0.00001. Otherwise the resulting string uses
scientific format. 

**n** Number. The argument must be a floating-point value. The value is converted
to a string of the form "-d,ddd,ddd.ddd...". The "n" format corresponds to the
"f" format, except that the resulting string contains thousand separators.

**m** Money. The argument must be a floating-point value. The value is converted to
a string that represents a currency amount. The conversion is controlled by the
CurrencyString, CurrencyFormat, NegCurrFormat, ThousandSeparator,
DecimalSeparator, and CurrencyDecimals global variables or their equivalent in
a TFormatSettings data structure. If the format string contains a precision
specifier, it overrides the value given by the CurrencyDecimals global variable
or its TFormatSettings equivalent.

**p** Pointer. The argument must be a pointer value. The value is converted to an 8
character string that represents the pointers value in hexadecimal.

**s** String. The argument must be a character, a string, or a PChar value. The
string or character is inserted in place of the format specifier. The precision
specifier, if present in the format string, specifies the maximum length of the
resulting string. If the argument is a string that is longer than this maximum,
the string is truncated.

**x** Hexadecimal. The argument must be an integer value. The value is converted to
a string of hexadecimal digits. If the format string contains a precision
specifier, it indicates that the resulting string must contain at least the
specified number of digits; if the value has fewer digits, the resulting string
is left-padded with zeros.

Conversion characters may be specified in uppercase as well as in
lowercase~Wboth produce the same results. For all floating-point formats, the
actual characters used as decimal and thousand separators are obtained from the
DecimalSeparator and ThousandSeparator global variables or their
TFormatSettings equivalent. Index, width, and precision specifiers can be
specified directly using decimal digit string (for example "%10d"), or
indirectly using an asterisk character (for example "%*.*f"). When using an
asterisk, the next argument in the argument list (which must be an integer
value) becomes the value that is actually used. For example,

Example:

Format('%*.*f', [8, 2, 123.456]); is equivalent to Format('%8.2f', [123.456]);

A width specifier sets the minimum field width for a conversion. If the
resulting string is shorter than the minimum field width, it is padded with
blanks to increase the field width. The default is to right-justify the result
by adding blanks in front of the value, but if the format specifier contains a
left-justification indicator (a "-" character preceding the width specifier),
the result is left-justified by adding blanks after the value.

An index specifier sets the current argument list index to the specified value.
The index of the first argument in the argument list is 0. Using index
specifiers, it is possible to format the same argument multiple times. For
example "Format('%d %d %0:d %1:d', [10, 20])" produces the string '10 20 10
20'.

Note: Setting the index specifier affects all subsequent formatting. That is,
Format('%d %d %d %0:d %d', [1, 2, 3, 4]) returns '1 2 3 1 2', not '1 2 3 1 4'.
To get the latter result, you have must use  Format('%d %d %d %0:d %3:d', [1,
2, 3, 4])




==== FormatFloat  - používá se pro formátování měny ====

FormatFloat formats the floating-point value given by Value using the format
string given by Format. The following format specifiers are supported in the
format string:

Specifier Represents:

**0** Digit place holder. If the value being formatted has a digit in the position
where the '0' appears in the format string, then that digit is copied to the
output string. Otherwise, a '0' is stored in that position in the output
string.

**#** Digit placeholder. If the value being formatted has a digit in the position
where the '#' appears in the format string, then that digit is copied to the
output string. Otherwise, nothing is stored in that position in the output 
string.

**.** Decimal point. The first '.' character in the format string determines the
location of the decimal separator in the formatted value; any additional '.'
characters are ignored. The actual character used as a the decimal separator in
the output string is determined by the DecimalSeparator global variable or its
TFormatSettings equivalent.

**,** Thousand separator. If the format string contains one or more ',' characters,
the output will have thousand separators inserted between each group of three
digits to the left of the decimal point. The placement and number of ','
characters in the format string does not affect the output, except to indicate
that thousand separators are wanted. The actual character used as a the
thousand separator in the output is determined by the ThousandSeparator global
variable or its TFormatSettings equivalent.

**E+** Scientific notation. If any of the strings 'E+', 'E-', 'e+', or 'e-' are
contained in the format string, the number is formatted using scientific
notation. A group of up to four '0' characters can immediately follow the 'E+',
'E-', 'e+', or 'e-' to determine the minimum number of digits in the exponent.
The 'E+' and 'e+' formats cause a plus sign to be output for positive exponents
and a minus sign to be output for negative exponents. The 'E-' and 'e-' formats
output a sign character only for negative exponents.

**'xx'/"xx" ** Characters enclosed in single or double quotes are output as-is, and do not
affect formatting.

**;** Separates sections for positive, negative, and zero numbers in the format
string.

The locations of the leftmost '0' before the decimal point in the format string
and the rightmost '0' after the decimal point in the format string determine
the range of digits that are always present in the output string.

The number being formatted is always rounded to as many decimal places as there
are digit placeholders ('0' or '#') to the right of the decimal point. If the
format string contains no decimal point, the value being formatted is rounded
to the nearest whole number.

If the number being formatted has more digits to the left of the decimal
separator than there are digit placeholders to the left of the '.' character in
the format string, the extra digits are output before the first digit
placeholder. To allow different formats for positive, negative, and zero
values, the format string can contain between one and three sections separated
by semicolons.

One section: The format string applies to all values. Two sections: The first
section applies to positive values and zeros, and the second section applies to
negative values. Three sections: The first section applies to positive values,
the second applies to negative values, and the third applies to zeros.

If the section for negative values or the section for zero values is empty,
that is if there is nothing between the semicolons that delimit the section,
the section for positive values is used instead.

If the section for positive values is empty, or if the entire format string is
empty, the value is formatted using general floating-point formatting with 15
significant digits, corresponding to a call to FloatToStrF with the ffGeneral
format. General floating-point formatting is also used if the value has more
than 18 digits to the left of the decimal point and the format string does not
specify scientific notation.

The first form of FormatFloat is not thread-safe, because it uses localization
information contained in global variables. The second form of FormatFloat,
which is thread-safe, refers to localization information contained in the
FormatSettings parameter. Before calling the thread-safe form of FormatFloat,
you must populate FormatSettings with localization information. To populate
FormatSettings with a set of default locale values, call
GetLocaleFormatSettings.