Multi-Byte-sichere wordwrap() -Funktion für UTF-8

Question

PHP wordwrap() Funktion funktioniert nicht korrekt für Multi-Byte-Zeichenfolgen wie UTF-8.

Es gibt ein paar Beispiele für mb sichere Funktionen in den Kommentaren, aber mit einigen verschiedenen Testdaten scheinen sie alle einige Probleme zu haben.

Die Funktion sollte die gleichen Parameter wie wordwrap() nehmen.

Insbesondere sicher sein, es funktioniert auf:

• Schnitt Mitte Wort, wenn $cut = true, nicht mitten im Wort nicht anders geschnitten
• nicht zusätzliche Leerzeichen in Worten einfügen, wenn $break = ' '
• arbeiten auch für $break = "\n"
• Arbeit für ASCII, und alle gültigen UTF-8

Answer 1

Dieses gut zu funktionieren scheint ...

function mb_wordwrap($str, $width = 75, $break = "\n", $cut = false, $charset = null) { 
    if ($charset === null) $charset = mb_internal_encoding(); 

    $pieces = explode($break, $str); 
    $result = array(); 
    foreach ($pieces as $piece) { 
     $current = $piece; 
     while ($cut && mb_strlen($current) > $width) { 
     $result[] = mb_substr($current, 0, $width, $charset); 
     $current = mb_substr($current, $width, 2048, $charset); 
     } 
     $result[] = $current; 
    } 
    return implode($break, $result); 
} 

Answer 2

Hier ist meine eigene att Ich möchte auf eine Funktion verzichten, die ein paar meiner eigenen Tests bestanden hat, obwohl ich nicht versprechen kann, dass sie zu 100% perfekt ist, also poste bitte ein besseres, wenn du ein Problem siehst.

/** 
* Multi-byte safe version of wordwrap() 
* Seems to me like wordwrap() is only broken on UTF-8 strings when $cut = true 
* @return string 
*/ 
function wrap($str, $len = 75, $break = " ", $cut = true) { 
    $len = (int) $len; 

    if (empty($str)) 
     return ""; 

    $pattern = ""; 

    if ($cut) 
     $pattern = '/([^'.preg_quote($break).']{'.$len.'})/u'; 
    else 
     return wordwrap($str, $len, $break); 

    return preg_replace($pattern, "\${1}".$break, $str); 
} 

Answer 3

/** 
* wordwrap for utf8 encoded strings 
* 
* @param string $str 
* @param integer $len 
* @param string $what 
* @return string 
* @author Milian Wolff <mail@milianw.de> 
*/ 

function utf8_wordwrap($str, $width, $break, $cut = false) { 
    if (!$cut) { 
     $regexp = '#^(?:[\x00-\x7F]|[\xC0-\xFF][\x80-\xBF]+){'.$width.',}\b#U'; 
    } else { 
     $regexp = '#^(?:[\x00-\x7F]|[\xC0-\xFF][\x80-\xBF]+){'.$width.'}#'; 
    } 
    if (function_exists('mb_strlen')) { 
     $str_len = mb_strlen($str,'UTF-8'); 
    } else { 
     $str_len = preg_match_all('/[\x00-\x7F\xC0-\xFD]/', $str, $var_empty); 
    } 
    $while_what = ceil($str_len/$width); 
    $i = 1; 
    $return = ''; 
    while ($i < $while_what) { 
     preg_match($regexp, $str,$matches); 
     $string = $matches[0]; 
     $return .= $string.$break; 
     $str = substr($str, strlen($string)); 
     $i++; 
    } 
    return $return.$str; 
} 

Gesamtzeit: 0,0020880699 ist gute Zeit :)

Answer 4

Ich habe keine funktionierende Code für mich gefunden. Hier ist was ich geschrieben habe. Für mich funktioniert es, dachte es ist wahrscheinlich nicht das schnellste.

Answer 5

Hier ist die Multibyte-Wordwrap-Funktion, die ich habe inspiriert von anderen im Internet gefunden.

function mb_wordwrap($long_str, $width = 75, $break = "\n", $cut = false) { 
    $long_str = html_entity_decode($long_str, ENT_COMPAT, 'UTF-8'); 
    $width -= mb_strlen($break); 
    if ($cut) { 
     $short_str = mb_substr($long_str, 0, $width); 
     $short_str = trim($short_str); 
    } 
    else { 
     $short_str = preg_replace('/^(.{1,'.$width.'})(?:\s.*|$)/', '$1', $long_str); 
     if (mb_strlen($short_str) > $width) { 
      $short_str = mb_substr($short_str, 0, $width); 
     } 
    } 
    if (mb_strlen($long_str) != mb_strlen($short_str)) { 
     $short_str .= $break; 
    } 
    return $short_str; 
} 

Nicht‘vergessen PHP für die Verwendung von UTF-8 mit konfigurieren:

ini_set('default_charset', 'UTF-8'); 
mb_internal_encoding('UTF-8'); 
mb_regex_encoding('UTF-8'); 

ich, das wird helfen hoffen. Guillaume

Answer 6

Weil keine Antwort jeden Anwendungsfall behandelt, hier ist etwas, das tut. Der Code basiert auf Drupal’s AbstractStringWrapper::wordWrap.

<?php 

/** 
* Wraps any string to a given number of characters. 
* 
* This implementation is multi-byte aware and relies on {@link 
* http://www.php.net/manual/en/book.mbstring.php PHP's multibyte 
* string extension}. 
* 
* @see wordwrap() 
* @link https://api.drupal.org/api/drupal/core%21vendor%21zendframework%21zend-stdlib%21Zend%21Stdlib%21StringWrapper%21AbstractStringWrapper.php/function/AbstractStringWrapper%3A%3AwordWrap/8 
* @param string $string 
* The input string. 
* @param int $width [optional] 
* The number of characters at which <var>$string</var> will be 
* wrapped. Defaults to <code>75</code>. 
* @param string $break [optional] 
* The line is broken using the optional break parameter. Defaults 
* to <code>"\n"</code>. 
* @param boolean $cut [optional] 
* If the <var>$cut</var> is set to <code>TRUE</code>, the string is 
* always wrapped at or before the specified <var>$width</var>. So if 
* you have a word that is larger than the given <var>$width</var>, it 
* is broken apart. Defaults to <code>FALSE</code>. 
* @return string 
* Returns the given <var>$string</var> wrapped at the specified 
* <var>$width</var>. 
*/ 
function mb_wordwrap($string, $width = 75, $break = "\n", $cut = false) { 
    $string = (string) $string; 
    if ($string === '') { 
    return ''; 
    } 

    $break = (string) $break; 
    if ($break === '') { 
    trigger_error('Break string cannot be empty', E_USER_ERROR); 
    } 

    $width = (int) $width; 
    if ($width === 0 && $cut) { 
    trigger_error('Cannot force cut when width is zero', E_USER_ERROR); 
    } 

    if (strlen($string) === mb_strlen($string)) { 
    return wordwrap($string, $width, $break, $cut); 
    } 

    $stringWidth = mb_strlen($string); 
    $breakWidth = mb_strlen($break); 

    $result = ''; 
    $lastStart = $lastSpace = 0; 

    for ($current = 0; $current < $stringWidth; $current++) { 
    $char = mb_substr($string, $current, 1); 

    $possibleBreak = $char; 
    if ($breakWidth !== 1) { 
     $possibleBreak = mb_substr($string, $current, $breakWidth); 
    } 

    if ($possibleBreak === $break) { 
     $result .= mb_substr($string, $lastStart, $current - $lastStart + $breakWidth); 
     $current += $breakWidth - 1; 
     $lastStart = $lastSpace = $current + 1; 
     continue; 
    } 

    if ($char === ' ') { 
     if ($current - $lastStart >= $width) { 
     $result .= mb_substr($string, $lastStart, $current - $lastStart) . $break; 
     $lastStart = $current + 1; 
     } 

     $lastSpace = $current; 
     continue; 
    } 

    if ($current - $lastStart >= $width && $cut && $lastStart >= $lastSpace) { 
     $result .= mb_substr($string, $lastStart, $current - $lastStart) . $break; 
     $lastStart = $lastSpace = $current; 
     continue; 
    } 

    if ($current - $lastStart >= $width && $lastStart < $lastSpace) { 
     $result .= mb_substr($string, $lastStart, $lastSpace - $lastStart) . $break; 
     $lastStart = $lastSpace = $lastSpace + 1; 
     continue; 
    } 
    } 

    if ($lastStart !== $current) { 
    $result .= mb_substr($string, $lastStart, $current - $lastStart); 
    } 

    return $result; 
} 

?>