掌握awk系列（20）: awk数组的详细用法

返回:

Awk数组特征:

Awk数组支持数组数组

1
2

arr[idx]
arr[idx] = value

索引可以是整数，负数，0，十进制，字符串. 如果它是数字索引，则将首先根据CONVFMT变量指定的格式将其转换为字符串.

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

awk '
  BEGIN{
    arr[1]   = 11
    arr["1"] = 111
    arr["a"] = "aa"
    arr[-1]  = -11
    arr[4.3] = 4.33
# 本文来自骏马金龙：www.junmajinlong.com
    print arr[1]     # 111
    print arr["1"]   # 111
    print arr["a"]   # aa
    print arr[-1]    # -11
    print arr[4.3]   # 4.33
  }
'

当通过索引访问数组中不存在的元素时，将返回一个空字符串. 同时，将创建该元素并将其值设置为空字符串.

1
2
3
4
5
6
7

awk '
  BEGIN{
    arr[-1]=3;
    print length(arr);  # 1
    print arr[1];
    print length(arr)   # 2
  }'

awk提供length（）函数以获取数组中元素的数量. 它也可以用来获取字符串中的字符数. 将值转换为字符串后，您还可以获得字符数.

1

awk 'BEGIN{arr[1]=1;arr[2]=2;print length(arr);print length("hello")}'

删除arr: 删除数组的所有元素

1
2

$ awk 'BEGIN{arr[1]=1;arr[2]=2;arr[3]=3;delete arr[2];print length(arr)}'
2

isarray（arr）可用于检测arr是否为数组. 如果是数组，则返回1；否则返回0. 否则返回0.

typeof（arr）返回数据类型. 如果arr是一个数组，则返回“ array”.

1
2
3
4
5

awk 'BEGIN{
    arr[1]=1;
    print isarray(arr);
    print (typeof(arr) == "array")
}'

请勿使用以下方法测试元素是否在数组中:

1

if(arr["x"] != ""){...}

有两个问题:

应使用in中的数组成员test运算符进行测试:

1
2

# 注意，idx不要使用index，它是一个内置函数
if (idx in arr){...}

它测试索引idx是否在数组中，如果存在则返回1，否则返回0.

1
2
3
4
5
6
7
8
9
10
11
12
13

awk '
    BEGIN{
    # 本文来自骏马金龙：www.junmajinlong.com
        arr[1]=1;
        arr[2]=2;
        arr[3]=3;

        arr[1]="";
        delete arr[2];

        print (1 in arr);  # 1
        print (2 in arr);  # 0
    }'

awk提供了一个for变量来遍历数组:

1

for(idx in arr){print arr[idx]}

因为awk数组是一个关联数组，所以元素不是连续的，即没有顺序. 当遍历awk数组时，顺序是不可预测的.

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 本文来自骏马金龙：www.junmajinlong.com
awk '
    BEGIN{
        arr["one"] = 1
        arr["two"] = 2
        arr["three"] = 3
        arr["four"] = 4
        arr["five"] = 5

        for(i in arr){
            print i " -> " arr[i]
        }
    }
'

另内awk数组长度，则可以使用此方法遍历.

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 本文来自骏马金龙：www.junmajinlong.com
awk '
    BEGIN{
        arr[1] = "one"
        arr[2] = "two"
        arr[3] = "three"
        arr[4] = "four"
        arr[5] = "five"
        arr[10]= "ten"

        for(i=0;i<=10;i++){
            if(i in arr){
                print arr[i]
            }
        }
    }
'

在awk中，简单数组通常只能存储两条信息: 索引和值. 但是在某些情况下，处理复杂的需求时可能会扩展这种简单的存储功能.

为了存储更多信息，其中一种方法是以特殊的方式将信息的第三和第四副本存储到值中，但是此方法在实际使用中并不方便，您需要每次值被除以提取每个部分的值.

另一种方法是将信息的第三和第四副本存储在索引中，并组合多个数据副本以形成索引.

Gawk提供了将多条数据信息组合成一个整体作为索引的功能. 默认方法是arr [xawk数组长度，y]，其中x和y是要组合以形成索引的两条数据信息. 逗号称为下标分隔符，在构建索引时，将基于预定义变量SUBSEP的值组合多个索引. 因此，arr [x，y]实际上等效于arr [x SUBSEP y].

例如，如果SUBSEP设置为“ @”，则当存储arr [5,12] = 512时，其实际索引为5 @ 12，因此要访问该元素，您需要使用arr [“ 5 @ 12“].

SUBSEP的默认值为\ 034，这是一个不可打印的字符，几乎不可能出现在字符串中.

如果愿意，我们还可以组合多个数据以自己建立索引，例如arr [x“” y]. 但是awk提供了这种更简单的方法，只需直接使用它即可.

为了测试此复杂数组的索引是否在数组中，可以使用以下方法:

1
2

arr["a","b"] = 12
if (("a", "b") in arr){...}

例如，顺时针反转以下数据:

1
2
3
4
5
6
7
8
9
10
11
12

1 2 3 4 5 6
2 3 4 5 6 1
3 4 5 6 1 2
4 5 6 1 2 3

结果：
4 3 2 1
5 4 3 2
6 5 4 3
1 6 5 4
2 1 6 5
3 2 1 6

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

{
  nf = NF
  nr = NR
  for(i=1;i<=NF;i++){
    arr[NR,i] = $i
  }
}

END{
  for(i=1;i<=nf;i++){
    for(j=nr;j>=1;j--){
      if(j%nr == 1){
        printf "%s\n", arr[j,i]
      }else {
        printf "%s ", arr[j,i]
      }
    }
  }
}

子数组是指数组中的一个元素，它是一个数组，即Array of Array，也称为子数组.

awk还支持子数组，这些子数组实际上是嵌套的或多维数组.

1
2
3
4
5
6
7
8
9
10

a[1][1] = 11
a[1][2] = 12
a[1][3] = 13
a[2][1] = 21
a[2][2] = 22
a[2][3] = 23
a[2][4][1] = 241
a[2][4][2] = 242
a[2][4][1] = 241
a[2][4][3] = 243

通过以下方式遍历二维数组:

1
2
3
4
5
6
7
8

for(i in a){
    for (j in a[i]){
        if(isarray(a[i][j])){
            continue
        }
        print a[i][j]
    }
}

由于awk数组是一个关联数组，因此默认情况下，遍历该数组时for（idr in arr）的顺序是不可预测的.

但是gawk提供了PROCINFO [“ sorted_in”]来指定要遍历的元素的顺序. 可以将其设置为两种类型的值:

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

awk '
  BEGIN{
    arr[1] = "one"
    arr[2] = "two"
    arr[3] = "three"
    arr["a"] ="aa"
    arr["b"] ="bb"
    arr[10]= "ten"

    #PROCINFO["sorted_in"] = "@ind_num_asc"
    #PROCINFO["sorted_in"] = "@ind_str_asc"
    PROCINFO["sorted_in"] = "@val_str_asc"
    for(idx in arr){
      print idx " -> " arr[idx]
    }
}'

a -> aa
b -> bb
1 -> one
2 -> two
3 -> three
10 -> ten

# 本文来自骏马金龙：www.junmajinlong.com

如果将其指定为用户定义的排序功能，则其功能格式为:

1
2
3
4

function sort_func(i1,v1,i2,v2){
    ...
    return <0;0;>0
}

其中，i1和i2是每次获取的两个元素的索引，而v1和v2是这两个索引的对应值.

如果返回值小于0，则表示i1在i2之前，且i1首先被遍历. 如果等于0，则表示i1和i2具有相等的关系，并且不能保证其遍历顺序. 如果大于0，则表示i2在i1之前遍历.

例如，比较数字数组元素以确定遍历顺序.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

awk '
function cmp_val_num(i1, v1, i2, v2){
  if ((v1 - v2) < 0) {
    return -1
  } else if ((v1 - v2) == 0) {
    return 0
  } else {
    return 1
  }
  # return (v1-v2)
}

NR > 1 {
  arr[$0] = $4
}

END {
  PROCINFO["sorted_in"] = "cmp_val_num"
  for (i in arr) {
    print i
  }
}' a.txt

另一个例子是比较数组元素值的字符大小.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

function cmp_val_str(i1,v1,i2,v2) {
    v1 = v1 ""
    v2 = v2 ""
    if(v1 < v2){
        return -1
    } else if(v1 == v2){
        return 0
    } else {
        return 1
    }
    # return (v1 < v2) ? -1 : (v1 != v2)
}

NR>1{
    arr[$0] = $2
}

END{
    PROCINFO["sorted_in"] = "cmp_val_str"
    for(line in arr)
    {
        print line
    }
}

再举一个例子，当元素值相等时，按升序数字顺序比较元素值，然后根据第一个字段ID按降序比较它们.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

awk '
function cmp_val_num(i1,v1,i2,v2,    a1,a2) {
    if (v1<v2) {
        return - 1
    } else if(v1 == v2){
        split(i1, a1, SUBSEP)
        split(i2, a2, SUBSEP)
        return a2[2] - a1[2]
    } else {
        return 1
    }
}

NR>1{
    arr[$0,$1] = $4
}

END{
    PROCINFO["sorted_in"] = "cmp_val_num"
    for(str in arr){
        split(str, a, SUBSEP)
        print a[1]
    }
}

' a.txt

上面使用arr [x，y]存储附加信息，下面使用arr [x] [y]多维数组存储附加信息以实现相同的排序功能.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

NR>1{
  arr[NR][$0] = $4
}

END{
  PROCINFO["sorted_in"] = "cmp_val_num"
  for(nr in arr){
    for(line in arr[nr]){
      print line
    }
  # 本文来自骏马金龙：www.junmajinlong.com
  }
}

function cmp_val_num(i1,v1,i2,v2,   ii1,ii2){
  # 获取v1/v2的索引，即$0的值
  for(ii1 in v1){ }
  for(ii2 in v2){ }

  if(v1[ii1] < v2[ii2]){
    return -1
  }else if(v1[ii1] > v2[ii2]){
    return 1
  }else{
    return (i2 - i1)
  }
}

此外，gawk提供了两个内置函数asort（）和asorti（）对数组进行排序.

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/jisuanjixue/article-154428-1.html