JS 判断对象属性是否存在，判断是否包含某个属性，是否为自身属性

判断是否包含某对象

我们知道访问对象属性有两种形式，如下：

var obj = {
  name:'听风是风'
};
obj.name;   //听风是风
obj['name'];   //听风是风

那么马上有同学就想到用这两种形式判断对象是否包含某个属性，因为原型链上如果某个属性不存在就会返回undefined，比如：

if(!obj.age){
    console.log('obj没有age属性');
}

这么做行不行，行，但是存在缺陷。最特殊的情况就是我们有age字段，而它的值偏偏就是 undefined，那这样就尴尬了。

怎么办呢，一般推荐使用 in 运算符，用法是属性名 in 对象，如果存在返回 true，反之为 false，来看个例子：

var echo = {
    name:'听风是风',
    job:undefined
};
console.log('name' in echo);   //true
console.log('job' in echo);    //true
console.log('age' in echo);    //false

但需要注意的是，in 只能判断对象有没有这个属性，无法判断这个属性是不是自身属性，啥意思？咱们接着说。

判断是否是自身属性

一个最简单的构造函数创建实例的例子：

function Parent(){
    this.name = 'echo';
};
Parent.prototype.age = 26;
var o = new Parent();
o.name//echo
o.age//26

在这个例子中，对于实例 o 而言，name 就是是自身属性，这是它自己有的，而 age 是原型属性，o 虽然没有这个属性，但在需要时，它还是顺着原型链找到了自己的老父亲 Parent，并借用了这个属性。

所以当我们用 in 判断时可以发现结果均为 true：

'name' in o;//true
'age' in o;//true

针对这个问题，如果我们还要判断是否是自身属性，就得借用方法hasOwnProperty()，不信你看：

o.hasOwnProperty('name');//true
o.hasOwnProperty('age');//false

说到底hasOwnProperty()做了两件事，除了判断对象是否包含这个属性，还判断此属性是不是对象的自身属性。

所以我们可以简单总结一下，如果我们只需判断对象有没有某个属性，使用 in 运算符就好了。而如果我们还要关心这个属性是不是自身属性，那么推荐hasOwnProperty()方法。

说了这么多，这两个判断有什么使用场景呢？

关于 in 运算符判断对象有没有某个属性，最常见的，我们希望给某个对象添加一个方法，直接添加又担心其他同事已经声明过，存在覆盖的可能性，所以使用 in 来判断，没有这个属性，咱们再加。

当然针对这个问题，使用 Symbol 来确保对象 key 的唯一性也是不错的做法，这个就看实际场景了。

而关于hasOwnProperty()这个方法呢，我目前遇到的就是深拷贝实现时会使用，因为我们知道每个对象都有原型，而深拷贝时我们只是希望拷贝对象的自身属性，使用此方法做个区分就是非常奈斯的做法了。

好了，这篇文章就说到这里了，全文结束。

转自：https://www.cnblogs.com/echolun/p/12377650.html

（1）获取对象的属性，并且判断对象属性是否存在

举例：

let test = {name:’22’,age:67,sex:’man’}; 获取age属性值；

简单写法：

if(test && test.age ){
 console.log(test.age);
}

优化写法：

let test = {name:’22’,age:67,sex:’man’}; 
console.log(test && test.age);  // 直接获取age的值；

（2）引入图片（图片都放在assects文件夹下面）

配置webpack @为src的路径，通过import引入

import emptyImg from '@/assets/imgs/defaultEmpty.png';

（3）PropTypes进行类型检查

对Component设置propTypes属性，可以为Component的props属性进行类型检查

import React from 'react';
import PropTypes from 'prop-types';

class MyComponent extends React.Component {
  render() {
    // 利用属性做更多得事
   }
}

MyComponent.propTypes = {
// 可以定义一个属性是特定的JS类型
//Array,Boolean,Function,Number,Object,String,Symbol
optionalArray: PropTypes.array,
optionalBool: PropTypes.bool,
optionalFunc: PropTypes.func,
optionalNumber: PropTypes.number,
optionalObject: PropTypes.object,
optionalString: PropTypes.string,
optionalSymbol: PropTypes.symbol,

//指定类型为：任何可以被渲染的元素，包括数字，字符串，react 元素，数组，fragment。
optionalNode: PropTypes.node,

// 指定类型为：一个react 元素
optionalElement: PropTypes.element,

//你可以类型为某个类的实例，这里使用JS的instanceOf操作符实现
optionalMessage: PropTypes.instanceOf(Message),


//指定枚举类型：你可以把属性限制在某些特定值之内
optionalEnum: PropTypes.oneOf(['News', 'Photos']),

// 指定多个类型：你也可以把属性类型限制在某些指定的类型范围内
optionalUnion: PropTypes.oneOfType([
  PropTypes.string,
  PropTypes.number,
  PropTypes.instanceOf(Message)
]),

// 指定某个类型的数组
optionalArrayOf: PropTypes.arrayOf(PropTypes.number),

// 指定类型为对象，且对象属性值是特定的类型
optionalObjectOf: PropTypes.objectOf(PropTypes.number),


//指定类型为对象，且可以规定哪些属性必须有，哪些属性可以没有
optionalObjectWithShape: PropTypes.shape({
  optionalProperty: PropTypes.string,
  requiredProperty: PropTypes.number.isRequired
}),

// 指定类型为对象，且可以指定对象的哪些属性必须有，哪些属性可以没有。如果出现没有定义的属性，会出现警告。
// 下面的代码optionalObjectWithStrictShape的属性值为对象，但是对象的属性最多有两个，optionalProperty 和 requiredProperty。
//出现第三个属性，控制台出现警告。
optionalObjectWithStrictShape: PropTypes.exact({
  optionalProperty: PropTypes.string,
  requiredProperty: PropTypes.number.isRequired
}),

//加上isReqired限制，可以指定某个属性必须提供，如果没有出现警告。
requiredFunc: PropTypes.func.isRequired,
requiredAny: PropTypes.any.isRequired,

// 你也可以指定一个自定义的验证器。如果验证不通过，它应该返回Error对象，而不是`console.warn `或抛出错误。`oneOfType`中不起作用。
customProp: function(props, propName, componentName) {
  if (!/matchme/.test(props[propName])) {
    return new Error(
      'Invalid prop `' + propName + '` supplied to' +
      ' `' + componentName + '`. Validation failed.'
    );
  }
},

//你也可以提供一个自定义的验证器 arrayOf和objectOf。如果验证失败，它应该返回一个Error对象。
//验证器用来验证数组或对象的每个值。验证器的前两个参数是数组或对象本身，还有对应的key。
customArrayProp: PropTypes.arrayOf(function(propValue, key,     componentName, location, propFullName) {
  if (!/matchme/.test(propValue[key])) {
    return new Error(
      'Invalid prop `' + propFullName + '` supplied to' +
      ' `' + componentName + '`. Validation failed.'
    );
  }
})

限制单个子元素
使用 PropTypes.element 你可以指定只有一个子元素可以被传递给组件。

 //将children限制为单个子元素。
Greeting.propTypes = {
  name: PropTypes.string,
  children: PropTypes.element.isRequired
};

如果如下方式引用Greeting组件：

 //传了两个子元素给组件Greeting那么，控制台会出现警告
<Greeting name={'world'}>
      <span>子元素1</span>
      <span>子元素2</span>
 </Greeting>

警告如图：

指定默认属性值

你可以给组件分配一个特殊的defaultProps属性。

//给Greeting属性中的name值指定默认值。当组件引用的时候，没有传入name属性时，会使用默认值。
Greeting.defaultProps = {
  name: 'Stranger'
};

(4) SSR 和CSR的区别

参考文章： https://blog.csdn.net/u012036171/article/details/88833200

(5) React 组件属性赋值的展开运算符应该怎么理解?

举例：

// 原句
data = {name: "张三", age: 12};
<Person {...data}></Person>

// 相等于
<Person name={data.name} age={data.age}></Person>

1、工具类

import com.myfutech.employee.service.api.vo.request.candidate.CandidateImportVO;
import com.myfutech.employee.service.api.vo.request.employee.EmployeeModifyVO;
import com.myfutech.employee.service.provider.model.Employee;
import com.myfutech.employee.service.provider.util.vo.IFieldResult;
import io.swagger.annotations.ApiModelProperty;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.apache.commons.lang3.time.DateUtils;

import java.lang.reflect.Field;
import java.util.Date;

/**
 * Created by Liuxd on 2019/2/25.
 */
public class IBeanUtils {

    public static IFieldResult containFieldName(Object obj, String filedName, String filedValue) throws Exception {
        if (StringUtils.isBlank(filedName)) {
            return new IFieldResult(false);
        }

        boolean flag = false;
        String type = "";
        Object value = null;

        for (Field f : obj.getClass().getDeclaredFields()) {
            f.setAccessible(true);

            if (filedName.equals(f.getName())) {
                flag = true;
                type = f.getType().toString();
                if (type.contains("Date")) {
                    if (!filedValue.contains(":")) {
                        filedValue = filedValue + " 00:00:00";
                    }
                    value = DateUtils.parseDate(filedValue, "yyyy-MM-dd HH:mm:ss");
                } else {
                    value = filedValue;
                }
                break;
            }

        }

        return new IFieldResult(flag, type, value);
    }

    public static String getFieldValueByFieldName(String fieldName, Object object) {
        try {
            Field field = object.getClass().getDeclaredField(fieldName);
            //设置对象的访问权限，保证对private的属性的访问
            field.setAccessible(true);
            Object hisValue = field.get(object);
            if (null == hisValue) {
                return "";
            }

            String value = "";
            String type = field.getType().toString();
            if (type.contains("Date")) {
                value = DateFormatUtils.format((Date) hisValue, "yyyy-MM-dd HH:mm:ss");
            } else {
                value = hisValue.toString();
            }

            return value;
        } catch (Exception e) {

            return "";
        }
    }

    public static String getFieldTypeByFieldName(String fieldName, Object object) {
        try {
            Field field = object.getClass().getDeclaredField(fieldName);
            //设置对象的访问权限，保证对private的属性的访问
            field.setAccessible(true);
            String type = field.getType().toString();
            return type;
        } catch (Exception e) {

            return "";
        }
    }

    public static String getFieldAnnotation(String fieldName, Object object) {
        try {
            Field field = object.getClass().getDeclaredField(fieldName);
            //设置对象的访问权限，保证对private的属性的访问
            field.setAccessible(true);
            ApiModelProperty property = field.getAnnotation(ApiModelProperty.class);
            if (null == property) {
                return "";
            }

            return property.value();
        } catch (Exception e) {
            return "";
        }

    }

    /**
     * 判断对象中属性值是否全为空
     *
     * @param object
     * @return
     */
    public static boolean checkObjAllFieldsIsNull(Object object) {
        if (null == object) {
            return true;
        }

        try {
            for (Field f : object.getClass().getDeclaredFields()) {
                f.setAccessible(true);

                if (f.get(object) != null && StringUtils.isNotBlank(f.get(object).toString())) {
                    return false;
                }

            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return true;
    }


    public static void main(String[] args) throws Exception {
        EmployeeModifyVO vo = new EmployeeModifyVO();

        IFieldResult result = IBeanUtils.containFieldName(vo, "employeeName", "99999");

        System.out.println(result.toString());

        vo.setEmployeeName("Jack");

        Object v = getFieldValueByFieldName("employeeName", vo);

        System.out.println(v);

        Employee employee = new Employee();

        employee.setCreateTime(new Date());

        String v2 = getFieldValueByFieldName("createTime", employee);

        System.out.println(v2);

        CandidateImportVO vo2 = new CandidateImportVO();
        boolean flag = checkObjAllFieldsIsNull(vo2);
        System.out.println(flag);


    }


}

2、相关VO类

import io.swagger.annotations.ApiModel;
import lombok.Data;

@Data
@ApiModel(value = "IFieldResult", description = "判断类包含属性结果")
public class IFieldResult<T> {

    private Boolean flag;

    private String type;

    private String table;

    private String hisValue;

    private T value;

    public IFieldResult() {
    }

    public IFieldResult(Boolean flag) {
        this.flag = flag;
    }

    public IFieldResult(Boolean flag, String type, T value) {
        this.flag = flag;
        this.type = type;
        this.value = value;
    }
}

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.ToString;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import java.io.Serializable;

@Data
@ToString
@ApiModel(value = "EmployeeModifyVO",description = "员工新增或修改对应实体类")
public class EmployeeModifyVO implements Serializable {

    private static final long serialVersionUID = -7226431718100006277L;

    public interface Create {}
    public interface Update extends Create {}

    @NotEmpty(groups = EmployeeModifyVO.Update.class)
    @ApiModelProperty("员工id")
    private Long id;

    @ApiModelProperty("员工编号")
    private String employeeCode;

    @NotEmpty(groups = EmployeeModifyVO.Create.class)
    @ApiModelProperty("员工姓名")
    private String employeeName;

    @ApiModelProperty("职级类型")
    private String rank;

    @ApiModelProperty("职级序列")
    private Integer orders;

    @NotNull(groups = EmployeeModifyVO.Create.class)
    @ApiModelProperty("证件类型 0身份证 1护照")
    private Integer documentType;

    @NotNull(groups = EmployeeModifyVO.Create.class)
    @ApiModelProperty("身份证号码")
    private String identityCard;

    @NotBlank(groups = EmployeeModifyVO.Create.class)
    @ApiModelProperty("手机号")
    private String phoneNumber;

    @ApiModelProperty("备用手机号")
    private String phoneBackup;

    @ApiModelProperty("公司邮箱")
    private String workEmail;

    @ApiModelProperty("入职时间")
    private String entryTime;

    @ApiModelProperty("转正时间")
    protected String formalTime;

    @ApiModelProperty("离职日期")
    private String dimissionTime;

    @ApiModelProperty("业绩考核 0否1是")
    private Integer examine;

    @ApiModelProperty("是否同步用户0是1否")
    private Integer isUser;

    @ApiModelProperty("员工类型(字典key:employeeType)")
    private Integer employeeType;

}