js初始化二维数组长度

❶ 在任何情况下 二维数组的初始化都可以省略第一维大小。为什么错误

如果省略第一维大小，则必须给出初值表，编译器才能根据初值表确定第一维的最小长度。如果既没有第一维长度又没有初值表，将导致编译错误。

将二维数组当作参数的时候，必须指明所有维数大小或者省略第一维的，但是不能省略第二维或者更高维的大小，高晌颂这是由编译器原理限制的。

因此，可以省略第一维的维数，不能省略其他维的维数。

(1)js初始化二维数组长度扩展阅读

二维数组的初始化方法

1、分行给二维数组赋初值。这种赋初值的方法比较直观，将第一个花括号内的数据赋给第一行的元素、第二个花括号内的数据赋给第二行的元素……即每行看作一个元素，按行赋初值。

2、可以将所有数据写在一个花戚郑括号内，按数组排列的顺序对各元素赋初值。不过这种方法如果数据多，写成一大片，容易遗漏，也不易检查。

3、可以只对部分元素赋初值。它的作用是对第一行的前两个元素赋值、第二行和第三行的第一个元素赋值，其余元素自动为 0。

4、int a[3][4]={0}；二维数谨余组“清零”，里面每一个元素都是零。

❷ javascript 定义二维数组,两列,未知行数

javascript定义二维数组的方法

1、是用一维数组来模拟二维数组

这种方法不是很好,有点麻烦,而且容易出错

2、将一维数组的分项又定义为一个一维数组

javascript本身只支持一维数组，有时非要用到二维数组的时候，可以将一维数组的分项又定义为一个数组，二维数组就是用数组构成的数组

varitems=newArray();//定义一维数组
for(i=1;i<=10;i++)
{
items[i]=newArray();//将每一个子元素又定义为数组
for(n=0;n<=10;n++)
{
items[i][n]=i+n;//此时items[i][n]可以看作是一个二级数组
}
}

❸ 如何给二维数组赋初值0

二维数明橡组的初始化:
(1) 分行给二维数组赋初值。如
int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
这种赋初值方法比较直观，把第1个花括弧内的数据给第1行的元素，第2个花括弧内的数据赋给第2行的元素……即按行赋初值。
(2) 可以将所有数据写在一个花括弧内，按数组排列的顺序对各元素赋初值。如：int a[3][4]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,12};
效果与前相同。但以第1种方法为好，一行对一行，界限清楚。用第2种方法如果数据多，写成一大片，容易遗漏，也不易检查。

(3) 可以对部分元素赋初值。

int a[3][4]={{1},{5},{9}};
它的作用是只对各行第1列的元素赋初值，其余元素值自动为0。赋初值后数组各元素为

1 0 0 0
5 0 0 0
9 0 0 0

也可以对各行中的某一元素赋初值：
int a[3][4]={{1},{0,6},{0,0,11}};
初始化后的数组元素如下：
1 0 0 0
0 6 0 0
0 0 11 0

这种方法对非0元素少时比较方便，不必将所有的0都写出来，只需输入少量数据。也可以只对某几行元素赋初值：

int a[3][4]={{1},{5,6}};

数组元素为
1 0 0 0
5 6 0 0
0 0 0 0

第3行不赋初值。也可以对第2行不赋初值：
int a[3][4]={{1},{},{9}};
(4) 如果对全部元素都赋初值(即提供全部初始数据)，则定义数组时对第一维的长度可以不指定，但第二维的长度不能省。如：
int a[3][4]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
与下面的定义等价：
int a[][4]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
系统会根据数据总个数分配存储空间，一共12个数据，每行4列，当然卖枝可确定为3行。
在定义时也可以只对部分元素赋初值而省略第一维的长度，但应分行赋初值。如：int a[][4]={{0,0,3},{},{0,10}};
这样的写法，能通知编译系统；数组共有3行。数组各元素为
0 0 3 0
0 0 0 0
0 100 0

从本节的介绍中可以看到：c语言在定义数组和表示数组元素时采用a[][]这种两个方括弧的方式，对数组初始化时十分有用，它激配旁使概念清楚，使用方便，不易出错。
练一个: 将一个二维数组行和列元素互换,存到另一个二维数组中。例如：
┌1 2 3┐ ┌1 4┐
a =│ │ b= │2 5│
└4 5 6┘ └3 6┘

❹ 二维数组 长度定义 高手进！！！

规定是不可以改的，但我们可以设置一常量，先来初始化数组！再使用变量就行了！就如下面的程序，我经常这么处理的！先设置一个边界值再加一个判断！
我觉得挺实用的！特别对数组来说！

#include "iostream.h"
#include "stdlib.h" //必须引用，因为后面用到exit()函数
const int MAX=100;
//边界值设置，如果设置成很大数值，后面的判断也可以省略！
void main()
{
int a[MAX][MAX];
int line,column,sum;
cout<<"输入数组的行: ";
cin>>line;
cout<<"输入数组的列: ";
cin>>column;
if(line>MAX||column>MAX) {cout<<"输入的数据太大！\n";exit(1);}
//处于安猛袜全考虑不省略为好！
cout<<"请输入带团"<<line<<"行"<<column<<"列数据:"<<endl;
sum=line*column;//数组元素个数总和
for(int i=0;i<line;i++)
for(int j=0;j<column;j++)
cin>>a[i][j];
for(i=0;i<line;i++)
{
for(int j=0;j<column;j++)
cout<<a[i][j]<<" ";
cout<<endl;
}
}

补充：如果刁难的话，输入有小数之类蠢知橘的行和列数，那得另加更细节的判断了，这里就不写了。

❺ 如何初始化一个二维数组

若声明为全局量，例如放在 main() {} 函数以前，则编译时，自动初始化为全0。
一般来书，二维数组初始化的形式为：
数据类型 数组名[整常量表达式][ 整常量表达式]={ 初始化数据 }；
在{ }中给出各数组元素的初值，各初值之间用逗号分开。把{ }中的初值依次赋给各数组元素。
有如下几种初始化方式：
⑴ 分行进行初始化
int a[2][3]={{1,2,3},{4,5,6}};
在{ }内部再用{ }把各行分开，第一对{ }中的初值1，2，3是0行的3个元素的初值。第二对{ }中的初值4，5，6是1行的3个元素的初值。相当于执行如下语句：
int a[2][3]；
a[0][0]=1；a[0][1]=2；a[0][2]=3；a[1][0]=4；a[1][1]=5；a[1][2]=6；
注意，初始化的数据个数不能超过数组元素的个数，否则出错。
⑵ 不分行的初始化
int a[2][3]={ 1,2,3,4,5,6};
把{ }中的数据依次赋给a数组各元素（按行赋值）。锋清即a[0][0]=1; a[0][1]=2；a[0][2]=3；a[1][0]=4；a[1][1]=5；a[1][2]=6；
⑶ 为部分数组元素初始化
=static int a[2][3]={{1,2},{4}};
第一行只有2个初值，按顺序分别赋给a[0][0]和a[0][1]；第二行的初值4赋给a[1][0]。由于存储类型是static，故其它数组元素的初值为0。
static int a[2][3]={ 1,2};
只有2个初值，即a[0][0]=1，a[0][1]=2，其余数组元素的初值均为0。
⑷ 可以省略第一维的定义，但不能省略第二维的定义。系统根据初始化的数据个数和第2维的长度可以确定第一维的长度。
int a[ ][3]={ 1,2，3，4，5，6};
a数组的第一维的定义被省略，初始化数据共6个，第二维的长度为3，即每行3个数，所以a数组的第一维是2。
一般，省略第一维的定义时竖槐，第一维的大小按如下规则确定：
初值个数能被第二维整除，所得的商就是第一维的大小；若不能整除，则第一维的大小为商再加1。例如，int a[ ][3]={ 1,2,3,4};等价于：int a[2][3]={ 1,2,3,4};
若分行初始化，也可以省略第一维的定义。下列的数组定义中有两对银纤前{ }，已经表示a数组有两行。
static int a[ ][3]={{1,2},{4}};

❻ JavaScript 如何定义一个二维数组

方法一：

定义已知长度的二维数组，可直接定义并且初始化

var _TheArray = [["0-1","0-2"],["1-1","1-2"],["2-1","2-2"]]

方法二：

定义未知长度的二维数组

vartArray = newArray(); //先声明一维数组

for(vark=0;k<i;k++)//一维数组长度为i，i为变量，可以根据实际情况改变

{

tArray[k]=newArray(); //声明二维，每一个一维数组里面的一个元素都是一个数组

for(varj=0;j<p;j++)//一维数组里面每个元素数组可以包含的数量p，p也是一个变量

{

tArray[k][j]="1"; //这里将变量初始化，我这边统一初始化为1

}

}

(6)js初始化二维数组长度扩展阅读：

JavaScript多维数组的创建：

<script>

varallarray=newArray();

varres="";

functionloaddata()

{

for(vari=0;i<3;i++)

{

varstarth=i*200;

varstrarw=i*200;

varendh=(i+1)*200;

varendw=(i+1)*200;

allarray[i]=newArray();

allarray[i][0]=newArray();

allarray[i][1]=newArray();

allarray[i][0][0]=starth;

allarray[i][0][1]=strarw;

allarray[i][1][0]=endh;

allarray[i][1][1]=endw;

}

for(vari=0;i<allarray.length;i++)

{

varsh=allarray[i][0][0];

varsw=allarray[i][0][1]

vareh=allarray[i][1][0];

varew=allarray[i][1][1]

res+="第"+i+"个坐标的开始坐标是："+sh+","+sw+"结束坐标是："+eh+","+ew+"<br/>";

}

document.getElementById("dv").innerHTML=res;

}

</script>。

❼ 二维数组正确初始化

首先要明确几点：
1、二维数组可按行分段赋值，也可早毕数按行连续赋值。{{1,2},{0}}是按陆首行分段赋值，{1,2,3,4,5,6}是按行连续赋值。
2、可以只对部分元素赋初值，对于int型数组，未赋初值的元素自动取0值。
3、如对全部元素赋初值，则第一维的长度可以不给出。
A,B,D选项符合以上条件，唯有C选项，是按行分段赋值，给出了3行数据（最外层大括号内有3组分段数销的大括号），而定义的第一维长度是2,所以是不正确的。

❽ java二维数组的初始化

你试试这样写:int[][]a=newint[3][];
然后你可以定义三个内部的一维数组比如:
a[0]=newint[]{0,1,2,5,6,7,8};
a[1]=newint[]{4,5,2,3,1};
a[2]=newint[]{9,1,7};
但是不能有3索引了,为什么?
因为长度已经被限制了只能是3个,内嵌的数组长度可以随意的!

回头看你说的这个:
int[][]a=newint[3][2];
也就是说,你这个3代表二位数组的长度,已经被限制了
但是后面这个2代表内置的数组元素个数,这个是可以变换的;
a[0]=newint[]{0,1,2,3};所以这个是合法的!

//总结了一下你看看:
importjava.util.Arrays;
publicclassTwoArr{
	publicstaticvoidmain(String[]args){
		//1
		int[][]arr1={};
		sop(arr1,1);
		
		//2
		int[][]arr2=newint[][]{{1,2},{2,3},{4,5}};
		sop(arr2,2);
		
		//3
		int[][]arr3={{1,2},{2,3},{4,5}};
		sop(arr3,3);
		
		//4
		int[][]arr4=newint[3][2];
		sop(arr4,4);
		arr4[0]=newint[]{1,2,3,4};
		sop(arr4,4);
		
		//5
		int[][]arr5={{0,0},{0,0},{0,0}};
		sop(arr5,5);
		arr5[1]=newint[]{8,9,7,10};
		sop(arr5,5);
		
		//6
		int[][]arr6=newint[][]{{0,0},{0,0},{0,0}};
		sop(arr6,6);
		arr6[0]=newint[]{8,7,9,5};
		arr6[1]=newint[]{8,7,9,5};
		arr6[2]=newint[]{8,7,9,5};
		sop(arr6,6);
		
		//7
		int[][]arr7=newint[3][];
		arr7[0]=newint[]{1,2};
		arr7[1]=newint[]{3,4};
		arr7[2]=newint[]{5,6};
		sop(arr7,7);
		
	}
	privatestaticvoidsop(int[][]arr,intcount){
		System.out.print("arr"+count+":[");
		for(int[]a:arr){
			System.out.print(Arrays.toString(a));
		}
		System.out.println("];");
		System.out.println();
	}
}
//2,3,4,5,6完全一个意思,区别就只是书写上,下面看看测试的效果!