精华内容
下载资源
问答
  • 2021-04-07 12:06:39

    一.通过点或者方括号

    我们在使用对象的时候,通过点或方括号可以获取对象的属性值,如果该对象自身不存在这个属性,就会返回undefined。

    	var obj={
    	    name:"小破船",
    	    doWhat:"借箭"
    	};
    	console.log(obj.name);//小破船
    	console.log(obj.age);//undefined
    	console.log(obj['age']);//undefined
    

    我们可以根据 obj.属性名 !== undefined 的返回值 来判断obj是否有该属性,不过这个方法的局限性在于,如果该属性的属性值本身就是undefined就无法进行正确判断。

    二.in运算符

    如果指定的属性在指定的对象或其原型链中,则in 运算符返回true反之返回false;

    	var obj={
    	    name:"小破船",
    	    doWhat:"借箭",
    	    ambiguity:undefined
    	};
    	console.log('name' in obj);//true
    	console.log('age' in obj);//false
    	console.log('ambiguity' in obj);//true
    

    即使出现obj里的属性的属性值本身为undefined的情况,使用in运算符也可以正常判断。弊端就是,无法判断是自身的属性还是原型链上的属性。

    三.使用hasOwnProperty()方法

    hasOwnProperty()方法返回一个布尔值,判断对象的自身属性中是否包含指定的属性。

    	var obj={
    	    name:"小破船",
    	    doWhat:"借箭",
    	    ambiguity:undefined
    	};
    	console.log(obj.hasOwnProperty('name'));//true
    	console.log(obj.hasOwnProperty('age'));//false
    	console.log(obj.hasOwnProperty('toString'));//false
    

    hasOwnProperty()方法只会判断对象自身的属性中是否包含指定的属性,这样就结局的in运算符的局限。不过该方法也是有局限性的,因为他只能判断自身属性。

    三种方式优缺点各有不同,结合场景使用,会更好哦!

    更多相关内容
  • 主要介绍了C#利用反射来判断对象是否包含某个属性的实现方法,很有借鉴价值的一个技巧,需要的朋友可以参考下
  • (1)获取对象的属性,并且判断对象属性是否存在 举例: let test = {name:’22’,age:67,sex:’man’}; 获取age属性值; 简单写法: if(test && test.age ){ console.log(test.age); } 优化写法: let ...

    (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>
    
    展开全文
  • 基础小白
  • JS 判断对象属性是否存在,判断是否包含某个属性,是否为自身属性 判断是否包含某对象 我们知道访问对象属性有两种形式,如下: var obj = { name:'听风是风' }; obj.name; //听风是风 obj['name']; //听风是风 ...

    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

    展开全文
  • @ApiModel(value = "IFieldResult", description = "判断类包含属性结果") public class IFieldResult<T> { private Boolean flag; private String type; private String table; private String hisValue; ...

    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;
    
    }
    

     

    展开全文
  • 看一段数据库中的表转化成用户可以看懂的数据,也就是把一些字段比如Date用ms存的,转化为'yyyy-MM-dd'这种格式,但是由于字段太多,所以利用Java反射机制自带的BeanUtils相关的方法来进行转化(要求两个类的属性名称相同...
  • 判断一个对象是否包含一个属性有多种的方式,如下: const obj = { name: 'john' } var a = 'name' in obj var b = Reflect.has(obj, 'name') var c = Reflect.hasOwnProperty.call(obj, 'name') var d = Object....
  • 理解对象 ...数据属性包含一个数据值的位置,在这个位置可以读取和写入值。数据属性有四个描述其特征的特性。(这些特性是为javascript内部引擎服务的,不能直接访问,所以将它们放在方括号中。) ...
  • Java遍历对象所有属性

    千次阅读 2021-02-12 15:49:45
    要获取对象的所有属性可以使用getDeclaredFields()方法会返回一个Field数组遍历这个数组几个遍历所有属性注意使用这个方法会抛出4个异常然后根据属性的类型选择执行对应的内容public static void eachProperties...
  • seriesID = ds.SeriesDescription # 比如看有没有SeriesDescription 这个属性 except AttributeError as e: pass #2 hasattr(ds, SeriesDescription) # True or False #3 object_list = dict(ds) if '...
  • 代码: let person = {isHuman: true} let user = { name: 'john', age: 17, date: new Date(), date1: null, order: { id: 123, price: '19yuan' } } user.__proto__ = person... //指定对象的原型 func...
  • java通过反射获取对象的指定属性值(包括私有属性值和指定注解属性值)
  • ES6学习--对象属性的遍历

    千次阅读 2020-12-19 11:12:52
    ES6一共有5种方法可以遍历对象属性。(1)for...infor...in循环遍历对象自身的和继承的可枚举属性(不含Symbol属性)。(2)Object.keys(obj)Object.keys返回一个数组,包括对象自身的(不含继承的)所有可枚举属性(不含...
  • 如何用js遍历对象数组及对象属性

    万次阅读 2018-12-10 22:50:11
    如何用js遍历对象数组及对象属性 条件:在Vue中objectList:[] 接收的后台数据是一个对象数组,对其进行遍历,得到某个具体的对象 for(var item=0;item&lt;this.objectList.length;item++){ //遍历对象数组,item...
  • ES 6中对象属性的遍历

    千次阅读 2020-01-08 10:33:33
    ES6 一共有 5 种方法可以遍历对象属性
  • PHP检查对象或类中是否存在属性

    千次阅读 2021-03-22 21:49:54
    如果属性对象的类定义的一部分,则property_exists返回true,即使它已被取消设置也是如此。我结束了:$exists = array_key_exists($property, get_object_vars($obj));例:class Foo {public $bar;f...
  • 遍历对象属性的5种方法

    千次阅读 2021-08-05 22:23:11
    遍历对象属性的5种方法ES6一共有**五种**方法可以遍历对象的属性 ES6一共有五种方法可以遍历对象的属性 for…in *for…in 循环遍历对象自己的和继承的可枚举属性(不含 Symbol 属性)。 Object.keys(obj) -...
  • js判断对象为空以及有好几种方法了,但是个人觉得不是特别方便。 比如: 1、把对象通过 JSON.stringify 转为字符串,再判断字符串是否等于 " {} " 2、for in循环,判断key是否存在 3、jq的方法 es6已经帮我们很...
  • JS获取对象属性的方法

    千次阅读 2021-01-21 18:12:12
    JS对象属性 js对象属性有两种类型:字符串类型和Symbol类型。 如果使用其他类型的值作为属性时,都会将其转为字符串;如果是对象类型时,会直接转为[object Object]。 var obj = { ['str']: 'String ...
  • 判断对象中是否包含某个属性名 1.indexOf 可以判断数组是否包含某个值,返回该值对应的下标;对于不存在的值,返回-1; ES6还提供了其他几种判断对象是否包含属性名的方法: 2.in:属性名 in 对象(判断属性名...
  • VUE获取对象所有属性

    千次阅读 2021-09-16 12:16:10
    有时候,在VUE中我们使用第三方,其中的对象有哪些属性我们是不知道,开发功能也显示不出来。例如VueSocketIO,我想知道其链接状态,但我并不知道通过this.$socket哪个属性可以获得,通过其下方式打印其所有属性: ...
  • 修改对象属性的方法

    千次阅读 2019-09-23 23:36:22
    可以用方括号语法来更新对象的属属性的新值在等号的右边。再次说明,性(不能用于更新方法)。对象名后跟上方如果想要修改的属性不存在,此动作会将括号,方括号里面是属性名称。这个属性添加给对象。 删除...
  • JS操作对象属性(获取、添加、删除、修改对象属性) 属性也称为名值对,包括属性名和属性值。属性名可以包含空字符串在内的任意字符串,一个对象中不能存在两个同名的属性。属性值可以是任意类型的数据。 1. 直接...
  • 对象克隆(复制)假如说你想复制一个简单变量。很简单:int apples = 5; int pears = apples; 不仅仅是int类型,其它七种原始数据类型(boolean,char,byte,short,float,double.long)同样适用于该类情况。但是如果你...
  • python如何打印一个对象的全部属性

    千次阅读 2020-12-07 10:05:50
    Python打印对象的全部属性可以使用__dict__方法...然后我找到了__dict__,使用这个属性可以动态获取到对象的所有属性,不包括公用属性。classTeacher(object):display="教师"#有公有属性def__init__(self,name,a...
  • js查看js对象属性

    千次阅读 2019-07-17 20:03:35
    一、创建对象 在js中创建对象并赋值 var person = new Object(); person.name="huangbaokang";...也可以直接新建对象,不通过构造函数,如下所示,我经常就使用这种方式。 var person = {}; person...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,924,993
精华内容 769,997
关键字:

对象的属性可以包含