PHP Hash::diff方法代码示例

 /**
  * hasDiffAddress
  * @param Model $model
  * @return boolean
  */
 protected function hasDiffAddress(Model $model)
 {
     $this->_instance = $model->findById($model->id);
     if ($this->_instance !== null && isset($model->data['User']['live_country'])) {
         $prevAddress = array('live_country' => $this->_instance['User']['live_country'], 'live_place' => $this->_instance['User']['live_place'], 'live_address' => $this->_instance['User']['live_address']);
         $currentAddress = array('live_country' => $model->data['User']['live_country'], 'live_place' => $model->data['User']['live_place'], 'live_address' => $model->data['User']['live_address']);
         $result = Hash::diff($prevAddress, $currentAddress);
         return !empty($result) ? true : false;
     }
     return false;
 }

 /**
  * Set plugin name
  *
  * @param array $backtrace Output "debug_backtrace" function
  *
  * @throws CakeException
  */
 protected static function setPluginName(array $backtrace)
 {
     $pluginPath = APP . 'Plugin';
     if (!is_readable($pluginPath)) {
         throw new CakeException(__d('hurad', 'Plugin path is not readable'));
     }
     if (strpos($backtrace[0]['file'], $pluginPath) != 0) {
         throw new CakeException(__d('hurad', 'You should use meta box in plugin'));
     }
     $diffPath = Hash::diff(explode(DIRECTORY_SEPARATOR, $backtrace[0]['file']), explode(DIRECTORY_SEPARATOR, $pluginPath));
     self::$pluginName = reset($diffPath);
 }

 public function testDifferentFormat001Save()
 {
     $dateFormats = array('d-m-Y' => '04-01-1952', 'd/m/Y' => '04/01/1952', 'Y/m/d' => '1952/01/04', 'Y-m-d' => '1952-01-04', 'Y-d-m' => '1952-04-01', 'Y/d/m' => '1952/04/01', 'm-d-Y' => '01-04-1952', 'm/d/Y' => '01/04/1952', 'Ymd' => '19520104', 'Ydm' => '19520401');
     //-- this record must be resetted at every cycle
     $this->loadUnload();
     $before = $this->Apple->read(null, 1);
     foreach ($dateFormats as $dateFormat => $expectedValue) {
         $this->loadUnload($dateFormat);
         $before = $this->Apple->read(null, 1);
         $postData = $before;
         $postData['Apple']['date'] = $expectedValue;
         $result = $this->Apple->save($postData);
         $this->assertInternalType('array', $result);
         $this->assertEquals($postData, $result);
         $expectedDiff = array('date' => $expectedValue);
         $diff = Hash::diff($result['Apple'], $before['Apple']);
         $this->assertEquals($expectedDiff, $diff);
         //-- Save record for next cycle
         $this->Apple->save($before);
     }
 }

 /**
  * select method
  *
  * @return void
  */
 public function select()
 {
     $this->__prepare();
     if (Hash::get($this->viewVars['user'], 'User.id') !== Current::read('User.id')) {
         $this->throwBadRequest();
         return;
     }
     $roomId = Hash::get($this->viewVars, 'roomId');
     if (!$roomId) {
         $this->throwBadRequest();
         return;
     }
     if ($this->request->is('post')) {
         //登録処理
         //** ロールルームユーザデータ取得
         $rolesRoomsUsers = $this->RolesRoomsUser->getRolesRoomsUsers(array('RolesRoomsUser.user_id' => $this->request->data['UserSelectCount']['user_id'], 'Room.id' => $roomId));
         $userIds = Hash::extract($rolesRoomsUsers, '{n}.RolesRoomsUser.user_id');
         sort($userIds);
         sort($this->request->data['UserSelectCount']['user_id']);
         //** user_idのチェック
         if (Hash::diff($userIds, $this->request->data['UserSelectCount']['user_id'])) {
             //diffがあった場合は、不正ありと判断する
             $this->throwBadRequest();
             return;
         }
         $data = array_map(function ($userId) {
             return array('UserSelectCount' => array('user_id' => $userId, 'created_user' => Current::read('User.id')));
         }, $this->request->data['UserSelectCount']['user_id']);
         //** 登録処理
         if (!$this->UserSelectCount->saveUserSelectCount($data)) {
             $this->NetCommons->handleValidationError($this->UserSelectCount->validationErrors);
         }
         return;
     } else {
         //表示処理
         //** レイアウトの設定
         $this->viewClass = 'View';
         $this->layout = 'NetCommons.modal';
         //** 選択したユーザ取得
         $users = $this->UserSelectCount->getUsers($roomId);
         if (!$users) {
             $users = array();
         }
         $this->set('searchResults', $users);
     }
 }

 /**
  * Handles automatic pagination of model records.
  *
  * @param Model|string $object Model to paginate (e.g: model instance, or 'Model', or 'Model.InnerModel')
  * @param string|array $scope Additional find conditions to use while paginating
  * @param array $whitelist List of allowed fields for ordering. This allows you to prevent ordering
  *   on non-indexed, or undesirable columns.
  * @return array Model query results
  * @throws MissingModelException
  * @throws NotFoundException
  */
 public function paginate($object = null, $scope = array(), $whitelist = array())
 {
     if (is_array($object)) {
         $whitelist = $scope;
         $scope = $object;
         $object = null;
     }
     $object = $this->_getObject($object);
     if (!is_object($object)) {
         throw new MissingModelException($object);
     }
     $options = $this->mergeOptions($object->alias);
     $options = $this->validateSort($object, $options, $whitelist);
     $options = $this->checkLimit($options);
     $conditions = $fields = $order = $limit = $page = $recursive = null;
     if (!isset($options['conditions'])) {
         $options['conditions'] = array();
     }
     $type = 'all';
     if (isset($options[0])) {
         $type = $options[0];
         unset($options[0]);
     }
     extract($options);
     if (is_array($scope) && !empty($scope)) {
         $conditions = array_merge($conditions, $scope);
     } elseif (is_string($scope)) {
         $conditions = array($conditions, $scope);
     }
     if ($recursive === null) {
         $recursive = $object->recursive;
     }
     $extra = array_diff_key($options, compact('conditions', 'fields', 'order', 'limit', 'page', 'recursive'));
     if (!empty($extra['findType'])) {
         $type = $extra['findType'];
         unset($extra['findType']);
     }
     if ($type !== 'all') {
         $extra['type'] = $type;
     }
     if (intval($page) < 1) {
         $page = 1;
     }
     $page = $options['page'] = (int) $page;
     if ($object->hasMethod('paginate')) {
         $results = $object->paginate($conditions, $fields, $order, $limit, $page, $recursive, $extra);
     } else {
         $parameters = compact('conditions', 'fields', 'order', 'limit', 'page');
         if ($recursive != $object->recursive) {
             $parameters['recursive'] = $recursive;
         }
         $results = $object->find($type, array_merge($parameters, $extra));
     }
     $defaults = $this->getDefaults($object->alias);
     unset($defaults[0]);
     if (!$results) {
         $count = 0;
     } elseif ($object->hasMethod('paginateCount')) {
         $count = $object->paginateCount($conditions, $recursive, $extra);
     } else {
         $parameters = compact('conditions');
         if ($recursive != $object->recursive) {
             $parameters['recursive'] = $recursive;
         }
         $count = $object->find('count', array_merge($parameters, $extra));
     }
     $pageCount = intval(ceil($count / $limit));
     $requestedPage = $page;
     $page = max(min($page, $pageCount), 1);
     $paging = array('page' => $page, 'current' => count($results), 'count' => $count, 'prevPage' => $page > 1, 'nextPage' => $count > $page * $limit, 'pageCount' => $pageCount, 'order' => $order, 'limit' => $limit, 'options' => Hash::diff($options, $defaults), 'paramType' => $options['paramType']);
     if (!isset($this->Controller->request['paging'])) {
         $this->Controller->request['paging'] = array();
     }
     $this->Controller->request['paging'] = array_merge((array) $this->Controller->request['paging'], array($object->alias => $paging));
     if ($requestedPage > $page) {
         throw new NotFoundException();
     }
     if (!in_array('Paginator', $this->Controller->helpers) && !array_key_exists('Paginator', $this->Controller->helpers)) {
         $this->Controller->helpers[] = 'Paginator';
     }
     return $results;
 }

 /**
  * Merge association of merge into data
  *
  * @param array &$data The data to merge.
  * @param array &$merge The data to merge.
  * @param string $association The association name to merge.
  * @param string $type The type of association
  * @param bool $selfJoin Whether or not this is a self join.
  * @return void
  */
 protected function _mergeAssociation(&$data, &$merge, $association, $type, $selfJoin = false)
 {
     if (isset($merge[0]) && !isset($merge[0][$association])) {
         $association = Inflector::pluralize($association);
     }
     $dataAssociation =& $data[$association];
     if ($type === 'belongsTo' || $type === 'hasOne') {
         if (isset($merge[$association])) {
             $dataAssociation = $merge[$association][0];
         } else {
             if (!empty($merge[0][$association])) {
                 foreach ($merge[0] as $assoc => $data2) {
                     if ($assoc !== $association) {
                         $merge[0][$association][$assoc] = $data2;
                     }
                 }
             }
             if (!isset($dataAssociation)) {
                 $dataAssociation = array();
                 if ($merge[0][$association]) {
                     $dataAssociation = $merge[0][$association];
                 }
             } else {
                 if (is_array($merge[0][$association])) {
                     $mergeAssocTmp = array();
                     foreach ($dataAssociation as $k => $v) {
                         if (!is_array($v)) {
                             $dataAssocTmp[$k] = $v;
                         }
                     }
                     foreach ($merge[0][$association] as $k => $v) {
                         if (!is_array($v)) {
                             $mergeAssocTmp[$k] = $v;
                         }
                     }
                     $dataKeys = array_keys($data);
                     $mergeKeys = array_keys($merge[0]);
                     if ($mergeKeys[0] === $dataKeys[0] || $mergeKeys === $dataKeys) {
                         $dataAssociation[$association] = $merge[0][$association];
                     } else {
                         $diff = Hash::diff($dataAssocTmp, $mergeAssocTmp);
                         $dataAssociation = array_merge($merge[0][$association], $diff);
                     }
                 } elseif ($selfJoin && array_key_exists($association, $merge[0])) {
                     $dataAssociation = array_merge($dataAssociation, array($association => array()));
                 }
             }
         }
     } else {
         if (isset($merge[0][$association]) && $merge[0][$association] === false) {
             if (!isset($dataAssociation)) {
                 $dataAssociation = array();
             }
         } else {
             foreach ($merge as $row) {
                 $insert = array();
                 if (count($row) === 1) {
                     $insert = $row[$association];
                 } elseif (isset($row[$association])) {
                     $insert = array_merge($row[$association], $row);
                     unset($insert[$association]);
                 }
                 if (empty($dataAssociation) || isset($dataAssociation) && !in_array($insert, $dataAssociation, true)) {
                     $dataAssociation[] = $insert;
                 }
             }
         }
     }
 }

 /**
  * Test diff();
  *
  * @return void
  */
 public function testDiff()
 {
     $a = array(0 => array('name' => 'main'), 1 => array('name' => 'about'));
     $b = array(0 => array('name' => 'main'), 1 => array('name' => 'about'), 2 => array('name' => 'contact'));
     $result = Hash::diff($a, array());
     $expected = $a;
     $this->assertEquals($expected, $result);
     $result = Hash::diff(array(), $b);
     $expected = $b;
     $this->assertEquals($expected, $result);
     $result = Hash::diff($a, $b);
     $expected = array(2 => array('name' => 'contact'));
     $this->assertEquals($expected, $result);
     $b = array(0 => array('name' => 'me'), 1 => array('name' => 'about'));
     $result = Hash::diff($a, $b);
     $expected = array(0 => array('name' => 'main'));
     $this->assertEquals($expected, $result);
     $a = array();
     $b = array('name' => 'bob', 'address' => 'home');
     $result = Hash::diff($a, $b);
     $this->assertEquals($result, $b);
     $a = array('name' => 'bob', 'address' => 'home');
     $b = array();
     $result = Hash::diff($a, $b);
     $this->assertEquals($result, $a);
     $a = array('key' => true, 'another' => false, 'name' => 'me');
     $b = array('key' => 1, 'another' => 0);
     $expected = array('name' => 'me');
     $result = Hash::diff($a, $b);
     $this->assertEquals($expected, $result);
     $a = array('key' => 'value', 'another' => null, 'name' => 'me');
     $b = array('key' => 'differentValue', 'another' => null);
     $expected = array('key' => 'value', 'name' => 'me');
     $result = Hash::diff($a, $b);
     $this->assertEquals($expected, $result);
     $a = array('key' => 'value', 'another' => null, 'name' => 'me');
     $b = array('key' => 'differentValue', 'another' => 'value');
     $expected = array('key' => 'value', 'another' => null, 'name' => 'me');
     $result = Hash::diff($a, $b);
     $this->assertEquals($expected, $result);
     $a = array('key' => 'value', 'another' => null, 'name' => 'me');
     $b = array('key' => 'differentValue', 'another' => 'value');
     $expected = array('key' => 'differentValue', 'another' => 'value', 'name' => 'me');
     $result = Hash::diff($b, $a);
     $this->assertEquals($expected, $result);
     $a = array('key' => 'value', 'another' => null, 'name' => 'me');
     $b = array(0 => 'differentValue', 1 => 'value');
     $expected = $a + $b;
     $result = Hash::diff($a, $b);
     $this->assertEquals($expected, $result);
 }

 public function paginate($object = null, $scope = array(), $whitelist = array())
 {
     if (is_array($object)) {
         $whitelist = $scope;
         $scope = $object;
         $object = null;
     }
     $object = $this->_getObject($object);
     if (!is_object($object)) {
         throw new MissingModelException($object);
     }
     $options = $this->mergeOptions($object->alias);
     $options = $this->validateSort($object, $options, $whitelist);
     $options = $this->checkLimit($options);
     $conditions = $fields = $order = $limit = $page = $recursive = null;
     if (!isset($options['conditions'])) {
         $options['conditions'] = array();
     }
     $type = 'all';
     if (isset($options[0])) {
         $type = $options[0];
         unset($options[0]);
     }
     extract($options);
     if (is_array($scope) && !empty($scope)) {
         $conditions = array_merge($conditions, $scope);
     } elseif (is_string($scope)) {
         $conditions = array($conditions, $scope);
     }
     if ($recursive === null) {
         $recursive = $object->recursive;
     }
     $extra = array_diff_key($options, compact('conditions', 'fields', 'order', 'limit', 'page', 'recursive'));
     if (!empty($extra['findType'])) {
         $type = $extra['findType'];
         unset($extra['findType']);
     }
     if ($type !== 'all') {
         $extra['type'] = $type;
     }
     if ((int) $page < 1) {
         $page = 1;
     }
     $page = $options['page'] = (int) $page;
     if ($object->hasMethod('paginate')) {
         $results = $object->paginate($conditions, $fields, $order, $limit, $page, $recursive, $extra);
     } else {
         $parameters = compact('conditions', 'fields', 'order', 'limit', 'page');
         if ($recursive != $object->recursive) {
             $parameters['recursive'] = $recursive;
         }
         /***********************************************************************************/
         /****************************** CUSTOMIZED BY WEBZASH ******************************/
         /***********************************************************************************/
         /**
          * This fix is related to bug reported at
          * https://groups.google.com/forum/#!topic/webzash-help/A6fpPwOzHfA
          * MySQL seems to mess up the results when its at last page of pagination.
          * This is due to the limit clause being eg : 30, 10 if there are total 36 rows.
          * Changing the limit clause at the last page to 30, 6 to match the number of exact
          * number of rows remaining fixes the problem.
          */
         $temp_params = $parameters;
         $temp_parameters = compact('conditions');
         if ($recursive != $object->recursive) {
             $temp_parameters['recursive'] = $recursive;
         }
         $temp_count = $object->find('count', array_merge($temp_parameters, $extra));
         $temp_pageCount = (int) ceil($temp_count / $limit);
         $temp_requestedPage = $page;
         $temp_page = max(min($page, $temp_pageCount), 1);
         /* If last page, then remove the page parameter and set the limit and offset parameters */
         if ($temp_pageCount == $temp_requestedPage) {
             $temp_params['offset'] = ($temp_requestedPage - 1) * $temp_params['limit'];
             $temp_params['limit'] = $temp_count - $temp_params['offset'];
             unset($temp_params['page']);
         }
         $results = $object->find($type, array_merge($temp_params, $extra));
     }
     $defaults = $this->getDefaults($object->alias);
     unset($defaults[0]);
     if (!$results) {
         $count = 0;
     } elseif ($object->hasMethod('paginateCount')) {
         $count = $object->paginateCount($conditions, $recursive, $extra);
     } elseif ($page === 1 && count($results) < $limit) {
         $count = count($results);
     } else {
         $parameters = compact('conditions');
         if ($recursive != $object->recursive) {
             $parameters['recursive'] = $recursive;
         }
         $count = $object->find('count', array_merge($parameters, $extra));
     }
     $pageCount = (int) ceil($count / $limit);
     $requestedPage = $page;
     $page = max(min($page, $pageCount), 1);
     $paging = array('page' => $page, 'current' => count($results), 'count' => $count, 'prevPage' => $page > 1, 'nextPage' => $count > $page * $limit, 'pageCount' => $pageCount, 'order' => $order, 'limit' => $limit, 'options' => Hash::diff($options, $defaults), 'paramType' => $options['paramType']);
     if (!isset($this->Controller->request['paging'])) {
         $this->Controller->request['paging'] = array();
//.........这里部分代码省略.........

 /**
  * Abstract for Hahs/Set/array_diff()
  *
  * @param array $one
  * @param array $two
  * @return array $diff
  */
 private function _diff($one, $two)
 {
     if (class_exists('Hash')) {
         return Hash::diff($one, $two);
     }
     if (class_exists('Set')) {
         return Set::diff($one, $two);
     }
     return array_diff($one, $two);
 }