[Autohotkey入门]这是一张标注清晰的地图-关联数组与数组

集装箱 := {}
;~ ------ 首先, 表示它是很有内容的(用{}大括号声明一个对象)

集装箱["里面"] := "内容"
;~ ------ 然后, 我们在它 的 "里面" 放上 "内容"

Msgbox, % 集装箱["里面"]
;~ ------ 接着, 我们通过 "里面" 把这个东西拿出来晒一晒

集装箱["别的标签"] := "新来的神秘物体"
;~ ------ 继续, 装点别的东西

s := "别的标签"
Msgbox, % 集装箱[s]
;~ ------ 通过一个变量把新的神秘物体弄出来

a := "别的"
b := "标签"
Msgbox, % 集装箱[a . b]
;~ ------ 通过2个变量拼接把新的神秘物体弄出来

c := "别"
Msgbox, % 集装箱[c . "的标签"]
;~ ------ 再来, 通过1个变量和1个字符串拼接做同样的事

Msgbox, % 集装箱.count() . " 个内容是至今这个集装箱里总共有的"
;~ ------ 我们到底放了多少东西呢, .count()是集装箱的方法之一

for 标签, 内容 in 集装箱
     msgbox, % 标签 "`n" 内容
;~ ------ 用for循环语句分别掏出来瞅一瞅

集装箱 := {"标1": "物1", "标2" : "物2"}
;~ 我们重新定义它

s := ""
for k, v in 集装箱
   s .= k . "=" . v . "`n"
msgbox, % s    
;~ ------ 可以发现最初定义的东西消失了, 
;~ ------ 这是用for循环拼接一个字符串s, 然后一次性显示在信息窗

对象 := {"键名" : "值"}
Msgbox, % 对象["键名"]

对象 := {2 : 34567}
Msgbox, % 对象[1+1]

对象["某参1"] := 333
对象["某参2"] := "一行字"

MsgBox, % 对象["某参1"]   ;~ 弹窗 333
MsgBox, % 对象["某参2"]   ;~ 弹窗 一行字

消息() {
  static 引用次数
  引用次数 += 1
  Msgbox, 弹出一个消息`n引用次数为%引用次数%
}

对象["弹窗"] := func("消息")
对象["弹窗"]()

即将被扔进另一个对象 := {"键": "别的键的值"}
对象["小天地"] := 即将被扔进另一个对象
Msgbox, % 对象["小天地"]["键"]

C := {"国学" : {"儒学" : {"荀子": {"温碧霞":"香魂.rmvb", "舒淇":"玉蒲团.avi", "叶玉卿":"卿本佳人.flv","快播":func("播放"), "高清写真" : {....})}}}}

好地方 := C["国学"]["儒学"]["荀子"]
好地方["快播"](好地方["舒淇"])

;~ 譬如 .count() 方法，获取字典中键值对数量
字典 := {"键1":"", "键2":""}

;~ 正常我们使用方法
Msgbox, % 字典.count()

;~ 用键名取方法也是被允许的
Msgbox, % 字典["count"]()

;~ 取键的值也可以用. 英文句号
Msgbox, % 字典.键1

;~ 但是这样内置的方法可以被重写(覆盖)
字典["count"] := 233

;~ 如此，这个字典永远失去了它的方法
Msgbox, % 字典["count"] . ": 这是count的新内容"
Msgbox, % 字典["count"]() . ": 到底经历了什么, 左边空掉了"

对象 := object()
对象 := {}

对象 := Array()
对象 := []

;~ 由object() 函数创建, 传入参数为一般为2的倍数, 单数位为键, 双数位为值
o1 := object("键1","1内容", "键2","2内容")

;~ 由{ } 中 的 (键 : 值) 以 (,) 分隔 方式
o2 := {"键1" : "1内容", "键2": "2内容"}

;~ 同上等效
o3 := {键1 : "1内容", 键2: "2内容"} ;键名有无双引号都视作字符串

变量 := "键"
a := {变量 : 11}
Msgbox, % a[变量] ;~ 空弹窗
Msgbox, % a["键"] ;~ 空弹窗
Msgbox, % a["变量"] ;~ 弹窗11

b := {(变量) : 11}
Msgbox, % b["键"] ;~ 弹窗11

c := {( "ab" . "cd") : 123 }
Msgbox, % c["abcd"]

;~ a1和a2两种定义方法，解释器默默地将内容本体从左至右写上出现次序的键
;~ 是以1为首序号，步进为1的递增

a1 := Array("1内容","2内容","3内容")
a2 := ["1内容", "2内容", "3内容"]


;~ 若你心大(闲得蛋疼)定义这样的数组可以如下办法, 也是等效的
a3 := {1 : "1内容", 2 : "2内容", 3 : "3内容"}

o := {"标1":123}
msgbox, % o["标1"] ;~ 弹窗123

o := {"标2":556}
msgbox, % o["标1"] ;~ 弹窗空白

a := {}
b := {}

c := {}
c[a] := 123
msgbox, % c[a] ;~ 取得123
msgbox, % c[b] ;~ 空弹窗

a := {}
a[1.1] := 11
a[5] := 22
a[9.9] := 33
Msgbox, % a.maxindex()
Msgbox, % a.minindex()

;~ 两个弹窗皆返回5

Msgbox, % a[9.9] ;~ 取值正常弹窗33

对象 := {"键1" : 123, "键2" :123}

;~如此行为添加内容(键值对)
对象["键3"] := 556  

for 键, 值 in 对象
  msgbox, % 键 "=" 值

/* 依次弹窗
键1=123
键2=123
键3=556
*/

a:= [123, 123]
a[3] := 556

for 键, 值 in a
  msgbox, % 键 "=" 值

数组.Push(值)

A := [123, 123]
A.push(556)
for 键, 值 in A
  msgbox, % 键 "=" 值   

/* 依次弹出
1=123
2=123
3=556
*/

A := {-6: 123, -5: 456}
A.push(789)
for 键, 值 in A
  msgbox, % 键 "=" 值

/* 依次弹窗:
-6=123
-5=456
-4=789
*/


;~ 等效方法:

A := {7: 123, 8: 123}
最大键 := A.maxindex()
msgbox, % 最大键       ;~弹窗8

A[最大键 + 1] := 556
for 键, 值 in A
  msgbox, % 键 "=" 值

A := [ ]
A.Push("abc")
A.Push("def")
A.Push("ghi")
for i, v in A
     MsgBox, % i "=" v

/* 依次弹窗
1=abc
2=def
3=ghi
*/

a := {"我不是数字键的哦" : 123}
a.push("随便放个东西")
for key in a
   Msgbox,% key

依次弹窗:
> 1
> 我不是数字键哦

;~数字键分别为1 6 10
A := {1: 111, 6: 222, 10: 333}

;~ 从第1位开始插入3个字符
A.InsertAt(1, "a", "b", "c")

for i, v in A
   Msgbox, % i "=" v

/* 分别弹窗:
1=a
2=b
3=c
4=111
9=222
13=333
*/

对象 := {"abc": 123}
msgbox, % 对象["abc"]   ;~ 弹窗123

Msgbox, %对象%["abc"]
Msgbox, %对象["abc"]%

obj := {22      : 100
    , "灵能100%": 200
    , "funcRet" : 300}

;~ 取键 22 的值
msgbox, % obj[11 * 2] 

;~ 取键 "灵能100%"的值
msgbox, % obj["灵能" . (20* 5) . "%"]

;~ 取键 "funcRet"的值
函数() {
   return "funcRet"
}
msgbox, % obj[函数()]

a := 123
b := {}
c := [123]
msgbox, % IsObject(a) ;~ 返回 0
msgbox, % IsObject(b) ;~ 返回 1
msgbox, % IsObject(c) ;~ 返回 1

;~ 数组A的3个键分别为，1, 2, 3
A := ["内容", "内容", "内容"]
msgbox, % A.haskey(3)  ;~ 返回1 (true)
msgbox, % A.haskey("内容") ;~ 返回0 (false)

;~ a的2个键分别为 "abc" "def"
A := {"abc": 111, "def": 222}

msgbox, % A.haskey("def") ;~ 返回1(true)
msgbox, % A.haskey(111) ;~ 返回0 (false)

数组 := {-1:"",-3:"", -5:""}
msgbox, % "最大键为" . 数组.maxindex()  ;~ 弹窗-1
msgbox, % "最小键为" . 数组.minindex()  ;~弹窗-5

for 键 in 对象
{
   ;~ 代码块
}

for 键, 值 in 对象
{
   ;~ 代码块
}

;~ 数组:
for i, v in ["abc", "def", "ghi"]
{
   Msgbox, 
   (
       当前循环次数: %A_Index%
       当前取得下标: %i%
       当前取得值: %v%
    )
}

;~ 字典:
for key, v in {"k1": 333, "k2":666, "k3":999}
{
   Msgbox, 
   (
       当前循环次数: %A_Index%
       当前取得键名: %key%
       当前取得值: %v%
    )
}

;~ for 遍历 数组 A
A := [333, 666, 999]
for i, v in A
    msgbox, % i "=" v


;~ for 遍历 函数的返回值
函数() { 
   return {"a":33, "b":66, "c":99}
}
for k, v in 函数()
    Msgbox, % k "=" v



;~ for 遍历 二维嵌套对象


a:= {}

a["abc"] := [11, 22, 33]
a["def"] := [44, 55, 66]
a["ghi"] := [77, 88, 99]

/* 等效定义方法
a := {"abc": [11, 22, 33]
    , "def": [44, 55, 66]
    , "ghi": [77, 88, 99]}
*/

计次 := 0

for key, List in a {
   for i, v in List {
      计次 += 1
      Msgbox, 
      (
         当前取得对象a中列表: %key%
         取得该列表下标: %i%
         下标对应值: %v%
         总计次: %计次%
      )

   }
}

loop, % 对象.count()
{
}

for i in 对象
{
}

for i in {11:"", 9:"", 5:"", 1:""}
  msgbox, % i

;~ 取得"启"字utf-16编码
code := asc("启")
MsgBox, % "启字编码为: " code

;~ 将"启"开始 编码步进为1 的所有编码对应字符依序拼接 200 个, 赋值给s1
s1 := ""
Loop, 200
  s1 .= chr(code + A_Index - 1)
MsgBox, % "初次执行结果:`n" . s1

;~ 声明一个空对象
obj := {}

;~ 解析s1 每个字符作为对象 obj 的键
Loop, parse, s1
{
  obj[A_LoopField] := ""
}

;~ 用 for 循环依次取出obj的键, 拼接赋值 给s2
s2 := ""
for key in obj
{
  s2 .= key
}
MsgBox, % "第二次执行结果:`n" . s2

if (s1 = s2)
{
  MsgBox, 这两个字符串是等值的
}
return