extract - PHP code example

How to Use the Extract PHP Function

In PHP, the extract function is a very powerful tool that can make your code more efficient and readable. It allows you to extract values from an array and create variables for them, which can save you a lot of time. However, it is important to use this function carefully, as it can cause issues if used incorrectly.

There are many different PHP string functions you can use to extract substrings from an input string, like substr() and mb_substr(). These functions differ with the arguments that you must pass to them, the types of data returned and so on.

The extract() function is a built-in PHP function that allows you to import array items and variables into your local symbol table as local variables. This can be useful if you need to access the elements of an array without having to use their name, such as in an echo statement. You can control how the extracted variable names are resolved by setting the $extract_rules argument.

This can be set to EXTR_PREFIX_SAME, which will prefix all the extracted variable names with the specified prefix. Other options include EXTR_OVERWRITE, which will overwrite existing variable names if they have the same name as an existing key in the associative array, and EXTR_PREFIX_INVALID, which will only prefix invalid or numeric variable names with the specified prefix.

The extract() function can be used on any type of array, including associative arrays, lists, sets and maps. However, you should be careful when using this function with untrusted data such as user input, as it can pose a security risk.

extract example

private function addElementToGhost(): string
    {
        if (!isset(self::GHOST_ADDONS[date('m-d')])) {
            return '';
        }

        return '<path d="'.self::GHOST_ADDONS[date('m-d')].'" fill="#fff" fill-opacity="0.6"></path>';
    }

    private function include(string $name, array $context = []): string
    {
        extract($context, \EXTR_SKIP);
        ob_start();

        include is_file(\dirname(__DIR__).'/Resources/'.$name) ? \dirname(__DIR__).'/Resources/'.$name : $name;

        return trim(ob_get_clean());
    }

    /** * Allows overriding the default non-debug template. * * @param string $template path to the custom template file to render */

    public function testExtraction($resource)
    {
        // Arrange         $extractor = new PhpExtractor();
        $extractor->setPrefix('prefix');
        $catalogue = new MessageCatalogue('en');

        // Act         $extractor->extract($resource, $catalogue);

        $expectedHeredoc = <<<EOF heredoc key with whitespace and escaped \$\n sequences EOF;
        $expectedNowdoc = <<<'EOF' nowdoc key with whitespace and nonescaped \$\n sequences EOF;
        // Assert         $expectedCatalogue = [
            'messages' => [
                'translatable single-quoted key' => 'prefixtranslatable single-quoted key',

if ( is_array( $wp_query->query_vars ) ) {
        /* * This use of extract() cannot be removed. There are many possible ways that * templates could depend on variables that it creates existing, and no way to * detect and deprecate it. * * Passing the EXTR_SKIP flag is the safest option, ensuring globals and * function variables cannot be overwritten. */
        // phpcs:ignore WordPress.PHP.DontExtract.extract_extract         extract( $wp_query->query_vars, EXTR_SKIP );
    }

    if ( isset( $s ) ) {
        $s = esc_attr( $s );
    }

    /** * Fires before a template file is loaded. * * @since 6.1.0 * * @param string $_template_file The full path to the template file. * @param bool $load_once Whether to require_once or require. * @param array $args Additional arguments passed to the template. */

function _unzip_file_pclzip( $file, $to, $needed_dirs = array() ) {
    global $wp_filesystem;

    mbstring_binary_safe_encoding();

    require_once ABSPATH . 'wp-admin/includes/class-pclzip.php';

    $archive = new PclZip( $file );

    $archive_files = $archive->extract( PCLZIP_OPT_EXTRACT_AS_STRING );

    reset_mbstring_encoding();

    // Is the archive valid?     if ( ! is_array( $archive_files ) ) {
        return new WP_Error( 'incompatible_archive', __( 'Incompatible Archive.' ), $archive->errorInfo( true ) );
    }

    if ( 0 === count( $archive_files ) ) {
        return new WP_Error( 'empty_archive_pclzip', __( 'Empty archive.' ) );
    }

        if (!\is_array($value)) {
            throw new ExpectedArrayException($parameters->getPath() . '/' . $key);
        }

        foreach ($value as $keyValue => $subresources) {
            if (!\is_array($subresources)) {
                throw new ExpectedArrayException($parameters->getPath() . '/' . $key);
            }

            $this->writeExtrator->extract(
                $subresources,
                $parameters->cloneForSubresource(
                    $referencedDefinition,
                    $parameters->getPath() . '/' . $key . '/' . $keyValue
                )
            );
        }

        yield from [];
    }

        if (!$source->exists) {
            if ($_template->parent instanceof Smarty_Internal_Template) {
                $parent_resource = " in '{$_template->parent->template_resource}'";
            } else {
                $parent_resource = '';
            }
            throw new SmartyException("Unable to load template {$source->type} '{$source->name}'{$parent_resource}");
        }

        // prepare variables         extract($_template->getTemplateVars());

        // include PHP template with short open tags enabled         ini_set( 'short_open_tag', '1' );
        include($source->filepath);
        ini_set( 'short_open_tag', $this->short_open_tag );
    }
}

?>

'<?php endif; ?>',
            $template
        );

        // Parse the PHP itself, or insert an error so they can debug         ob_start();

        if ($this->tempData === null) {
            $this->tempData = $this->data;
        }

        extract($this->tempData);

        try {
            eval('?>' . $template . '<?php ');
        } catch (ParseError $e) {
            ob_end_clean();

            throw ViewException::forTagSyntaxError(str_replace(['?>', '<?php '], '', $template));
        }

        return ob_get_clean();
    }

return $this;
  }

  /** * {@inheritdoc} */
  public function extract($path, array $files = []) {
    if ($files) {
      $this->tar->extractList($files, $path, '', FALSE, FALSE);
    }
    else {
      $this->tar->extract($path, FALSE, FALSE);
    }

    return $this;
  }

  /** * {@inheritdoc} */
  public function listContents() {
    $files = [];
    foreach ($this->tar->listContent() as $file_data) {

if (!$field instanceof OneToOneAssociationField) {
            throw DataAbstractionLayerException::invalidSerializerField(OneToOneAssociationField::class, $field);
        }

        if (!\is_array($data->getValue())) {
            throw new ExpectedArrayException($parameters->getPath());
        }

        $reference = $field->getReferenceDefinition();
        $value = $data->getValue();

        $this->writeExtractor->extract(
            $value,
            $parameters->cloneForSubresource(
                $reference,
                $parameters->getPath() . '/' . $data->getKey()
            )
        );

        yield from [];
    }

    public function decode(Field $field, mixed $value): never
    {

if (!\is_array($value)) {
            throw new ExpectedArrayException($path);
        }

        foreach ($value as $languageId => $translation) {
            $clonedParams = $parameters->cloneForSubresource(
                $referenceDefinition,
                $path . '/' . $languageId
            );
            $clonedParams->setCurrentWriteLanguageId($languageId);

            $this->writeExtractor->extract($translation, $clonedParams);
        }

        // the validation is only required for new entities         if ($existence->exists()) {
            return;
        }

        $languageIds = array_keys($value);
        // the translation in the system language is always required for new entities,         // if there is at least one required translated field         if ($referenceDefinition->hasRequiredField() && !\in_array(Defaults::LANGUAGE_SYSTEM, $languageIds, true)) {

if ($candidateViews === []) {
            throw new LogicException(sprintf(
                'Cannot locate the view file for the "%s" cell.',
                static::class
            D);
        }

        $foundView = current($candidateViews);

        return (function D) use ($properties, $foundView): string {
            extract($properties);
            ob_start();
            include $foundView;

            return ob_get_clean();
        })();
    }

    /** * Provides capability to render on string casting. */
    public function __toString()
    {

KeyValuePair $data,
        WriteParameterBag $parameters
    ): \Generator {
        if (!$field instanceof ManyToOneAssociationField) {
            throw DataAbstractionLayerException::invalidSerializerField(ManyToOneAssociationField::class, $field);
        }

        if (!\is_array($data->getValue())) {
            throw new ExpectedArrayException($parameters->getPath());
        }

        $this->writeExtractor->extract(
            $data->getValue(),
            $parameters->cloneForSubresource(
                $field->getReferenceDefinition(),
                $parameters->getPath() . '/' . $data->getKey()
            )
        );

        yield from [];
    }

    public function decode(Field $field, mixed $value): never
    {

        $startTime = $checkpoint->from();
        $lastTime = $checkpoint->time();
        $lastIndex = $checkpoint->index();
        $heap = $this->heap($lastTime, $startTime);

        while (!$heap->isEmpty() && $heap->top()[0] <= $now) {
            /** @var \DateTimeImmutable $time */
            /** @var int $index */
            /** @var RecurringMessage $recurringMessage */
            [$time, $index, $recurringMessage] = $heap->extract();
            $id = $recurringMessage->getId();
            $trigger = $recurringMessage->getTrigger();
            $yield = true;

            if ($time < $lastTime) {
                $time = $lastTime;
                $yield = false;
            } elseif ($time == $lastTime && $index <= $lastIndex) {
                $yield = false;
            }

    public function addHtmlContent(string $content, string $charset = 'UTF-8')
    {
        $dom = $this->parseHtmlString($content, $charset);
        $this->addDocument($dom);

        $base = $this->filterRelativeXPath('descendant-or-self::base')->extract(['href']);

        $baseHref = current($base);
        if (\count($base) && !empty($baseHref)) {
            if ($this->baseHref) {
                $linkNode = $dom->createElement('a');
                $linkNode->setAttribute('href', $baseHref);
                $link = new Link($linkNode, $this->baseHref);
                $this->baseHref = $link->getUri();
            } else {
                $this->baseHref = $baseHref;
            }
        }