Popularity
4.5
Growing
Activity
7.5
Declining
399
17
52

Description

It is written in PHP (>= 5.3) and can work without "mbstring", "iconv" or any other extra encoding php-extension on your server. The benefit of Portable UTF-8 is that it is easy to use, easy to bundle. This library will also auto-detect your server environment and will use the installed php-extensions if they are available, so you will have the best possible performance. As Fallback we will use Symfony Polyfills (Iconv, Intl, Mbstring, Xml, ... | https://github.com/symfony/polyfill).

The project based on Hamid Sarfraz's work (http://pageconfig.com/attachments/portable-utf8.php) + parts of Nicolas Grekas's work (https://github.com/tchwork/utf8) + parts of Behat's work (https://github.com/Behat/Transliterator) + parts of Sebasti谩n Grignoli's work (https://github.com/neitanod/forceutf8) + parts of Ivan Enderlin's work (https://github.com/hoaproject/Ustring) + cherry-picks from many gist and stackoverflow snippets.

Code Quality Rank: L3
Monthly Downloads: 43,341
Programming language: PHP
License: CNRI Python Open Source GPL Compatible License Agreement
Tags: Strings     Utf8     Utf-8     Unicode     String     Utils     Multibyte     UTF     String Manipulation     clean    
Latest version: v5.4.50

Portable UTF-8 alternatives and similar libraries

Based on the "Strings" category

Do you think we are missing an alternative of Portable UTF-8 or a related project?

Add another 'Strings' Library

README

Build Status Build status FOSSA Status Coverage Status Codacy Badge Latest Stable Version Total Downloads License Donate to this project using PayPal Donate to this project using Patreon

馃墤 Portable UTF-8

Description

It is written in PHP (PHP 7+) and can work without "mbstring", "iconv" or any other extra encoding php-extension on your server.

The benefit of Portable UTF-8 is that it is easy to use, easy to bundle. This library will also auto-detect your server environment and will use the installed php-extensions if they are available, so you will have the best possible performance.

As a fallback we will use Symfony Polyfills, if needed. (https://github.com/symfony/polyfill)

The project based on ...

Demo

Here you can test some basic functions from this library and you can compare some results with the native php function results.

Index

Alternative

If you like a more Object Oriented Way to edit strings, then you can take a look at voku/Stringy, it's a fork of "danielstjules/Stringy" but it used the "Portable UTF-8"-Class and some extra methods.

// Standard library
strtoupper('f貌么b脿艡');       // 'F貌么B脿艡'
strlen('f貌么b脿艡');           // 10

// mbstring 
// WARNING: if you don't use a polyfill like "Portable UTF-8", you need to install the php-extension "mbstring" on your server
mb_strtoupper('f貌么b脿艡');    // 'F脪脭B脌艠'
mb_strlen('f貌么b脿艡');        // '6'

// Portable UTF-8
use voku\helper\UTF8;
UTF8::strtoupper('f貌么b脿艡');    // 'F脪脭B脌艠'
UTF8::strlen('f貌么b脿艡');        // '6'

// voku/Stringy
use Stringy\Stringy as S;
$stringy = S::create('f貌么b脿艡');
$stringy->toUpperCase();    // 'F脪脭B脌艠'
$stringy->length();         // '6'

Install "Portable UTF-8" via "composer require"

composer require voku/portable-utf8

If your project do not need some of the Symfony polyfills please use the replace section of your composer.json. This removes any overhead from these polyfills as they are no longer part of your project. e.g.:

{
  "replace": {
    "symfony/polyfill-php72": "1.99",
    "symfony/polyfill-iconv": "1.99",
    "symfony/polyfill-intl-grapheme": "1.99",
    "symfony/polyfill-intl-normalizer": "1.99",
    "symfony/polyfill-mbstring": "1.99"
  }
}

Why Portable UTF-8?

PHP 5 and earlier versions have no native Unicode support. To bridge the gap, there exist several extensions like "mbstring", "iconv" and "intl".

The problem with "mbstring" and others is that most of the time you cannot ensure presence of a specific one on a server. If you rely on one of these, your application is no more portable. This problem gets even severe for open source applications that have to run on different servers with different configurations. Considering these, I decided to write a library:

Requirements and Recommendations

  • No extensions are required to run this library. Portable UTF-8 only needs PCRE library that is available by default since PHP 4.2.0 and cannot be disabled since PHP 5.3.0. "\u" modifier support in PCRE for UTF-8 handling is not a must.
  • PHP 5.3 is the minimum requirement, and all later versions are fine with Portable UTF-8.
  • PHP 7.0 is the minimum requirement since version 4.0 of Portable UTF-8, otherwise composer will install an older version
  • PHP 8.0 support is also available and will adapt the behaviours of the native functions.
  • To speed up string handling, it is recommended that you have "mbstring" or "iconv" available on your server, as well as the latest version of PCRE library
  • Although Portable UTF-8 is easy to use; moving from native API to Portable UTF-8 may not be straight-forward for everyone. It is highly recommended that you do not update your scripts to include Portable UTF-8 or replace or change anything before you first know the reason and consequences. Most of the time, some native function may be all what you need.
  • There is also a shim for "mbstring", "iconv" and "intl", so you can use it also on shared webspace.

Info

Since version 5.4.26 this library will NOT force "UTF-8" by "bootstrap.php" anymore. If you need to enable this behavior you can define "PORTABLE_UTF8__ENABLE_AUTO_FILTER", before requiring the autoloader.

define('PORTABLE_UTF8__ENABLE_AUTO_FILTER', 1);

Before version 5.4.26 this behavior was enabled by default and you could disable it via "PORTABLE_UTF8__DISABLE_AUTO_FILTER", but the code had potential security vulnerabilities via injecting code while redirecting via header('Location .... This is the reason I decided to add this BC in a bug fix release, so that everybody using the current version will receive the security-fix.

Usage

Example 1: UTF8::cleanup()

  echo UTF8::cleanup('锟紻脙录sseldorf锟');

  // will output:
  // D眉sseldorf

Example 2: UTF8::strlen()

  $string = 'string <strong>with utf-8 chars 氓猫盲</strong> - doo-bee doo-bee dooh';

  echo strlen($string) . "\n<br />";
  echo UTF8::strlen($string) . "\n<br />";

  // will output:
  // 70
  // 67

  $string_test1 = strip_tags($string);
  $string_test2 = UTF8::strip_tags($string);

  echo strlen($string_test1) . "\n<br />";
  echo UTF8::strlen($string_test2) . "\n<br />";

  // will output:
  // 53
  // 50

Example 3: UTF8::fix_utf8()


  echo UTF8::fix_utf8('D脙录sseldorf');
  echo UTF8::fix_utf8('脙陇');

  // will output:
  // D眉sseldorf
  // 盲

Portable UTF-8 | API

The API from the "UTF8"-Class is written as small static methods that will match the default PHP-API.

Class methods

access add_bom_to_string array_change_key_case between binary_to_str bom callback char_at chars checkForSupport chr chr_map chr_size_list chr_to_decimal chr_to_hex chunk_split clean cleanup codepoints collapse_whitespace count_chars css_identifier css_stripe_media_queries ctype_loaded decimal_to_chr decode_mimeheader emoji_decode emoji_encode emoji_from_country_code encode encode_mimeheader extract_text file_get_contents file_has_bom filter filter_input filter_input_array filter_var filter_var_array finfo_loaded first_char fits_inside fix_simple_utf8 fix_utf8 getCharDirection getSupportInfo get_file_type get_random_string get_unique_string has_lowercase has_uppercase has_whitespace hex_to_chr hex_to_int html_encode html_entity_decode html_escape html_stripe_empty_tags htmlentities htmlspecialchars iconv_loaded int_to_hex intlChar_loaded intl_loaded is_alpha is_alphanumeric is_ascii is_base64 is_binary is_binary_file is_blank is_bom is_empty is_hexadecimal is_html is_json is_lowercase is_printable is_punctuation is_serialized is_uppercase is_url is_utf8 is_utf16 is_utf32 json_decode json_encode json_loaded lcfirst lcwords ltrim max max_chr_width mbstring_loaded min normalize_encoding normalize_line_ending normalize_msword normalize_whitespace ord parse_str pcre_utf8_support range rawurldecode regex_replace remove_bom remove_duplicates remove_html remove_html_breaks remove_invisible_characters remove_left remove_right replace replace_all replace_diamond_question_mark rtrim showSupport single_chr_html_encode spaces_to_tabs str_camelize str_capitalize_name str_contains str_contains_all str_contains_any str_dasherize str_delimit str_detect_encoding str_ends_with str_ends_with_any str_ensure_left str_ensure_right str_humanize str_iends_with str_iends_with_any str_insert str_ireplace str_ireplace_beginning str_ireplace_ending str_istarts_with str_istarts_with_any str_isubstr_after_first_separator str_isubstr_after_last_separator str_isubstr_before_first_separator str_isubstr_before_last_separator str_isubstr_first str_isubstr_last str_last_char str_limit str_limit_after_word str_longest_common_prefix str_longest_common_substring str_longest_common_suffix str_matches_pattern str_obfuscate str_offset_exists str_offset_get str_pad str_pad_both str_pad_left str_pad_right str_repeat str_replace_beginning str_replace_ending str_replace_first str_replace_last str_shuffle str_slice str_snakeize str_sort str_split str_split_array str_split_pattern str_starts_with str_starts_with_any str_substr_after_first_separator str_substr_after_last_separator str_substr_before_first_separator str_substr_before_last_separator str_substr_first str_substr_last str_surround str_titleize str_titleize_for_humans str_to_binary str_to_lines str_to_words str_truncate str_truncate_safe str_underscored str_upper_camelize str_word_count strcasecmp strcmp strcspn string string_has_bom strip_tags strip_whitespace stripos stripos_in_byte stristr strlen strlen_in_byte strnatcasecmp strnatcmp strncasecmp strncmp strpbrk strpos strpos_in_byte strrchr strrev strrichr strripos strripos_in_byte strrpos strrpos_in_byte strspn strstr strstr_in_byte strtocasefold strtolower strtoupper strtr strwidth substr substr_compare substr_count substr_count_in_byte substr_count_simple substr_ileft substr_in_byte substr_iright substr_left substr_replace substr_right swapCase symfony_polyfill_used tabs_to_spaces titlecase to_ascii to_boolean to_filename to_int to_iso8859 to_string to_utf8 to_utf8_string trim ucfirst ucwords urldecode utf8_decode utf8_encode whitespace_table words_limit wordwrap wordwrap_per_line ws

access(string $str, int $pos, string $encoding): string

鈫 Return the character at the specified position: $str[1] like functionality.

EXAMPLE: UTF8::access('f貌么', 1); // '貌'

Parameters:

  • string $str <p>A UTF-8 string.</p>
  • int $pos <p>The position of character to return.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string <p>Single multi-byte character.</p>

add_bom_to_string(string $str): string

鈫 Prepends UTF-8 BOM character to the string and returns the whole string.

INFO: If BOM already existed there, the Input string is returned.

EXAMPLE: UTF8::add_bom_to_string('f貌么'); // "\xEF\xBB\xBF" . 'f貌么'

Parameters:

  • string $str <p>The input string.</p>

Return:

  • string <p>The output string that contains BOM.</p>

array_change_key_case(array $array, int $case, string $encoding): string[]

鈫 Changes all keys in an array.

Parameters:

  • array<string, mixed> $array <p>The array to work on</p>
  • int $case [optional] <p> Either <strong>CASE_UPPER</strong><br> or <strong>CASE_LOWER</strong> (default)</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string[] <p>An array with its keys lower- or uppercased.</p>

between(string $str, string $start, string $end, int $offset, string $encoding): string

鈫 Returns the substring between $start and $end, if found, or an empty string. An optional offset may be supplied from which to begin the search for the start string.

Parameters:

  • string $str
  • string $start <p>Delimiter marking the start of the substring.</p>
  • string $end <p>Delimiter marking the end of the substring.</p>
  • int $offset [optional] <p>Index from which to begin the search. Default: 0</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string

binary_to_str(string $bin): string

鈫 Convert binary into a string.

INFO: opposite to UTF8::str_to_binary()

EXAMPLE: UTF8::binary_to_str('11110000100111111001100010000011'); // '馃槂'

Parameters:

  • string $bin 1|0

Return:

  • string

bom(): string

鈫 Returns the UTF-8 Byte Order Mark Character.

INFO: take a look at UTF8::$bom for e.g. UTF-16 and UTF-32 BOM values

EXAMPLE: UTF8::bom(); // "\xEF\xBB\xBF"

Parameters: nothing

Return:

  • string <p>UTF-8 Byte Order Mark.</p>

callback(callable $callback, string $str): string[]

Parameters:

  • callable $callback
  • string $str

Return:

  • string[]

char_at(string $str, int $index, string $encoding): string

鈫 Returns the character at $index, with indexes starting at 0.

Parameters:

  • string $str <p>The input string.</p>
  • int $index <p>Position of the character.</p>
  • string $encoding [optional] <p>Default is UTF-8</p>

Return:

  • string <p>The character at $index.</p>

chars(string $str): string[]

鈫 Returns an array consisting of the characters in the string.

Parameters:

  • string $str <p>The input string.</p>

Return:

  • string[] <p>An array of chars.</p>

checkForSupport(): true|null

鈫 This method will auto-detect your server environment for UTF-8 support.

Parameters: nothing

Return:

  • true|null

chr(int $code_point, string $encoding): string|null

鈫 Generates a UTF-8 encoded character from the given code point.

INFO: opposite to UTF8::ord()

EXAMPLE: UTF8::chr(0x2603); // '鈽'

Parameters:

  • int $code_point <p>The code point for which to generate a character.</p>
  • string $encoding [optional] <p>Default is UTF-8</p>

Return:

  • string|null <p>Multi-byte character, returns null on failure or empty input.</p>

chr_map(callable $callback, string $str): string[]

鈫 Applies callback to all characters of a string.

EXAMPLE: UTF8::chr_map([UTF8::class, 'strtolower'], '螝峤瓜兾嘉'); // ['魏','峤', '蟽', '渭', '蔚']

Parameters:

  • callable $callback <p>The callback function.</p>
  • string $str <p>UTF-8 string to run callback on.</p>

Return:

  • string[] <p>The outcome of the callback, as array.</p>

chr_size_list(string $str): int[]

鈫 Generates an array of byte length of each character of a Unicode string.

1 byte => U+0000 - U+007F 2 byte => U+0080 - U+07FF 3 byte => U+0800 - U+FFFF 4 byte => U+10000 - U+10FFFF

EXAMPLE: UTF8::chr_size_list('涓枃绌虹櫧-test'); // [3, 3, 3, 3, 1, 1, 1, 1, 1]

Parameters:

  • string $str <p>The original unicode string.</p>

Return:

  • int[] <p>An array of byte lengths of each character.</p>

chr_to_decimal(string $char): int

鈫 Get a decimal code representation of a specific character.

INFO: opposite to UTF8::decimal_to_chr()

EXAMPLE: UTF8::chr_to_decimal('搂'); // 0xa7

Parameters:

  • string $char <p>The input character.</p>

Return:

  • int

chr_to_hex(int|string $char, string $prefix): string

鈫 Get hexadecimal code point (U+xxxx) of a UTF-8 encoded character.

EXAMPLE: UTF8::chr_to_hex('搂'); // U+00a7

Parameters:

  • int|string $char <p>The input character</p>
  • string $prefix [optional]

Return:

  • string <p>The code point encoded as U+xxxx.</p>

chunk_split(string $body, int $chunk_length, string $end): string

鈫 Splits a string into smaller chunks and multiple lines, using the specified line ending character.

EXAMPLE: UTF8::chunk_split('ABC-脰脛脺-涓枃绌虹櫧-魏峤瓜兾嘉', 3); // "ABC\r\n-脰脛\r\n脺-涓璡r\n鏂囩┖鐧絓r\n-魏峤筡r\n蟽渭蔚"

Parameters:

  • string $body <p>The original string to be split.</p>
  • int $chunk_length [optional] <p>The maximum character length of a chunk.</p>
  • string $end [optional] <p>The character(s) to be inserted at the end of each chunk.</p>

Return:

  • string <p>The chunked string.</p>

clean(string $str, bool $remove_bom, bool $normalize_whitespace, bool $normalize_msword, bool $keep_non_breaking_space, bool $replace_diamond_question_mark, bool $remove_invisible_characters, bool $remove_invisible_characters_url_encoded): string

鈫 Accepts a string and removes all non-UTF-8 characters from it + extras if needed.

EXAMPLE: UTF8::clean("\xEF\xBB\xBF鈥濧bcdef\xc2\xa0\x20鈥︹ 鈥 馃槂 - D脙录sseldorf", true, true); // '鈥濧bcdef聽 鈥︹ 鈥 馃槂 - D脙录sseldorf'

Parameters:

  • string $str <p>The string to be sanitized.</p>
  • bool $remove_bom [optional] <p>Set to true, if you need to remove UTF-BOM.</p>
  • bool $normalize_whitespace [optional] <p>Set to true, if you need to normalize the whitespace.</p>
  • bool $normalize_msword [optional] <p>Set to true, if you need to normalize MS Word chars e.g.: "鈥" => "..."</p>
  • bool $keep_non_breaking_space [optional] <p>Set to true, to keep non-breaking-spaces, in combination with $normalize_whitespace</p>
  • bool $replace_diamond_question_mark [optional] <p>Set to true, if you need to remove diamond question mark e.g.: "锟"</p>
  • bool $remove_invisible_characters [optional] <p>Set to false, if you not want to remove invisible characters e.g.: "\0"</p>
  • bool $remove_invisible_characters_url_encoded [optional] <p>Set to true, if you not want to remove invisible url encoded characters e.g.: "%0B"<br> WARNING: maybe contains false-positives e.g. aa%0Baa -> aaaa. </p>

Return:

  • string <p>An clean UTF-8 encoded string.</p>

cleanup(string $str): string

鈫 Clean-up a string and show only printable UTF-8 chars at the end + fix UTF-8 encoding.

EXAMPLE: UTF8::cleanup("\xEF\xBB\xBF鈥濧bcdef\xc2\xa0\x20鈥︹ 鈥 馃槂 - D脙录sseldorf", true, true); // '鈥濧bcdef聽 鈥︹ 鈥 馃槂 - D眉sseldorf'

Parameters:

  • string $str <p>The input string.</p>

Return:

  • string

codepoints(string|string[] $arg, bool $use_u_style): int[]|string[]

鈫 Accepts a string or a array of strings and returns an array of Unicode code points.

INFO: opposite to UTF8::string()

EXAMPLE: UTF8::codepoints('魏枚帽'); // array(954, 246, 241) // ... OR ... UTF8::codepoints('魏枚帽', true); // array('U+03ba', 'U+00f6', 'U+00f1')

Parameters:

  • string|string[] $arg <p>A UTF-8 encoded string or an array of such strings.</p>
  • bool $use_u_style <p>If True, will return code points in U+xxxx format, default, code points will be returned as integers.</p>

Return:

  • int[]|string[] <p> The array of code points:<br> int[] for $u_style === false<br> string[] for $u_style === true<br> </p>

collapse_whitespace(string $str): string

鈫 Trims the string and replaces consecutive whitespace characters with a single space. This includes tabs and newline characters, as well as multibyte whitespace such as the thin space and ideographic space.

Parameters:

  • string $str <p>The input string.</p>

Return:

  • string <p>A string with trimmed $str and condensed whitespace.</p>

count_chars(string $str, bool $clean_utf8, bool $try_to_use_mb_functions): int[]

鈫 Returns count of characters used in a string.

EXAMPLE: UTF8::count_chars('魏a魏b魏c'); // array('魏' => 3, 'a' => 1, 'b' => 1, 'c' => 1)

Parameters:

  • string $str <p>The input string.</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>
  • bool $try_to_use_mb_functions [optional] <p>Set to false, if you don't want to use

Return:

  • int[] <p>An associative array of Character as keys and their count as values.</p>

css_identifier(string $str, string[] $filter, bool $strip_tags, bool $strtolower): string

鈫 Create a valid CSS identifier for e.g. "class"- or "id"-attributes.

EXAMPLE: UTF8::css_identifier('123foo/bar!!!'); // _23foo-bar

copy&past from https://github.com/drupal/core/blob/8.8.x/lib/Drupal/Component/Utility/Html.php#L95

Parameters:

  • string $str <p>INFO: if no identifier is given e.g. " " or "", we will create a unique string automatically</p>
  • array<string, string> $filter
  • bool $strip_tags
  • bool $strtolower

Return:

  • string

css_stripe_media_queries(string $str): string

鈫 Remove css media-queries.

Parameters:

  • string $str

Return:

  • string

ctype_loaded(): bool

鈫 Checks whether ctype is available on the server.

Parameters: nothing

Return:

  • bool <p><strong>true</strong> if available, <strong>false</strong> otherwise</p>

decimal_to_chr(int|string $int): string

鈫 Converts an int value into a UTF-8 character.

INFO: opposite to UTF8::string()

EXAMPLE: UTF8::decimal_to_chr(931); // '危'

Parameters:

  • int|numeric-string $int

Return:

  • string

decode_mimeheader(string $str, string $encoding): false|string

鈫 Decodes a MIME header field

Parameters:

  • string $str
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • false|string <p>A decoded MIME field on success, or false if an error occurs during the decoding.</p>

emoji_decode(string $str, bool $use_reversible_string_mappings): string

鈫 Decodes a string which was encoded by "UTF8::emoji_encode()".

INFO: opposite to UTF8::emoji_encode()

EXAMPLE: UTF8::emoji_decode('foo CHARACTER_OGRE', false); // 'foo 馃懝' // UTF8::emoji_decode('foo -_PORTABLE_UTF8-308095726-627590803-8FTU_ELBATROP-_', true); // 'foo 馃懝'

Parameters:

  • string $str <p>The input string.</p>
  • bool $use_reversible_string_mappings [optional] <p> When <b>TRUE</b>, we se a reversible string mapping between "emoji_encode" and "emoji_decode".</p>

Return:

  • string

emoji_encode(string $str, bool $use_reversible_string_mappings): string

鈫 Encode a string with emoji chars into a non-emoji string.

INFO: opposite to UTF8::emoji_decode()

EXAMPLE: UTF8::emoji_encode('foo 馃懝', false)); // 'foo CHARACTER_OGRE' // UTF8::emoji_encode('foo 馃懝', true)); // 'foo -_PORTABLE_UTF8-308095726-627590803-8FTU_ELBATROP-_'

Parameters:

  • string $str <p>The input string</p>
  • bool $use_reversible_string_mappings [optional] <p> when <b>TRUE</b>, we use a reversible string mapping between "emoji_encode" and "emoji_decode"</p>

Return:

  • string

emoji_from_country_code(string $country_code_iso_3166_1): string

鈫 Convert any two-letter country code (ISO 3166-1) to the corresponding Emoji.

Parameters:

  • string $country_code_iso_3166_1 <p>e.g. DE</p>

Return:

  • string <p>Emoji or empty string on error.</p>

encode(string $to_encoding, string $str, bool $auto_detect_the_from_encoding, string $from_encoding): string

鈫 Encode a string with a new charset-encoding.

INFO: This function will also try to fix broken / double encoding, so you can call this function also on a UTF-8 string and you don't mess up the string.

EXAMPLE: UTF8::encode('ISO-8859-1', '-ABC-涓枃绌虹櫧-'); // '-ABC-????-' // UTF8::encode('UTF-8', '-ABC-涓枃绌虹櫧-'); // '-ABC-涓枃绌虹櫧-' // UTF8::encode('HTML', '-ABC-涓枃绌虹櫧-'); // '-ABC-中文空白-' // UTF8::encode('BASE64', '-ABC-涓枃绌虹櫧-'); // 'LUFCQy3kuK3mlofnqbrnmb0t'

Parameters:

  • string $to_encoding <p>e.g. 'UTF-16', 'UTF-8', 'ISO-8859-1', etc.</p>
  • string $str <p>The input string</p>
  • bool $auto_detect_the_from_encoding [optional] <p>Force the new encoding (we try to fix broken / double encoding for UTF-8)<br> otherwise we auto-detect the current string-encoding</p>
  • string $from_encoding [optional] <p>e.g. 'UTF-16', 'UTF-8', 'ISO-8859-1', etc.<br> A empty string will trigger the autodetect anyway.</p>

Return:

  • string

encode_mimeheader(string $str, string $from_charset, string $to_charset, string $transfer_encoding, string $linefeed, int $indent): false|string

Parameters:

  • string $str
  • string $from_charset [optional] <p>Set the input charset.</p>
  • string $to_charset [optional] <p>Set the output charset.</p>
  • string $transfer_encoding [optional] <p>Set the transfer encoding.</p>
  • string $linefeed [optional] <p>Set the used linefeed.</p>
  • int $indent [optional] <p>Set the max length indent.</p>

Return:

  • false|string <p>An encoded MIME field on success, or false if an error occurs during the encoding.</p>

extract_text(string $str, string $search, int|null $length, string $replacer_for_skipped_text, string $encoding): string

鈫 Create an extract from a sentence, so if the search-string was found, it try to centered in the output.

Parameters:

  • string $str <p>The input string.</p>
  • string $search <p>The searched string.</p>
  • int|null $length [optional] <p>Default: null === text->length / 2</p>
  • string $replacer_for_skipped_text [optional] <p>Default: 鈥</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string

file_get_contents(string $filename, bool $use_include_path, resource|null $context, int|null $offset, int|null $max_length, int $timeout, bool $convert_to_utf8, string $from_encoding): false|string

鈫 Reads entire file into a string.

EXAMPLE: UTF8::file_get_contents('utf16le.txt'); // ...

WARNING: Do not use UTF-8 Option ($convert_to_utf8) for binary files (e.g.: images) !!!

Parameters:

  • string $filename <p> Name of the file to read. </p>
  • bool $use_include_path [optional] <p> Prior to PHP 5, this parameter is called use_include_path and is a bool. As of PHP 5 the FILE_USE_INCLUDE_PATH can be used to trigger include path search. </p>
  • resource|null $context [optional] <p> A valid context resource created with stream_context_create. If you don't need to use a custom context, you can skip this parameter by &null;. </p>
  • int|null $offset [optional] <p> The offset where the reading starts. </p>
  • int|null $max_length [optional] <p> Maximum length of data read. The default is to read until end of file is reached. </p>
  • int $timeout <p>The time in seconds for the timeout.</p>
  • bool $convert_to_utf8 <strong>WARNING!!!</strong> <p>Maybe you can't use this option for some files, because they used non default utf-8 chars. Binary files like images or pdf will not be converted.</p>
  • string $from_encoding [optional] <p>e.g. 'UTF-16', 'UTF-8', 'ISO-8859-1', etc.<br> A empty string will trigger the autodetect anyway.</p>

Return:

  • false|string <p>The function returns the read data as string or <b>false</b> on failure.</p>

file_has_bom(string $file_path): bool

鈫 Checks if a file starts with BOM (Byte Order Mark) character.

EXAMPLE: UTF8::file_has_bom('utf8_with_bom.txt'); // true

Parameters:

  • string $file_path <p>Path to a valid file.</p>

Return:

  • bool <p><strong>true</strong> if the file has BOM at the start, <strong>false</strong> otherwise</p>

filter(array|object|string $var, int $normalization_form, string $leading_combining): mixed

鈫 Normalizes to UTF-8 NFC, converting from WINDOWS-1252 when needed.

EXAMPLE: UTF8::filter(array("\xE9", '脿', 'a')); // array('茅', 'a虁', 'a')

Parameters:

  • TFilter $var
  • int $normalization_form
  • string $leading_combining

Return:

  • mixed

filter_input(int $type, string $variable_name, int $filter, int|int[]|null $options): mixed

鈫 "filter_input()"-wrapper with normalizes to UTF-8 NFC, converting from WINDOWS-1252 when needed.

Gets a specific external variable by name and optionally filters it.

EXAMPLE: // _GET['foo'] = 'bar'; UTF8::filter_input(INPUT_GET, 'foo', FILTER_SANITIZE_STRING)); // 'bar'

Parameters:

  • int $type <p> One of <b>INPUT_GET</b>, <b>INPUT_POST</b>, <b>INPUT_COOKIE</b>, <b>INPUT_SERVER</b>, or <b>INPUT_ENV</b>. </p>
  • string $variable_name <p> Name of a variable to get. </p>
  • int $filter [optional] <p> The ID of the filter to apply. The manual page lists the available filters. </p>
  • int|int[]|null $options [optional] <p> Associative array of options or bitwise disjunction of flags. If filter accepts options, flags can be provided in "flags" field of array. </p>

Return:

  • mixed <p> Value of the requested variable on success, <b>FALSE</b> if the filter fails, or <b>NULL</b> if the <i>variable_name</i> variable is not set. If the flag <b>FILTER_NULL_ON_FAILURE</b> is used, it returns <b>FALSE</b> if the variable is not set and <b>NULL</b> if the filter fails. </p>

filter_input_array(int $type, array|null $definition, bool $add_empty): mixed

鈫 "filter_input_array()"-wrapper with normalizes to UTF-8 NFC, converting from WINDOWS-1252 when needed.

Gets external variables and optionally filters them.

EXAMPLE: // _GET['foo'] = 'bar'; UTF8::filter_input_array(INPUT_GET, array('foo' => 'FILTER_SANITIZE_STRING')); // array('bar')

Parameters:

  • int $type <p> One of <b>INPUT_GET</b>, <b>INPUT_POST</b>, <b>INPUT_COOKIE</b>, <b>INPUT_SERVER</b>, or <b>INPUT_ENV</b>. </p>
  • array|null $definition [optional] <p> An array defining the arguments. A valid key is a string containing a variable name and a valid value is either a filter type, or an array optionally specifying the filter, flags and options. If the value is an array, valid keys are filter which specifies the filter type, flags which specifies any flags that apply to the filter, and options which specifies any options that apply to the filter. See the example below for a better understanding. </p> <p> This parameter can be also an integer holding a filter constant. Then all values in the input array are filtered by this filter. </p>
  • bool $add_empty [optional] <p> Add missing keys as <b>NULL</b> to the return value. </p>

Return:

  • mixed <p> An array containing the values of the requested variables on success, or <b>FALSE</b> on failure. An array value will be <b>FALSE</b> if the filter fails, or <b>NULL</b> if the variable is not set. Or if the flag <b>FILTER_NULL_ON_FAILURE</b> is used, it returns <b>FALSE</b> if the variable is not set and <b>NULL</b> if the filter fails. </p>

filter_var(float|int|string|null $variable, int $filter, int|int[]|null $options): mixed

鈫 "filter_var()"-wrapper with normalizes to UTF-8 NFC, converting from WINDOWS-1252 when needed.

Filters a variable with a specified filter.

EXAMPLE: UTF8::filter_var('-ABC-涓枃绌虹櫧-', FILTER_VALIDATE_URL); // false

Parameters:

  • float|int|string|null $variable <p> Value to filter. </p>
  • int $filter [optional] <p> The ID of the filter to apply. The manual page lists the available filters. </p>
  • int|int[]|null $options [optional] <p> Associative array of options or bitwise disjunction of flags. If filter accepts options, flags can be provided in "flags" field of array. For the "callback" filter, callable type should be passed. The callback must accept one argument, the value to be filtered, and return the value after filtering/sanitizing it. </p> <p> <code> // for filters that accept options, use this format $options = array( 'options' => array( 'default' => 3, // value to return if the filter fails // other options here 'min_range' => 0 ), 'flags' => FILTER_FLAG_ALLOW_OCTAL, ); $var = filter_var('0755', FILTER_VALIDATE_INT, $options); // for filter that only accept flags, you can pass them directly $var = filter_var('oops', FILTER_VALIDATE_BOOLEAN, FILTER_NULL_ON_FAILURE); // for filter that only accept flags, you can also pass as an array $var = filter_var('oops', FILTER_VALIDATE_BOOLEAN, array('flags' => FILTER_NULL_ON_FAILURE)); // callback validate filter function foo($value) { // Expected format: Surname, GivenNames if (strpos($value, ", ") === false) return false; list($surname, $givennames) = explode(", ", $value, 2); $empty = (empty($surname) || empty($givennames)); $notstrings = (!is_string($surname) || !is_string($givennames)); if ($empty || $notstrings) { return false; } else { return $value; } } $var = filter_var('Doe, Jane Sue', FILTER_CALLBACK, array('options' => 'foo')); </code> </p>

Return:

  • mixed <p>The filtered data, or <b>FALSE</b> if the filter fails.</p>

filter_var_array(array $data, array|int|null $definition, bool $add_empty): mixed

鈫 "filter_var_array()"-wrapper with normalizes to UTF-8 NFC, converting from WINDOWS-1252 when needed.

Gets multiple variables and optionally filters them.

EXAMPLE: $filters = [ 'name' => ['filter' => FILTER_CALLBACK, 'options' => [UTF8::class, 'ucwords']], 'age' => ['filter' => FILTER_VALIDATE_INT, 'options' => ['min_range' => 1, 'max_range' => 120]], 'email' => FILTER_VALIDATE_EMAIL, ];

$data = [ 'name' => '魏峤瓜兾嘉', 'age' => '18', 'email' => 'foo@bar.de' ];

UTF8::filter_var_array($data, $filters, true); // ['name' => '螝蠈蟽渭蔚', 'age' => 18, 'email' => 'foo@bar.de']

Parameters:

  • array $data <p> An array with string keys containing the data to filter. </p>
  • array|int|null $definition [optional] <p> An array defining the arguments. A valid key is a string containing a variable name and a valid value is either a filter type, or an array optionally specifying the filter, flags and options. If the value is an array, valid keys are filter which specifies the filter type, flags which specifies any flags that apply to the filter, and options which specifies any options that apply to the filter. See the example below for a better understanding. </p> <p> This parameter can be also an integer holding a filter constant. Then all values in the input array are filtered by this filter. </p>
  • bool $add_empty [optional] <p> Add missing keys as <b>NULL</b> to the return value. </p>

Return:

  • mixed <p> An array containing the values of the requested variables on success, or <b>FALSE</b> on failure. An array value will be <b>FALSE</b> if the filter fails, or <b>NULL</b> if the variable is not set. </p>

finfo_loaded(): bool

鈫 Checks whether finfo is available on the server.

Parameters: nothing

Return:

  • bool <p><strong>true</strong> if available, <strong>false</strong> otherwise</p>

first_char(string $str, int $n, string $encoding): string

鈫 Returns the first $n characters of the string.

Parameters:

  • string $str <p>The input string.</p>
  • int $n <p>Number of characters to retrieve from the start.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string

fits_inside(string $str, int $box_size): bool

鈫 Check if the number of Unicode characters isn't greater than the specified integer.

EXAMPLE: UTF8::fits_inside('魏峤瓜兾嘉', 6); // false

Parameters:

  • string $str the original string to be checked
  • int $box_size the size in number of chars to be checked against string

Return:

  • bool <p><strong>TRUE</strong> if string is less than or equal to $box_size, <strong>FALSE</strong> otherwise.</p>

fix_simple_utf8(string $str): string

鈫 Try to fix simple broken UTF-8 strings.

INFO: Take a look at "UTF8::fix_utf8()" if you need a more advanced fix for broken UTF-8 strings.

EXAMPLE: UTF8::fix_simple_utf8('D脙录sseldorf'); // 'D眉sseldorf'

If you received an UTF-8 string that was converted from Windows-1252 as it was ISO-8859-1 (ignoring Windows-1252 chars from 80 to 9F) use this function to fix it. See: http://en.wikipedia.org/wiki/Windows-1252

Parameters:

  • string $str <p>The input string</p>

Return:

  • string

fix_utf8(string|string[] $str): string|string[]

鈫 Fix a double (or multiple) encoded UTF8 string.

EXAMPLE: UTF8::fix_utf8('F脙脗脗脗脗漏d脙脗脗脗脗漏ration'); // 'F茅d茅ration'

Parameters:

  • string|string[] $str you can use a string or an array of strings

Return:

  • string|string[] Will return the fixed input-"array" or the fixed input-"string"

getCharDirection(string $char): string

鈫 Get character of a specific character.

EXAMPLE: UTF8::getCharDirection('丕'); // 'RTL'

Parameters:

  • string $char

Return:

  • string <p>'RTL' or 'LTR'.</p>

getSupportInfo(string|null $key): mixed

鈫 Check for php-support.

Parameters:

  • string|null $key

Return:

  • mixed Return the full support-"array", if $key === null<br> return bool-value, if $key is used and available<br> otherwise return <strong>null</strong>

get_file_type(string $str, array $fallback): null[]|string[]

鈫 Warning: this method only works for some file-types (png, jpg) if you need more supported types, please use e.g. "finfo"

Parameters:

  • string $str
  • array{ext: (null|string), mime: (null|string), type: (null|string)} $fallback <p>with this keys: 'ext', 'mime', 'type'

Return:

  • null[]|string[] <p>with this keys: 'ext', 'mime', 'type'</p>

get_random_string(int $length, string $possible_chars, string $encoding): string

Parameters:

  • int $length <p>Length of the random string.</p>
  • string $possible_chars [optional] <p>Characters string for the random selection.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string

get_unique_string(int|string $extra_entropy, bool $use_md5): string

Parameters:

  • int|string $extra_entropy [optional] <p>Extra entropy via a string or int value.</p>
  • bool $use_md5 [optional] <p>Return the unique identifier as md5-hash? Default: true</p>

Return:

  • string

has_lowercase(string $str): bool

鈫 Returns true if the string contains a lower case char, false otherwise.

Parameters:

  • string $str <p>The input string.</p>

Return:

  • bool <p>Whether or not the string contains a lower case character.</p>

has_uppercase(string $str): bool

鈫 Returns true if the string contains an upper case char, false otherwise.

Parameters:

  • string $str <p>The input string.</p>

Return:

  • bool <p>Whether or not the string contains an upper case character.</p>

has_whitespace(string $str): bool

鈫 Returns true if the string contains whitespace, false otherwise.

Parameters:

  • string $str <p>The input string.</p>

Return:

  • bool <p>Whether or not the string contains whitespace.</p>

hex_to_chr(string $hexdec): false|string

鈫 Converts a hexadecimal value into a UTF-8 character.

INFO: opposite to UTF8::chr_to_hex()

EXAMPLE: UTF8::hex_to_chr('U+00a7'); // '搂'

Parameters:

  • string $hexdec <p>The hexadecimal value.</p>

Return:

  • false|string one single UTF-8 character

hex_to_int(string $hexdec): false|int

鈫 Converts hexadecimal U+xxxx code point representation to integer.

INFO: opposite to UTF8::int_to_hex()

EXAMPLE: UTF8::hex_to_int('U+00f1'); // 241

Parameters:

  • string $hexdec <p>The hexadecimal code point representation.</p>

Return:

  • false|int <p>The code point, or false on failure.</p>

html_encode(string $str, bool $keep_ascii_chars, string $encoding): string

鈫 Converts a UTF-8 string to a series of HTML numbered entities.

INFO: opposite to UTF8::html_decode()

EXAMPLE: UTF8::html_encode('涓枃绌虹櫧'); // '中文空白'

Parameters:

  • string $str <p>The Unicode string to be encoded as numbered entities.</p>
  • bool $keep_ascii_chars [optional] <p>Keep ASCII chars.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string HTML numbered entities

html_entity_decode(string $str, int|null $flags, string $encoding): string

鈫 UTF-8 version of html_entity_decode()

The reason we are not using html_entity_decode() by itself is because while it is not technically correct to leave out the semicolon at the end of an entity most browsers will still interpret the entity correctly. html_entity_decode() does not convert entities without semicolons, so we are left with our own little solution here. Bummer.

Convert all HTML entities to their applicable characters.

INFO: opposite to UTF8::html_encode()

EXAMPLE: UTF8::html_entity_decode('中文空白'); // '涓枃绌虹櫧'

Parameters:

  • string $str <p> The input string. </p>
  • int|null $flags [optional] <p> A bitmask of one or more of the following flags, which specify how to handle quotes and which document type to use. The default is ENT_COMPAT | ENT_HTML401. <table> Available <i>flags</i> constants <tr valign="top"> <td>Constant Name</td> <td>Description</td> </tr> <tr valign="top"> <td><b>ENT_COMPAT</b></td> <td>Will convert double-quotes and leave single-quotes alone.</td> </tr> <tr valign="top"> <td><b>ENT_QUOTES</b></td> <td>Will convert both double and single quotes.</td> </tr> <tr valign="top"> <td><b>ENT_NOQUOTES</b></td> <td>Will leave both double and single quotes unconverted.</td> </tr> <tr valign="top"> <td><b>ENT_HTML401</b></td> <td> Handle code as HTML 4.01. </td> </tr> <tr valign="top"> <td><b>ENT_XML1</b></td> <td> Handle code as XML 1. </td> </tr> <tr valign="top"> <td><b>ENT_XHTML</b></td> <td> Handle code as XHTML. </td> </tr> <tr valign="top"> <td><b>ENT_HTML5</b></td> <td> Handle code as HTML 5. </td> </tr> </table> </p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string the decoded string

html_escape(string $str, string $encoding): string

鈫 Create a escape html version of the string via "UTF8::htmlspecialchars()".

Parameters:

  • string $str
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string

html_stripe_empty_tags(string $str): string

鈫 Remove empty html-tag.

e.g.:

Parameters:

  • string $str

Return:

  • string

htmlentities(string $str, int $flags, string $encoding, bool $double_encode): string

鈫 Convert all applicable characters to HTML entities: UTF-8 version of htmlentities().

EXAMPLE: UTF8::htmlentities('<鐧-枚盲眉>'); // '<白-öäü>'

Parameters:

  • string $str <p> The input string. </p>
  • int $flags [optional] <p> A bitmask of one or more of the following flags, which specify how to handle quotes, invalid code unit sequences and the used document type. The default is ENT_COMPAT | ENT_HTML401. <table> Available <i>flags</i> constants <tr valign="top"> <td>Constant Name</td> <td>Description</td> </tr> <tr valign="top"> <td><b>ENT_COMPAT</b></td> <td>Will convert double-quotes and leave single-quotes alone.</td> </tr> <tr valign="top"> <td><b>ENT_QUOTES</b></td> <td>Will convert both double and single quotes.</td> </tr> <tr valign="top"> <td><b>ENT_NOQUOTES</b></td> <td>Will leave both double and single quotes unconverted.</td> </tr> <tr valign="top"> <td><b>ENT_IGNORE</b></td> <td> Silently discard invalid code unit sequences instead of returning an empty string. Using this flag is discouraged as it may have security implications. </td> </tr> <tr valign="top"> <td><b>ENT_SUBSTITUTE</b></td> <td> Replace invalid code unit sequences with a Unicode Replacement Character U+FFFD (UTF-8) or &#38;#38;#FFFD; (otherwise) instead of returning an empty string. </td> </tr> <tr valign="top"> <td><b>ENT_DISALLOWED</b></td> <td> Replace invalid code points for the given document type with a Unicode Replacement Character U+FFFD (UTF-8) or &#38;#38;#FFFD; (otherwise) instead of leaving them as is. This may be useful, for instance, to ensure the well-formedness of XML documents with embedded external content. </td> </tr> <tr valign="top"> <td><b>ENT_HTML401</b></td> <td> Handle code as HTML 4.01. </td> </tr> <tr valign="top"> <td><b>ENT_XML1</b></td> <td> Handle code as XML 1. </td> </tr> <tr valign="top"> <td><b>ENT_XHTML</b></td> <td> Handle code as XHTML. </td> </tr> <tr valign="top"> <td><b>ENT_HTML5</b></td> <td> Handle code as HTML 5. </td> </tr> </table> </p>
  • string $encoding [optional] <p> Like <b>htmlspecialchars</b>, <b>htmlentities</b> takes an optional third argument <i>encoding</i> which defines encoding used in conversion. Although this argument is technically optional, you are highly encouraged to specify the correct value for your code. </p>
  • bool $double_encode [optional] <p> When <i>double_encode</i> is turned off PHP will not encode existing html entities. The default is to convert everything. </p>

Return:

  • string <p> The encoded string. <br><br> If the input <i>string</i> contains an invalid code unit sequence within the given <i>encoding</i> an empty string will be returned, unless either the <b>ENT_IGNORE</b> or <b>ENT_SUBSTITUTE</b> flags are set. </p>

htmlspecialchars(string $str, int $flags, string $encoding, bool $double_encode): string

鈫 Convert only special characters to HTML entities: UTF-8 version of htmlspecialchars()

INFO: Take a look at "UTF8::htmlentities()"

EXAMPLE: UTF8::htmlspecialchars('<鐧-枚盲眉>'); // '<鐧-枚盲眉>'

Parameters:

  • string $str <p> The string being converted. </p>
  • int $flags [optional] <p> A bitmask of one or more of the following flags, which specify how to handle quotes, invalid code unit sequences and the used document type. The default is ENT_COMPAT | ENT_HTML401. <table> Available <i>flags</i> constants <tr valign="top"> <td>Constant Name</td> <td>Description</td> </tr> <tr valign="top"> <td><b>ENT_COMPAT</b></td> <td>Will convert double-quotes and leave single-quotes alone.</td> </tr> <tr valign="top"> <td><b>ENT_QUOTES</b></td> <td>Will convert both double and single quotes.</td> </tr> <tr valign="top"> <td><b>ENT_NOQUOTES</b></td> <td>Will leave both double and single quotes unconverted.</td> </tr> <tr valign="top"> <td><b>ENT_IGNORE</b></td> <td> Silently discard invalid code unit sequences instead of returning an empty string. Using this flag is discouraged as it may have security implications. </td> </tr> <tr valign="top"> <td><b>ENT_SUBSTITUTE</b></td> <td> Replace invalid code unit sequences with a Unicode Replacement Character U+FFFD (UTF-8) or &#38;#38;#FFFD; (otherwise) instead of returning an empty string. </td> </tr> <tr valign="top"> <td><b>ENT_DISALLOWED</b></td> <td> Replace invalid code points for the given document type with a Unicode Replacement Character U+FFFD (UTF-8) or &#38;#38;#FFFD; (otherwise) instead of leaving them as is. This may be useful, for instance, to ensure the well-formedness of XML documents with embedded external content. </td> </tr> <tr valign="top"> <td><b>ENT_HTML401</b></td> <td> Handle code as HTML 4.01. </td> </tr> <tr valign="top"> <td><b>ENT_XML1</b></td> <td> Handle code as XML 1. </td> </tr> <tr valign="top"> <td><b>ENT_XHTML</b></td> <td> Handle code as XHTML. </td> </tr> <tr valign="top"> <td><b>ENT_HTML5</b></td> <td> Handle code as HTML 5. </td> </tr> </table> </p>
  • string $encoding [optional] <p> Defines encoding used in conversion. </p> <p> For the purposes of this function, the encodings ISO-8859-1, ISO-8859-15, UTF-8, cp866, cp1251, cp1252, and KOI8-R are effectively equivalent, provided the <i>string</i> itself is valid for the encoding, as the characters affected by <b>htmlspecialchars</b> occupy the same positions in all of these encodings. </p>
  • bool $double_encode [optional] <p> When <i>double_encode</i> is turned off PHP will not encode existing html entities, the default is to convert everything. </p>

Return:

  • string the converted string. </p> <p> If the input <i>string</i> contains an invalid code unit sequence within the given <i>encoding</i> an empty string will be returned, unless either the <b>ENT_IGNORE</b> or <b>ENT_SUBSTITUTE</b> flags are set

iconv_loaded(): bool

鈫 Checks whether iconv is available on the server.

Parameters: nothing

Return:

  • bool <p><strong>true</strong> if available, <strong>false</strong> otherwise</p>

int_to_hex(int $int, string $prefix): string

鈫 Converts Integer to hexadecimal U+xxxx code point representation.

INFO: opposite to UTF8::hex_to_int()

EXAMPLE: UTF8::int_to_hex(241); // 'U+00f1'

Parameters:

  • int $int <p>The integer to be converted to hexadecimal code point.</p>
  • string $prefix [optional]

Return:

  • string the code point, or empty string on failure

intlChar_loaded(): bool

鈫 Checks whether intl-char is available on the server.

Parameters: nothing

Return:

  • bool <p><strong>true</strong> if available, <strong>false</strong> otherwise</p>

intl_loaded(): bool

鈫 Checks whether intl is available on the server.

Parameters: nothing

Return:

  • bool <p><strong>true</strong> if available, <strong>false</strong> otherwise</p>

is_alpha(string $str): bool

鈫 Returns true if the string contains only alphabetic chars, false otherwise.

Parameters:

  • string $str <p>The input string.</p>

Return:

  • bool <p>Whether or not $str contains only alphabetic chars.</p>

is_alphanumeric(string $str): bool

鈫 Returns true if the string contains only alphabetic and numeric chars, false otherwise.

Parameters:

  • string $str <p>The input string.</p>

Return:

  • bool <p>Whether or not $str contains only alphanumeric chars.</p>

is_ascii(string $str): bool

鈫 Checks if a string is 7 bit ASCII.

EXAMPLE: UTF8::is_ascii('鐧'); // false

Parameters:

  • string $str <p>The string to check.</p>

Return:

  • bool <p> <strong>true</strong> if it is ASCII<br> <strong>false</strong> otherwise </p>

is_base64(string|null $str, bool $empty_string_is_valid): bool

鈫 Returns true if the string is base64 encoded, false otherwise.

EXAMPLE: UTF8::is_base64('4KSu4KWL4KSo4KS/4KSa'); // true

Parameters:

  • string|null $str <p>The input string.</p>
  • bool $empty_string_is_valid [optional] <p>Is an empty string valid base64 or not?</p>

Return:

  • bool <p>Whether or not $str is base64 encoded.</p>

is_binary(int|string $input, bool $strict): bool

鈫 Check if the input is binary.

.. (is look like a hack).

EXAMPLE: UTF8::is_binary(01); // true

Parameters:

  • int|string $input
  • bool $strict

Return:

  • bool

is_binary_file(string $file): bool

鈫 Check if the file is binary.

EXAMPLE: UTF8::is_binary('./utf32.txt'); // true

Parameters:

  • string $file

Return:

  • bool

is_blank(string $str): bool

鈫 Returns true if the string contains only whitespace chars, false otherwise.

Parameters:

  • string $str <p>The input string.</p>

Return:

  • bool <p>Whether or not $str contains only whitespace characters.</p>

is_bom(string $str): bool

鈫 Checks if the given string is equal to any "Byte Order Mark".

WARNING: Use "UTF8::string_has_bom()" if you will check BOM in a string.

EXAMPLE: UTF8::is_bom("\xef\xbb\xbf"); // true

Parameters:

  • string $str <p>The input string.</p>

Return:

  • bool <p><strong>true</strong> if the $utf8_chr is Byte Order Mark, <strong>false</strong> otherwise.</p>

is_empty(array|float|int|string $str): bool

鈫 Determine whether the string is considered to be empty.

A variable is considered empty if it does not exist or if its value equals FALSE. empty() does not generate a warning if the variable does not exist.

Parameters:

  • array|float|int|string $str

Return:

  • bool <p>Whether or not $str is empty().</p>

is_hexadecimal(string $str): bool

鈫 Returns true if the string contains only hexadecimal chars, false otherwise.

Parameters:

  • string $str <p>The input string.</p>

Return:

  • bool <p>Whether or not $str contains only hexadecimal chars.</p>

is_html(string $str): bool

鈫 Check if the string contains any HTML tags.

EXAMPLE: UTF8::is_html('lall'); // true

Parameters:

  • string $str <p>The input string.</p>

Return:

  • bool <p>Whether or not $str contains html elements.</p>

is_json(string $str, bool $only_array_or_object_results_are_valid): bool

鈫 Try to check if "$str" is a JSON-string.

EXAMPLE: UTF8::is_json('{"array":[1,"楼","盲"]}'); // true

Parameters:

  • string $str <p>The input string.</p>
  • bool $only_array_or_object_results_are_valid [optional] <p>Only array and objects are valid json results.</p>

Return:

  • bool <p>Whether or not the $str is in JSON format.</p>

is_lowercase(string $str): bool

Parameters:

  • string $str <p>The input string.</p>

Return:

  • bool <p>Whether or not $str contains only lowercase chars.</p>

is_printable(string $str): bool

鈫 Returns true if the string contains only printable (non-invisible) chars, false otherwise.

Parameters:

  • string $str <p>The input string.</p>

Return:

  • bool <p>Whether or not $str contains only printable (non-invisible) chars.</p>

is_punctuation(string $str): bool

鈫 Returns true if the string contains only punctuation chars, false otherwise.

Parameters:

  • string $str <p>The input string.</p>

Return:

  • bool <p>Whether or not $str contains only punctuation chars.</p>

is_serialized(string $str): bool

鈫 Returns true if the string is serialized, false otherwise.

Parameters:

  • string $str <p>The input string.</p>

Return:

  • bool <p>Whether or not $str is serialized.</p>

is_uppercase(string $str): bool

鈫 Returns true if the string contains only lower case chars, false otherwise.

Parameters:

  • string $str <p>The input string.</p>

Return:

  • bool <p>Whether or not $str contains only lower case characters.</p>

is_url(string $url, bool $disallow_localhost): bool

鈫 Check if $url is an correct url.

Parameters:

  • string $url
  • bool $disallow_localhost

Return:

  • bool

is_utf8(int|string|string[]|null $str, bool $strict): bool

鈫 Checks whether the passed input contains only byte sequences that appear valid UTF-8.

EXAMPLE: UTF8::is_utf8(['I帽t毛rn芒ti么n脿liz忙ti酶n', 'foo']); // true // UTF8::is_utf8(["I帽t毛rn芒ti么n脿liz忙ti酶n\xA0\xA1", 'bar']); // false

Parameters:

  • int|string|string[]|null $str <p>The input to be checked.</p>
  • bool $strict <p>Check also if the string is not UTF-16 or UTF-32.</p>

Return:

  • bool

is_utf16(string $str, bool $check_if_string_is_binary): false|int

鈫 Check if the string is UTF-16.

EXAMPLE: UTF8::is_utf16(file_get_contents('utf-16-le.txt')); // 1 // UTF8::is_utf16(file_get_contents('utf-16-be.txt')); // 2 // UTF8::is_utf16(file_get_contents('utf-8.txt')); // false

Parameters:

  • string $str <p>The input string.</p>
  • bool $check_if_string_is_binary

Return:

  • false|int <strong>false</strong> if is't not UTF-16,<br> <strong>1</strong> for UTF-16LE,<br> <strong>2</strong> for UTF-16BE

is_utf32(string $str, bool $check_if_string_is_binary): false|int

鈫 Check if the string is UTF-32.

EXAMPLE: UTF8::is_utf32(file_get_contents('utf-32-le.txt')); // 1 // UTF8::is_utf32(file_get_contents('utf-32-be.txt')); // 2 // UTF8::is_utf32(file_get_contents('utf-8.txt')); // false

Parameters:

  • string $str <p>The input string.</p>
  • bool $check_if_string_is_binary

Return:

  • false|int <strong>false</strong> if is't not UTF-32,<br> <strong>1</strong> for UTF-32LE,<br> <strong>2</strong> for UTF-32BE

json_decode(string $json, bool $assoc, int $depth, int $options): mixed

鈫 (PHP 5 >= 5.2.0, PECL json >= 1.2.0) Decodes a JSON string

EXAMPLE: UTF8::json_decode('[1,"\u00a5","\u00e4"]'); // array(1, '楼', '盲')

Parameters:

  • string $json <p> The <i>json</i> string being decoded. </p> <p> This function only works with UTF-8 encoded strings. </p> <p>PHP implements a superset of JSON - it will also encode and decode scalar types and <b>NULL</b>. The JSON standard only supports these values when they are nested inside an array or an object. </p>
  • bool $assoc [optional] <p> When <b>TRUE</b>, returned objects will be converted into associative arrays. </p>
  • int $depth [optional] <p> User specified recursion depth. </p>
  • int $options [optional] <p> Bitmask of JSON decode options. Currently only <b>JSON_BIGINT_AS_STRING</b> is supported (default is to cast large integers as floats) </p>

Return:

  • mixed <p>The value encoded in <i>json</i> in appropriate PHP type. Values true, false and null (case-insensitive) are returned as <b>TRUE</b>, <b>FALSE</b> and <b>NULL</b> respectively. <b>NULL</b> is returned if the <i>json</i> cannot be decoded or if the encoded data is deeper than the recursion limit.</p>

json_encode(mixed $value, int $options, int $depth): false|string

鈫 (PHP 5 >= 5.2.0, PECL json >= 1.2.0) Returns the JSON representation of a value.

EXAMPLE: UTF8::json_enocde(array(1, '楼', '盲')); // '[1,"\u00a5","\u00e4"]'

Parameters:

  • mixed $value <p> The <i>value</i> being encoded. Can be any type except a resource. </p> <p> All string data must be UTF-8 encoded. </p> <p>PHP implements a superset of JSON - it will also encode and decode scalar types and <b>NULL</b>. The JSON standard only supports these values when they are nested inside an array or an object. </p>
  • int $options [optional] <p> Bitmask consisting of <b>JSON_HEX_QUOT</b>, <b>JSON_HEX_TAG</b>, <b>JSON_HEX_AMP</b>, <b>JSON_HEX_APOS</b>, <b>JSON_NUMERIC_CHECK</b>, <b>JSON_PRETTY_PRINT</b>, <b>JSON_UNESCAPED_SLASHES</b>, <b>JSON_FORCE_OBJECT</b>, <b>JSON_UNESCAPED_UNICODE</b>. The behaviour of these constants is described on the JSON constants page. </p>
  • int $depth [optional] <p> Set the maximum depth. Must be greater than zero. </p>

Return:

  • false|string A JSON encoded <strong>string</strong> on success or<br> <strong>FALSE</strong> on failure

json_loaded(): bool

鈫 Checks whether JSON is available on the server.

Parameters: nothing

Return:

  • bool <p><strong>true</strong> if available, <strong>false</strong> otherwise</p>

lcfirst(string $str, string $encoding, bool $clean_utf8, string|null $lang, bool $try_to_keep_the_string_length): string

鈫 Makes string's first char lowercase.

EXAMPLE: UTF8::lcfirst('脩T脣RN脗TI脭N脌LIZ脝TI脴N'); // 帽T脣RN脗TI脭N脌LIZ脝TI脴N

Parameters:

  • string $str <p>The input string</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>
  • string|null $lang [optional] <p>Set the language for special cases: az, el, lt, tr</p>
  • bool $try_to_keep_the_string_length [optional] <p>true === try to keep the string length: e.g. 岷 -> 脽</p>

Return:

  • string the resulting string

lcwords(string $str, string[] $exceptions, string $char_list, string $encoding, bool $clean_utf8, string|null $lang, bool $try_to_keep_the_string_length): string

鈫 Lowercase for all words in the string.

Parameters:

  • string $str <p>The input string.</p>
  • string[] $exceptions [optional] <p>Exclusion for some words.</p>
  • string $char_list [optional] <p>Additional chars that contains to words and do not start a new word.</p>
  • string $encoding [optional] <p>Set the charset.</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>
  • string|null $lang [optional] <p>Set the language for special cases: az, el, lt, tr</p>
  • bool $try_to_keep_the_string_length [optional] <p>true === try to keep the string length: e.g. 岷 -> 脽</p>

Return:

  • string

ltrim(string $str, string|null $chars): string

鈫 Strip whitespace or other characters from the beginning of a UTF-8 string.

EXAMPLE: UTF8::ltrim('銆涓枃绌虹櫧銆 '); // '涓枃绌虹櫧銆 '

Parameters:

  • string $str <p>The string to be trimmed</p>
  • string|null $chars <p>Optional characters to be stripped</p>

Return:

  • string the string with unwanted characters stripped from the left

max(string[]|string $arg): string|null

鈫 Returns the UTF-8 character with the maximum code point in the given data.

EXAMPLE: UTF8::max('abc-盲枚眉-涓枃绌虹櫧'); // '酶'

Parameters:

  • string[]|string $arg <p>A UTF-8 encoded string or an array of such strings.</p>

Return:

  • string|null the character with the highest code point than others, returns null on failure or empty input

max_chr_width(string $str): int

鈫 Calculates and returns the maximum number of bytes taken by any UTF-8 encoded character in the given string.

EXAMPLE: UTF8::max_chr_width('Int毛rn芒ti么n脿liz忙ti酶n'); // 2

Parameters:

  • string $str <p>The original Unicode string.</p>

Return:

  • int <p>Max byte lengths of the given chars.</p>

mbstring_loaded(): bool

鈫 Checks whether mbstring is available on the server.

Parameters: nothing

Return:

  • bool <p><strong>true</strong> if available, <strong>false</strong> otherwise</p>

min(string|string[] $arg): string|null

鈫 Returns the UTF-8 character with the minimum code point in the given data.

EXAMPLE: UTF8::min('abc-盲枚眉-涓枃绌虹櫧'); // '-'

Parameters:

  • string|string[] $arg <strong>A UTF-8 encoded string or an array of such strings.</strong>

Return:

  • string|null <p>The character with the lowest code point than others, returns null on failure or empty input.</p>

normalize_encoding(mixed $encoding, mixed $fallback): mixed|string

鈫 Normalize the encoding-"name" input.

EXAMPLE: UTF8::normalize_encoding('UTF8'); // 'UTF-8'

Parameters:

  • mixed $encoding <p>e.g.: ISO, UTF8, WINDOWS-1251 etc.</p>
  • string|TNormalizeEncodingFallback $fallback <p>e.g.: UTF-8</p>

Return:

  • mixed|string <p>e.g.: ISO-8859-1, UTF-8, WINDOWS-1251 etc.<br>Will return a empty string as fallback (by default)</p>

normalize_line_ending(string $str, string|string[] $replacer): string

鈫 Standardize line ending to unix-like.

Parameters:

  • string $str <p>The input string.</p>
  • string|string[] $replacer <p>The replacer char e.g. "\n" (Linux) or "\r\n" (Windows). You can also use \PHP_EOL here.</p>

Return:

  • string <p>A string with normalized line ending.</p>

normalize_msword(string $str): string

鈫 Normalize some MS Word special characters.

EXAMPLE: UTF8::normalize_msword('鈥濧bcdef鈥︹'); // '"Abcdef..."'

Parameters:

  • string $str <p>The string to be normalized.</p>

Return:

  • string <p>A string with normalized characters for commonly used chars in Word documents.</p>

normalize_whitespace(string $str, bool $keep_non_breaking_space, bool $keep_bidi_unicode_controls): string

鈫 Normalize the whitespace.

EXAMPLE: UTF8::normalize_whitespace("abc-\xc2\xa0-枚盲眉-\xe2\x80\xaf-\xE2\x80\xAC", true); // "abc-\xc2\xa0-枚盲眉- -"

Parameters:

  • string $str <p>The string to be normalized.</p>
  • bool $keep_non_breaking_space [optional] <p>Set to true, to keep non-breaking-spaces.</p>
  • bool $keep_bidi_unicode_controls [optional] <p>Set to true, to keep non-printable (for the web) bidirectional text chars.</p>

Return:

  • string <p>A string with normalized whitespace.</p>

ord(string $chr, string $encoding): int

鈫 Calculates Unicode code point of the given UTF-8 encoded character.

INFO: opposite to UTF8::chr()

EXAMPLE: UTF8::ord('鈽'); // 0x2603

Parameters:

  • string $chr <p>The character of which to calculate code point.<p/>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • int <p>Unicode code point of the given character,<br> 0 on invalid UTF-8 byte sequence</p>

parse_str(string $str, array $result, bool $clean_utf8): bool

鈫 Parses the string into an array (into the the second parameter).

WARNING: Unlike "parse_str()", this method does not (re-)place variables in the current scope, if the second parameter is not set!

EXAMPLE: UTF8::parse_str('I帽t毛rn芒ti么n茅脿liz忙ti酶n=娓│&arr[]=foo+娓│&arr[]=嗪佮翰嗪權簵嗪秽簲嗪涵嗪', $array); echo $array['I帽t毛rn芒ti么n茅脿liz忙ti酶n']; // '娓│'

Parameters:

  • string $str <p>The input string.</p>
  • array $result <p>The result will be returned into this reference parameter.</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>

Return:

  • bool <p>Will return <strong>false</strong> if php can't parse the string and we haven't any $result.</p>

pcre_utf8_support(): bool

鈫 Checks if \u modifier is available that enables Unicode support in PCRE.

Parameters: nothing

Return:

  • bool <p> <strong>true</strong> if support is available,<br> <strong>false</strong> otherwise </p>

range(int|string $var1, int|string $var2, bool $use_ctype, string $encoding, float|int $step): string[]

鈫 Create an array containing a range of UTF-8 characters.

EXAMPLE: UTF8::range('魏', '味'); // array('魏', '喂', '胃', '畏', '味',)

Parameters:

  • int|string $var1 <p>Numeric or hexadecimal code points, or a UTF-8 character to start from.</p>
  • int|string $var2 <p>Numeric or hexadecimal code points, or a UTF-8 character to end at.</p>
  • bool $use_ctype <p>use ctype to detect numeric and hexadecimal, otherwise we will use a simple "is_numeric"</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • float|int $step [optional] <p> If a step value is given, it will be used as the increment between elements in the sequence. step should be given as a positive number. If not specified, step will default to 1. </p>

Return:

  • string[]

rawurldecode(string $str, bool $multi_decode): string

鈫 Multi decode HTML entity + fix urlencoded-win1252-chars.

EXAMPLE: UTF8::rawurldecode('tes%20枚盲眉%20\u00edtest+test'); // 'tes 枚盲眉 铆test+test'

e.g: 'test+test' => 'test+test' 'Düsseldorf' => 'D眉sseldorf' 'D%FCsseldorf' => 'D眉sseldorf' 'Düsseldorf' => 'D眉sseldorf' 'D%26%23xFC%3Bsseldorf' => 'D眉sseldorf' 'D脙录sseldorf' => 'D眉sseldorf' 'D%C3%BCsseldorf' => 'D眉sseldorf' 'D%C3%83%C2%BCsseldorf' => 'D眉sseldorf' 'D%25C3%2583%25C2%25BCsseldorf' => 'D眉sseldorf'

Parameters:

  • string $str <p>The input string.</p>
  • bool $multi_decode <p>Decode as often as possible.</p>

Return:

  • string <p>The decoded URL, as a string.</p>

regex_replace(string $str, string $pattern, string $replacement, string $options, string $delimiter): string

鈫 Replaces all occurrences of $pattern in $str by $replacement.

Parameters:

  • string $str <p>The input string.</p>
  • string $pattern <p>The regular expression pattern.</p>
  • string $replacement <p>The string to replace with.</p>
  • string $options [optional] <p>Matching conditions to be used.</p>
  • string $delimiter [optional] <p>Delimiter the the regex. Default: '/'</p>

Return:

  • string

remove_bom(string $str): string

鈫 Remove the BOM from UTF-8 / UTF-16 / UTF-32 strings.

EXAMPLE: UTF8::remove_bom("\xEF\xBB\xBF螠蟺慰蟻蠋 谓伪"); // '螠蟺慰蟻蠋 谓伪'

Parameters:

  • string $str <p>The input string.</p>

Return:

  • string <p>A string without UTF-BOM.</p>

remove_duplicates(string $str, string|string[] $what): string

鈫 Removes duplicate occurrences of a string in another string.

EXAMPLE: UTF8::remove_duplicates('枚盲眉-魏峤瓜兾嘉滴横焦蟽渭蔚-盲枚眉', '魏峤瓜兾嘉'); // '枚盲眉-魏峤瓜兾嘉-盲枚眉'

Parameters:

  • string $str <p>The base string.</p>
  • string|string[] $what <p>String to search for in the base string.</p>

Return:

  • string <p>A string with removed duplicates.</p>

remove_html(string $str, string $allowable_tags): string

鈫 Remove html via "strip_tags()" from the string.

Parameters:

  • string $str <p>The input string.</p>
  • string $allowable_tags [optional] <p>You can use the optional second parameter to specify tags which should not be stripped. Default: null </p>

Return:

  • string <p>A string with without html tags.</p>

remove_html_breaks(string $str, string $replacement): string

鈫 Remove all breaks [ | \r\n | \r | \n | .

..] from the string.

Parameters:

  • string $str <p>The input string.</p>
  • string $replacement [optional] <p>Default is a empty string.</p>

Return:

  • string <p>A string without breaks.</p>

remove_invisible_characters(string $str, bool $url_encoded, string $replacement): string

鈫 Remove invisible characters from a string.

e.g.: This prevents sandwiching null characters between ascii characters, like Java\0script.

EXAMPLE: UTF8::remove_invisible_characters("魏峤瓜僜0渭蔚"); // '魏峤瓜兾嘉'

copy&past from https://github.com/bcit-ci/CodeIgniter/blob/develop/system/core/Common.php

Parameters:

  • string $str <p>The input string.</p>
  • bool $url_encoded [optional] <p> Try to remove url encoded control character. WARNING: maybe contains false-positives e.g. aa%0Baa -> aaaa. <br> Default: false </p>
  • string $replacement [optional] <p>The replacement character.</p>

Return:

  • string <p>A string without invisible chars.</p>

remove_left(string $str, string $substring, string $encoding): string

鈫 Returns a new string with the prefix $substring removed, if present.

Parameters:

  • string $str <p>The input string.</p>
  • string $substring <p>The prefix to remove.</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>

Return:

  • string <p>A string without the prefix $substring.</p>

remove_right(string $str, string $substring, string $encoding): string

鈫 Returns a new string with the suffix $substring removed, if present.

Parameters:

  • string $str
  • string $substring <p>The suffix to remove.</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>

Return:

  • string <p>A string having a $str without the suffix $substring.</p>

replace(string $str, string $search, string $replacement, bool $case_sensitive): string

鈫 Replaces all occurrences of $search in $str by $replacement.

Parameters:

  • string $str <p>The input string.</p>
  • string $search <p>The needle to search for.</p>
  • string $replacement <p>The string to replace with.</p>
  • bool $case_sensitive [optional] <p>Whether or not to enforce case-sensitivity. Default: true</p>

Return:

  • string <p>A string with replaced parts.</p>

replace_all(string $str, array $search, array|string $replacement, bool $case_sensitive): string

鈫 Replaces all occurrences of $search in $str by $replacement.

Parameters:

  • string $str <p>The input string.</p>
  • array $search <p>The elements to search for.</p>
  • array|string $replacement <p>The string to replace with.</p>
  • bool $case_sensitive [optional] <p>Whether or not to enforce case-sensitivity. Default: true</p>

Return:

  • string <p>A string with replaced parts.</p>

replace_diamond_question_mark(string $str, string $replacement_char, bool $process_invalid_utf8_chars): string

鈫 Replace the diamond question mark (锟) and invalid-UTF8 chars with the replacement.

EXAMPLE: UTF8::replace_diamond_question_mark('涓枃绌虹櫧锟', ''); // '涓枃绌虹櫧'

Parameters:

  • string $str <p>The input string</p>
  • string $replacement_char <p>The replacement character.</p>
  • bool $process_invalid_utf8_chars <p>Convert invalid UTF-8 chars </p>

Return:

  • string <p>A string without diamond question marks (锟).</p>

rtrim(string $str, string|null $chars): string

鈫 Strip whitespace or other characters from the end of a UTF-8 string.

EXAMPLE: UTF8::rtrim('-ABC-涓枃绌虹櫧- '); // '-ABC-涓枃绌虹櫧-'

Parameters:

  • string $str <p>The string to be trimmed.</p>
  • string|null $chars <p>Optional characters to be stripped.</p>

Return:

  • string <p>A string with unwanted characters stripped from the right.</p>

showSupport(bool $useEcho): string|void

鈫 WARNING: Print native UTF-8 support (libs) by default, e.g. for debugging.

Parameters:

  • bool $useEcho

Return:

  • string|void

single_chr_html_encode(string $char, bool $keep_ascii_chars, string $encoding): string

鈫 Converts a UTF-8 character to HTML Numbered Entity like "{".

EXAMPLE: UTF8::single_chr_html_encode('魏'); // 'κ'

Parameters:

  • string $char <p>The Unicode character to be encoded as numbered entity.</p>
  • bool $keep_ascii_chars <p>Set to <strong>true</strong> to keep ASCII chars.</>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string <p>The HTML numbered entity for the given character.</p>

spaces_to_tabs(string $str, int $tab_length): string

Parameters:

  • string $str
  • int $tab_length

Return:

  • string

str_camelize(string $str, string $encoding, bool $clean_utf8, string|null $lang, bool $try_to_keep_the_string_length): string

鈫 Returns a camelCase version of the string. Trims surrounding spaces, capitalizes letters following digits, spaces, dashes and underscores, and removes spaces, dashes, as well as underscores.

Parameters:

  • string $str <p>The input string.</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>
  • string|null $lang [optional] <p>Set the language for special cases: az, el, lt, tr</p>
  • bool $try_to_keep_the_string_length [optional] <p>true === try to keep the string length: e.g. 岷 -> 脽</p>

Return:

  • string

str_capitalize_name(string $str): string

鈫 Returns the string with the first letter of each word capitalized, except for when the word is a name which shouldn't be capitalized.

Parameters:

  • string $str

Return:

  • string <p>A string with $str capitalized.</p>

str_contains(string $haystack, string $needle, bool $case_sensitive): bool

鈫 Returns true if the string contains $needle, false otherwise. By default the comparison is case-sensitive, but can be made insensitive by setting $case_sensitive to false.

Parameters:

  • string $haystack <p>The input string.</p>
  • string $needle <p>Substring to look for.</p>
  • bool $case_sensitive [optional] <p>Whether or not to enforce case-sensitivity. Default: true</p>

Return:

  • bool <p>Whether or not $haystack contains $needle.</p>

str_contains_all(string $haystack, array $needles, bool $case_sensitive): bool

鈫 Returns true if the string contains all $needles, false otherwise. By default the comparison is case-sensitive, but can be made insensitive by setting $case_sensitive to false.

Parameters:

  • string $haystack <p>The input string.</p>
  • array $needles <p>SubStrings to look for.</p>
  • bool $case_sensitive [optional] <p>Whether or not to enforce case-sensitivity. Default: true</p>

Return:

  • bool <p>Whether or not $haystack contains $needle.</p>

str_contains_any(string $haystack, array $needles, bool $case_sensitive): bool

鈫 Returns true if the string contains any $needles, false otherwise. By default the comparison is case-sensitive, but can be made insensitive by setting $case_sensitive to false.

Parameters:

  • string $haystack <p>The input string.</p>
  • array $needles <p>SubStrings to look for.</p>
  • bool $case_sensitive [optional] <p>Whether or not to enforce case-sensitivity. Default: true</p>

Return:

  • bool <p>Whether or not $str contains $needle.</p>

str_dasherize(string $str, string $encoding): string

鈫 Returns a lowercase and trimmed string separated by dashes. Dashes are inserted before uppercase characters (with the exception of the first character of the string), and in place of spaces as well as underscores.

Parameters:

  • string $str <p>The input string.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string

str_delimit(string $str, string $delimiter, string $encoding, bool $clean_utf8, string|null $lang, bool $try_to_keep_the_string_length): string

鈫 Returns a lowercase and trimmed string separated by the given delimiter.

Delimiters are inserted before uppercase characters (with the exception of the first character of the string), and in place of spaces, dashes, and underscores. Alpha delimiters are not converted to lowercase.

Parameters:

  • string $str <p>The input string.</p>
  • string $delimiter <p>Sequence used to separate parts of the string.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>
  • string|null $lang [optional] <p>Set the language for special cases: az, el, lt, tr</p>
  • bool $try_to_keep_the_string_length [optional] <p>true === try to keep the string length: e.g. 岷 -> 脽</p>

Return:

  • string

str_detect_encoding(string $str): false|string

鈫 Optimized "mb_detect_encoding()"-function -> with support for UTF-16 and UTF-32.

EXAMPLE: UTF8::str_detect_encoding('涓枃绌虹櫧'); // 'UTF-8' UTF8::str_detect_encoding('Abc'); // 'ASCII'

Parameters:

  • string $str <p>The input string.</p>

Return:

  • false|string <p> The detected string-encoding e.g. UTF-8 or UTF-16BE,<br> otherwise it will return false e.g. for BINARY or not detected encoding. </p>

str_ends_with(string $haystack, string $needle): bool

鈫 Check if the string ends with the given substring.

EXAMPLE: UTF8::str_ends_with('BeginMiddle螝峤瓜兾嘉', '螝峤瓜兾嘉'); // true UTF8::str_ends_with('BeginMiddle螝峤瓜兾嘉', '魏峤瓜兾嘉'); // false

Parameters:

  • string $haystack <p>The string to search in.</p>
  • string $needle <p>The substring to search for.</p>

Return:

  • bool

str_ends_with_any(string $str, string[] $substrings): bool

鈫 Returns true if the string ends with any of $substrings, false otherwise.

  • case-sensitive

Parameters:

  • string $str <p>The input string.</p>
  • string[] $substrings <p>Substrings to look for.</p>

Return:

  • bool <p>Whether or not $str ends with $substring.</p>

str_ensure_left(string $str, string $substring): string

鈫 Ensures that the string begins with $substring. If it doesn't, it's prepended.

Parameters:

  • string $str <p>The input string.</p>
  • string $substring <p>The substring to add if not present.</p>

Return:

  • string

str_ensure_right(string $str, string $substring): string

鈫 Ensures that the string ends with $substring. If it doesn't, it's appended.

Parameters:

  • string $str <p>The input string.</p>
  • string $substring <p>The substring to add if not present.</p>

Return:

  • string

str_humanize(string $str): string

鈫 Capitalizes the first word of the string, replaces underscores with spaces, and strips '_id'.

Parameters:

  • string $str

Return:

  • string

str_iends_with(string $haystack, string $needle): bool

鈫 Check if the string ends with the given substring, case-insensitive.

EXAMPLE: UTF8::str_iends_with('BeginMiddle螝峤瓜兾嘉', '螝峤瓜兾嘉'); // true UTF8::str_iends_with('BeginMiddle螝峤瓜兾嘉', '魏峤瓜兾嘉'); // true

Parameters:

  • string $haystack <p>The string to search in.</p>
  • string $needle <p>The substring to search for.</p>

Return:

  • bool

str_iends_with_any(string $str, string[] $substrings): bool

鈫 Returns true if the string ends with any of $substrings, false otherwise.

  • case-insensitive

Parameters:

  • string $str <p>The input string.</p>
  • string[] $substrings <p>Substrings to look for.</p>

Return:

  • bool <p>Whether or not $str ends with $substring.</p>

str_insert(string $str, string $substring, int $index, string $encoding): string

鈫 Inserts $substring into the string at the $index provided.

Parameters:

  • string $str <p>The input string.</p>
  • string $substring <p>String to be inserted.</p>
  • int $index <p>The index at which to insert the substring.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string

str_ireplace(string|string[] $search, string|string[] $replacement, string|string[] $subject, int $count): string|string[]

鈫 Case-insensitive and UTF-8 safe version of str_replace.

EXAMPLE: UTF8::str_ireplace('lIz脝', 'lise', 'I帽t毛rn芒ti么n脿liz忙ti酶n'); // 'I帽t毛rn芒ti么n脿liseti酶n'

Parameters:

  • string|string[] $search <p> Every replacement with search array is performed on the result of previous replacement. </p>
  • string|string[] $replacement <p>The replacement.</p>
  • TStrIReplaceSubject $subject <p> If subject is an array, then the search and replace is performed with every entry of subject, and the return value is an array as well. </p>
  • int $count [optional] <p> The number of matched and replaced needles will be returned in count which is passed by reference. </p>

Return:

  • string|string[] <p>A string or an array of replacements.</p>

str_ireplace_beginning(string $str, string $search, string $replacement): string

鈫 Replaces $search from the beginning of string with $replacement.

Parameters:

  • string $str <p>The input string.</p>
  • string $search <p>The string to search for.</p>
  • string $replacement <p>The replacement.</p>

Return:

  • string <p>The string after the replacement.</p>

str_ireplace_ending(string $str, string $search, string $replacement): string

鈫 Replaces $search from the ending of string with $replacement.

Parameters:

  • string $str <p>The input string.</p>
  • string $search <p>The string to search for.</p>
  • string $replacement <p>The replacement.</p>

Return:

  • string <p>The string after the replacement.</p>

str_istarts_with(string $haystack, string $needle): bool

鈫 Check if the string starts with the given substring, case-insensitive.

EXAMPLE: UTF8::str_istarts_with('螝峤瓜兾嘉礛iddleEnd', '螝峤瓜兾嘉'); // true UTF8::str_istarts_with('螝峤瓜兾嘉礛iddleEnd', '魏峤瓜兾嘉'); // true

Parameters:

  • string $haystack <p>The string to search in.</p>
  • string $needle <p>The substring to search for.</p>

Return:

  • bool

str_istarts_with_any(string $str, array $substrings): bool

鈫 Returns true if the string begins with any of $substrings, false otherwise.

  • case-insensitive

Parameters:

  • string $str <p>The input string.</p>
  • array $substrings <p>Substrings to look for.</p>

Return:

  • bool <p>Whether or not $str starts with $substring.</p>

str_isubstr_after_first_separator(string $str, string $separator, string $encoding): string

鈫 Gets the substring after the first occurrence of a separator.

Parameters:

  • string $str <p>The input string.</p>
  • string $separator <p>The string separator.</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>

Return:

  • string

str_isubstr_after_last_separator(string $str, string $separator, string $encoding): string

鈫 Gets the substring after the last occurrence of a separator.

Parameters:

  • string $str <p>The input string.</p>
  • string $separator <p>The string separator.</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>

Return:

  • string

str_isubstr_before_first_separator(string $str, string $separator, string $encoding): string

鈫 Gets the substring before the first occurrence of a separator.

Parameters:

  • string $str <p>The input string.</p>
  • string $separator <p>The string separator.</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>

Return:

  • string

str_isubstr_before_last_separator(string $str, string $separator, string $encoding): string

鈫 Gets the substring before the last occurrence of a separator.

Parameters:

  • string $str <p>The input string.</p>
  • string $separator <p>The string separator.</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>

Return:

  • string

str_isubstr_first(string $str, string $needle, bool $before_needle, string $encoding): string

鈫 Gets the substring after (or before via "$before_needle") the first occurrence of the "$needle".

Parameters:

  • string $str <p>The input string.</p>
  • string $needle <p>The string to look for.</p>
  • bool $before_needle [optional] <p>Default: false</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>

Return:

  • string

str_isubstr_last(string $str, string $needle, bool $before_needle, string $encoding): string

鈫 Gets the substring after (or before via "$before_needle") the last occurrence of the "$needle".

Parameters:

  • string $str <p>The input string.</p>
  • string $needle <p>The string to look for.</p>
  • bool $before_needle [optional] <p>Default: false</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>

Return:

  • string

str_last_char(string $str, int $n, string $encoding): string

鈫 Returns the last $n characters of the string.

Parameters:

  • string $str <p>The input string.</p>
  • int $n <p>Number of characters to retrieve from the end.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string

str_limit(string $str, int $length, string $str_add_on, string $encoding): string

鈫 Limit the number of characters in a string.

Parameters:

  • string $str <p>The input string.</p>
  • int $length [optional] <p>Default: 100</p>
  • string $str_add_on [optional] <p>Default: 鈥</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string

str_limit_after_word(string $str, int $length, string $str_add_on, string $encoding): string

鈫 Limit the number of characters in a string, but also after the next word.

EXAMPLE: UTF8::str_limit_after_word('f貌么 b脿艡 f貌么', 8, ''); // 'f貌么 b脿艡'

Parameters:

  • string $str <p>The input string.</p>
  • int $length [optional] <p>Default: 100</p>
  • string $str_add_on [optional] <p>Default: 鈥</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string

str_longest_common_prefix(string $str1, string $str2, string $encoding): string

鈫 Returns the longest common prefix between the $str1 and $str2.

Parameters:

  • string $str1 <p>The input sting.</p>
  • string $str2 <p>Second string for comparison.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string

str_longest_common_substring(string $str1, string $str2, string $encoding): string

鈫 Returns the longest common substring between the $str1 and $str2.

In the case of ties, it returns that which occurs first.

Parameters:

  • string $str1
  • string $str2 <p>Second string for comparison.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string <p>A string with its $str being the longest common substring.</p>

str_longest_common_suffix(string $str1, string $str2, string $encoding): string

鈫 Returns the longest common suffix between the $str1 and $str2.

Parameters:

  • string $str1
  • string $str2 <p>Second string for comparison.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string

str_matches_pattern(string $str, string $pattern): bool

鈫 Returns true if $str matches the supplied pattern, false otherwise.

Parameters:

  • string $str <p>The input string.</p>
  • string $pattern <p>Regex pattern to match against.</p>

Return:

  • bool <p>Whether or not $str matches the pattern.</p>

str_obfuscate(string $str, float $percent, string $obfuscateChar, string[] $keepChars): string

鈫 Convert a string into a obfuscate string.

EXAMPLE:

UTF8::str_obfuscate('lars@moelleken.org', 0.5, '', ['@', '.']); // e.g. "l@mlleke*.r"

Parameters:

  • string $str
  • float $percent
  • string $obfuscateChar
  • string[] $keepChars

Return:

  • string <p>The obfuscate string.</p>

str_offset_exists(string $str, int $offset, string $encoding): bool

鈫 Returns whether or not a character exists at an index. Offsets may be negative to count from the last character in the string. Implements part of the ArrayAccess interface.

Parameters:

  • string $str <p>The input string.</p>
  • int $offset <p>The index to check.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • bool <p>Whether or not the index exists.</p>

str_offset_get(string $str, int $index, string $encoding): string

鈫 Returns the character at the given index. Offsets may be negative to count from the last character in the string. Implements part of the ArrayAccess interface, and throws an OutOfBoundsException if the index does not exist.

Parameters:

  • string $str <p>The input string.</p>
  • int $index <p>The <strong>index</strong> from which to retrieve the char.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string <p>The character at the specified index.</p>

str_pad(string $str, int $pad_length, string $pad_string, int|string $pad_type, string $encoding): string

鈫 Pad a UTF-8 string to a given length with another string.

EXAMPLE: UTF8::str_pad('涓枃绌虹櫧', 10, '', STR_PAD_BOTH); // '涓枃绌虹櫧_'

Parameters:

  • string $str <p>The input string.</p>
  • int $pad_length <p>The length of return string.</p>
  • string $pad_string [optional] <p>String to use for padding the input string.</p>
  • int|string $pad_type [optional] <p> Can be <strong>STR_PAD_RIGHT</strong> (default), [or string "right"]<br> <strong>STR_PAD_LEFT</strong> [or string "left"] or<br> <strong>STR_PAD_BOTH</strong> [or string "both"] </p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>

Return:

  • string <p>Returns the padded string.</p>

str_pad_both(string $str, int $length, string $pad_str, string $encoding): string

鈫 Returns a new string of a given length such that both sides of the string are padded. Alias for "UTF8::str_pad()" with a $pad_type of 'both'.

Parameters:

  • string $str
  • int $length <p>Desired string length after padding.</p>
  • string $pad_str [optional] <p>String used to pad, defaults to space. Default: ' '</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string <p>The string with padding applied.</p>

str_pad_left(string $str, int $length, string $pad_str, string $encoding): string

鈫 Returns a new string of a given length such that the beginning of the string is padded. Alias for "UTF8::str_pad()" with a $pad_type of 'left'.

Parameters:

  • string $str
  • int $length <p>Desired string length after padding.</p>
  • string $pad_str [optional] <p>String used to pad, defaults to space. Default: ' '</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string <p>The string with left padding.</p>

str_pad_right(string $str, int $length, string $pad_str, string $encoding): string

鈫 Returns a new string of a given length such that the end of the string is padded. Alias for "UTF8::str_pad()" with a $pad_type of 'right'.

Parameters:

  • string $str
  • int $length <p>Desired string length after padding.</p>
  • string $pad_str [optional] <p>String used to pad, defaults to space. Default: ' '</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string <p>The string with right padding.</p>

str_repeat(string $str, int $multiplier): string

鈫 Repeat a string.

EXAMPLE: UTF8::str_repeat("掳~\xf0\x90\x28\xbc", 2); // '掳~冒聬(录掳~冒聬(录'

Parameters:

  • string $str <p> The string to be repeated. </p>
  • int $multiplier <p> Number of time the input string should be repeated. </p> <p> multiplier has to be greater than or equal to 0. If the multiplier is set to 0, the function will return an empty string. </p>

Return:

  • string <p>The repeated string.</p>

str_replace_beginning(string $str, string $search, string $replacement): string

鈫 Replaces $search from the beginning of string with $replacement.

Parameters:

  • string $str <p>The input string.</p>
  • string $search <p>The string to search for.</p>
  • string $replacement <p>The replacement.</p>

Return:

  • string <p>A string after the replacements.</p>

str_replace_ending(string $str, string $search, string $replacement): string

鈫 Replaces $search from the ending of string with $replacement.

Parameters:

  • string $str <p>The input string.</p>
  • string $search <p>The string to search for.</p>
  • string $replacement <p>The replacement.</p>

Return:

  • string <p>A string after the replacements.</p>

str_replace_first(string $search, string $replace, string $subject): string

鈫 Replace the first "$search"-term with the "$replace"-term.

Parameters:

  • string $search
  • string $replace
  • string $subject

Return:

  • string

str_replace_last(string $search, string $replace, string $subject): string

鈫 Replace the last "$search"-term with the "$replace"-term.

Parameters:

  • string $search
  • string $replace
  • string $subject

Return:

  • string

str_shuffle(string $str, string $encoding): string

鈫 Shuffles all the characters in the string.

INFO: uses random algorithm which is weak for cryptography purposes

EXAMPLE: UTF8::str_shuffle('f貌么 b脿艡 f貌么'); // '脿貌么艡b ff貌么 '

Parameters:

  • string $str <p>The input string</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string <p>The shuffled string.</p>

str_slice(string $str, int $start, int|null $end, string $encoding): false|string

鈫 Returns the substring beginning at $start, and up to, but not including the index specified by $end. If $end is omitted, the function extracts the remaining string. If $end is negative, it is computed from the end of the string.

Parameters:

  • string $str
  • int $start <p>Initial index from which to begin extraction.</p>
  • int|null $end [optional] <p>Index at which to end extraction. Default: null</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • false|string <p>The extracted substring.</p><p>If <i>str</i> is shorter than <i>start</i> characters long, <b>FALSE</b> will be returned.

str_snakeize(string $str, string $encoding): string

鈫 Convert a string to e.g.: "snake_case"

Parameters:

  • string $str
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string <p>A string in snake_case.</p>

str_sort(string $str, bool $unique, bool $desc): string

鈫 Sort all characters according to code points.

EXAMPLE: UTF8::str_sort(' -ABC-涓枃绌虹櫧- '); // ' ---ABC涓枃鐧界┖'

Parameters:

  • string $str <p>A UTF-8 string.</p>
  • bool $unique <p>Sort unique. If <strong>true</strong>, repeated characters are ignored.</p>
  • bool $desc <p>If <strong>true</strong>, will sort characters in reverse code point order.</p>

Return:

  • string <p>A string of sorted characters.</p>

str_split(int|string $input, int $length, bool $clean_utf8, bool $try_to_use_mb_functions): string[]

鈫 Convert a string to an array of unicode characters.

EXAMPLE: UTF8::str_split('涓枃绌虹櫧'); // array('涓', '鏂', '绌', '鐧')

Parameters:

  • int|string $input <p>The string or int to split into array.</p>
  • int $length [optional] <p>Max character length of each array element.</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>
  • bool $try_to_use_mb_functions [optional] <p>Set to false, if you don't want to use "mb_substr"</p>

Return:

  • string[] <p>An array containing chunks of chars from the input.</p>

str_split_array(int[]|string[] $input, int $length, bool $clean_utf8, bool $try_to_use_mb_functions): string[][]

鈫 Convert a string to an array of Unicode characters.

EXAMPLE: UTF8::str_split_array(['涓枃绌虹櫧', 'test'], 2); // [['涓枃', '绌虹櫧'], ['te', 'st']]

Parameters:

  • int[]|string[] $input <p>The string[] or int[] to split into array.</p>
  • int $length [optional] <p>Max character length of each array lement.</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>
  • bool $try_to_use_mb_functions [optional] <p>Set to false, if you don't want to use "mb_substr"</p>

Return:

  • string[][] <p>An array containing chunks of the input.</p>

str_split_pattern(string $str, string $pattern, int $limit): string[]

鈫 Splits the string with the provided regular expression, returning an array of strings. An optional integer $limit will truncate the results.

Parameters:

  • string $str
  • string $pattern <p>The regex with which to split the string.</p>
  • int $limit [optional] <p>Maximum number of results to return. Default: -1 === no limit</p>

Return:

  • string[] <p>An array of strings.</p>

str_starts_with(string $haystack, string $needle): bool

鈫 Check if the string starts with the given substring.

EXAMPLE: UTF8::str_starts_with('螝峤瓜兾嘉礛iddleEnd', '螝峤瓜兾嘉'); // true UTF8::str_starts_with('螝峤瓜兾嘉礛iddleEnd', '魏峤瓜兾嘉'); // false

Parameters:

  • string $haystack <p>The string to search in.</p>
  • string $needle <p>The substring to search for.</p>

Return:

  • bool

str_starts_with_any(string $str, array $substrings): bool

鈫 Returns true if the string begins with any of $substrings, false otherwise.

  • case-sensitive

Parameters:

  • string $str <p>The input string.</p>
  • array $substrings <p>Substrings to look for.</p>

Return:

  • bool <p>Whether or not $str starts with $substring.</p>

str_substr_after_first_separator(string $str, string $separator, string $encoding): string

鈫 Gets the substring after the first occurrence of a separator.

Parameters:

  • string $str <p>The input string.</p>
  • string $separator <p>The string separator.</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>

Return:

  • string

str_substr_after_last_separator(string $str, string $separator, string $encoding): string

鈫 Gets the substring after the last occurrence of a separator.

Parameters:

  • string $str <p>The input string.</p>
  • string $separator <p>The string separator.</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>

Return:

  • string

str_substr_before_first_separator(string $str, string $separator, string $encoding): string

鈫 Gets the substring before the first occurrence of a separator.

Parameters:

  • string $str <p>The input string.</p>
  • string $separator <p>The string separator.</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>

Return:

  • string

str_substr_before_last_separator(string $str, string $separator, string $encoding): string

鈫 Gets the substring before the last occurrence of a separator.

Parameters:

  • string $str <p>The input string.</p>
  • string $separator <p>The string separator.</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>

Return:

  • string

str_substr_first(string $str, string $needle, bool $before_needle, string $encoding): string

鈫 Gets the substring after (or before via "$before_needle") the first occurrence of the "$needle".

Parameters:

  • string $str <p>The input string.</p>
  • string $needle <p>The string to look for.</p>
  • bool $before_needle [optional] <p>Default: false</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>

Return:

  • string

str_substr_last(string $str, string $needle, bool $before_needle, string $encoding): string

鈫 Gets the substring after (or before via "$before_needle") the last occurrence of the "$needle".

Parameters:

  • string $str <p>The input string.</p>
  • string $needle <p>The string to look for.</p>
  • bool $before_needle [optional] <p>Default: false</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>

Return:

  • string

str_surround(string $str, string $substring): string

鈫 Surrounds $str with the given substring.

Parameters:

  • string $str
  • string $substring <p>The substring to add to both sides.</p>

Return:

  • string <p>A string with the substring both prepended and appended.</p>

str_titleize(string $str, array|string[]|null $ignore, string $encoding, bool $clean_utf8, string|null $lang, bool $try_to_keep_the_string_length, bool $use_trim_first, string|null $word_define_chars): string

鈫 Returns a trimmed string with the first letter of each word capitalized.

Also accepts an array, $ignore, allowing you to list words not to be capitalized.

Parameters:

  • string $str
  • array|string[]|null $ignore [optional] <p>An array of words not to capitalize or null. Default: null</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>
  • string|null $lang [optional] <p>Set the language for special cases: az, el, lt, tr</p>
  • bool $try_to_keep_the_string_length [optional] <p>true === try to keep the string length: e.g. 岷 -> 脽</p>
  • bool $use_trim_first [optional] <p>true === trim the input string, first</p>
  • string|null $word_define_chars [optional] <p>An string of chars that will be used as whitespace separator === words.</p>

Return:

  • string <p>The titleized string.</p>

str_titleize_for_humans(string $str, array $ignore, string $encoding): string

鈫 Returns a trimmed string in proper title case.

Also accepts an array, $ignore, allowing you to list words not to be capitalized.

Adapted from John Gruber's script.

Parameters:

  • string $str
  • array $ignore <p>An array of words not to capitalize.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string <p>The titleized string.</p>

str_to_binary(string $str): false|string

鈫 Get a binary representation of a specific string.

EXAPLE: UTF8::str_to_binary('馃槂'); // '11110000100111111001100010000011'

Parameters:

  • string $str <p>The input string.</p>

Return:

  • false|string <p>false on error</p>

str_to_lines(string $str, bool $remove_empty_values, int|null $remove_short_values): string[]

Parameters:

  • string $str
  • bool $remove_empty_values <p>Remove empty values.</p>
  • int|null $remove_short_values <p>The min. string length or null to disable</p>

Return:

  • string[]

str_to_words(string $str, string $char_list, bool $remove_empty_values, int|null $remove_short_values): string[]

鈫 Convert a string into an array of words.

EXAMPLE: UTF8::str_to_words('涓枃绌虹櫧 o枚盲眉#s', '#') // array('', '涓枃绌虹櫧', ' ', 'o枚盲眉#s', '')

Parameters:

  • string $str
  • string $char_list <p>Additional chars for the definition of "words".</p>
  • bool $remove_empty_values <p>Remove empty values.</p>
  • int|null $remove_short_values <p>The min. string length or null to disable</p>

Return:

  • string[]

str_truncate(string $str, int $length, string $substring, string $encoding): string

鈫 Truncates the string to a given length. If $substring is provided, and truncating occurs, the string is further truncated so that the substring may be appended without exceeding the desired length.

Parameters:

  • string $str
  • int $length <p>Desired length of the truncated string.</p>
  • string $substring [optional] <p>The substring to append if it can fit. Default: ''</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>

Return:

  • string <p>A string after truncating.</p>

str_truncate_safe(string $str, int $length, string $substring, string $encoding, bool $ignore_do_not_split_words_for_one_word): string

鈫 Truncates the string to a given length, while ensuring that it does not split words. If $substring is provided, and truncating occurs, the string is further truncated so that the substring may be appended without exceeding the desired length.

Parameters:

  • string $str
  • int $length <p>Desired length of the truncated string.</p>
  • string $substring [optional] <p>The substring to append if it can fit. Default: ''</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>
  • bool $ignore_do_not_split_words_for_one_word [optional] <p>Default: false</p>

Return:

  • string <p>A string after truncating.</p>

str_underscored(string $str): string

鈫 Returns a lowercase and trimmed string separated by underscores.

Underscores are inserted before uppercase characters (with the exception of the first character of the string), and in place of spaces as well as dashes.

Parameters:

  • string $str

Return:

  • string <p>The underscored string.</p>

str_upper_camelize(string $str, string $encoding, bool $clean_utf8, string|null $lang, bool $try_to_keep_the_string_length): string

鈫 Returns an UpperCamelCase version of the supplied string. It trims surrounding spaces, capitalizes letters following digits, spaces, dashes and underscores, and removes spaces, dashes, underscores.

Parameters:

  • string $str <p>The input string.</p>
  • string $encoding [optional] <p>Default: 'UTF-8'</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>
  • string|null $lang [optional] <p>Set the language for special cases: az, el, lt, tr</p>
  • bool $try_to_keep_the_string_length [optional] <p>true === try to keep the string length: e.g. 岷 -> 脽</p>

Return:

  • string <p>A string in UpperCamelCase.</p>

str_word_count(string $str, int $format, string $char_list): int|string[]

鈫 Get the number of words in a specific string.

EXAMPLES: // format: 0 -> return only word count (int) // UTF8::str_word_count('涓枃绌虹櫧 枚盲眉 abc#c'); // 4 UTF8::str_word_count('涓枃绌虹櫧 枚盲眉 abc#c', 0, '#'); // 3

// format: 1 -> return words (array) // UTF8::str_word_count('涓枃绌虹櫧 枚盲眉 abc#c', 1); // array('涓枃绌虹櫧', '枚盲眉', 'abc', 'c') UTF8::str_word_count('涓枃绌虹櫧 枚盲眉 abc#c', 1, '#'); // array('涓枃绌虹櫧', '枚盲眉', 'abc#c')

// format: 2 -> return words with offset (array) // UTF8::str_word_count('涓枃绌虹櫧 枚盲眉 ab#c', 2); // array(0 => '涓枃绌虹櫧', 5 => '枚盲眉', 9 => 'abc', 13 => 'c') UTF8::str_word_count('涓枃绌虹櫧 枚盲眉 ab#c', 2, '#'); // array(0 => '涓枃绌虹櫧', 5 => '枚盲眉', 9 => 'abc#c')

Parameters:

  • string $str <p>The input string.</p>
  • int $format [optional] <p> <strong>0</strong> => return a number of words (default)<br> <strong>1</strong> => return an array of words<br> <strong>2</strong> => return an array of words with word-offset as key </p>
  • string $char_list [optional] <p>Additional chars that contains to words and do not start a new word.</p>

Return:

  • int|string[] <p>The number of words in the string.</p>

strcasecmp(string $str1, string $str2, string $encoding): int

鈫 Case-insensitive string comparison.

INFO: Case-insensitive version of UTF8::strcmp()

EXAMPLE: UTF8::strcasecmp("i帽t毛rn芒ti么n\n脿liz忙ti酶n", "I帽t毛rn芒ti么n\n脿liz忙ti酶n"); // 0

Parameters:

  • string $str1 <p>The first string.</p>
  • string $str2 <p>The second string.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • int <strong>&lt; 0</strong> if str1 is less than str2;<br> <strong>&gt; 0</strong> if str1 is greater than str2,<br> <strong>0</strong> if they are equal

strcmp(string $str1, string $str2): int

鈫 Case-sensitive string comparison.

EXAMPLE: UTF8::strcmp("i帽t毛rn芒ti么n\n脿liz忙ti酶n", "i帽t毛rn芒ti么n\n脿liz忙ti酶n"); // 0

Parameters:

  • string $str1 <p>The first string.</p>
  • string $str2 <p>The second string.</p>

Return:

  • int <strong>&lt; 0</strong> if str1 is less than str2<br> <strong>&gt; 0</strong> if str1 is greater than str2<br> <strong>0</strong> if they are equal

strcspn(string $str, string $char_list, int $offset, int|null $length, string $encoding): int

鈫 Find length of initial segment not matching mask.

Parameters:

  • string $str
  • string $char_list
  • int $offset
  • int|null $length
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • int

string(int|int[]|string|string[] $intOrHex): string

鈫 Create a UTF-8 string from code points.

INFO: opposite to UTF8::codepoints()

EXAMPLE: UTF8::string(array(246, 228, 252)); // '枚盲眉'

Parameters:

  • int[]|numeric-string[]|int|numeric-string $intOrHex <p>Integer or Hexadecimal codepoints.</p>

Return:

  • string <p>A UTF-8 encoded string.</p>

string_has_bom(string $str): bool

鈫 Checks if string starts with "BOM" (Byte Order Mark Character) character.

EXAMPLE: UTF8::string_has_bom("\xef\xbb\xbf foobar"); // true

Parameters:

  • string $str <p>The input string.</p>

Return:

  • bool <p> <strong>true</strong> if the string has BOM at the start,<br> <strong>false</strong> otherwise </p>

strip_tags(string $str, string|null $allowable_tags, bool $clean_utf8): string

鈫 Strip HTML and PHP tags from a string + clean invalid UTF-8.

EXAMPLE: UTF8::strip_tags("魏峤瓜兾嘉礬xa0\xa1"); // '魏峤瓜兾嘉'

Parameters:

  • string $str <p> The input string. </p>
  • string|null $allowable_tags [optional] <p> You can use the optional second parameter to specify tags which should not be stripped. </p> <p> HTML comments and PHP tags are also stripped. This is hardcoded and can not be changed with allowable_tags. </p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>

Return:

  • string <p>The stripped string.</p>

strip_whitespace(string $str): string

鈫 Strip all whitespace characters. This includes tabs and newline characters, as well as multibyte whitespace such as the thin space and ideographic space.

EXAMPLE: UTF8::strip_whitespace(' 螣 蟽蠀纬纬蟻伪蠁苇伪蟼 '); // '螣蟽蠀纬纬蟻伪蠁苇伪蟼'

Parameters:

  • string $str

Return:

  • string

stripos(string $haystack, string $needle, int $offset, string $encoding, bool $clean_utf8): false|int

鈫 Find the position of the first occurrence of a substring in a string, case-insensitive.

INFO: use UTF8::stripos_in_byte() for the byte-length

EXAMPLE: UTF8::stripos('a蟽蟽b', '危危'); // 1 (蟽蟽 == 危危)

Parameters:

  • string $haystack <p>The string from which to get the position of the first occurrence of needle.</p>
  • string $needle <p>The string to find in haystack.</p>
  • int $offset [optional] <p>The position in haystack to start searching.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>

Return:

  • false|int Return the <strong>(int)</strong> numeric position of the first occurrence of needle in the haystack string,<br> or <strong>false</strong> if needle is not found

stripos_in_byte(string $haystack, string $needle, int $offset): false|int

鈫 Find the position of the first occurrence of a substring in a string, case-insensitive.

Parameters:

  • string $haystack <p> The string being checked. </p>
  • string $needle <p> The position counted from the beginning of haystack. </p>
  • int $offset [optional] <p> The search offset. If it is not specified, 0 is used. </p>

Return:

  • false|int <p>The numeric position of the first occurrence of needle in the haystack string. If needle is not found, it returns false.</p>

stristr(string $haystack, string $needle, bool $before_needle, string $encoding, bool $clean_utf8): false|string

鈫 Returns all of haystack starting from and including the first occurrence of needle to the end.

EXAMPLE: $str = 'i帽t毛rn芒ti么n脿liz忙ti酶n'; $search = 'N脗T';

UTF8::stristr($str, $search)); // 'n芒ti么n脿liz忙ti酶n' UTF8::stristr($str, $search, true)); // 'i帽t毛r'

Parameters:

  • string $haystack <p>The input string. Must be valid UTF-8.</p>
  • string $needle <p>The string to look for. Must be valid UTF-8.</p>
  • bool $before_needle [optional] <p> If <b>TRUE</b>, it returns the part of the haystack before the first occurrence of the needle (excluding the needle). </p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>

Return:

  • false|string <p>A sub-string,<br>or <strong>false</strong> if needle is not found.</p>

strlen(string $str, string $encoding, bool $clean_utf8): false|int

鈫 Get the string length, not the byte-length!

INFO: use UTF8::strwidth() for the char-length

EXAMPLE: UTF8::strlen("I帽t毛rn芒ti么n\xE9脿liz忙ti酶n")); // 20

Parameters:

  • string $str <p>The string being checked for length.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>

Return:

  • false|int <p> The number <strong>(int)</strong> of characters in the string $str having character encoding $encoding. (One multi-byte character counted as +1). <br> Can return <strong>false</strong>, if e.g. mbstring is not installed and we process invalid chars. </p>

strlen_in_byte(string $str): int

鈫 Get string length in byte.

Parameters:

  • string $str

Return:

  • int

strnatcasecmp(string $str1, string $str2, string $encoding): int

鈫 Case-insensitive string comparisons using a "natural order" algorithm.

INFO: natural order version of UTF8::strcasecmp()

EXAMPLES: UTF8::strnatcasecmp('2', '10Hello WORLD 涓枃绌虹櫧!'); // -1 UTF8::strcasecmp('2Hello world 涓枃绌虹櫧!', '10Hello WORLD 涓枃绌虹櫧!'); // 1

UTF8::strnatcasecmp('10Hello world 涓枃绌虹櫧!', '2Hello WORLD 涓枃绌虹櫧!'); // 1 UTF8::strcasecmp('10Hello world 涓枃绌虹櫧!', '2Hello WORLD 涓枃绌虹櫧!'); // -1

Parameters:

  • string $str1 <p>The first string.</p>
  • string $str2 <p>The second string.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • int <strong>&lt; 0</strong> if str1 is less than str2<br> <strong>&gt; 0</strong> if str1 is greater than str2<br> <strong>0</strong> if they are equal

strnatcmp(string $str1, string $str2): int

鈫 String comparisons using a "natural order" algorithm

INFO: natural order version of UTF8::strcmp()

EXAMPLES: UTF8::strnatcmp('2Hello world 涓枃绌虹櫧!', '10Hello WORLD 涓枃绌虹櫧!'); // -1 UTF8::strcmp('2Hello world 涓枃绌虹櫧!', '10Hello WORLD 涓枃绌虹櫧!'); // 1

UTF8::strnatcmp('10Hello world 涓枃绌虹櫧!', '2Hello WORLD 涓枃绌虹櫧!'); // 1 UTF8::strcmp('10Hello world 涓枃绌虹櫧!', '2Hello WORLD 涓枃绌虹櫧!'); // -1

Parameters:

  • string $str1 <p>The first string.</p>
  • string $str2 <p>The second string.</p>

Return:

  • int <strong>&lt; 0</strong> if str1 is less than str2;<br> <strong>&gt; 0</strong> if str1 is greater than str2;<br> <strong>0</strong> if they are equal

strncasecmp(string $str1, string $str2, int $len, string $encoding): int

鈫 Case-insensitive string comparison of the first n characters.

EXAMPLE: UTF8::strcasecmp("i帽t毛rn芒ti么n\n脿liz忙ti酶n321", "i帽t毛rn芒ti么n\n脿liz忙ti酶n123", 5); // 0

Parameters:

  • string $str1 <p>The first string.</p>
  • string $str2 <p>The second string.</p>
  • int $len <p>The length of strings to be used in the comparison.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • int <strong>&lt; 0</strong> if <i>str1</i> is less than <i>str2</i>;<br> <strong>&gt; 0</strong> if <i>str1</i> is greater than <i>str2</i>;<br> <strong>0</strong> if they are equal

strncmp(string $str1, string $str2, int $len, string $encoding): int

鈫 String comparison of the first n characters.

EXAMPLE: UTF8::strncmp("I帽t毛rn芒ti么n\n脿liz忙ti酶n321", "I帽t毛rn芒ti么n\n脿liz忙ti酶n123", 5); // 0

Parameters:

  • string $str1 <p>The first string.</p>
  • string $str2 <p>The second string.</p>
  • int $len <p>Number of characters to use in the comparison.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • int <strong>&lt; 0</strong> if <i>str1</i> is less than <i>str2</i>;<br> <strong>&gt; 0</strong> if <i>str1</i> is greater than <i>str2</i>;<br> <strong>0</strong> if they are equal

strpbrk(string $haystack, string $char_list): false|string

鈫 Search a string for any of a set of characters.

EXAMPLE: UTF8::strpbrk('-涓枃绌虹櫧-', '鐧'); // '鐧-'

Parameters:

  • string $haystack <p>The string where char_list is looked for.</p>
  • string $char_list <p>This parameter is case-sensitive.</p>

Return:

  • false|string <p>The string starting from the character found, or false if it is not found.</p>

strpos(string $haystack, int|string $needle, int $offset, string $encoding, bool $clean_utf8): false|int

鈫 Find the position of the first occurrence of a substring in a string.

INFO: use UTF8::strpos_in_byte() for the byte-length

EXAMPLE: UTF8::strpos('ABC-脰脛脺-涓枃绌虹櫧-涓枃绌虹櫧', '涓'); // 8

Parameters:

  • string $haystack <p>The string from which to get the position of the first occurrence of needle.</p>
  • int|string $needle <p>The string to find in haystack.<br>Or a code point as int.</p>
  • int $offset [optional] <p>The search offset. If it is not specified, 0 is used.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>

Return:

  • false|int The <strong>(int)</strong> numeric position of the first occurrence of needle in the haystack string.<br> If needle is not found it returns false.

strpos_in_byte(string $haystack, string $needle, int $offset): false|int

鈫 Find the position of the first occurrence of a substring in a string.

Parameters:

  • string $haystack <p> The string being checked. </p>
  • string $needle <p> The position counted from the beginning of haystack. </p>
  • int $offset [optional] <p> The search offset. If it is not specified, 0 is used. </p>

Return:

  • false|int <p>The numeric position of the first occurrence of needle in the haystack string. If needle is not found, it returns false.</p>

strrchr(string $haystack, string $needle, bool $before_needle, string $encoding, bool $clean_utf8): false|string

鈫 Find the last occurrence of a character in a string within another.

EXAMPLE: UTF8::strrchr('魏峤瓜兾嘉滴横焦蟽渭蔚-盲枚眉', '魏峤瓜兾嘉'); // '魏峤瓜兾嘉-盲枚眉'

Parameters:

  • string $haystack <p>The string from which to get the last occurrence of needle.</p>
  • string $needle <p>The string to find in haystack</p>
  • bool $before_needle [optional] <p> Determines which portion of haystack this function returns. If set to true, it returns all of haystack from the beginning to the last occurrence of needle. If set to false, it returns all of haystack from the last occurrence of needle to the end, </p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>

Return:

  • false|string <p>The portion of haystack or false if needle is not found.</p>

strrev(string $str, string $encoding): string

鈫 Reverses characters order in the string.

EXAMPLE: UTF8::strrev('魏-枚盲眉'); // '眉盲枚-魏'

Parameters:

  • string $str <p>The input string.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string <p>The string with characters in the reverse sequence.</p>

strrichr(string $haystack, string $needle, bool $before_needle, string $encoding, bool $clean_utf8): false|string

鈫 Find the last occurrence of a character in a string within another, case-insensitive.

EXAMPLE: UTF8::strrichr('A魏峤瓜兾嘉滴横焦蟽渭蔚-盲枚眉', 'a魏峤瓜兾嘉'); // 'A魏峤瓜兾嘉滴横焦蟽渭蔚-盲枚眉'

Parameters:

  • string $haystack <p>The string from which to get the last occurrence of needle.</p>
  • string $needle <p>The string to find in haystack.</p>
  • bool $before_needle [optional] <p> Determines which portion of haystack this function returns. If set to true, it returns all of haystack from the beginning to the last occurrence of needle. If set to false, it returns all of haystack from the last occurrence of needle to the end, </p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>

Return:

  • false|string <p>The portion of haystack or<br>false if needle is not found.</p>

strripos(string $haystack, int|string $needle, int $offset, string $encoding, bool $clean_utf8): false|int

鈫 Find the position of the last occurrence of a substring in a string, case-insensitive.

EXAMPLE: UTF8::strripos('ABC-脰脛脺-涓枃绌虹櫧-涓枃绌虹櫧', '涓'); // 13

Parameters:

  • string $haystack <p>The string to look in.</p>
  • int|string $needle <p>The string to look for.</p>
  • int $offset [optional] <p>Number of characters to ignore in the beginning or end.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>

Return:

  • false|int <p>The <strong>(int)</strong> numeric position of the last occurrence of needle in the haystack string.<br>If needle is not found, it returns false.</p>

strripos_in_byte(string $haystack, string $needle, int $offset): false|int

鈫 Finds position of last occurrence of a string within another, case-insensitive.

Parameters:

  • string $haystack <p> The string from which to get the position of the last occurrence of needle. </p>
  • string $needle <p> The string to find in haystack. </p>
  • int $offset [optional] <p> The position in haystack to start searching. </p>

Return:

  • false|int <p>eturn the numeric position of the last occurrence of needle in the haystack string, or false if needle is not found.</p>

strrpos(string $haystack, int|string $needle, int $offset, string $encoding, bool $clean_utf8): false|int

鈫 Find the position of the last occurrence of a substring in a string.

EXAMPLE: UTF8::strrpos('ABC-脰脛脺-涓枃绌虹櫧-涓枃绌虹櫧', '涓'); // 13

Parameters:

  • string $haystack <p>The string being checked, for the last occurrence of needle</p>
  • int|string $needle <p>The string to find in haystack.<br>Or a code point as int.</p>
  • int $offset [optional] <p>May be specified to begin searching an arbitrary number of characters into the string. Negative values will stop searching at an arbitrary point prior to the end of the string. </p>
  • string $encoding [optional] <p>Set the charset.</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>

Return:

  • false|int <p>The <strong>(int)</strong> numeric position of the last occurrence of needle in the haystack string.<br>If needle is not found, it returns false.</p>

strrpos_in_byte(string $haystack, string $needle, int $offset): false|int

鈫 Find the position of the last occurrence of a substring in a string.

Parameters:

  • string $haystack <p> The string being checked, for the last occurrence of needle. </p>
  • string $needle <p> The string to find in haystack. </p>
  • int $offset [optional] <p>May be specified to begin searching an arbitrary number of characters into the string. Negative values will stop searching at an arbitrary point prior to the end of the string. </p>

Return:

  • false|int <p>The numeric position of the last occurrence of needle in the haystack string. If needle is not found, it returns false.</p>

strspn(string $str, string $mask, int $offset, int|null $length, string $encoding): false|int

鈫 Finds the length of the initial segment of a string consisting entirely of characters contained within a given mask.

EXAMPLE: UTF8::strspn('i帽t毛rn芒ti么n脿liz忙ti酶n', 'it帽'); // '3'

Parameters:

  • string $str <p>The input string.</p>
  • string $mask <p>The mask of chars</p>
  • int $offset [optional]
  • int|null $length [optional]
  • string $encoding [optional] <p>Set the charset.</p>

Return:

  • false|int

strstr(string $haystack, string $needle, bool $before_needle, string $encoding, bool $clean_utf8): false|string

鈫 Returns part of haystack string from the first occurrence of needle to the end of haystack.

EXAMPLE: $str = 'i帽t毛rn芒ti么n脿liz忙ti酶n'; $search = 'n芒t';

UTF8::strstr($str, $search)); // 'n芒ti么n脿liz忙ti酶n' UTF8::strstr($str, $search, true)); // 'i帽t毛r'

Parameters:

  • string $haystack <p>The input string. Must be valid UTF-8.</p>
  • string $needle <p>The string to look for. Must be valid UTF-8.</p>
  • bool $before_needle [optional] <p> If <b>TRUE</b>, strstr() returns the part of the haystack before the first occurrence of the needle (excluding the needle). </p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>

Return:

  • false|string <p>A sub-string,<br>or <strong>false</strong> if needle is not found.</p>

strstr_in_byte(string $haystack, string $needle, bool $before_needle): false|string

鈫 Finds first occurrence of a string within another.

Parameters:

  • string $haystack <p> The string from which to get the first occurrence of needle. </p>
  • string $needle <p> The string to find in haystack. </p>
  • bool $before_needle [optional] <p> Determines which portion of haystack this function returns. If set to true, it returns all of haystack from the beginning to the first occurrence of needle. If set to false, it returns all of haystack from the first occurrence of needle to the end, </p>

Return:

  • false|string <p>The portion of haystack, or false if needle is not found.</p>

strtocasefold(string $str, bool $full, bool $clean_utf8, string $encoding, string|null $lang, bool $lower): string

鈫 Unicode transformation for case-less matching.

EXAMPLE: UTF8::strtocasefold('前鈼屘'); // 'j虒鈼屘'

Parameters:

  • string $str <p>The input string.</p>
  • bool $full [optional] <p> <b>true</b>, replace full case folding chars (default)<br> <b>false</b>, use only limited static array [UTF8::$COMMON_CASE_FOLD] </p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>
  • string $encoding [optional] <p>Set the charset.</p>
  • string|null $lang [optional] <p>Set the language for special cases: az, el, lt, tr</p>
  • bool $lower [optional] <p>Use lowercase string, otherwise use uppercase string. PS: uppercase is for some languages better ...</p>

Return:

  • string

strtolower(string $str, string $encoding, bool $clean_utf8, string|null $lang, bool $try_to_keep_the_string_length): string

鈫 Make a string lowercase.

EXAMPLE: UTF8::strtolower('D脡J脌 危蟽蟼 I谋陌i'); // 'd茅j脿 蟽蟽蟼 i谋ii'

Parameters:

  • string $str <p>The string being lowercased.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>
  • string|null $lang [optional] <p>Set the language for special cases: az, el, lt, tr</p>
  • bool $try_to_keep_the_string_length [optional] <p>true === try to keep the string length: e.g. 岷 -> 脽</p>

Return:

  • string <p>String with all alphabetic characters converted to lowercase.</p>

strtoupper(string $str, string $encoding, bool $clean_utf8, string|null $lang, bool $try_to_keep_the_string_length): string

鈫 Make a string uppercase.

EXAMPLE: UTF8::strtoupper('D茅j脿 危蟽蟼 I谋陌i'); // 'D脡J脌 危危危 II陌I'

Parameters:

  • string $str <p>The string being uppercased.</p>
  • string $encoding [optional] <p>Set the charset.</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>
  • string|null $lang [optional] <p>Set the language for special cases: az, el, lt, tr</p>
  • bool $try_to_keep_the_string_length [optional] <p>true === try to keep the string length: e.g. 岷 -> 脽</p>

Return:

  • string <p>String with all alphabetic characters converted to uppercase.</p>

strtr(string $str, string|string[] $from, string|string[] $to): string

鈫 Translate characters or replace sub-strings.

EXAMPLE: $array = [ 'Hello' => '鈼嬧棌鈼', '涓枃绌虹櫧' => 'earth', ]; UTF8::strtr('Hello 涓枃绌虹櫧', $array); // '鈼嬧棌鈼 earth'

Parameters:

  • string $str <p>The string being translated.</p>
  • string|string[] $from <p>The string replacing from.</p>
  • string|string[] $to [optional] <p>The string being translated to to.</p>

Return:

  • string <p>This function returns a copy of str, translating all occurrences of each character in "from" to the corresponding character in "to".</p>

strwidth(string $str, string $encoding, bool $clean_utf8): int

鈫 Return the width of a string.

INFO: use UTF8::strlen() for the byte-length

EXAMPLE: UTF8::strwidth("I帽t毛rn芒ti么n\xE9脿liz忙ti酶n")); // 21

Parameters:

  • string $str <p>The input string.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>

Return:

  • int

substr(string $str, int $offset, int|null $length, string $encoding, bool $clean_utf8): false|string

鈫 Get part of a string.

EXAMPLE: UTF8::substr('涓枃绌虹櫧', 1, 2); // '鏂囩┖'

Parameters:

  • string $str <p>The string being checked.</p>
  • int $offset <p>The first position used in str.</p>
  • int|null $length [optional] <p>The maximum length of the returned string.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>

Return:

  • false|string The portion of <i>str</i> specified by the <i>offset</i> and <i>length</i> parameters.</p><p>If <i>str</i> is shorter than <i>offset</i> characters long, <b>FALSE</b> will be returned.

substr_compare(string $str1, string $str2, int $offset, int|null $length, bool $case_insensitivity, string $encoding): int

鈫 Binary-safe comparison of two strings from an offset, up to a length of characters.

EXAMPLE: UTF8::substr_compare("鈼嬧棌鈼嶾r", '鈼忊棊', 0, 2); // -1 UTF8::substr_compare("鈼嬧棌鈼嶾r", '鈼庘棌', 1, 2); // 1 UTF8::substr_compare("鈼嬧棌鈼嶾r", '鈼忊棊', 1, 2); // 0

Parameters:

  • string $str1 <p>The main string being compared.</p>
  • string $str2 <p>The secondary string being compared.</p>
  • int $offset [optional] <p>The start position for the comparison. If negative, it starts counting from the end of the string.</p>
  • int|null $length [optional] <p>The length of the comparison. The default value is the largest of the length of the str compared to the length of main_str less the offset.</p>
  • bool $case_insensitivity [optional] <p>If case_insensitivity is TRUE, comparison is case insensitive.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • int <strong>&lt; 0</strong> if str1 is less than str2;<br> <strong>&gt; 0</strong> if str1 is greater than str2,<br> <strong>0</strong> if they are equal

substr_count(string $haystack, string $needle, int $offset, int|null $length, string $encoding, bool $clean_utf8): false|int

鈫 Count the number of substring occurrences.

EXAMPLE: UTF8::substr_count('涓枃绌虹櫧', '鏂囩┖', 1, 2); // 1

Parameters:

  • string $haystack <p>The string to search in.</p>
  • string $needle <p>The substring to search for.</p>
  • int $offset [optional] <p>The offset where to start counting.</p>
  • int|null $length [optional] <p> The maximum length after the specified offset to search for the substring. It outputs a warning if the offset plus the length is greater than the haystack length. </p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>

Return:

  • false|int <p>This functions returns an integer or false if there isn't a string.</p>

substr_count_in_byte(string $haystack, string $needle, int $offset, int|null $length): false|int

鈫 Count the number of substring occurrences.

Parameters:

  • string $haystack <p> The string being checked. </p>
  • string $needle <p> The string being found. </p>
  • int $offset [optional] <p> The offset where to start counting </p>
  • int|null $length [optional] <p> The maximum length after the specified offset to search for the substring. It outputs a warning if the offset plus the length is greater than the haystack length. </p>

Return:

  • false|int <p>The number of times the needle substring occurs in the haystack string.</p>

substr_count_simple(string $str, string $substring, bool $case_sensitive, string $encoding): int

鈫 Returns the number of occurrences of $substring in the given string.

By default, the comparison is case-sensitive, but can be made insensitive by setting $case_sensitive to false.

Parameters:

  • string $str <p>The input string.</p>
  • string $substring <p>The substring to search for.</p>
  • bool $case_sensitive [optional] <p>Whether or not to enforce case-sensitivity. Default: true</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • int

substr_ileft(string $haystack, string $needle): string

鈫 Removes a prefix ($needle) from the beginning of the string ($haystack), case-insensitive.

EXMAPLE: UTF8::substr_ileft('螝峤瓜兾嘉礛iddleEnd', '螝峤瓜兾嘉'); // 'MiddleEnd' UTF8::substr_ileft('螝峤瓜兾嘉礛iddleEnd', '魏峤瓜兾嘉'); // 'MiddleEnd'

Parameters:

  • string $haystack <p>The string to search in.</p>
  • string $needle <p>The substring to search for.</p>

Return:

  • string <p>Return the sub-string.</p>

substr_in_byte(string $str, int $offset, int|null $length): false|string

鈫 Get part of a string process in bytes.

Parameters:

  • string $str <p>The string being checked.</p>
  • int $offset <p>The first position used in str.</p>
  • int|null $length [optional] <p>The maximum length of the returned string.</p>

Return:

  • false|string The portion of <i>str</i> specified by the <i>offset</i> and <i>length</i> parameters.</p><p>If <i>str</i> is shorter than <i>offset</i> characters long, <b>FALSE</b> will be returned.

substr_iright(string $haystack, string $needle): string

鈫 Removes a suffix ($needle) from the end of the string ($haystack), case-insensitive.

EXAMPLE: UTF8::substr_iright('BeginMiddle螝峤瓜兾嘉', '螝峤瓜兾嘉'); // 'BeginMiddle' UTF8::substr_iright('BeginMiddle螝峤瓜兾嘉', '魏峤瓜兾嘉'); // 'BeginMiddle'

Parameters:

  • string $haystack <p>The string to search in.</p>
  • string $needle <p>The substring to search for.</p>

Return:

  • string <p>Return the sub-string.<p>

substr_left(string $haystack, string $needle): string

鈫 Removes a prefix ($needle) from the beginning of the string ($haystack).

EXAMPLE: UTF8::substr_left('螝峤瓜兾嘉礛iddleEnd', '螝峤瓜兾嘉'); // 'MiddleEnd' UTF8::substr_left('螝峤瓜兾嘉礛iddleEnd', '魏峤瓜兾嘉'); // '螝峤瓜兾嘉礛iddleEnd'

Parameters:

  • string $haystack <p>The string to search in.</p>
  • string $needle <p>The substring to search for.</p>

Return:

  • string <p>Return the sub-string.</p>

substr_replace(string|string[] $str, string|string[] $replacement, int|int[] $offset, int|int[]|null $length, string $encoding): string|string[]

鈫 Replace text within a portion of a string.

EXAMPLE: UTF8::substr_replace(array('I帽t毛rn芒ti么n脿liz忙ti酶n', 'foo'), '忙', 1); // array('I忙帽t毛rn芒ti么n脿liz忙ti酶n', 'f忙oo')

source: https://gist.github.com/stemar/8287074

Parameters:

  • string|string[] $str <p>The input string or an array of stings.</p>
  • string|string[] $replacement <p>The replacement string or an array of stings.</p>
  • int|int[] $offset <p> If start is positive, the replacing will begin at the start'th offset into string. <br><br> If start is negative, the replacing will begin at the start'th character from the end of string. </p>
  • int|int[]|null $length [optional] <p>If given and is positive, it represents the length of the portion of string which is to be replaced. If it is negative, it represents the number of characters from the end of string at which to stop replacing. If it is not given, then it will default to strlen( string ); i.e. end the replacing at the end of string. Of course, if length is zero then this function will have the effect of inserting replacement into string at the given start offset.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string|string[] <p>The result string is returned. If string is an array then array is returned.</p>

substr_right(string $haystack, string $needle, string $encoding): string

鈫 Removes a suffix ($needle) from the end of the string ($haystack).

EXAMPLE: UTF8::substr_right('BeginMiddle螝峤瓜兾嘉', '螝峤瓜兾嘉'); // 'BeginMiddle' UTF8::substr_right('BeginMiddle螝峤瓜兾嘉', '魏峤瓜兾嘉'); // 'BeginMiddle螝峤瓜兾嘉'

Parameters:

  • string $haystack <p>The string to search in.</p>
  • string $needle <p>The substring to search for.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>

Return:

  • string <p>Return the sub-string.</p>

swapCase(string $str, string $encoding, bool $clean_utf8): string

鈫 Returns a case swapped version of the string.

EXAMPLE: UTF8::swapCase('d茅J脌 蟽蟽蟼 i谋II'); // 'D脡j脿 危危危 IIii'

Parameters:

  • string $str <p>The input string.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>

Return:

  • string <p>Each character's case swapped.</p>

symfony_polyfill_used(): bool

鈫 Checks whether symfony-polyfills are used.

Parameters: nothing

Return:

  • bool <p><strong>true</strong> if in use, <strong>false</strong> otherwise</p>

tabs_to_spaces(string $str, int $tab_length): string

Parameters:

  • string $str
  • int $tab_length

Return:

  • string

titlecase(string $str, string $encoding, bool $clean_utf8, string|null $lang, bool $try_to_keep_the_string_length): string

鈫 Converts the first character of each word in the string to uppercase and all other chars to lowercase.

Parameters:

  • string $str <p>The input string.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>
  • string|null $lang [optional] <p>Set the language for special cases: az, el, lt, tr</p>
  • bool $try_to_keep_the_string_length [optional] <p>true === try to keep the string length: e.g. 岷 -> 脽</p>

Return:

  • string <p>A string with all characters of $str being title-cased.</p>

to_ascii(string $str, string $unknown, bool $strict): string

鈫 Convert a string into ASCII.

EXAMPLE: UTF8::to_ascii('d茅j脿 蟽蟽蟼 i谋ii'); // 'deja sss iiii'

Parameters:

  • string $str <p>The input string.</p>
  • string $unknown [optional] <p>Character use if character unknown. (default is ?)</p>
  • bool $strict [optional] <p>Use "transliterator_transliterate()" from PHP-Intl | WARNING: bad performance</p>

Return:

  • string

to_boolean(bool|int|string $str): bool

Parameters:

  • bool|int|numeric-string $str

Return:

  • bool

to_filename(string $str, bool $use_transliterate, string $fallback_char): string

鈫 Convert given string to safe filename (and keep string case).

Parameters:

  • string $str
  • bool $use_transliterate No transliteration, conversion etc. is done by default - unsafe characters are simply replaced with hyphen.
  • string $fallback_char

Return:

  • string

to_int(string $str): int|null

鈫 Returns the given string as an integer, or null if the string isn't numeric.

Parameters:

  • string $str

Return:

  • int|null <p>null if the string isn't numeric</p>

to_iso8859(string|string[] $str): string|string[]

鈫 Convert a string into "ISO-8859"-encoding (Latin-1).

EXAMPLE: UTF8::to_utf8(UTF8::to_iso8859(' -ABC-涓枃绌虹櫧- ')); // ' -ABC-????- '

Parameters:

  • string|string[] $str

Return:

  • string|string[]

to_string(float|int|object|string|null $input): string|null

鈫 Returns the given input as string, or null if the input isn't int|float|string and do not implement the "__toString()" method.

Parameters:

  • float|int|object|string|null $input

Return:

  • string|null <p>null if the input isn't int|float|string and has no "__toString()" method</p>

to_utf8(string|string[] $str, bool $decode_html_entity_to_utf8): string|string[]

鈫 This function leaves UTF-8 characters alone, while converting almost all non-UTF8 to UTF8.

It decode UTF-8 codepoints and Unicode escape sequences. It assumes that the encoding of the original string is either WINDOWS-1252 or ISO-8859. WARNING: It does not remove invalid UTF-8 characters, so you maybe need to use "UTF8::clean()" for this case.

EXAMPLE: UTF8::to_utf8(["\u0063\u0061\u0074"]); // array('cat')

Parameters:

  • TToUtf8 $str <p>Any string or array of strings.</p>
  • bool $decode_html_entity_to_utf8 <p>Set to true, if you need to decode html-entities.</p>

Return:

  • string|string[] <p>The UTF-8 encoded string</p>

to_utf8_string(string $str, bool $decode_html_entity_to_utf8): string

鈫 This function leaves UTF-8 characters alone, while converting almost all non-UTF8 to UTF8.

It decode UTF-8 codepoints and Unicode escape sequences. It assumes that the encoding of the original string is either WINDOWS-1252 or ISO-8859. WARNING: It does not remove invalid UTF-8 characters, so you maybe need to use "UTF8::clean()" for this case.

EXAMPLE: UTF8::to_utf8_string("\u0063\u0061\u0074"); // 'cat'

Parameters:

  • string $str <p>Any string.</p>
  • bool $decode_html_entity_to_utf8 <p>Set to true, if you need to decode html-entities.</p>

Return:

  • string <p>The UTF-8 encoded string</p>

trim(string $str, string|null $chars): string

鈫 Strip whitespace or other characters from the beginning and end of a UTF-8 string.

INFO: This is slower then "trim()"

We can only use the original-function, if we use <= 7-Bit in the string / chars but the check for ASCII (7-Bit) cost more time, then we can safe here.

EXAMPLE: UTF8::trim(' -ABC-涓枃绌虹櫧- '); // '-ABC-涓枃绌虹櫧-'

Parameters:

  • string $str <p>The string to be trimmed</p>
  • string|null $chars [optional] <p>Optional characters to be stripped</p>

Return:

  • string <p>The trimmed string.</p>

ucfirst(string $str, string $encoding, bool $clean_utf8, string|null $lang, bool $try_to_keep_the_string_length): string

鈫 Makes string's first char uppercase.

EXAMPLE: UTF8::ucfirst('帽t毛rn芒ti么n脿liz忙ti酶n foo'); // '脩t毛rn芒ti么n脿liz忙ti酶n foo'

Parameters:

  • string $str <p>The input string.</p>
  • string $encoding [optional] <p>Set the charset for e.g. "mb_" function</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>
  • string|null $lang [optional] <p>Set the language for special cases: az, el, lt, tr</p>
  • bool $try_to_keep_the_string_length [optional] <p>true === try to keep the string length: e.g. 岷 -> 脽</p>

Return:

  • string <p>The resulting string with with char uppercase.</p>

ucwords(string $str, string[] $exceptions, string $char_list, string $encoding, bool $clean_utf8): string

鈫 Uppercase for all words in the string.

EXAMPLE: UTF8::ucwords('i帽t 毛rn 芒Ti 么n脿 liz 忙ti 酶n'); // 'I帽t 脣rn 脗Ti 脭n脿 Liz 脝ti 脴n'

Parameters:

  • string $str <p>The input string.</p>
  • string[] $exceptions [optional] <p>Exclusion for some words.</p>
  • string $char_list [optional] <p>Additional chars that contains to words and do not start a new word.</p>
  • string $encoding [optional] <p>Set the charset.</p>
  • bool $clean_utf8 [optional] <p>Remove non UTF-8 chars from the string.</p>

Return:

  • string

urldecode(string $str, bool $multi_decode): string

鈫 Multi decode HTML entity + fix urlencoded-win1252-chars.

EXAMPLE: UTF8::urldecode('tes%20枚盲眉%20\u00edtest+test'); // 'tes 枚盲眉 铆test test'

e.g: 'test+test' => 'test test' 'Düsseldorf' => 'D眉sseldorf' 'D%FCsseldorf' => 'D眉sseldorf' 'Düsseldorf' => 'D眉sseldorf' 'D%26%23xFC%3Bsseldorf' => 'D眉sseldorf' 'D脙录sseldorf' => 'D眉sseldorf' 'D%C3%BCsseldorf' => 'D眉sseldorf' 'D%C3%83%C2%BCsseldorf' => 'D眉sseldorf' 'D%25C3%2583%25C2%25BCsseldorf' => 'D眉sseldorf'

Parameters:

  • string $str <p>The input string.</p>
  • bool $multi_decode <p>Decode as often as possible.</p>

Return:

  • string

utf8_decode(string $str, bool $keep_utf8_chars): string

鈫 Decodes a UTF-8 string to ISO-8859-1.

EXAMPLE: UTF8::encode('UTF-8', UTF8::utf8_decode('-ABC-涓枃绌虹櫧-')); // '-ABC-????-'

Parameters:

  • string $str <p>The input string.</p>
  • bool $keep_utf8_chars

Return:

  • string

utf8_encode(string $str): string

鈫 Encodes an ISO-8859-1 string to UTF-8.

EXAMPLE: UTF8::utf8_decode(UTF8::utf8_encode('-ABC-涓枃绌虹櫧-')); // '-ABC-涓枃绌虹櫧-'

Parameters:

  • string $str <p>The input string.</p>

Return:

  • string

whitespace_table(): string[]

鈫 Returns an array with all utf8 whitespace characters.

Parameters: nothing

Return:

  • string[] An array with all known whitespace characters as values and the type of whitespace as keys as defined in above URL

words_limit(string $str, int $limit, string $str_add_on): string

鈫 Limit the number of words in a string.

EXAMPLE: UTF8::words_limit('f貌么 b脿艡 f貌么', 2, ''); // 'f貌么 b脿艡'

Parameters:

  • string $str <p>The input string.</p>
  • int $limit <p>The limit of words as integer.</p>
  • string $str_add_on <p>Replacement for the striped string.</p>

Return:

  • string

wordwrap(string $str, int $width, string $break, bool $cut): string

鈫 Wraps a string to a given number of characters

EXAMPLE: UTF8::wordwrap('I帽t毛rn芒ti么n脿liz忙ti酶n', 2, '', true)); // 'I帽t毛rn芒ti么n脿liz忙ti酶n'

Parameters:

  • string $str <p>The input string.</p>
  • int $width [optional] <p>The column width.</p>
  • string $break [optional] <p>The line is broken using the optional break parameter.</p>
  • bool $cut [optional] <p> If the cut is set to true, the string is always wrapped at or before the specified width. So if you have a word that is larger than the given width, it is broken apart. </p>

Return:

  • string <p>The given string wrapped at the specified column.</p>

wordwrap_per_line(string $str, int $width, string $break, bool $cut, bool $add_final_break, string|null $delimiter): string

鈫 Line-Wrap the string after $limit, but split the string by "$delimiter" before .

.. ... so that we wrap the per line.

Parameters:

  • string $str <p>The input string.</p>
  • int $width [optional] <p>The column width.</p>
  • string $break [optional] <p>The line is broken using the optional break parameter.</p>
  • bool $cut [optional] <p> If the cut is set to true, the string is always wrapped at or before the specified width. So if you have a word that is larger than the given width, it is broken apart. </p>
  • bool $add_final_break [optional] <p> If this flag is true, then the method will add a $break at the end of the result string. </p>
  • string|null $delimiter [optional] <p> You can change the default behavior, where we split the string by newline. </p>

Return:

  • string

ws(): string[]

鈫 Returns an array of Unicode White Space characters.

Parameters: nothing

Return:

  • string[] <p>An array with numeric code point as key and White Space Character as value.</p>

Unit Test

1) Composer is a prerequisite for running the tests.

composer install

2) The tests can be executed by running this command from the root directory:

./vendor/bin/phpunit

Support

For support and donations please visit GitHub | Issues | PayPal | Patreon.

For status updates and release announcements please visit Releases | Twitter | Patreon.

For professional support please contact me.

Thanks

  • Thanks to GitHub (Microsoft) for hosting the code and a good infrastructure including Issues-Management, etc.
  • Thanks to IntelliJ as they make the best IDEs for PHP and they gave me an open source license for PhpStorm!
  • Thanks to Travis CI for being the most awesome, easiest continuous integration tool out there!
  • Thanks to StyleCI for the simple but powerful code style check.
  • Thanks to PHPStan && Psalm for really great Static analysis tools and for discovering bugs in the code!

"Portable UTF8" is free software; you can redistribute it and/or modify it under the terms of the (at your option):

Unicode handling requires tedious work to be implemented and maintained on the long run. As such, contributions such as unit tests, bug reports, comments or patches licensed under both licenses are really welcomed.

FOSSA Status


*Note that all licence references and agreements mentioned in the Portable UTF-8 README section above are relevant to that project's source code only.