精华内容
下载资源
问答
  • ECMAScript提供的对象有:String、Date、Array、Boolean、Math、Number、RegExp、Global 程序中需要用到很多自定义的js对象 1、直接创建 var obj = new Object(); obj.username = "jinxiao"; obj.age = 26; 可...

    ECMAScript提供的对象有:String、Date、Array、Boolean、Math、Number、RegExp、Global

    程序中需要用到很多自定义的js对象

    1、直接创建

    var obj = new Object();

    obj.username = "jinxiao";

    obj.age = 26;

    可替代该方法的是:var obj = {username:"jinxiao",age:26};

    2、构造函数创建

    function Obj(username,age){

      this.username = username;

      this.age = age;

    }

    var obj1 = new Obj("jinxiao",26);

    var obj2 = new Obj("brotherxiao",27);

     

    转载于:https://www.cnblogs.com/jinxiao/p/5625372.html

    展开全文
  • 对于一个普通的对象来说,如果它的所有property名均为正整数,同时也相应的length属性,那么虽然该对象并不是由Array构造函数所创建的,它依然呈现出数组的行为,在这种情况下,这些对象被称为类数组对象。...

    首先说说什么是类数组,类数组有几个组成部分:

    • 属性要为索引(数字)。
    • 必须有length属性,
    • 最好加上push和splice方法

    对于一个普通的对象来说,如果它的所有property名均为正整数,同时也有相应的length属性,那么虽然该对象并不是由Array构造函数所创建的,它依然呈现出数组的行为,在这种情况下,这些对象被称为类数组对象

    类数组的length属性会随着数组成员的增减而发生变化,同时又从Array构造函数中继承了一些用于进行数组操作的方法。

    var obj = {
        "0" : 'a',
        "1" : 'b',
        "2" : 'c',
        "length" : 3,
        "push" : Array.prototype.push,
        "splice" : Array.prototype.splice
    }

    前面已经说了,类似数组的对象,本质特征只有一点,即必须有length属性。因此,任何有length属性的对象,都可以通过Array.from方法转为数组。

    let arrayLike = {
        '0' : 'a',
        '1' : 'b',
        '2' : 'c',
        length : 3
    };
    let arr1 = Array.prototype.slice.call(arrayLike);
    let arr2 = [].slice.call(arrayLike);
    let arr3 = Array.from(arrayLike);

    注意

    在浏览器环境中,document.getElementsByTagName()语句返回的就是一个类数组对象。

    在function调用中,function代码内的arguments变量(保存传入的参数)也是一个类数组对象。

    展开全文
  • C#里用来创建对象方式有以下几种 调用构造函数 new obj(...) 初始化成员列表 new obj { f1 = xxx, f2 = xxx, ... } 创建数组 new arraytype[] { e1, e2, e3, ...} 如果是匿名对象话,创建方式

    C#里用来创建对象的方式有以下几种

    调用构造函数 new obj(...)

    初始化成员列表 new obj { f1 = xxx, f2 = xxx, ... }

    创建数组 new arraytype[] { e1, e2, e3, ...}

    如果是匿名对象话,创建方式只有后2种。

    非匿名对象的创建:

            private Expression ProcessNewExpression(ParseTreeNode expNode)
            {
                var typeName = expNode.GetChild("qual_name_with_targs").FindTokenAndGetText();
                var args = expNode.GetChild("creation_args").GetDescendant("argument_list");
                var arglist = new List<Expression>();
                if (args != null)
                {
                    foreach (var arg in args.ChildNodes)
                    {
                        arglist.Add(ProcessExpression(arg.FirstChild));
                    }
                }
                var type = GetType(typeName);
    
                if (expNode.GetChild("creation_args").HasChild("array_creation_args"))
                {
                    var elements = expNode.GetChild("array_initializer_opt").GetDescendant("elem_initializer_list");
                    var elemlist = new List<Expression>();
                    if (elements != null)
                    {
                        foreach (var child in elements.ChildNodes)
                        {
                            elemlist.Add(ProcessExpression(child.GetChild("initializer_value").FirstChild));
                        }
                    }
                    return Expression.NewArrayInit(type, elemlist);
                }
    
                var newexp = Expression.New(type.GetConstructor(arglist.Select(e => e.Type).ToArray()), arglist);
                var members = expNode.GetChild("array_initializer_opt").GetDescendant("elem_initializer_list");
                var bindlist = new List<MemberBinding>();
                if (members != null)
                {
                    foreach (var child in members.ChildNodes)
                    {
                        var memberName = child.GetChild("Identifier").GetValue();
                        var expr = ProcessExpression(child.GetChild("initializer_value").FirstChild);
                        bindlist.Add(Expression.Bind(type.GetMember(memberName).First(), expr));
                    }
                }
                return Expression.MemberInit(newexp, bindlist);
            }


    大致过程就是先获得创建对象的类型,然后分析是否有调用构造方法并获取构造参数列表,如是创建数组对象则获取元素列表并返回数组初始化表达式,最后就是如果有成员初始化列表就和new表达式一起使用。

    匿名类型创建:

            private Expression ProcessNewAnonymousExpression(ParseTreeNode expNode)
            {
                if (expNode.HasChild("anonymous_array_creation_expression"))
                {
                    var elements = expNode.GetDescendant("element_declarator_list");
                    var elemlist = new List<Expression>();
                    var elemtype = typeof(void);
                    if (elements != null)
                    {
                        foreach (var child in elements.ChildNodes)
                        {
                            var exp = ProcessExpression(child.FirstChild);
                            elemtype = exp.Type;
                            elemlist.Add(exp);
                        }
                    }
                    return Expression.NewArrayInit(elemtype, elemlist);
                }
    
                var members = expNode.GetDescendant("member_declarator_list");
                var memblist = new List<Expression>();
                var names = new List<string>();
                var types = new List<Type>();
                List<AnonymousMetaProperty> properties = new List<AnonymousMetaProperty>();
                if (members != null)
                {
                    foreach (var child in members.ChildNodes)
                    {
                        var name = child.GetChild("Identifier").GetValue();
                        var expr = ProcessExpression(child.GetChild("primary_expression"));
                        names.Add(name);
                        types.Add(expr.Type);
                        memblist.Add(expr);
                    }
                }
    
                return GetAnonymousExpression(names.ToArray(), types.ToArray(), memblist.ToArray());
            }


     创建匿名表达式最大的问题是需要对匿名类型进行引用,也就是说需要在解析的时候动态创建匿名类型,在项目里使用了InterLinq创建匿名类型部分的代码(InterLinq是一个提供远程执行LINQ方法的框架)来创建一个匿名类型:

            private static Type GetAnonymousType(string[] propertyNames, Type[] propertyTypes)
            {
                List<AnonymousMetaProperty> properties = new List<AnonymousMetaProperty>();
                for (int i = 0; i < propertyNames.Length; ++i)
                {
                    properties.Add(new AnonymousMetaProperty(propertyNames[i], propertyTypes[i]));
                }
                return  AnonymousTypeHelper.GetAnonymousType(properties.ToArray()).GetClrType();
            }
    
            private Expression GetAnonymousExpression(IEnumerable<string> names, IEnumerable<Type> types, IEnumerable<Expression> membs)
            {
                var newobj = GetAnonymousType(names.ToArray(), types.ToArray());
                return Expression.New(newobj.GetConstructor(types.ToArray()), membs, newobj.GetProperties());
            }


    不过匿名数组可以根据初始化参数确定数组元素类型所以无需创建匿名类型这个过程。

     

    至此大部分的表达式都能被顺利解析转换了,用Irony对lambda表达式解析的介绍就告一段落了,对typeof、泛型调用以及BlockExpression等的支持和grammar的进一步完善留着下次再介绍了。

    展开全文
  • C#里用来创建对象方式有以下几种 调用构造函数 new obj(...) 初始化成员列表 new obj { f1 = xxx, f2 = xxx, ... } 创建数组 new arraytype[] { e1, e2, e3, ...} 如果是匿名对象话,创建方式只有后2种。 非...

    C#里用来创建对象的方式有以下几种

    调用构造函数 new obj(...)

    初始化成员列表 new obj { f1 = xxx, f2 = xxx, ... }

    创建数组 new arraytype[] { e1, e2, e3, ...}

    如果是匿名对象话,创建方式只有后2种。

    非匿名对象的创建:

    1. private Expression ProcessNewExpression(ParseTreeNode expNode)
    2. {
    3. var typeName = expNode.GetChild("qual_name_with_targs").FindTokenAndGetText();
    4. var args = expNode.GetChild("creation_args").GetDescendant("argument_list");
    5. var arglist = new List<Expression>();
    6. if (args != null)
    7. {
    8. foreach (var arg in args.ChildNodes)
    9. {
    10. arglist.Add(ProcessExpression(arg.FirstChild));
    11. }
    12. }
    13. var type = GetType(typeName);
    14. if (expNode.GetChild("creation_args").HasChild("array_creation_args"))
    15. {
    16. var elements = expNode.GetChild("array_initializer_opt").GetDescendant("elem_initializer_list");
    17. var elemlist = new List<Expression>();
    18. if (elements != null)
    19. {
    20. foreach (var child in elements.ChildNodes)
    21. {
    22. elemlist.Add(ProcessExpression(child.GetChild("initializer_value").FirstChild));
    23. }
    24. }
    25. return Expression.NewArrayInit(type, elemlist);
    26. }
    27. var newexp = Expression.New(type.GetConstructor(arglist.Select(e => e.Type).ToArray()), arglist);
    28. var members = expNode.GetChild("array_initializer_opt").GetDescendant("elem_initializer_list");
    29. var bindlist = new List<MemberBinding>();
    30. if (members != null)
    31. {
    32. foreach (var child in members.ChildNodes)
    33. {
    34. var memberName = child.GetChild("Identifier").GetValue();
    35. var expr = ProcessExpression(child.GetChild("initializer_value").FirstChild);
    36. bindlist.Add(Expression.Bind(type.GetMember(memberName).First(), expr));
    37. }
    38. }
    39. return Expression.MemberInit(newexp, bindlist);
    40. }

    private Expression ProcessNewExpression(ParseTreeNode expNode) { var typeName = expNode.GetChild("qual_name_with_targs").FindTokenAndGetText(); var args = expNode.GetChild("creation_args").GetDescendant("argument_list"); var arglist = new List<Expression>(); if (args != null) { foreach (var arg in args.ChildNodes) { arglist.Add(ProcessExpression(arg.FirstChild)); } } var type = GetType(typeName); if (expNode.GetChild("creation_args").HasChild("array_creation_args")) { var elements = expNode.GetChild("array_initializer_opt").GetDescendant("elem_initializer_list"); var elemlist = new List<Expression>(); if (elements != null) { foreach (var child in elements.ChildNodes) { elemlist.Add(ProcessExpression(child.GetChild("initializer_value").FirstChild)); } } return Expression.NewArrayInit(type, elemlist); } var newexp = Expression.New(type.GetConstructor(arglist.Select(e => e.Type).ToArray()), arglist); var members = expNode.GetChild("array_initializer_opt").GetDescendant("elem_initializer_list"); var bindlist = new List<MemberBinding>(); if (members != null) { foreach (var child in members.ChildNodes) { var memberName = child.GetChild("Identifier").GetValue(); var expr = ProcessExpression(child.GetChild("initializer_value").FirstChild); bindlist.Add(Expression.Bind(type.GetMember(memberName).First(), expr)); } } return Expression.MemberInit(newexp, bindlist); }


    大致过程就是先获得创建对象的类型,然后分析是否有调用构造方法并获取构造参数列表,如是创建数组对象则获取元素列表并返回数组初始化表达式,最后就是如果有成员初始化列表就和new表达式一起使用。

    匿名类型创建:

    1. private Expression ProcessNewAnonymousExpression(ParseTreeNode expNode)
    2. {
    3. if (expNode.HasChild("anonymous_array_creation_expression"))
    4. {
    5. var elements = expNode.GetDescendant("element_declarator_list");
    6. var elemlist = new List<Expression>();
    7. var elemtype = typeof(void);
    8. if (elements != null)
    9. {
    10. foreach (var child in elements.ChildNodes)
    11. {
    12. var exp = ProcessExpression(child.FirstChild);
    13. elemtype = exp.Type;
    14. elemlist.Add(exp);
    15. }
    16. }
    17. return Expression.NewArrayInit(elemtype, elemlist);
    18. }
    19. var members = expNode.GetDescendant("member_declarator_list");
    20. var memblist = new List<Expression>();
    21. var names = new List<string>();
    22. var types = new List<Type>();
    23. List<AnonymousMetaProperty> properties = new List<AnonymousMetaProperty>();
    24. if (members != null)
    25. {
    26. foreach (var child in members.ChildNodes)
    27. {
    28. var name = child.GetChild("Identifier").GetValue();
    29. var expr = ProcessExpression(child.GetChild("primary_expression"));
    30. names.Add(name);
    31. types.Add(expr.Type);
    32. memblist.Add(expr);
    33. }
    34. }
    35. return GetAnonymousExpression(names.ToArray(), types.ToArray(), memblist.ToArray());
    36. }

    private Expression ProcessNewAnonymousExpression(ParseTreeNode expNode) { if (expNode.HasChild("anonymous_array_creation_expression")) { var elements = expNode.GetDescendant("element_declarator_list"); var elemlist = new List<Expression>(); var elemtype = typeof(void); if (elements != null) { foreach (var child in elements.ChildNodes) { var exp = ProcessExpression(child.FirstChild); elemtype = exp.Type; elemlist.Add(exp); } } return Expression.NewArrayInit(elemtype, elemlist); } var members = expNode.GetDescendant("member_declarator_list"); var memblist = new List<Expression>(); var names = new List<string>(); var types = new List<Type>(); List<AnonymousMetaProperty> properties = new List<AnonymousMetaProperty>(); if (members != null) { foreach (var child in members.ChildNodes) { var name = child.GetChild("Identifier").GetValue(); var expr = ProcessExpression(child.GetChild("primary_expression")); names.Add(name); types.Add(expr.Type); memblist.Add(expr); } } return GetAnonymousExpression(names.ToArray(), types.ToArray(), memblist.ToArray()); }


    创建匿名表达式最大的问题是需要对匿名类型进行引用,也就是说需要在解析的时候动态创建匿名类型,在项目里使用了InterLinq创建匿名类型部分的代码(InterLinq是一个提供远程执行LINQ方法的框架)来创建一个匿名类型:

    1. private static Type GetAnonymousType(string[] propertyNames, Type[] propertyTypes)
    2. {
    3. List<AnonymousMetaProperty> properties = new List<AnonymousMetaProperty>();
    4. for (int i = 0; i < propertyNames.Length; ++i)
    5. {
    6. properties.Add(new AnonymousMetaProperty(propertyNames[i], propertyTypes[i]));
    7. }
    8. return AnonymousTypeHelper.GetAnonymousType(properties.ToArray()).GetClrType();
    9. }
    10. private Expression GetAnonymousExpression(IEnumerable<string> names, IEnumerable<Type> types, IEnumerable<Expression> membs)
    11. {
    12. var newobj = GetAnonymousType(names.ToArray(), types.ToArray());
    13. return Expression.New(newobj.GetConstructor(types.ToArray()), membs, newobj.GetProperties());
    14. }

    private static Type GetAnonymousType(string[] propertyNames, Type[] propertyTypes) { List<AnonymousMetaProperty> properties = new List<AnonymousMetaProperty>(); for (int i = 0; i < propertyNames.Length; ++i) { properties.Add(new AnonymousMetaProperty(propertyNames[i], propertyTypes[i])); } return AnonymousTypeHelper.GetAnonymousType(properties.ToArray()).GetClrType(); } private Expression GetAnonymousExpression(IEnumerable<string> names, IEnumerable<Type> types, IEnumerable<Expression> membs) { var newobj = GetAnonymousType(names.ToArray(), types.ToArray()); return Expression.New(newobj.GetConstructor(types.ToArray()), membs, newobj.GetProperties()); }


    不过匿名数组可以根据初始化参数确定数组元素类型所以无需创建匿名类型这个过程。

    至此大部分的表达式都能被顺利解析转换了,用Irony对lambda表达式解析的介绍就告一段落了,对typeof、泛型调用以及BlockExpression等的支持和grammar的进一步完善留着下次再介绍了。

    转载于:https://www.cnblogs.com/liuhaili/archive/2011/10/13/2210995.html

    展开全文
  • js_Array学习

    2020-11-12 15:26:13
    创建数组的方式有如下几种: //1. 使用构造函数创建 var colors = new Array(20); var colors = new Array("red","blue"); var colors = Array(20);//省略new //2. 使用数组字面量的方式构造 var colors = ["red",...
  • numpy作为python科学计算的基础模块,...numpy主要以下几种方式创建数组。除此之外,其他过程也可能产生数组,比如:cv2.imread读取图片,返回数组。 np.array() # 传入类数组数据结构,list,tuple等,或者其他嵌套
  • 在JS中,对象引用类型共可分为以下几种,Object、Array、Date、RegExp、Function,以及类似于JAVA包装机制的Boolean、Number、String,还有内置对象...创建Object对象有种方式 var obj=new Object(); obj.name...
  • 类型创建与检测Object创建Array创建检测 引用类型是一数据结构,用于 将数据和功能组织在一起,时候也被称为对象定义。因为它们 描述的一类 对象所具有的属性和方法 Object 创建 方法一:对象直接量 let ...
  • Symbol对象是什么

    2020-12-27 09:27:49
    获取symbol类型值的三种方式 <ul><li>通过Symbol对象 > 也就是前面说的 <pre><code>let sym = Symbol();</code></pre>得到一个为一个的symbol值</li><li> <p>Symbol.for(string) > 可以注册一个symbol&#...
  • JavaScript-数组详解

    千次阅读 2015-06-11 18:18:40
    前言计划赶不上变化,本来想深入学习python的我,无奈要转到js开发,在...创建数组js中数组的声明可以如下几种方式:var arr = []; // 简写模式 var arr = new Array(); // new一个array对象 var arr = new Array(arr
  • 这个方法能够判断一个对象是否是一个Array类型或者其派生类型。 <pre><code>js class MyArray extends Array {} const arr1 = []; const arr2 = new MyArray(); console.log(Array.isArray(arr1), Array....
  • js中的数组

    2018-07-02 22:22:56
    js中内置对象Array作为创建数组之用(数组是动态性的,想调用方法(函数),必须要先new或者其他方式生成对象)数组的几种声明方式;1.创建 Array 对象的语法:new Array(); new Array(size); new Array(element0, ...
  • 有几种方式可以创建数组,一种是数组字面量,一种是通过new关键字调用但不传递参数或者传递参数,也可以直接使用Array()创建,在ES6中新增了两个静态方法创建数组:Array.from和Array.of let a = [] let a1 = [1, 2,...
  • 总的来说JavaScript是面向对象语言,其实与java很多共通的地方。 声明和实例化:与java一样,利用new关键字创建对象,区别在于javascript对象构造函数如果没有...Array对象几种创建方式:var arr = new Array(); ...
  • 第五章——引用类型

    2017-04-22 22:17:00
    创建对象有种方式:1.new出一个Object的实例;2.使用对象字面量来创建对象,在对象字面量中,使用逗号分隔不同的属性,但最后一个属性的后面不能再添加逗号,在IE7以前的版本会报错。 使用对象字面量,属性名...
  • js中数组的声明可以如下几种方式: var arr = []; // 简写模式 var arr = new Array(); // new一个array对象 var arr = new Array(arrayLength); // new一个确定长度的array对象 要说明的是: 虽然第三种方法...
  • 关于数组

    2017-07-29 22:36:00
    创建对象几种常用方式1、 var arr = [];//创建一个空数组 var arr2 = [1,2,3];//创建一个三个元素的数组 2、 a、var arr1 = new Array();//创建空数组 b、var arr2 = new Array(10);//创建一个长度为10的...
  • 创建一个不可变数组NSArray以下几种方式//仅仅开辟了一块内存并创建了一个NSArray类型的对象,没有什么内容 NSArray *array = [[NSArray alloc]init];   //开辟内存创建一个带多个对象的数组 //id是通用...
  • **numpy的基本操作** 下面是我个人关于numpy基本知识的...如上有几种代表性的创建方式,第一种是输入一个seq序列,可以是列表,元组,字典等,第二种是以arange等函数创建,第三种是预定式的数创建,如此数组na3即为.
  • 为了解决这个问题,经过 vue 内部处理后可以使用以下几种方法来监听数组 <pre><code>js push(); pop(); shift(); unshift(); splice(); sort(); reverse(); </code></pre> 由于只针对了以上 7 种方法进行了 hack ...
  • JS核心原理 ...Array构造器用于创建一个新的数组,通常推荐使用对象字面的方式创建一个数组 // 使用Array构造器,可以自定义长度 var a = Array(6); //[undefined * 6] //使用对象字面量 var b = []; b
  • JS中的数组

    2021-06-08 10:49:52
    除了 Object,Array 应该就是 ECMAScript 中最常用的类型了。ECMAScript 数组跟其他编程语言 的数组有很大区别。跟其他语言中的数组一样,...有几种基本的方式可以创建数组。一种是使用 Array 构造函数,比如.
  • 1 Numpy基础

    2021-01-23 01:16:27
    种方式,如从已数据中创建,利用random创建创建特定形状的多维数 组,利用arange、linspace函数生成等 1.1.1 从已数据中创建数组 直接对Python的基础数据类型(如列表、元组等)进行转换来生成 ndarray:
  • 有些面试题记得不是很清楚,大概回忆了下: Array能不能动态长度? sleep(), wait()和yield()的...有几种方式创建一个实例 手动写Equals方法 ImageLoader是否用过 surfaceview是用来做什么的 Java中创建对象实例的...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 124
精华内容 49
关键字:

创建array对象有几种方式