parse_str - PHP code example

The PHP Function ParseStr

The php function parse_str is used to parse a string into an array. It takes a string of data that is in query format (such as 'name=wilson&color=blue') and creates an array of variable names and values. You can then use this array as a key in other functions.

Another important PHP string function is the rtrim() function. This function removes white spaces and other predefined characters from the right side of a string. It also makes sure that non-alphanumeric characters are preceded by a backslash. This is important because if a non-alphanumeric character appears in a password hash, it can be easily cracked and used to hack into a database.

There are also other useful PHP string functions that help to make code more readable and efficient. For example, the addslashes() function adds a backslash to certain characters in a string so that it is safe to store in a database or display on a web page. This function is particularly useful when working with regular expressions to escape special characters.

Other functions that are useful for parsing data into an array include the parse_url(), which parses a URL into variables, and the explode(), which splits a string into a set of key-value pairs. Both of these functions are essential for anyone using PHP and can save a lot of time when dealing with large strings of data. Learn how to perform well on System Design Interviews with the free O'Reilly course, Get Hired in 2023 — Sign Up Now.

parse_str example

throw new \InvalidArgumentException("Missing scheme in URL '$url'");
    }
    $driver = $matches[1];

    // Determine if the database driver is provided by a module.     // @todo https://www.drupal.org/project/drupal/issues/3250999. Refactor when     // all database drivers are provided by modules.     $module = NULL;
    $connection_class = NULL;
    $url_components = parse_url($url);
    $url_component_query = $url_components['query'] ?? '';
    parse_str($url_component_query, $query);

    // Add the module key for core database drivers when the module key is not     // set.     if (!isset($query['module']) && in_array($driver, ['mysql', 'pgsql', 'sqlite'], TRUE)) {
      $query['module'] = $driver;
    }

    if (isset($query['module']) && $query['module']) {
      $module = $query['module'];
      // Set up an additional autoloader. We don't use the main autoloader as       // this method can be called before Drupal is installed and is never

class LinkOptions extends ProcessPluginBase {

  /** * {@inheritdoc} */
  public function transform($value, MigrateExecutableInterface $migrate_executable, Row $row, $destination_property) {
    if (isset($value['query'])) {
      // If the query parameters are stored as a string (as in D6), convert it       // into an array.       if (is_string($value['query'])) {
        parse_str($value['query'], $old_query);
      }
      else {
        $old_query = $value['query'];
      }
      $value['query'] = $old_query;
    }
    return $value;
  }

}

if (!function_exists('mb_check_encoding')) {
    function mb_check_encoding($value = null, $encoding = null) { return p\Mbstring::mb_check_encoding($value, $encoding); }
}
if (!function_exists('mb_detect_encoding')) {
    function mb_detect_encoding($string, $encodings = null, $strict = false) { return p\Mbstring::mb_detect_encoding($string, $encodings, $strict); }
}
if (!function_exists('mb_detect_order')) {
    function mb_detect_order($encoding = null) { return p\Mbstring::mb_detect_order($encoding); }
}
if (!function_exists('mb_parse_str')) {
    function mb_parse_str($string, &$result = []) { parse_str($string, $result); return (bool) $result; }
}
if (!function_exists('mb_strlen')) {
    function mb_strlen($string, $encoding = null) { return p\Mbstring::mb_strlen($string, $encoding); }
}
if (!function_exists('mb_strpos')) {
    function mb_strpos($haystack, $needle, $offset = 0, $encoding = null) { return p\Mbstring::mb_strpos($haystack, $needle, $offset, $encoding); }
}
if (!function_exists('mb_strtolower')) {
    function mb_strtolower($string, $encoding = null) { return p\Mbstring::mb_strtolower($string, $encoding); }
}
if (!function_exists('mb_strtoupper')) {

// This section ensures that even on servers that require the URI to contain the query string (Nginx) a correct         // URI is found, and also fixes the QUERY_STRING Server var and $_GET array.         if (trim($uri, '/') === '' && strncmp($query, '/', 1) === 0) {
            $query                   = explode('?', $query, 2);
            $uri                     = $query[0];
            $_SERVER['QUERY_STRING'] = $query[1] ?? '';
        } else {
            $_SERVER['QUERY_STRING'] = $query;
        }

        // Update our globals for values likely to been have changed         parse_str($_SERVER['QUERY_STRING'], $_GET);
        $this->populateGlobals('server');
        $this->populateGlobals('get');

        $uri = URI::removeDotSegments($uri);

        return ($uri === '/' || $uri === '') ? '/' : ltrim($uri, '/');
    }

    /** * Parse QUERY_STRING * * Will parse QUERY_STRING and automatically detect the URI from it. * * @deprecated 4.4.0 Moved to SiteURIFactory. */

if (empty($path)) {
        // We have to return a valid path but / won't be routable and config         // might be broken so stop execution.         throw new NotFoundHttpException();
      }
      $components = parse_url($path);
      // Remove query string and fragment.       $path = $components['path'];
      // Merge query parameters from front page configuration value       // with URL query, so that actual URL takes precedence.       if (!empty($components['query'])) {
        parse_str($components['query'], $parameters);
        array_replace($parameters, $request->query->all());
        $request->query->replace($parameters);
      }
    }
    return $path;
  }

}

if ($request->attributes->has('_controller')) {
            // Is a sub-request: no need to parse _path but it should still be removed from query parameters as below.             $request->query->remove('_path');

            return;
        }

        if ($event->isMainRequest()) {
            $this->validateRequest($request);
        }

        parse_str($request->query->get('_path', ''), $attributes);
        $request->attributes->add($attributes);
        $request->attributes->set('_route_params', array_replace($request->attributes->get('_route_params', []), $attributes));
        $request->query->remove('_path');
    }

    protected function validateRequest(Request $request): void
    {
        // is the Request safe?         if (!$request->isMethodSafe()) {
            throw new AccessDeniedHttpException();
        }

<?php
use Symfony\Component\RemoteEvent\Event\Sms\SmsEvent;

parse_str(trim(file_get_contents(str_replace('.php', '.txt', __FILE__))), $payload);
$wh = new SmsEvent(SmsEvent::DELIVERED, 'SM4262411b90e5464b98a4f66a49c57a97', $payload);
$wh->setRecipientPhone('+15622089096');

return $wh;

    }
    return $path;
  }

  /** * {@inheritdoc} */
  public function getLanguageSwitchLinks(Request $request, $type, Url $url) {
    $links = [];
    $query = [];
    parse_str($request->getQueryString() ?? '', $query);
    $config = $this->config->get('language.negotiation')->get('session');
    $param = $config['parameter'];
    $language_query = $_SESSION[$param] ?? $this->languageManager->getCurrentLanguage($type)->getId();

    foreach ($this->languageManager->getNativeLanguages() as $language) {
      $langcode = $language->getId();
      $links[$langcode] = [
        // We need to clone the $url object to avoid using the same one for all         // links. When the links are rendered, options are set on the $url         // object, so if we use the same one, they would be set for all links.         'url' => clone $url,

if (false === $params = parse_url($params)) {
            throw new InvalidArgumentException('Invalid Redis DSN.');
        }

        $query = $hosts = [];

        $tls = 'rediss' === $scheme;
        $tcpScheme = $tls ? 'tls' : 'tcp';

        if (isset($params['query'])) {
            parse_str($params['query'], $query);

            if (isset($query['host'])) {
                if (!\is_array($hosts = $query['host'])) {
                    throw new InvalidArgumentException('Invalid Redis DSN: query parameter "host" must be an array.');
                }
                foreach ($hosts as $host => $parameters) {
                    if (\is_string($parameters)) {
                        parse_str($parameters, $parameters);
                    }
                    if (false === $i = strrpos($host, ':')) {
                        $hosts[$host] = ['scheme' => $tcpScheme, 'host' => $host, 'port' => 6379] + $parameters;
                    }

'token' => $token,
            'transactionId' => $transactionId,
            'paymentMethodId' => $paymentMethodId,
        ];
    }

    private function getToken(string $returnUrl): string
    {
        $query = \parse_url($returnUrl, \PHP_URL_QUERY);
        static::assertIsString($query);

        \parse_str($query, $params);

        $token = $params['_sw_payment_token'];

        static::assertIsString($token);

        return $token;
    }
}

if (false === $components = parse_url($dsn)) {
            throw new InvalidArgumentException('The given Beanstalkd DSN is invalid.');
        }

        $connectionCredentials = [
            'host' => $components['host'],
            'port' => $components['port'] ?? PheanstalkInterface::DEFAULT_PORT,
        ];

        $query = [];
        if (isset($components['query'])) {
            parse_str($components['query'], $query);
        }

        $configuration = [];
        $configuration += $options + $query + self::DEFAULT_OPTIONS;

        // check for extra keys in options         $optionsExtraKeys = array_diff(array_keys($options), array_keys(self::DEFAULT_OPTIONS));
        if (0 < \count($optionsExtraKeys)) {
            throw new InvalidArgumentException(sprintf('Unknown option found : [%s]. Allowed options are [%s].', implode(', ', $optionsExtraKeys), implode(', ', array_keys(self::DEFAULT_OPTIONS))));
        }

return $this->connection->executeQuery($sql, [
            'shopId' => $shopId,
            'pathInfo' => $pathInfo,
        ])->fetchAssociative();
    }

    /** * @return array<array-key, mixed> */
    private function getQueryFormOrgPath(string $orgPath): array
    {
        parse_str($orgPath, $query);
        $query = array_merge($this->defaultRoute, $query);
        if (isset($query['sViewport'])) {
            $query['controller'] = $query['sViewport'];
            unset($query['sViewport']);
            if (isset($query['sAction'])) {
                $query['action'] = $query['sAction'];
                unset($query['sAction']);
            }
        }

        return $query;
    }

$this->scheme = $parsedDsn['scheme'];

        if (!isset($parsedDsn['host'])) {
            throw new InvalidArgumentException('The notifier DSN must contain a host (use "default" by default).');
        }
        $this->host = $parsedDsn['host'];

        $this->user = '' !== ($parsedDsn['user'] ?? '') ? urldecode($parsedDsn['user']) : null;
        $this->password = '' !== ($parsedDsn['pass'] ?? '') ? urldecode($parsedDsn['pass']) : null;
        $this->port = $parsedDsn['port'] ?? null;
        $this->path = $parsedDsn['path'] ?? null;
        parse_str($parsedDsn['query'] ?? '', $this->options);
    }

    public function getScheme(): string
    {
        return $this->scheme;
    }

    public function getHost(): string
    {
        return $this->host;
    }

    public static function fromDsn(#[\SensitiveParameter] string $dsn, array $options = [], HttpClientInterface $client = null, LoggerInterface $logger = null): self     {
        if (false === $parsedUrl = parse_url($dsn)) {
            throw new InvalidArgumentException('The given Amazon SQS DSN is invalid.');
        }

        $query = [];
        if (isset($parsedUrl['query'])) {
            parse_str($parsedUrl['query'], $query);
        }

        // check for extra keys in options         $optionsExtraKeys = array_diff(array_keys($options), array_keys(self::DEFAULT_OPTIONS));
        if (0 < \count($optionsExtraKeys)) {
            throw new InvalidArgumentException(sprintf('Unknown option found: [%s]. Allowed options are [%s].', implode(', ', $optionsExtraKeys), implode(', ', array_keys(self::DEFAULT_OPTIONS))));
        }

        // check for extra keys in options         $queryExtraKeys = array_diff(array_keys($query), array_keys(self::DEFAULT_OPTIONS));
        if (0 < \count($queryExtraKeys)) {

public function reset()
    {
        foreach ($this->createdTransports as $transport) {
            $transport->reset();
        }
    }

    private function parseDsn(string $dsn): array
    {
        $query = [];
        if ($queryAsString = strstr($dsn, '?')) {
            parse_str(ltrim($queryAsString, '?'), $query);
        }

        return [
            'serialize' => filter_var($query['serialize'] ?? false, \FILTER_VALIDATE_BOOL),
        ];
    }
}