in_array - PHP code example

PHP Function In_Array

PHP arrays are very versatile and powerful data types which can be used in a wide range of programming scenarios. As such, there are many functions in the PHP language for working with arrays including adding and removing elements, sorting, searching, merging etc. In this article we will discuss the php function in_array, a very useful and time saving function which can be used to search an array for a given value.

The in_array function searches the given value in an array and returns a boolean value of true or false. The value being searched can be a string or an integer. If the search parameter is a string, it will be compared with values in the array in a case sensitive manner. If the search parameter is an integer, it will be compared with values in an array using loose comparison. If the third parameter strict is set to True, in_array will also check and compare the types of the values being searched.

The in_array function is a very handy and time saving function which can be used to save valuable CPU cycles in large scale projects. When used with a small array it can even be faster than PHP's built in array_search function which takes on average 1.346 seconds to search a 1000 element array for a value. Moreover, if the in_array function is being used in strict mode it can be even faster as it will also compare and check the types of the values being searched.

in_array example

$globalOptions = [
            'help',
            'quiet',
            'verbose',
            'version',
            'ansi',
            'no-interaction',
        ];
        $nonDefaultOptions = [];
        foreach ($definition->getOptions() as $option) {
            // Skip global options.             if (!\in_array($option->getName(), $globalOptions)) {
                $nonDefaultOptions[] = $option;
            }
        }

        return $nonDefaultOptions;
    }

    private function setVisibleNamespaces(ApplicationDescription $description): void
    {
        $commands = $description->getCommands();
        foreach ($description->getNamespaces() as $namespace) {

/** * {@inheritdoc} */
  public function prepareRow(Row $row) {
    $row->setSourceProperty('teaser_length', $this->teaserLength);
    $row->setSourceProperty('node_preview', $this->nodePreview);

    $type = $row->getSourceProperty('type');
    $source_options = $this->variableGet('node_options_' . $type, ['promote', 'sticky']);
    $options = [];
    foreach (['promote', 'sticky', 'status', 'revision'] as $item) {
      $options[$item] = in_array($item, $source_options);
    }
    $row->setSourceProperty('options', $options);
    $submitted = $this->themeSettings['toggle_node_info_' . $type] ?? FALSE;
    $row->setSourceProperty('display_submitted', $submitted);

    if ($default_node_menu = $this->variableGet('menu_default_node_menu', NULL)) {
      $row->setSourceProperty('available_menus', [$default_node_menu]);
      $row->setSourceProperty('parent', $default_node_menu . ':');
    }

    if ($this->moduleExists('comment')) {

throw new RuntimeException('Matching failed with error: '.preg_last_error_msg());
            }
        } finally {
            restore_error_handler();
        }

        return $matches;
    }

    public function normalize(int $form = self::NFC): static
    {
        if (!\in_array($form, [self::NFC, self::NFD, self::NFKC, self::NFKD])) {
            throw new InvalidArgumentException('Unsupported normalization form.');
        }

        $str = clone $this;
        normalizer_is_normalized($str->string, $form) ?: $str->string = normalizer_normalize($str->string, $form);

        return $str;
    }

    public function padBoth(int $length, string $padStr = ' '): static
    {

    public function do_item( $handle, $group = false ) {
        if ( ! parent::do_item( $handle ) ) {
            return false;
        }

        if ( 0 === $group && $this->groups[ $handle ] > 0 ) {
            $this->in_footer[] = $handle;
            return false;
        }

        if ( false === $group && in_array( $handle, $this->in_footer, true ) ) {
            $this->in_footer = array_diff( $this->in_footer, (array) $handle );
        }

        $obj = $this->registered[ $handle ];

        if ( null === $obj->ver ) {
            $ver = '';
        } else {
            $ver = $obj->ver ? $obj->ver : $this->default_version;
        }

    }

    public function triggerChangeSet(PreWriteValidationEvent $event): void
    {
        $associatedEntities = $this->getAssociationEntities();

        foreach ($event->getCommands() as $command) {
            $definition = $command->getDefinition();
            $entity = $definition->getEntityName();

            if (!$command instanceof ChangeSetAware || !\in_array($entity, $associatedEntities, true)) {
                continue;
            }

            if ($command instanceof DeleteCommand) {
                $command->requestChangeSet();

                continue;
            }

            foreach ($this->getForeignKeyFields($definition) as $field) {
                if ($command->hasField($field->getStorageName())) {

$alias = $columnEntry[2];

            if ($alias !== null) {
                $column = $alias;
            }

            switch (true) {
                case ($column == self::SQL_WILDCARD):
                    break;

                case ($column instanceof Zend_Db_Expr):
                case (!in_array($column, $cols)):
                    $readOnly = true;
                    break 2;
            }
        }

        return $readOnly;
    }

    /** * Adds a FROM table and optional columns to the query. * * The table name can be expressed * * @param array|string|Zend_Db_Expr|Zend_Db_Table_Abstract $name The table name or an associative array relating table name to correlation name. * @param array|string|Zend_Db_Expr $cols The columns to select from this table. * @param string $schema The schema name to specify, if any. * @return Zend_Db_Table_Select This Zend_Db_Table_Select object. */

protected function doProtectFields(array $data): array
    {
        if (! $this->protectFields) {
            return $data;
        }

        if (empty($this->allowedFields)) {
            throw DataException::forInvalidAllowedFields(static::class);
        }

        foreach (array_keys($data) as $key) {
            if (! in_array($key, $this->allowedFields, true)) {
                unset($data[$key]);
            }
        }

        return $data;
    }

    /** * Ensures that only the fields that are allowed to be inserted are in * the data array. * * Used by insert() and insertBatch() to protect against mass assignment * vulnerabilities. * * @param array $data Data * * @throws DataException */

        foreach ($files as $file) {
            if ($file === null) {
                return false;
            }

            if ($file->getError() === UPLOAD_ERR_NO_FILE) {
                return true;
            }

            if (! in_array($file->getMimeType(), $params, true)) {
                return false;
            }
        }

        return true;
    }

    /** * Checks to see if an uploaded file's extension matches one in the parameter. */
    public function ext_in(?string $blank, string $params): bool
    {

class FileExtensionEscapingStrategy
{
    /** * Guesses the best autoescaping strategy based on the file name. * * @param string $name The template name * * @return string|false The escaping strategy name to use or false to disable */
    public static function guess(string $name)
    {
        if (\in_array(substr($name, -1), ['/', '\\'])) {
            return 'html'; // return html for directories         }

        if ('.twig' === substr($name, -5)) {
            $name = substr($name, 0, -5);
        }

        $extension = pathinfo($name, \PATHINFO_EXTENSION);

        switch ($extension) {
            case 'js':

$content = $client->getResponse()->getContent();
        static::assertNotFalse($content);
        static::assertJson($content);

        $response = json_decode($content, true);

        static::assertSame(200, $client->getResponse()->getStatusCode());

        foreach ($response as $event) {
            if ($event['name'] === 'mail.after.create.message' || $event['name'] === 'mail.before.send' || $event['name'] === 'mail.sent') {
                static::assertFalse(\in_array('Shopware\Core\Framework\Event\MailAware', $event['aware'], true));

                continue;
            }

            static::assertTrue(\in_array('Shopware\Core\Framework\Event\MailAware', $event['aware'], true));
            static::assertFalse(\in_array('Shopware\Core\Framework\Event\MailActionInterface', $event['aware'], true));
        }
    }

    public function testFlowBusinessEventRouteHasAppFlowEvents(): void
    {

    public function withSameSite(?string $sameSite): static
    {
        if ('' === $sameSite) {
            $sameSite = null;
        } elseif (null !== $sameSite) {
            $sameSite = strtolower($sameSite);
        }

        if (!\in_array($sameSite, [self::SAMESITE_LAX, self::SAMESITE_STRICT, self::SAMESITE_NONE, null], true)) {
            throw new \InvalidArgumentException('The "sameSite" parameter value is not valid.');
        }

        $cookie = clone $this;
        $cookie->sameSite = $sameSite;

        return $cookie;
    }

    /** * Returns the cookie as a string. */

$view_settings = $this->getConfiguration()['view'];
    $displays = Views::getApplicableViews('entity_reference_display');
    // Filter views that list the entity type we want, and group the separate     // displays by view.     $entity_type = $this->entityTypeManager->getDefinition($this->configuration['target_type']);
    $view_storage = $this->entityTypeManager->getStorage('view');

    $options = [];
    foreach ($displays as $data) {
      [$view_id, $display_id] = $data;
      $view = $view_storage->load($view_id);
      if (in_array($view->get('base_table'), [$entity_type->getBaseTable(), $entity_type->getDataTable()])) {
        $display = $view->get('display');
        $options[$view_id . ':' . $display_id] = $view_id . ' - ' . $display[$display_id]['display_title'];
      }
    }

    // The value of the 'view_and_display' select below will need to be split     // into 'view_name' and 'view_display' in the final submitted values, so     // we massage the data at validate time on the wrapping element (not     // ideal).     $form['view']['#element_validate'] = [[static::class, 'settingsFormValidate']];

/** * {@inheritdoc} */
  public function condition($field, $value = NULL, $operator = '=') {
    if (empty($operator)) {
      $operator = '=';
    }
    if (empty($value) && is_array($value)) {
      throw new InvalidQueryException(sprintf("Query condition '%s %s ()' cannot be empty.", $field, $operator));
    }
    if (is_array($value) && in_array($operator, ['=', '<', '>', '<=', '>=', 'IS NULL', 'IS NOT NULL'], TRUE)) {
      if (count($value) > 1) {
        $value = implode(', ', $value);
        throw new InvalidQueryException(sprintf("Query condition '%s %s %s' must have an array compatible operator.", $field, $operator, $value));
      }
      else {
        $value = $value[0];
        @trigger_error('Calling ' . __METHOD__ . '() without an array compatible operator is deprecated in drupal:10.1.0 and will be required in drupal:11.0.0. See https://www.drupal.org/node/3350985', E_USER_DEPRECATED);
      }
    }

    $this->conditions[] = [

    public function toUnicodeString(string $fromEncoding = null): UnicodeString
    {
        return new UnicodeString($this->toCodePointString($fromEncoding)->string);
    }

    public function toCodePointString(string $fromEncoding = null): CodePointString
    {
        $u = new CodePointString();

        if (\in_array($fromEncoding, [null, 'utf8', 'utf-8', 'UTF8', 'UTF-8'], true) && preg_match('//u', $this->string)) {
            $u->string = $this->string;

            return $u;
        }

        set_error_handler(static fn ($t, $m) => throw new InvalidArgumentException($m));

        try {
            try {
                $validEncoding = false !== mb_detect_encoding($this->string, $fromEncoding ?? 'Windows-1252', true);
            } catch (InvalidArgumentException $e) {

/** * Creates iterator for errors with specific codes. * * @param string|string[] $codes The codes to find */
    public function findByCodes(string|array $codes): static
    {
        $codes = (array) $codes;
        $violations = [];
        foreach ($this as $violation) {
            if (\in_array($violation->getCode(), $codes, true)) {
                $violations[] = $violation;
            }
        }

        return new static($violations);
    }
}