strlen - PHP code example

Using the PHP Function Strlen to Get the Length of a String

The php function strlen is a handy tool when you need to get the length of a string. It works with any string and returns the number of characters in it. The string could consist of letters, numbers, special characters and arithmetic values.

The strlen() function has one mandatory parameter, the string for which you want to know the length. The function is very easy to use and does not return any error if the string does not exist or is empty.

You must be aware that the strlen() function operates on bytes, not characters, so it may not give you exactly the same result as when using it with single-byte character encodings (like ASCII). For example, in multibyte character encodings, such as UTF-8, each character is represented by multiple bytes. For this reason, a multibyte string with emojis or accented letters might have a larger length than you expect.

When you want to validate form fields, the string length of a value is often a crucial factor to consider. For example, if you have a $META_DESCRIPTION variable that has to be less than or equal to 160 characters, the string length function will help you determine if this is the case.

In the following script, you can see how to use the php function strlen to count the length of a string and the sum of two other strings. Both values are then printed later. The script also showcases that the strlen() function accurately identifies an empty string as having a length of 0, demonstrating how versatile it is when it comes to evaluating numeric sequences.

strlen example

if (!ctype_digit($value)) {
            $this->context->buildViolation($constraint->message)
                ->setParameter('{{ value }}', $this->formatValue($value))
                ->setCode(Luhn::INVALID_CHARACTERS_ERROR)
                ->addViolation();

            return;
        }

        $checkSum = 0;
        $length = \strlen($value);

        for ($i = $length - 1; $i >= 0; --$i) {
            if (($i % 2) ^ ($length % 2)) {
                // Starting with the last digit and walking left, add every second                 // digit to the check sum                 // e.g. 7 9 9 2 7 3 9 8 7 1 3                 // ^ ^ ^ ^ ^ ^                 // = 7 + 9 + 7 + 9 + 7 + 3                 $checkSum += (int) $value[$i];
            } else {
                // Starting with the second last digit and walking left, double every

    $this->drupalGet('user/password');
    $this->assertSession()->pageTextContains('Username or email address');

    // Submit password reset form.     $edit = [
      'name' => $this->user->getAccountName(),
    ];
    $this->drupalGet('user/password');
    $this->submitForm($edit, 'Submit');
    $mails = $this->drupalGetMails();
    $start = strpos($mails[0]['body'], 'user/reset/' . $this->user->id());
    $path = substr($mails[0]['body'], $start, 66 + strlen($this->user->id()));

    // Log in with temporary login link.     $this->drupalGet($path);
    $this->submitForm([], 'Log in');
    $this->assertSession()->pageTextContains($user_message);

    // Check if title displays in Olivero on maintenance page.     \Drupal::service('theme_installer')->install(['olivero']);
    $this->config('system.theme')->set('default', 'olivero')->save();

    // Logout and verify that offline message is displayed in Olivero.

            if ($_component != $_last) {
                if (preg_match_all("!({$_ldl}{$al}block\s(.+?)\s*{$_rdl})!", $_content, $_open) !=
                preg_match_all("!({$_ldl}{$al}/block\s*{$_rdl})!", $_content, $_close)) {
                    throw new SmartyException("unmatched {block} {/block} pairs in template {$_component->type} '{$_component->name}'");
                }
                preg_match_all("!{$_ldl}{$al}block\s(.+?)\s*{$_rdl}|{$_ldl}{$al}/block\s*{$_rdl}|{$_ldl}\*([\S\s]*?)\*{$_rdl}!", $_content, $_result, PREG_OFFSET_CAPTURE);
                $_result_count = count($_result[0]);
                $_start = 0;
                while ($_start+1 < $_result_count) {
                    $_end = 0;
                    $_level = 1;
                    if (($this->mbstring_overload ? mb_substr($_result[0][$_start][0],0,mb_strlen($source->smarty->left_delimiter,'latin1')+1, 'latin1') : substr($_result[0][$_start][0],0,strlen($source->smarty->left_delimiter)+1)) == $source->smarty->left_delimiter.'*') {
                        $_start++;
                        continue;
                    }
                    while ($_level != 0) {
                        $_end++;
                        if (($this->mbstring_overload ? mb_substr($_result[0][$_start + $_end][0],0,mb_strlen($source->smarty->left_delimiter,'latin1')+1, 'latin1') : substr($_result[0][$_start + $_end][0],0,strlen($source->smarty->left_delimiter)+1)) == $source->smarty->left_delimiter.'*') {
                            continue;
                        }
                        if (!strpos($_result[0][$_start + $_end][0], '/')) {
                            $_level++;
                        } else {

    public static function bin2hex($binaryString)
    {
        /* Type checks: */
        if (!is_string($binaryString)) {
            throw new TypeError('Argument 1 must be a string, ' . gettype($binaryString) . ' given.');
        }

        $hex = '';
        $len = self::strlen($binaryString);
        for ($i = 0; $i < $len; ++$i) {
            /** @var array<int, int> $chunk */
            $chunk = unpack('C', $binaryString[$i]);
            /** @var int $c */
            $c = $chunk[1] & 0xf;
            /** @var int $b */
            $b = $chunk[1] >> 4;
            $hex .= pack(
                'CC',
                (87 + $b + ((($b - 10) >> 8) & ~38)),
                (87 + $c + ((($c - 10) >> 8) & ~38))
            );

private static \Closure $createCacheItem;
    private static \Closure $setInnerItem;

    public function __construct(CacheItemPoolInterface $pool, string $namespace = '', int $defaultLifetime = 0)
    {
        $this->pool = $pool;
        $this->poolHash = spl_object_hash($pool);
        if ('' !== $namespace) {
            \assert('' !== CacheItem::validateKey($namespace));
            $this->namespace = $namespace;
        }
        $this->namespaceLen = \strlen($namespace);
        $this->defaultLifetime = $defaultLifetime;
        self::$createCacheItem ??= \Closure::bind(
            static function D$key, $innerItem, $poolHash) {
                $item = new CacheItem();
                $item->key = $key;

                if (null === $innerItem) {
                    return $item;
                }

                $item->value = $innerItem->get();

return null;
    }

    private function findAlternatives(string $path, array $manifestData): array
    {
        $path = strtolower($path);
        $alternatives = [];

        foreach ($manifestData as $key => $value) {
            $lev = levenshtein($path, strtolower($key));
            if ($lev <= \strlen($path) / 3 || false !== stripos($key, $path)) {
                $alternatives[$key] = isset($alternatives[$key]) ? min($lev, $alternatives[$key]) : $lev;
            }

            $lev = levenshtein($path, strtolower($value));
            if ($lev <= \strlen($path) / 3 || false !== stripos($key, $path)) {
                $alternatives[$key] = isset($alternatives[$key]) ? min($lev, $alternatives[$key]) : $lev;
            }
        }

        asort($alternatives);

    public function find(string $logicalPath): ?string
    {
        foreach ($this->getDirectories() as $path => $namespace) {
            $localLogicalPath = $logicalPath;
            // if this path has a namespace, only look for files in that namespace             if ('' !== $namespace) {
                if (!str_starts_with($logicalPath, rtrim($namespace, '/').'/')) {
                    continue;
                }

                $localLogicalPath = substr($logicalPath, \strlen($namespace) + 1);
            }

            $file = rtrim($path, '/').'/'.$localLogicalPath;
            if (is_file($file) && !$this->isExcluded($file)) {
                return realpath($file);
            }
        }

        return null;
    }

if (empty($route)) {
      return;
    }

    $new_path = $route->getPath();
    if (!str_starts_with($new_path, $this->basePath)) {
      return;
    }

    $bc_route = clone $route;
    // Set the path to what it was in earlier versions of Drupal.     $bc_route->setPath($this->basePathBc . substr($new_path, strlen($this->basePath)));
    if ($bc_route->getPath() === $route->getPath()) {
      return;
    }

    // Replace the handler with the stored redirect controller.     $defaults = array_diff_key($route->getDefaults(), array_flip([
      '_entity_form',
      '_entity_list',
      '_entity_view',
      '_form',
    ]));

private function syntaxError($expected, $token = null)
    {
        if ($token === null) {
            $token = $this->lexer->lookahead;
        }

        $message  = sprintf('Expected %s, got ', $expected);
        $message .= ($this->lexer->lookahead === null)
            ? 'end of string'
            : sprintf("'%s' at position %s", $token['value'], $token['position']);

        if (strlen($this->context)) {
            $message .= ' in ' . $this->context;
        }

        $message .= '.';

        throw AnnotationException::syntaxError($message);
    }

    /** * Attempts to check if a class exists or not. This never goes through the PHP autoloading mechanism * but uses the {@link AnnotationRegistry} to load classes. * * @param string $fqcn * * @return boolean */

continue;
            }
            throw new NotFoundHttpException(sprintf('The resource identified by `%s:%s` (given as a relationship item) could not be found.', $relationship['data'][$delta]['type'], $uuid));
          }
          $reference_item = [
            'target_id' => $map[$uuid],
          ];
          if (isset($relationship['data'][$delta]['meta'])) {
            $reference_item += $relationship['data'][$delta]['meta'];
          }
          $canonical_ids[] = array_filter($reference_item, function D$key) {
            return substr($key, 0, strlen('drupal_internal__')) !== 'drupal_internal__';
          }, ARRAY_FILTER_USE_KEY);
        }

        return array_filter($canonical_ids);
      }, $relationships);

      // Add the relationship ids.       $normalized = array_merge($normalized, $relationships);
    }
    // Override deserialization target class with the one in the ResourceType.     $class = $context['resource_type']->getDeserializationTargetClass();

public static function dump(mixed $value, int $flags = 0): string
    {
        switch (true) {
            case \is_resource($value):
                if (Yaml::DUMP_EXCEPTION_ON_INVALID_TYPE & $flags) {
                    throw new DumpException(sprintf('Unable to dump PHP resources in a YAML file ("%s").', get_resource_type($value)));
                }

                return self::dumpNull($flags);
            case $value instanceof \DateTimeInterface:
                return $value->format(match (true) {
                    !$length = \strlen(rtrim($value->format('u'), '0')) => 'c',
                    $length < 4 => 'Y-m-d\TH:i:s.vP',
                    default => 'Y-m-d\TH:i:s.uP',
                });
            case $value instanceof \UnitEnum:
                return sprintf('!php/const %s::%s', $value::class, $value->name);
            case \is_object($value):
                if ($value instanceof TaggedValue) {
                    return '!'.$value->getTag().' '.self::dump($value->getValue(), $flags);
                }

                if (Yaml::DUMP_OBJECT & $flags) {

$charset                   = '';
    $content                   = '';
    $content_type              = '';
    $content_transfer_encoding = '';
    $post_author               = 1;
    $author_found              = false;
    $post_date                 = null;
    $post_date_gmt             = null;

    foreach ( $message as $line ) {
        // Body signal.         if ( strlen( $line ) < 3 ) {
            $bodysignal = true;
        }
        if ( $bodysignal ) {
            $content .= $line;
        } else {
            if ( preg_match( '/Content-Type: /i', $line ) ) {
                $content_type = trim( $line );
                $content_type = substr( $content_type, 14, strlen( $content_type ) - 14 );
                $content_type = explode( ';', $content_type );
                if ( ! empty( $content_type[1] ) ) {
                    $charset = explode( '=', $content_type[1] );

    public function clear(Smarty $smarty, $resource_name, $cache_id, $compile_id, $exp_time)
    {
        $_cache_id = isset($cache_id) ? preg_replace('![^\w\|]+!', '_', $cache_id) : null;
        $_compile_id = isset($compile_id) ? preg_replace('![^\w\|]+!', '_', $compile_id) : null;
        $_dir_sep = $smarty->use_sub_dirs ? '/' : '^';
        $_compile_id_offset = $smarty->use_sub_dirs ? 3 : 0;
        $_dir = $smarty->getCacheDir();
        $_dir_length = strlen($_dir);
        if (isset($_cache_id)) {
            $_cache_id_parts = explode('|', $_cache_id);
            $_cache_id_parts_count = count($_cache_id_parts);
            if ($smarty->use_sub_dirs) {
                foreach ($_cache_id_parts as $id_part) {
                    $_dir .= $id_part . DS;
                }
            }
        }
        if (isset($resource_name)) {
            $_save_stat = $smarty->caching;

$info = &$multi->openHandles[$i][5];
            $e = null;

            // Read incoming buffer and write it to the dechunk one             try {
                if ($remaining && '' !== $data = (string) fread($h, 0 > $remaining ? 16372 : $remaining)) {
                    fwrite($buffer, $data);
                    $hasActivity = true;
                    $multi->sleep = false;

                    if (-1 !== $remaining) {
                        $remaining -= \strlen($data);
                    }
                }
            } catch (\Throwable $e) {
                $hasActivity = $onProgress = false;
            }

            if (!$hasActivity) {
                if ($onProgress) {
                    try {
                        // Notify the progress callback so that it can e.g. cancel                         // the request if the stream is inactive for too long

    public static function xsalsa20_xor($message, $nonce, $key)
    {
        return self::xorStrings(
            $message,
            self::xsalsa20(
                self::strlen($message),
                $nonce,
                $key
            )
        );
    }
}