array_diff - PHP code example

PHP Function Array_Diff

The php function array_diff is an important one that every software developer should be familiar with. It helps in comparing arrays and finding the differences between them. This article will give you a thorough overview of php function array_diff along with some examples and practical applications of this useful function.

The array_diff() function compares the values of an input array against multiple other arrays and returns all the entries from the first array that are not present in any of the other arrays. You can pass any number of arrays to the function for comparison. The function also has a sister function called array_diff_key that works similar to the array_diff but compares keys instead of values.

Both functions are quite useful in their own way and have their uses for different scenarios. It is recommended to use the php function array_diff rather than php function array_intersect as it is less memory intensive.

In addition to the above, another feature of the array_diff function is that it compares elements based on their string representation. This means that 1 and '1' are considered equal for the function. Another important aspect is that it ignores the number of times a value occurs in the input array. This is useful when working with multidimensional arrays as it saves time compared to performing a comparison on each dimension individually.

The function also accepts associative keys like 'b' => 'banana that can be used for comparison of arrays. This is similar to the way php function array_assoc works.

array_diff example

  protected function getPostDocument() {
    // @todo Update once https://www.drupal.org/node/2300677 is fixed.     return [];
  }

  /** * {@inheritdoc} */
  protected function getExpectedCacheContexts(array $sparse_fieldset = NULL) {
    // @see ::createEntity()     return array_values(array_diff(parent::getExpectedCacheContexts(), ['user.permissions']));
  }

  /** * {@inheritdoc} */
  protected function getExpectedCacheTags(array $sparse_fieldset = NULL) {
    // Because the 'user.permissions' cache context is missing, the cache tag     // for the anonymous user role is never added automatically.     return array_values(array_diff(parent::getExpectedCacheTags(), ['config:user.role.anonymous']));
  }

'flopimage',
            'readimage',
            'readimageblob',
        );

        // Now, test for deep requirements within Imagick.         if ( ! defined( 'imagick::COMPRESSION_JPEG' ) ) {
            return false;
        }

        $class_methods = array_map( 'strtolower', get_class_methods( 'Imagick' ) );
        if ( array_diff( $required_methods, $class_methods ) ) {
            return false;
        }

        return true;
    }

    /** * Checks to see if editor supports the mime-type specified. * * @since 3.5.0 * * @param string $mime_type * @return bool */

$is_fieldable = $entity_type->entityClassImplements(FieldableEntityInterface::class);
    if ($is_fieldable) {
      $field_definitions = $this->entityFieldManager->getFieldDefinitions($entity_type->id(), $bundle);
    }

    // For all other fields, use their internal field name also as their public     // field name. Unless they're called "id" or "type": those names are     // reserved by the JSON:API spec.     // @see http://jsonapi.org/format/#document-resource-object-fields     $reserved_field_names = ['id', 'type'];
    foreach (array_diff($field_names, array_keys($fields)) as $field_name) {
      $alias = $field_name;
      // Alias the fields reserved by the JSON:API spec with `{entity_type}_`.       if (in_array($field_name, $reserved_field_names, TRUE)) {
        $alias = $entity_type->id() . '_' . $field_name;
      }

      // The default, which applies to most fields: expose as-is.       $field_definition = $is_fieldable && !empty($field_definitions[$field_name]) ? $field_definitions[$field_name] : NULL;
      $is_relationship_field = $field_definition && static::isReferenceFieldDefinition($field_definition);
      $has_one = !$field_definition || $field_definition->getFieldStorageDefinition()->getCardinality() === 1;
      $fields[$field_name] = $is_relationship_field
        ?

  protected static function replaceStorageContents(StorageInterface $source, StorageInterface &$target) {
    // Remove all collections from the target which are not in the source.     foreach (array_diff($target->getAllCollectionNames(), $source->getAllCollectionNames()) as $collection) {
      // We do this first so we don't have to loop over the added collections.       $target->createCollection($collection)->deleteAll();
    }
    // Copy all the configuration from all the collections.     foreach (array_merge([StorageInterface::DEFAULT_COLLECTION], $source->getAllCollectionNames()) as $collection) {
      $source_collection = $source->createCollection($collection);
      $target_collection = $target->createCollection($collection);
      $names = $source_collection->listAll();
      // First we delete all the config which shouldn't be in the target.       foreach (array_diff($target_collection->listAll(), $names) as $name) {
        $target_collection->delete($name);
      }

$dataRaw = @parse_ini_file($entry->getRealPath(), true, INI_SCANNER_RAW);

            if ($dataRaw === false) {
                $error = error_get_last();
                if (\is_array($error)) {
                    $invalidSnippets[] = $error['message'] . ' (' . $entry->getRealPath() . ')';
                } else {
                    $invalidSnippets[] = 'Unknown error (' . $entry->getRealPath() . ')';
                }
            } else {
                $diffGroups = array_diff(array_keys($data), $validLocales);
                if (\array_key_exists('default', $data)) {
                    $invalidSnippets[] = '"Default" snippet group is deprecated (' . $entry->getRealPath() . ')';
                } elseif ($diffGroups) {
                    $invalidSnippets[] = sprintf(
                        'Invalid snippet group(s): %s (%s)',
                        implode(', ', $diffGroups),
                        $entry->getRealPath()
                    );
                }
            }
        }

                unset($customFields[$customFieldName]);

                break;
            case 'add':
                if (empty($customFieldValue)) {
                    return null;
                }

                $customFields[$customFieldName] = (array) ($customFields[$customFieldName] ?? []);
                $addData = array_diff((array) $customFieldValue, $customFields[$customFieldName]);

                if (empty($addData)) {
                    return null;
                }

                $customFields[$customFieldName] = array_merge($customFields[$customFieldName], $addData);

                break;
            case 'remove':
                if (!isset($customFields[$customFieldName]) || empty($customFieldValue)) {
                    return null;
                }

// Forum has an extra step to be able to uninstall it.         $this->preUninstallForum();
      }

      // Delete all workspaces before uninstall.       if ($name == 'workspaces') {
        $workspaces = Workspace::loadMultiple();
        \Drupal::entityTypeManager()->getStorage('workspace')->delete($workspaces);
      }

      $now_installed_list = \Drupal::moduleHandler()->getModuleList();
      $added_modules = array_diff(array_keys($now_installed_list), array_keys($was_installed_list));
      while ($added_modules) {
        $initial_count = count($added_modules);
        foreach ($added_modules as $to_uninstall) {
          // See if we can currently uninstall this module (if its dependencies           // have been uninstalled), and do so if we can.           $this->drupalGet('admin/modules/uninstall');
          $checkbox = $this->assertSession()->fieldExists("uninstall[$to_uninstall]");
          if (!$checkbox->hasAttribute('disabled')) {
            // This one is eligible for being uninstalled.             $package = $all_modules[$to_uninstall]->info['package'];
            $this->assertSuccessfulUninstall($to_uninstall, $package);

    public function establish_loaded_changeset() {
        global $pagenow;

        if ( empty( $this->_changeset_uuid ) ) {
            $changeset_uuid = null;

            if ( ! $this->branching() && $this->is_theme_active() ) {
                $unpublished_changeset_posts = $this->get_changeset_posts(
                    array(
                        'post_status'               => array_diff( get_post_stati(), array( 'auto-draft', 'publish', 'trash', 'inherit', 'private' ) ),
                        'exclude_restore_dismissed' => false,
                        'author'                    => 'any',
                        'posts_per_page'            => 1,
                        'order'                     => 'DESC',
                        'orderby'                   => 'date',
                    )
                );
                $unpublished_changeset_post  = array_shift( $unpublished_changeset_posts );
                if ( ! empty( $unpublished_changeset_post ) && wp_is_uuid( $unpublished_changeset_post->post_name ) ) {
                    $changeset_uuid = $unpublished_changeset_post->post_name;
                }
            }

// Check that we have an array of data.     $this->assertIsArray($this->definitions);

    // Check all plugin types.     foreach ($this->pluginTypes as $type) {
      $this->assertArrayHasKey($type, $this->definitions);
      $this->assertIsArray($this->definitions[$type]);
      $this->assertNotEmpty($this->definitions[$type], "Plugin type '$type' should contain plugins.");
    }

    // Tests that the plugin list has not missed any types.     $diff = array_diff(array_keys($this->definitions), $this->pluginTypes);
    $this->assertEmpty($diff, 'All plugins were found and matched.');
  }

  /** * Tests creating instances of every views plugin. * * This will iterate through all plugins from _views_fetch_plugin_data(), * filtering out deprecated plugins. */
  public function testPluginInstances() {
    $this->assertPluginInstances(FALSE);
  }

/** * List of available options: * * prefix: The prefix to use for the keys in order to avoid collision on the Redis server * * ttl: The time to live in seconds. * * @throws \InvalidArgumentException When unsupported client or options are passed */
    public function __construct(
        private \Redis|Relay|\RedisArray|\RedisCluster|\Predis\ClientInterface $redis,
        array $options = [],
    ) {
        if ($diff = array_diff(array_keys($options), ['prefix', 'ttl'])) {
            throw new \InvalidArgumentException(sprintf('The following options are not supported "%s".', implode(', ', $diff)));
        }

        $this->prefix = $options['prefix'] ?? 'sf_s';
        $this->ttl = $options['ttl'] ?? null;
    }

    protected function doRead(#[\SensitiveParameter] string $sessionId): string     {
        return $this->redis->get($this->prefix.$sessionId) ?: '';
    }

            // prevent empty composite constraint to have empty groups             $this->groups = array_keys($mergedGroups) ?: [self::DEFAULT_GROUP];
            $this->$compositeOption = $nestedConstraints;

            return;
        }

        foreach ($nestedConstraints as $constraint) {
            if (isset(((array) $constraint)['groups'])) {
                $excessGroups = array_diff($constraint->groups, $this->groups);

                if (\count($excessGroups) > 0) {
                    throw new ConstraintDefinitionException(sprintf('The group(s) "%s" passed to the constraint "%s" should also be passed to its containing constraint "%s".', implode('", "', $excessGroups), get_debug_type($constraint), static::class));
                }
            } else {
                $constraint->groups = $this->groups;
            }
        }

        $this->$compositeOption = $nestedConstraints;
    }

    return $this;
  }

  /** * {@inheritdoc} */
  public function revokePermission($permission) {
    if ($this->isAdmin()) {
      return $this;
    }
    $this->permissions = array_diff($this->permissions, [$permission]);
    return $this;
  }

  /** * {@inheritdoc} */
  public function isAdmin() {
    return (bool) $this->is_admin;
  }

  /** * {@inheritdoc} */

exit(ERR_TIMEOUT);
    }

    if (in_array(\STDOUT, $w) && '' !== $out) {
        $written = fwrite(\STDOUT, (string) $out, 32768);
        if (false === $written) {
            exit(ERR_WRITE_FAILED);
        }
        $out = (string) substr($out, $written);
    }
    if (null === $read && '' === $out) {
        $write = array_diff($write, [\STDOUT]);
    }

    if (in_array(\STDERR, $w) && '' !== $err) {
        $written = fwrite(\STDERR, (string) $err, 32768);
        if (false === $written) {
            exit(ERR_WRITE_FAILED);
        }
        $err = (string) substr($err, $written);
    }
    if (null === $read && '' === $err) {
        $write = array_diff($write, [\STDERR]);
    }

  protected function calculateChecksum(array $tags) {
    $checksum = 0;

    $query_tags = array_diff($tags, array_keys($this->tagCache));
    if ($query_tags) {
      $tag_invalidations = $this->getTagInvalidationCounts($query_tags);
      $this->tagCache += $tag_invalidations;
      // Fill static cache with empty objects for tags not found in the storage.       $this->tagCache += array_fill_keys(array_diff($query_tags, array_keys($tag_invalidations)), 0);
    }

    foreach ($tags as $tag) {
      $checksum += $this->tagCache[$tag];
    }

/** * Asserts that a renderable array has a set of cache tags. * * @param array $renderable * The renderable array. Must have a #cache[tags] element. * @param array $cache_tags * The expected cache tags. * * @internal */
  protected function assertCacheTags(array $renderable, array $cache_tags): void {
    $diff = array_diff($cache_tags, $renderable['#cache']['tags']);
    $this->assertEmpty($diff);
  }

}