0 follower

Class yii\helpers\BaseInflector

Inheritanceyii\helpers\BaseInflector
Subclassesyii\helpers\Inflector
Available since version2.0
Source Code https://github.com/yiisoft/yii2/blob/master/framework/helpers/BaseInflector.php

BaseInflector provides concrete implementation for yii\helpers\Inflector.

Do not use BaseInflector. Use yii\helpers\Inflector instead.

Public Properties

Hide inherited properties

Property Type Description Defined By
$plurals array The rules for converting a word into its plural form. yii\helpers\BaseInflector
$singulars array The rules for converting a word into its singular form. yii\helpers\BaseInflector
$specials array The special rules for converting a word between its plural form and singular form. yii\helpers\BaseInflector
$transliteration array Fallback map for transliteration used by transliterate() when intl isn't available. yii\helpers\BaseInflector
$transliterator mixed Either a Transliterator, or a string from which a Transliterator can be built for transliteration. yii\helpers\BaseInflector

Public Methods

Hide inherited methods

Method Description Defined By
camel2id() Converts a CamelCase name into an ID in lowercase. yii\helpers\BaseInflector
camel2words() Converts a CamelCase name into space-separated words. yii\helpers\BaseInflector
camelize() Returns given word as CamelCased. yii\helpers\BaseInflector
classify() Converts a table name to its class name. yii\helpers\BaseInflector
humanize() Returns a human-readable string from $word. yii\helpers\BaseInflector
id2camel() Converts an ID into a CamelCase name. yii\helpers\BaseInflector
ordinalize() Converts number to its ordinal English form. For example, converts 13 to 13th, 2 to 2nd . yii\helpers\BaseInflector
pluralize() Converts a word to its plural form. yii\helpers\BaseInflector
sentence() Converts a list of words into a sentence. yii\helpers\BaseInflector
singularize() Returns the singular of the $word. yii\helpers\BaseInflector
slug() Returns a string with all spaces converted to given replacement, non word characters removed and the rest of characters transliterated. yii\helpers\BaseInflector
tableize() Converts a class name to its table name (pluralized) naming conventions. yii\helpers\BaseInflector
titleize() Converts an underscored or CamelCase word into a English sentence. yii\helpers\BaseInflector
transliterate() Returns transliterated version of a string. yii\helpers\BaseInflector
underscore() Converts any "CamelCased" into an "underscored_word". yii\helpers\BaseInflector
variablize() Same as camelize but first char is in lowercase. yii\helpers\BaseInflector

Protected Methods

Hide inherited methods

Method Description Defined By
hasIntl() yii\helpers\BaseInflector

Constants

Hide inherited constants

Constant Value Description Defined By
TRANSLITERATE_LOOSE 'Any-Latin; Latin-ASCII; [\u0080-\uffff] remove' Shortcut for Any-Latin; Latin-ASCII; [\u0080-\uffff] remove transliteration rule. The rule is loose, letters will be transliterated with the characters of Basic Latin Unicode Block. For example: čŽ·å–åˆ° 恩恔悉 Š£ŠŗрŠ°Ń—Š½ŃŃŒŠŗŠ°: Ņ‘,є, Š”рŠæсŠŗŠ°: ђ, њ, џ! ĀæEspaƱol? will be transliterated to huo qu dao dochira Ukrainska: g,e, Srpska: d, n, d! Espanol?. Used in transliterate(). For detailed information see unicode normalization forms yii\helpers\BaseInflector
TRANSLITERATE_MEDIUM 'Any-Latin; Latin-ASCII' Shortcut for Any-Latin; Latin-ASCII transliteration rule. The rule is medium, letters will be transliterated to characters of Latin-1 (ISO 8859-1) ASCII table. For example: čŽ·å–åˆ° 恩恔悉 Š£ŠŗрŠ°Ń—Š½ŃŃŒŠŗŠ°: Ņ‘,є, Š”рŠæсŠŗŠ°: ђ, њ, џ! ĀæEspaƱol? will be transliterated to huo qu dao dochira UkrainsŹ¹ka: g,e, Srpska: d, n, d! ĀæEspanol?. Used in transliterate(). For detailed information see unicode normalization forms yii\helpers\BaseInflector
TRANSLITERATE_STRICT 'Any-Latin; NFKD' Shortcut for Any-Latin; NFKD transliteration rule. The rule is strict, letters will be transliterated with the closest sound-representation chars. The result may contain any UTF-8 chars. For example: čŽ·å–åˆ° 恩恔悉 Š£ŠŗрŠ°Ń—Š½ŃŃŒŠŗŠ°: Ņ‘,є, Š”рŠæсŠŗŠ°: ђ, њ, џ! ĀæEspaƱol? will be transliterated to huoĢ€ quĢŒ daĢ€o dochira UkraiĢĢˆnsŹ¹ka: gĢ€,eĢ‚, Srpska: đ, nĢ‚, dĢ‚! ĀæEspanĢƒol?. Used in transliterate(). For detailed information see unicode normalization forms yii\helpers\BaseInflector

Property Details

Hide inherited properties

$plurals public static property

The rules for converting a word into its plural form. The keys are the regular expressions and the values are the corresponding replacements.

public static array $plurals = [
    
'/([nrlm]ese|deer|fish|sheep|measles|ois|pox|media)$/i' => '\1',
    
'/^(sea[- ]bass)$/i' => '\1',
    
'/(m)ove$/i' => '\1oves',
    
'/(f)oot$/i' => '\1eet',
    
'/(h)uman$/i' => '\1umans',
    
'/(s)tatus$/i' => '\1tatuses',
    
'/(s)taff$/i' => '\1taff',
    
'/(t)ooth$/i' => '\1eeth',
    
'/(quiz)$/i' => '\1zes',
    
'/^(ox)$/i' => '\1\2en',
    
'/([m|l])ouse$/i' => '\1ice',
    
'/(matr|vert|ind)(ix|ex)$/i' => '\1ices',
    
'/(x|ch|ss|sh)$/i' => '\1es',
    
'/([^aeiouy]|qu)y$/i' => '\1ies',
    
'/(hive)$/i' => '\1s',
    
'/(?:([^f])fe|([lr])f)$/i' => '\1\2ves',
    
'/sis$/i' => 'ses',
    
'/([ti])um$/i' => '\1a',
    
'/(p)erson$/i' => '\1eople',
    
'/(m)an$/i' => '\1en',
    
'/(c)hild$/i' => '\1hildren',
    
'/(buffal|tomat|potat|ech|her|vet)o$/i' => '\1oes',
    
'/(alumn|bacill|cact|foc|fung|nucle|radi|stimul|syllab|termin|vir)us$/i' => '\1i',
    
'/us$/i' => 'uses',
    
'/(alias)$/i' => '\1es',
    
'/(ax|cris|test)is$/i' => '\1es',
    
'/(currenc)y$/' => '\1ies',
    
'/s$/' => 's',
    
'/^$/' => '',
    
'/$/' => 's',
]
$singulars public static property

The rules for converting a word into its singular form. The keys are the regular expressions and the values are the corresponding replacements.

public static array $singulars = [
    
'/([nrlm]ese|deer|fish|sheep|measles|ois|pox|media|ss)$/i' => '\1',
    
'/^(sea[- ]bass)$/i' => '\1',
    
'/(s)tatuses$/i' => '\1tatus',
    
'/(f)eet$/i' => '\1oot',
    
'/(t)eeth$/i' => '\1ooth',
    
'/^(.*)(menu)s$/i' => '\1\2',
    
'/(quiz)zes$/i' => '\1',
    
'/(matr)ices$/i' => '\1ix',
    
'/(vert|ind)ices$/i' => '\1ex',
    
'/^(ox)en/i' => '\1',
    
'/(alias)(es)*$/i' => '\1',
    
'/(alumn|bacill|cact|foc|fung|nucle|radi|stimul|syllab|termin|viri?)i$/i' => '\1us',
    
'/([ftw]ax)es/i' => '\1',
    
'/(cris|ax|test)es$/i' => '\1is',
    
'/(shoe|slave)s$/i' => '\1',
    
'/(o)es$/i' => '\1',
    
'/ouses$/' => 'ouse',
    
'/([^a])uses$/' => '\1us',
    
'/([m|l])ice$/i' => '\1ouse',
    
'/(x|ch|ss|sh)es$/i' => '\1',
    
'/(m)ovies$/i' => '\1\2ovie',
    
'/(s)eries$/i' => '\1\2eries',
    
'/([^aeiouy]|qu)ies$/i' => '\1y',
    
'/([lr])ves$/i' => '\1f',
    
'/(tive)s$/i' => '\1',
    
'/(hive)s$/i' => '\1',
    
'/(drive)s$/i' => '\1',
    
'/([^fo])ves$/i' => '\1fe',
    
'/(^analy)ses$/i' => '\1sis',
    
'/(analy|diagno|^ba|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i' => '\1\2sis',
    
'/([ti])a$/i' => '\1um',
    
'/(p)eople$/i' => '\1\2erson',
    
'/(m)en$/i' => '\1an',
    
'/(c)hildren$/i' => '\1\2hild',
    
'/(n)ews$/i' => '\1\2ews',
    
'/(n)etherlands$/i' => '\1\2etherlands',
    
'/eaus$/' => 'eau',
    
'/(currenc)ies$/' => '\1y',
    
'/^(.*us)$/' => '\1',
    
'/s$/i' => '',
]
$specials public static property

The special rules for converting a word between its plural form and singular form. The keys are the special words in singular form, and the values are the corresponding plural form.

public static array $specials = [
    
'atlas' => 'atlases',
    
'beef' => 'beefs',
    
'brother' => 'brothers',
    
'cafe' => 'cafes',
    
'child' => 'children',
    
'cookie' => 'cookies',
    
'corpus' => 'corpuses',
    
'cow' => 'cows',
    
'curve' => 'curves',
    
'foe' => 'foes',
    
'ganglion' => 'ganglions',
    
'genie' => 'genies',
    
'genus' => 'genera',
    
'graffito' => 'graffiti',
    
'hoof' => 'hoofs',
    
'loaf' => 'loaves',
    
'man' => 'men',
    
'money' => 'monies',
    
'mongoose' => 'mongooses',
    
'move' => 'moves',
    
'mythos' => 'mythoi',
    
'niche' => 'niches',
    
'numen' => 'numina',
    
'occiput' => 'occiputs',
    
'octopus' => 'octopuses',
    
'opus' => 'opuses',
    
'ox' => 'oxen',
    
'pasta' => 'pasta',
    
'penis' => 'penises',
    
'sex' => 'sexes',
    
'soliloquy' => 'soliloquies',
    
'testis' => 'testes',
    
'trilby' => 'trilbys',
    
'turf' => 'turfs',
    
'wave' => 'waves',
    
'Amoyese' => 'Amoyese',
    
'bison' => 'bison',
    
'Borghese' => 'Borghese',
    
'bream' => 'bream',
    
'breeches' => 'breeches',
    
'britches' => 'britches',
    
'buffalo' => 'buffalo',
    
'cantus' => 'cantus',
    
'carp' => 'carp',
    
'chassis' => 'chassis',
    
'clippers' => 'clippers',
    
'cod' => 'cod',
    
'coitus' => 'coitus',
    
'Congoese' => 'Congoese',
    
'contretemps' => 'contretemps',
    
'corps' => 'corps',
    
'debris' => 'debris',
    
'diabetes' => 'diabetes',
    
'djinn' => 'djinn',
    
'eland' => 'eland',
    
'elk' => 'elk',
    
'equipment' => 'equipment',
    
'Faroese' => 'Faroese',
    
'flounder' => 'flounder',
    
'Foochowese' => 'Foochowese',
    
'gallows' => 'gallows',
    
'Genevese' => 'Genevese',
    
'Genoese' => 'Genoese',
    
'Gilbertese' => 'Gilbertese',
    
'graffiti' => 'graffiti',
    
'headquarters' => 'headquarters',
    
'herpes' => 'herpes',
    
'hijinks' => 'hijinks',
    
'Hottentotese' => 'Hottentotese',
    
'information' => 'information',
    
'innings' => 'innings',
    
'jackanapes' => 'jackanapes',
    
'Kiplingese' => 'Kiplingese',
    
'Kongoese' => 'Kongoese',
    
'Lucchese' => 'Lucchese',
    
'mackerel' => 'mackerel',
    
'Maltese' => 'Maltese',
    
'mews' => 'mews',
    
'moose' => 'moose',
    
'mumps' => 'mumps',
    
'Nankingese' => 'Nankingese',
    
'news' => 'news',
    
'nexus' => 'nexus',
    
'Niasese' => 'Niasese',
    
'Pekingese' => 'Pekingese',
    
'Piedmontese' => 'Piedmontese',
    
'pincers' => 'pincers',
    
'Pistoiese' => 'Pistoiese',
    
'pliers' => 'pliers',
    
'Portuguese' => 'Portuguese',
    
'proceedings' => 'proceedings',
    
'rabies' => 'rabies',
    
'rice' => 'rice',
    
'rhinoceros' => 'rhinoceros',
    
'salmon' => 'salmon',
    
'Sarawakese' => 'Sarawakese',
    
'scissors' => 'scissors',
    
'series' => 'series',
    
'Shavese' => 'Shavese',
    
'shears' => 'shears',
    
'siemens' => 'siemens',
    
'species' => 'species',
    
'swine' => 'swine',
    
'testes' => 'testes',
    
'trousers' => 'trousers',
    
'trout' => 'trout',
    
'tuna' => 'tuna',
    
'Vermontese' => 'Vermontese',
    
'Wenchowese' => 'Wenchowese',
    
'whiting' => 'whiting',
    
'wildebeest' => 'wildebeest',
    
'Yengeese' => 'Yengeese',
    
'software' => 'software',
    
'hardware' => 'hardware',
]
$transliteration public static property

Fallback map for transliteration used by transliterate() when intl isn't available.

public static array $transliteration = [
    
'ƀ' => 'A',
    
'Ɓ' => 'A',
    
'Ƃ' => 'A',
    
'ƃ' => 'A',
    
'Ƅ' => 'A',
    
'ƅ' => 'A',
    
'Ɔ' => 'AE',
    
'Ƈ' => 'C',
    
'ƈ' => 'E',
    
'Ɖ' => 'E',
    
'Ɗ' => 'E',
    
'Ƌ' => 'E',
    
'ƌ' => 'I',
    
'ƍ' => 'I',
    
'Ǝ' => 'I',
    
'Ə' => 'I',
    
'Ɛ' => 'D',
    
'Ƒ' => 'N',
    
'ƒ' => 'O',
    
'Ɠ' => 'O',
    
'Ɣ' => 'O',
    
'ƕ' => 'O',
    
'Ɩ' => 'O',
    
'Ő' => 'O',
    
'Ƙ' => 'O',
    
'ƙ' => 'U',
    
'ƚ' => 'U',
    
'ƛ' => 'U',
    
'Ɯ' => 'U',
    
'Å°' => 'U',
    
'Ɲ' => 'Y',
    
'ƞ' => 'TH',
    
'Ɵ' => 'ss',
    
'Ć ' => 'a',
    
'Ć”' => 'a',
    
'Ć¢' => 'a',
    
'Ć£' => 'a',
    
'Ƥ' => 'a',
    
'Ć„' => 'a',
    
'Ʀ' => 'ae',
    
'Ƨ' => 'c',
    
'ĆØ' => 'e',
    
'Ć©' => 'e',
    
'ĆŖ' => 'e',
    
'Ć«' => 'e',
    
'Ƭ' => 'i',
    
'Ć­' => 'i',
    
'Ć®' => 'i',
    
'ĆÆ' => 'i',
    
'Ć°' => 'd',
    
'Ʊ' => 'n',
    
'Ć²' => 'o',
    
'Ć³' => 'o',
    
'Ć“' => 'o',
    
'Ƶ' => 'o',
    
'ƶ' => 'o',
    
'ő' => 'o',
    
'Ćø' => 'o',
    
'Ć¹' => 'u',
    
'Ćŗ' => 'u',
    
'Ć»' => 'u',
    
'Ć¼' => 'u',
    
'ű' => 'u',
    
'Ć½' => 'y',
    
'Ć¾' => 'th',
    
'Ćæ' => 'y',
]
$transliterator public static property

Either a Transliterator, or a string from which a Transliterator can be built for transliteration. Used by transliterate() when intl is available. Defaults to TRANSLITERATE_LOOSE

See also https://www.php.net/manual/en/transliterator.transliterate.php.

public static mixed $transliterator self::TRANSLITERATE_LOOSE

Method Details

Hide inherited methods

camel2id() public static method

Converts a CamelCase name into an ID in lowercase.

Words in the ID may be concatenated using the specified character (defaults to '-'). For example, 'PostTag' will be converted to 'post-tag'.

public static string camel2id ( $name, $separator '-', $strict false )
$name string

The string to be converted

$separator string

The character used to concatenate the words in the ID

$strict boolean|string

Whether to insert a separator between two consecutive uppercase chars, defaults to false

return string

The resulting ID

                public static function camel2id($name, $separator = '-', $strict = false)
{
    if (empty($name)) {
        return (string) $name;
    }
    $regex = $strict ? '/\p{Lu}/u' : '/(?<!\p{Lu})\p{Lu}/u';
    if ($separator === '_') {
        return mb_strtolower(trim(preg_replace($regex, '_\0', $name), '_'), self::encoding());
    }
    return mb_strtolower(trim(str_replace('_', $separator, preg_replace($regex, $separator . '\0', $name)), $separator), self::encoding());
}

            
camel2words() public static method

Converts a CamelCase name into space-separated words.

For example, 'PostTag' will be converted to 'Post Tag'.

public static string camel2words ( $name, $ucwords true )
$name string

The string to be converted

$ucwords boolean

Whether to capitalize the first letter in each word

return string

The resulting words

                public static function camel2words($name, $ucwords = true)
{
    if (empty($name)) {
        return (string) $name;
    }
    // Add a space before any uppercase letter preceded by a lowercase letter (xY => x Y)
    // and any uppercase letter preceded by an uppercase letter and followed by a lowercase letter (XYz => X Yz)
    $label = preg_replace('/(?<=\p{Ll})\p{Lu}|(?<=\p{L})\p{Lu}(?=\p{Ll})/u', ' \0', $name);
    $label = mb_strtolower(trim(str_replace(['-', '_', '.'], ' ', $label)), self::encoding());
    return $ucwords ? StringHelper::mb_ucwords($label, self::encoding()) : $label;
}

            
camelize() public static method

Returns given word as CamelCased.

Converts a word like "send_email" to "SendEmail". It will remove non alphanumeric character from the word, so "who's online" will be converted to "WhoSOnline".

See also variablize().

public static string camelize ( $word )
$word string

The word to CamelCase

                public static function camelize($word)
{
    if (empty($word)) {
        return (string) $word;
    }
    return str_replace(' ', '', StringHelper::mb_ucwords(preg_replace('/[^\pL\pN]+/u', ' ', $word), self::encoding()));
}

            
classify() public static method

Converts a table name to its class name.

For example, converts "people" to "Person".

public static string classify ( $tableName )
$tableName string

                public static function classify($tableName)
{
    if (empty($tableName)) {
        return (string) $tableName;
    }
    return static::camelize(static::singularize($tableName));
}

            
hasIntl() protected static method

protected static boolean hasIntl ( )
return boolean

If intl extension is loaded

                protected static function hasIntl()
{
    return extension_loaded('intl');
}

            
humanize() public static method

Returns a human-readable string from $word.

public static string humanize ( $word, $ucAll false )
$word string

The string to humanize

$ucAll boolean

Whether to set all words to uppercase or not

                public static function humanize($word, $ucAll = false)
{
    if (empty($word)) {
        return (string) $word;
    }
    $word = str_replace('_', ' ', preg_replace('/_id$/', '', $word));
    $encoding = self::encoding();
    return $ucAll ? StringHelper::mb_ucwords($word, $encoding) : StringHelper::mb_ucfirst($word, $encoding);
}

            
id2camel() public static method

Converts an ID into a CamelCase name.

Words in the ID separated by $separator (defaults to '-') will be concatenated into a CamelCase name. For example, 'post-tag' is converted to 'PostTag'.

public static string id2camel ( $id, $separator '-' )
$id string

The ID to be converted

$separator string

The character used to separate the words in the ID

return string

The resulting CamelCase name

                public static function id2camel($id, $separator = '-')
{
    if (empty($id)) {
        return (string) $id;
    }
    return str_replace(' ', '', StringHelper::mb_ucwords(str_replace($separator, ' ', $id), self::encoding()));
}

            
ordinalize() public static method

Converts number to its ordinal English form. For example, converts 13 to 13th, 2 to 2nd .

..

public static string ordinalize ( $number )
$number integer

The number to get its ordinal value

                public static function ordinalize($number)
{
    if (in_array($number % 100, range(11, 13))) {
        return $number . 'th';
    }
    switch ($number % 10) {
        case 1:
            return $number . 'st';
        case 2:
            return $number . 'nd';
        case 3:
            return $number . 'rd';
        default:
            return $number . 'th';
    }
}

            
pluralize() public static method

Converts a word to its plural form.

Note that this is for English only! For example, 'apple' will become 'apples', and 'child' will become 'children'.

public static string pluralize ( $word )
$word string

The word to be pluralized

return string

The pluralized word

                public static function pluralize($word)
{
    if (empty($word)) {
        return (string) $word;
    }
    if (isset(static::$specials[$word])) {
        return static::$specials[$word];
    }
    foreach (static::$plurals as $rule => $replacement) {
        if (preg_match($rule, $word)) {
            return preg_replace($rule, $replacement, $word);
        }
    }
    return $word;
}

            
sentence() public static method (available since version 2.0.1)

Converts a list of words into a sentence.

Special treatment is done for the last few words. For example,

$words = ['Spain', 'France'];
echo Inflector::sentence($words);
// output: Spain and France

$words = ['Spain', 'France', 'Italy'];
echo Inflector::sentence($words);
// output: Spain, France and Italy

$words = ['Spain', 'France', 'Italy'];
echo Inflector::sentence($words, ' & ');
// output: Spain, France & Italy
public static string sentence ( array $words, $twoWordsConnector null, $lastWordConnector null, $connector ', ' )
$words array

The words to be converted into an string

$twoWordsConnector string|null

The string connecting words when there are only two

$lastWordConnector string|null

The string connecting the last two words. If this is null, it will take the value of $twoWordsConnector.

$connector string

The string connecting words other than those connected by $lastWordConnector and $twoWordsConnector

return string

The generated sentence

                public static function sentence(array $words, $twoWordsConnector = null, $lastWordConnector = null, $connector = ', ')
{
    if ($twoWordsConnector === null) {
        $twoWordsConnector = Yii::t('yii', ' and ');
    }
    if ($lastWordConnector === null) {
        $lastWordConnector = $twoWordsConnector;
    }
    switch (count($words)) {
        case 0:
            return '';
        case 1:
            return reset($words);
        case 2:
            return implode($twoWordsConnector, $words);
        default:
            return implode($connector, array_slice($words, 0, -1)) . $lastWordConnector . end($words);
    }
}

            
singularize() public static method

Returns the singular of the $word.

public static string singularize ( $word )
$word string

The english word to singularize

return string

Singular noun.

                public static function singularize($word)
{
    if (empty($word)) {
        return (string) $word;
    }
    $result = array_search($word, static::$specials, true);
    if ($result !== false) {
        return $result;
    }
    foreach (static::$singulars as $rule => $replacement) {
        if (preg_match($rule, $word)) {
            return preg_replace($rule, $replacement, $word);
        }
    }
    return $word;
}

            
slug() public static method

Returns a string with all spaces converted to given replacement, non word characters removed and the rest of characters transliterated.

If intl extension isn't available uses fallback that converts latin characters only and removes the rest. You may customize characters map via $transliteration property of the helper.

public static string slug ( $string, $replacement '-', $lowercase true )
$string string

An arbitrary string to convert

$replacement string

The replacement to use for spaces

$lowercase boolean

Whether to return the string in lowercase or not. Defaults to true.

return string

The converted string.

                public static function slug($string, $replacement = '-', $lowercase = true)
{
    if (empty($string)) {
        return (string) $string;
    }
    if ((string)$replacement !== '') {
        $parts = explode($replacement, static::transliterate($string));
    } else {
        $parts = [static::transliterate($string)];
    }
    $replaced = array_map(function ($element) use ($replacement) {
        $element = preg_replace('/[^a-zA-Z0-9=\sā€”ā€“-]+/u', '', $element);
        return preg_replace('/[=\sā€”ā€“-]+/u', $replacement, $element);
    }, $parts);
    $string = trim(implode($replacement, $replaced), $replacement);
    if ((string)$replacement !== '') {
        $string = preg_replace('#' . preg_quote($replacement, '#') . '+#', $replacement, $string);
    }
    return $lowercase ? strtolower($string) : $string;
}

            
tableize() public static method

Converts a class name to its table name (pluralized) naming conventions.

For example, converts "Person" to "people".

public static string tableize ( $className )
$className string

The class name for getting related table_name

                public static function tableize($className)
{
    if (empty($className)) {
        return (string) $className;
    }
    return static::pluralize(static::underscore($className));
}

            
titleize() public static method

Converts an underscored or CamelCase word into a English sentence.

public static string titleize ( $words, $ucAll false )
$words string
$ucAll boolean

Whether to set all words to uppercase

                public static function titleize($words, $ucAll = false)
{
    if (empty($words)) {
        return (string) $words;
    }
    $words = static::humanize(static::underscore($words), $ucAll);
    return $ucAll ? StringHelper::mb_ucwords($words, self::encoding()) : StringHelper::mb_ucfirst($words, self::encoding());
}

            
transliterate() public static method

Returns transliterated version of a string.

If intl extension isn't available uses fallback that converts latin characters only and removes the rest. You may customize characters map via $transliteration property of the helper.

public static string transliterate ( $string, $transliterator null )
$string string

Input string

$transliterator string|Transliterator|null

Either a Transliterator or a string from which a Transliterator can be built.

Version Description
2.0.7 this method is public.

                public static function transliterate($string, $transliterator = null)
{
    if (empty($string)) {
        return (string) $string;
    }
    if (static::hasIntl()) {
        if ($transliterator === null) {
            $transliterator = static::$transliterator;
        }
        return transliterator_transliterate($transliterator, $string);
    }
    return strtr($string, static::$transliteration);
}

            
underscore() public static method

Converts any "CamelCased" into an "underscored_word".

public static string underscore ( $words )
$words string

The word(s) to underscore

                public static function underscore($words)
{
    if (empty($words)) {
        return (string) $words;
    }
    return mb_strtolower(preg_replace('/(?<=\\pL)(\\p{Lu})/u', '_\\1', $words), self::encoding());
}

            
variablize() public static method

Same as camelize but first char is in lowercase.

Converts a word like "send_email" to "sendEmail". It will remove non alphanumeric character from the word, so "who's online" will be converted to "whoSOnline".

public static string variablize ( $word )
$word string

To lowerCamelCase

                public static function variablize($word)
{
    if (empty($word)) {
        return (string) $word;
    }
    $word = static::camelize($word);
    return mb_strtolower(mb_substr($word, 0, 1, self::encoding())) . mb_substr($word, 1, null, self::encoding());
}