mb_strlen - PHP code example

The php Function MB_Strlen

The php function mb_strlen (as multi-byte string length) is used to get the total number of characters in a specified string. This is a new function introduced in PHP 4.6.0 to replace the old strlen function that only returned the number of ASCII characters in a string.

This function accepts two parameters: the string and the character encoding. The encoding is used to determine which character set to use. If the encoding is omitted or null, then the internal character encoding value will be used. The return value is the number of characters present in the string. A multi-byte character is counted as one. If the encoding is not known, an error of level E_warning will be generated.

Another thing to note is that the speed of mb_strlen varies a lot depending on the specified character set. For example, it can be several times slower than using strlen in environments that use the utf8 charset.

It's best to avoid relying on the PHP STRLEN function in a production environment when you need to validate a string for length, especially if it's going to be used with a character set such as utf8 or other multi-byte character sets. Instead, use mb_strlen or an alternative such as the MB_STRLEN or ISSET functions. All of these are significantly faster than PHP STRLEN and they also offer more accurate results when working with Unicode strings. This is especially important when dealing with special characters like umlauts, etc.

mb_strlen example

$limits = array_filter($values, static fn (int $value) => $value > 0);

        return min($limits);
    }

    private static function toBytes(string $value): int
    {
        if (is_numeric($value)) {
            return (int) $value;
        }
        $length = mb_strlen($value);
        $qty = (int) mb_substr($value, 0, $length - 1);
        $unit = mb_strtolower(mb_substr($value, $length - 1));
        match ($unit) {
            'k' => $qty *= 1024,
            'm' => $qty *= 1048576,
            'g' => $qty *= 1073741824,
            default => $qty,
        };

        return $qty;
    }
}

$this->removeDBPrefix();
        $builder = $this->db->table($tableName);
        $builder->limit($limitRows);
        if ($sortField !== null) {
            $builder->orderBy($sortField, $this->sortDesc ? 'DESC' : 'ASC');
        }
        $rows = $builder->get()->getResultArray();
        $this->restoreDBPrefix();

        foreach ($rows as $row) {
            $row = array_map(
                static fn ($item): string => mb_strlen((string) $item) > $limitFieldValue
                    ? mb_substr((string) $item, 0, $limitFieldValue) . '...'
                    : (string) $item,
                $row
            );
            $this->tbody[] = $row;
        }

        if ($sortField === null && $this->sortDesc) {
            krsort($this->tbody);
        }

$bytes = substr_replace($bytes, $timeHiAndVersion, 6, 2);

        return substr_replace($bytes, $clockSeqHiAndReserved, 8, 2);
    }

    /** * @throws InvalidUuidException * @throws InvalidUuidLengthException */
    public static function fromBytesToHex(string $bytes): string
    {
        if (mb_strlen($bytes, '8bit') !== 16) {
            throw new InvalidUuidLengthException(mb_strlen($bytes, '8bit'), bin2hex($bytes));
        }
        $uuid = bin2hex($bytes);

        if (!self::isValid($uuid)) {
            throw new InvalidUuidException($uuid);
        }

        return $uuid;
    }

    protected function doSend(MessageInterface $message): SentMessage
    {
        if (!$message instanceof ChatMessage) {
            throw new UnsupportedMessageTypeException(__CLASS__, ChatMessage::class, $message);
        }

        $options = $message->getOptions()?->toArray() ?? [];
        $options['content'] = $message->getSubject();

        if (mb_strlen($options['content'], 'UTF-8') > self::SUBJECT_LIMIT) {
            throw new LengthException(sprintf('The subject length of a Discord message must not exceed %d characters.', self::SUBJECT_LIMIT));
        }

        $endpoint = sprintf('https://%s/api/webhooks/%s/%s', $this->getEndpoint(), $this->webhookId, $this->token);
        $response = $this->client->request('POST', $endpoint, [
            'json' => array_filter($options),
        ]);

        try {
            $statusCode = $response->getStatusCode();
        } catch (TransportExceptionInterface $e) {

  public function __toString() {
    return Html::escape($this->string);
  }

  /** * {@inheritdoc} */
  #[\ReturnTypeWillChange]   public function count() {
    return mb_strlen($this->string);
  }

  /** * {@inheritdoc} */
  #[\ReturnTypeWillChange]   public function jsonSerialize() {
    return $this->__toString();
  }

}

public function getEntityType() {
    return $this->entityTypeManager()->getDefinition($this->getEntityTypeId());
  }

  /** * {@inheritdoc} */
  public function preSave(EntityStorageInterface $storage) {
    // Check if this is an entity bundle.     if ($this->getEntityType()->getBundleOf()) {
      // Throw an exception if the bundle ID is longer than 32 characters.       if (mb_strlen($this->id()) > EntityTypeInterface::BUNDLE_MAX_LENGTH) {
        throw new ConfigEntityIdLengthException("Attempt to create a bundle with an ID longer than " . EntityTypeInterface::BUNDLE_MAX_LENGTH . " characters: $this->id().");
      }
    }
  }

  /** * {@inheritdoc} */
  public function postSave(EntityStorageInterface $storage, $update = TRUE) {
    $this->invalidateTagsOnSave($update);
  }

/** * {@inheritDoc} */
    public function decrypt($data, $params = null)
    {
        $this->parseParams($params);

        if (empty($this->key)) {
            throw EncryptionException::forNeedsStarterKey();
        }

        if (mb_strlen($data, '8bit') < (SODIUM_CRYPTO_SECRETBOX_NONCEBYTES + SODIUM_CRYPTO_SECRETBOX_MACBYTES)) {
            // message was truncated             throw EncryptionException::forAuthenticationFailed();
        }

        // Extract info from encrypted data         $nonce      = self::substr($data, 0, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
        $ciphertext = self::substr($data, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);

        // decrypt data         $data = sodium_crypto_secretbox_open($ciphertext, $nonce, $this->key);

  public function testGenerateSampleValue(int $max_length): void {
    $definition = $this->prophesize(FieldDefinitionInterface::class);
    $definition->getSetting('max_length')->willReturn($max_length);

    for ($i = 0; $i < 1000; $i++) {
      $sample_value = UserNameItem::generateSampleValue($definition->reveal());
      $this->assertLessThanOrEqual($max_length, mb_strlen($sample_value['value']));
      $this->assertEquals(trim($sample_value['value'], ' '), $sample_value['value']);
    }
  }

  /** * Data provider for maximum-lengths. * * @return array * Test cases. */
  public function providerMaxLength(): array {

if ($bin) {
            $str = $this->utf8Encode($str);
        }
        if ('' === $str) {
            $this->line .= '""';
            if ($cut) {
                $this->line .= '…'.$cut;
            }
            $this->endValue($cursor);
        } else {
            $attr += [
                'length' => 0 <= $cut ? mb_strlen($str, 'UTF-8') + $cut : 0,
                'binary' => $bin,
            ];
            $str = $bin && str_contains($str, "\0") ? [$str] : explode("\n", $str);
            if (isset($str[1]) && !isset($str[2]) && !isset($str[1][0])) {
                unset($str[1]);
                $str[0] .= "\n";
            }
            $m = \count($str) - 1;
            $i = $lineCut = 0;

            if (self::DUMP_STRING_LENGTH & $this->flags) {

$first = TRUE;
    foreach ($lines as $line) {
      // If the line is too long, just pretend the entire line is one big word       // This prevents resource exhaustion problems       if ( $first ) {
        $first = FALSE;
      }
      else {
        $words[] = "\n";
        $stripped[] = "\n";
      }
      if (mb_strlen($line) > $this::MAX_LINE_LENGTH) {
        $words[] = $line;
        $stripped[] = $line;
      }
      else {
        if (preg_match_all('/ ( [^\S\n]+ | [0-9_A-Za-z\x80-\xff]+ | . ) (?: (?!< \n) [^\S\n])? /xs', $line, $m)) {
          $words = array_merge($words, $m[0]);
          $stripped = array_merge($stripped, $m[1]);
        }
      }
    }
    return [$words, $stripped];
  }

    if (empty($width) || !is_numeric($width)) {
        $width = 10;
    } else {
        $width = (int) $width;
    }
    // if no string is given, just build one string containing the fill pattern     if (!\is_scalar($str)) {
        return str_repeat($fill, $width);
    }
    // If the string longer than the given width shorten the string and append the break pattern     if (mb_strlen($str) > $width) {
        $str = mb_substr($str, 0, $width - mb_strlen($break)) . $break;
    }
    // If the string is shorter than the given width - fill the remaining space with the filling pattern     if ($width > mb_strlen($str)) {
        return $str . str_repeat($fill, $width - mb_strlen($str));
    }

    return $str;
}

$parts = preg_split('//u', $emoji, -1, \PREG_SPLIT_NO_EMPTY);
                $emojiCodePoints = implode(' ', array_map('dechex', array_map('mb_ord', $parts)));
                if (!array_key_exists($emojiCodePoints, $emojisCodePoints)) {
                    $ignored[] = [
                        'locale' => $locale,
                        'emoji' => $emoji,
                        'name' => $name,
                    ];
                    continue;
                }
                self::testEmoji($emoji, $locale);
                $codePointsCount = mb_strlen($emoji);
                $mapsByLocale[$locale][$codePointsCount][$emoji] = $name;
            }
        }

        ksort($mapsByLocale);

        foreach ($mapsByLocale as $locale => $maps) {
            $parentLocale = $locale;

            while (false !== $i = strrpos($parentLocale, '_')) {
                $parentLocale = substr($parentLocale, 0, $i);

function smarty_modifier_truncate($string, $length = 80, $etc = '...', $break_words = false, $middle = false) {
    if ($length == 0)
        return '';

    if (Smarty::$_MBSTRING) {
        if (mb_strlen($string, Smarty::$_CHARSET) > $length) {
            $length -= min($length, mb_strlen($etc, Smarty::$_CHARSET));
            if (!$break_words && !$middle) {
                $string = preg_replace('/\s+?(\S+)?$/' . Smarty::$_UTF8_MODIFIER, '', mb_substr($string, 0, $length + 1, Smarty::$_CHARSET));
            }
            if (!$middle) {
                return mb_substr($string, 0, $length, Smarty::$_CHARSET) . $etc;
            }
            return mb_substr($string, 0, $length / 2, Smarty::$_CHARSET) . $etc . mb_substr($string, - $length / 2, $length, Smarty::$_CHARSET);
        }
        return $string;
    }

private function addBrackets(string &$trans): void
    {
        if (!$this->brackets) {
            return;
        }

        $trans = '['.$trans.']';
    }

    private function strlen(string $s): int
    {
        return false === ($encoding = mb_detect_encoding($s, null, true)) ? \strlen($s) : mb_strlen($s, $encoding);
    }
}

        foreach ($array as $key => $value) {
            if (\is_array($value)) {
                $array[$key] = $this->convert($value);
            }

            /** @var list<string> $encodings */
            $encodings = mb_detect_order();
            // NEXT-21735 - This is covered randomly             // @codeCoverageIgnoreStart             if (\is_string($value)) {
                if (!ctype_print($value) && mb_strlen($value) === 16) {
                    $array[$key] = sprintf('ATTENTION: Converted binary string by the "%s": %s', self::class, bin2hex($value));
                } elseif (!mb_detect_encoding($value, $encodings, true)) {
                    $array[$key] = mb_convert_encoding($value, 'UTF-8', 'ISO-8859-1');
                }
            }
            // @codeCoverageIgnoreEnd         }

        return $array;
    }
}