javascript数组有几种创建方法（在JavaScript中，如何定义一维数组Array）

本文目录

• 在JavaScript中，如何定义一维数组Array
• JS数组有哪几种定义方式
• JavaScript可以定义一个List吗
• 在javascript中定义一个数组的正确方式有哪些
• JavaScript不使用for循环，还有其他方法快速新建一个指定长度的数组，并且每个元素的值就是
• js创建数组对象的过程有几种特点是什么

在JavaScript中，如何定义一维数组Array

转自网上：
new Array()
new Array(len)
new Array(
使用数组对象的方法：
var objArray=new Array();
objArray.concact(;
arr.concact("d","e");
将返回包括从"a"到"e"字母元素的数组。而arr本身不受影响。
objArray.join(separator)---以separator指定的字符作为分割符，将数组转换为字符串，当seperator 为逗号时，其作用和toString()相同。
objArray.pop()---------通俗的讲，就是弹出数组的最后一个元素。结合下面的push方法，使得将数组作为栈来使用成为可能。pop方法返回数组最后一个元素的值，并将length属性减１，即返回后立即丢失最后一个元素。
objArray.push(
objArray.reverse()将数组中的元素反转排列。如：，这个操作是在原有数组上经行操作，同时也返回数组本身
objArray.shift()-----------移去数组的第一个元素，并返回这个元素的值。这个方法的性质和pop方法很类似，pop方法是移去最后一个元素。
objArray.slice(start,end)----------- 返回数组对象的一个子集，索引从start开始（包括 start），到end结束（不包括end),原有数组不受影响。如：。如果end小于等于start，将返回空数组。
objArray.sort(comparefn)------- 根据comparefn定义的大小比较函数，对一个数组进行排序。函数comparefn必须接受两个参数element1,element2,如果需要需要element1排在element2之前，应该返回一个负数；如果需要element1排在element2之后，应该返回一个正数，如果两个数平等对待（即保持原有顺序）则返回０。当省略comparefn时，则元素按照字典顺序排列。如：对定义的比较函数cmp: function cmp(e1,e2){return e1-e2;}则.
objArray.splice(start,deleteCount则表示可选的插入到start之前的元素列表。如：
var arr=;
arr.splice(1,1);
document.write(arr);//显示“０，２，３，４，５，６”
arr=;
arr.splice(0,0,"a","b");
document.write(arr);//显示“a,b,0,1,2,3,4,5,6"
arr=;
arr.splice(3,2,"c","d");
document.write(arr);//显示"0,1,2,c,d,5,6"
objArray.unshift(item1。

JS数组有哪几种定义方式

定义数组

数组对象用来在单独的变量名中存储一系列的值。

我们使用关键词 new 来创建数组对象。下面的代码定义了一个名为 arr 的数组对象：

vararr=newArray();有两种向数组赋值的方法（你可以添加任意多的值，就像你可以定义你需要的任意多的变量一样）。

varmycars=newArray();

mycars="Saab";

mycars="Volvo";

mycars="BMW";也可以使用一个整数自变量来控制数组的容量：

varmycars=newArray(3);

mycars="Saab";

mycars="Volvo";

mycars="BMW";2:

varmycars=newArray("Saab","Volvo","BMW");-------------------------------------------------------------------------------------

或者用数组字面量（直接量）方便的创建数组。一个数组字面量是在一对方括号中包裹着一个或多个用 逗号 隔开的表达式。并且数组中的每个值都有索引。从0开始。

varempty=;

varcars=;

empty//undefined

cars//’Volvo’

JavaScript可以定义一个List吗

JavaScript可以定义数组类型，没有所谓的List类型。

JavaScript也没有必要存在List类型。J**A的List类型是为了解决数组长度不可变的问题，但JavaScript不存在从这个问题。JavaScript的数组长度可变，并有非常多且实用的方法可使用，比J**A的数组灵活的多，J**A的List的大部分功能，JavaScript的数组也都有。

JavaScript的数组的定义方法有以下几种：

var arr = ;//定义一个空数组

var arr = ;//定义一个带元素的数组

var arr = new Array();//定义一个空数组，啰嗦的写法

var arr = new Array(5);//定义一个长度为5的数组，容易误导人，非常不建议的一种写法

扩展阅读：数组对象的方法

concat()    连接两个或更多的数组，并返回结果。    

copyWithin()    从数组的指定位置拷贝元素到数组的另一个指定位置中。    

entries()    返回数组的可迭代对象。    

every()    检测数值元素的每个元素是否都符合条件。    

fill()    使用一个固定值来填充数组。    

filter()    检测数值元素，并返回符合条件所有元素的数组。    

find()    返回符合传入测试（函数）条件的数组元素。    

findIndex()    返回符合传入测试（函数）条件的数组元素索引。    

forEach()    数组每个元素都执行一次回调函数。    

from()    通过给定的对象中创建一个数组。    

includes()    判断一个数组是否包含一个指定的值。    

indexOf()    搜索数组中的元素，并返回它所在的位置。    

isArray()    判断对象是否为数组。    

join()    把数组的所有元素放入一个字符串。    

keys()    返回数组的可迭代对象，包含原始数组的键(key)。    

lastIndexOf()    返回一个指定的字符串值最后出现的位置，在一个字符串中的指定位置从后向前搜索。    

map()    通过指定函数处理数组的每个元素，并返回处理后的数组。    

pop()    删除数组的最后一个元素并返回删除的元素。    

push()    向数组的末尾添加一个或更多元素，并返回新的长度。    

reduce()    将数组元素计算为一个值（从左到右）。    

reduceRight()    将数组元素计算为一个值（从右到左）。    

reverse()    反转数组的元素顺序。    

shift()    删除并返回数组的第一个元素。    

slice()    选取数组的的一部分，并返回一个新数组。    

some()    检测数组元素中是否有元素符合指定条件。    

sort()    对数组的元素进行排序。    

splice()    从数组中添加或删除元素。    

toString()    把数组转换为字符串，并返回结果。    

unshift()    向数组的开头添加一个或更多元素，并返回新的长度。    

valueOf()    返回数组对象的原始值

在javascript中定义一个数组的正确方式有哪些

一、直接字面量定义:
var arr = ;//创建空数组
var arr = //长度为三的数组，内容分别是1，2，3
二、new Array
var arr=new Array();//new一个没有内容的空数组
var arr=new Array(20);//定义指定大小；长度为20
var arr=new Array(’abc’, ’def’, ’ghi’, ’opq’);//定义时赋初值

JavaScript不使用for循环，还有其他方法快速新建一个指定长度的数组，并且每个元素的值就是

1、定义数组
var arr1 = 方式定义一个数组
var arr2 = new Array(2);//通过Array对象定义一个数组
2、for循环赋值
for(var i=0;i《arr2.length;i++){//循环数组
arr2 = i;//为arr2赋每个数组元素赋值
arr1=i;//往arr1中赋数组初始值
}

js创建数组对象的过程有几种特点是什么

js编程中创建对象的几种方式，如原始方法、工厂方法等创建对象。
1、原始方法
复制代码代码示例:
《script type="text/javascript"》
var obj = new Object();
obj.name = "Koji"; //为对象添加属性
obj.age = 21;
obj.showName = function(){ //为对象添加方法
alert(this.name);
}
obj.showAge = function(){
alert(this.age);
}
obj.showName(); //Koji
obj.showAge(); //21
《/script》
上面的方式通过new关键字生成一个对象，然后根据JS是动态语言的特性添加属性和方法，构造一个对象。其中的this是表示调用该方法的对象。
这种方式的问题是如果需要多次创建对象，则需要重复代码多次，不利于代码的复用。
2、工厂方法 ：
复制代码代码示例:
《script type="text/javascript"》
function createObj(){
var obj = new Object(); //创建对象
obj.name = "Koji";
obj.age = 21;
obj.showName = function(){
alert(this.name);
}
obj.showAge = function(){
alert(this.age);
}
return obj; //返回对象
}
var obj1 = createObj();
var obj2 = createObj();
obj1.showName(); //Koji
obj2.showAge(); //21
《/script》
这种方式提高了代码重用率，还可以改变工厂方法，传入参数赋值。

复制代码代码示例:
《script type="text/javascript"》
function createObj(name, age){ //构造对象时可以传入初始化参数
var obj = new Object(); //创建对象
obj.name = name;
obj.age = age;
obj.showName = function(){
alert(this.name);
}
obj.showAge = function(){
alert(this.age);
}
return obj; //返回对象
}
var obj1 = createObj("Koji", 22);
var obj2 = createObj("Luo", 21);
obj1.showName(); //Koji
obj1.showAge(); //22
obj2.showName(); //Luo
obj2.showAge(); //21
《/script》
上面的方式虽然可以提高代码的复用率，但和面向对象中类的概念相比有一个很大的**。面向对象强调对象的属性私有，而对象的方法是共享的。而上面的工厂方法创建对象的时候要为每个对象创建各自私有的方法。同时由于为每个对象都创建逻辑相同的方法，浪费内存。
改进如下：

复制代码代码示例:
《script type="text/javascript"》
function createObj(name, age){
var obj = new Object(); //创建对象
obj.name = name;
obj.age = age;
obj.showName = showName;
obj.showAge = showAge;
return obj; //返回对象
}
function showName(){ //函数也是一个对象
alert(this.name);
}
function showAge(){
alert(this.age);
}
var obj1 = createObj("Koji", 22);
var obj2 = createObj("Luo", 21);
obj1.showName(); //Koji
obj1.showAge(); //22
obj2.showName(); //Luo
obj2.showAge(); //21
《/script》
上面通过定义连个函数对象，解决了不同对象持有函数对象的私有问题。现在所有对象的方法都持有上面两个函数的引用。但这么一来的话，对象的函数又和对象成了相互独立，不相干的了。这和面向对象**定方法属于特定类的思想不符合。
3、构造函数方式
复制代码代码示例:
《script type="text/javascript"》
//定义一个构造函数，用来生成对应的对象，可以类比Java中的构造函数
function Person(name, age){
//当调用new Person的时候，在执行第一行代码前，先生成一个Person对象，并将对象在内存中的
//索引赋值给this关键字，此时可以通过this关键字操作新生成的对象，如下面的添加属性或方法
this.name = name; //this关键字不能少。为当前对象，即this关键字引用的对象的name属性赋值
//，实际相当于为当前对象添加name属性后,再为其name属性赋值。
this.age = age;
this.showName = function(){ //为当前对象添加方法
alert(this.name);
}
this.showAge = function(){
alert(this.age);
}
//将当前对象返回给赋值符号左边的变量（不必明确使用return）
}
var obj1 = new Person("Koji", 22); //生成一个Person对象
var obj2 = new Person("Luo", 21);
obj1.showName(); //Koji
obj1.showAge(); //22
obj2.showName(); //Luo
obj2.showAge(); //21
《/script》
构造函数的方式和工厂方式一样，会为每个对象创建独享的函数对象。当然也可以将这些函数
对象定义在构造函数外面，这样又有了对象和方法相互独立的问题。
原型方法：
该方法利用的对象的prototype属性

复制代码代码示例:
《script type="text/javascript"》
function Person(){} //定义一个空构造函数，且不能传递参数
//将所有的属性的方法都赋予prototype属性
Person.prototype.name = "Koji"; //添加属性
Person.prototype.age = 22;
Person.prototype.showName = function(){ //添加方法
alert(this.name);
}
Person.prototype.showAge = function(){
alert(this.age);
}
var obj1 = new Person(); //生成一个Person对象
var obj2 = new Person();
obj1.showName(); //Koji
obj1.showAge(); //22
obj2.showName(); //Koji
obj2.showAge(); //22
《/script》
当生成Person对象的时候prototype的属性都赋值给了新的对象。那么属性和方法是共享的。
该方法的问题首先是构造函数不能传参，每个新生成的对象都有默认值。其次，方法共享没有任何问题，但是属性共享就有问题，当属性是可改变状态的对象的时候。
例子：

复制代码代码示例:
《script type="text/javascript"》
function Person(){} //定义一个空构造函数，且不能传递参数
Person.prototype.age = 22;
Person.prototype.array = new Array("Koji", "Luo");
Person.prototype.showAge = function(){
alert(this.age);
}
Person.prototype.showArray = function(){
alert(this.array);
}
var obj1 = new Person(); //生成一个Person对象
var obj2 = new Person();
obj1.array.push("Kyo"); //向obj1的array属性添加一个元素
obj1.showArray(); //Koji,Luo,Kyo
obj2.showArray(); //Koji,Luo,Kyo
《/script》

以上代码通过obj1向obj1的属性array添加元素的时候，obj2的arra属性的元素也跟着受到影响，原因就在于obj1和obj2对象的array属性引用的是同一个Array对象，那么改变这个Array 对象，另一引用该Array对象的属性自然也会受到影响混合的构造函数/原型方式。
使用构造函数定义对象的属性，使用原型（prototype）定义对象的方法，这样就可以做到属性私有，而方法共享。
例子：

复制代码代码示例:
《script type="text/javascript"》
function Person(name, age) {
this.name = name;
this.age = age;
this.array = new Array("Koji", "Luo");
}
Person.prototype.showName = function() {
alert(this.name);
}
Person.prototype.showArray = function() {
alert(this.array);
}
var obj1 = new Person("Koji", 22); //生成一个Person对象
var obj2 = new Person("Luo", 21);
obj1.array.push("Kyo"); //向obj1的array属性添加一个元素
obj1.showArray(); //Koji,Luo,Kyo
obj1.showName(); //Koji
obj2.showArray(); //Koji,Luo
obj2.showName(); //Luo
《/script》
属性私有后，改变各自的属性不会影响别的对象。同时，方法也是由各个对象共享。在语义上，
这符合了面相对象编程的要求。
4、动态原型方法
复制代码代码示例:
《script type="text/javascript"》
function Person(name, age) {
this.name = name;
this.age = age;
this.array = new Array("Koji", "Luo");
//如果Person对象中的_initialized为undefined，表明还没有为Person的原型添加方法
if (typeof Person._initialized == "undefined")
{
Person.prototype.showName = function() {
alert(this.name);
}
Person.prototype.showArray = function() {
alert(this.array);
}
Person._initialized = true; //设置为true，不必再为prototype添加方法
}
}
var obj1 = new Person("Koji", 22); //生成一个Person对象
var obj2 = new Person("Luo", 21);
obj1.array.push("Kyo"); //向obj1的array属性添加一个元素
obj1.showArray(); //Koji,Luo,Kyo
obj1.showName(); //Koji
obj2.showArray(); //Koji,Luo
obj2.showName(); //Luo
《/script》
这种方法和构造函数/原型方式大同小异。只是将方法的添加放到了构造函数之中，同时在构造函数Person上添加了一个属性用来保证if语句只能成功执行一次。
在实际应用中采用最广泛的是构造函数/原型方法。动态原型方法也很流行，它在功能上和构造函数/原型方法是等价的，不要单独使用构造函数或原型方法。