精华内容
下载资源
问答
  • 2019-07-30 15:09:08

    没有优化,凑合着用吧。需要using System.ComponentModel;


     /// <summary>
     /// 根据属性描述获取枚举值
     /// </summary>
     /// <typeparam name="T">类型</typeparam>
     /// <param name="des">属性说明</param>
     /// <returns>枚举值</returns>
     public static T GetEnum<T>(string des) where T : struct, IConvertible
     {
             Type type = typeof(T);
             if (!type.IsEnum)
             {
                     return default(T);
             }
             T[] enums = (T[])Enum.GetValues(type);
             T temp;
             if (!Enum.TryParse(des, out temp))
             {
                     temp = default(T);
             }
             for (int i = 0; i < enums.Length; i++)
             {
                     string name = enums[i].ToString();
                     FieldInfo field = type.GetField(name);
                     object[] objs = field.GetCustomAttributes(typeof(DescriptionAttribute), false);
                     if (objs == null || objs.Length == 0)
                     {
                             continue;
                     }
                     DescriptionAttribute descriptionAttribute = (DescriptionAttribute)objs[0];
                     string edes = descriptionAttribute.Description;
                     if (des == edes)
                     {
                             temp = enums[i];
                             break;
                     }
             }
    
             return temp;
     }

    字符串转为枚举值:


                    //字符串转为枚举
                    public static T ToEnum<T>(this string enumName) where T : struct, IConvertible
                    {
                            Type type = typeof(T);
                            if (!type.IsEnum)
                            {
                                    return default(T);
                            }
                            T temp;
                            if (!Enum.TryParse<T>(enumName, out temp))
                            {
                                    temp = default(T);
                            }
                            return temp;
                    }

    下面是获取枚举的属性描述的代码,来源于https://www.cnblogs.com/TanSea/p/6923743.html


            //获取属性描述
            public static string GetEnumDescription(Enum enumValue)
            {
                string value = enumValue.ToString();
                FieldInfo field = enumValue.GetType().GetField(value);
                object[] objs = field.GetCustomAttributes(typeof(DescriptionAttribute), false);    //获取描述属性
                if (objs == null || objs.Length == 0)    //当描述属性没有时,直接返回名称
                {
                    return value;
                }
    
                DescriptionAttribute descriptionAttribute = (DescriptionAttribute)objs[0];
                return descriptionAttribute.Description;
            }

     

    更多相关内容
  • 通过反射,我们能获取到枚举类型的描述属性。 首先我们需要给枚举类型添加描述属性属性都没有是不可能取到的),[Description]就是描述属性,使用这个属性,我们需要添加 using System.ComponentModel 引用。 ...
  • 主要介绍了ECMAScript 5中的属性描述符详解,本文讲解了Object.defineProperty、数据描述符、存取描述符、获取属性描述符、对象控制等内容,需要的朋友可以参考下
  • C#反射机制来获取属性描述

    千次阅读 2016-12-02 18:52:46
    通过C#反射获取类和类中属性描述信息 自定义特性代码 [System.Serializable] [System.AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = false)] ...

    通过C#反射获取类和类中属性的描述信息

    自定义特性代码

        [System.Serializable]
        [System.AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = false)]
        [System.Runtime.InteropServices.ComVisible(true)]
        public class RecordAttribute : Attribute //注意:自定义特性名称后面需加Attribute
        {
            private string recordType;      // 记录类型:更新/创建
            private string author;          // 作者
            private DateTime date;          // 更新/创建 日期
            private string memo;         // 备注
    
    
            // 构造函数,构造函数的参数在特性中也称为“位置参数”。
            public RecordAttribute(string recordType, string author, string date)
            {
                this.recordType = recordType;
                this.author = author;
                this.date = Convert.ToDateTime(date);
            }
    
    
            // 对于位置参数,通常只提供get访问器
            public string RecordType { get { return recordType; } }
            public string Author { get { return author; } }
            public DateTime Date { get { return date; } }
    
    
            // 构建一个属性,在特性中也叫“命名参数”
            public string Memo
            {
                get { return memo; }
                set { memo = value; }
    
            }
        }
    我们发现在这个特性的定义上,又用了三个特性去描述它。这三个特性分别是:Serializable、AttributeUsage 和 ComVisible。Serializable特性我们前面已经讲述过,ComVisible简单来说是“控制程序集中个别托管类型、成员或所有类型对 COM 的可访问性”(微软给的定义)。这里我们应该注意到:特性本身就是用来描述数据的元数据,而这三个特性又用来描述特性,所以它们可以认为是“元数据的元数据”(元元数据:meta-metadata)。

    AllowMutiple 属性用于设置该特性是不是可以重复地添加到一个类型上(默认为false),
    Inherited 就更复杂一些了,假如有一个类继承自我们的DemoClass,那么当我们将RecordAttribute添加到DemoClass上时,DemoClass的子类也会获得该特性。而当特性应用于一个方法,如果继承自该类的子类将这个方法覆盖,那么Inherited则用于说明是否子类方法是否继承这个特性。

    定义一个测试用类

        [Record("ITone", "ITone", "2018-8-8")]
        [Record("ITone", "ITone", "2018-8-8", Memo = "测试仪")]
        [Record("ITone", "ITone", "2018-8-8")]
        public class TestClass
        {
            [Description("中文名字")]
            public string Name { get; set; }
            [Description("描述用户的ID")]
            public string UserID { get; set; }
    
    
            [Obsolete("请使用新的方法 ")]
            public void SendMsg()
            {
                Console.Write("xxxxx");
            }
            public void SendMsg(string ms)
            {
                Console.Write("x1222xxxx");
            }
        }
    测试代码

            static void Main(string[] args)
            {
                Type t = typeof(TestClass);
                Object[] records = t.GetCustomAttributes(typeof(RecordAttribute), false);
                foreach (RecordAttribute record in records)
                {
                    Console.WriteLine("      类型:{0}", record.RecordType);
                    Console.WriteLine("      作者:{0}", record.Author);
                    Console.WriteLine("      日期:{0}", record.Date.ToShortDateString());
                    if (!String.IsNullOrEmpty(record.Memo))
                    {
                        Console.WriteLine("      备注:{0}", record.Memo);
                    }
                }
                //获取这个对象的所有公共属性
                PropertyInfo[] zh = t.GetProperties();
                foreach (var item in zh)
                {
                    //获取属性的描述
                   Object[] obs= item.GetCustomAttributes(typeof(DescriptionAttribute),false);
                    foreach (DescriptionAttribute record in obs)
                    {
                        Console.WriteLine("      类型:{0}", record.Description);
                      
                    }
                }    
                //通过反射来创建一个实体                                          
                TestClass ass = (TestClass)Assembly.GetExecutingAssembly().CreateInstance("Demo_One.TestClass");
                ass.SendMsg("");
            }



    展开全文
  • /// 获取属性描述 /// </summary> /// <param name="t"></param> /// <returns></returns> public static string GetDesc(this PropertyInfo t) { string des = (...

    属性描述

    定义为PropertyInfo的扩展方法

    /// <summary>
    /// 获取属性描述
    /// </summary>
    /// <param name="t"></param>
    /// <returns></returns>
    public static string GetDesc(this PropertyInfo t)
    {
    	string des = ((DescriptionAttribute)Attribute.GetCustomAttribute(t, typeof(DescriptionAttribute)))?.Description ?? null;// 属性描述
    	return des;
    }

    属性相关操作

    是否拥有某属性,获取某属性值,设置某属性值,是否拥有某字段,获取某字段值,设置某字段值,获取实体层描述

    private static BindingFlags _bindingFlags { get; }= BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static;
    /// <summary>
    /// 是否拥有某属性
    /// </summary>
    /// <param name="obj"> 对象 </param>
    /// <param name="propertyName"> 属性名 </param>
    /// <returns> </returns>
    public static bool ContainsProperty(this object obj, string propertyName)
    {
        return obj.GetType().GetProperty(propertyName, _bindingFlags) != null;
    }
    
    /// <summary>
    /// 获取某属性值
    /// </summary>
    /// <param name="obj"> 对象 </param>
    /// <param name="propertyName"> 属性名 </param>
    /// <returns> </returns>
    public static object GetPropertyValue(this object obj, string propertyName)
    {
        return obj.GetType().GetProperty(propertyName, _bindingFlags).GetValue(obj);
    }
    
    /// <summary>
    /// 设置某属性值
    /// </summary>
    /// <param name="obj"> 对象 </param>
    /// <param name="propertyName"> 属性名 </param>
    /// <param name="value"> 值 </param>
    /// <returns> </returns>
    public static void SetPropertyValue(this object obj, string propertyName, object value)
    {
        obj.GetType().GetProperty(propertyName, _bindingFlags).SetValue(obj, value);
    }
    
    /// <summary>
    /// 是否拥有某字段
    /// </summary>
    /// <param name="obj"> 对象 </param>
    /// <param name="fieldName"> 字段名 </param>
    /// <returns> </returns>
    public static bool ContainsField(this object obj, string fieldName)
    {
        return obj.GetType().GetField(fieldName, _bindingFlags) != null;
    }
    
    /// <summary>
    /// 获取某字段值
    /// </summary>
    /// <param name="obj"> 对象 </param>
    /// <param name="fieldName"> 字段名 </param>
    /// <returns> </returns>
    public static object GetGetFieldValue(this object obj, string fieldName)
    {
        return obj.GetType().GetField(fieldName, _bindingFlags).GetValue(obj);
    }
    
    /// <summary>
    /// 设置某字段值
    /// </summary>
    /// <param name="obj"> 对象 </param>
    /// <param name="fieldName"> 字段名 </param>
    /// <param name="value"> 值 </param>
    /// <returns> </returns>
    public static void SetFieldValue(this object obj, string fieldName, object value)
    {
        obj.GetType().GetField(fieldName, _bindingFlags).SetValue(obj, value);
    }
    
    /// <summary>
    /// 获取某字段值
    /// </summary>
    /// <param name="obj"> 对象 </param>
    /// <param name="methodName"> 方法名 </param>
    /// <returns> </returns>
    public static MethodInfo GetMethod(this object obj, string methodName)
    {
        return obj.GetType().GetMethod(methodName, _bindingFlags);
    }
    /// <summary>
    /// 获取实体层描述
    /// </summary>
    /// <param name="value"> </param>
    /// <param name="Name"> </param>
    /// <returns> </returns>
    public static string GetEntityDescription(this Type value, string Name)
    {
        PropertyDescriptor s = TypeDescriptor.GetProperties(value)[Name];
        DescriptionAttribute description = s == null ? null : s.Attributes[typeof(DescriptionAttribute)] as DescriptionAttribute;
        return description == null ? "" : description.Description;
    }
    
    /// <summary>
    /// 获取实体层描述
    /// </summary>
    /// <param name="s"> </param>
    /// <returns> </returns>
    public static string GetEntityDescription(this PropertyDescriptor s)
    {
        DescriptionAttribute description = s == null ? null : s.Attributes[typeof(DescriptionAttribute)] as DescriptionAttribute;
        return description == null ? "" : description.Description;
    }

    枚举描述

    定义为扩展方法

      /// <summary>
      /// 获取枚举描述
      /// </summary>
      /// <param name="value"> 枚举值 </param>
      /// <returns> </returns>
      public static string GetDescription(this Enum value)
      {
          DescriptionAttribute attribute = value.GetType()
              .GetField(value.ToString())
              .GetCustomAttributes(typeof(DescriptionAttribute), false)
              .SingleOrDefault() as DescriptionAttribute;
          return attribute == null ? value.ToString() : attribute.Description;
      }
    
      /// <summary>
      /// 知道枚举,传入枚举英文,获取描述
      /// </summary>
      /// <param name="value"> </param>
      /// <param name="Name"> </param>
      /// <returns> </returns>
      public static string GetDescription(this Type value, string Name)
      {
          DescriptionAttribute attribute = value.GetField(Name)
              .GetCustomAttributes(typeof(DescriptionAttribute), false)
              .SingleOrDefault() as DescriptionAttribute;
          return attribute == null ? value.ToString() : attribute.Description;
      }
    展开全文
  • JavaScript语法高级之属性&属性描述

    千次阅读 2018-08-31 21:05:29
    属性描述符:修饰属性的属性 ,元属性,是属性的特征; 数据描述符:具有writable value属性描述符的属性; 访问描述符:具有set和get的属性。 set&amp;get:set中value必须写;成对出现; &lt;script ...

    这里写图片描述

    一、描述符分类:

    属性描述符:修饰属性的属性 ,元属性,是属性的特征;
    数据描述符:具有writable value属性描述符的属性;
    访问描述符:具有set和get的属性。
    set&get:set中value必须写;成对出现;

    <script type="text/javascript">
        /*
            属性描述符:修饰属性的属性 元属性 属性的特征
    
            数据描述符:具有writable 和 value属性描述符的属性
            访问描述符:具有set和get属性描述符的属性
        */
    
        var obj ={}
        Object.defineProperty(obj,"age",{
            /*value:30,
            writable:true,*/
            get:function(){
                return this.__age__;
            },
            set:function(val){
                this.__age__ = val;
            }
        })
    
    
    
        </script>

    二、属性描述符

    1、元属性
    属性的属性 称为元属性

    2、定义属性:defineProperty

    <!--定义属性:defineProperty-->
        <script type="text/javascript">
            var obj={
                name:"snw"
            };
            Object.defineProperty(obj,"age",{
                value:18,
                writable:true,
                configurable:true,
                enumerable:true
            });
            console.log(obj); //Object {name: "snw", age: 18}
            console.log(obj.age);//18
    
    
            Object.defineProperty(obj,"sex",{
                value:"man"
            })
            var result =Object.getOwnPropertyDescriptor(obj,"sex");
            console.log(result);//默认值都是false
        </script>

    3、获取属性描述符:getOwnPropertyDescriptor

    <!--获取属性:getOwnPropertyDescriptor-->
        <script type="text/javascript">
            var a="a";
            var a;
            b="b";
            console.log(Object.getOwnPropertyDescriptor(window,"a"));
            console.log(Object.getOwnPropertyDescriptor(window,"b"));
    
            delete a;
            delete b;
    
            console.log(a);
            console.log(b);
        </script>

    4、属性描述符定义
    属性描述符:修饰属性的属性 ,元属性,是属性的特征。属性描述符共有以下五类:
    1)writable&value :控制属性的可读写权限

    <script type="text/javascript">
    //      writable决定了属性值的读写权限
            var zd={};
            Object.defineProperty(zd,"wife",{
                value:"zdy",
                writable:true
            })
    
            //静默失败
            zd.wife="18岁的zdy";
            console.log(zd);
        </script>

    2)enumerable :决定属性可枚举权限
    可枚举:能否出现对象的for in循环中

    <script type="text/javascript">
    //      enumerable决定了属性能否出现在对象的for in循环中
            var zd={};
            Object.defineProperty(zd,"wife",{
                value:"18岁zdy",
                writable:true
            })
            Object.defineProperty(zd,"wife1",{
                value:"19岁zdy",
                writable:true
            })
            Object.defineProperty(zd,"wife2",{
                value:"20岁zdy",
                writable:true,
                enumerable:true
            })
            Object.defineProperty(zd,"wife3",{
                value:"21岁zdy",
                writable:true
            })
            Object.defineProperty(zd,"wife4",{
                value:"22岁zdy",
                writable:true,
                enumerable:true
    
            })
    
    
            Object.prototype.fromObjectP ="test";
            for(item in zd){
                console.log(item);
            }
    
            console.log(Object.getOwnPropertyDescriptor(zd.__proto__,"toString"))
    
    
        </script>

    3)configurable :决定属性可配置权限
    可配置:能否重新定义和能否删除(delete)

    <script type="text/javascript">
    /*      configurable决定了属性的可配置权限
                1.属性可否重新定义
                2.属性是否可删除
    
                注意:configurable为false时
    
                    value只受writable的控制
                    writable可以从true变为false
                    其他的改动一律不允许
    
    */
            var zd={};
            Object.defineProperty(zd,"wife",{
                value:"19岁zdy",
                writable:true,
                enumerable:true
            })
    
            Object.defineProperty(zd,"wife",{
                value:"19岁zdy",
                writable:false,
                enumerable:false
            })
    
            console.log(zd);
        </script>

    4)getter&setter

                    对属性进行操作时,我们可以绑上自己的业务逻辑
                    get:
                        对属性进行获取调用get方法
                    set:
                        对属性进行设置时调用set方法
        注意:     get&setvalue&writable不能同时出现;

    5、注意事项

    • value只受writable控制;writable值可以从true到flase
    • 操作符(in)可以上原型链。
    • JS中方法是浅不变形的!不会遍历原型链,只影响读写直接属性值。

    6、属性存在性
    1)存在性检查
    方法 : obj.hasOwnProperty("toString")

        <script type="text/javascript">
            var obj={
                age:18
            }
            console.log(obj.age)
            console.log("age" in obj)
            console.log(obj.hasOwnProperty("age"))
        </script>

    2) 应用:解决for in 中能够获取原型链中属性(只获取直接属性)。

    <!--for in 
             问题:循环遍历时会获取所有属性包括原型链中属性,但是通常只获取直接属性
          解决:使用hasOwnProperty过滤掉 原型链中属性-->
        <script type="text/javascript">
    //      enumerable决定了属性能否出现在对象的for in循环中
            var zd={
                son:{
                    name:"xfz"
                }
            };
            Object.defineProperty(zd,"wife",{
                value:"18岁周",
                writable:true
            })
            Object.defineProperty(zd,"wife1",{
                value:"19岁周",
                writable:true
            })
            Object.defineProperty(zd,"wife2",{
                value:"20岁周",
                writable:true,
                enumerable:true
            })
            Object.defineProperty(zd,"wife3",{
                value:"21岁周",
                writable:true
            })
            Object.defineProperty(zd,"wife4",{
                value:"22岁周",
                writable:true,
                enumerable:true
            })
            Object.defineProperty(Object.prototype,"demo",{
                value:"demo",
                writable:true,
                enumerable:true
            })
    
            for(item in zd){
                if(zd.hasOwnProperty(item)){
                    console.log(item);
                }
            }
    
    
        </script>

    三、对象不变性

    1、基本介绍

    常量属性:默认属性为false。将属性的writable和configurable设置为false。
    禁止对象扩展Object.preventExtensions(obj)**
    密封对象Object.seal(obj)
    冻结对象Object.freeze(obj)
    深度冻结

    2、代码示例:

    01_常量属性.html

    <script type="text/javascript">
    
            var math ={};
            Object.defineProperty(math,"PI",{
                value:3.141592654,
                enumerable:true
            })
    
        </script>

    02_禁止对象的扩展.html

    <script type="text/javascript">
            //对象不变性的第一个级别:禁止对象的扩展
            var obj ={
                age:18,
                name:"达姆",
                wife:{
                    name:"周冬雨",
                    age:18
                }
            };
            Object.defineProperty(obj,"PI",{
                value:3.141592654,
                enumerable:true
            })
    
    
            Object.preventExtensions(obj)
            obj.age=19;
            delete obj.wife.age;
            delete obj.name;
            console.log(obj)
    
        </script>

    03_密封对象.html

    <script type="text/javascript">
    
            var obj ={
                age:18,
                name:"达姆",
                wife:{
                    name:"周冬雨",
                    age:18
                }
            };
            Object.defineProperty(obj,"PI",{
                value:3.141592654,
                enumerable:true
            })
    
    //      浅密封
            Object.seal(obj)
            obj.age=19;
            delete obj.wife.age;
            delete obj.name;
            console.log(obj)
    
        </script>

    04_冻结对象.html

    <script type="text/javascript">
    
            var obj ={
                age:18,
                name:"达姆",
                wife:{
                    name:"周冬雨",
                    age:18
                }
            };
            Object.defineProperty(obj,"PI",{
                value:3.141592654,
                enumerable:true
            })
    
            //冻结对象
            Object.freeze(obj)
            obj.age=19;
            delete obj.wife.age;
            delete obj.name;
            console.log(obj)
    
        </script>

    05_深度冻结对象.html

    <script type="text/javascript">
    
            var obj ={
                age:18,
                name:"达姆",
                wife:{
                    name:"周冬雨",
                    age:18
                }
            };
    
    //      浅冻结
            Object.freeze(obj);
    
            //深度冻结操作:遍历每一个子元素,并分别冻结
            for(item in obj){
                //除了Object.prptotype
                if(obj[item] instanceof Object){
                    Object.freeze(obj[item]);
                }
            }
    
            obj.wife.name="aaa";
            delete obj.wife.age;
            console.log(obj)
    
        </script>

    四、属性的设置与获取

    1、 属性查找: [[Get]]:代表的属性查找的算法
    [[Get]]:

     1.在对象中查找是否具有相同名称的属性,如果找到,就会返回这个属性的值。
     2.如果没有找到,则遍历原型链
     3.无论·如何都没找到,返回undefined

    属性的设置与获取.html

    <script type="text/javascript">
        /*
            属性(writable为true的数据描述符)
            属性的获取:
                先在当前对象中找 
                    如果找到则使用
                    如果找不到  上隐式原型链
                        如果找到使用
                        如果找不到  返回undefined
    
            属性的设置
                不管怎么样都影响对象的直接属性
        */
    
    
    
    
        /*[[Get]]1.在对象中查找是否具有相同名称的属性,如果找到,就会返回这个属性的值。
            2.如果没有找到,则遍历原型链
            3.无论·如何都没找到,返回undefined
            4.如果属性是访问描述符就看get方法的逻辑!!*/
    
    
    
    
             /*
             obj.a="a";
             [[put]]1.如果属性直接存在于对象中 不在原型链上
             4.如果属性直接存在于对象中  也在原型链上
                     找到直接存在于对象中的属性
                     -数据描述符(没有setter/getter)
                            直接修改对象中的属性(注意writbale的值)
                     -访问描述符
                            直接调用set方法
             2.如果属性不直接存在于对象中也不在原型链上
                    在对象的直接属性中添加一个属性(数据描述符)    
                     value:"a"
                     writable:true
                     configurable:true
                     enumerable:true
    
             3.如果属性不直接存在于对象中  在原型链上
                     ①.该属性是数据描述符(没有setter/getter)
                         -writbale为true
                     直接在对象中添加一个属性,我们称之为屏蔽属性
                         -writbale为false
                         报错,不会生成屏蔽属性
    
                     ②.该属性是访问描述符
                         调用set,不会生成屏蔽属性
            */
    
    
    
    
            /*
            3.如果属性不直接存在于对象中  在原型链上
                     ①.该属性是数据描述符(没有setter/getter)
                         -writbale为true
                                直接在对象中添加一个属性,我们称之为屏蔽属性
                         -writbale为false
                                静默失败,不会生成屏蔽属性
    
                     ②.该属性是访问描述符
                            调用set,不会生成屏蔽属性
            */
            var obj={};
            Object.defineProperty(Object.prototype,"age",{
                /*value:18,
                writable:false*/
                get:function(){
    
                },
                set:function(val){
    
                }
            })
            obj.age=1;
            console.log(obj,Object.prototype.age);
        </script>

    2、属性设置:[[Put]]:代表的属性设置的算法

    [[put]]:

      1.如果属性直接存在于对象中 不在原型链上
        找到直接存在于对象中的属性
            -数据描述符(没有setter/getter)
               直接修改对象中的属性(注意writbale的值)
            -访问描述符
                直接调用set方法
    
        2.如果属性不直接存在于对象中也不在原型链上
            在对象的直接属性中添加一个属性(数据描述符)    
                 value:"a"
                 writable:true
                 configurable:true
                 enumerable:true
    
        3.如果属性不直接存在于对象中  在原型链上
             ①.该属性是数据描述符(没有setter/getter)
                 -writbale为true
                    直接在对象中添加一个属性,我们称之为屏蔽属性
                 -writbale为false
                     报错,不会生成屏蔽属性
    
             ②.该属性是访问描述符
                   调用set,不会生成屏蔽属性
    
    
        4.如果属性直接存在于对象中  也在原型链上
          找到直接存在于对象中的属性
                -数据描述符(没有setter/getter)
                   直接修改对象中的属性(注意writbale的值)
                -访问描述符
                    直接调用set方法

    01如果属性直接存在于对象中,不在原型链上.html

    <script type="text/javascript">
    //  如果属性直接存在于对象中 不在原型链上
            console.log(Object.prototype)
    
    
    //      -数据描述符(没有setter/getter)
    //          直接修改对象中的属性(注意writbale的值)
            var obj={
                a:"a"
            }
    
            Object.defineProperty(obj,"a",{
                writable:false
            })
    
            obj.a="b";
            console.log(obj.a)
    
    //  -访问描述符
    //          直接调用set方法
            var obj2={
                a:"a"
            }
    
            Object.defineProperty(obj2,"a",{
                get :function(){
                    return this._a_;
                },
                set :function(val){
                    this._a_ = val;
                }
            })
    
            obj2.a="b";
            console.log(obj2)
            console.log(obj2.a)
        </script>

    02如果属性不直接存在于对象中也不在原型链上.html

    <script type="text/javascript">
    //  如果属性不直接存在于对象中也不在原型链上
            console.log(Object.prototype)
            var obj={}
            obj.a="a";
            console.log(obj.a)
    
            var result =Object.getOwnPropertyDescriptor(obj,"a");
            console.log(result);
        </script>

    03如果属性不直接存在于对象中 在原型链上.html

        <script type="text/javascript">
    //  如果属性不直接存在于对象中  在原型链上
            Object.prototype.a="prototypeA";
            console.log(Object.prototype);
            var result = Object.getOwnPropertyDescriptor(Object.prototype,"a");
            console.log(result);
    
    //      ①.该属性是数据描述符(没有setter/getter)
    //          -writbale为true
    //          直接在对象中添加一个属性,我们称之为屏蔽属性
            var obj={};
            obj.a="a";
            console.log(obj,"------------------------------")
    
    
    //          -writbale为false
    //          报错,不会生成屏蔽属性
            Object.defineProperty(Object.prototype,"a",{
                writable:false
            });
            console.log(Object.prototype);
            var result = Object.getOwnPropertyDescriptor(Object.prototype,"a");
            console.log(result);
    
            var obj2={};
            obj2.a="a";
            console.log(obj2,"------------------------------")
    
    
    //      ②.该属性是访问描述符
    //          调用set,不会生成屏蔽属性
            Object.defineProperty(Object.prototype,"a",{
    //          get:function(){
    //              
    //          },
                set:function(val){
    
                }
            });
            console.log(Object.prototype);
            var result = Object.getOwnPropertyDescriptor(Object.prototype,"a");
            console.log(result);
    
            var obj3={};
            obj3.a="a";
            console.log(obj3,"------------------------------")
    
    
        </script>

    04如果属性直接存在于对象中 也在原型链上.html

    <script type="text/javascript">
    //  如果属性直接存在于对象中  也在原型链上
            Object.prototype.a="prototypeA";
            console.log(Object.prototype)
    
            var obj={
                get a(){
                    return this._a_;
                },
                set a(val){
                    this._a_="_a_";
                }
            }
            obj.a="b";
            console.log(obj)
            console.log(Object.prototype)
        </script>
    展开全文
  • 解决办法,获取到组件的this,然后利用this去拿到组件的name属性,这样的话,代码就可以这么写: catchError.call(this, 'errorDescription') 我们就只需要专注于错误描述就行了(说不定错误描述也是一个变量,那
  • 主要介绍了Python3 获取文件属性的方式(时间、大小等),具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 引入描述子简化和约简的概念, 给出描述子的区分函数, 利用布尔推理理论求取描述子的约简, 并由此获取信息系统的优化决策规则.从保持原系统决策信息的角度出发, 定义信息系统的GS-约简和DS-约简,G-约简和D-约简.通过...
  • C#中获取类的属性属性

    万次阅读 2017-05-16 15:49:15
    通过遍历来获取类的属性属性的值,具体实现是通过反射获取属性再根据属性获取其值。具体代码如下。 /// /// 获取对象的属性和值 /// /// 对象 /// 返回属性与值一一对应的字典 public static Dictionary ...
  • 浅析 python 属性描述符(上)

    千次阅读 2019-06-11 14:20:21
    转载自我自己的 github 博客 ——>...浅析 python 属性描述符(上) 浅析 python 属性描述符(下) python 导入时与运行时 python 元编程之动态属性 python 元编程之类元编程 Review 在上一...
  • C# 获取所有USB属性

    2019-04-29 14:32:09
    C#查询所有usb设备ID,设备名称,设备描述,服务,设备状态,供应商标识,产品编号 ,设备安装类GUID
  • 获取对象属性描述

    千次阅读 2013-11-21 11:31:26
    return "未知属性名称"; } public static string GetPropertyName(Expression, object>> expr) { var rtn = ""; if (expr.Body is UnaryExpression) { rtn = ((MemberExpression)((UnaryExpression)expr....
  • 目录python 属性类属性和实例属性@property装饰器属性描述符`__set__`方法 python 属性 类属性和实例属性 在类中定义的是类属性,在实例中定义的是实例属性。 如下定义的属性是类属性: class Person: name = None ...
  • ES5中对象的属性可以分为数据属性和访问器属性 数据属性 数据属性包含以下4个特性: [[configurable]]:表示属性是否可以被delete,是否可以被重新修改,或者是否可以被修改成访问器属性 [[enumerable]]:是否可...
  • Python类及获取对象属性方法解析

    千次阅读 2020-11-23 23:42:44
    Python类及获取对象属性方法解析1.类外面添加对象属性class Washer():def wash(self):print('do some laundry stuff')haier1 = Washer()#添加属性,对象名、属性名 = 值haier1.width = 400haier1.height = 500对象...
  • 属性描述属性描述符的介绍属性描述符作用属性描述符协议代码解释注意实现需求调用顺序 属性描述符的介绍 它是一个强大的通用协议 它是properties, methods, static methods, class methods 和super()的调用原理 ...
  • 利用布尔推理理论求取描述子的约简,并由此获取信息系统的优化决策规则。从保持原系统决策信息的角度出发,定义信息系统的Gs-约简和Ds-约简,G-约简和D-约简。通过对这几种约简及其关系的讨论,从不同角度考察了信息...
  • C# 获取变量或属性的名称

    千次阅读 2020-04-29 22:22:59
    偶尔我们需要直接获取变量或属性的名称,如下: class Men{ int age{get;set;} } Men m =new Men(); m.age;//这里我们想输出age 实现办法如下: public static string PropName(Expression<Func<...
  • 详解Java8中如何通过方法引用获取属性

    千次阅读 热门讨论 2020-04-26 23:07:34
    在我们开发过程中常常有一个需求,就是要知道实体类中Getter方法对应的属性名称(Field Name),例如实体类属性到数据库字段的映射,我们常常是硬编码指定 属性名,这种硬编码有两个缺点。 1、编码效率低:因为要硬...
  • studio开发安卓中的属性描述

    千次阅读 2017-02-17 19:20:50
    一、属性值为具体的像素值,如30dp,40px,50sp android:layout_width定义本元素的宽度 android:layout_height定义本元素的高度 android:layout_margin 本元素离上下左右间的距离  android:layout_marginBottom 离...
  • 获取枚举值的属性

    2021-03-04 10:01:26
    我想知道是否可以获取枚举值而不是枚举本身的属性? 例如,假设我有以下枚举:using System.ComponentModel; // for DescriptionAttributeenum FunkyAttributesEnum{[Description("Name With Spaces1")]...
  • 添加链接描述 遇到js对象时可以将其转为json对象
  • java获取实体类的属性名和属性

    千次阅读 2021-01-28 12:22:45
    在Java反射中Field类描述的是类的属性信息,功能包括: 获取当前对象的成员变量的类型 对成员变量重新设值 Field常用方法 getType(): 获取属性声明时类型对象(返回class对象) getGenericType() : 返回属性声的...
  • java通过反射获取某个类的所有属性

    千次阅读 2021-10-25 18:42:00
    最近项目上需要通过自定义类中的类型去添加校验,然后我想到了可以通过反射去获取类中的属性获取类型,所以在这里记录一下,基本代码如下: import BO.QweBO; import java.lang.reflect.Field; public class ...
  • 如何利用Python爬虫库BeautifulSoup获取对象(标签)名,属性,内容,注释等操作下面就为大家介绍一下一、Tag(标签)对象1.Tag对象与XML或HTML原生文档中的tag相同。from bs4 import BeautifulSoupsoup = BeautifulSoup('...
  • JQ获取对象的属性与值

    千次阅读 2018-07-19 09:13:04
    1.获取对象的常用方法 $(“*”) 表示获取所有对象(一般都不会去使用) $(“#XXX”) ’获得 id=XXX 的元素对象(常用) $(“.XXX”) ’获得 class=XXX 的元素对象(常用) $(“div”) ’ 标签选择器 选择所有的...
  • ** BeanInfo **:提供有关Bean的显式信息的接口,其中包含类的属性,方法、事件等显式信息,可以通过Introspector底层反射机制获取** Introspector **:用于构建一个一个全面描述目标bean的BeanInfo对象,使用低层次的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 838,346
精华内容 335,338
关键字:

获取属性的描述