array_diff_assoc - PHP code example

PHP Function Array_Diff_ASSOC

In PHP, there are a lot of functions that can help developers in performing tasks such as comparing arrays. Among them, the php function array_diff_assoc is a small but powerful tool. The function allows for nuanced array comparisons by comparing both keys and values. This allows developers to find differences in their data that may not be obvious using the simplest of array compare methods. Mastering this function is essential for developers working with associative arrays, especially in a data-heavy project.

This article will explore the ins and outs of this handy function, including its syntax and usage. We will also look at a number of examples demonstrating its usage in various scenarios.

php function array_diff_assoc

The php function array_diff_assoc() is an inbuilt PHP function that is used to compare a set of associative arrays and return the difference between them. It accepts a minimum of two arrays as input parameters and then compares their keys and values to return the list of elements that are present in one array but not present in the other arrays.

The main difference between the php function array_diff_assoc and similar functions such as array_intersect() is that it not only compares the keys of an input array but also its values, which makes it much more powerful than the other comparable functions. The php function array_diff_assoc() can be used with any number of comma-separated input arrays. The syntax of the function is array_diff_assoc(array1, array2, array3, etc.) and can be used with any number of arrays based on task requirement.

array_diff_assoc example

/** * {@inheritdoc} */
  public function log($level, string|\Stringable $message, array $context = []): void {
    $trigger = [
      '%type' => 'Exception',
      '@message' => 'Deforestation',
      '%function' => 'Drupal\error_service_test\MonkeysInTheControlRoom->handle()',
      'severity_level' => 3,
      'channel' => 'php',
    ];
    if (array_diff_assoc($trigger, $context) === []) {
      throw new \Exception('Oh, oh, frustrated monkeys!');
    }
  }

}

  protected function assertResults(array $expected, bool $sorted = FALSE): void {
    $found = TRUE;
    $expected_keys = array_keys($expected);
    foreach ($this->queryResult as $key => $row) {
      $keys = $sorted ? [$key] : $expected_keys;
      foreach ($keys as $key) {
        $expected_row = $expected[$key];
        if (!array_diff_assoc($row, $expected_row) && !array_diff_assoc($expected_row, $row)) {
          continue 2;
        }
      }
      $found = FALSE;
      break;
    }
    $this->assertTrue($found, strtr('!expected expected, !found found', ['!expected' => print_r($expected, TRUE), '!found' => print_r($this->queryResult, TRUE)]));
  }

  /** * Asserts the results as expected regardless of order in rows. * * @param array $expected * An array of the expected results. * * @internal */

    }
    // Allow modules to change the weight of specific implementations, but avoid     // an infinite loop.     if ($hook != 'module_implements_alter') {
      // Remember the original implementations, before they are modified with       // hook_module_implements_alter().       $implementations_before = $implementations;
      // Verify implementations that were added or modified.       $this->alter('module_implements', $implementations, $hook);
      // Verify new or modified implementations.       foreach (array_diff_assoc($implementations, $implementations_before) as $module => $group) {
        // If an implementation of hook_module_implements_alter() changed or         // added a group, the respective file needs to be included.         if ($group) {
          $this->loadInclude($module, 'inc', "$module.$group");
        }
        // If a new implementation was added, verify that the function exists.         if (!function_exists($module . '_' . $hook)) {
          throw new \RuntimeException("An invalid implementation {$module}_{$hook} was added by hook_module_implements_alter()");
        }
      }
    }

$link['mlid'] = $original['mlid'];
      $link['has_children'] = $original['has_children'];
      $affected_menus[$original['menu_name']] = $original['menu_name'];
      $fields = $this->preSave($link, $original);
      // If $link matches the $original data then exit early as there are no       // changes to make. Use array_diff_assoc() to check if they match because:       // - Some of the data types of the values are not the same. The values       // in $original are all strings because they have come from database but       // $fields contains typed values.       // - MenuTreeStorage::preSave() removes the 'mlid' from $fields.       // - The order of the keys in $original and $fields is different.       if (array_diff_assoc($fields, $original) == [] && array_diff_assoc($original, $fields) == ['mlid' => $link['mlid']]) {
        return $affected_menus;
      }
    }

    try {
      $transaction = $this->connection->startTransaction();
      if (!$original) {
        // Generate a new mlid.         // @todo Remove the 'return' option in Drupal 11.         // @see https://www.drupal.org/project/drupal/issues/3256524         $options = ['return' => Database::RETURN_INSERT_ID] + $this->options;

        }
    }

    /** * @param string[] $entries * * @return string[] */
    private function getDuplicates(array $entries): array
    {
        return array_unique(array_diff_assoc($entries, array_unique($entries)));
    }

    /** * @param list<Column|CardField> $listOfObjectsWithRefProperty * * @return list<string> */
    private function getRefsAsList(array $listOfObjectsWithRefProperty): array
    {
        return \array_map(
            fn ($object) => $object->getRef(),

    private function sync(string $originDir, string $targetDirectory, array $localManifest, array $remoteManifest): void
    {
        // compare the file names and hashes: will return a list of files not present in remote as well         // as files with changed hashes         $uploads = array_keys(array_diff_assoc($localManifest, $remoteManifest));

        // diff the opposite way to find files which are present remote, but not locally.         // we use array_diff_key because we don't care about the hash, just the file names         $removes = array_keys(array_diff_key($remoteManifest, $localManifest));

        foreach ($removes as $file) {
            $this->filesystem->delete($targetDirectory . '/' . $file);
        }

        foreach ($uploads as $file) {
            $this->copyFile($originDir . '/' . $file, $targetDirectory . '/' . $file);
        }

/** * @dataProvider provideFilter */
    public function testFilter($filter, $expectedDiff, $listedProperties = null)
    {
        if (null === $listedProperties) {
            $filteredArray = Caster::filter(self::$referenceArray, $filter);
        } else {
            $filteredArray = Caster::filter(self::$referenceArray, $filter, $listedProperties);
        }

        $this->assertSame($expectedDiff, array_diff_assoc(self::$referenceArray, $filteredArray));
    }

    public static function provideFilter()
    {
        return [
            [
                0,
                [],
            ],
            [
                Caster::EXCLUDE_PUBLIC,
                [

update_option( 'finished_splitting_shared_terms', 0 );
        wp_schedule_single_event( time() + ( 1 * MINUTE_IN_SECONDS ), 'wp_split_shared_term_batch' );
    }

    if ( $wp_current_db_version < 33055 && 'utf8mb4' === $wpdb->charset ) {
        if ( is_multisite() ) {
            $tables = $wpdb->tables( 'blog' );
        } else {
            $tables = $wpdb->tables( 'all' );
            if ( ! wp_should_upgrade_global_tables() ) {
                $global_tables = $wpdb->tables( 'global' );
                $tables        = array_diff_assoc( $tables, $global_tables );
            }
        }

        foreach ( $tables as $table ) {
            maybe_convert_table_to_utf8mb4( $table );
        }
    }
}

/** * Executes comments changes made in WordPress 4.3.0. * * @ignore * @since 4.3.0 * * @global wpdb $wpdb WordPress database abstraction object. */

  /** * Asserts whether arrays A and B are equal, when treated as sets. * * @todo This method is broken. Fix it in * https://www.drupal.org/project/drupal/issues/3144926 * * @internal */
  protected function assertSetsEqual(array $a, array $b): void {
    $result = count($a) == count($b) && !array_diff_assoc($a, $b);
  }

  /** * Asserts whether a BigPipe no-JS cookie exists or not. * * @internal */
  protected function assertBigPipeNoJsCookieExists(string $expected): void {
    $this->assertCookieExists('big_pipe_nojs', $expected, 'BigPipe no-JS');
  }

    /** * @param list<array<string, mixed>> $states */
    private function calculateChangeSet(WriteCommand $command, array $states): ChangeSet
    {
        foreach ($states as $state) {
            // check if current loop matches the command primary key             $primaryKey = array_intersect($command->getPrimaryKey(), $state);

            if (\count(array_diff_assoc($command->getPrimaryKey(), $primaryKey)) === 0) {
                return new ChangeSet($state, $command->getPayload(), $command instanceof DeleteCommand);
            }
        }

        return new ChangeSet([], [], $command instanceof DeleteCommand);
    }

    private function getPlaceholders(int $columnCount, int $tupleCount): string
    {
        if ($columnCount > 1) {
            // multi column pk. Example: (product_id, language_id) IN ((p1, l1), (p2, l2), (px,lx),...)