前端 项目中 判断两个对象value值是否相等

项目中的实例
看上图知道，点击了支付时，验证了选中行的主体信息，不一致就给提示信息，一致就出现弹框（这里弹框没有写）
那么我们就要在循环遍历的基础上，判断选中的行信息的 某个值是否相等。
也就是 判断两个对象内容值是否相等
假设我们已经点击了支付按钮

最主要的是

  let Name = [] // 定义一个空的数组，来存放组织名称
  for (let n = 0; n < rowsData.length; n++){
    Name.push(rowsData[n].settleEntityName) // 向name 数组中push 主体名称
  }
  for(let i = 0; i< Name.length; i++){ // 进行for循环 承接主体名称的数组
    if(Name[0] != Name[i]){ // 值不等
      ElNotification({
        type: 'error',
        message: '结算主体不一致，不允许支付'
      });
      this.setState({
        modalVisible: false
      })
      return ;
    }
  }		

详细1代码如下（这个是有查询传查询，没查询按照选中数据）：

// 支付
  handleCreate = (...[, paramData]) => {
    // console.log('支付', paramData, '///', this.tableRef.getSelectionData().selectedRows)
    const rowsData= this.tableRef.getSelectionData().selectedRows // 选中tab行信息
    const SearchparamData = this.tableRef.getFormRef().getFieldsValue(); // 查询form条件
    if(rowsData == '' && SearchparamData.sourceNo == undefined){ // 如果没有选中也没有查询来源单号,直接点击支付按钮
      ElNotification({
        type: 'error',
        message: '查询条件来源单号为空或者没有选中数据，不允许支付操作,请查询来源单号或选中数据'
      });
    }else{
      // 如果有查询条件 并且没有选中
      if(SearchparamData.sourceNo != undefined && rowsData == ''){
        const formDataSource = this.tableRef.getRows(); // 获取查询的数据结果[]
        // 把查询到的数据遍历出名称 进行对比是否每个值都一样
        let Name = []
        for (let n = 0; n < formDataSource.length; n++){
          Name.push(formDataSource[n].settleEntityName)
        }
        for(let i = 0; i< Name.length; i++){
          if(Name[0] != Name[i]){ // 如果名称的值不等，就直接拒绝执行 进行 return
            ElNotification({
              type: 'error',
              message: '结算主体不一致，不允许支付'
            });
            this.setState({
              modalVisible: false
            })
            return ;
          }
        }
        // 如果 名称一样，但是 金额为0 
        if(formDataSource.every(item => item.noPayAmount === 0)){
          ElNotification({
            type: 'error',
            message: '暂无待支付金额，请重新选择'
          });
        }else {
          let sourceNoSum = 0
          formDataSource.forEach(item => {
            sourceNoSum += item.noPayAmount
          });
          this.setState({
            modalVisible: true,
            data: { payMethod: '10' }, // 付款方式 传入默认值 中金
            mark: 'pay',
            unpaidInfo: {
              settleEntityName: formDataSource[0].settleEntityName, // 付款主体
              noPayAmount:sourceNoSum, // 本次付款金额 总和
              settleEntityAddrNo: formDataSource[0].settleEntityAddrNo, // 银行的地址号
              payId: formDataSource.id, // 用户ID
            },
            modalConfirmLoading: false
          });
        }
      }else {
        // 如果有查询条件 或者有选中数据
        let Name = []
        for (let n = 0; n < rowsData.length; n++){
          Name.push(rowsData[n].settleEntityName)
        }
        for(let i = 0; i< Name.length; i++){
          if(Name[0] != Name[i]){ // 值不等
            ElNotification({
              type: 'error',
              message: '结算主体不一致，不允许支付'
            });
            this.setState({
              modalVisible: false
            })
            return ;
          }
        }

        if(rowsData != '' && rowsData.every(item => item.noPayAmount === 0)){ // 如果选中但是待支付金额为0
          ElNotification({
            type: 'error',
            message: '暂无待支付金额，请重新选择'
          });
        }else {
          if(rowsData.every(item => item.noPayAmount !== 0 )){ // 待付款不为0，且付款状态为待付款 && item.payState == 'AWAIT'
            let sum = 0
            rowsData.forEach(item => {
              sum += item.noPayAmount
            });
            this.setState({
              modalVisible: true,
              data: { payMethod: '10' }, // 付款方式 传入默认值 中金
              mark: 'pay',
              unpaidInfo: { // 点击支付按钮传递给弹框的信息值
                settleEntityName: rowsData[0].settleEntityName, // 付款主体
                noPayAmount:sum, // 本次付款金额 总和
                settleEntityAddrNo: rowsData[0].settleEntityAddrNo, // 银行的地址号
                payId: rowsData.id, // 用户ID
              },
              modalConfirmLoading: false
            });
          }
          else {
            ElNotification({
              type: 'error',
              message: '选中数据中有非待付款状态或无待支付金额，请重新选择'
            });
          }
        }
      }
    }
  };

详细2代码如下（这种是要求有选中行的）：

 handleCreate = (...[, paramData]) => {
    // console.log('支付', paramData, '///', this.tableRef.getSelectionData().selectedRows)
    const rowsData= this.tableRef.getSelectionData().selectedRows // 选中tab行信息
    const SearchparamData = this.tableRef.getFormRef().getFieldsValue(); // 查询form条件
    if(rowsData == '' && SearchparamData.sourceNo == undefined){ // 如果没有选中也没有查询来源单号,直接点击支付按钮
      ElNotification({
        type: 'error',
        message: '查询条件来源单号为空或者没有选中数据，不允许支付操作,请查询来源单号或选中数据'
      });
    }else{
      let Name = []  // 定义一个空的数组，来存放组织名称
      for (let n = 0; n < rowsData.length; n++){
        Name.push(rowsData[n].settleEntityName) // for循环把组织名称放入空数组。
      }
      for(let i = 0; i< Name.length; i++){ // 对名称数组遍历判断
        if(Name[0] != Name[i]){ // 值不等
          ElNotification({
            type: 'error',
            message: '结算主体不一致，不允许支付'
          });
          this.setState({
            modalVisible: false
          })
          return ;
        }
      }
      if(rowsData != '' && rowsData.every(item => item.noPayAmount === 0)){ // 如果选中但是待支付金额为0
        ElNotification({
          type: 'error',
          message: '暂无待支付金额，请重新选择'
        });
      }
      else {
        if(rowsData == ''){
          ElNotification({
            type: 'error',
            message: '请选择支付信息行'
          });
        }else{
          if(rowsData.every(item => item.noPayAmount !== 0 )){ // 待付款不为0，且付款状态为待付款 && item.payState == 'AWAIT'
            console.log('1111111')
            let sum = 0
            rowsData.forEach(item => {
              sum += item.noPayAmount
            });
            this.setState({
              modalVisible: true,
              data: { payMethod: '10' }, // 付款方式 传入默认值 中金
              mark: 'pay',
              unpaidInfo: {
                settleEntityName: rowsData[0].settleEntityName, // 付款主体
                noPayAmount:sum, // 本次付款金额 总和
                settleEntityAddrNo: rowsData[0].settleEntityAddrNo, // 银行的地址号
                payId: rowsData.id, // 用户ID
              },
              modalConfirmLoading: false
            });
          }
          else {
            console.log('2222222')
            if(SearchparamData.sourceNo != undefined || SearchparamData.sourceNo != ''){
              const dataSource = this.tableRef.getRows(); // 获取查询的数据结果[]
              if(dataSource.every(item => item.noPayAmount === 0)){
                ElNotification({
                  type: 'error',
                  message: '暂无待支付金额，请重新选择'
                });
              }else {
                let sourceNoSum = 0
                dataSource.forEach(item => {
                  sourceNoSum += item.noPayAmount
                });
                this.setState({
                  modalVisible: true,
                  data: { payMethod: '10' }, // 付款方式 传入默认值 中金
                  mark: 'pay',
                  unpaidInfo: {
                    settleEntityName: dataSource[0].settleEntityName, // 付款主体
                    noPayAmount:sourceNoSum, // 本次付款金额 总和
                    settleEntityAddrNo: dataSource[0].settleEntityAddrNo, // 银行的地址号
                    payId: dataSource.id, // 用户ID
                  },
                  modalConfirmLoading: false
                });
              }
            }
            else {
              ElNotification({
                type: 'error',
                message: '选中数据中有非待付款状态或无待支付金额，请重新选择'
              });
            }
          }
        }
      }
    }
  };

小例子：

现在有两个对象：

let a = {name: 'zj', tel: '123', sex: 0, id: 1}
let b = {name: 'zj', tel: '123', sex: 0, id: 1}

如何判断对象a和对象b相等呢？
这个时候需要自己定义一个方法来判断对象内容值是否相等，代码如下：

function objEqual(a, b) {
    if (Object.keys(a).length !== Object.keys(b).length) {
        return false
    }
    for (let key in a) {
        if (b[key] === undefined) {
            return false
        }
        if (a[key] !== b[key]) {
            return false
        }
    }
    return true
}

但是，如果涉及到对象内部还存在复式结构的，比如：

let c = {name: 'zj', tel: '123', sex: 0, id: 1, obj: {name: '111'}}
let d = {name: 'zj', tel: '123', sex: 0, id: 1, obj: {name: '1111'}}

这样如何解决呢？
采用嵌套就可以啦~~
代码如下：

function objEqual(a, b) {
    if (Object.keys(a).length !== Object.keys(b).length) {
        return false
    }
    for (let key in a) {
        if (b[key] === undefined) {
            return false
        }
        if (typeof(b[key]) === 'function' || typeof(a[key]) === 'function') {
            throw new Error('type error')
        }
        if (typeof(b[key]) != typeof(a[key])) {
            return false
        }
        if (typeof(a[key]) === 'object') {
            return objEqual(a[key], b[key])
        }
        if (a[key] !== b[key]) {
            return false
        }
    }
    return true
}