快手( AAuto開發環境 ) 下載壓縮包僅 6.x MB, 綠色軟體解壓即用 - 無論個人或企業都可以永久免費
使用本軟體。快手內建AAuto標準庫，以及大量範例全部開源。AAuto使用者可以自由使用無需付費
，使用AAuto製作的軟體產品不需要宣告使用AAuto開發，免費使用AAuto無任何附加條件。
工具/原料
AAuto開發環境
AAuto開發手冊
方法/步驟
識別符號基本規則：
識別符號由英文字母、中文字元、數字、下劃線“_”三種字元組成。
數字不允許作為首字元。
變數名包含中文時，中文字元前面不能有字母或數字。
可以使用美元符號($)作為變數名或變數名的第一個字元。
可以使用下劃線作為變數名或常量名的首字元,當下劃線作為首字元時表
示常量,單個下劃線表示變數。
識別符號區分大小。
關鍵字：
AAuto支援自定義關鍵字，例如：
def 如果 = if
def 否則 = else
def 否則是 = elseif
def 名字空間= namespace
def 迴圈 = while
io.open();
如果 1== 1 {
io.print(" 1等於1 ")
}
否則{
io.print(" 1不等於1 ")
}
當關鍵字置於成員符之後,AAuto會將關鍵字作為普通成員變數名,如下:
io.namespace = "io"
註釋：
1、、單行註釋
單行註釋以 //開始，到行尾結束;
2、 多行註釋
多行註釋以 /*開始，到 */結束，首尾的*字元可以有一或多個，但*字元的數目
必須首尾匹配。
操作符：
算術運算子：+ - * / % **
按位運算子:<< >> >>>
等式運算子:= != == === !===
邏輯運算子:? : && == === !===
關係運算符:< > >= <= == !==
連線運算子:++
取長運算子:#
包含操作符：$
成員操作符：. [ ] [ [ ] ]
表示式：
單個運算元可以構成一個表示式。
運算元、運算子可以組成表示式，使用運算子對運算元進行運算並返回一個
新的值。
一個表示式可以作為另一個表示式的運算元。
函作返回值可以作為表示式。
賦值語句不能作為表示式。
語句：
語句以分號“;”表示結束，如果能保持語句在語義上的獨立完整性，分號“;”通常可以省略。
1.1、賦值
例如: a = 120;
1.2、多重賦值
a,b,c = 1,2,3;
//將變數宣告為當前名字空間下的成員變數value = 100;//以下劃線開始的成員常量，只能賦值一次_value = 100; //以下劃線開始的全域性常量，只能賦值一次 _VALUE = 100; //使用::操作符定義的全域性常量，只能賦值一次 ::Value = 100;
1.3、使用var賦值語句定義區域性變數
區域性變數需要用var語句宣告。使用區域性變數有兩個好處 1.避免命名衝突 2.訪問區域性變數的速度比全域性變數更快.
1.2、使用賦值語句刪除變數
將一個變數賦值為null，刪除這個變數。例：x = null
a= a + b 可以寫成 a += b所有二元操作符都可以按上述規則書寫。例如：a -= b;a *= b;
A := c 也就是 A = A:c如果A為null空值，則將c賦值給A。
定義常量時，為避免重複賦值，通常使用初始化賦值語句。
str ?= string.lower(str) 上面的語句等價於： str = str and string.lower(str)如果a不為null空值，則執行後面的賦值語句。其語義如下：
if(str != null){ str = string.lower(str)}
這樣可以避免str為null空值時，string.lower丟擲錯誤。如果str為空，則等號右側的語句根本不會執行。
a++; 等價於 a += 1;a--; 等價於 a -= 1;
C樣式語句塊
使用“{ }” 標明語句塊，“{”表示語句塊的開始, “}”表式語句塊的結束。例如：
{ var str = "我是區域性變數" ; io.open(); io.print(str); //輸出：我是區域性變數};io.print(str); //輸出：null
在任何時候，begin ... end 與 { } 都是等價的，可以相互替換使用。
if語句可選包含任意多個elseif分支判斷語句，可選包含一個else語句。並可以巢狀使用。
一個標準的if語句如下:
io.open() //開啟控制檯var a=1if(b==1){ if(a==1) begin io.print("if") end}elseif(a==11){ io.print("elseif")}else{ io.print("else")}
select case語句
select指定一個選擇器變數或表示式，case語句列舉不同的值或條件值，符合條件的case語句將會執行。
case語句預設呼叫恆等式運算子進行比較。也可以自行指定操作符。
例如：
io.open() //開啟控制檯var a = 0;select( a ) { case 1 { //判斷 1===a 是否為真 io.print("a==1") //其他程式碼 } case 1,9,10 { //判斷 a 是否其中的一個 io.print("a是1,9,10其中之一") } case 10;20 { //判斷 ( 10<=a and a <=20 ) 是否為真 io.print("a在10到20的範圍") } case !=0{ //判斷 a是否不等於0，這是自已指定關係運算符的示例 io.print("a不等於0") } else{ //所有條件不符時執行else語句塊 io.print("a是其他值(0)") }}
select case語句可以巢狀使用。
while語句包含條件判斷部份、執行程式碼部份。而迴圈體可以是一個單獨的語句，也可以是用{ } 包含的語句塊，也可以是begin end包含的語句塊.
while 語法如下：
while( 條件判斷語句 ) { //需要迴圈執行的語句}
示例程式碼：
io.open() var countLoop = 1 while( countLoop<10 /*這裡指定進入並重復執行迴圈語句的條件*/ ){ countLoop++ io.print("迴圈次數", countLoop); }; execute("pause") //按任意鍵繼續 io.close();//關閉控制檯
while var 語句類似while語句,但可以條件判斷前新增迴圈變數初始化、判斷條件前執行語句。
語法如下：
while( var 初始化迴圈變數列表;判斷條件前執行語句;條件判斷語句 ) { //需要迴圈執行的語句}
示例程式碼：
io.open() while( var next,line = io.lines("~\lib\console\_.aau"); //在迴圈開始前初始化區域性變數 line = next(); //語句或語句塊，可省略不寫,但不能省略分號 line //迴圈條件表示式,不可省略 ){ io.print( line ); };
do...while語句包含條件判斷部份、執行程式碼部份。執行程式碼部份可以是一句程式碼，或者一個語句塊，語句塊可以是{ } 包含的語句塊，也可以是begin end包含的語句塊.do...while語句是首先執行迴圈體，然後再判斷迴圈條件。迴圈體至少會執行一次。
語法如下：
do{ //需要迴圈執行的語句} while( 條件判斷語句 )
下面是兩層巢狀的while語句示例:
do{ io.print(countLoop) countLoop++}while( countLoop<123 ); //判斷條件
for迴圈執行一個固定次數的迴圈，語法如下：
for( 計數器變數= 初始數值; 最大數值; 步進數值) { //步進可以省略，預設值為1。 //需要迴圈執行的語句}
io.open();for( i=1;10;2 ){ //計數器i從1迴圈到10，每次遞增2 io.print(i)}
//支援修改計數器變數for( i=1;10;1 )begin i++;//如果你將i賦值為非數字，在下次迴圈以前將會被自動恢復為計數器值end;
//遞減計數器for( i=1;-10;-1 )begin io.print(i) end;
execute("pause") //按任意鍵繼續io.close();//關閉控制檯
迴圈中斷語句
一個好的習慣是：使迴圈的條件控制集中在迴圈體的開始或結束，使迴圈體內部保持良好的內聚性。從而使程式碼的結構清晰並容易理解、中斷語句在一定程度上破壞了這一規則，是以應謹慎的使用中斷語句。並且儘可能的使中斷語句的使用簡潔而清晰、並使他們保持一致性的規律(例如在相同的深度的巢狀層)。
1、break語句
break語句中斷並退出迴圈並跳轉到指定迴圈的結束點以後開始執行。
2、continue語句
continue語句跳過迴圈體剩下的部份，跳轉到迴圈體的開始處並繼續執行下一次迴圈。類似一種不執行迴圈體剩餘部份程式碼的條件語句。可以在迴圈體的開始處使用continue語句是一種好的習慣，可以避免將迴圈體程式碼包含在一個大的if語句中。使程式擁有清晰的結構。
3、帶標號的break、continue語句(labeled break、labeled continue)
AAuto支援帶標號的break、continue語句。標號可以是一個數值，例如 break N; continue N;N指定迴圈語句的巢狀序號。當前迴圈用1表示，上層迴圈為2，再上層為3，依此累加......也可以在迴圈語句的開始，為迴圈語句指定一個具名標號，然後使用break lable、continue lable中斷指定的迴圈。
迴圈中斷語句
一個好的習慣是：使迴圈的條件控制集中在迴圈體的開始或結束，使迴圈體內部保持良好的內聚性。從而使程式碼的結構清晰並容易理解、中斷語句在一定程度上破壞了這一規則，是以應謹慎的使用中斷語句。並且儘可能的使中斷語句的使用簡潔而清晰、並使他們保持一致性的規律(例如在相同的深度的巢狀層)。
1、break語句
break語句中斷並退出迴圈並跳轉到指定迴圈的結束點以後開始執行。
2、continue語句
continue語句跳過迴圈體剩下的部份，跳轉到迴圈體的開始處並繼續執行下一次迴圈。類似一種不執行迴圈體剩餘部份程式碼的條件語句。可以在迴圈體的開始處使用continue語句是一種好的習慣，可以避免將迴圈體程式碼包含在一個大的if語句中。使程式擁有清晰的結構。
3、帶標號的break、continue語句(labeled break、labeled continue)
AAuto支援帶標號的break、continue語句。標號可以是一個數值，例如 break N; continue N;N指定迴圈語句的巢狀序號。當前迴圈用1表示，上層迴圈為2，再上層為3，依此累加......也可以在迴圈語句的開始，為迴圈語句指定一個具名標號，然後使用break lable、continue lable中斷指定的迴圈。示例程式碼：
io.open(); //開啟控制檯 while( true ){ 迴圈體2: //可以在迴圈體的開始指定一個標號 io.print("迴圈體2開始" ); while( true )begin io.print("迴圈體1開始" ); break 2;//中斷上層迴圈 break 迴圈體2; //這句的作用與上面的break作用是一樣的 io.print("迴圈體1結束" ); end; io.print("迴圈體2結束" ); } execute("pause") //按任意鍵繼續io.close();//關閉控制檯
泛型for與迭代器：
迭代指的是一種迴圈過程,下一步的迴圈總是以上一步的結果作為基礎。踩出第一步，才知道第二步怎麼走。屈原有詩“路漫漫其修遠兮,吾將上下而求索”描繪的就是一種迭代的思想。迭代不但常用於迴圈演算法，同樣也是軟體開發過程的核心思想。
迭代器(iterator)指的是一個使用迭代演算法返回集合成員的函式、可用於泛型for迴圈語句中.而構造迭代器的函式我們稱之為迭代器生成器.
next = com.each( com物件 )
其中next是一個迭代器,而com.each就是一個迭代器生成器.
所以下面的寫法:
for i,obj in com.each( com物件 ) { //迴圈語句 }
等價於下面的寫法
next = com.each( com物件 ) for i,obj in next { //迴圈語句 }
try...catch容錯語句：
try語句嘗試執行一個語句塊，遇到錯誤則退出try語句塊而不是中斷AAuto程式。如果使用了catch語句塊就可以捕獲異常(catch語句塊是可選的)。
io.open(); //開啟控制檯視窗
try{ b="aaaaaaaaaaaa" *2 io.print("錯誤會中斷try語句塊")}catch(e){ //catch部份可以省略 io.print( "錯誤資訊：",e ) //在這裡可以呼叫debug庫 //在棧釋放以前呼叫錯誤處理 //所以可以呼叫debug庫中的函式收集錯誤相關的資訊}
io.print("錯誤不會中斷程式")
錯誤資訊不一定要是一個字串,傳遞給error的任何資訊都會被catch捕獲
try{ error( {a=2;b=3} ) //error顯式丟擲一個異常 io.print("錯誤會中斷try語句塊")}catch(e){ //catch部份可以省略 io.print( "錯誤資訊：",e.a,e.b) }
容錯語句是允許多重巢狀的，一個容錯語句允許包含另一個容錯語句。為了清晰的表示巢狀的層次，需要根據巢狀的層次使用tab製表符縮排。
變數：
1、成員變數
成員變數是屬於一個名字空間的成員物件。變數的預設名字空間為global名字空間，並可以使用namespace改變指定程式碼塊的名字空間。可以使用self關鍵字訪問當前名空間。使用..操作符訪問global名字空間
//沒有用var語句顯式宣告的變數，預設就是當前名字空間的成員變數變數 = "字串:普通變數";變數 = "變數的值是可以改變的" ..str = 123; //..str等價於 ..global.str
2、區域性變數
var宣告一個區域性變數，作用域為當前語句塊，以及被當前語句塊所包含的語句塊。var語句宣告的區域性變數可以指定一個初始值，也可以不指定，建議對所有變數指定初始值。
例如：
var 區域性變數;區域性變數 = 123;var a,b,c = 1,2,3io.print( a,b,c,區域性變數 )
常量：
1、字面常量
指以數值、字串等字面值表示資料的物件。象123,"abc"這樣的值被稱之為字面值，被稱為字面值是因為他的值就是程式碼直接描述的值，並且沒有名字可以稱呼他，只能用他的值來表示。
常量只能賦值一次，重複賦於相同的數字或字串等常量值將會被忽略，賦於不同的值將會丟擲錯誤。AAuto中的常量以下劃線作為起始字元的識別符號來表示。
2、具名常量
用合法的識別符號來表示不可修改資料的物件稱為常量，與字面值不同的是他具有類似變數名的常量名稱。常量名以下劃線作為首字元，或使用::操作符將普通的變數轉換為常量。具名常量可以理解為賦值後不可修改的變數。
2.1 成員常量用字母、數字、中文字元、下劃線等組成的識別符號來表示，並且必須以下劃線作為起始字元。成員常量與成員變數一樣預設創建於當前名字空間(self名字空間)、也可以指成員常量的名字空間字首。成員常量的長度必須大於1並小於256個位元組(單個下劃線不是常量,在AAuto中通常用作匿名變數佔位符)
2.2 全域性常量用大寫字母、數字、下劃線等組成的識別符號來表示，並且必須以“下劃線+大寫字母”作為起始字元。全域性常量類似於成員常量，區別是必須大寫、並且位於globle根名字空間。實際上使用全域性物件是不好的習慣，你應當儘可能的避免使用全域性物件、將他們放入適當的名字空間。不要介意多打幾個字多寫幾個名字空間字首，理解了全域性物件會不知不覺增加程式的複雜度、並且努力地去避免使用全域性物件(這裡不是指名字空間、相反應當更多地使用名字空間來組織資料)，意謂著你已經成為了一名有經驗的程式設計師。
而且全域性常量在AAuto是執行時物件，意謂著會增加發布後的程式體積。把他們改為字面常量並加上註釋是一個不錯的優化方案，AAuto Quicker提供相應的工具。
2.3 轉換全域性常量可用::字首將普通的變數強制轉換為全域性常量。::字首對變數名的作用是不可逆的，因此在同一個檔案中用::宣告為全域性變數的變數名，即使不再新增::字首，仍然會被解釋為全域性常量。::在編譯時起作用，並根據編譯的順序擁有向後向下的持久作用域。
import語句是在執行時載入外部aau程式碼、因此import載入的檔案中的::操作符不能直接作用於當前程式碼檔案。
例如：
::Str = "字串:全域性常量" //也可以用::操作符定義一個全域性常量(良好的編碼習慣是首字母大寫)
3、使用初始化賦值語句定義常量
常量是僅能初始化賦值一次，對於數值常量，重複賦於相同的值會被自動忽略。如果常量的值是非數值物件，即不能保證每次建立的值是相同的，為避免無意中修改常量值導致異常，可使用:=操作符賦值。例如:
::Func := function() beginend;
上面的程式碼等效於
:
::Func = Func or function() beginend;
基本資料型別：
type.null null 空值，所有變數預設初始值為null
type.boolean true、
false
布林值，表示條件真、假
type.number 數值 數值
type.string 字元
串
字串
type.table 陣列
、哈
希表
集合(collection)
type.function 函式 函式
type.pointer 裸指
針
裸指標(AAuto不負責分配釋放)，通常來自API
函式. 裸指標給你最大的自由,同時也帶來最大的風險,如
果你不是清楚的瞭解裸指標指向記憶體的分配釋放
規則，儘可策的避免直接使用此型別。
type.cdata 託管
指標
託管指標(AAuto管理分配釋放)
如果一個託管指標沒有元表,則可以直接在API函
數中替代pointer型別. 否則,,必須使用_topointer元方法返回裸指標才能
在API函式中作為指標使用.
type.fiber 纖程 協同程式
type.class 類 類
nnuull(空值)
null即變數沒有儲存任何資料，將一個變數賦值為null等於刪除這個變數
booooleeaann(邏輯布林值)
有兩個值,true表示真、 false 表示假。通常用在條件表示式中。
通俗一點說,true表示是、符合條件,false表示不是、不符合條件。
在條件表示式(恆等式除外)中， null、數值0這認為是false，
其他有效的資料都被認為是true。
與C++類似，AAuto認為0為false，非零數值為true，在外
部api函式中可以保持一致。
nnuummbeerr(數值)
數值型別可以使用不同的進位制來表示，參考：數值與進位制
例如使用0字首表示八進位制的數，使用0x字首表示十六進位制數，例：num =0xA1 + 0xFF，而使用2_字首可以表示2進位制數。也可以用科學計演算法表示
數值 num = 6e+20
把一個大於10的數寫成a * 10
n 的形式，其中a稱為尾數、n稱為
指數，是整數數位只有一位的數，這種計數法叫做科學計數法
，也叫10的冪計數法。例如 x= -3.5×10
5 這裡最前面有一個
負號，3.5是尾數，兩個有效數字，後面以10為基數的指數為5 。我們可以將它表示為-3.5E5。
sstrrinng(字串)
字串就是由多個字元組成的字串,注意字元與字串是不同的.字元只是字
符串中一個最小的單位。
一個英文字元、在記憶體中佔用一個8bit位的位元組(8個二進位制位),中文字元則佔
用兩個位元組。
與其他程式語言不同,字串不僅可用用來儲存文字，也可以可以儲存二進位制
資料，允許包含\0。
在C語言中、\0是字串結束標記。
一、、普通字串
普通字串放在雙引號中，字串可以包含換行，AAuto保證雙引號中的字元
串換行使用'\n'換行符,不包含'\r'回車符。
例如：
strPath ="C:\Documents and Settings\admin\Desktop\string.aau"
strLine ="第一行
第二行"
二、、轉義字串
轉義字串放在單引號中。支援\轉義符，語法與C\C++相同。
AAuto保證單引號中只能以'\r\n'表示回車換行符,所有字面值的回車換行被忽略
轉義符 說明
\\ 表示普通\字元
\ddd 用一到三個數字組成十進位制數值表示一個字元
\xAA 用x後面的兩位十六進位制表示一個字元
\uAAAA 用u後面的四位十六進位制表示一個Unicode或雙位元組字元
\a 響鈴符(常用於print函式發出警告鈴聲，例如 io.print('\a')
\b 退格
\f 換頁
\r 回車
\n 換行
\r\n 回車換行
\t 製表符(橫向跳格)
\v 匹配一個垂直製表符。等價於 \x0b\" 雙引號
\' 單引號
\[ 方括號[
\] 方括號]
轉義字串可以換行、但是AAuto會忽略換行符，必須使用\n表示換行、
用\r\n表示回車換行。
如果單引號中僅包含一個字元、並且後面附加#號字尾、則表示該字元的位元組
碼數值。
示例：
io.open()
// 字串中也可以直接用十六進位制表示字元，例：
io.print('Hel\x6c\x6f
world\x21'); //換行被忽略
//也可以使用unicode編碼表示Unicode字串,例:
string.fromUnicode( '\u4E2D\u6587' )
//字串也可以直用三位十進位制數表示字元，格式如\000 例：
io.print('Hel\108\111 world\33')
//如果單引號中僅包含一個字元，並且在後面加上#號標記,則表示字元的ASCII值
io.print( 'A'# ) //顯示65
注意在轉義符串結束後附加#符號表示位元組碼，附加U或u表示Unicode字元
串(以'\0\0'結尾)，例如：
var wstr = '這是unicode字串'u
注意AAuto的字串是二進位制的，理論上可以支援任意文字編碼，當一個文字
字串結尾為'\0\0'，AAuto根據需要將其識別為Unicode文字。
string.fromto,string.toUnicode等函式的源字串（也就是第一個引數）可傳
入以上的unicode字串並返回正確的結果。 使用此特性，AAuto中的很多功
能可以自動支援系統內碼以及Unicode編碼，例如在web.layout(HTMLayout)
中傳入文字到介面上即可自由選擇是否使用Unicode編碼。 在com物件中，
文字屬性在傳入引數或賦值時無論是否unicode都可以自動支援（最終轉換
為unicode傳給com物件）， 而從com物件取回文字屬性值時，AAuto將自動
轉換為系統編碼，如果在屬性名後新增Unicode字尾則返回Unicode編碼文字
，例如 document.titleUnicode，注意這個字尾不應也不必要用於賦值語句。
三、、註釋字串
在AAuto的賦值語句中，可以將行註釋、段註釋作為一個字串組成賦值語句
。
在用註釋表示字串時，段註釋保證以'\r\n'換行,而行註釋保證字串沒有回
車符('\r')或換行符('\n')
請參考:回車換行符
示例：
str = //表示原始單行字串，到行尾結束;
str = /*
表示原始多行字串，首尾的*字元可以有一或多個，但*字元的數目必須首尾匹配
*/
表：
taablee(表)
AAuto中使用table資料型別可方便的支援表驅動法程式設計。
table是AAuto中唯一的資料結構型別，用來構建有序或無序的集合(collection)
。
１、表結構
1..1、、雜湊表
無序集合又稱為字典(Dictionaries)、雜湊表(hashtable)，對映(Map)，聯
合記憶體(associative memories)，聯合陣列( associative arrays)，每個元
素都是一個“鍵值對(key:value pairs )”。“鍵”可以是字元或其他除null以外
的資料型別,甚至可以在table元素中包含table，table允許巢狀。
通常把“鍵”放在索引操作符“[]”中來索引一個元素的值，這時候鍵又稱為“
下標”或“索引”。例如 tab["鍵"] tab[1] ;也可以把一個符合變數命名規則的
鍵放在成員操作符“.”後面,例如 tab.key tab.key2 ;
1..2、、陣列
table中以從1開始有序連續的數值索引儲存的元素構成陣列。陣列在記憶體中的儲存是有序的。
如果table中的部份元素使用了數字鍵但是並未包含在從1開始有序連續的
數值索引中、則構成稀疏陣列。
在AAuto所指的陣列專指有序連續陣列。
2、構造表
用{}操作符構造新的table物件，並以分號;分隔每一個元素 (不能使用逗號代替
分號)。
如果成員是一個函式並以}或end結束時，可以省略分隔符。
{}操作符在表示式中只能作為賦值表示式的右值、函式引數、或被包含在另一
個table構造器中，而不允許與其他操作符結合，不允許向前結合、向後結合
，僅允許被括號{}[]()包含。
建立一個空的table。
days = {}
建立一個table陣列。
days = { "Sunday"; "Monday"; "Tuesday"; "Wednesday";
"Thursday"; "Friday"; "Saturday" }
//days[1] 的內容是 "Sunday".days[2]的內容就是"Monday"......
table元素可以使用各種資料型別的變數，甚至可以是一個表示式或者一個
函式，如果我們為table中的值賦於一個鍵名字，則在table字典中新增一個鍵
值對。
point = { x=100 ; y=200 }
//point.x 的值是100;point.y 的值是200
可以在一個table中同時包括“陣列”、“字典”。
tab = {x=100;y=200;"Sunday"; "Monday"}
//tab.x 的值是100;tab.y 的值是200
table的鍵名並不要求符合變數命名規則，鍵可以是任何除null以外的值或字
符串。
但是在{}構造器中的鍵名必須符合變數命名規則。
在任何時候，table中不符合變數命名規則的鍵必須通過[]操作符
訪問，以下是正確的寫法：
tab = { [1]=300;[2]=400;["+"]=200;[1+1]=200 }; //因為
變數名不能以數字開始,更不能包含運算子。
以上的寫法等價於
tab ={};
tab[1]=300;
tab[2]=400;
tab["+"]=200;
tab[1+1]=200;
我們可以把多個變數用一對花括號包含起來以轉換為table陣列，也可以通過table.unpack函式將table陣列轉換為多個變數。
tab = {"a";"abc";"abcd"} ; //建立一個table;
a,b,c = table.unpack(tab);
tab ={ table.unpack(tab) }; //將所有返回值轉換為table變
量tlinks
3、、在函式引數中構造表
當在函式內部有且只有一個使用{}構造器構建的table引數時，並且不包含數
組元素，則{}可以省略。
例如：
func( { k = 123 ; k2=456 } )
可以省略{}寫成如下格式：
func( k = 123 ; k2=456 )
4、、訪問taablee成員
在訪問table中的元素時，用元素的鍵作為下標查詢元素的值，例如:
tab = {}; //用一對花括號建立一個空的table
tab["x"] = 200; //下標為字串"x"，鍵名為字串"x"，值為數
值200。
tab[1] = "hellor world"; //下標為數字1,鍵索引為1，值為字
符串 "hellor world"
如果“鍵”是一個數字索引稱為“鍵索引”，如果鍵是一個字串稱為“鍵名” ，
對於符合變數命名規範的鍵名，可以用"."成員符訪問。例如：
tab["x"] = 200; 也可以寫為 tab.x = 200;
當我們將tab元素賦值為null會刪除這個元素。例如：
tab.x = null; //刪除tab.x
4、、遍歷taablee
遍歷table列表中的全部元素
io.open(); //開啟控制檯視窗,用來支援print函式
tab = { a="字串"; b=123; c="字串2"; d=23; e=56; 78; 99; 123; 0 }
for k,v in tab {
//k為鍵,v是匹配的值,在這裡鍵值對無序的隨機出現。
io.print(k,v); //顯示: 鍵,值
};
遍歷table列表中的陣列元素
io.open(); //開啟控制檯視窗,用來支援print函式
tab = { a="字串"; b=123; c="字串2"; d=23; e=56; 78; 99; 123; 0 }for i=1; #tab;1 {
io.print( i ,tab[i] );
}
fuunncctioonn(函式)
函式是一個子程式，可以接收零個或多個引數、返回一個或多個值。使
用function關鍵字定義函式，使用()操作符呼叫函式。請參考：定義函式
ccdaataa(核心物件）
物件是由AAuto管理的指標物件，由AAuto自動管理cdata指向的記憶體，並在不需要的時候自動釋放。
一般cdate物件由AAuto核心提供。可以通過元表指定成員方法、過載操作符
，使之有類似table的行為。
如果指定了_topointer元言法則可以自動轉換為裸指標供API函式使用。
io.open(); //開啟控制檯視窗
io.print( type( io.stdin ) , type.cdata );//顯示 cdata ,
cdata
使用raw.malloc函式可以動態建立cdata型別的記憶體指標、可以使用索引操作
符存取資料、可以在API函式中自動轉換為裸指標，不應當為raw.malloc建立
的cdata物件指定元表，這會導致索引操作符失效。
buf = raw.malloc(123)
buf[1] = 65
io.open()
io.print(buf[1])
//對於溢位下標返回數值0
io.print(buf[-1])
cclaassss(類)
使用class關鍵字定義類。類可以動態建立資料結構相同的table物件。 請參考
：class
fiber(纖程)
fiber.create()建立並返回的纖程物件。 纖程類似執行緒,但不是執行緒. 纖程有獨立的執行堆疊,並且也可以暫停或繼續執行,但是纖程並不會建立新的
執行緒,也不能同時執行多個纖程.
請參考：內建庫->纖程庫
轉換資料型別
數值、字串會自動轉換，但是我們也可以用AAuto提供的函式強制轉換。
AAuto提供三個強制轉換動態型別的函式
tostring(v) 轉換引數v為字串，可使用_tostring元方法自定義轉換函式
。
tonumber(v) 轉換引數v為數值，可使用_tonumber元方法自定義轉換
函式。
topointer(v) 轉換引數v為指標，可使用_topointer元方法自定義轉換函式
。
io.open(); //開啟控制檯視窗,用來支援io.print函式
n = tonumber( "2" );//tonumber函式強制轉換一個變數為數字，如果失敗
返回null空值str = tostring( 2 );//強制轉換一個變數為字串，如果失敗返回null空值
ptr = topointer( 123 ); //強制轉換為指標，如果失敗返回null空值
io.print( type(n),type(str),type(ptr) );
使用typee函式可以讀取資料型別。。
1、、函式原型：：
dataType[,structType][,metaType] = type( any )
2、、函式說明：：
type函式返回物件的基本資料型別dataType。
如果物件是一個struct結構體，則返回結構體型別structType。
如果物件在元表中指定了_type欄位的值，則返回元型別metaType。
AAuto用字串描述型別，所以返回的型別都是字串, 如果沒有任何引數,type函式無返回值.
3、、呼叫示例：：
io.open(); //開啟控制檯視窗
io.print( type(null) , type.null );//顯示null , null
io.print( type("Hello world") , type.string );//顯示
string , string
io.print( type(1000) , type.number );//顯示 number ,
number
io.print( type(io.print) , type.function );//function ,
function
io.print( type( class{} ) , type.class );//顯示 class ,
class
io.print( type(true) , type.boolean );//boolean , boolean
io.print( type( io.stdin ) , type.cdata );//顯示 cdata ,
cdata
io.print( type( {x=0;y=0} ) , type.table );//顯示 table ,
table
io.print( type( topointer( 1 ) ) , type.pointer );//
顯示 pointer , pointer
使用typee..eeq比較資料型別
1、、函式原型：：eq = type.eq( obj,obj2 )
2、、函式說明：：
比較引數一、引數二的型別、元型別、sturct型別，如果完全相等返回true，
否則返回false
3、呼叫示例:
import time.ole
io.open(); //開啟控制檯視窗
var oletm = time.ole();
var tm = time();
//type.eq嚴格比較所有型別(基礎型別、元型別、struct型別)
if( type.eq( oletm,tm ) ){
io.print("oletm,tm型別相同")
}
else{
io.print("oletm,tm型別不相同")
}
//time.istime不比較元型別，因此相容oletime
io.print( "是datetime物件嗎?",time.istime(oletm) )
execute("pause") //按任意鍵繼續
io.close();//關閉控制檯
注意事項
這是一個aauto語言語法規則
你可以參考，寫自己的程式語言