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完全一個意思,區別就只是書寫上,下面看看測試的效果!