jesse_b's questions

我有一个很大的数据表，我想将其转换为 json，并且不确定像 jq、mlr 或类似的工具是否能够执行这样的任务，而不必求助于我糟糕的 awk 技能。

样本表：

Balance_sheet for AAPL:

                                                        2023-09-30      2022-09-30      2021-09-30      2020-09-30
Treasury Shares Number                                         0.0             NaN             NaN             NaN
Ordinary Shares Number                               15550061000.0   15943425000.0   16426786000.0   16976763000.0

首选输出：

{
    "Balance_sheet for AAPL": {
        "Treasury Shares Number": {
            "2023-09-30": "0.0",
            "2022-09-30": "NaN",
            "2021-09-30": "NaN",
            "2020-09-30": "NaN"
        },
        "Ordinary Shares Number": {
            "2023-09-30": "15550061000.0",
            "2022-09-30": "15943425000.0",
            "2021-09-30": "16426786000.0",
            "2020-09-30": "16976763000.0"
        }
    }
}

以下格式也可以使用，但不太理想：

{
    "Balance_sheet for AAPL": {
        "2023-09-30": {
            "Treasury Shares Number": "0.0",
            "Ordinary Shares Number": "15550061000.0"
        },
        "2022-09-30": {
            "Treasury Shares Number": "NaN",
            "Ordinary Shares Number": "15943425000.0"
        },
        "2021-09-30": {
            "Treasury Shares Number": "NaN",
            "Ordinary Shares Number": "16426786000.0"
        },
        "2020-09-30": {
            "Treasury Shares Number": "NaN",
            "Ordinary Shares Number": "16976763000.0"
        }
    }
}

有谁知道完成此任务的明智方法？

我过去曾问过类似的问题，但我很难使该解决方案适应这个问题。

我有以下 json 数组：

$ jq <<<"$json"
[
  {
    "id": "node1"
  },
  {
    "id": "node2"
  },
  {
    "id": "node3"
  }
]

我想向每个节点添加一个键/值或修改它（如果它已经存在）。我可以这样做：

$ jq '.[] | select(.id == "node2") += {status: "fail"}' <<<"$json"
{
  "id": "node1"
}
{
  "id": "node2",
  "status": "fail"
}
{
  "id": "node3"
}

但请注意，外部数组消失了，因此当我尝试在脚本中实现此解决方案时，它失败了。

#!/usr/bin/env bash

[[ $DEBUG == true ]] && set -x

nodes=(node1 node2 node3)
json='[{"id": "node1"},{"id": "node2"},{"id": "node3"}]'

for node in "${nodes[@]}"; do
    if [[ $node == node2 ]]; then
        status=fail
    else
        status=pass
    fi
    json=$(jq --arg status "$status" --arg node "$node" '.[] | select(.id == $node) += {status: $status}' <<<"$json")
done

错误：

$ ./script.sh
jq: error (at <stdin>:4): Cannot index string with string "id"
jq: error (at <stdin>:7): Cannot index string with string "id"
jq: error (at <stdin>:10): Cannot index string with string "id"

有没有办法可以修改这些 json 对象，同时保留整体结构？

我有一个脚本，可以选择在 STDIN 上获取一些输入，然后向用户提供一些选择列表。当在 STDIN 上输入数据时，选择列表会显示但退出而不接受输入，但是当通过 stdin 未提供任何内容时它可以正常工作。

我有一个简单的例子：

#!/usr/bin/env bash

if [[ -p /dev/stdin && ${#bar[@]} -eq 0 ]]; then
    while IFS= read -r foo; do
        bar+=("$foo")
    done </dev/stdin
fi

for foo in "${bar[@]}"; do
    echo "$foo"
done

select thing in foo bar baz; do
    case $thing in
        *)  echo "You have selected $thing"; break;;
    esac
done

不使用标准输入执行：

$ ./script.sh
1) foo
2) bar
3) baz
#? 2
You have selected bar

使用标准输入执行：

$ printf '%s\n' foo bar | ./script.sh
foo
bar
1) foo
2) bar
3) baz
#?
$

有谁知道为什么会发生这种情况以及如何预防？

不知何故，花引号进入了我的代码，我得到了意想不到的行为

#!/bin/sh

if [ foo = ‘foo’ ]; then
   echo yes
else
   echo no
fi

我希望这会回应“是”，但它会回应“否”。

我正在尝试匹配sed 中的一个[或]一个字符集，但由于某种原因它不喜欢]

$ echo 'foo [bar]' | sed -E 's/[\[\]]//g'
foo [bar]

以下作品：

$ echo 'foo [bar]' | sed -E 's/\]//g'
foo [bar
$ echo 'foo [bar]' | sed -E 's/[\[]//g'
foo bar]

但是由于某种原因]，该字符集的内部会破坏它：

$ echo 'foo [bar]' | sed -E 's/[\]]//g'
foo [bar]

奇怪的是，即使这样也有效：

$ echo 'foo [bar]' | sed -E 's/[]]//g'
foo [bar
$ echo 'foo [bar]' | sed -E 's/[[]//g'
foo bar]

但不是这个：

$ echo 'foo [bar]' | sed -E 's/[[]]//g'
foo [bar]

我是否只需要某种额外的转义，或者这甚至可能吗？

我有几个相当大的 csv 文件，我需要将每列的值求和并转置列标题。

样本 csv：

col1,col2,col3
enabled,disabled,active
disabled,disabled,enabled
N/A,enabled,active
enabled,N/A,disabled

期望的输出：

col1,2 enabled,1 disabled,1 N/A
col2,1 enabled,2 disabled,1 N/A
col3,1 enabled,1 disabled,2 active

实际的 csv 具有更多的列和行，因此最好能够自动迭代文件。我可能会想出一些 awk 程序的 hack 工作来一次处理一列，但我希望能够一次处理整个文件并且不知道从哪里开始。输出不需要采用我所包含的确切格式，但至少相似。

我出于无聊创建了这个脚本，其唯一目的是使用/测试 GNU 并行，所以我知道它不是特别有用或优化，但我有一个脚本可以计算所有质数，直到 n：

#!/usr/bin/env bash

isprime () {
    local n=$1
    ((n==1)) && return 1
    for ((i=2;i<n;i++)); do
        if ((n%i==0)); then
            return 1
        fi
    done
    printf '%d\n' "$n"
}

for ((f=1;f<=$1;f++)); do
    isprime "$f"
done

使用循环运行时：

$ time ./script.sh 5000 >/dev/null

real    0m28.875s
user    0m38.818s
sys     0m29.628s

我希望用 GNU 并行替换 for 循环会使它运行得更快，但这不是我的经验。平均而言，它只快了大约 1 秒：

#!/usr/bin/env bash

isprime () {
    local n=$1
    ((n==1)) && return 1
    for ((i=2;i<n;i++)); do
        if ((n%i==0)); then
            return 1
        fi
    done
    printf '%d\n' "$n"
}

export -f isprime

seq 1 $1 | parallel -j 20 -N 1 isprime {}

并行运行：

$ time ./script.sh 5000 >/dev/null

real    0m27.655s
user    0m38.145s
sys     0m28.774s

我对优化isprime()函数并不感兴趣，我只是想知道是否可以做些什么来优化 GNU 并行？

在我的测试seq中实际上运行得比运行时更快，for ((i=1...))所以我认为这与运行时没有太大关系

有趣的是，如果我将 for 循环修改为：

for ((f=1;f<=$1;f++)); do
    isprime "$f" &
done | sort -n

它运行得更快：

$ time ./script.sh 5000 >/dev/null

real    0m5.995s
user    0m33.229s
sys     0m6.382s

这与awk print 2 line back if match有关，但由于我的命令存在我无法解决的缓冲问题，我认为更好的方法是完全忽略 stderr 并查找缺少某些行的输出。

所以我的输出将是：

Gathering drive descriptors ...
Gathering data for drive 0 ...
Drive Model: DataTraveler 2.0
Gathering data for drive 1 ...
Drive name:  id1,sd@n5000cca17096
Drive Model: HUH721010AL4204
Drive Speed: 7200 RPMs
Drive Temp:  41 C

Gathering data for drive 2 ...
Drive name:  id1,sd@n5000cca24156
Drive Model: HUH721010AL4204
Drive Speed: 7200 RPMs
Drive Temp:  41 C

Gathering data for drive 3 ...
Drive name:  id1,sd@n5000cca8749
Drive Model: HUH721010AL4204
Gathering data for drive 4 ...
Drive name:  id1,sd@n5000cca19183
Drive Model: HUH721010AL4204
Drive Speed: 7200 RPMs
Drive Temp:  41 C

Gathering data for drive 5 ...
Drive name:  id1,sd@n5000cca4607
Drive Model: HUSMH8010BSS204
Gathering data for drive 6 ...
Drive name:  id1,sd@n5000cca10152
Drive Model: HUH721010AL4204
Drive Speed: 7200 RPMs
Drive Temp:  41 C

我想Drive name为缺少Drive Speed和Drive Temp线的任何驱动器输出 。

输出应该是：

Drive name:  id1,sd@n5000cca8749
Drive name:  id1,sd@n5000cca4607

这超出了我的能力范围，但我确信awk可以做到，但我不打算使用awk，任何完成任务的东西都可以工作（没有 GNU 工具）。谢谢！

我有一些如下所示的输出：

Gathering data for drive 1 ...
Drive name:  id1,sd@n5000cca17096
Drive Model: HUH721010AL4204
Drive Speed: 7200 RPMs
Drive Temp:  41 C

Gathering data for drive 2 ...
Drive name:  id1,sd@n5000cca24156
Drive Model: HUH721010AL4204
Drive Speed: 7200 RPMs
Drive Temp:  41 C

Gathering data for drive 3 ...
Drive name:  id1,sd@n5000cca8749
Drive Model: HUH721010AL4204
failed to get drive stats

Gathering data for drive 4 ...
Drive name:  id1,sd@n5000cca19183
Drive Model: HUH721010AL4204
Drive Speed: 7200 RPMs
Drive Temp:  41 C

Gathering data for drive 5 ...
Drive name:  id1,sd@n5000cca4607
Drive Model: HUSMH8010BSS204
failed to get drive stats

Gathering data for drive 6 ...
Drive name:  id1,sd@n5000cca10152
Drive Model: HUH721010AL4204
Drive Speed: 7200 RPMs
Drive Temp:  41 C

我想为无法返回驱动器统计信息的任何驱动器打印“驱动器名称”（因此匹配 on failed to get drive stats）。

我知道如何获得上一行：

awk '$0=="failed to get drive stats" && $2>1 {print f} {f=$0}'

但这对我没有帮助。

期望的输出：

Drive name:  id1,sd@n5000cca8749
Drive name:  id1,sd@n5000cca4607

编辑：

由于某种原因，当输出被重定向时，它的显示方式与终端上的不同。如果我运行：

command >out.txt 2>&1

输出文件将如下所示：

failed to get drive stats
failed to get drive stats

Gathering data for drive 1 ...
Drive name:  id1,sd@n5000cca17096
Drive Model: HUH721010AL4204
Drive Speed: 7200 RPMs
Drive Temp:  41 C

Gathering data for drive 2 ...
Drive name:  id1,sd@n5000cca24156
Drive Model: HUH721010AL4204
Drive Speed: 7200 RPMs
Drive Temp:  41 C

....

两个 awk 答案都提供了工作，但我猜我还有其他问题

我正在尝试使用 system() 在 awk 中执行 grep，根据手册应该返回正在运行的命令的退出代码。

$ cat foo.txt
bar
$ grep -q bar foo.txt; echo $?
0
$ awk 'BEGIN{ if ( system( "grep -q bar foo.txt" ) ) { print "yes" } else { print "no" } }'
no

如果我删除了，-q我可以看到 grep 确实找到bar了，所以它应该退出 0 并因此打印是，否？

$ awk 'BEGIN{ if ( system( "grep bar foo.txt" ) ) { print "yes" } else { print "no" } }'
bar
no

完全grep从等式中删除：

$ awk 'BEGIN{ if ( system( "true" ) ) { print "yes" } else { print "no" } }'
no

我正在尝试提出一个工具，用于通过 API 将数据发送到 github gist。问题是 github api 将要点content作为一行，所有转义序列都按字面写出，如下所示：

{
  "test.txt": {
    "filename": "test.txt",
    "type": "text/plain",
    "language": "Shell",
    "raw_url": "https://gist.githubusercontent.com/jessebutryn/5c8b2a95b4b016e2fa33edee294c732b/raw/474f72ad32c843c18e9a61a228a31df6b85a8da1/test.txt",
    "size": 96,
    "truncated": false,
    "content": "#!/bin/sh\n\n# comment\nfunc () {\n\tfor ((i=1;i<10;i++)); do\n\t\t:\n\tdone\n}\n\nprintf '%s\\n' Foo bar baz\n"
  }
}

该内容显示如下：

#!/bin/sh

# comment
func () {
    for ((i=1;i<10;i++)); do
        :
    done
}

printf '%s\n' Foo bar baz

其中需要转换为：

#!/bin/sh\n\n# comment\nfunc () {\n\tfor ((i=1;i<10;i++)); do\n\t\t:\n\tdone\n}\n\nprintf '%s\\n' Foo bar baz\n

是否有任何工具可以一次性完成此操作？如果没有，是否有人知道如何使用sed或任何标准的 unix 工具来完成它？

注意：原始文本中的任何文字转义序列都需要转义以防止 github 解释它们（但是这将是次要问题，不一定需要在这个问题中解决，但会很高兴） ：

IE：

printf '%s\n' Foo bar baz

变成：

printf '%s\\n' Foo bar baz

我知道这不是一件好事和/或一个好的解决方案，但我只是在试图回答这个问题时搞砸了，我遇到了以下问题。

目标是逐字符读取输入文件，如果字符在指定范围内，则替换它。

输入：

NNNNN
NNNNN
NNNNN
NNNNN

脚本：

#!/bin/bash
#set -x

input=~/tmp/in
declare -i count=0
low=$1
high=$2
new_char=$3

while IFS=$'\n' read -r line; do
    while IFS= read -rn1 char; do
        if ((count>=low)) && ((count<=high)); then
            printf '%s' "$new_char"
        else
            printf '%s' "$char"
        fi
        ((count++))
    done <<<"$(printf '%s' "$line")"
    echo
done <"$input"

所需的输出（运行时：）./script.sh 10 13 P：

NNNNN
NNNNP
PPPNN
NNNNN

实际输出：

$ ./script.sh 10 13 P
NNNNN
NNNNPP
PPNNN
NNNNN

我不确定为什么它似乎在第 2 行凭空创造了一个新角色，而不是在第 3 行替换第 13 个角色。我尝试将((count++))语句移动到第二个 while 循环的开头，我尝试从 开始count=1，我尝试了似乎((++count))||的所有组合 count=$((count+1))|| ((count+1)). 结果各不相同，但似乎都在第二行添加了一个额外的字符。

我已经仔细检查了输入文件的任何行上都没有尾随空格。

我正在尝试编写一个函数来替换exit内置函数的功能，以防止自己退出终端。

我试图使用SHLVL环境变量，但它似乎在子shell中没有改变：

$ echo $SHLVL
1
$ ( echo $SHLVL )
1
$ bash -c 'echo $SHLVL'
2

我的功能如下：

exit () {
    if [[ $SHLVL -eq 1 ]]; then
        printf '%s\n' "Nice try!" >&2
    else
        command exit
    fi
}

这将不允许我exit在子shell中使用：

$ exit
Nice try!
$ (exit)
Nice try!

检测我是否在子shell中的好方法是什么？

当我的一台服务器中的内存模块发生故障时，事件日志通常会报告错误的 DIMM 插槽或完全不存在的 DIMM 插槽。我们想出的确定故障 DIMM 的最佳方法是检查哪个 DIMM 缺失。

我有一个产生以下输出的命令：

  Location Tag: P1-DIMMA1   Size: 34359738368 bytes
  Location Tag: P1-DIMMA2
  Location Tag: P1-DIMMB1   
  Location Tag: P1-DIMMC1
  Location Tag: P1-DIMMD1   Size: 34359738368 bytes
  Location Tag: P1-DIMMD2
  Location Tag: P1-DIMME1   Size: 34359738368 bytes
  Location Tag: P1-DIMMF1
  Location Tag: P2-DIMMA1   Size: 34359738368 bytes
  Location Tag: P2-DIMMA2
  Location Tag: P2-DIMMB1   Size: 34359738368 bytes
  Location Tag: P2-DIMMC1
  Location Tag: P2-DIMMD1   Size: 34359738368 bytes
  Location Tag: P2-DIMMD2
  Location Tag: P2-DIMME1   Size: 34359738368 bytes
  Location Tag: P2-DIMMF1

在此示例中，P1-DIMMB1 发生故障（该 DIMM 插槽安装在 P2 中，但未安装在 P1 中）

我正在寻找一种编程方法来确定一个 cpu 中哪些 DIMM 插槽是空的，而另一个 cpu 中没有。我想出了以下 bash monstrocity 来完成此任务，但我确信有一种更简单的方法可以使用awk.

cpu1_dimms=()
cpu2_dimms=()
missing=()

while read -r line; do
    dimm=$(awk '{print $3}' <<<"$line")
    cpu=${dimm:1:1}
    size=$(awk '{print $5}' <<<"$line")
    if [[ -n "$size" ]]; then
        case $cpu in
            1)  cpu1_dimms+=( "${dimm:3}" );;
            2)  cpu2_dimms+=( "${dimm:3}" );;
        esac
    fi
done < <(echo "$var")

for dimm in "${cpu1_dimms[@]}"; do
    if ! [[ "${cpu2_dimms[@]}" =~ "$dimm" ]]; then
        missing+=( "P2-$dimm" )
    fi
done
for dimm in "${cpu2_dimms[@]}"; do
    if ! [[ "${cpu1_dimms[@]}" =~ "$dimm" ]]; then
        missing+=( "P1-$dimm" )
    fi
done

这假设上述命令的输出存储在变量中var

我正在编写一个函数，它将进行 REST API 调用，可以是GET, PUT, DELETE,POST等。

我想将此方法作为参数提供给函数，并将其添加到该单个函数调用的选项数组中。这可能吗？

目前我正在通过创建一个单独的local数组来解决这个问题，但我更愿意只使用单个options数组。

#!/bin/bash

options=(
    --user me:some-token
    -H "Accept: application/json"
)

some_func () {
    local urn=$1
    shift
    local func_opts=("${options[@]}" "$@")
    printf '%s\n' "${func_opts[@]}"
}

# This should return all options including -X GET
some_func /test -X GET

# This should return only the original options
printf '%s\n' "${options[@]}"

我也可以使用一个临时数组来存储 的内容options，添加新选项，然后在函数结束之前重置它，但我认为这也不是一个特别干净的方法。

我有一个命令输出有关块中所有 DIMM 插槽的信息，如下所示：

ID    SIZE TYPE
44    105  SMB_TYPE_MEMDEVICE (type 17) (memory device)

  Manufacturer: NO DIMM
  Serial Number: NO DIMM
  Asset Tag: NO DIMM
  Location Tag: P1-DIMMD1
  Part Number: NO DIMM

  Physical Memory Array: 43
  Memory Error Data: Not Supported
  Total Width: 0 bits
  Data Width: 0 bits
  Size: Not Populated
  Form Factor: 9 (DIMM)
  Set: None
  Rank: Unknown
  Memory Type: 2 (unknown)
  Flags: 0x4
        SMB_MDF_UNKNOWN (unknown)
  Speed: Unknown
  Configured Speed: Unknown
  Device Locator: P1-DIMMD1
  Bank Locator: P0_Node1_Channel0_Dimm0
  Minimum Voltage: 1.20V
  Maximum Voltage: 1.20V
  Configured Voltage: 1.20V

这些块以ID SIZE TYPE标题开始，以配置的电压信息结束。该命令为每个 DIMM 输出这些数据块之一，每个 DIMM 由一个空行分隔。

我希望能够根据该Location Tag字段获取特定 DIMM 插槽的信息块，但我不确定如何去做。我很确定这可以完成，awk但只知道如何打印匹配awk '/P1-DIMMD1/'或匹配前的行awk '/P1-DIMMD1/ {print a}{a=$0}'

Location Tag如果匹配我的搜索（ ） ，有谁知道我如何提取整个数据块P1-DIMMD1？

看到这个问题后，我想知道为什么.选择符号来表示点命令？

我无法找到有关它的起源或创建它的人的太多信息，并且很好奇为什么选择句号来表示此命令。

我有一些数据，其中第 4 列将是frz或-。我想找到frz只有下一行的第4 列是第 4 列的所有行-，然后打印这两行。

样本输入：

2018-04-09T14:15:23.366Z  7 multi -   uuid1 uuid2 uuid3 -
2018-04-09T14:15:23.978Z  8 multi frz   uuid1 uuid3 -        -
2018-04-09T14:29:35.826Z  8 multi frz   uuid1 uuid3 uuid2 -
2018-04-09T17:19:01.901Z  8 multi frz uuid1 uuid3 uuid2 -
2018-06-03T22:12:38.688Z  8 multi -   uuid1 uuid3 uuid2 -
2018-06-28T00:35:54.338Z  9 multi -   uuid1 uuid2 -        -
2018-06-28T00:47:51.679Z  9 multi -   uuid1 uuid2 uuid3 -
2018-06-28T00:47:51.720Z 10 multi -   uuid1 uuid3 -        -
2018-06-28T00:47:58.863Z 10 multi -   uuid1 uuid3 uuid2 -
2018-06-28T16:29:01.624Z 10 multi frz uuid1 uuid3 uuid2 -
2018-06-28T17:29:01.624Z 10 multi - uuid1 uuid3 uuid2 -

预期输出：

2018-04-09T17:19:01.901Z  8 multi frz uuid1 uuid3 uuid2 -
2018-06-03T22:12:38.688Z  8 multi -   uuid1 uuid3 uuid2 -
2018-06-28T16:29:01.624Z 10 multi frz uuid1 uuid3 uuid2 -
2018-06-28T17:29:01.624Z 10 multi - uuid1 uuid3 uuid2 -

我找到了一些awk命令来在匹配后打印该行，但我不知道如何匹配两行并打印两者。

我目前拥有的：

$ awk 'f{print;f=0} $4=="frz"{f=1}' input
2018-04-09T14:29:35.826Z  8 multi frz   uuid1 uuid3 uuid2 -
2018-04-09T17:19:01.901Z  8 multi frz uuid1 uuid3 uuid2 -
2018-06-03T22:12:38.688Z  8 multi -   uuid1 uuid3 uuid2 -
2018-06-28T17:29:01.624Z 10 multi - uuid1 uuid3 uuid2 -

我有以下 bash 脚本：

#!/bin/bash

encl0=( 0,0 0,1 0,2 0,3 0,4 0,5 0,7 0,8 0,9 0,10 0,11 0,12 0,13 0,14 0,15 )
MISSING_DISKS=()
OLDIFS=$IFS
IFS=$'\n'
MISSING_DISKS+=($({ printf '0 %s\n' {0..15}; printf '0 %s\n' "${encl0[@]#0,}"; } | sort | uniq -u))
IFS=$OLDIFS
echo "$({ printf '0 %s\n' {0..15}; printf '0 %s\n' "${encl0[@]#0,}"; } | sort | uniq -u)"
echo "${MISSING_DISKS[@]}"
if ((${#MISSING_DISKS[@]}>1)); then
    echo "Greater than 1"
else
    echo "Success"
fi

当我使用 bash v4.4 运行它时，它可以按预期工作：

$ /usr/local/bin/bash test.sh
0 6
0 6
Success

但是，当我使用 bash v3.2 运行它时，它不会：

$ /bin/bash test.sh
0 6
0 0 0 0 1 2 3 4 5 7 8 9 10 11 12 13 14 15 0 1 0 10 0 11 0 12 0 13 0 14 0 15 0 2 0 3 0 4 0 5 0 6 0 7 0 8 0 9
Greater than 1

我不明白如何MISSING_DISKS设置为与设置它的命令的输出不同的东西。有谁知道是什么原因造成的？

我有一个DISK_INFO使用以下内容调用的变量：

diskid   HGST     HUSMH8010BSS204  serial             no  no  [0] Slot00
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot02
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot03
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot04
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot05
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot06
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot07
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot08
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot09
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot10
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot11
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot12
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot13
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot14
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot15
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot16
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot17
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot18
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot19
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot20
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot21
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot22
diskid   HGST     HUH728080AL4204  serial             no  no  [0] Slot23
diskid   HGST     HUH728080AL4204  serial             no  no  [1] Slot00
diskid   HGST     HUH728080AL4204  serial             no  no  [1] Slot01
diskid   HGST     HUH728080AL4204  serial             no  no  [1] Slot02
diskid   HGST     HUH728080AL4204  serial             no  no  [1] Slot03
diskid   HGST     HUH728080AL4204  serial             no  no  [1] Slot04
diskid   HGST     HUH728080AL4204  serial             no  no  [1] Slot05
diskid   HGST     HUH728080AL4204  serial             no  no  [1] Slot06
diskid   HGST     HUH728080AL4204  serial             no  no  [1] Slot07
diskid   HGST     HUH728080AL4204  serial             no  no  [1] Slot08
diskid   HGST     HUH728080AL4204  serial             no  no  [1] Slot09
diskid   HGST     HUH728080AL4204  serial             no  no  [1] Slot10
diskid   HGST     HUH728080AL4204  serial             no  no  [1] Slot11
c2t0d0                  Kingston DataTraveler 2.0 -                    -   -   -

当磁盘发生故障时，它将从此列表中删除，在此示例中，机箱 0 插槽 01 中的磁盘发生故障。

假设机柜 0 总是有 24 个磁盘 00-23，机柜 1 总是有 12 个磁盘 00-11，我怎样才能有效和准确地确定丢失的磁盘？

我目前有以下内容，但我确信这可以在单个 awk 命令中完成：

enclosure0=($(awk '$7 ~ "[0]"{print $8}' <<<"$DISK_INFO" | sort -n))
enclosure1=($(awk '$7 ~ "[1]"{print $8}' <<<"$DISK_INFO" | sort -n))
for n in {00..23}; do
  grep -q "$n" <<<"${enclosure0[@]}" || missing+=("Enclosure 0 - Slot$n")
done
for n in {00..11}; do
  grep -q "$n" <<< "${enclosure1[@]}" || missing+=("Enclosure 1 - Slot$n")
done