シェルスクリプトのクォート — 空白入りのファイル名でforが割れる

シェルスクリプトのクォート。引用符で囲まれたファイルのカードと端末画面、確認用の虫眼鏡。

本線の回で、サーバーの状態を見るスクリプトを書きました。動きました。 それで満足していました。

前回: ss・tcpdump・ufwでパケットを追う — 開けたのに繋がらない これは深掘りです。本線の順路ではありません。 シェルスクリプトの書き方|変数・引数・実行権限の基本 の続きとして、そこで「そう書くもの」として通り過ぎた変数・クォート・if・set -e を正面から扱います。飛ばしても本線は進めます。

この記事のコマンドは、すべて Ubuntu の中で打ちます。 Windows の PowerShell ではありません。

でも、しばらくして気づきました。動いた理由が説明できない。

  • なぜ "$SERVICE" は " で囲むのか。囲まないと具体的に何が起きるのか
  • なぜ if [ -z "$SERVICE" ] の [ の後ろに空白が要るのか。詰めると何が起きるのか
  • set -e を書いたのに止まらないことがあるのは、書き方が悪いのか、set -e が悪いのか

「たぶんこう」で書いたコードは、たぶんで壊れます。 そして厄介なことに、シェルスクリプトは壊れても止まりません。 変な値のまま最後まで走り切って、rm まで到達します。

ただ、救いがあります。

シェルスクリプトの壊れ方は、ほとんど決まっている。 大半が「クォートを付けなかった」の一系統に収まる。

この記事では、その決まった壊れ方を全部その場で再現します。読むだけでなく、実際に壊してから直します。 最後に shellcheck という検査ツールに自分のスクリプトを見せて、指摘を1つずつ直すところまでやります。

対象レベル: 中級〜上級 / 区分: 発展

目次

この記事でわかること

  • " で囲まない変数は、値の中の空白でバラバラに割れること。事故のほとんどがこれ
  • [ はコマンドであること。だから前後に空白が要るし、変数が空だと構文エラーになる
  • $@ と $*、[ ] と [[ ]] は別物であること。見た目が似ているだけ
  • set -e が効かない場所があること。if の条件、&& の左、そこで呼ばれた関数の中
  • 関数の戻り値は終了コードで、値は標準出力で返すこと。return 文字列 は書けない

この記事でやること

  1. 空白入りのファイル名を作って、for が割れるところを実際に見る
  2. ${var:-} ${var#} ${var%} ${var/} ${#var} を1つずつ打って出力を確かめる
  3. [ ] と [[ ]]、for i in $(cat f) と while IFS= read -r を両方書いて差を見る
  4. set -euo pipefail を書いたスクリプトを、わざと素通りさせる
  5. shellcheck を入れて、自分の書いたスクリプトの指摘を1つずつ直す

先に知る言葉

この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。

言葉意味
単語分割(word splitting)シェルが値を空白で区切って複数の単語として扱う動き。クォートを付けないと起きる
展開(expansion)$NAME や * を、シェルが実際の値やファイル名に置き換えること。コマンドが動く前に終わっている
グロブ(glob)* ? [abc] のような、ファイル名を並べるための記号。正規表現とは別物
IFS単語分割に使う区切り文字が入っている変数。既定は空白・タブ・改行
終了コードコマンドが終わるときに返す数字。0が成功、それ以外が失敗。$? で読める
サブシェル一時的に作られる子のシェル。中で変数を書き換えても、親には戻らない
shellcheckシェルスクリプトの間違いを指摘してくれる検査ツール。この記事の最後で入れます

準備 — 実験用のフォルダを作る

壊す実験をするので、専用のフォルダを作ります。 自分のホームの下だけで完結させます。

bash
$ mkdir -p ~/sh-lab
$ cd ~/sh-lab
$ pwd
/home/ユーザー名/sh-lab

この記事のコマンドは、断りがない限りすべてこのフォルダの中で打ちます。 最後にフォルダごと消します。

クォートを付けないと壊れる

ここが今日の一番大事なところです。 先に結論を書きます。

シェルは、変数を「値」ではなく「文字列を書いた場所」として扱う。 $NAME はまず文字に置き換えられ、そのあとで空白で区切り直される。

この2段階が全部の原因です。 順に壊していきます。

空白入りのファイル名を作る

bash
$ cd ~/sh-lab
$ touch "my report.txt" "notes.txt" "a b c.log"
$ ls
a b c.log  my report.txt  notes.txt

3つのファイルができました。 そのうち2つの名前に空白が入っています。Windows から来ると珍しくない名前です。

for f in $(ls) は割れる

「ファイルを1つずつ処理する」でよく書かれてしまう形です。 打ってみます。

bash
$ for f in $(ls); do echo "[$f]"; done
[a]
[b]
[c.log]
[my]
[report.txt]
[notes.txt]

3個のはずが、6個になりました。

ls の結果は a b c.log my report.txt notes.txt という3行ですが、$(ls) を書いた場所にその文字列がそのまま貼られ、そのあとシェルが空白で切り直しています。 シェルから見れば、改行も空白も同じ「区切り」です。

これが単語分割です。 for が壊れているのではなく、for に渡る前に、もう6個になっています。

もしこの中身が echo ではなく rm $f だったら。 a b c.log という存在しないファイルを消そうとして失敗し、残りも意図と違うものを消します。「動いているように見えて、違うものを触る」のが、この事故の一番怖いところです。

[スクリーンショット: 01_for_split.png] ls の結果が3行なのに、for f in $(ls) の出力が6行になっている画面を撮ってください。この対比が今回の要点です。

正しくは for f in *

そもそも ls を挟む必要がありません。

bash
$ for f in *; do echo "[$f]"; done
[a b c.log]
[my report.txt]
[notes.txt]

3個のままです。

*(グロブ)はシェル自身がファイル名の一覧に展開します。 このとき、1ファイル = 1単語として扱われることが保証されます。 文字列を作ってから切り直す $(ls) とは、そこが決定的に違います。

書き方何が起きるか
for f in $(ls)ls の出力の文字列を、あとから空白で切る。名前の空白で割れる
for f in *シェルがファイル名として展開する。割れない

中で変数を使うときは、そこでも囲みます。

bash
$ for f in *; do
$   echo "処理: [$f]"
$   wc -c "$f"
$ done

wc -c $f と囲まずに書くと、wc は my と report.txt という2つのファイルを探しに行って失敗します。 囲めば1つのファイル名として渡ります。

"$var" と $var を、目で比べる

もっと小さく確かめます。

bash
$ V="a b c"
$ echo $V
$ echo "$V"
a b c
a b c

echo だと同じに見えます。 echo は受け取った単語を空白で繋いで出すので、割れていても元に戻ってしまうからです。だから echo で確認しても分かりません。

単語の個数が見える形にします。

bash
$ V="a b c"
$ printf '[%s]\n' $V
$ printf '[%s]\n' "$V"
[a]
[b]
[c]
[a b c]

同じ変数から、3単語と1単語という別の結果が出ました。

printf は書式を引数の数だけ繰り返すので、単語がいくつになったかがそのまま見えます。クォートの有無を確かめるときは printf '[%s]\n' を使ってください。

空のときは、さらに差が出ます。

bash
$ V=""
$ printf '[%s]\n' "$V"
$ set -- "$V"; printf '引数の数: %s\n' $#
$ set -- $V; printf '引数の数: %s\n' $#
[]
引数の数: 1
引数の数: 0

囲めば「空文字という1個の引数」が渡ります。囲まないと引数が0個になり、そこに何も無かったことになります。 この「引数が消える」が、次に出てくる構文エラーの正体です。

"$@" と $* — 実際に引数を渡して確かめる

スクリプトの引数をそのまま別のコマンドに渡す場面は必ず来ます。 ここも4通りあって、正解は1つだけです。

bash
$ nano args.sh
bash
#!/bin/bash

  echo "--- 引数の個数: $# ---"

  echo '"$@" ='
  printf '  [%s]\n' "$@"

  echo '$@ ='
  printf '  [%s]\n' $@

  echo '"$*" ='
  printf '  [%s]\n' "$*"

  echo '$* ='
  printf '  [%s]\n' $*

実行します。引数の1つ目に、わざと空白を入れます。

bash
$ chmod +x args.sh
$ ./args.sh "my report.txt" notes.txt
--- 引数の個数: 2 ---
"$@" =
  [my report.txt]
  [notes.txt]
$@ =
  [my]
  [report.txt]
  [notes.txt]
"$*" =
  [my report.txt notes.txt]
$* =
  [my]
  [report.txt]
  [notes.txt]

渡したのは2個です。正しく2個のまま出たのは "$@" だけでした。

書き方結果使う場面
"$@"元の個数のまま、1引数=1単語これを使う。ほぼ唯一の正解
$@空白で割れる使わない
"$*"全部を空白で繋いだ1個の文字列ログに「渡された引数」を1行で出すときだけ
$*空白で割れる使わない

"$@" は、シェルの中でも特別扱いされる書き方です。 「引数を1個ずつ、囲んだまま並べ直す」という専用の動きを持っています。引数を横流しするときは、迷わず "$@"。 これだけ覚えれば足ります。

bash
$ # 受け取った引数を、そのまま ls に渡したい
$ ls -l "$@"

[ $x = 1 ] は、変数が空だと構文エラーになる

ここが本線で説明を飛ばした場所です。 実際に起こします。

bash
$ x=""
$ [ $x = 1 ] && echo "1です"
bash: [: =: unary operator expected

「比較しただけ」なのにエラーになりました。

理由は、さきほど見た「囲まないと引数が消える」です。$x が空なので、シェルが [ に渡したのは = と 1 と ] の3つだけになります。[ から見れば [ = 1 ] と書かれたのと同じで、左辺が無いのでどう読んでいいか分かりません。

囲めば直ります。

bash
$ x=""
$ [ "$x" = 1 ] && echo "1です"
$ echo "終了コード: $?"
終了コード: 1

エラーが出ず、「等しくない」という結果(終了コード1)で静かに終わりました。 これが正しい動きです。

もう1つ、[[ ]] を使う手もあります。

bash
$ x=""
$ [[ $x = 1 ]] && echo "1です"
$ echo "終了コード: $?"
終了コード: 1

[[ ]] の中では単語分割が起きません。 だから囲まなくても壊れません。ただし後述のとおり移植性を捨てるので、まずは「囲む」を体に入れてください。

[ $x = 1 ] を「値が空だと落ちる比較」と覚えないでください。 [ に渡す引数が消えているだけです。原因が分かれば、-z でも -f でも同じ理屈だと分かります。

[ -f $file ]     ← file が空だと [ -f ] になって崩れる
[ -f "$file" ]   ← 正しい

逆に、囲まなくてよいのはどこか

「常に囲め」で困ることはほとんどありませんが、理屈は知っておきます。

場所囲む必要理由
[ ... ] の中必要引数が消えて構文が崩れる
コマンドの引数必要単語分割される
[[ ... ]] の中不要この構文の中では単語分割が起きない
$(( ... )) の中不要数として読まれる。$ も省ける
V=$OTHER の右辺不要代入の右辺だけは単語分割されない

例外を覚えるより、全部囲むほうが速いです。 この記事でも、以降は全部囲みます。

変数の展開 — ${ } の中でできること

${var} の中には、実は小さな言語が入っています。 覚えると、sed や cut を呼ばずに済む場面が一気に増えます。

書き方意味
${var:-既定}空か未定義なら「既定」を使う。var 自体は変わらない
${var:=既定}空か未定義なら「既定」を入れてから使う
${var:?メッセージ}空か未定義なら、メッセージを出して落ちる
${var#接頭}先頭から最短で一致した分を消す
${var##接頭}先頭から最長で一致した分を消す
${var%接尾}末尾から最短で一致した分を消す
${var%%接尾}末尾から最長で一致した分を消す
${var/前/後}最初の1回だけ置き換える
${var//前/後}全部置き換える
${#var}文字数を返す

表だけだと入りません。1つずつ打ちます。

bash
$ FILE="/var/log/nginx/access.log.1"
$ echo "${FILE##*/}"
$ echo "${FILE%/*}"
$ echo "${FILE%.*}"
$ echo "${FILE%%.*}"
$ echo "${#FILE}"
access.log.1
/var/log/nginx
/var/log/nginx/access.log
/var/log/nginx/access
27

読み方はこうです。

  • ${FILE##*/} … 末尾の / までを最長で消す → ファイル名だけが残る(basename と同じ)
  • ${FILE%/*} … 最後の / 以降を消す → フォルダ部分が残る(dirname と同じ)
  • ${FILE%.*} … 最後のドット以降を消す → 拡張子を1つ落とす
  • ${FILE%%.*} … 最初のドット以降を全部消す → .log.1 がまとめて消える

# は左、% は右。 キーボードで # は % より左にある、と覚えると迷いません。 1個が最短、2個が最長です。

置換と既定値も打ちます。

bash
$ S="a-b-c"
$ echo "${S/-/+}"
$ echo "${S//-/+}"
$ echo "${S//-/}"
a+b-c
a+b+c
abc

置き換え先を書かなければ削除になります。

bash
$ unset NAME
$ echo "名前: ${NAME:-無名}"
$ echo "NAME の中身: [$NAME]"
名前: 無名
NAME の中身: []

:- は「そのとき代わりに使うだけ」で、変数自体は空のままです。入れたいなら := を使います。

そして、必須の引数にはこれを使います。

bash
$ unset TARGET
$ echo "対象: ${TARGET:?対象のホスト名を指定してください}"
bash: TARGET: 対象のホスト名を指定してください

:? は、値が無ければその場でメッセージを出して止めます。 スクリプトの先頭に並べておくと、「引数チェックの if を10行書く」が1行になります。

bash
#!/bin/bash
  HOST="${1:?使い方: ./ping.sh ホスト名}"
  COUNT="${2:-3}"
  ping -c "$COUNT" "$HOST"

必須は :?、省略可は :-。 この対で書くと読みやすくなります。

$(...) とバッククォート、そして $(( ))

コマンドの実行結果を埋め込む書き方は2つあります。

bash
$ echo "今日は $(date '+%m月%d日') です"
$ echo "今日は `date '+%m月%d日'` です"

どちらも同じ結果になります。 では何が違うのか。

$(...) は入れ子にできる。バッククォートはできない。

bash
$ echo "$(basename "$(dirname /var/log/nginx/access.log)")"
nginx

内側の $(...) の結果を、外側の $(...) がそのまま受け取れました。 これをバッククォートでやろうとすると、内側のバッククォートをいちいち逆スラッシュで打ち消すことになり、3段になった時点で読めなくなります。

さらに、バッククォートの中では逆スラッシュの扱いが変わるという落とし穴もあります。

書き方判定
$(...)これを使う。入れ子にできる。中のクォートも素直に書ける
...古い書き方。読めるようにはしておく(他人のスクリプトに出てくる)

計算は、また別の記号です。

bash
$ A=10
$ B=3
$ echo "$(( A + B ))"
$ echo "$(( A * B ))"
$ echo "$(( A / B ))"
$ echo "$(( A % B ))"
13
30
3
1

$(( )) の中は数として読まれます。 $ を付けなくても変数として扱われますし、空白を入れても構いません。

ただし、シェルの計算は整数だけです。

bash
$ echo "$(( 10 / 3 ))"
3

小数は出ません。切り捨てです。 小数が要るときは bc や awk に渡します。

bash
$ echo "10 / 3" | bc -l
3.33333333333333333333

expr や let は使わなくて構いません。 $(( )) があれば足ります。

条件分岐 — [ はコマンドである

[ がコマンドである証拠

これを見ると、全部の疑問が消えます。

bash
$ type [
$ ls -l /usr/bin/[
[ is a shell builtin
-rwxr-xr-x 1 root root ... /usr/bin/[

/usr/bin/[ という名前の実行ファイルが、本当に存在します。

つまり if [ -z "$X" ]; then は、「[ というコマンドを、-z と $X と ] という3つの引数で実行している」だけです。

ここから、疑問だった仕様が全部説明できます。

疑問答え
なぜ [ の後ろに空白が要るのかコマンド名と引数の区切りだから。[-z では [-z というコマンドを探しに行く
なぜ最後に ] が要るのか[ が「最後の引数は ] であること」を要求しているから。ただの引数
なぜ [ "$x" = 1 ] で = の前後に空白が要るのか= も引数の1つだから。"$x"=1 では1個の引数になる
なぜ変数が空だと崩れるのか引数が1つ消えるから

試すと納得できます。

bash
$ [ -z "" ]
$ echo "$?"
$ [-z ""]
0
bash: [-z: command not found

「コマンドが見つからない」と言われました。 構文エラーですらなく、コマンド名として探しに行っています。

[ ] と [[ ]] の違い

[[ ]] は bash が持つ「構文」で、コマンドではありません。 だから中の書き方の制約が緩みます。

[ ](test コマンド)[[ ]](bash の構文)
正体コマンドシェルの構文
クォートしない空変数崩れる崩れない
パターンマッチできない[[ "$f" == *.log ]] が書ける
正規表現できない[[ "$s" =~ ^[0-9]+$ ]] が書ける
かつ・または-a -o(曖昧で非推奨)&& || が使え、短絡評価される
< > の比較リダイレクトと解釈されるので \< が必要そのまま書ける
移植性どのシェルでも動く(POSIX)bash / zsh のみ。sh では動かない

パターンマッチを試します。

bash
$ f="access.log"
$ [[ "$f" == *.log ]] && echo "ログファイルです"
$ [[ "$f" =~ ^acc ]] && echo "acc で始まります"
ログファイルです
acc で始まります

== の右側のクォートを外すのがポイントです。 [[ "$f" == "*.log" ]] と囲むと、パターンではなくただの文字列として比較されて一致しません。左は囲む、パターン側は囲まない。

短絡評価も見ます。

bash
$ f=""
$ [[ -n "$f" && -f "$f" ]] && echo "ある"
$ echo "終了コード: $?"
終了コード: 1

-n "$f" が偽の時点で、右側の -f "$f" は評価されません。 これが短絡評価です。[ ] の -a は両方が先に評価される可能性があり、意図しない結果になることがあります。

どちらを使うか。 #!/bin/bash と書いたスクリプトなら [[ ]] を使って構いません。 そのほうが事故が減ります。 #!/bin/sh と書いたなら [[ ]] は使えません。 Ubuntu の /bin/sh は bash ではなく dash です。

ls -l /bin/sh
lrwxrwxrwx 1 root root 4 ... /bin/sh -> dash

シバンに bash と書いたのに sh script.sh で実行すると、シバンは無視されて dash で動きます。 ここが一番よくある「自分の環境では動いたのに」の原因です。

case — 分岐が3つ以上になったら

if を elif で積むより読みやすくなります。

bash
$ nano level.sh
bash
#!/bin/bash
  set -euo pipefail

  FILE="${1:?使い方: ./level.sh ファイル名}"

  case "$FILE" in
    *.log|*.txt)
      echo "テキスト系のファイルです"
      ;;
    *.tar.gz|*.tgz)
      echo "圧縮ファイルです"
      ;;
    .*)
      echo "隠しファイルです"
      ;;
    *)
      echo "分類できません"
      ;;
  esac
bash
$ chmod +x level.sh
$ ./level.sh access.log
$ ./level.sh backup.tar.gz
$ ./level.sh .bashrc
$ ./level.sh image.png
テキスト系のファイルです
圧縮ファイルです
隠しファイルです
分類できません
部分意味
case "$X" in始まり
パターン)グロブのパターン。正規表現ではない
A|B)どちらかに一致
;;その枝の終わり。書き忘れると構文エラー
*)どれにも当たらなかったとき。必ず最後に置く
esaccase の終わり(case の逆さ読み)

*) は必ず書いてください。 「想定外の値が来たときに何もせず次へ進む」のが、シェルスクリプトで一番静かに壊れるパターンです。

繰り返し — for / while read / until

for i in $(cat f) を、実際に壊す

山場①でやったのと同じ事故が、ファイルを1行ずつ読むときにも出ます。 実験用のファイルを作ります。

bash
$ cd ~/sh-lab
$ printf 'apple 100\nbanana  200\n  cherry 300\ngrape\t400\n' > lines.txt
$ cat -A lines.txt
apple 100$
banana  200$
  cherry 300$
grape^I400$

cat -A は見えない文字を見せてくれます。 $ が行末、^I がタブです。4行のファイルで、行頭の空白・連続した空白・タブが混ざっています。

まず、やってはいけない書き方から。

bash
$ for line in $(cat lines.txt); do echo "[$line]"; done
[apple]
[100]
[banana]
[200]
[cherry]
[300]
[grape]
[400]

4行のはずが、8個になりました。 理由は for f in $(ls) と同じで、行という単位はどこにも残っていません。 $(cat ...) はただの1本の文字列で、それを空白・タブ・改行で切り直しているだけです。

正しくは while IFS= read -r line

bash
$ while IFS= read -r line; do echo "[$line]"; done < lines.txt | cat -A
[apple 100]$
[banana  200]$
[  cherry 300]$
[grape^I400]$

4行のまま、行頭の空白も連続空白もタブも、そのまま残りました。 ここでも cat -A に通しているのは、タブが残っているかを目で確かめるためです。^I がタブでした。

呪文に見えるので、3つに分けます。

部分無いとどうなるか
IFS=行頭・行末の空白とタブが削られる。 cherry の空白が消える
-r逆スラッシュがエスケープとして食われる。 C:\new のような値が壊れる
< lines.txtファイルを while の入力に繋ぐ。ここはパイプで流し込んでも動くが、後述の理由でリダイレクトを使う

IFS= を外して差を見ます。

bash
$ while read -r line; do echo "[$line]"; done < lines.txt | cat -A
[apple 100]$
[banana  200]$
[cherry 300]$
[grape^I400]$

3行目の行頭の空白が消えました。 「なんとなく動くが、たまに値がずれる」の正体はこれです。

while IFS= read -r line; do ... done < ファイル は、丸ごと1つの型として覚えてください。 3つの部品を毎回考えるより速く、考えないほうが間違えません。

ついでに、1行を項目に分けたいときも read でできます。

bash
$ while read -r name price; do
$   echo "$name は $price 円"
$ done < lines.txt
apple は 100 円
banana は 200 円
cherry は 300 円
grape は 400 円

read は変数を複数書くと、区切って入れてくれます。 最後の変数に残り全部が入るので、列が多いときは最後を rest にしておくと安全です。

パイプで繋ぐと、変数が戻らない

もう1つ、while read 特有の落とし穴です。

bash
$ count=0
$ cat lines.txt | while read -r line; do count=$((count + 1)); done
$ echo "件数: $count"
件数: 0

4行読んだのに、0のままです。

パイプの右側はサブシェル(子のシェル)で動くからです。子の中で count を増やしても、親には戻りません。 リダイレクトの回で見た「パイプは別のプロセスを繋ぐもの」が、ここで効いてきます。

リダイレクトで読めば、同じシェルの中なので戻ります。

bash
$ count=0
$ while read -r line; do count=$((count + 1)); done < lines.txt
$ echo "件数: $count"
件数: 4

while read は、パイプではなく < ファイル で読む。 これも型として覚えてしまってください。

最後の行が読まれないことがある

改行で終わっていないファイルは、最後の1行が落ちます。

bash
$ printf 'aaa\nbbb\nccc' > noeol.txt
$ while IFS= read -r line; do echo "[$line]"; done < noeol.txt
[aaa]
[bbb]

ccc が出ません。 read は「改行を読んだら成功」なので、改行が来ないまま終わると失敗として扱われ、ループが終わります。

対処はこれです。

bash
$ while IFS= read -r line || [ -n "$line" ]; do echo "[$line]"; done < noeol.txt
[aaa]
[bbb]
[ccc]

「読み込みに失敗しても、変数に中身が残っていればもう1回だけ回す」という意味です。他人が作ったファイルを読むときは、これを付けてください。

until — while の逆

until は「条件が成立するまで回す」です。 while と逆なだけですが、待つ処理では until のほうが素直に読めます。

bash
$ nano wait-port.sh
bash
#!/bin/bash
  set -euo pipefail

  PORT="${1:-22}"
  TRIES=0

  until ss -ltn "sport = :$PORT" | grep -q LISTEN; do
    TRIES=$((TRIES + 1))
    if [ "$TRIES" -ge 10 ]; then
      echo "ポート $PORT が10回待っても開きませんでした" >&2
      exit 1
    fi
    echo "待機中... ($TRIES)"
    sleep 1
  done

  echo "ポート $PORT は開いています"
bash
$ chmod +x wait-port.sh
$ ./wait-port.sh 22
ポート 22 は開いています

開いていないポートでも試します。

bash
$ ./wait-port.sh 9999
待機中... (1)
待機中... (2)
(中略)
ポート 9999 が10回待っても開きませんでした

「回数の上限」を必ず入れてください。 上限の無い until は、条件が永久に成立しないとき、黙って回り続けます。 サーバーの起動待ちでこれを踏むと、CI が止まったまま気づきません。

>&2 は「エラーメッセージは標準エラーに出す」という意味です。詳しくはリダイレクトの回にあります。エラーは必ず >&2 に出す。 そうしないと、パイプの先にエラー文が混ざります。

事故を防ぐ4行

人のスクリプトの先頭には、だいたい同じものが書いてあります。

bash
#!/bin/bash
  set -euo pipefail

本線では set -e と set -u までやりました。ここでは残りと、そして「効かない場所」をやります。

指定意味
-eエラーが出たら、そこで止める
-u未定義の変数を使ったら、エラーにする
-o pipefailパイプの途中が失敗したら、パイプ全体を失敗にする

pipefail はリダイレクトの回で扱いました。set -euo pipefail は、この3つを1行で書いた形です。

set -e が効かない場所を、実際に見る

ここが今日の2つ目の山です。 「set -e を書いたから安全」は間違いです。

bash
$ nano trap-e.sh
bash
#!/bin/bash
  set -euo pipefail

  echo "=== 1. そのまま失敗させる ==="
  set +e   # 1番だけ、親が一緒に止まらないよう一時的に外す
  ( set -e; false; echo "この行は出ない" )
  set -e
  echo "  → サブシェルは止まりました"

  echo "=== 2. if の条件の中 ==="
  if false; then
    echo "真"
  else
    echo "  → 止まらない。if の条件は失敗してよい場所"
  fi

  echo "=== 3. && の左 ==="
  false && echo "出ない"
  echo "  → 止まらない。&& の左も失敗してよい場所"

  echo "=== 4. || で受けた ==="
  false || echo "  → 止まらない。|| は失敗を受け止める書き方"

  echo "=== 5. 関数を if で呼ぶ ==="
  danger() {
    false
    echo "  → 関数の中の false の後ろが、実行されてしまった"
    return 0
  }
  if danger; then
    echo "  → しかも成功として扱われた"
  fi

  echo "=== 6. 関数を、そのまま呼ぶ ==="
  danger
  echo "この行は出ない"
bash
$ chmod +x trap-e.sh
$ ./trap-e.sh
$ echo "終了コード: $?"
=== 1. そのまま失敗させる ===
  → サブシェルは止まりました
=== 2. if の条件の中 ===
  → 止まらない。if の条件は失敗してよい場所
=== 3. && の左 ===
  → 止まらない。&& の左も失敗してよい場所
=== 4. || で受けた ===
  → 止まらない。|| は失敗を受け止める書き方
=== 5. 関数を if で呼ぶ ===
  → 関数の中の false の後ろが、実行されてしまった
  → しかも成功として扱われた
=== 6. 関数を、そのまま呼ぶ ===
終了コード: 1

5番を見てください。

同じ danger という関数なのに、if で呼んだときは中の false で止まらず、そのまま呼んだときは止まりました。

理由はこうです。

set -e は「失敗が誰にも拾われていないとき」だけ効く。 if の条件、&& の左、|| の左は、失敗が「判定材料」として拾われる場所なので、set -e は黙る。 そして、その文脈で呼ばれた関数は、中身まで丸ごと黙る。

つまり if 関数; then と書いた瞬間、その関数の中では set -e が無効になります。 ここを知らないと、「関数にまとめたら、急にエラーを素通りするようになった」という説明のつかない現象になります。

[スクリーンショット: 02_set_e_bypass.png] ./trap-e.sh の出力全体を撮ってください。5番と6番で、同じ関数の結果が違うところが要点です。

では、どう書けばいいのか。

bash
$ # 失敗を拾いたい関数は、終了コードを自分で受ける
$ if danger; then
$   echo "成功"
$ else
$   echo "失敗(終了コード: $?)"
$ fi

$ # 途中で必ず止めたい場所は、自分で書く
$ important_step || { echo "important_step に失敗しました" >&2; exit 1; }

|| { ...; exit 1; } を明示的に書く。 これが一番確実です。

set -e は保険であって、設計ではありません。 「止まってほしい場所は、自分で || exit 1 を書く」を基本にして、set -e はそこから漏れたものを拾う網、と考えてください。

trap — 途中で落ちても後片づけする

スクリプトが途中で落ちると、一時ファイルが残ります。

bash
$ nano cleanup.sh
bash
#!/bin/bash
  set -euo pipefail

  TMP="/tmp/mywork.$$"
  echo "作業ファイル: $TMP"
  touch "$TMP"

  false          # ここで落ちる

  rm -f "$TMP"   # ここまで来ない
bash
$ chmod +x cleanup.sh
$ ./cleanup.sh
$ ls /tmp/mywork.*
作業ファイル: /tmp/mywork.1234
/tmp/mywork.1234

残りました。 これが毎日動くスクリプトだと、ゴミが溜まり続けます。

trap は「終わるときに必ず実行する処理」を先に登録しておく仕組みです。

bash
$ nano cleanup2.sh
bash
#!/bin/bash
  set -euo pipefail

  TMP="$(mktemp)"
  trap 'rm -f "$TMP"; echo "後片づけしました: $TMP"' EXIT

  echo "作業ファイル: $TMP"
  echo "途中経過" > "$TMP"

  false          # ここで落ちる

  echo "ここまで来ない"
bash
$ chmod +x cleanup2.sh
$ ./cleanup2.sh
$ echo "終了コード: $?"
$ ls "$TMP" 2>/dev/null || echo "ファイルは残っていません"
作業ファイル: /tmp/tmp.AbCdEf1234
後片づけしました: /tmp/tmp.AbCdEf1234
終了コード: 1
ファイルは残っていません

落ちたのに、後片づけが実行されました。

部分意味
trap 'コマンド' EXITどんな終わり方をしても、最後にそのコマンドを実行する
trap 'コマンド' INT TERMCtrl + C や kill されたときだけ実行する
EXIT を使う正常終了・エラー終了・Ctrl + C、全部まとめて拾える

trap は ' シングルクォートで囲みます。 " にすると、登録した瞬間に変数が展開されてしまい、後で変わった値が反映されません。

そして、trap は「一時ファイルを作る前」ではなく「作った直後」に置きます。

bash
$ TMP="$(mktemp)"           # 先に作って
$ trap 'rm -f "$TMP"' EXIT  # すぐ登録する

この2行はセットです。 間に何か書いて落ちると、その1行のあいだだけゴミが残ります。

mktemp — 一時ファイルの名前を自分で決めない

/tmp/mywork.txt のような固定の名前は、2つの理由で危険です。

  1. 同じスクリプトを2つ同時に動かすと、お互いのファイルを壊し合う
  2. 他人が先に同じ名前のファイルを置いて待ち構えられる(/tmp は誰でも書けるため)
bash
$ TMP="$(mktemp)"
$ echo "$TMP"

$ TMPDIR_="$(mktemp -d)"
$ echo "$TMPDIR_"
/tmp/tmp.9zQx1mK3pW
/tmp/tmp.7bR4nT8vLc

mktemp は、重複しない名前で、本人しか読み書きできない権限で作ってくれます。

bash
$ ls -ld "$TMPDIR_"
drwx------ 2 ユーザー名 ユーザー名 4096 ... /tmp/tmp.7bR4nT8vLc

drwx------。 他人には何も見えません。権限の回でやった読み方が、ここで効きます。

フォルダごと作って、trap で丸ごと消すのが一番楽です。

bash
$ WORK="$(mktemp -d)"
$ trap 'rm -rf "$WORK"' EXIT

readonly — 書き換えられたくない値を守る

bash
$ readonly BACKUP_DIR="/var/backups/myapp"
$ BACKUP_DIR="/"
$ echo "$BACKUP_DIR"
bash: BACKUP_DIR: readonly variable
/var/backups/myapp

代入が拒否されました。

これが効くのは、rm -rf "$BACKUP_DIR" のような行があるときです。 スクリプトが長くなって、どこかで同じ名前の変数を使い回してしまうと、rm -rf / に化けます。 readonly にしておけば、その代入の時点で落ちます。

設定値は先頭にまとめて readonly で置く。 これだけで、事故の面積が目に見えて減ります。

bash
#!/bin/bash
  set -euo pipefail

  readonly SCRIPT_NAME="$(basename "$0")"
  readonly BACKUP_DIR="/var/backups/myapp"
  readonly KEEP_DAYS=7

関数 — 戻り値は終了コード、値は標準出力

他の言語から来ると、必ず一度これを書きます。

bash
$ get_name() {
$   return "obmes"
$ }
bash: return: obmes: numeric argument required

怒られます。

シェルの関数は、値を返さない。返すのは終了コード(0〜255の数字)だけ。 値は、標準出力に「書く」。呼ぶ側が $(...) で拾う。

正しくはこうです。

bash
$ nano func.sh
bash
#!/bin/bash
  set -euo pipefail

  # 値を返したい関数 → echo で出す
  disk_usage_percent() {
    local target="${1:-/}"
    df --output=pcent "$target" | tail -n 1 | tr -d ' %'
  }

  # 成否を返したい関数 → return で 0 か 1
  is_service_running() {
    local name="$1"
    systemctl is-active --quiet "$name"
  }

  USED="$(disk_usage_percent /)"
  echo "ルートの使用率: ${USED}%"

  if [ "$USED" -ge 80 ]; then
    echo "警告: 80%を超えています" >&2
  fi

  if is_service_running ssh; then
    echo "ssh: 動いています"
  else
    echo "ssh: 止まっています"
  fi
bash
$ chmod +x func.sh
$ ./func.sh
ルートの使用率: 34%
ssh: 動いています
やりたいこと書き方
値を返すecho / printf で標準出力に出す → 呼ぶ側で X="$(関数名)"
成否を返すreturn 0 / return 1 → 呼ぶ側で if 関数名; then
数値を返すecho で出す。return は 0〜255 しか入らない

return 256 は 0 になります。 終了コードは1バイトなので、256で1周します。 件数などを return で返してはいけません。

値を返す関数の中で echo でログを出さないでください。 ログも一緒に $(...) で拾われて、値が汚れます。関数の中のログは >&2 に出します。

bash
$ disk_usage_percent() {
$   local target="${1:-/}"
$   echo "調べています: $target" >&2     # ← これは拾われない
$   df --output=pcent "$target" | tail -n 1 | tr -d ' %'
$ }

local — 関数の中の変数を外に漏らさない

シェルの変数は、既定で全部グローバルです。

bash
$ nano local.sh
bash
#!/bin/bash

  i="大事な値"

  bad() {
    for i in 1 2 3; do :; done
  }

  good() {
    local i
    for i in 1 2 3; do :; done
  }

  good
  echo "good の後: $i"

  bad
  echo "bad の後:  $i"
bash
$ chmod +x local.sh
$ ./local.sh
good の後: 大事な値
bad の後:  3

bad を呼んだだけで、外の i が書き換わりました。

関数の中で使う変数は、必ず local を付けてください。 引数も同じです。

bash
$ myfunc() {
$   local src="$1"
$   local dest="$2"
$   local count=0
$   ...
$ }

local は宣言と代入を同時にできますが、注意点が1つあります。

bash
$ local out="$(command_that_fails)"

この書き方だと、command_that_fails が失敗しても set -e で止まりません。 local 自体が成功してしまうためです。終了コードを見たいなら、2行に分けます。

bash
$ local out
$ out="$(command_that_fails)"

これは知らないと絶対に気づきません。 次の shellcheck が指摘してくれます。

shellcheck で、自分のスクリプトを検査する

ここまでの内容は、全部ツールが自動で指摘してくれます。 これが今日いちばん効きます。

bash
$ sudo apt update
$ sudo apt install -y shellcheck
$ shellcheck --version
ShellCheck - shell script analysis tool
version: 0.9.0
license: GNU General Public License, version 3

apt update が何をしているかはパッケージ管理の回にあります。

わざと問題を詰め込んだスクリプトを書いて、見せます。

bash
$ nano bad.sh
bash
#!/bin/bash

  for f in $(ls)
  do
    if [ $f = "notes.txt" ]; then
      echo "見つけた: "$f
    fi
  done

  cd /tmp
  rm -f mywork.txt

  count=`cat lines.txt | wc -l`
  echo "件数: $count"

検査します。

bash
$ shellcheck bad.sh
In bad.sh line 3:
for f in $(ls)
         ^---^ SC2045: Iterating over ls output is fragile. Use globs.

In bad.sh line 5:
  if [ $f = "notes.txt" ]; then
       ^-- SC2086: Double quote to prevent globbing and word splitting.

In bad.sh line 6:
    echo "見つけた: "$f
                     ^-- SC2086: Double quote to prevent globbing and word splitting.

In bad.sh line 9:
cd /tmp
^-----^ SC2164: Use 'cd ... || exit' in case cd fails.

In bad.sh line 12:
count=`cat lines.txt | wc -l`
      ^-- SC2006: Use $(...) notation instead of legacy backticks.
                  ^-- SC2002: Useless cat. Consider 'cmd < file'.

For more information:
  https://www.shellcheck.net/wiki/SC2086
  https://www.shellcheck.net/wiki/SC2164
  https://www.shellcheck.net/wiki/SC2045

この記事でやったことが、そのまま並びました。

[スクリーンショット: 03_shellcheck.png] shellcheck bad.sh の出力を撮ってください。行と列が指されているところが分かるように撮ります。

指摘を1つずつ直します。

コード指摘直し方
SC2086変数を囲んでいない"$f" にする。今日いちばん多く出る指摘
SC2045ls の出力で回しているfor f in * にする
SC2164cd が失敗する可能性cd /tmp || exit 1 にする
SC2006バッククォート$(...) にする
SC2002cat が無駄wc -l < lines.txt にする

直した版です。

bash
$ nano good.sh
bash
#!/bin/bash
  set -euo pipefail

  cd /tmp || exit 1

  for f in *; do
    if [ "$f" = "notes.txt" ]; then
      echo "見つけた: $f"
    fi
  done

  rm -f mywork.txt

  count="$(wc -l < lines.txt)"
  echo "件数: $count"
bash
$ shellcheck good.sh
$ echo "終了コード: $?"
終了コード: 0

何も出ませんでした。 shellcheck は指摘が無ければ何も言わず、終了コード0で終わります。

SC2164(cd の失敗)は軽く見えますが、一番怖い指摘です。

cd /backup/tmp     ← 失敗しても進む
rm -rf *           ← いま居る場所の中身が消える

cd が失敗した瞬間、rm -rf * の意味が変わります。 だから cd ... || exit 1 を必ず付けます。

指摘を無視したいときは、理由を書いて黙らせます。

bash
$ # shellcheck disable=SC2086
$ echo $INTENTIONALLY_SPLIT

「なぜ無視していいのか」を書かずに disable を貼るのはやめてください。 半年後の自分が、その1行を消せなくなります。

新しくスクリプトを書いたら、必ず1回通す。 それだけで、この記事の内容の8割は自動で守られます。

デバッグ — 何が起きているかを、目で見る

「動かないけどエラーも出ない」ときは、シェルに実況させます。

bash
$ nano debug.sh
bash
#!/bin/bash
  set -euo pipefail

  NAME="obmes"
  DIR="/tmp/$NAME"
  COUNT=$(( 2 * 3 ))

  echo "$DIR で $COUNT 件"
bash
$ chmod +x debug.sh
$ bash -x debug.sh
+ NAME=obmes
+ DIR=/tmp/obmes
+ COUNT=6
+ echo '/tmp/obmes で 6 件'
/tmp/obmes で 6 件

+ で始まる行が、シェルの実況です。

重要なのは、実況が「展開したあと」の姿を見せていることです。 $NAME ではなく obmes と出ています。自分が書いたつもりの値と、実際に渡っている値の差が、ここで一目で分かります。

方法使う場面
bash -x スクリプトファイルを書き換えずに1回だけ見たいとき
set -x / set +xスクリプトの一部だけ見たいとき
PS4 を変えるどの行を実行しているかまで見たいとき

一部だけ見る書き方です。

bash
$ set -x        # ここから実況
$ 問題の処理
$ set +x        # ここで実況をやめる

行番号を出すには PS4 を変えます。

bash
$ export PS4='+ ${BASH_SOURCE}:${LINENO}: '   # export しないと子の bash に渡らない
$ bash -x debug.sh
+ debug.sh:4: NAME=obmes
+ debug.sh:5: DIR=/tmp/obmes
+ debug.sh:6: COUNT=6
+ debug.sh:8: echo '/tmp/obmes で 6 件'
/tmp/obmes で 6 件

ファイル名と行番号が付きました。 100行を超えるスクリプトでは、これが無いとどこを見ているか分かりません。

PS4 は「実況の行の先頭に付ける文字列」で、既定は + です。 シバンの下に書いておくと、bash -x のたびに行番号が出ます。

bash
#!/bin/bash
  set -euo pipefail
  PS4='+ ${BASH_SOURCE}:${LINENO}: '

もう1つ、構文だけ確かめる方法があります。

bash
$ bash -n good.sh
$ echo "終了コード: $?"
終了コード: 0

-n は「実行せずに構文だけ見る」です。危険な処理を含むスクリプトを触ったあと、実行する前に1回打つと、括弧の閉じ忘れや fi の書き忘れを、動かさずに見つけられます。

つまずいたところ

echo でクォートの確認をしていて、何日も気づきませんでした。 echo $V と echo "$V" が同じ出力になるので、「囲んでも囲まなくても同じ」と結論していました。echo は受け取った単語を空白で繋いで出すので、割れていても元に戻って見えるだけでした。printf '[%s]\n' に変えた瞬間に、全部見えました。確認方法が間違っていると、正しい実験をしても間違った結論が出ます。

[ $x = 1 ] のエラーを、比較のやり方が違うのだと思っていました。 unary operator expected を読んで、「単項演算子? = は2項なのに?」と混乱し、== にしたり -eq にしたりして、たまたま直ったり直らなかったりしていました。[ がコマンドで、引数が1つ消えているだけと分かったのは、ls -l /usr/bin/[ を見たときです。正体を知らないまま、症状に対処していました。

set -euo pipefail を書いたスクリプトが、途中の失敗を素通りしました。 「set -e が壊れている」と思って、bash のバージョンを疑いました。実際は、その処理を関数にまとめて if 関数; then で呼んでいただけです。if の条件で呼んだ関数は、中まで set -e が無効になるという仕様を知りませんでした。保険を掛けたつもりで、保険を自分で外していました。

cat file | while read で数えたカウントが 0 のままでした。 ループの中に echo を入れると4回出るので、「ループは回っているのに変数が増えない」という状態で止まりました。パイプの右側はサブシェルで、そこで増やした値は親に戻らないという話が、リダイレクトの回で扱ったことと同じだと後で気づきました。別の記事で覚えたことを、この場面と結びつけられませんでした。

local out="$(...)" で set -e が効かない件は、自力では絶対に見つけられませんでした。 shellcheck の SC2155 で指摘されて初めて知りました。「知らないことは、検索もできない」というのを一番強く感じた指摘です。だからツールを先に入れます。

そして、この記事を書きながら自分の過去のスクリプトを全部 shellcheck に通しました。 SC2086(クォート)が、1本のファイルで20件以上出たものがありました。「動いていた」のではなく、「空白入りのファイル名を、たまたま一度も渡していなかった」だけでした。

後片づけ

この記事で作ったものを消します。

bash
$ cd ~
$ ls ~/sh-lab
$ rm -rf ~/sh-lab

消す前に必ず ls で中身を確認します。 パスを打ち間違えたまま rm -rf を打つのが、一番よくある事故だからです。

消えたことを確かめます。

bash
$ ls ~ | grep sh-lab

何も出なければ消えています。

/tmp に残ったものも消します。

bash
$ ls /tmp/mywork.* /tmp/tmp.* 2>/dev/null
$ rm -f /tmp/mywork.*

shellcheck は残しておいてください。 これから書く全部のスクリプトで使います。消したいときはこれです。

bash
$ sudo apt remove shellcheck

rm -rf は、ホームディレクトリの中の、自分で作ったフォルダにだけ使います。

まとめ

  • シェルは変数を「値」ではなく「文字列を書いた場所」として扱う。 置き換えてから空白で切り直すので、囲まないと割れる
  • for f in $(ls) は空白入りのファイル名で割れる。 ファイルを回すなら for f in *
  • クォートの確認に echo を使わない。 printf '[%s]\n' にすれば、単語がいくつになったか見える
  • 引数を横流しするときは "$@"。 $@ $* "$*" は全部別物で、"$@" だけが個数を保つ
  • [ はコマンド。 だから前後に空白が要り、] が要り、変数が空だと引数が消えて構文エラーになる。[ "$x" = 1 ] と囲む
  • [[ ]] は bash の構文なので割れない。 パターンマッチと短絡評価が使えるが、sh では動かない
  • ${var#} は左、${var%} は右、1個が最短、2個が最長。 basename も dirname も ${ } で書ける
  • 必須の引数は ${1:?使い方...}、省略可は ${1:-既定}。 引数チェックの if が1行になる
  • $(...) は入れ子にできる。バッククォートはできない。 計算は $(( )) で、整数だけ
  • ファイルは while IFS= read -r line; do ... done < ファイル。 3つの部品を型として覚える。パイプで繋ぐとサブシェルになって変数が戻らない
  • set -e は「失敗が誰にも拾われていないとき」だけ効く。 if の条件、&& の左、そこで呼ばれた関数の中では黙る。止めたい場所は || exit 1 を自分で書く
  • 一時ファイルは mktemp で作り、作った直後に trap ... EXIT を登録する。 落ちても片づく
  • 関数は値を返さない。返すのは終了コードだけ。 値は標準出力に出して $(...) で拾う。関数の中の変数には local
  • shellcheck を入れて、書いたら必ず1回通す。 この記事の内容の大半は、ツールが自動で指摘してくれる
  • 動かないときは bash -x。 展開したあとの実際の値が見える。PS4 を変えれば行番号も出る

「たぶんこう書く」をやめました。 壊れ方が決まっていると分かってからは、書く前に「ここは囲んだか」「ここは [ に引数がいくつ渡るか」を考えるようになりました。そして、考え忘れたぶんは shellcheck が拾ってくれます。

参考リンク


次に読む

この記事は 【深掘り】Linux の 14 / 18 本目です。

記事
← 前の記事ss・tcpdump・ufwでパケットを追う — 開けたのに繋がらない
→ 次の記事Linuxの起動プロセス GRUB・initramfs — 止まったら見る場所は5つ

上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。

全体の順路は はじめに にあります。

roadmap.sh のどこをやっているか

DevOps›Linux — Shell Programming
  • クォート・変数展開・条件分岐・繰り返し
  • set -euo pipefail の限界と shellcheck

この記事は、上の項目を実際に手を動かして確かめる回です。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次