Normalization and LocalizationZend_Locale_Format is an internal component used by
Zend_Locale. All locale aware classes use
Zend_Locale_Format for normalization and localization of numbers and
dates. Normalization involves parsing input from a variety of data representations, like
dates, into a standardized, structured representation, such as a PHP
array with year, month, and day elements.
The exact same string containing a number or a date might mean different things to people
with different customs and conventions. Disambiguation of numbers and dates requires rules
about how to interpret these strings and normalize the values into a standardized data
structure. Thus, all methods in Zend_Locale_Format require a locale
in order to parse the input data.
Default "root" Locale
If no locale is specified, then normalization and localization will use the standard
"root" locale, which might yield unexpected behavior, if the input originated in a
different locale, or output for a specific locale was expected.
Number normalization: getNumber($input, Array $options)
There are many number systems
different from the common decimal system (e.g. "3.14").
Numbers can be normalized with the getNumber() function to
obtain the standard decimal representation. for all number-related discussions in this
manual, Arabic/European numerals
(0,1,2,3,4,5,6,7,8,9) are implied, unless explicitly stated otherwise. The
options array may contain a 'locale' to define grouping and decimal characters. The
array may also have a 'precision' to truncate excess digits from the result.
Number normalization $locale,
'precision' => 3)
);
print $number; // will return 13524.678
]]>Precision and Calculations
Since getNumber($value, array $options = array()) can
normalize extremely large numbers, check the result carefully before using finite
precision calculations, such as ordinary PHP math operations. For
example, if ((string)int_val($number) != $number) { use BCMath or GMP. Most PHP
installations support the BCMath extension.
Also, the precision of the resulting decimal representation can be rounded to a
desired length with getNumber() with the option
'precision'. If no precision is given, no rounding occurs. Use
only PHP integers to specify the precision.
If the resulting decimal representation should be truncated to a desired length
instead of rounded the option 'number_format' can be used
instead. Define the length of the decimal representation with the desired length
of zeros. The result will then not be rounded. So if the defined precision within
number_format is zero the value "1.6" will return "1", not "2.
See the example nearby:
Number normalization with precision 1,
'locale' => $locale)
);
print $number; // will return 13524.7
$number = Zend_Locale_Format::getNumber('13.524,678',
array('number_format' => '#.00',
'locale' => $locale)
);
print $number; // will return 13524.67
]]>Number localizationtoNumber($value, array $options = array()) can localize numbers
to the following supported locales. This
function will return a localized string of the given number in a conventional format for
a specific locale. The 'number_format' option explicitly specifies a non-default number
format for use with toNumber().
Number localization $locale));
// will return 13.547,36
print $number;
]]>Unlimited lengthtoNumber() can localize numbers with unlimited length.
It is not related to integer or float limitations.
The same way as within getNumber(),
toNumber() handles precision. If no precision is given, the
complete localized number will be returned.
Number localization with precision 2,
'locale' => $locale));
// will return 13.547,37
print $number;
]]>
Using the option 'number_format' a self defined format for generating a number can be
defined. The format itself has to be given in CLDR format as
described below. The locale is used to get separation, precision and other number
formatting signs from it. German for example defines ',' as precision separation and in
English the '.' sign is used.
Format tokens for self generated number formatsTokenDescriptionExample formatGenerated output#0Generates a number without precision and separation#01234567,
Generates a separation with the length from separation to next
separation or to 0
#,##01,234,567#,##,##0
Generates a standard separation of 3 and all following separations with
2
#,##,##012,34,567.Generates a precision#0.#1234567.12340Generates a precision with a defined length#0.001234567.12
Using a self defined number format '#,#0.00',
'locale' => 'de')
);
// will return 1.35.47,36
print $number;
$number = Zend_Locale_Format::toNumber(13547.3,
array('number_format' => '#,##0.00',
'locale' => 'de')
);
// will return 13.547,30
print $number;
]]>Number testingisNumber($value, array $options = array()) checks if a given
string is a number and returns TRUE or FALSE.
Number testing 'de_AT'))) {
print "Number";
} else {
print "not a Number";
}
]]>Float value normalization
Floating point values can be parsed with the
getFloat($value, array $options = array()) function. A floating
point value will be returned.
Floating point value normalization 2,
'locale' => $locale)
);
// will return 13524.68
print $number;
]]>Floating point value localizationtoFloat() can localize floating point values. This function
will return a localized string of the given number.
Floating point value localization 1,
'locale' => $locale)
);
// will return 13.547,4
print $number;
]]>Floating point value testingisFloat($value, array $options = array()) checks if a given
string is a floating point value and returns TRUE or
FALSE.
Floating point value testing $locale))) {
print "float";
} else {
print "not a float";
}
]]>Integer value normalization
Integer values can be parsed with the getInteger() function. A
integer value will be returned.
Integer value normalization $locale));
// will return 13524
print $number;
]]>Integer point value localizationtoInteger($value, array $options = array()) can localize
integer values. This function will return a localized string of the given number.
Integer value localization $locale));
// will return 13.547
print $number;
]]>Integer value testingisInteger($value, array $options = array()) checks if a given
string is an integer value and returns TRUE or
FALSE.
Integer value testing $locale))) {
print "integer";
} else {
print "not an integer";
}
]]>Numeral System ConversionZend_Locale_Format::convertNumerals() converts digits between
different numeral
systems, including the standard Arabic/European/Latin numeral system
(0,1,2,3,4,5,6,7,8,9), not to be confused with Eastern Arabic
numerals sometimes used with the Arabic language to express numerals.
Attempts to use an unsupported numeral system will result in an exception, to avoid
accidentally performing an incorrect conversion due to a spelling error. All characters
in the input, which are not numerals for the selected numeral system, are copied to the
output with no conversion provided for unit separator characters.
Zend_Locale* components rely on the data provided by
CLDR (see their list
of scripts grouped by language).
In CLDR and hereafter, the Europena/Latin numerals will
be referred to as "Latin" or by the assigned 4-letter code "Latn".
Also, the CLDR refers to this numeral systems as "scripts".
Suppose a web form collected a numeric input expressed using Eastern Arabic digits
"١٠٠". Most software and PHP functions expect input using Arabic
numerals. Fortunately, converting this input to its equivalent Latin numerals "100"
requires little effort using convertNumerals($inputNumeralString,
$sourceNumeralSystem, $destNumeralSystem), which returns the
$input with numerals in the script
$sourceNumeralSystem converted to the script
$destNumeralSystem.
Converting numerals from Eastern Arabic scripts to European/Latin scripts
Similarly, any of the supported numeral systems may be converted to any other supported
numeral system.
Converting numerals from Latin script to Eastern Arabic script
Getting 4 letter CLDR script code using a native-language name of the script
For a list of supported numeral systems call
Zend_Locale::getTranslationList('numberingsystem', 'en').