Base64 decoder - Bash Advent Calendar - Day 9

むか～し、このネタをどこかに書いた気がするので、既に見たことがあったらゴメンナサイ。何度も書くけどネタがないんです。ネタください。

Base64の仕様

RFC3548読んでください。以上。だって、ここ読むような人は大体知ってるか、知らなくてもこの後読めば分かるでしょ。

では何なので、エンコーダーの場合

1. 3 octet (24 bit, ASCII char 3 文字分) を 6bit のかたまり x 4 に展開
2. 各 6 bit を以下の文字に変換
• 0 〜 25: "A" 〜 "Z"
• 26 〜 51: "a" 〜 "z"
• 52 〜 61: "0" 〜 "9"
• 62: "+", 63: "/" 
• 処理の最後、入力が 1 octet もしくは 2octet しかない場合には "=" で padding

という感じで変換します。これでも意味不明なら、Wikipedia でもなんでも、適当に検索して自分で調べてね。

Bashの64進数

前回、基数が37以上の場合を説明しませんでしたが、下記64進数のマッピングから類推してください。で、64進数のマッピングは

• 0 〜 9: "0" 〜 "9"
• 10 〜 35: "a" 〜 "z"
• 36 〜 61: "A" 〜 "Z"
• 62: "@", 63: "_" 

となっております。そんなわけで、上のマッピングのの違いを吸収してあげるだけで、Base64デコーダーが算術式評価で簡単に作れる、はず。paddingとか面倒だけど。

検証用入力値

"Bash" AND "base64" で検索すると出てくる数々の、「コマンドライン上でBase64」を処理する方法。全然、Bash スクリプトじゃないじゃないか。そこですぐスクリプトが検索結果に出てきたらネタにならないんですけどね。

とにかく、検索したところ base64 コマンドを使えと。まんまですね。というわけで

$ echo "Hello World!!" | base64
SGVsbG8gV29ybGQhIQo=

全然関係ないですけど、おせっかいにもヒストリー展開が有効になってると !! がヒストリー展開されていやーんなことになるかもしれませんが、ここは適宜自分の好きな文字に置き換えるなり、ヒストリー展開を未来永劫禁止したり、好きなようにしてください。

スクリプト

とりあえずネタなので、不正な入力のハンドリングはなしということで。誰も実際にこんなん使わないでしょ。

四文字受け取って三オクテット返す関数

これがメインですが

four_char_to_three_octet() {
    local input="$1"
    local bash_64=$(LC_ALL=C tr "A-Za-z0-9+/=" "0-9a-zA-Z@_0" <<< "${input}")
    local -i base_64_num="64#${bash_64}"
    printf '\\x%02x\\x%02x\\x%02x\n' \
      $(( (base_64_num & 0xff0000) >> 16)) \
      $(( (base_64_num & 0x00ff00) >>  8)) \
      $(( base_64_num & 0x0000ff ))
}

tr を Bash ビルトインだけで書くこともできるのですが、全然関係ないところでスクリプトの量が10倍ぐらいになるので今日のところは tr で勘弁してください。tr の同等の処理じゃなく、単純に仕様に従って数値に変換してもいいんですが、そうすると「Bashの64進数表記」というネタの根本がどっかにいってしまうし、面白くもなんともありません。

色々実装の仕方はあると思うのですが、とりあえずここでは padding は無視して "=" も 0 に変換してます。それと printf の出力に余計な \ がついてるのは後で出てきます。とりあえず、実行結果は

$ four_char_to_three_octet "SGVs"
\x48\x65\x6c

となりますが、これは "Hello world!!" の最初の３文字 Hel に一致するはず

$ echo -n Hel | od -An -t x1
 48 65 6c

１行分の文字列を４文字ずつに区切る

仕様上、パディングを含めれば必ず１行は４の倍数文字なので

split_line() {
  local line="$1"
  local result=()
  local -i i
  for ((i = 0; i < ${#line}; i += 4)); do
    result+=(${line:i:4})
  done
  echo "${result[@]}"
}

と何も考えずに４文字ずつ区切るだけ。

$ split_line "SGVsbG8gV29ybGQhIQo="
SGVs bG8g V29y bGQh IQo=

パディング処理

詳細は自分で計算するなり、仕様をチェックしてくれればいいのですが、パディングはなし、1文字、２文字の３通りで、パディングの文字数分のオクテットだけ出力を削ればOKです。four_char_to_three_octet は１オクテットにつき \xXX で４文字出力するので、パディングの長さ×４文字削除しています。

strip_padded_part() {
  local src="$1"    # XXXX, XXX= or XX==
  local output="$2" # \xXX\xXX\xXX
  local src_except_padding="${src%%=*}"
  local -i padding_length="4 - ${#src_except_padding}"
  echo "${output:0:12-(padding_length * 4)}"
}

12は "\xXX\xXX\xXX" の文字数です。なんかもっとスマートな方法がある気がする、というか３オクテットを一つの文字列で返したのが敗因ですね。思いつきでこの記事を書きながらスクリプトを書いてるのでこんなハメに。最初にスクリプトを全部書き終えてから記事にすればよかった。

閑話休題、これで

$ four_char_to_three_octet "IQo="
\x21\x0a\x00
$ strip_padded_part "IQo=" '\x21\x0a\x00'
\x21\x0a

ちゃんと不要な \x00 が削除されてるのが分かります。

バイナリ出力

あとは今までのをまとめて、バイナリ出力するだけです。

base64_decode() {
  local line
  local four_char
  local three_octet
  while read line; do
    for four_char in $(split_line "${line}"); do
      three_octet=$(four_char_to_three_octet "${four_char}")
      if [[ "${four_char}" == *= ]]; then
        three_octet=$(strip_padded_part "${four_char}" "${three_octet}")
      fi
      printf "${three_octet}"
    done
  done
}

printf に引数一つだけというのは、Cならかなりダメコードのサインなのですが、printf "\xXX" (または "\0XXX")、もしくは echo -e だけがバイナリーを出力する手段 (printf "%c" は違うのが残念）なので、このようになっております。今回は printf の直後に - が来ないのが分かってますが、そうじゃない場合に気持ち悪いので echo -n -e "..." よりは printf -- "..." の方が好みです。って、"--" をここでは指定してないので一緒ですけどね。

とにかく

$ base64_decode <<< "SGVsbG8gV29ybGQhIQo="
Hello World!!
$

と、まさしくデコードできました。めでたしめでたし。ちなみに途中経過で \0x0a が出てくる通り、エンコードされた文字列に改行文字が入ってるので、出力にも改行が入ってますが、末尾に改行なんてないバイナリーデータでも正しく処理できるはずです。

今日の結論。スクリプトを書き終わって、ちゃんと恥ずかしくないようなものになってから記事を書きましょう。

Misc - Bash Advent Calendar - Day 8

今までちょっと説明が足りなかったところのランダムな補足。正直、既に息切れなので小休止。

配列変数の展開

特定の要素に対する文字列展開は、普通の変数の文字列展開と一緒なので省略。

${var[@]:-str}
var が存在し１個以上あれば ${var[@]} に同じ、そうでなければ str になる。var の中身を見て、それが空白文字だったら str に置きかわる、という動作をするわけではない。

${var[@]-str}
var が存在し１個以上あれば ${var[@]} に同じ、そうでなければ str になる。中身がない空の配列でも str に置き代わってしまうという残念な動作。仕様としては未定義っぽいけど。

${var[@]:?str}, ${var[@]:+word}
上と同様。

${var[@]:=str}
エラーになる。正直、エラーにならない場合、どんな動作をすべきか思いつかないので、妥当な仕様だと思う。

${var[@]:offset}, ${var[@]:offset:length}
offset 番目から length 個の要素を取り出す。実は同様に ${@:offset} とか ${@:offset:length} で、位置パラメータを部分的に取得できるんだけど、普通は shift 使えということで目にすることはまずないでしょう。残念ながら、各要素の部分文字列展開をしたい場合には、for ループで回すしかない。

${#var[@]}
配列の要素数になる。「各要素の文字列の長さ」が返ってくるわけではない。残念だけど、じゃぁ、配列の要素数を返すのに他に適当な記法があるかといえば、たしかにこれがベストと言わざるを得ないでしょう。

${var[@]#str}, ${var[@]##str}, ${var[@]%str}, ${var[@]%%str}
それぞれの要素に対して、先頭または末尾にマッチする文字列が削除、その結果を返します。

${var[@]/pattern/str}, ${var[@]//pattern/str}
それぞれの要素に対して、パターンにマッチした文字列を置換して、その結果を返します。

${var[@]^pattern}, ${var[@]^^pattern}, ${var[@],pattern}, ${var[@],,pattern}
それぞれの要素に対して、大文字、小文字変換変換した結果を返します。

というわけで、

• 「変数が存在するかどうか、または空文字列か」をチェックする系のは動作はするけど : の有無が影響しないのでつまらない。
• 数値を返す、または数値を引数に取る系のは、各要素に対して何か操作をするのではなく、配列全体に対する動作になる
• 文字列置換系は各要素に対しての操作になる

とまとめられるかと思います。

[[ X -gt Y ]] と [ X -gt Y ] の互換性

正直、undocumented なので言及するだけ時間の無駄な気がしますが、現状、[[ ]] の場合は X Y ともに算術式評価がされるようです。なので

$ X=2
$ Y=1
$ [[ X -gt Y ]]; echo $?
0
$ [ X -gt Y ]; echo $?
bash: [: X: 整数の式が予期されます
2

と非互換の動作をします。算術式評価であれば、ちゃんと

(( X > Y ))

と書く方法があるので、"-gt" と test と同じ名前を使うのであれば、やっぱり test と同じような動作をすべきなんじゃないかと思うわけです。

declare コマンドと変数宣言

さてここまでずっと変数の宣言として declare コマンドを使ってきましたが、何回か書いてあるとおり、これらは内部「コマンド」であって bash の文法の一部ではありません。キバヤシなら「な、何だってー−！」と驚くところです。

で、何がポイントかというと、あるコマンドの実行結果を変数に代入する場合に問題になります。

• $?は最後のコマンドの実行結果を返す
• declareコマンドが実行される前に $() のコマンド展開が行われる

ということで

$ declare shadow=$(cat /etc/shadow 2>/dev/null)
$ echo $?
0
$ unset; declare shadow
$ shadow=$(cat /etc/shadow 2>/dev/null)
$ echo $?
1

実際のところ、declare コマンドでこれが問題になるケースは稀だと思いますが、その兄弟的な local コマンドでありがちなミスとして

function foo(){
  local tmp=$(mktemp foo.XXXXXX)
  if [[ $? -ne 0 ]]; then
    ...
}

みたいなのがあると思います。mktemp コマンドが失敗しても local コマンドは成功してしまうので、この if 文の評価は常に偽になります。

というわけで

local var=value

と書くと短く書けるのはいいのですが、右辺にコマンド展開がある場合は

local var
value=$(...)

と書く癖を付けておきましょう。

あと、これを書く動機として

• declare -i -A または declare -i -a で右辺が算術評価されない

というバグがあります。これは

declare -i -a foo
foo=("1 + 2")

のように宣言と代入を分けることで回避できます。これ自体で困ることはそうそうないとは思いますが、こういうバグを見ると「どうやったらこんなバグ生じさせられるんだよ」とか「こんなところでバグるソフトとか信頼性どうなのよ」とか、でもきっと中の人は大変なんだろうなとか、いろいろと空想できて楽しいと思います。

というわけで今日の結論。やっぱり配列とか連想配列とか使うんだったら他のLL使いましょうw

算術式（その２） - Bash Advent Calendar - Day 7

昨日の続き、算術式内の変数について。

数値インデックスの配列変数（連想配列じゃない方の配列）にも対応しています。なので

$ declare foo=(1 2 3)
$ declare -i bar="foo[0] + foo[1] + foo[2]"
$ declare -p bar
declare -i bar="6"

これまでと同様、再帰的に算術式として評価されるので

$ declare foo=(0 1)
$ declare bar="foo[0] + foo[1]"
$ declare -i buzz
$ buzz="bar[0] + bar[1]"
$ declare -p buzz
declare -i buzz="3"

これで何が嬉しいのか書いてる本人もよく分かりませんが、とりあえずこんなこともできますよと。

基数#文字列

これで昨日のリストの１〜４を説明しました。６は単純な数値なので、これで最後、今日のメインディッシュ "基数#文字列" です。

これまでに説明した８進数、１６進数、そして普段使いの１０進数以外に使いそうなのは２進数ぐらいですかね。

$ declare -i foo
$ foo="2#10100101"  # 0xA5
$ declare -p foo
declare -i foo="165"

これまで同様、何が嬉しいのかよくわからないですね。

１１進数から３６進数までは数字とアルファベット（大文字、小文字の区別なし）で数値を表現します。すなわち

$ declare -i foo
$ foo="36#sekine"
$ declare -p foo
declare -i foo="1717524842"

３６進数とか言われても、これで正しいかどうなのかよく分からんですね。せっかくなのでこれまでの算術式やら、配列など色々駆使して、この値を検証してみましょう。

$ char_code_hex=($(echo -n 'asekine' | od -A n -t x1))
$ declare -i -a char_code_hex_num
$ char_code_hex_num=("${char_code_hex[@]/#/0x}")
$ declare -p char_code_num
declare -ai char_code_num='([0]="97" [1]="115" [2]="101" [3]="107" [4]="105" [5]="110" [6]="101")'

とまず、"sekine" と、ついでに "a" の文字コードを取得します。補足として

• 本当は od で直接 10 進数でダンプできますが、そんなオプション普段使わないよね
• ${var/pattern/str} で pattern を str に変換しますが、pattern は正規表現ではなく、いわゆる glob パターンで、さらにその拡張版で # は文字列の先頭にマッチします

さて、仕上げで

$ a="char_code_num[0]"
$ c_to_base36="c - a + 10"
$ declare -i sum=0
$ for ((i=1; i < ${#char_code_num[@]}; i++)); do
>   c="char_code_num[i]"
>   let "sum*=36, sum+=c_to_base36"
> done
$ echo $sum
1717524842

ちゃんと一致しましたね。上から順番に説明しておくと

• 変数 a に "a" の文字コードを（あえて変数展開せずに、いわばその値の入った配列ををさすポインタとして）代入。
• c_to_base36 は、変数というよりは無名関数の定義、
• Pythonで言えば lambda : c - a + 10 みたいなもの
• Scheme なら (lambda () (+ c (- a 10))) みたいな
• 以下、char_code_numの各要素に対してsum = sum * 36 + c_to_base36() を計算。

a="${char_code_num[0]}" でいいんじゃないかとか、この lambda もどきはなんなんだ、普通に関数定義しろとか色々あるとは思うのですが、全体がネタなので細かいことは気にしないでいきましょう。

ちなみに前日ちゃんと説明しませんでしたが ${#var[@]} で配列変数の要素数を取得できます。残念ながら、配列の各要素の文字数を一気に返してくれたりはしません。

base という単語と数字と言えば、そうみんな大好き Base64 というわけで、明日は簡易 Base 64 デコーダーに挑戦しようかと思います。

算術式 - Bash Advent Calendar - Day 6

Array, Associative Array と予定どおり A から順にネタを消化中で、今日は Arithmetic Expression。辞書順的に後戻りですが、細かいことは気にしないでいきましょう。

扱える範囲

とりあえず小数は扱えません。小数を使うような計算が必要なときは素直に他のLLを使いましょう。

扱える整数の範囲は実装依存で、いわゆる long の範囲です。最近の 64bit 環境であれば -2^63 〜 2^63 - 1 なので、十分実用に堪えると思います。

算術式が使われる場所

ちゃんとチェックしてないので抜けがあるかもしれませんが

1. 数値変数への代入 (local, readonly, declare, typeset コマンドを含む)
2. let "算術式"
3. ((算術式))
4. for ((算術式; 算術式; 算術式)) do ... done
5. $((算術式))  ($[算術式] もいまだに使えると思いますが、そのうち使えなくなるはず)
6. 配列変数[算術式] や ${配列変数[算術式]} などの配列変数のインデックス。
7. 部分文字列展開: ${変数:算術式} および ${変数:算術式:算術式}
8. 数値比較 [[ 算術式 OP 算術式 ]]　(OP は -gt, -ge, -lt, -le のいずれか)

ぐらいですかね。最後のは undocumented なので、期待したとおりに動かなくても当方は関知いたしません。

数値変数

説明の都合上数値変数の定義だけ。

declare -i で変数を数値変数として定義できます。

$ declare -i foo=1
$ declare -p foo
declare -i foo="1"

declare -p の結果の右辺が "1" とクォートされているので文字列っぽく見えますが、ここはそういうものだと（今日のところは）思っててください。declare の後にちゃんと -i と付いているので、これは確かに数値変数です。

ちなみに、配列 / 連想配列とは直行する概念なので

$ declare -ia foo
$ declare -iA bar
$ declare -p foo bar
declare -ai foo='()'
declare -Ai bar='()'

といった感じで数値配列、数値連想配列なんてのも作成できます。

さて、逆説的ですが、数値変数と普通の変数との違いは「右辺が算術式として評価される」だけです。では先に進みましょう。

算術式評価

だいたい、普通にありそうな演算子がそのまま使えます。以下 id は変数を指します。

• 単項演算子
• +, -
• ++id, id++, --id, id--
• ! 式 (論理否定: 0→1, 0 以外→0)
• 二項演算子
• 四則演算 +, -, *, /
• 剰余 %
• べき乗 **
• 比較 >, <, >=, <=, ==, !=
• 論理演算 ||, &smp;&smp;
• 三項演算子
• 式 ? 式 : 式
• ビット演算（単項演算子、二項演算子両方）
• ~式 (ビット反転, e.g. 0→-1, 1→-2, ...)
• &, |, ^ (XOR)
• ビットシフト <<, >>

その他の文法として

• 複文
• 式, 式
• 代入
• id=式, id*=式, id/=式, id+=式, id-=式, id%=式
• id>>=式, id<<=式, id|=式, id&=式, id^=式
• 結合
• (式)

と、まぁ C 系のプログラマにとっては妥当なものかと思います。結合の優先順位がどうなってるかは man ページにないのでよくわかりませんが、多分、常識的なものだと思います。 が、とにかくあやしい場合には、() を使いましょう。

さて、昨日も少しだけ触れましたが、式内の上記以外の文字列は

1. 空文字列は 0
2. "0x" または "0X" で始まる文字列は 16 進数の数値
3. "0" (ゼロ) で始まる文字列は 8 進数の数値
4. アルファベットまたは "_" で始まる文字列(二文字目以降は数字も可)は変数名。変数の中身は算術式として評価されます。
5. "基数#文字列" は "基数"進数の数値（後述）
6. それ以外の数字列は 10 進数の数値

と評価されます。

具体例

では、上から順に具体例をば。まずは空文字列

$ declare -i foo=""
$ declare -p foo
declare -i foo="0"

次に 16 進数。

$ declare -i foo=0xabc
$ declare -p foo
declare -i foo="2748"
$ printf '%x\n' "${foo}"
abc

printfについては説明略ということで。まーとにかく普通。お次は 8 進数。

$ declare -i foo="0123"
$ declare -p foo
declare -i foo="83"
$ printf '%o\n' "${foo}"
123

こんな単純じゃつまらないので、ここで早くもこれは使いづらいという例を。前提として GNU date

$ date
Fri Dec  6 22:12:30 PST 2013
$ date --date "next Monday"
Mon Dec  9 00:00:00 PST 2013

を使います。

$ declare -i today monday
$ today=$(date +%d)
$ declare -p today
declare -i today="6"
$ monday=$(date +%d --date "next Monday")
bash: 09: 基底の値が大きすぎます (エラーのあるトークンは "09")

エラーメッセージで分かっちゃうと思いますが、

$ date +%d --date "next Monday"
09

と、date コマンドのこの結果は、先頭に 0 が付きます。それでもって、上で説明した通り 0 から始まる文字列は 8 進数とみなされるので、8 進数では使えない "9" が出てきてエラーになると。

では続きを。次は変数。

$ declare foo="1"
$ declare -i bar
$ bar="foo"
$ declare -p bar
declare -i bar="1"

上で説明したように、変数の中身が算術式評価されるので、bar が文字列変数でも問題ありません。それどころか

$ declare foo="1"
$ declare bar="foo"
$ declare -i buzz
$ buzz="bar"
$ declare -p buzz
declare -i buzz="1"

となります。何が起こってるかというと

1. buzz="bar" の右辺は変数名なので、変数の中身 "foo" を算術式評価
1. "foo" は変数名なので変数の中身 "1" を算術式評価
1. 文字列 "1" は 1
2. よって "foo" → 1
2. よって "bar" → 1

となります。楽しくなって来ましたね。変数の中身もまた算術式評価されるということは

$ declare foo=1
$ declare bar="foo+2"
$ declare -i buzz="bar+3"
$ declare -p buzz
declare -i buzz="6"
$ declare -p bar
declare -- bar="foo+2"

と、"-i" を一箇所に付けるだけで普通のシェルスクリプトはひと味も二味も違うことができます。

大分長くなってきたので、かなり中途半端ですが続きは明日。とりあえず中途半端ですが、今日の結論は「やっぱり数値計算するならちゃんとしたLLを使おう」です。bash で数値計算しようとする考えが根本的に間違ってると思います。

連想配列 - Bash Advent Calendar - Day 5

今日は連想配列についてです。なんか予想以上に読者が少なくてモチベーションが上がりません。

初期化

基本的な書式は数値インデックスの配列（以下「普通の配列」）と変わりません。declare で指定する引数が大文字の A になるぐらい。

$ declare -A foo
$ declare -A foo=()

ただし、普通の配列の場合にはインデックスを指定しない場合には 0 から順に勝手にインデックス値を決めてくれましたが、（ある意味当然ですが）連想配列の場合は必ずインデックス文字列が必要です。

$ declare -A foo=("bar" "baz")
bash: foo: bar: 連想配列を設定するときには添字をつけなければいけません
bash: foo: baz: 連想配列を設定するときには添字をつけなければいけません

というわけで、

$ declare -A foo=(["bar"]="BAR" ["baz"]="BAZ")
$ declare -p foo
declare -A foo='([bar]="BAR" [baz]="BAZ" )'

でメデタシメデタシとなります。

一つ普通の配列と違うことは、declare 文（または typeset）が省略できないことです。

$ unset foo bar baz
$ foo=(["bar"]="BAR" ["baz"]="BAZ")
$ declare -p foo
declare -a foo='([0]="BAZ")'

一見すると意味不明かもしれませんが、これについては後述します。Bash の仕様としては、宣言されてない変数に対して配列を代入しようとした場合、それは常に普通の配列として初期化されるということになります。

値の代入、追加

細かいところはDay 1での説明を参照してください。常にインデックスが必要な以外は普通の配列と一緒です。+= の糞仕様も健在です。

$ declare -A foo=(["bar"]="BAR" ["baz"]="BAZ")
$ foo+=(["qux"]="QUX" ["bar"]="I'd like to overwrite this value.")
$ declare -p foo
declare -A foo='([bar]="BARI'\''d like to overwrite this value." [qux]="QUX" [baz]="BAZ" )'

というわけで、[bar]="I'd like to overwrite this value."ではなく、その前に BAR が残ったままです。

インデックスが存在するかのチェック

そういえば普通の配列のときにインデックスのチェック方法を説明してませんでしたね。今までに普通の配列でインデックスのチェックが必要になったことが一度もないので、完全に失念していました。

Bash では特別なインデックスチェックの文法はありません。ただ、変数展開では変数の存在チェックができるので、

$  declare -A foo=(["bar"]="BAR" ["baz"]="BAZ" ["qux"]="")
$  [[ "${foo[bar]+_}" == "_" ]]; echo $?
0
$  [[ "${foo[baz]+_}" == "_" ]]; echo $?
0
$  [[ "${foo[qux]+_}" == "_" ]]; echo $?
0
$  [[ "${foo[_]+_}" == "_" ]]; echo $?
1

といった感じで「変数が存在したら文字を置き換える」（${var[index]:+}ではなくコロンなしの${var[index]+}を使う）という変数展開を活用することでインデックスの存在チェックが可能です。

普通の配列との違い

今までちゃんと説明してませんでしたが、普通の配列と連想配列との大きな違いは、そのインデックスの型にあります。普通の配列のインデックスは数値型なので、Bash に算術評価式が使えます、もとい勝手に使われます。一方の連想配列では、インデックスは常に文字列です。

算術式評価だけで２・３日分はブログが書けるので細かいことはあえて説明しませんが、算術式評価では

• 数値や演算子以外の文字列（で変数名として有効なもの）は変数名とみなされる
• 未定義の変数の参照結果は 0

ということになります。なので

$ unset foo bar baz
$ foo=(["bar"]="BAR" ["baz"]="BAZ")

は、

1. 初期化の項で述べた仕様により、右辺は普通の配列とみなす
2. 普通の配列のインデックスは算術式評価の対象
3. "bar" の算術式評価の結果は、bar という変数が存在しないので 0
4. "baz" の算術式評価の結果は、bar という変数が存在しないので 0

となり、結果的に

$ unset foo bar baz
$ declare -a foo=([0]="BAR" [0]="BAZ")

と等価、インデックスの 0 が重複してるので最終的に

$ declare -p foo
declare -a foo='([0]="BAZ")'

という結果が得られるわけです。そんなこんなで、連想配列を使うときに declare -A を忘れたり、間違って declare -a とかすると、Bash はエラーを吐かない代わりに予測不能な挙動を示します。

では今日の結論。Bash スクリプトで連想配列がないと出来ないような処理をする必要があるのなら、他の LL を検討すべきですw Bash 遅いしね。

配列操作の性能 - Bash Advent Calendar - Day 4

昨日まで配列について説明してきましたが、残念なお知らせです。

遅い、とにかく遅い。私が初めてこの機能を知った時、これで多くの場面で sed, awk が要らなくなり、fork() しなくてすむことによりスクリプトが高速になるのではないかと思いました。で、試しにとあるスクリプトを書き換えてみたのですが、むしろかなり遅くなってしまいました。

bash, ksh, zsh の速度比較 - 拡張 POSIX シェルスクリプト Advent Calendar 2013でも述べられている通り、bash さん遅いんです（配列操作に限りません）。ここで bash と他のシェルを比べた時に、他のシェルに負けると悔しいので、AWK と対決。

#!/bin/bash
DICT=/usr/share/dict/american-english
declare -a english_words
declare dict_content
function load_dict() {
  local IFS=$'\n'
  dict_content="$(< ${DICT})"
  english_words=(${dict_content})
  readonly dict_content english_words
}
function replace_st_to_ts() {
  local unused=("${english_words[@]//st/ts}")
}
function now() {
  date +%s.%N
}
load_dict
start=$(now)
for ((i=0;i<10;i++)); do
  replace_st_to_ts
done
end=$(now)
echo -n "Bash: "
bc -l <<< "${end} - ${start}"
start=$(now)
for ((i=0;i<10;i++)); do
  awk '{gsub(/st/, "ts"); print}' <<< "${dict_content}" > /dev/null
done
end=$(now)
echo -n "Awk: "
bc -l <<< "${end} - ${start}"

というスクリプトを実行してみたところ

Bash: 4.278741750
Awk: 1.491188335

と Bash の方が約３倍時間がかかってしまいました。さすがに桁までは違わないですが遅いですね。

というわけで昨日まで色々説明してきましたが、今日の結論は「awk って便利だね」ということで、要は「適材適所が大事」でしめさせていただきます。

配列（その３） - Bash Advent Calendar - Day 3

すでに３日めにして当初の勢いは全くなし。このままずっと続く気がしません。

閑話休題、変数展開との組み合わせで面白いことできるんじゃないの的なお話。

変数展開

普通の変数展開については既に知ってる前提で。で、配列変数においても変数展開が可能です。

まずは特定要素の変数展開をば。

$ foo=("bar" "baz")
$ echo "${foo[0]:-qux}"
bar
$ echo "${foo[2]:-qux}"
qux

と期待通りの動作をしてくれます。デフォルト値の設定も同様に

$ foo=("bar" "baz")
$ : "${foo[2]:=qux}"
$ declaare -p foo
declare -a foo='([0]="bar" [1]="baz" [2]="qux")'
$ : "${foo[1]:=quux}"
$ declaare -p foo
declare -a foo='([0]="bar" [1]="baz" [2]="qux")'

と期待通りの動作ですね。

その他にも ${var:?word} ${var:+word} も同様に想像通りの動作をしてくれます。

応用編

特定要素ではなくインデックスに @ を指定して変数展開をすると、文字列処理が一気に出来ます。Python ユーザーあたりにはウケがよさそうな

$ foo=("bar" "baz")
$ qux=("${foo[@]//a/A}")
$ declare -p qux
declare -a qux='([0]="bAr" [1]="bAz")'

みたいなことができてしまいます。これは配列の各々の要素において "a" を "A" に置換しています。このように for ループ無しで一気に文字列を処理できます。

これって Python での

>>> foo = ['bar', 'baz']
>>> qux = [s.replace('a', 'A') for s in foo]
>>> qux
['bAr', 'bAz']

にちょっと似てると思いません？でもってかなり短く書けます。

当然、変数展開の範囲内でしかできませんが、もうちょっとスクリプトっぽくすると

$ backups=(*~)
$ original_files=("${backups[@]:0:-1}")
$ for f in "${original_files}"; do
>   if [[ -f "${f}" ]]; then
>     rm "${f}"~
>   fi
> done

みたいな、Pythonでいえば

>>> backups = glob.glob('*~')
>>> original_files = [f[0:-1] for f in backups]
>>> for f in original_files:
...   if os.path.exists(f):
...     os.unlink(f + '~')
...

感じのことができます（ただし Bash スクリプトの例では、ファイル名に空白が含まれていると期待した動作をしません）。ちゃんと説明すると、

1. *~ でファイル名が ~ で終わるファイルのリストを取得
2. それらのファイル名から末尾の ~ を削除
3. ~ 無しのファイルが存在する場合は
1. ~ 付きのファイルを削除

という処理をしています。

他の ${var##word}, ${var%%word} といった文字列展開と組み合わせると、さらにいろんな事ができるのですが、もう眠いので今日はこのへんで。