mb_str_replace()... ist langsam. alternativen?

Möchte ich sicherstellen, dass einige string-Ersetzung ' s bei mir läuft, sind multi-byte-sicher. Ich habe einige gefunden mb_str_replace Funktionen um die net, aber Sie sind langsam. Ich spreche von 20% zu erhöhen, nach der übergabe vielleicht 500-900 bytes durch.

Irgendwelche Empfehlungen? Ich denke über die Verwendung von preg_replace, wie es die einheimischen und zusammengestellt, so könnte es schneller sein. Irgendwelche Gedanken würde geschätzt.

Sie müssen geben Sie mehr info. Was ist die Ersatz-Zeichenfolge und die Kodierung des Subjekts? Wenn das Thema UTF-8 und die Ersatz-Zeichenfolge im ASCII-Bereich, die Sie verwenden können str_replace.
Unicode hat schon was, 15 Jahren? Immer noch mucken mit mb strings in einem core-innere Schleife? Arbeiten von innen nach außen.

InformationsquelleAutor onassar | 2010-08-15

  1. 10

    Wie gesagt es, str_replace ist sicher für die Verwendung in utf-8 zusammenhängen, solange alle Parameter sind utf-8 gültig, da es keine mehrdeutigen match zwischen den beiden multibyte-kodierten strings. Wenn Sie überprüfen die Gültigkeit Ihrer Eingabe, dann haben Sie keine Notwendigkeit, sich für eine andere Funktion.

    Dies ist falsch, wenn man mit unicode und kümmern uns um unicode-äquivalenz. In unicode mehrere unterschiedliche byte-Sequenzen darstellen kann, den gleichen Charakter. Mit str_replace funktionieren würde nur wenn Sie normalisieren die beiden Ihren Streicher ersten.
    Guter Tipp, jedenfalls mein Verständnis von "multibyte-sicher" ist "Sie nicht geben falsche positive, während matching", was in der Praxis bedeutet, dass Sie nicht beschädigt die Ausgabe von Informationen in Bezug auf das, was es ist gewünscht für den Ersatz.
    überprüfen Sie den angegebenen link
    danke!!!

    InformationsquelleAutor Áxel Costas Pena

  2. 3

    Als Kodierung ist eine echte Herausforderung, wenn es Eingaben von überall (utf8 oder andere), ich ziehe mit nur multibyte-safe-Funktionen. Für str_replace ich bin mit diese eine, die ist schnell genug.

    if (!function_exists('mb_str_replace'))
{
   function mb_str_replace($search, $replace, $subject, &$count = 0)
   {
      if (!is_array($subject))
      {
         $searches = is_array($search) ? array_values($search) : array($search);
         $replacements = is_array($replace) ? array_values($replace) : array($replace);
         $replacements = array_pad($replacements, count($searches), '');
         foreach ($searches as $key => $search)
         {
            $parts = mb_split(preg_quote($search), $subject);
            $count += count($parts) - 1;
            $subject = implode($replacements[$key], $parts);
         }
      }
      else
      {
         foreach ($subject as $key => $value)
         {
            $subject[$key] = mb_str_replace($search, $replace, $value, $count);
         }
      }
      return $subject;
   }
}

    InformationsquelleAutor Alain Tiemblo

  3. 2

    Hier ist meine Umsetzung, basierend auf Alains Antwort:

    /**
 * Replace all occurrences of the search string with the replacement string. Multibyte safe.
 *
 * @param string|array $search The value being searched for, otherwise known as the needle. An array may be used to designate multiple needles.
 * @param string|array $replace The replacement value that replaces found search values. An array may be used to designate multiple replacements.
 * @param string|array $subject The string or array being searched and replaced on, otherwise known as the haystack.
 *                              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.
 * @param string $encoding The encoding parameter is the character encoding. If it is omitted, the internal character encoding value will be used.
 * @param int $count If passed, this will be set to the number of replacements performed.
 * @return array|string
 */
public static function mbReplace($search, $replace, $subject, $encoding = 'auto', &$count=0) {
    if(!is_array($subject)) {
        $searches = is_array($search) ? array_values($search) : [$search];
        $replacements = is_array($replace) ? array_values($replace) : [$replace];
        $replacements = array_pad($replacements, count($searches), '');
        foreach($searches as $key => $search) {
            $replace = $replacements[$key];
            $search_len = mb_strlen($search, $encoding);

            $sb = [];
            while(($offset = mb_strpos($subject, $search, 0, $encoding)) !== false) {
                $sb[] = mb_substr($subject, 0, $offset, $encoding);
                $subject = mb_substr($subject, $offset + $search_len, null, $encoding);
                ++$count;
            }
            $sb[] = $subject;
            $subject = implode($replace, $sb);
        }
    } else {
        foreach($subject as $key => $value) {
            $subject[$key] = self::mbReplace($search, $replace, $value, $encoding, $count);
        }
    }
    return $subject;
}

    Seiner nicht annimmt, eine Zeichen-Kodierung, obwohl ich denke, man könnte es über mb_regex_encoding.

    Meine unit-tests pass:

    function testMbReplace() {
    $this->assertSame('bbb',Str::mbReplace('a','b','aaa','auto',$count1));
    $this->assertSame(3,$count1);
    $this->assertSame('ccc',Str::mbReplace(['a','b'],['b','c'],'aaa','auto',$count2));
    $this->assertSame(6,$count2);
    $this->assertSame("\xbf\x5c\x27",Str::mbReplace("\x27","\x5c\x27","\xbf\x27",'iso-8859-1'));
    $this->assertSame("\xbf\x27",Str::mbReplace("\x27","\x5c\x27","\xbf\x27",'gbk'));
}

    InformationsquelleAutor mpen

  4. 0

    Top rated Hinweis auf http://php.net/manual/en/ref.mbstring.php#109937 sagt str_replace Werke für multibyte-strings.

    InformationsquelleAutor Shaunak Sontakke

Schreibe einen Kommentar