array_pop - PHP code example

How to Use the PHP Function Array_Pop() to Remove the Last Element From an Array

Arrays in PHP are versatile and powerful data structures that allow you to store multiple values under a single variable name. They provide a wide range of operations such as accessing, modifying, adding, removing, searching, and sorting elements. It is important for developers to understand the array functions and how to use them, as this can improve their coding efficiency and code readability.

One common operation that you may need to perform is removing the last element from an array. In PHP, this is easy to do using the built-in function array_pop(). This function removes the last element from an array and returns its value, which can be helpful for a variety of purposes.

This function requires a single parameter, which is the array to pop from. It will return the value of the last element that was removed from the array, which effectively reduces its size by one. It will also reset() the array pointer of the input array after use. If the array is empty or the input variable is not an array, it will return NULL.

You can find more information about this function on its official PHP manual page here. You can also view the example code below for more information on how this function works. Remember that this function directly modifies the array it operates on, so it is important to consider whether this behavior is desired in your application. Otherwise, it is best to avoid using this function with empty arrays or non-array variables in order to prevent unexpected results and errors.

array_pop example

public function getParent(): ?PropertyPathInterface
 {
 if ($this->length <= 1) {
 return null;
 }

 $parent = clone $this;

 --$parent->length;
 array_pop($parent->elements);
 array_pop($parent->isIndex);
 array_pop($parent->mapsForm);

 $parent->buildString();

 return $parent;
 }

 public function getElements(): array
 {
 return $this->elements;
 }

/** * @param array<mixed> $params */
 public function __construct(
 string $field,
 ?string $order = null,
 ?BuilderInterface $nestedFilter = null,
 array $params = []
 ) {
 $path = explode('.', $field);
 array_pop($path);

 $params = array_merge(
 $params,
 [
 'mode' => 'sum',
 'nested' => ['path' => implode('.', $path)],
 'missing' => 0,
 ]
 );

 $path[] = '_count';

  protected function assertMenuActiveTrail($tree, $last_active, $active_trail_class = 'menu-item--active-trail', $active_class = 'is-active') {
    end($tree);
    $active_link_path = key($tree);
    $active_link_title = array_pop($tree);
    $xpath = '';
    if ($tree) {
      $i = 0;
      foreach ($tree as $link_path => $link_title) {
        $part_xpath = (!$i ? '//' : '/following-sibling::ul/descendant::');
        $part_xpath .= 'li[contains(@class, :class-trail)]/a[contains(@href, :href) and contains(text(), :title)]';
        $part_args = [
          ':class-trail' => $active_trail_class,
          ':href' => Url::fromUri('base:' . $link_path)->toString(),
          ':title' => $link_title,
        ];

/** * Duplicates search packages. * * @param array<string, string> $vars */
 protected function checkDuplicates(string $path, array $vars = array()): void
 {
 $packageType = substr($vars['type'], strlen('bitrix') + 1);
 $localDir = explode('/', $vars['bitrix_dir']);
 array_pop($localDir);
 $localDir[] = 'local';
 $localDir = implode('/', $localDir);

 $oldPath = str_replace(
 array('{$bitrix_dir}', '{$name}'),
 array($localDir, $vars['name']),
 $this->locations[$packageType]
 );

 if (in_array($oldPath, static::$checkedDuplicates)) {
 return;
 }

throw new \RuntimeException(sprintf('The template "%s" cannot be rendered.', $this->parser->parse($name)));
        }

        // decorator         if ($this->parents[$key]) {
            $slots = $this->get('slots');
            $this->stack[] = $slots->get('_content');
            $slots->set('_content', $content);

            $content = $this->render($this->parents[$key], $parameters);

            $slots->set('_content', array_pop($this->stack));
        }

        return $content;
    }

    public function exists(string|TemplateReferenceInterface $name): bool
    {
        try {
            $this->load($name);
        } catch (\InvalidArgumentException) {
            return false;
        }

EOF;

        $entity = explode('\\', (string) $definition->getEntityClass());
        $entity = array_pop($entity);

        $callTemplate = '';
        if (!empty($calls)) {
            $callTemplate = "\n " . implode("\n ", $calls);
        }

        $vars = [
            '#namespace#' => $namespace,
            '#class#' => $class,
            '#entity#' => $entity,
            '#fields#' => implode("\n ", $fields),

    protected function checkDns($host)
    {
        $variant = INTL_IDNA_VARIANT_UTS46;

        $host = rtrim(idn_to_ascii($host, IDNA_DEFAULT, $variant), '.');

        $hostParts = explode('.', $host);
        $host = array_pop($hostParts);

        while (count($hostParts) > 0) {
            $host = array_pop($hostParts) . '.' . $host;

            if ($this->validateDnsRecords($host)) {
                return true;
            }
        }

        return false;
    }

$this->compileArguments($compiler, false);
    }

    public function toArray(): array
    {
        $array = [];

        foreach ($this->getKeyValuePairs() as $pair) {
            $array[] = $pair['value'];
            $array[] = ', ';
        }
        array_pop($array);

        return $array;
    }
}

private function placeOrder(IdsCollection $ids): void
    {
        $cart = $this->cartService->createNew($this->salesChannelContext->getToken());
        $cart = $this->addProducts($cart, $ids);

        $ids->set('order', $this->cartService->order($cart, $this->salesChannelContext, new RequestDataBag()));
    }

    private function addProducts(Cart $cart, IdsCollection $ids): Cart
    {
        $taxIds = $this->salesChannelContext->getTaxRules()->getIds();
        $ids->set('t1', (string) array_pop($taxIds));

        $this->productRepository->create([
            (new ProductBuilder($ids, 'product'))
                ->price(100)
                ->tax('t1')
                ->visibility()
                ->add('height', 3)
                ->add('width', 3)
                ->add('length', 3)
                ->build(),
        ], $this->salesChannelContext->getContext());

throw $e;
        }

        $node = new ModuleNode(new BodyNode([$body]), $this->parent, new Node($this->blocks), new Node($this->macros), new Node($this->traits), $this->embeddedTemplates, $stream->getSourceContext());

        $traverser = new NodeTraverser($this->env, $this->visitors);

        $node = $traverser->traverse($node);

        // restore previous stack so previous parse() call can resume working         foreach (array_pop($this->stack) as $key => $val) {
            $this->$key = $val;
        }

        return $node;
    }

    public function subparse($test, bool $dropNeedle = false): Node
    {
        $lineno = $this->getCurrentToken()->getLine();
        $rv = [];
        while (!$this->stream->isEOF()) {

throw new InvalidArgumentException(sprintf('Invalid definition for service "%s": the "interface" attribute is missing on a "proxy" tag.', $id ?? $definition->getClass()));
                }
                if (!interface_exists($tag['interface']) && !class_exists($tag['interface'], false)) {
                    throw new InvalidArgumentException(sprintf('Invalid definition for service "%s": several "proxy" tags found but "%s" is not an interface.', $id ?? $definition->getClass(), $tag['interface']));
                }
                if ('object' !== $definition->getClass() && !is_a($class->name, $tag['interface'], true)) {
                    throw new InvalidArgumentException(sprintf('Invalid "proxy" tag for service "%s": class "%s" doesn\'t implement "%s".', $id ?? $definition->getClass(), $definition->getClass(), $tag['interface']));
                }
                $interfaces[] = new \ReflectionClass($tag['interface']);
            }

            $class = 1 === \count($interfaces) && !$interfaces[0]->isInterface() ? array_pop($interfaces) : null;
        } elseif ($class->isInterface()) {
            $interfaces = [$class];
            $class = null;
        }

        try {
            return (\PHP_VERSION_ID >= 80200 && $class?->isReadOnly() ? 'readonly ' : '').'class '.$proxyClass.ProxyHelper::generateLazyProxy($class, $interfaces);
        } catch (LogicException $e) {
            throw new InvalidArgumentException(sprintf('Cannot generate lazy proxy for service "%s".', $id ?? $definition->getClass()), 0, $e);
        }
    }

        public static function prepend_each_line( $input_string, $with ) {
            $lines  = explode( "\n", $input_string );
            $append = '';
            if ( "\n" === substr( $input_string, -1 ) && '' === end( $lines ) ) {
                /* * Last line might be empty because $input_string was terminated * with a newline, remove it from the $lines array, * we'll restore state by re-terminating the string at the end. */
                array_pop( $lines );
                $append = "\n";
            }
            foreach ( $lines as &$line ) {
                $line = $with . $line;
            }
            unset( $line );
            return implode( "\n", $lines ) . $append;
        }

        /** * Prepare a text as a comment -- wraps the lines and prepends # * and a special character to each line * * @access private * @param string $text the comment text * @param string $char character to denote a special PO comment, * like :, default is a space */

  protected function treeDataRecursive(array &$links, array $parents, $depth) {
    $tree = [];
    while ($tree_link_definition = array_pop($links)) {
      $tree[$tree_link_definition['id']] = [
        'definition' => $this->prepareLink($tree_link_definition, TRUE),
        'has_children' => $tree_link_definition['has_children'],
        // We need to determine if we're on the path to root so we can later         // build the correct active trail.         'in_active_trail' => in_array($tree_link_definition['id'], $parents),
        'subtree' => [],
        'depth' => $tree_link_definition['depth'],
      ];
      // Look ahead to the next link, but leave it on the array so it's       // available to other recursive function calls if we return or build a

else {
 $log_message = $this->t('All errors have been logged.');
 }

 if ($update_success) {
 $message = '' . $this->t('Updates were attempted. If you see no failures below, you may proceed happily back to your <a href=":url">site</a>. Otherwise, you may need to update your database manually.', [':url' => Url::fromRoute('<front>')->setOption('base_url', $base_url)->toString(TRUE)->getGeneratedUrl()]) . ' ' . $log_message . '';
 }
 else {
 $last = $session->get('updates_remaining');
 $last = reset($last);
 [$module, $version] = array_pop($last);
 $message = '' . $this->t('The update process was aborted prematurely while running update #@version in @module.module.', [
 '@version' => $version,
 '@module' => $module,
 ]) . ' ' . $log_message;
 if ($dblog_exists) {
 $message .= ' ' . $this->t('You may need to check the <code>watchdog</code> database table manually.');
 }
 $message .= '';
 }

 if (Settings::get('update_free_access')) {

$stopsWhen[] = "been running for {$timeLimit}s";
            $this->eventDispatcher->addSubscriber(new StopWorkerOnTimeLimitListener($timeLimit, $this->logger));
        }

        $stopsWhen[] = 'received a stop signal via the messenger:stop-workers command';

        $io = new SymfonyStyle($input, $output instanceof ConsoleOutputInterface ? $output->getErrorOutput() : $output);
        $io->success(sprintf('Consuming messages from transport%s "%s".', \count($receivers) > 1 ? 's' : '', implode(', ', $receiverNames)));

        if ($stopsWhen) {
            $last = array_pop($stopsWhen);
            $stopsWhen = ($stopsWhen ? implode(', ', $stopsWhen).' or ' : '').$last;
            $io->comment("The worker will automatically exit once it has {$stopsWhen}.");
        }

        $io->comment('Quit the worker with CONTROL-C.');

        if (OutputInterface::VERBOSITY_VERBOSE > $output->getVerbosity()) {
            $io->comment('Re-run the command with a -vv option to see logs about consumed messages.');
        }

        $bus = $input->getOption('bus') ? $this->routableBus->getMessageBus($input->getOption('bus')) : $this->routableBus;