//AS,JS字符串索引以及对象索引资料收集,请先运行一下程序,就知道了.然后才看总结
/*** 测试使用数组前必须赋值 ***/
a=[];//使用数组前必须赋值,有3种方法:① ?=[];② ?=new Array();③?=[....];
o={};//使用普通对象前必须赋值,有3种方法:① ?={};② ?=new Object();③?={....};
//注意:一个数组、一个对象【无论用new 或[]还是{}】再赋值都只会全部更换内容!不会添加内容.


/*** 测试这是【不规则,不对称性】 ***/
a[9]="9";a[10]=10;
trace(a[10]+"。允许无size地个别元素赋值.证明允许存在空成员,不像c#的固定空间");
trace(typeof(a[9])+" "+typeof(a[10])+"。不要求子体类型一致");


/*** 测试共性【字符串索引】,测试方法可以作子体 ***/
a["11"]="这个元素的索引是\"11\"。a[11]和a[\"11\"]完全等价";
trace(a[11]);trace(a["11"]);//这个元素的索引是"11"。a[11]和a["11"]完全等价


a[12]=function(){trace("方法也可用索引,这个方法的索引是12。a[12]()和a[\"12\"]()完全等价");};
a[12]();a["12"]();//方法也可用索引,这个方法的索引是12。a[12]()和a["12"]()完全等价


/*** 测试小数和负数索引 ***/
a[12.7]="这个元素的索引是12.7(即\"12.7\"),它不影响a[12],但【赋值给元素时,若数字索引大于[]长度,则改写[]长度】";
trace(a["12.7"]);//这个元素的索引是12.7(即"12.7"),它不影响a[12],也不会算在数组长度之内
a[12]();//所以a[12]仍然是a[12]
trace("所以a[12]仍然是a[12]");


a[-2]="这个元素的索引是-2(即\"-2\"),也不会算在数组长度之内";
trace(a[-2]);//这个元素的索引是-2(即"-2"),也不会算在数组长度之内


/*** 测试只有【以非负整数或其字符串为索引的子体】才会.length之内 ***/
trace("此时的数组长度是"+a.length+",刚好是最后的非负整数索引+1");//此时的数组长度是13,刚好是最后的非负整数索引+1


/*** 测试任何字符串可作索引 ***/
a["1←.?;&"]=function (){trace("这个方法以Unicode字符串为索引,也不会计算在数组长度之内");};
a["1←.?;&"]();//哈,这种语法估计很多人还未见过


/*** 测试属性属于字符串索引的一种 ***/
a.a属性="a.a属性和a[\"a属性\"]完全等价,也不会计算在数组长度之内";
trace(a.a属性);trace(a["a属性"]);//a.a属性和a["a属性"]完全等价,也不会计算在数组长度之内

/*** 测试只有【以非负整数或其字符串为索引的子体】才会.length之内 ***/
trace("数组长度仍是"+a.length+",证明以非负整数或其字符串为索引的子体才计算在数组长度之内");//长度仍是13,证明以非负整数或其字符串为索引的子体才计算在数组长度之内


/*** 测试保存在prototype的子体不会计算在数组长度之内 ***/
Array.prototype[13]=function (){trace("这个方法以13为索引,由于保存在prototype中的,也不在数组长度之内");}
a[13]();
Array.prototype[14]="这个元素以14为索引,但由于保存在prototype,也不在数组长度之内";
trace(a[14]);

trace("数组长度仍然是"+a.length+".证明保存在prototype的部分不会计算在数组长度之内");


/*** 测试【多维对象组】的存在以及【用{}嵌套来避免跨层定义】 ***/
a["7.2"]={};//如果没有这一句则没有下面的输出
a["7.2"]["∵⊿.;+"]=function(){trace("非【以非负整数或其字符串为索引的子体】也可多维,例如必须先定义a[\"?\"]才能使a[\"?\"][\"?\"]生效,和数组类似");}
a["7.2"]["∵⊿.;+"]();
o={a:{哈:function(){trace("o={a:{哈:function(){}},b:1};,用{}或[]嵌套可避免跨层定义");}},b:1};
o.a.哈();


/*** 测试对象索引 ***/
b={};
c=b;
a[b]=function(){trace("这个元素的索引是对象地址b,由于c=b;所以a[b]和a[c]完全等价");}
a["b"]=function(){trace("这个元素的索引是\"b\",a.b和a[\"b\"]完全等价");}
a[b]();a[c]();
a["b"]();a.b();
trace((a[b]==a["b"])+",所以a[b]和a[\"b\"]不能混为一谈");



/*** 测试多维数组不能跨层定义 ***/
a=[];
a[0][1]=12;
trace(a[0][1]+"←空的,返回undefined证明不定义a[0]就不能定义a[0][1]");



/*** 测试多唯【非负整数索引的子体】数组不是Array类独有 ***/
o={};
o[1]={};//Object ;
o[1][2]="索引是[1][2]";
trace(o[1][2]+",证明多维数组不是Array类独有");



/*** 测试静态成员也可以用索引 ***/
类=function(){}
类.a=function(){trace("【类.a】和【类[\"a\"]】是同一个静态成员");}
类.a();类["a"]();
类[2]=function(){trace("【类[2]】和【类[\"2\"]】是同一个静态成员");}
类[2]();类["2"]();



/*** 函数:定义"三维对象组",SX,SY,SZ表示各维长度,索引用数字 ***/
function new3a(o,SX,SY,SZ)
{
    for(var X=0;X    {
        o[X]={};
        for(var Y=0;Y        {
            o[X][Y]={};
            o[X][Y][Z-1]=null;
            trace(o[X][Y][Z-2]=2);
        }
    
    }
    return o;
}
q=new3a({},3,4,5);
trace(q[3][4][1]="你好");
//flash数组和对象都可以三维,而且都不能跨层定义,就是不定义o[2]就不能定义o[2][3]




/*** 综上所述, ***/
/* 字符串索引知识总结:
　一般数组元素=【以非负整数或其字符串为索引的子体】
　一般对象成员=以【"名"】为索引的子体
　【非数字非名字符串作索引的子体】例如a["2←.,△"]=1;
　负数或小数或其字符串作索引的子体
以上4种【子体】的共性就是:
　　①索引本质是一致的。可以统一为【字符串索引】,【充分发挥文本处理功能】.(setProperty()也可以看成表现为字符串索引).
　　②如果主体是数组的话,保存在prototype的子体不会计算在数组长度之内,意味着不能全享数组的方法.
　　③【仿指针仿引用:】巧用索引和子体可以弥补Flash没有指针的弊病,也可以防止一个对象多个引用导致的对象不能删除性
　　④子体本质一致,可以装载属性,方法,g/s属性
　　⑤这种制度比较稳定和自由
　　⑥【不规则,不对称】,即不要求子体一致存在,不要求子体类型一致,也不必声明类型
　　⑦【动态】:即子体可以随意增/改/删:a.a=1;a.a=undefined;
　　⑧单唯和多维【非负整数索引的子体】的数组不是Array类独有
　　⑨【以非负整数或其字符串为索引的子体】的多维与[]的多维数组的定义【都不能跨层定义】:
a["&"]={};a["&"]["_"]=1;
o={a:{哈:1},b:1};
c=[null,null,[null,"2_1"]];
b[2]=[];b[2][1]="2_1";
　　⑩静态成员也可以用索引,和一般子体用法类似.
　　⑾起初我以为子体太多是降低组运行速度的最大因素。原来多维和循环才是。
　　⑿在CSAS、FRSSAS（.asr）、FCSSAS（.asc）、JS中都可以使用任何字符串索引,符合这里。
但是不知为什么:在FCSSAS中,客端nc远程call服端client的方法时,则被call方法必须正规变量命名.
　　⒀【无论用new 或[]还是{}】再赋值都只会全部更换内容!不会添加内容
　　⒁赋值器【[]和{}是new Array()和new Object()的简写】,且【都可以嵌套(可避免来跨层定义).】,这点JS和AS都一样.
　　⒂

4种子体的区别就是:
　　①4者的内存是完全区别的,不是互相包含的
　　②【以非名为索引的子体】既不能通过【.】来访问,【也不能在{}里面定义】。
而以【非数字字符串】为索引的子体【既不能通过数字索引来访问】,【也不能在[]里面定义】.
　　③如果主体是[]的话,[]的小数索引元素不会直接享用方法,但它透过
【赋值给元素时,若数字索引大于[]长度,则改写[]长度】这个原理来影响方法的运行效果。
　　④什么字符串可以作名呢?就是以各国文字或_开头,后跟各国文字或数字或_。注意JS的名不支持非英文的各国文字。
　　
　　

△对象(即其内存地址)也可作索引,这很像C#中的Dictionary,这反映了弱类型语言的对象的灵活性。【对象索引】不属于【字符串索引】,但特性基本相同.

集中一些关于字符串索引的命令:------------------------------------------------------------------------------------------------------------

set("",);
get("")
setProperty("",,);
getProperty("",)
eval( )
[""]
[""]()
for(var 每个字符串索引 in ){}




总之ActionScript和javascript仿佛力图将函数和类的形式、数组和对象的形式、声明与赋值的形式、类成员定义和实例成员定义的形式,方法和属性形式都趋向统一。
*/

a=[];//Array b;
a=[0,1,2,3];
trace(a.length);

a[0.1]=0.1;
a[1.1]=1.1;
a[2.1]=2.1;
a[3.1]=3.1;


trace("for in------");
for(var 每索 in a){trace(每索);}
trace("------");
trace(a.length+",[]小数索引小于已有的长度时不会对长度有影响");
trace(a[1]);



trace("----------------------------------");
b=[];//Array b;
b[-2]=-2;
trace(b.length);
b[3.7]=3.7;


trace("for in------");
for(var 每索 in b){trace(每索);}
trace("------");
trace(b.length+",[]的小数索引大于现有长度时有机会改变长度.");
//[]的小数索引很奇特,
//它小于已有的长度是不会对长度有影响
//,但它大于现有长度时却有机会改变长度.


trace("b[3]="+b[3]);
b.push("push 1");
trace("b[4]="+b[4]+" 此时长度是"+b.length);
b.push("push 2");
trace("b[5]="+b[5]+" 此时长度是"+b.length+"看来长度只由最大的数字索引的元素决定");

trace(",[]的小数索引元素不会直接享用方法,但它透过【赋值给元素时,若数字索引大于[]长度,则改写[]长度】这个原理来影响方法的运行效果,看下面:");

str=b.join(",");
trace(str+"证明以小数作为索引的元素不能享用join方法");

b[100.5]=100.5;
trace("b[100.5]=100.5;此时长度:"+b.length);
trace("被pop的元素是:"+b.pop()+",此时长度是:"+b.length+",100.5是最大的数字索引,而b[100.5]没有被pop,仍在:b[100.5]="+b[100.5]);

b.reverse();
trace("b.reverse();b此时变化了: "+b.join(","));

trace("此时长度:"+b.length);
b[100.5]=100.5;
trace("再赋值一次,b[100.5]=100.5;此时长度:"+b.length);