Joomla Platform  13.1
Documentation des API du framework Joomla Platform
 Tout Classes Espaces de nommage Fichiers Fonctions Variables Pages
Fonctions membres publiques statiques | Attributs protégés statiques
Référence de la classe JString

Liste de tous les membres

Fonctions membres publiques statiques

static splitCamelCase ($string)
static increment ($string, $style= 'default', $n=0)
static strpos ($str, $search, $offset=false)
static strrpos ($str, $search, $offset=0)
static substr ($str, $offset, $length=false)
static strtolower ($str)
static strtoupper ($str)
static strlen ($str)
static str_ireplace ($search, $replace, $str, $count=null)
static str_split ($str, $split_len=1)
static strcasecmp ($str1, $str2, $locale=false)
static strcmp ($str1, $str2, $locale=false)
static strcspn ($str, $mask, $start=null, $length=null)
static stristr ($str, $search)
static strrev ($str)
static strspn ($str, $mask, $start=null, $length=null)
static substr_replace ($str, $repl, $start, $length=null)
static ltrim ($str, $charlist=false)
static rtrim ($str, $charlist=false)
static trim ($str, $charlist=false)
static ucfirst ($str, $delimiter=null, $newDelimiter=null)
static ucwords ($str)
static transcode ($source, $from_encoding, $to_encoding)
static valid ($str)
static compliant ($str)
static parse_url ($url)

Attributs protégés statiques

static $incrementStyles

Description détaillée

Définition à la ligne 47 du fichier string.php.

Documentation des fonctions membres

static JString::compliant (   $str)
static

Tests whether a string complies as UTF-8. This will be much faster than utf8_is_valid but will pass five and six octet UTF-8 sequences, which are not supported by Unicode and so cannot be displayed correctly in a browser. In other words it is not as strict as utf8_is_valid but it's faster. If you use it to validate user input, you place yourself at the risk that attackers will be able to inject 5 and 6 byte sequences (which may or may not be a significant risk, depending on what you are are doing)

Paramètres:
string$strUTF-8 string to check
Renvoie:
boolean TRUE if string is valid UTF-8
Voir également:
JString::valid()
http://www.php.net/manual/en/reference.pcre.pattern.modifiers.php#54805
Depuis:
11.1

Définition à la ligne 919 du fichier string.php.

Références strlen().

{
if (strlen($str) == 0)
{
return true;
}
/*
* If even just the first character can be matched, when the /u
* modifier is used, then it's valid UTF-8. If the UTF-8 is somehow
* invalid, nothing at all will match, even if the string contains
* some valid sequences
*/
return (preg_match('/^.{1}/us', $str, $ar) == 1);
}

+ Voici le graphe d'appel pour cette fonction :

static JString::increment (   $string,
  $style = 'default',
  $n = 0 
)
static

Increments a trailing number in a string.

Used to easily create distinct labels when copying objects. The method has the following styles:

default: "Label" becomes "Label (2)" dash: "Label" becomes "Label-2"

Paramètres:
string$stringThe source string.
string$styleThe the style (default|dash).
integer$nIf supplied, this number is used for the copy, otherwise it is the 'next' number.
Renvoie:
string The incremented string.
Depuis:
11.3

Définition à la ligne 107 du fichier string.php.

Référencé par JModelAdmin\generateNewTitle().

{
$styleSpec = isset(self::$incrementStyles[$style]) ? self::$incrementStyles[$style] : self::$incrementStyles['default'];
// Regular expression search and replace patterns.
if (is_array($styleSpec[0]))
{
$rxSearch = $styleSpec[0][0];
$rxReplace = $styleSpec[0][1];
}
else
{
$rxSearch = $rxReplace = $styleSpec[0];
}
// New and old (existing) sprintf formats.
if (is_array($styleSpec[1]))
{
$newFormat = $styleSpec[1][0];
$oldFormat = $styleSpec[1][1];
}
else
{
$newFormat = $oldFormat = $styleSpec[1];
}
// Check if we are incrementing an existing pattern, or appending a new one.
if (preg_match($rxSearch, $string, $matches))
{
$n = empty($n) ? ($matches[1] + 1) : $n;
$string = preg_replace($rxReplace, sprintf($oldFormat, $n), $string);
}
else
{
$n = empty($n) ? 2 : $n;
$string .= sprintf($newFormat, $n);
}
return $string;
}

+ Voici le graphe des appelants de cette fonction :

static JString::ltrim (   $str,
  $charlist = false 
)
static

UTF-8 aware replacement for ltrim()

Strip whitespace (or other characters) from the beginning of a string You only need to use this if you are supplying the charlist optional arg and it contains UTF-8 characters. Otherwise ltrim will work normally on a UTF-8 string

Paramètres:
string$strThe string to be trimmed
string$charlistThe optional charlist of additional characters to trim
Renvoie:
string The trimmed string
Voir également:
http://www.php.net/ltrim
Depuis:
11.1

Définition à la ligne 585 du fichier string.php.

Références jimport(), et utf8_ltrim().

{
if (empty($charlist) && $charlist !== false)
{
return $str;
}
jimport('phputf8.trim');
if ($charlist === false)
{
return utf8_ltrim($str);
}
else
{
return utf8_ltrim($str, $charlist);
}
}

+ Voici le graphe d'appel pour cette fonction :

static JString::parse_url (   $url)
static

Does a UTF-8 safe version of PHP parse_url function

Paramètres:
string$urlURL to parse
Renvoie:
mixed Associative array or false if badly formed URL.
Voir également:
http://us3.php.net/manual/en/function.parse-url.php
Depuis:
11.1

Définition à la ligne 945 du fichier string.php.

Référencé par JUri\parse(), JFormRuleUrl\test(), JStringPunycode\urlToPunycode(), et JStringPunycode\urlToUTF8().

{
$result = false;
// Build arrays of values we need to decode before parsing
$entities = array('%21', '%2A', '%27', '%28', '%29', '%3B', '%3A', '%40', '%26', '%3D', '%24', '%2C', '%2F', '%3F', '%23', '%5B', '%5D');
$replacements = array('!', '*', "'", "(", ")", ";", ":", "@", "&", "=", "$", ",", "/", "?", "#", "[", "]");
// Create encoded URL with special URL characters decoded so it can be parsed
// All other characters will be encoded
$encodedURL = str_replace($entities, $replacements, urlencode($url));
// Parse the encoded URL
$encodedParts = parse_url($encodedURL);
// Now, decode each value of the resulting array
if ($encodedParts)
{
foreach ($encodedParts as $key => $value)
{
$result[$key] = urldecode(str_replace($replacements, $entities, $value));
}
}
return $result;
}

+ Voici le graphe des appelants de cette fonction :

static JString::rtrim (   $str,
  $charlist = false 
)
static

UTF-8 aware replacement for rtrim() Strip whitespace (or other characters) from the end of a string You only need to use this if you are supplying the charlist optional arg and it contains UTF-8 characters. Otherwise rtrim will work normally on a UTF-8 string

Paramètres:
string$strThe string to be trimmed
string$charlistThe optional charlist of additional characters to trim
Renvoie:
string The trimmed string
Voir également:
http://www.php.net/rtrim
Depuis:
11.1

Définition à la ligne 619 du fichier string.php.

Références jimport(), et utf8_rtrim().

{
if (empty($charlist) && $charlist !== false)
{
return $str;
}
jimport('phputf8.trim');
if ($charlist === false)
{
return utf8_rtrim($str);
}
else
{
return utf8_rtrim($str, $charlist);
}
}

+ Voici le graphe d'appel pour cette fonction :

static JString::splitCamelCase (   $string)
static

Split a string in camel case format

"FooBarABCDef" becomes array("Foo", "Bar", "ABC", "Def"); "JFooBar" becomes array("J", "Foo", "Bar"); "J001FooBar002" becomes array("J001", "Foo", "Bar002"); "abcDef" becomes array("abc", "Def"); "abc_defGhi_Jkl" becomes array("abc_def", "Ghi_Jkl"); "ThisIsA_NASAAstronaut" becomes array("This", "Is", "A_NASA", "Astronaut")), "JohnFitzgerald_Kennedy" becomes array("John", "Fitzgerald_Kennedy")),

Paramètres:
string$stringThe source string.
Renvoie:
array The splitted string.
Obsolète:
12.3 (Platform) & 4.0 (CMS) - Use JStringNormalise::fromCamelCase()
Depuis:
11.3

Définition à la ligne 84 du fichier string.php.

Références JLog\add(), JStringNormalise\fromCamelCase(), et JLog\WARNING.

{
JLog::add('JString::splitCamelCase has been deprecated. Use JStringNormalise::fromCamelCase.', JLog::WARNING, 'deprecated');
return JStringNormalise::fromCamelCase($string, true);
}

+ Voici le graphe d'appel pour cette fonction :

static JString::str_ireplace (   $search,
  $replace,
  $str,
  $count = null 
)
static

UTF-8 aware alternative to str_ireplace Case-insensitive version of str_replace

Paramètres:
string$searchString to search
string$replaceExisting string to replace
string$strNew string to replace with
integer$countOptional count value to be passed by referene
Renvoie:
string UTF-8 String
Voir également:
http://www.php.net/str_ireplace
Depuis:
11.1

Définition à la ligne 289 du fichier string.php.

Références jimport(), et utf8_ireplace().

Référencé par JTableContent\check().

{
jimport('phputf8.str_ireplace');
if ($count === false)
{
return utf8_ireplace($search, $replace, $str);
}
else
{
return utf8_ireplace($search, $replace, $str, $count);
}
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

static JString::str_split (   $str,
  $split_len = 1 
)
static

UTF-8 aware alternative to str_split Convert a string to an array

Paramètres:
string$strUTF-8 encoded string to process
integer$split_lenNumber to characters to split string by
Renvoie:
array
Voir également:
http://www.php.net/str_split
Depuis:
11.1

Définition à la ligne 315 du fichier string.php.

Références jimport(), et utf8_str_split().

{
jimport('phputf8.str_split');
return utf8_str_split($str, $split_len);
}

+ Voici le graphe d'appel pour cette fonction :

static JString::strcasecmp (   $str1,
  $str2,
  $locale = false 
)
static

UTF-8/LOCALE aware alternative to strcasecmp A case insensitive string comparison

Paramètres:
string$str1string 1 to compare
string$str2string 2 to compare
mixed$localeThe locale used by strcoll or false to use classical comparison
Renvoie:
integer < 0 if str1 is less than str2; > 0 if str1 is greater than str2, and 0 if they are equal.
Voir également:
http://www.php.net/strcasecmp
http://www.php.net/strcoll
http://www.php.net/setlocale
Depuis:
11.1

Définition à la ligne 337 du fichier string.php.

Références stristr(), utf8_strcasecmp(), et utf8_strtolower().

Référencé par JArrayHelper\_sortObjects().

{
if ($locale)
{
// Get current locale
$locale0 = setlocale(LC_COLLATE, 0);
if (!$locale = setlocale(LC_COLLATE, $locale))
{
$locale = $locale0;
}
// See if we have successfully set locale to UTF-8
if (!stristr($locale, 'UTF-8') && stristr($locale, '_') && preg_match('~\.(\d+)$~', $locale, $m))
{
$encoding = 'CP' . $m[1];
}
elseif (stristr($locale, 'UTF-8') || stristr($locale, 'utf8'))
{
$encoding = 'UTF-8';
}
else
{
$encoding = 'nonrecodable';
}
// If we successfully set encoding it to utf-8 or encoding is sth weird don't recode
if ($encoding == 'UTF-8' || $encoding == 'nonrecodable')
{
return strcoll(utf8_strtolower($str1), utf8_strtolower($str2));
}
else
{
return strcoll(
self::transcode(utf8_strtolower($str1), 'UTF-8', $encoding),
self::transcode(utf8_strtolower($str2), 'UTF-8', $encoding)
);
}
}
else
{
return utf8_strcasecmp($str1, $str2);
}
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

static JString::strcmp (   $str1,
  $str2,
  $locale = false 
)
static

UTF-8/LOCALE aware alternative to strcmp A case sensitive string comparison

Paramètres:
string$str1string 1 to compare
string$str2string 2 to compare
mixed$localeThe locale used by strcoll or false to use classical comparison
Renvoie:
integer < 0 if str1 is less than str2; > 0 if str1 is greater than str2, and 0 if they are equal.
Voir également:
http://www.php.net/strcmp
http://www.php.net/strcoll
http://www.php.net/setlocale
Depuis:
11.1

Définition à la ligne 397 du fichier string.php.

Références stristr().

Référencé par JArrayHelper\_sortObjects().

{
if ($locale)
{
// Get current locale
$locale0 = setlocale(LC_COLLATE, 0);
if (!$locale = setlocale(LC_COLLATE, $locale))
{
$locale = $locale0;
}
// See if we have successfully set locale to UTF-8
if (!stristr($locale, 'UTF-8') && stristr($locale, '_') && preg_match('~\.(\d+)$~', $locale, $m))
{
$encoding = 'CP' . $m[1];
}
elseif (stristr($locale, 'UTF-8') || stristr($locale, 'utf8'))
{
$encoding = 'UTF-8';
}
else
{
$encoding = 'nonrecodable';
}
// If we successfully set encoding it to utf-8 or encoding is sth weird don't recode
if ($encoding == 'UTF-8' || $encoding == 'nonrecodable')
{
return strcoll($str1, $str2);
}
else
{
return strcoll(self::transcode($str1, 'UTF-8', $encoding), self::transcode($str2, 'UTF-8', $encoding));
}
}
else
{
return strcmp($str1, $str2);
}
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

static JString::strcspn (   $str,
  $mask,
  $start = null,
  $length = null 
)
static

UTF-8 aware alternative to strcspn Find length of initial segment not matching mask

Paramètres:
string$strThe string to process
string$maskThe mask
integer$startOptional starting character position (in characters)
integer$lengthOptional length
Renvoie:
integer The length of the initial segment of str1 which does not contain any of the characters in str2
Voir également:
http://www.php.net/strcspn
Depuis:
11.1

Définition à la ligne 453 du fichier string.php.

Références jimport(), et utf8_strcspn().

{
jimport('phputf8.strcspn');
if ($start === false && $length === false)
{
return utf8_strcspn($str, $mask);
}
elseif ($length === false)
{
return utf8_strcspn($str, $mask, $start);
}
else
{
return utf8_strcspn($str, $mask, $start, $length);
}
}

+ Voici le graphe d'appel pour cette fonction :

static JString::stristr (   $str,
  $search 
)
static

UTF-8 aware alternative to stristr Returns all of haystack from the first occurrence of needle to the end. needle and haystack are examined in a case-insensitive manner Find first occurrence of a string using case insensitive comparison

Paramètres:
string$strThe haystack
string$searchThe needle
Renvoie:
string the sub string
Voir également:
http://www.php.net/stristr
Depuis:
11.1

Définition à la ligne 485 du fichier string.php.

Références jimport(), et utf8_stristr().

Référencé par strcasecmp(), et strcmp().

{
jimport('phputf8.stristr');
return utf8_stristr($str, $search);
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

static JString::strlen (   $str)
static

UTF-8 aware alternative to strlen.

Returns the number of characters in the string (NOT THE NUMBER OF BYTES),

Paramètres:
string$strUTF-8 string.
Renvoie:
integer Number of UTF-8 characters in string.
Voir également:
http://www.php.net/strlen
Depuis:
11.1

Définition à la ligne 270 du fichier string.php.

Références utf8_strlen().

Référencé par compliant(), et valid().

{
return utf8_strlen($str);
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

static JString::strpos (   $str,
  $search,
  $offset = false 
)
static

UTF-8 aware alternative to strpos.

Find position of first occurrence of a string.

Paramètres:
string$strString being examined
string$searchString being searched for
integer$offsetOptional, specifies the position from which the search should be performed
Renvoie:
mixed Number of characters before the first match or FALSE on failure
Voir également:
http://www.php.net/strpos
Depuis:
11.1

Définition à la ligne 162 du fichier string.php.

Références utf8_strpos().

{
if ($offset === false)
{
return utf8_strpos($str, $search);
}
else
{
return utf8_strpos($str, $search, $offset);
}
}

+ Voici le graphe d'appel pour cette fonction :

static JString::strrev (   $str)
static

UTF-8 aware alternative to strrev Reverse a string

Paramètres:
string$strString to be reversed
Renvoie:
string The string in reverse character order
Voir également:
http://www.php.net/strrev
Depuis:
11.1

Définition à la ligne 503 du fichier string.php.

Références jimport(), et utf8_strrev().

{
jimport('phputf8.strrev');
return utf8_strrev($str);
}

+ Voici le graphe d'appel pour cette fonction :

static JString::strrpos (   $str,
  $search,
  $offset = 0 
)
static

UTF-8 aware alternative to strrpos Finds position of last occurrence of a string

Paramètres:
string$strString being examined.
string$searchString being searched for.
integer$offsetOffset from the left of the string.
Renvoie:
mixed Number of characters before the last match or false on failure
Voir également:
http://www.php.net/strrpos
Depuis:
11.1

Définition à la ligne 187 du fichier string.php.

Références utf8_strrpos().

{
return utf8_strrpos($str, $search, $offset);
}

+ Voici le graphe d'appel pour cette fonction :

static JString::strspn (   $str,
  $mask,
  $start = null,
  $length = null 
)
static

UTF-8 aware alternative to strspn Find length of initial segment matching mask

Paramètres:
string$strThe haystack
string$maskThe mask
integer$startStart optional
integer$lengthLength optional
Renvoie:
integer
Voir également:
http://www.php.net/strspn
Depuis:
11.1

Définition à la ligne 524 du fichier string.php.

Références jimport(), et utf8_strspn().

{
jimport('phputf8.strspn');
if ($start === null && $length === null)
{
return utf8_strspn($str, $mask);
}
elseif ($length === null)
{
return utf8_strspn($str, $mask, $start);
}
else
{
return utf8_strspn($str, $mask, $start, $length);
}
}

+ Voici le graphe d'appel pour cette fonction :

static JString::strtolower (   $str)
static

UTF-8 aware alternative to strtlower

Make a string lowercase Note: The concept of a characters "case" only exists is some alphabets such as Latin, Greek, Cyrillic, Armenian and archaic Georgian - it does not exist in the Chinese alphabet, for example. See Unicode Standard Annex #21: Case Mappings

Paramètres:
string$strString being processed
Renvoie:
mixed Either string in lowercase or FALSE is UTF-8 invalid
Voir également:
http://www.php.net/strtolower
Depuis:
11.1

Définition à la ligne 233 du fichier string.php.

Références utf8_strtolower().

Référencé par JStringInflector\_getCachedPlural(), JStringInflector\_getCachedSingular(), JStringInflector\_setCache(), JFilterOutput\stringURLSafe(), JFilterOutput\stringURLUnicodeSlug(), et JLanguage\transliterate().

{
return utf8_strtolower($str);
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

static JString::strtoupper (   $str)
static

UTF-8 aware alternative to strtoupper Make a string uppercase Note: The concept of a characters "case" only exists is some alphabets such as Latin, Greek, Cyrillic, Armenian and archaic Georgian - it does not exist in the Chinese alphabet, for example. See Unicode Standard Annex #21: Case Mappings

Paramètres:
string$strString being processed
Renvoie:
mixed Either string in uppercase or FALSE is UTF-8 invalid
Voir également:
http://www.php.net/strtoupper
Depuis:
11.1

Définition à la ligne 253 du fichier string.php.

Références utf8_strtoupper().

{
return utf8_strtoupper($str);
}

+ Voici le graphe d'appel pour cette fonction :

static JString::substr (   $str,
  $offset,
  $length = false 
)
static

UTF-8 aware alternative to substr Return part of a string given character offset (and optionally length)

Paramètres:
string$strString being processed
integer$offsetNumber of UTF-8 characters offset (from left)
integer$lengthOptional length in UTF-8 characters from offset
Renvoie:
mixed string or FALSE if failure
Voir également:
http://www.php.net/substr
Depuis:
11.1

Définition à la ligne 205 du fichier string.php.

Références utf8_substr().

{
if ($length === false)
{
return utf8_substr($str, $offset);
}
else
{
return utf8_substr($str, $offset, $length);
}
}

+ Voici le graphe d'appel pour cette fonction :

static JString::substr_replace (   $str,
  $repl,
  $start,
  $length = null 
)
static

UTF-8 aware substr_replace Replace text within a portion of a string

Paramètres:
string$strThe haystack
string$replThe replacement string
integer$startStart
integer$lengthLength (optional)
Renvoie:
string
Voir également:
http://www.php.net/substr_replace
Depuis:
11.1

Définition à la ligne 556 du fichier string.php.

Références utf8_substr_replace().

{
// Loaded by library loader
if ($length === false)
{
return utf8_substr_replace($str, $repl, $start);
}
else
{
return utf8_substr_replace($str, $repl, $start, $length);
}
}

+ Voici le graphe d'appel pour cette fonction :

static JString::transcode (   $source,
  $from_encoding,
  $to_encoding 
)
static

Transcode a string.

Paramètres:
string$sourceThe string to transcode.
string$from_encodingThe source encoding.
string$to_encodingThe target encoding.
Renvoie:
mixed The transcoded string, or null if the source was not a string.

11.1

Définition à la ligne 736 du fichier string.php.

{
if (is_string($source))
{
switch (ICONV_IMPL)
{
case 'glibc':
return @iconv($from_encoding, $to_encoding . '//TRANSLIT,IGNORE', $source);
case 'libiconv':
default:
return iconv($from_encoding, $to_encoding . '//IGNORE//TRANSLIT', $source);
}
}
return null;
}
static JString::trim (   $str,
  $charlist = false 
)
static

UTF-8 aware replacement for trim() Strip whitespace (or other characters) from the beginning and end of a string Note: you only need to use this if you are supplying the charlist optional arg and it contains UTF-8 characters. Otherwise trim will work normally on a UTF-8 string

Paramètres:
string$strThe string to be trimmed
string$charlistThe optional charlist of additional characters to trim
Renvoie:
string The trimmed string
Voir également:
http://www.php.net/trim
Depuis:
11.1

Définition à la ligne 653 du fichier string.php.

Références jimport(), et utf8_trim().

{
if (empty($charlist) && $charlist !== false)
{
return $str;
}
jimport('phputf8.trim');
if ($charlist === false)
{
return utf8_trim($str);
}
else
{
return utf8_trim($str, $charlist);
}
}

+ Voici le graphe d'appel pour cette fonction :

static JString::ucfirst (   $str,
  $delimiter = null,
  $newDelimiter = null 
)
static

UTF-8 aware alternative to ucfirst Make a string's first character uppercase or all words' first character uppercase

Paramètres:
string$strString to be processed
string$delimiterThe words delimiter (null means do not split the string)
string$newDelimiterThe new words delimiter (null means equal to $delimiter)
Renvoie:
string If $delimiter is null, return the string with first character as upper case (if applicable) else consider the string of words separated by the delimiter, apply the ucfirst to each words and return the string with the new delimiter
Voir également:
http://www.php.net/ucfirst
Depuis:
11.1

Définition à la ligne 687 du fichier string.php.

Références jimport(), et utf8_ucfirst().

Référencé par JFormField\__construct(), et JFormHelper\loadClass().

{
jimport('phputf8.ucfirst');
if ($delimiter === null)
{
return utf8_ucfirst($str);
}
else
{
if ($newDelimiter === null)
{
$newDelimiter = $delimiter;
}
return implode($newDelimiter, array_map('utf8_ucfirst', explode($delimiter, $str)));
}
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

static JString::ucwords (   $str)
static

UTF-8 aware alternative to ucwords Uppercase the first character of each word in a string

Paramètres:
string$strString to be processed
Renvoie:
string String with first char of each word uppercase
Voir également:
http://www.php.net/ucwords
Depuis:
11.1

Définition à la ligne 716 du fichier string.php.

Références jimport(), et utf8_ucwords().

{
jimport('phputf8.ucwords');
return utf8_ucwords($str);
}

+ Voici le graphe d'appel pour cette fonction :

static JString::valid (   $str)
static

Tests a string as to whether it's valid UTF-8 and supported by the Unicode standard.

Note: this function has been modified to simple return true or false.

Paramètres:
string$strUTF-8 encoded string.
Renvoie:
boolean true if valid
Auteur:
hsivo.nosp@m.nen@.nosp@m.iki.f.nosp@m.i
Voir également:
http://hsivonen.iki.fi/php-utf8/
JString::compliant()
Depuis:
11.1

End of the multi-octet sequence. mUcs4 now contains the final Unicode codepoint to be output

((0xC0 & (*in) != 0x80) && (mState != 0)) Incomplete multi-octet sequence.

Définition à la ligne 767 du fichier string.php.

Références strlen().

Référencé par JFormRuleUrl\test().

{
// Cached expected number of octets after the current octet
// until the beginning of the next UTF8 character sequence
$mState = 0;
// Cached Unicode character
$mUcs4 = 0;
// Cached expected number of octets in the current sequence
$mBytes = 1;
$len = strlen($str);
for ($i = 0; $i < $len; $i++)
{
$in = ord($str{$i});
if ($mState == 0)
{
// When mState is zero we expect either a US-ASCII character or a
// multi-octet sequence.
if (0 == (0x80 & ($in)))
{
// US-ASCII, pass straight through.
$mBytes = 1;
}
elseif (0xC0 == (0xE0 & ($in)))
{
// First octet of 2 octet sequence
$mUcs4 = ($in);
$mUcs4 = ($mUcs4 & 0x1F) << 6;
$mState = 1;
$mBytes = 2;
}
elseif (0xE0 == (0xF0 & ($in)))
{
// First octet of 3 octet sequence
$mUcs4 = ($in);
$mUcs4 = ($mUcs4 & 0x0F) << 12;
$mState = 2;
$mBytes = 3;
}
elseif (0xF0 == (0xF8 & ($in)))
{
// First octet of 4 octet sequence
$mUcs4 = ($in);
$mUcs4 = ($mUcs4 & 0x07) << 18;
$mState = 3;
$mBytes = 4;
}
elseif (0xF8 == (0xFC & ($in)))
{
/* First octet of 5 octet sequence.
*
* This is illegal because the encoded codepoint must be either
* (a) not the shortest form or
* (b) outside the Unicode range of 0-0x10FFFF.
* Rather than trying to resynchronize, we will carry on until the end
* of the sequence and let the later error handling code catch it.
*/
$mUcs4 = ($in);
$mUcs4 = ($mUcs4 & 0x03) << 24;
$mState = 4;
$mBytes = 5;
}
elseif (0xFC == (0xFE & ($in)))
{
// First octet of 6 octet sequence, see comments for 5 octet sequence.
$mUcs4 = ($in);
$mUcs4 = ($mUcs4 & 1) << 30;
$mState = 5;
$mBytes = 6;
}
else
{
/* Current octet is neither in the US-ASCII range nor a legal first
* octet of a multi-octet sequence.
*/
return false;
}
}
else
{
// When mState is non-zero, we expect a continuation of the multi-octet
// sequence
if (0x80 == (0xC0 & ($in)))
{
// Legal continuation.
$shift = ($mState - 1) * 6;
$tmp = $in;
$tmp = ($tmp & 0x0000003F) << $shift;
$mUcs4 |= $tmp;
/**
* End of the multi-octet sequence. mUcs4 now contains the final
* Unicode codepoint to be output
*/
if (0 == --$mState)
{
/*
* Check for illegal sequences and codepoints.
*/
// From Unicode 3.1, non-shortest form is illegal
if (((2 == $mBytes) && ($mUcs4 < 0x0080)) || ((3 == $mBytes) && ($mUcs4 < 0x0800)) || ((4 == $mBytes) && ($mUcs4 < 0x10000))
|| (4 < $mBytes)
|| (($mUcs4 & 0xFFFFF800) == 0xD800) // From Unicode 3.2, surrogate characters are illegal
|| ($mUcs4 > 0x10FFFF)) // Codepoints outside the Unicode range are illegal
{
return false;
}
// Initialize UTF8 cache.
$mState = 0;
$mUcs4 = 0;
$mBytes = 1;
}
}
else
{
/**
*((0xC0 & (*in) != 0x80) && (mState != 0))
* Incomplete multi-octet sequence.
*/
return false;
}
}
}
return true;
}

+ Voici le graphe d'appel pour cette fonction :

+ Voici le graphe des appelants de cette fonction :

Documentation des données membres

JString::$incrementStyles
staticprotected
Valeur initiale :
array(
'dash' => array(
'#-(\d+)$#',
'-%d'
),
'default' => array(
array('#\((\d+)\)$#', '#\(\d+\)$#'),
array(' (%d)', '(%d)'),
),
)

Définition à la ligne 55 du fichier string.php.

La documentation de cette classe a été générée à partir du fichier suivant :