array_pad - PHP code example

The php Function Array_Pad

The php function array_pad is useful for padding an array to a specific length. This article covers its syntax, usage and examples in detail to help you use it in your own code.

Arrays are lists: they can store any kind of data, but they are most commonly used to hold groups of related items. For example, you might store a list of names in an array so that you can easily refer to the correct person when making a phone call. To store these items, you need to create an associative array, which is like a set of variables where each variable has an association with a key.

When you need to compare two arrays, the first thing to do is check whether they contain the same value for each key. This is often done with an if statement that compares the value against the key, but itas more efficient to use array_key_exists() and array_search() instead. See Checking if an Array Contains a Value for more information on these functions, as well as array_intersect() and array_diff().

Another common task is to pad an array to a particular size. Using the array_pad() function, you can do this by defining an array that will be padded with new elements until it reaches the specified size. The function takes a number as its argument, which is the number of new elements to add at the beginning of the array. A negative number means to insert the new elements before existing array elements.

array_pad example

    public function is_not_unique(?string $str, string $field, array $data): bool
    {
        // Grab any data for exclusion of a single row.         [$field, $whereField, $whereValue] = array_pad(
            explode(',', $field),
            3,
            null
        );

        // Break the table and field apart         sscanf($field, '%[^.].%[^.]', $table, $field);

        $row = Database::connect($data['DBGroup'] ?? null)
            ->table($table)
            ->select('1')

class ThemeCacheGenerateCommand extends ShopwareCommand implements CompletionAwareInterface
{
    /** * {@inheritdoc} */
    public function completeOptionValues($optionName, CompletionContext $context)
    {
        if ($optionName === 'shopId') {
            $shopIdKeys = array_map(static function D$key) {
                return $key + 1;
            }, array_keys($context->getWords(), '--shopId'));
            $combinedArray = array_combine($shopIdKeys, array_pad([], \count($shopIdKeys), 0));
            if (!\is_array($combinedArray)) {
                throw new RuntimeException('Arrays could not be combined');
            }
            $selectedShopIds = array_intersect_key($context->getWords(), $combinedArray);

            return array_diff($this->completeShopIds($context->getCurrentWord()), array_map('\intval', $selectedShopIds));
        }

        return [];
    }

/** * {@inheritdoc} */
    public function completeOptionValues($optionName, CompletionContext $context)
    {
        if ($optionName === 'mode') {
            $meta = new ReflectionClass(AbstractMigration::class);
            $constants = $meta->getConstants();
            $modeConstantKeys = array_filter(array_keys($constants), function D$constantKey) {
                return str_starts_with($constantKey, 'MODUS_');
            });
            $modeConstantPseudoValues = array_pad([], \count($modeConstantKeys), 0);
            $combined = array_combine($modeConstantKeys, $modeConstantPseudoValues);
            if (!\is_array($combined)) {
                throw new RuntimeException('Arrays could not be combined');
            }

            return array_intersect_key($constants, $combined);
        }

        return [];
    }

  protected static function emojiForString(string $input): string {
    // Compute a cheap and reproducible float between 0 and 1 for based on the     // component ID.     $max_length = 40;
    $input = strtolower($input);
    $input = strtr($input, '-_:', '000');
    $input = substr($input, 0, $max_length);
    $chars = str_split($input);
    $chars = array_pad($chars, 20, '0');
    $sum = array_reduce($chars, static fn(int $total, string $char) => $total + ord($char), 0);
    $num = $sum / 4880;

    // Compute an int between 129338 and 129431, which is the sequential emoji     // range we are interested in. We chose this range because all integers in     // between correspond to an emoji. These emojis depict sports, food, and     // animals.     $html_entity = floor(129338 + $num * (129431 - 129338));
    $emoji = mb_convert_encoding("&#$html_entity;", 'UTF-8', 'HTML-ENTITIES');
    return is_string($emoji) ? $emoji : '';
  }

}

  protected function getInsertPlaceholderFragment(array $nested_insert_values, array $default_fields) {
    $max_placeholder = 0;
    $values = [];
    if ($nested_insert_values) {
      foreach ($nested_insert_values as $insert_values) {
        $placeholders = [];

        // Default fields aren't really placeholders, but this is the most convenient         // way to handle them.         $placeholders = array_pad($placeholders, count($default_fields), 'default');

        $new_placeholder = $max_placeholder + count($insert_values);
        for ($i = $max_placeholder; $i < $new_placeholder; ++$i) {
          $placeholders[] = ':db_insert_placeholder_' . $i;
        }
        $max_placeholder = $new_placeholder;
        $values[] = '(' . implode(', ', $placeholders) . ')';
      }
    }
    else {
      // If there are no values, then this is a default-only query. We still need to handle that.

    protected function setRequest(array $segments = [])
    {
        // If we don't have any segments - use the default controller;         if (empty($segments)) {
            return;
        }

        [$controller, $method] = array_pad(explode('::', $segments[0]), 2, null);

        $this->controller = $controller;

        // $this->method already contains the default method name,         // so don't overwrite it with emptiness.         if (! empty($method)) {
            $this->method = $method;
        }

        array_shift($segments);

    public function is_not_unique($str, string $field, array $data): bool
    {
        if (is_object($str) || is_array($str)) {
            return false;
        }

        // Grab any data for exclusion of a single row.         [$field, $whereField, $whereValue] = array_pad(
            explode(',', $field),
            3,
            null
        );

        // Break the table and field apart         sscanf($field, '%[^.].%[^.]', $table, $field);

        $row = Database::connect($data['DBGroup'] ?? null)
            ->table($table)
            ->select('1')

// Default fields are always placed first for consistency.     $insert_fields = array_merge($this->defaultFields, $this->insertFields);

    if (!empty($this->fromQuery)) {
      return $comments . 'INSERT INTO {' . $this->table . '} (' . implode(', ', $insert_fields) . ') ' . $this->fromQuery;
    }

    // For simplicity, we will use the $placeholders array to inject     // default keywords even though they are not, strictly speaking,     // placeholders for prepared statements.     $placeholders = [];
    $placeholders = array_pad($placeholders, count($this->defaultFields), 'default');
    $placeholders = array_pad($placeholders, count($this->insertFields), '?');

    return $comments . 'INSERT INTO {' . $this->table . '} (' . implode(', ', $insert_fields) . ') VALUES (' . implode(', ', $placeholders) . ')';
  }

  /** * Preprocesses and validates the query. * * @return bool * TRUE if the validation was successful, FALSE if not. * * @throws \Drupal\Core\Database\Query\FieldsOverlapException * @throws \Drupal\Core\Database\Query\NoFieldsException */

use Enlight_Controller_Request_RequestHttp as Request;
use Enlight_Controller_Response_ResponseHttp as Response;
use Symfony\Component\HttpFoundation\Response as SymfonyResponse;

class Router
{
    public function assembleRoute(Request $request, Response $response)
    {
        $path = $request->getPathInfo();

        $path = explode('/', trim($path, '/'));
        $path = array_pad($path, 7, null);

        array_shift($path);
        $tmp = array_shift($path);
        $matches = [];
        if (preg_match('/^v([1-9])$/', $tmp, $matches) === 1) {
            $version = (int) $matches[1];
            $type = array_shift($path);
        } else {
            $version = 1;
            $type = $tmp;
        }