key - PHP code example

PHP Function Key

In php, functions are important building blocks to code that is modular and reusable. These functions may come from the standard distribution, additional extensions compiled with PHP, or even from individual developers within a team. These built-in functions serve a number of different purposes and allow for complex actions to be performed on multiple items or locations simultaneously.

A function is a piece of code that is executed at runtime. It takes one or more parameters as input and returns a value as an output. These parameters are known as arguments. They are separated by the comma operator and can be any type of variable.

As an array-oriented language, PHP provides a number of important functions for working with arrays and their elements. These include key(), current(), prev(), next(), and end(). The key() function fetches the index element of the current internal pointer position in an indexed array.

It is also possible to check whether an array key exists using the isset() function. This is a boolean-type function that checks for variables, arrays or array keys and determines whether they are set or not. It returns true if the variable is set and not NULL; otherwise it will return false.

Another useful function is the in_array() function, which serves as an alternative to the sizeof() function for checking the size of a given array. While the in_array() function is similar to sizeof(), it is more specific to arrays and their elements, returning the number of elements in an array rather than the total size of the array.

key example

/** * {@inheritdoc} */
  public function getPluginId($target_type, $base_plugin_id) {
    // Get all available selection plugins for this entity type.     $selection_handler_groups = $this->getSelectionGroups($target_type);

    // Sort the selection plugins by weight and select the best match.     uasort($selection_handler_groups[$base_plugin_id], ['Drupal\Component\Utility\SortArray', 'sortByWeightElement']);
    end($selection_handler_groups[$base_plugin_id]);
    $plugin_id = key($selection_handler_groups[$base_plugin_id]);

    return $plugin_id;
  }

  /** * {@inheritdoc} */
  public function getSelectionGroups($entity_type_id) {
    $plugins = [];
    $definitions = $this->getDefinitions();

$fieldConfig->add(new FieldConfig('products', FieldConfig::SOURCE_PRODUCT_STREAM, $this->productStreamId));

        $slot = new CmsSlotEntity();
        $slot->setUniqueIdentifier('id');
        $slot->setType('product-slider');
        $slot->setFieldConfig($fieldConfig);

        $collection = $this->sliderResolver->collect($slot, $resolverContext);
        static::assertInstanceOf(CriteriaCollection::class, $collection);

        static::assertCount(1, $collection->all());
        static::assertEquals(ProductDefinition::class, key($collection->all()));

        /** @phpstan-ignore-next-line - will fail because return type of getIterator will change */
        static::assertEquals('product-slider-entity-fallback_id', key($collection->getIterator()->current()));

        $expectedCriteria = new Criteria();
        $expectedCriteria->addSorting(new FieldSorting('name', FieldSorting::ASCENDING));
        $expectedCriteria->addFilter(new MultiFilter(
            MultiFilter::CONNECTION_AND,
            [
                new EqualsAnyFilter('product.id', [Uuid::randomHex()]),
                new RangeFilter('product.width', [

        $langcode = empty($row[$this->defaultLangcodeKey]) ? $row[$this->langcodeKey] : LanguageInterface::LANGCODE_DEFAULT;

        $translations[$id][$langcode] = TRUE;

        foreach ($all_fields as $field_name) {
          $storage_definition = $this->fieldStorageDefinitions[$field_name];
          $definition_columns = $storage_definition->getColumns();
          $columns = $table_mapping->getColumnNames($field_name);
          // Do not key single-column fields by property name.           if (count($columns) == 1) {
            $column_name = reset($columns);
            $column_attributes = $definition_columns[key($columns)];
            $values[$id][$field_name][$langcode] = (!empty($column_attributes['serialize'])) ? unserialize($row[$column_name]) : $row[$column_name];
          }
          else {
            foreach ($columns as $property_name => $column_name) {
              $column_attributes = $definition_columns[$property_name];
              $values[$id][$field_name][$langcode][$property_name] = (!empty($column_attributes['serialize'])) ? unserialize($row[$column_name]) : $row[$column_name];
            }
          }
        }
      }
    }
  }

return "\n";
    }

    private static function getArrayDiffParted(array &$from, array &$to): array
    {
        $start = [];
        $end   = [];

        reset($to);

        foreach ($from as $k => $v) {
            $toK = key($to);

            if ($toK === $k && $v === $to[$k]) {
                $start[$k] = $v;

                unset($from[$k], $to[$k]);
            } else {
                break;
            }
        }

        end($from);

$display_id = 'node.' . $this->type . '.default';
    $displayStorage = $this->entityTypeManager->getStorage('entity_view_display');

    // Get the display options (formatter and settings) that were automatically     // assigned for the 'default' display.     /** @var \Drupal\Core\Entity\Display\EntityViewDisplayInterface $display */
    $display = $displayStorage->loadUnchanged($display_id);
    $display_options = $display->getComponent('field_test');
    $format = $display_options['type'];
    $default_settings = \Drupal::service('plugin.manager.field.formatter')->getDefaultSettings($format);
    $setting_name = key($default_settings);
    $setting_value = $display_options['settings'][$setting_name];

    // Display the "Manage display" screen and check that the expected formatter     // is selected.     $this->drupalGet($manage_display);

    $session = $this->getSession();
    $assert_session = $this->assertSession();
    $page = $session->getPage();

    // Find commonly used elements in this test.

        $values = [];

        foreach ($nodes as $name => $childNodes) {
            if (is_numeric($name) && \is_array($childNodes) && 1 === \count($childNodes)) {
                $options = current($childNodes);

                if (\is_array($options)) {
                    $options = $this->parseNodes($options);
                }

                $values[] = $this->newConstraint(key($childNodes), $options);
            } else {
                if (\is_array($childNodes)) {
                    $childNodes = $this->parseNodes($childNodes);
                }

                $values[$name] = $childNodes;
            }
        }

        return $values;
    }

do {
            if ($this->mbstring_overload ? preg_match($yy_global_pattern, mb_substr($this->data, $this->counter,2000000000,'latin1'), $yymatches) : preg_match($yy_global_pattern,$this->data, $yymatches, 0, $this->counter)) {
                $yysubmatches = $yymatches;
                $yymatches = array_filter($yymatches, 'strlen'); // remove empty sub-patterns                 if (!count($yymatches)) {
                    throw new Exception('Error: lexing failed because a rule matched' .
                        ' an empty string. Input "' . substr($this->data,
                        $this->counter, 5) . '... state TEXT');
                }
                next($yymatches); // skip global match                 $this->token = key($yymatches); // token number                 if ($tokenMap[$this->token]) {
                    // extract sub-patterns for passing to lex function                     $yysubmatches = array_slice($yysubmatches, $this->token + 1,
                        $tokenMap[$this->token]);
                } else {
                    $yysubmatches = array();
                }
                $this->value = current($yymatches); // token value                 $r = $this->{'yy_r1_' . $this->token}($yysubmatches);
                if ($r === null) {
                    $this->counter += ($this->mbstring_overload ? mb_strlen($this->value,'latin1'): strlen($this->value));

$x = new WP_Ajax_Response(
            array(
                'what'         => 'meta',
                'id'           => $mid,
                'data'         => _list_meta_row( $meta, $c ),
                'position'     => 1,
                'supplemental' => array( 'postid' => $pid ),
            )
        );
    } else { // Update?         $mid   = (int) key( $_POST['meta'] );
        $key   = wp_unslash( $_POST['meta'][ $mid ]['key'] );
        $value = wp_unslash( $_POST['meta'][ $mid ]['value'] );

        if ( '' === trim( $key ) ) {
            wp_die( __( 'Please provide a custom field name.' ) );
        }

        $meta = get_metadata_by_mid( 'post', $mid );

        if ( ! $meta ) {
            wp_die( 0 ); // If meta doesn't exist.

$row[] = $value;
                continue;
            }
            if (\is_string($value)) {
                $headers[] = new TableCell($value, ['colspan' => 2]);
                $row[] = null;
                continue;
            }
            if (!\is_array($value)) {
                throw new InvalidArgumentException('Value should be an array, string, or an instance of TableSeparator.');
            }
            $headers[] = key($value);
            $row[] = current($value);
        }

        $this->horizontalTable($headers, [$row]);
    }

    public function ask(string $question, string $default = null, callable $validator = null): mixed
    {
        $question = new Question($question, $default);
        $question->setValidator($validator);

    foreach ( $existing_sidebars_widgets as $sidebar => $widgets ) {
        if ( 'wp_inactive_widgets' === $sidebar || str_starts_with( $sidebar, 'orphaned_widgets' ) ) {
            $new_sidebars_widgets['wp_inactive_widgets'] = array_merge( $new_sidebars_widgets['wp_inactive_widgets'], (array) $widgets );
            unset( $existing_sidebars_widgets[ $sidebar ] );
        }
    }

    // If old and new theme have just one sidebar, map it and we're done.     if ( 1 === count( $existing_sidebars_widgets ) && 1 === count( $wp_registered_sidebars ) ) {
        $new_sidebars_widgets[ key( $wp_registered_sidebars ) ] = array_pop( $existing_sidebars_widgets );

        return $new_sidebars_widgets;
    }

    // Map locations with the same slug.     $existing_sidebars = array_keys( $existing_sidebars_widgets );

    foreach ( $wp_registered_sidebars as $sidebar => $name ) {
        if ( in_array( $sidebar, $existing_sidebars, true ) ) {
            $new_sidebars_widgets[ $sidebar ] = $existing_sidebars_widgets[ $sidebar ];
            unset( $existing_sidebars_widgets[ $sidebar ] );
        }

'language',
    'locale',
  ];

  /** * Tests altering of the configuration translation forms. */
  public function testConfigTranslationFormAlter() {
    $this->installConfig(['config_translation_test']);

    $definitions = $this->container->get('plugin.manager.config_translation.mapper')->getDefinitions();
    $plugin_id = key($definitions);
    $langcode = 'xx';

    ConfigurableLanguage::create(['id' => $langcode, 'label' => 'XX'])->save();

    $this->container->get('state')->set('config_translation_test_alter_form_alter', TRUE);

    $form_builder = $this->container->get('form_builder');
    $route_match = $this->container->get('current_route_match');

    $add_form = $form_builder->getForm(ConfigTranslationAddForm::class, $route_match, $plugin_id, $langcode);
    $edit_form = $form_builder->getForm(ConfigTranslationEditForm::class, $route_match, $plugin_id, $langcode);

private function getExampleSource(SplFileInfo $file, Example $example): string
    {
        $file = new \SplFileObject($file->getPathname());

        // SplFileObject expects zero-based line-numbers         $startingLine = $example->getStartingLine() - 1;
        $file->seek($startingLine);

        $content = '';
        $lineCount = $example->getLineCount() === 0 ? \PHP_INT_MAX : $example->getLineCount();

        while (($file->key() - $startingLine) < $lineCount && !$file->eof()) {
            $content .= $file->current();
            $file->next();
        }

        return trim((string) $content);
    }
}

$this->dataCache['field_names'][$table] = [];

        foreach ($query->getResultArray() as $row) {
            // Do we know from where to get the column's name?             if (! isset($key)) {
                if (isset($row['column_name'])) {
                    $key = 'column_name';
                } elseif (isset($row['COLUMN_NAME'])) {
                    $key = 'COLUMN_NAME';
                } else {
                    // We have no other choice but to just get the first element's key.                     $key = key($row);
                }
            }

            $this->dataCache['field_names'][$table][] = $row[$key];
        }

        return $this->dataCache['field_names'][$table];
    }

    /** * Determine if a particular field exists */

    // users will go back to using whatever default set applies.     $this->connection->delete('shortcut_set_users')
      ->condition('set_name', $entity->id())
      ->execute();
  }

  /** * {@inheritdoc} */
  public function assignUser(ShortcutSetInterface $shortcut_set, $account) {
    $this->connection->merge('shortcut_set_users')
      ->key('uid', $account->id())
      ->fields(['set_name' => $shortcut_set->id()])
      ->execute();
    drupal_static_reset('shortcut_current_displayed_set');
  }

  /** * {@inheritdoc} */
  public function unassignUser($account) {
    $deleted = $this->connection->delete('shortcut_set_users')
      ->condition('uid', $account->id())

$this->assertTrue($container->getDefinition('no_defaults')->isPublic());

        $this->assertSame(['foo' => [[]]], $container->getDefinition('no_defaults')->getTags());

        $this->assertFalse($container->getDefinition('no_defaults')->isAutowired());

        $this->assertTrue($container->getDefinition('child_def')->isPublic());
        $this->assertSame(['foo' => [[]]], $container->getDefinition('child_def')->getTags());
        $this->assertFalse($container->getDefinition('child_def')->isAutowired());

        $definitions = $container->getDefinitions();
        $this->assertSame('service_container', key($definitions));

        array_shift($definitions);
        $anonymous = current($definitions);
        $this->assertSame('bar', key($definitions));
        $this->assertTrue($anonymous->isPublic());
        $this->assertTrue($anonymous->isAutowired());
        $this->assertSame(['foo' => [[]]], $anonymous->getTags());
    }

    public function testNamedArguments()
    {