strpos - PHP code example

The PHP Function Strpos()

PHP offers a variety of functions that help developers work with string data types. One of these is strpos(), which allows you to specify the position in a string where a specific substring occurrence occurs. This function is case sensitive and treats upper and lower case characters differently. For example, if you search for "scaler" in a string that contains the word "scaler", you would find it at index 0; however, if you search for the same string in another string that uses the word "scaler," you might not find it.

The strpos() function takes three arguments: the string that will be searched, the substring to search for, and an optional index where the search should start within the string. In addition, the function returns an integer value that indicates where the first occurrence of the searched string occurs in the original string.

The strpos() function is an essential tool for developers working with string data. It has a wide usage and community support, ensuring that it is available in many programming environments. However, it's important to remember that the function only searches for a single occurrence of the substring and does not provide advanced pattern matching capabilities like regular expressions. For more advanced string manipulation and analysis, consider using a different function such as stripos().

strpos example

// Make sure the page display shows the nodes we expect, and that they     // appear in the expected order.     $this->assertSession()->addressEquals($view['page[path]']);
    $this->assertSession()->pageTextContains($view['page[title]']);
    $content = $this->getSession()->getPage()->getContent();
    $this->assertSession()->pageTextContains($node5->label());
    $this->assertSession()->pageTextContains($node4->label());
    $this->assertSession()->pageTextContains($node3->label());
    $this->assertSession()->pageTextContains($node2->label());
    $this->assertSession()->pageTextNotContains($node1->label());
    $this->assertSession()->pageTextNotContains($page_node->label());
    $pos5 = strpos($content, $node5->label());
    $pos4 = strpos($content, $node4->label());
    $pos3 = strpos($content, $node3->label());
    $pos2 = strpos($content, $node2->label());
    $this->assertGreaterThan($pos5, $pos4);
    $this->assertGreaterThan($pos4, $pos3);
    $this->assertGreaterThan($pos3, $pos2);

    // Confirm that the block is listed in the block administration UI.     $this->drupalGet('admin/structure/block/list/' . $this->config('system.theme')->get('default'));
    $this->clickLink('Place block');
    $this->assertSession()->pageTextContains($view['label']);

    function str_contains( $haystack, $needle ) {
        if ( '' === $needle ) {
            return true;
        }

        return false !== strpos( $haystack, $needle );
    }
}

if ( ! function_exists( 'str_starts_with' ) ) {
    /** * Polyfill for `str_starts_with()` function added in PHP 8.0. * * Performs a case-sensitive check indicating if * the haystack begins with needle. * * @since 5.9.0 * * @param string $haystack The string to search in. * @param string $needle The substring to search for in the `$haystack`. * @return bool True if `$haystack` starts with `$needle`, otherwise false. */

if (!str_contains($s, "'")) {
            return sprintf("'%s'", $s);
        }

        if (!str_contains($s, '"')) {
            return sprintf('"%s"', $s);
        }

        $string = $s;
        $parts = [];
        while (true) {
            if (false !== $pos = strpos($string, "'")) {
                $parts[] = sprintf("'%s'", substr($string, 0, $pos));
                $parts[] = "\"'\"";
                $string = substr($string, $pos + 1);
            } else {
                $parts[] = "'$string'";
                break;
            }
        }

        return sprintf('concat(%s)', implode(', ', $parts));
    }

protected static function parse_response($headers, $url, $req_headers, $req_data, $options) {
        $return = new Response();
        if (!$options['blocking']) {
            return $return;
        }

        $return->raw  = $headers;
        $return->url  = (string) $url;
        $return->body = '';

        if (!$options['filename']) {
            $pos = strpos($headers, "\r\n\r\n");
            if ($pos === false) {
                // Crap!                 throw new Exception('Missing header/body separator', 'requests.no_crlf_separator');
            }

            $headers = substr($return->raw, 0, $pos);
            // Headers will always be separated from the body by two new lines - `\n\r\n\r`.             $body = substr($return->raw, $pos + 4);
            if (!empty($body)) {
                $return->body = $body;
            }
        }

'article_listing_3col.tpl',
            'article_listing_4col.tpl',
        ];
        $templates = $this->connection->query("SELECT vals.id, vals.value FROM `s_core_config_values` as vals INNER JOIN `s_core_config_elements` as elems ON elems.id = vals.element_id WHERE elems.name = 'categorytemplates'")
            ->fetchAll(\PDO::FETCH_KEY_PAIR);

        foreach ($templates as $valueId => $serializedValue) {
            $cleanedTemplates = [];
            $templates = unserialize($serializedValue);

            foreach (explode(';', $templates) as $template) {
                if (strpos($template, ':') === false) {
                    continue;
                }

                list($file, $name) = explode(':', $template);

                if (\in_array($file, $templateBlacklist) || empty($name)) {
                    continue;
                }

                $cleanedTemplates[] = $file . ':' . $name;
            }

        // Last Page - Number of Samples         if (!getid3_lib::intValueSupported($info['avdataend'])) {

            $this->warning('Unable to parse Ogg end chunk file (PHP does not support file operations beyond '.round(PHP_INT_MAX / 1073741824).'GB)');

        } else {

            $this->fseek(max($info['avdataend'] - $this->getid3->fread_buffer_size(), 0));
            $LastChunkOfOgg = strrev($this->fread($this->getid3->fread_buffer_size()));
            if ($LastOggSpostion = strpos($LastChunkOfOgg, 'SggO')) {
                $this->fseek($info['avdataend'] - ($LastOggSpostion + strlen('SggO')));
                $info['avdataend'] = $this->ftell();
                $info['ogg']['pageheader']['eos'] = $this->ParseOggPageHeader();
                $info['ogg']['samples']   = $info['ogg']['pageheader']['eos']['pcm_abs_position'];
                if ($info['ogg']['samples'] == 0) {
                    $this->error('Corrupt Ogg file: eos.number of samples == zero');
                    return false;
                }
                if (!empty($info['audio']['sample_rate'])) {
                    $info['ogg']['bitrate_average'] = (($info['avdataend'] - $info['avdataoffset']) * 8) / ($info['ogg']['samples'] / $info['audio']['sample_rate']);
                }
            }

/** * @return void */
    public function process(ContainerBuilder $container)
    {
        if (!$container->hasDefinition('translator')) {
            return;
        }

        foreach ($this->findControllerArguments($container) as $controller => $argument) {
            $id = substr($controller, 0, strpos($controller, ':') ?: \strlen($controller));
            if ($container->hasDefinition($id)) {
                [$locatorRef] = $argument->getValues();
                $this->controllers[(string) $locatorRef][$container->getDefinition($id)->getClass()] = true;
            }
        }

        try {
            parent::process($container);

            $paths = [];
            foreach ($this->paths as $class => $_) {

return isset($matches[1]) ? trim($matches[1]) : null;
    }

    /** * Retrieve the content of a given section * !!!NOTE: Due to PCRE limit, we CANNOT use Regular Expression here for a long content * preg_match('/#\s' . $section . '\s*\n((\n|.)+)((___)|$)/iU', $content, $matches); */
    private function parseSection(string $content, string $section): ?string
    {
        $startPos = strpos($content, '# ' . $section);
        if ($startPos === false) {
            return null;
        }
        $endPos = strpos($content, '___', $startPos + \strlen('# ' . $section)) ?: 0;
        if ($endPos) {
            $length = $endPos - $startPos - \strlen('# ' . $section);
            $matches = substr($content, $startPos + \strlen('# ' . $section), $length);
        } else {
            $matches = substr($content, $startPos + \strlen('# ' . $section));
        }

        // numbers         elseif (preg_match(self::REGEX_NUMBER, $this->code, $match, 0, $this->cursor)) {
            $number = (float) $match[0];  // floats             if (ctype_digit($match[0]) && $number <= \PHP_INT_MAX) {
                $number = (int) $match[0]; // integers lower than the maximum             }
            $this->pushToken(/* Token::NUMBER_TYPE */ 6, $number);
            $this->moveCursor($match[0]);
        }
        // punctuation         elseif (false !== strpos(self::PUNCTUATION, $this->code[$this->cursor])) {
            // opening bracket             if (false !== strpos('([{', $this->code[$this->cursor])) {
                $this->brackets[] = [$this->code[$this->cursor], $this->lineno];
            }
            // closing bracket             elseif (false !== strpos(')]}', $this->code[$this->cursor])) {
                if (empty($this->brackets)) {
                    throw new SyntaxError(sprintf('Unexpected "%s".', $this->code[$this->cursor]), $this->lineno, $this->source);
                }

                list($expect, $lineno) = array_pop($this->brackets);

$path = $relative_url_parts['path'];

            // Else it's a relative path.         } elseif ( ! empty( $relative_url_parts['path'] ) ) {
            // Strip off any file components from the absolute path.             $path = substr( $path, 0, strrpos( $path, '/' ) + 1 );

            // Build the new path.             $path .= $relative_url_parts['path'];

            // Strip all /path/../ out of the path.             while ( strpos( $path, '../' ) > 1 ) {
                $path = preg_replace( '![^/]+/\.\./!', '', $path );
            }

            // Strip any final leading ../ from the path.             $path = preg_replace( '!^/(\.\./)+!', '', $path );
        }

        // Add the query string.         if ( ! empty( $relative_url_parts['query'] ) ) {
            $path .= '?' . $relative_url_parts['query'];
        }

    public function createModelFile($table, $sourceCode)
    {
        // At least we need a file name for the current table object.         $className = $this->getClassNameOfTableName($table->getName());
        if (strpos($table->getName(), '_attributes')) {
            $tableName = str_replace('_attributes', '', $table->getName());
            $className = $this->getClassNameOfTableName($tableName);
        }

        if ($className === '') {
            return false;
        }

        $file = $this->getPath() . $className . '.php';

        if (file_exists($file) && !is_writable($file)) {

    do_action( '_admin_menu' );
}

// Create list of page plugin hook names. foreach ( $menu as $menu_page ) {
    $pos = strpos( $menu_page[2], '?' );

    if ( false !== $pos ) {
        // Handle post_type=post|page|foo pages.         $hook_name = substr( $menu_page[2], 0, $pos );
        $hook_args = substr( $menu_page[2], $pos + 1 );
        wp_parse_str( $hook_args, $hook_args );

        // Set the hook name to be the post type.         if ( isset( $hook_args['post_type'] ) ) {
            $hook_name = $hook_args['post_type'];
        } else {

$requiredPackages = [];
        foreach ($packagesToRequire as $options) {
            $packageName = trim($options->packageName, '/');
            $constraint = $options->versionConstraint ?? '*';

            // avoid resolving the same package twice             if (isset($resolvedPackages[$packageName])) {
                continue;
            }

            $filePath = '';
            $i = strpos($packageName, '/');

            if ($i && (!str_starts_with($packageName, '@') || $i = strpos($packageName, '/', $i + 1))) {
                // @vendor/package/filepath or package/filepath                 $filePath = substr($packageName, $i);
                $packageName = substr($packageName, 0, $i);
            }

            $response = $this->httpClient->request('GET', sprintf($this->versionUrlPattern, $packageName, urlencode($constraint)));
            $requiredPackages[] = [$options, $response, $packageName, $filePath, $options];
        }

return $this->stream->getCurrent();
    }

    private function filterBodyNodes(Node $node, bool $nested = false): ?Node
    {
        // check that the body does not contain non-empty output nodes         if (
            ($node instanceof TextNode && !ctype_space($node->getAttribute('data')))
            ||
            (!$node instanceof TextNode && !$node instanceof BlockReferenceNode && $node instanceof NodeOutputInterface)
        ) {
            if (false !== strpos((string) $node, \chr(0xEF).\chr(0xBB).\chr(0xBF))) {
                $t = substr($node->getAttribute('data'), 3);
                if ('' === $t || ctype_space($t)) {
                    // bypass empty nodes starting with a BOM                     return null;
                }
            }

            throw new SyntaxError('A template that extends another one cannot include content outside Twig blocks. Did you forget to put the content inside a {% block %} tag?', $node->getTemplateLine(), $this->stream->getSourceContext());
        }

        // bypass nodes that "capture" the output

if (! array_key_exists($foreground, static::$foreground_colors)) {
            throw CLIException::forInvalidColor('foreground', $foreground);
        }

        if ($background !== null && ! array_key_exists($background, static::$background_colors)) {
            throw CLIException::forInvalidColor('background', $background);
        }

        $newText = '';

        // Detect if color method was already in use with this text         if (strpos($text, "\033[0m") !== false) {
            $pattern = '/\\033\\[0;.+?\\033\\[0m/u';

            preg_match_all($pattern, $text, $matches);
            $coloredStrings = $matches[0];

            // No colored string found. Invalid strings with no `\033[0;??`.             if ($coloredStrings === []) {
                return $newText . self::getColoredText($text, $foreground, $background, $format);
            }

            $nonColoredText = preg_replace(