_.isMatch(object, source)

144

_.isMatch(object, source)

_.isMatch在object和source之间进行部分的深度比较确定是否object对象包含了和source相同的属性值

注意：当source部分比较的时候，此方法和matches方法效果相同

部分比较对于空数组或者空对象的source会分别匹配任何数组或是对象。

参数

object (Object): 需要检查的对象
source (Object): 需要匹配判断的对象

返回值

(boolean): 如果属性匹配返回true，否则false

例子

var object = { 'a': 1, 'b': 2 };
 
_.isMatch(object, { 'b': 2 });
// => true
 
_.isMatch(object, { 'b': 1 });
// => false

源代码：

import baseIsMatch from './.internal/baseIsMatch.js'
import getMatchData from './.internal/getMatchData.js'

/**
 * Performs a partial deep comparison between `object` and `source` to
 * determine if `object` contains equivalent property values.
 *
 * **Note:** This method is equivalent to `matches` when `source` is
 * partially applied.
 *
 * Partial comparisons will match empty array and empty object `source`
 * values against any array or object value, respectively. See `isEqual`
 * for a list of supported value comparisons.
 *
 * @since 3.0.0
 * @category Lang
 * @param {Object} object The object to inspect.
 * @param {Object} source The object of property values to match.
 * @returns {boolean} Returns `true` if `object` is a match, else `false`.
 * @example
 *
 * const object = { 'a': 1, 'b': 2 }
 *
 * isMatch(object, { 'b': 2 })
 * // => true
 *
 * isMatch(object, { 'b': 1 })
 * // => false
 */
//在object和source之间进行部分的深度比较确定是否object对象包含了和source相同的属性值
//注意：当source部分比较的时候，此方法和matches方法效果相同
//部分比较对于空数组或者空对象的source会分别匹配任何数组或是对象。
function isMatch(object, source) {
  //判断object和source是否严格相等，否则调用baseIsMatch判断
  return object === source || baseIsMatch(object, source, getMatchData(source))
}

export default isMatch

getMatchData

import isStrictComparable from './isStrictComparable.js'
import keys from '../keys.js'

/**
 * Gets the property names, values, and compare flags of `object`.
 *
 * @private
 * @param {Object} object The object to query.
 * @returns {Array} Returns the match data of `object`.
 */
//获取object的属性名（键名），属性值和比较标记（是否适合使用===比较）
function getMatchData(object) {
  const result = keys(object)//获取object的自身可枚举属性组成的数组
  let length = result.length//object的自身可枚举属性长度

  while (length--) {
    const key = result[length]//object属性名
    const value = object[key]//object属性值
    result[length] = [key, value, isStrictComparable(value)]//生成结果数组的元素
  }
  return result
}

export default getMatchData

baseIsMatch

import Stack from './Stack.js'
import baseIsEqual from './baseIsEqual.js'

/** Used to compose bitmasks for value comparisons. */
const COMPARE_PARTIAL_FLAG = 1
const COMPARE_UNORDERED_FLAG = 2

/**
 * The base implementation of `isMatch`.
 *
 * @private
 * @param {Object} object The object to inspect.
 * @param {Object} source The object of property values to match.
 * @param {Array} matchData The property names, values, and compare flags to match.
 * @param {Function} [customizer] The function to customize comparisons.
 * @returns {boolean} Returns `true` if `object` is a match, else `false`.
 */
//isMatch的基础实现
function baseIsMatch(object, source, matchData, customizer) {
  let index = matchData.length//source对象的键，值，和严格比较标识组成的数组的长度，作为循环索引
  const length = index
  const noCustomizer = !customizer//是否没有传递自定义比较函数

  if (object == null) {//如果object是null，判断source的属性长度作为结果
    return !length
  }
  let data
  let result
  object = Object(object)
  while (index--) {//循环source属性长度
    data = matchData[index]//当前matchData
    if ((noCustomizer && data[2])
          ? data[1] !== object[data[0]]
          : !(data[0] in object)
          //如果没有自定义比较函数并且适合严格比较，就直接严格比较
          //否则用in操作符判断object对象里有没有source对应的键
        ) {
      return false//没有或者不匹配就返回false
    }
  }
  while (++index < length) {//经过一轮适合严格比较和in操作符比较后，索引从长度变为了0，再次从0开始循环到长度，深度比较是否相等
    data = matchData[index]//当前matchData
    const key = data[0]//当前source对象键
    const objValue = object[key]//对应object对象的值
    const srcValue = data[1]//当前source对象值

    if (noCustomizer && data[2]) {//如果没有自定义比较函数并且适合严格比较
      if (objValue === undefined && !(key in object)) {//判断object对应值是否是undefined或者object不存在对应key，如果是，就返回false
        return false
      }
    } else {//不适合严格比较或者有自定义比较函数的处理
      const stack = new Stack//stack，用于处理循环引用问题
      if (customizer) {//如果有自定义比较调用处理
        result = customizer(objValue, srcValue, key, object, source, stack)
      }
      if (!(result === undefined
            ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
            : result
          )) {//否则调用baseIsEqual处理
        return false
      }
    }
  }
  return true
}

export default baseIsMatch