substr - PHP code example

PHP Function Substr - What Are the Three Parameters That Can Be Passed to the Function Substr?

PHP offers a variety of inbuilt functions that can manipulate different types of data. One of them is the substr function that helps developers isolate a particular part of a string.

There are three parameters that can be passed to the php function substr, of which two are mandatory while the third is optional. The first parameter is the start position of the string, from which the substring is to be removed. This is an integer value and it can be positive, negative or even 0.

The second parameter is the length of the string that needs to be cut. This is also an integer value that can be positive, negative or even 0 just like the start position. If the number is negative, it indicates that a certain amount of characters will be omitted from the end of the string.

The third parameter is the length of the trimmed string that will be returned. This is an integer value that can be positive, negative, or even 0 just like the start and offset position. If no value is specified, the default value which is to the end of the string will be returned. If the trimmed string is not retrieved or any failure occurs, a False will be returned.

substr example

  public function handleExecutionException(\Exception $exception, StatementInterface $statement, array $arguments = [], array $options = []): void {
    if ($exception instanceof \PDOException) {
      // Wrap the exception in another exception, because PHP does not allow       // overriding Exception::getMessage(). Its message is the extra database       // debug information.       $message = $exception->getMessage() . ": " . $statement->getQueryString() . "; " . print_r($arguments, TRUE);
      // Match all SQLSTATE 23xxx errors.       if (substr($exception->getCode(), -6, -3) == '23') {
        throw new IntegrityConstraintViolationException($message, $exception->getCode(), $exception);
      }
      throw new DatabaseExceptionWrapper($message, 0, $exception);
    }

    throw $exception;
  }

}

'HTTP/1.1 301 Moved Permanently',
            'Location: http://127.0.0.1:8057/302',
            'Content-Type: application/json',
            'HTTP/1.1 302 Found',
            'Location: http://localhost:8057/',
            'Content-Type: application/json',
            'HTTP/1.1 200 OK',
            'Content-Type: application/json',
        ];

        $filteredHeaders = array_values(array_filter($response->getInfo('response_headers'), function D$h) {
            return \in_array(substr($h, 0, 4), ['HTTP', 'Loca', 'Cont'], true) && 'Content-Encoding: gzip' !== $h;
        }));

        $this->assertSame($expected, $filteredHeaders);
    }

    public function testInvalidRedirect()
    {
        $client = $this->getHttpClient(__FUNCTION__);
        $response = $client->request('GET', 'http://localhost:8057/301/invalid');

        $this->assertSame(301, $response->getStatusCode());

// Both registration and last updated dates must always be present and valid.     $date_fields = array( 'registered', 'last_updated' );
    foreach ( $date_fields as $date_field ) {
        if ( empty( $data[ $date_field ] ) ) {
            $errors->add( 'site_empty_' . $date_field, __( 'Both registration and last updated dates must be provided.' ) );
            break;
        }

        // Allow '0000-00-00 00:00:00', although it be stripped out at this point.         if ( '0000-00-00 00:00:00' !== $data[ $date_field ] ) {
            $month      = substr( $data[ $date_field ], 5, 2 );
            $day        = substr( $data[ $date_field ], 8, 2 );
            $year       = substr( $data[ $date_field ], 0, 4 );
            $valid_date = wp_checkdate( $month, $day, $year, $data[ $date_field ] );
            if ( ! $valid_date ) {
                $errors->add( 'site_invalid_' . $date_field, __( 'Both registration and last updated dates must be valid dates.' ) );
                break;
            }
        }
    }

    if ( ! empty( $errors->errors ) ) {

    private function prepareVariantParam(array $properties, array $fields): array
    {
        // Maps the fields to the correct table         foreach ($properties as $key => $property) {
            foreach ($fields as $field) {
                $asStr = self::AS_STRING;
                $dotPos = strpos($field, '.');
                $asPos = strpos($field, $asStr, 1);

                if ($asPos) {
                    $fieldName = substr($field, $asPos + \strlen($asStr));
                } else {
                    $fieldName = substr($field, $dotPos + 1);
                }

                if ($fieldName == $property['property']) {
                    $properties[$key]['property'] = $field;
                }
            }
        }

        return $properties;
    }

        if (!\is_string($changelogPart)) {
            return;
        }

        $changelogEntries = explode("\n", $changelogPart);
        foreach ($changelogEntries as $changelogEntry) {
            if (!str_starts_with($changelogEntry, '*')) {
                continue;
            }
            // Remove leading asterisk and spaces around changelog entry             $changelogEntry = trim(substr($changelogEntry, 1));
            if ($changelogEntry === '') {
                continue;
            }

            foreach (ChangelogKeyword::cases() as $allowedChangelogKeyword) {
                if (str_starts_with($changelogEntry, $allowedChangelogKeyword->value)) {
                    continue 2;
                }
            }
            $context->buildViolation(sprintf(self::VIOLATION_MESSAGE_STARTING_KEYWORD, $changelogEntry, implode(', ', array_column(ChangelogKeyword::cases(), 'value'))))
                ->atPath($currentSection->name)

        $str = clone $this;

        if ($prefix instanceof self) {
            $prefix = $prefix->string;
        } else {
            $prefix = (string) $prefix;
        }

        if ('' !== $prefix && \strlen($this->string) >= \strlen($prefix) && 0 === substr_compare($this->string, $prefix, 0, \strlen($prefix), $this->ignoreCase)) {
            $str->string = substr($this->string, \strlen($prefix));
        }

        return $str;
    }

    abstract public function trimStart(string $chars = " \t\n\r\0\x0B\x0C\u{A0}\u{FEFF}"): static;

    /** * @param string|string[] $suffix */
    public function trimSuffix($suffix): static
    {

    public function read($length): string
    {
        $currentLength = strlen($this->buffer);

        if ($length >= $currentLength) {
            // No need to slice the buffer because we don't have enough data.             $result = $this->buffer;
            $this->buffer = '';
        } else {
            // Slice up the result to provide a subset of the buffer.             $result = substr($this->buffer, 0, $length);
            $this->buffer = substr($this->buffer, $length);
        }

        return $result;
    }

    /** * Writes data to the buffer. */
    public function write($string): int
    {

    private function findFileWithExtension($class, $ext)
    {
        // PSR-4 lookup         $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;

        $first = $class[0];
        if (isset($this->prefixLengthsPsr4[$first])) {
            $subPath = $class;
            while (false !== $lastPos = strrpos($subPath, '\\')) {
                $subPath = substr($subPath, 0, $lastPos);
                $search = $subPath . '\\';
                if (isset($this->prefixDirsPsr4[$search])) {
                    $pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1);
                    foreach ($this->prefixDirsPsr4[$search] as $dir) {
                        if (file_exists($file = $dir . $pathEnd)) {
                            return $file;
                        }
                    }
                }
            }
        }

public static function parse(string $str): string
    {
        $bLength = 0;
        if ('b' === $str[0]) {
            $bLength = 1;
        }

        if ('\'' === $str[$bLength]) {
            return str_replace(
                ['\\\\', '\\\''],
                ['\\', '\''],
                substr($str, $bLength + 1, -1)
            );
        } else {
            return self::parseEscapeSequences(substr($str, $bLength + 1, -1), '"');
        }
    }

    /** * Parses escape sequences in strings (all string types apart from single quoted). * * @param string $str String without quotes * @param string|null $quote Quote type */

$this->parseArgument($token);
        }

        return $parseOptions;
    }

    /** * Parses a short option. */
    private function parseShortOption(string $token): void
    {
        $name = substr($token, 1);

        if (\strlen($name) > 1) {
            if ($this->definition->hasShortcut($name[0]) && $this->definition->getOptionForShortcut($name[0])->acceptValue()) {
                // an option with a value (with no space)                 $this->addShortOption($name[0], substr($name, 1));
            } else {
                $this->parseShortOptionSet($name);
            }
        } else {
            $this->addShortOption($name, null);
        }
    }

    public static function stringToContext($string)
    {
        $ctx = self::context();

        # uint64_t h[8];         for ($i = 0; $i < 8; ++$i) {
            $ctx[0][$i] = SplFixedArray::fromArray(
                array(
                    self::load_4(
                        self::substr($string, (($i << 3) + 4), 4)
                    ),
                    self::load_4(
                        self::substr($string, (($i << 3) + 0), 4)
                    )
                )
            );
        }

        # uint64_t t[2];         # uint64_t f[2];         for ($i = 1; $i < 3; ++$i) {

            if ($arg == '--') {
                $non_opts = array_merge($non_opts, array_slice($args, $i + 1));
                break;
            }

            if ($arg[0] != '-' || (strlen($arg) > 1 && $arg[1] == '-' && !$long_options)) {
                $non_opts = array_merge($non_opts, array_slice($args, $i));
                break;
            } elseif (strlen($arg) > 1 && $arg[1] == '-') {
                $error = Console_Getopt::_parseLongOption(substr($arg, 2),
                                                          $long_options,
                                                          $opts,
                                                          $i,
                                                          $args,
                                                          $skip_unknown);
                if (PEAR::isError($error)) {
                    return $error;
                }
            } elseif ($arg == '-') {
                // - is stdin                 $non_opts = array_merge($non_opts, array_slice($args, $i));

        if (! $this->fileNew) {
            ftruncate($this->fileHandle, 0);
            rewind($this->fileHandle);
        }

        if (($length = strlen($data)) > 0) {
            $result = null;

            for ($written = 0; $written < $length; $written += $result) {
                if (($result = fwrite($this->fileHandle, substr($data, $written))) === false) {
                    break;
                }
            }

            if (! is_int($result)) {
                $this->fingerprint = md5(substr($data, 0, $written));
                $this->logger->error('Session: Unable to write data.');

                return false;
            }
        }

$length = mb_strlen($str);
    // If the text is shorter than the minimum word size, don't tokenize it.     if ($length <= $min) {
      return ' ' . $str . ' ';
    }
    $tokens = ' ';
    // Build a FIFO queue of characters.     $chars = [];
    for ($i = 0; $i < $length; $i++) {
      // Add the next character off the beginning of the string to the queue.       $current = mb_substr($str, 0, 1);
      $str = substr($str, strlen($current));
      $chars[] = $current;
      if ($i >= $min - 1) {
        // Make a token of $min characters, and add it to the token string.         $tokens .= implode('', $chars) . ' ';
        // Shift out the first character in the queue.         array_shift($chars);
      }
    }
    return $tokens;
  }

if (stripos($class_name, 'Requests') !== 0 && $psr_4_prefix_pos !== 0) {
                return false;
            }

            $class_lower = strtolower($class_name);

            if ($class_lower === 'requests') {
                // Reference to the original PSR-0 Requests class.                 $file = dirname(__DIR__) . '/library/Requests.php';
            } elseif ($psr_4_prefix_pos === 0) {
                // PSR-4 classname.                 $file = __DIR__ . '/' . strtr(substr($class_name, 15), '\\', '/') . '.php';
            }

            if (isset($file) && file_exists($file)) {
                include $file;
                return true;
            }

            /* * Okay, so the class starts with "Requests", but we couldn't find the file. * If this is one of the deprecated/renamed PSR-0 classes being requested, * let's alias it to the new name and throw a deprecation notice. */