创建array对象有几种方式

创建javascript对象的几种方式

2016-06-28 23:26:00

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

收起

展开全文

JavaScript：将类数组转换成数组的几种方式

2018-11-13 15:40:42

对于一个普通的对象来说，如果它的所有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变量(保存传入的参数)也是一个类数组对象。

收起

展开全文

JavaScript 数组类数组转换

lambda表达式的解析（七）对象的创建

千次阅读 2011-08-04 16:47:06

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的进一步完善留着下次再介绍了。

收起

展开全文

lambda properties list null

（转）lambda表达式的解析（七）对象的创建

2011-10-13 22:49:00

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种。
非匿名对象的创建：


view plaincopy to clipboardprint?

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

        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表达式一起使用。
匿名类型创建：


view plaincopy to clipboardprint?

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

        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方法的框架）来创建一个匿名类型：


view plaincopy to clipboardprint?

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

        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",...
收起
第5章　JavaScript对象与数组
收起
Numpy 理解ndarray对象的示例代码
2021-01-20 01:43:21
numpy作为python科学计算的基础模块，...numpy主要有以下几种方式创建数组。除此之外，其他过程也可能产生数组，比如：cv2.imread读取图片，返回数组。 np.array() # 传入类数组数据结构，list，tuple等，或者其他嵌套
收起
JavaScript 对象引用类型(穿插了很多与Python的比较)
2011-06-12 09:42:00
在JS中，对象引用类型共可分为以下几种，Object、Array、Date、RegExp、Function，以及类似于JAVA包装机制的Boolean、Number、String，还有内置对象...创建Object对象有两种方式 var obj=new Object(); obj.name...
收起
几年之后再看JavaScript--引用类型
2020-05-13 17:37:24
类型创建与检测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&#...
收起
第6章　字符串与数值处理对象
收起
第30章对象相等性
收起
JavaScript-数组详解
千次阅读 2015-06-11 18:18:40
前言计划赶不上变化，本来想深入学习python的我，无奈要转到js开发，在...创建数组js中数组的声明可以有如下几种方式：var arr = []; // 简写模式 var arr = new Array(); // new一个array对象 var arr = new Array(arr
收起
javascript 排序算法
如何准确判断一个对象的类型?
2020-12-28 10:23:51
这个方法能够判断一个对象是否是一个Array类型或者其派生类型。 <pre><code>js class MyArray extends Array {} const arr1 = []; const arr2 = new MyArray(); console.log(Array.isArray(arr1), Array....
收起
附录A　培训实习生——面向对象基础
收起
js中的数组
2018-07-02 22:22:56
js中有内置对象Array作为创建数组之用(数组是动态性的,想调用方法(函数),必须要先new或者其他方式生成对象)数组的几种声明方式;1.创建 Array 对象的语法：new Array(); new Array(size); new Array(element0, ...
收起
集合引用类型篇（一）
2021-04-05 11:33:04
有几种方式可以创建数组，一种是数组字面量，一种是通过new关键字调用但不传递参数或者传递参数，也可以直接使用Array()创建，在ES6中新增了两个静态方法创建数组：Array.from和Array.of let a = [] let a1 = [1, 2,...
收起
js javascript
Javascript高级程序设计笔记（三）
2019-10-01 01:04:36
总的来说JavaScript是面向对象语言，其实与java有很多共通的地方。声明和实例化：与java一样，利用new关键字创建对象，区别在于javascript对象构造函数如果没有...Array对象几种创建方式：var arr = new Array(); ...
收起
第五章——引用类型
2017-04-22 22:17:00
创建对象有两种方式：1.new出一个Object的实例；2.使用对象字面量来创建对象，在对象字面量中，使用逗号分隔不同的属性，但最后一个属性的后面不能再添加逗号，在IE7以前的版本会报错。使用对象字面量，属性名...
收起
详解JavaScript中数组的相关知识
2020-12-09 00:48:35
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的...
收起
objective-c基础语法之数组NSArray、NSMutableArray
2015-06-12 11:22:01
创建一个不可变数组NSArray有以下几种方式//仅仅开辟了一块内存并创建了一个NSArray类型的对象，没有什么内容 NSArray *array = [[NSArray alloc]init]; //开辟内存创建一个带有多个对象的数组 //id是通用...
收起
ios NSArray
python小白数据可视化基础之numpy的基本操作
2020-05-30 09:36:24
**numpy的基本操作** 下面是我个人关于numpy基本知识的...如上有几种代表性的创建方式，第一种是输入一个seq序列，可以是列表，元组，字典等，第二种是以arange等函数创建，第三种是预定式的数创建，如此数组na3即为.
收起
python numpy
12道vue高频原理面试题,你能答出几道?
2020-12-26 11:47:58
为了解决这个问题,经过 vue 内部处理后可以使用以下几种方法来监听数组 <pre><code>js push(); pop(); shift(); unshift(); splice(); sort(); reverse(); </code></pre> 由于只针对了以上 7 种方法进行了 hack ...
收起
JS核心原理 - 模块二 - 数组API
2021-05-03 22:23:35
JS核心原理 ...Array构造器用于创建一个新的数组，通常推荐使用对象字面的方式创建一个数组 // 使用Array构造器，可以自定义长度 var a = Array(6); //[undefined * 6] //使用对象字面量 var b = []; b
收起
js
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：
收起
pw Android笔试面试题(含java)
2015-04-27 10:28:51
有些面试题记得不是很清楚，大概回忆了下: Array能不能动态长度？ sleep(), wait()和yield()的...有几种方式创建一个实例手动写Equals方法 ImageLoader是否用过 surfaceview是用来做什么的 Java中创建对象实例的...
收起

创建javascript对象的几种方式

JavaScript：将类数组转换成数组的几种方式

注意

lambda表达式的解析（七） 对象的创建

（转）lambda表达式的解析（七） 对象的创建

js_Array学习

第5章 JavaScript对象与数组

Numpy 理解ndarray对象的示例代码

JavaScript 对象引用类型(穿插了很多与Python的比较)

几年之后再看JavaScript--引用类型

Symbol对象是什么

第6章 字符串与数值处理对象

第30章 对象相等性

JavaScript-数组详解

如何准确判断一个对象的类型?

附录A 培训实习生——面向对象基础

js中的数组

集合引用类型篇（一）

Javascript高级程序设计 笔记（三）

第五章——引用类型

详解JavaScript中数组的相关知识

关于数组

objective-c基础语法之数组NSArray、NSMutableArray

python小白数据可视化基础之numpy的基本操作

12道vue高频原理面试题,你能答出几道?

JS核心原理 - 模块二 - 数组API

JS中的数组

1 Numpy基础

pw Android笔试面试题(含java)

创建array对象有几种方式

lambda表达式的解析（七）对象的创建

（转）lambda表达式的解析（七）对象的创建

第5章　JavaScript对象与数组

第6章　字符串与数值处理对象

第30章对象相等性

附录A　培训实习生——面向对象基础

Javascript高级程序设计笔记（三）