array_slice - PHP code example

PHP Function Array_Slice

In the last article, Working With Array Elements in PHP, you learned how to read and change individual elements of an array. However, there are times where you may want to work with a range of array elements instead of just one. This is where the php function array_slice comes into play. In this article, you'll learn about the function, how to use it, and some practical examples of its usage.

The php function array_slice returns the selected part of an array based on its arguments. It takes four parameters, two of which are mandatory: the array and its starting position. The rest are optional: the length of the sequence (if specified), and the preserve_keys option, which if set to true will preserve the indexes of integer arrays; if not, they will be reset to zero.

If the length of the sequence is not specified, then the slice will contain everything from the start to the end of the array. This is a good way to quickly fetch just a specific part of an array, especially if the array has a lot of elements that you aren't interested in.

The length of the slice can also be specified if you'd like to take just a specific number of elements from an array. For example, if the array has five elements and you only want to take four of them, then you would specify the length as 4. You can also specify a negative value for the length if you'd like to start from the end of the array.

array_slice example

        return ($this->lazyObjectState->realInstance ??= ($this->lazyObjectState->initializer)())->hStrLen(...\func_get_args());
    }

    public function hVals($key)
    {
        return ($this->lazyObjectState->realInstance ??= ($this->lazyObjectState->initializer)())->hVals(...\func_get_args());
    }

    public function hscan($str_key, &$i_iterator, $str_pattern = null, $i_count = null)
    {
        return ($this->lazyObjectState->realInstance ??= ($this->lazyObjectState->initializer)())->hscan($str_key, $i_iterator, $str_pattern, $i_count, ...\array_slice(\func_get_args(), 4));
    }

    public function incr($key)
    {
        return ($this->lazyObjectState->realInstance ??= ($this->lazyObjectState->initializer)())->incr(...\func_get_args());
    }

    public function incrBy($key, $value)
    {
        return ($this->lazyObjectState->realInstance ??= ($this->lazyObjectState->initializer)())->incrBy(...\func_get_args());
    }

$this->_start_diff();

    foreach ($diff->getEdits() as $edit) {
      if ($edit->type == 'copy') {
        if (is_array($block)) {
          if (sizeof($edit->orig) <= $nlead + $ntrail) {
            $block[] = $edit;
          }
          else {
            if ($ntrail) {
              $context = array_slice($edit->orig, 0, $ntrail);
              $block[] = new DiffOpCopy($context);
            }
            $this->_block($x0, $ntrail + $xi - $x0, $y0, $ntrail + $yi - $y0, $block);
            $block = FALSE;
          }
        }
        $context = $edit->orig;
      }
      else {
        if (!is_array($block)) {
          $context = array_slice($context, sizeof($context) - $nlead);

            if (\array_key_exists($p->name, $values)) {
                $i = $p->name;
            } elseif (!\array_key_exists($i, $values)) {
                continue;
            }

            $this->checkType($checkedDefinition, $values[$i], $p, $envPlaceholderUniquePrefix);
        }

        if ($reflectionFunction->isVariadic() && ($lastParameter = end($reflectionParameters))->hasType()) {
            $variadicParameters = \array_slice($values, $lastParameter->getPosition());

            foreach ($variadicParameters as $variadicParameter) {
                $this->checkType($checkedDefinition, $variadicParameter, $lastParameter, $envPlaceholderUniquePrefix);
            }
        }
    }

    /** * @throws InvalidParameterTypeException When a parameter is not compatible with the declared type */
    private function checkType(Definition $checkedDefinition, mixed $value, \ReflectionParameter $parameter, ?string $envPlaceholderUniquePrefix, \ReflectionType $reflectionType = null): void
    {

$getOrders,
            ['subject' => $this, 'id' => $userId]
        );

        if ($perPage != 0) {
            // Make Array with page-structure to render in template             $numberOfPages = ceil(\count($getOrders) / $perPage);
        } else {
            $numberOfPages = 0;
        }
        $offset = ($destinationPage - 1) * $perPage;
        $orderData['orderData'] = \array_slice($getOrders, $offset, $perPage, true);
        $orderData['numberOfPages'] = $numberOfPages;
        $orderData['pages'] = $this->getPagerStructure($destinationPage, $numberOfPages);

        return $orderData;
    }

    /** * Get all orders for the current user * Used in the user account in the Frontend * * @param int $destinationPage * @param int $perPage * * @return array Array with order data / positions */

ob_start();
        imagepng($imgResource, null, 9);
        $img = (string) ob_get_clean();
        imagedestroy($imgResource);
        $img = base64_encode($img);

        /** @var string[] $sRandArray */
        $sRandArray = $this->container->get('session')->get(self::SESSION_KEY, []);

        $threshold = 51;
        if (\count($sRandArray) > $threshold) {
            $sRandArray = \array_slice($sRandArray, -$threshold);
        }

        $sRandArray[$string] = true;

        $this->container->get('session')->offsetSet(self::SESSION_KEY, $sRandArray);

        return ['img' => $img];
    }

    /** * {@inheritdoc} */

$deprecations = E_DEPRECATED | E_USER_DEPRECATED;

        return ($error & $deprecations) !== 0;
    }

    /** * @return true */
    private function handleDeprecationError(string $message, ?string $file = null, ?int $line = null): bool
    {
        // Remove the trace of the error handler.         $trace = array_slice(debug_backtrace(), 2);

        log_message(
            $this->config->deprecationLogLevel,
            "[DEPRECATED] {message} in {errFile} on line {errLine}.\n{trace}",
            [
                'message' => $message,
                'errFile' => clean_path($file ?? ''),
                'errLine' => $line ?? 0,
                'trace'   => self::renderBacktrace($trace),
            ]
        );

    $p = $params['parts'];
    // get the length of array     $listlen = \count($list);
    // calculate partsize     $partlen = floor($listlen / $p);
    $partrem = $listlen % $p;
    $partition = [];
    $mark = 0;
    // Split array in to chunks     for ($px = 0; $px < $p; ++$px) {
        $incr = ($px < $partrem) ? $partlen + 1 : $partlen;
        $partition[$px] = \array_slice($list, $mark, $incr);
        $mark += $incr;
    }
    $smarty->assign($params['assign'], $partition);
}

    if (!$form_state->isSubmitted() || $form_state->get('rerender')) {
      return $response;
    }

    // Sometimes we need to re-generate the form for multi-step type operations.     if (!empty($view->stack)) {
      $stack = $view->stack;
      $top = array_shift($stack);

      // Build the new form state for the next form in the stack.       $reflection = new \ReflectionClass($view::$forms[$top[1]]);
      $form_state = $reflection->newInstanceArgs(array_slice($top, 3, 2))->getFormState($view, $top[2], $form_state->get('ajax'));
      $form_class = get_class($form_state->getFormObject());

      $form_state->setUserInput([]);
      $form_url = views_ui_build_form_url($form_state);
      if (!$form_state->get('ajax')) {
        return new RedirectResponse($form_url->setAbsolute()->toString());
      }
      $form_state->set('url', $form_url);
      $response = $this->ajaxFormWrapper($form_class, $form_state);
    }
    elseif (!$form_state->get('ajax')) {

        if (!$this->styles) {
            return $this->emptyStyle;
        }

        if (null === $style) {
            return array_pop($this->styles);
        }

        foreach (array_reverse($this->styles, true) as $index => $stackedStyle) {
            if ($style->apply('') === $stackedStyle->apply('')) {
                $this->styles = \array_slice($this->styles, 0, $index);

                return $stackedStyle;
            }
        }

        throw new InvalidArgumentException('Incorrectly nested style tag found.');
    }

    /** * Computes current style with stacks top codes. */

private ?Stopwatch $stopwatch = null,
    ) {
        parent::__construct($statement);

        $this->query = new Query($sql);
    }

    public function bindParam($param, &$variable, $type = ParameterType::STRING, $length = null): bool
    {
        $this->query->setParam($param, $variable, $type);

        return parent::bindParam($param, $variable, $type, ...\array_slice(\func_get_args(), 3));
    }

    public function bindValue($param, $value, $type = ParameterType::STRING): bool
    {
        $this->query->setValue($param, $value, $type);

        return parent::bindValue($param, $value, $type);
    }

    public function execute($params = null): ResultInterface
    {

private function doResolveDefinition(ChildDefinition $definition): Definition
    {
        if (!$this->container->has($parent = $definition->getParent())) {
            throw new RuntimeException(sprintf('Parent definition "%s" does not exist.', $parent));
        }

        $searchKey = array_search($parent, $this->currentPath);
        $this->currentPath[] = $parent;

        if (false !== $searchKey) {
            throw new ServiceCircularReferenceException($parent, \array_slice($this->currentPath, $searchKey));
        }

        $parentDef = $this->container->findDefinition($parent);
        if ($parentDef instanceof ChildDefinition) {
            $id = $this->currentId;
            $this->currentId = $parent;
            $parentDef = $this->resolveDefinition($parentDef);
            $this->container->setDefinition($parent, $parentDef);
            $this->currentId = $id;
        }

    public function exec(Matches $matches)
    {
        $retMatches = array();
        foreach ($this->groups as $group) {
            $clonedMatches = $matches->createClone();
            $group->exec($clonedMatches);
            $retMatches[] = $clonedMatches;
        }
        if (count($retMatches) > 1) {
            $retMatches[0]->merge(array_slice($retMatches, 1));
        }
        return $retMatches[0];
    }
}

    public function findDefinition(string $id): Definition
    {
        $seen = [];
        while (isset($this->aliasDefinitions[$id])) {
            $id = (string) $this->aliasDefinitions[$id];

            if (isset($seen[$id])) {
                $seen = array_values($seen);
                $seen = \array_slice($seen, array_search($id, $seen));
                $seen[] = $id;

                throw new ServiceCircularReferenceException($id, $seen);
            }

            $seen[$id] = $id;
        }

        return $this->getDefinition($id);
    }

'JWT generation requires customer to be logged in'
        );
    }

    /** * @param array<string> $features */
    public static function appSecretRequiredForFeatures(string $appName, array $features): self
    {
        $featuresAsString = \count($features) < 3
            ? implode(' and ', $features)
            : sprintf('%s and %s', implode(', ', \array_slice($features, 0, -1)), array_pop($features));

        return new self(
            Response::HTTP_BAD_REQUEST,
            self::FEATURES_REQUIRE_APP_SECRET,
            'App "{{ appName }}" could not be installed/updated because it uses features {{ features }} but has no secret',
            ['appName' => $appName, 'features' => $featuresAsString],
        );
    }

    public static function actionButtonProcessException(string $actionId, string $message, ?\Throwable $e = null): self
    {

// Locate the index of $template (without the theme directory path) in $templates.         $relative_template_path = str_replace(
            array( get_stylesheet_directory() . '/', get_template_directory() . '/' ),
            '',
            $template
        );
        $index                  = array_search( $relative_template_path, $templates, true );

        // If the template hierarchy algorithm has successfully located a PHP template file,         // we will only consider block templates with higher or equal specificity.         $templates = array_slice( $templates, 0, $index + 1 );
    }

    $block_template = resolve_block_template( $type, $templates, $template );

    if ( $block_template ) {
        $_wp_current_template_id = $block_template->id;

        if ( empty( $block_template->content ) && is_user_logged_in() ) {
            $_wp_current_template_content =
            sprintf(
                /* translators: %s: Template title */