算術式（その２） - 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} といった文字列展開と組み合わせると、さらにいろんな事ができるのですが、もう眠いので今日はこのへんで。

配列（その２） - Bash Advent Calendar - Day 2

すでに時間ギリギリ。さて、昨日は初期化と代入を説明したので、今日は削除と参照をば。

削除

変数まるごと削除は unset で。

$ foo=("bar" "baz")
$ unset foo
$ declare -p foo
bash: declare: foo: 見つかりません

特定の要素を削除するには unset 変数[インデックス]で。

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

削除については以上。よほど大規模な Bash スクリプトでもない限り、unset とかわざわざ使うこともないでしょう。

参照

これだけでかなりの量を書ける気がするのですが、二日目にして既に息切れ状態なので手短に。

もう日本語が面倒になってきたので、以下の例参照。

$ foo=("bar" "baz")
$ echo ${foo[0]}
bar
$ echo ${foo[1]}
baz
$ echo ${foo}
bar
$ unset foo[0]
$ echo ${foo}
    # 何もなし

というわけで、${変数[インデックス]} で参照できます。インデックスを省略した場合、それは [0] と等価（最小インデックスを参照してくれるわけではない）になります。どうがんばって見ても、インデックス指定なしの参照は配列変数にアクセスしているようには見えないので、変に省略するのはやめましょう。もとい、そんな変な仕様知ってる人なんてほとんどいないでしょう。

すべての要素を参照

ここまではウォームアップです。これから実用性アップのはず。

さて、配列にまとめてアクセスするには * もしくは @ という特殊なインデックスを使います。

$ foo=("bar" "baz")
$ echo "${foo[*]}"
bar baz
$ echo "${foo[@]}"
bar baz

この例では * と @ に違いがありませんが、その違いは "$*" と "$@" の違いと一緒です。

わからない人にとっては何言ってるのか意味不明だと思いますが、これはこれで一日分使えるのでまたの機会に。とりあえず、IFS を変更しない限り @ の方を使うと覚えておけば大丈夫です。

これを応用することで、配列のコピーができます。

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

これは２行目の qux= の部分が

$ qux=("bar" "baz")

と変数展開された結果です。さて、初期化の部分で述べたように、Bash の配列はインデックスが飛び飛びでも構わないのですが、変数展開ではインデックスの値までは展開されないので、このコピーは完璧ではありません。

インデックスの参照

というわけで、格納されてるインデックスを参照したくなりますよね。

$ foo=("bar" "baz")
$ echo "${!foo[@]}"
0 1
$ unset foo[0]
$ echo "${!foo[@]}"
1

というように "${!変数名[@]}" でインデックスをまとめて取り出せます。ここでも * と @ を使えますが、その違いについては割愛します。ここでもとりあえず @ で覚えておけば間違いありません。

このテクニックを使えばコピーも完璧です。

$ foo=([1]="bar" [3]="baz")
$ qux=()
$ for i in "${!foo[@]}"; do
$   qux[i]="${foo[i]}"
$ done
$ declare -p qux
declare -a qux='([1]="bar" [3]="baz")'

 力尽きたので、さらに明日に続きます。

 

とあるインフラエンジニアの独り言

「SlideShareのスライドをダウンロードできるサイトを作りました。」の件を肴に、ちょっと独り言。

端的に言えば、ある人が「SlideShare がスライドダウンロードさせてくれないからダウンローダー作ったよ」とおっしゃってますが、それどうなのよ、から派生してスクレーパーとかマジやめてというお話。

規約の内容

まずは SlideShare の規約がどうなってるかですが、Terms of Service に

You agree not to use or launch any automated system, including without limitation, "robots," "spiders," "offline readers," etc., that accesses the Site in a manner that sends more request messages to the SlideShare servers in a given period of time than a human can reasonably produce in the same period by using a convention on-line web browser. 

と書いてあります。てきとーに意訳すると、

人間が一般的なブラウザを使った場合に送るリクエストよりも早いペースでリクエストを送る「ロボット」や「スパイダー」、「オフラインリーダー」といったような自動化されたシステムを使用しない、または立ち上げないことに同意します。

ってところでしょうか。後続の文では検索エンジンのロボットに対する条件が書いてありますが、このダウンローダーは該当しないので割愛します。

ダウンローダーは規約違反？

世の中には次に読むであろうページのプリフェッチ、さらにはプリレンダリングまでするブラウザが存在するらしい、というかそんな自社製品があるような気がするので、"human can reasonably produce" すなわち普通の人間がブラウザを操作することによって要求しうる QPS は一般人が思ってるよりは大きいのですが、当該サイトがその妥当性を考慮してダウンロードリクエストのペースを調整しているか分かりません。

ということで規約違反がどうか外からは判断できませんが、ある程度の可能性はあると思っています。

実際、何が悪いの？

実際上は、SlideShare に送っている QPS はそんなに大したことないでしょうし、ちょっと行儀が悪いだけのオフラインリーダーぐらいのものでしょう。なので、多分 SlideShare が規約をたてに何かアクションを取る （e.g. アクセスブロックする) ようなことはないとおもいます。

ただ、この手の proxy とか scraper といった「一つのリクエストを受けて複数のリクエストを他サイトに投げる」サービスは、悪い人に使われると DoS の片棒を担がされたりする危険があるし、前述したような規約違反の可能性、そのほか著作権 (特に DMCA) 違反の可能性など色々面倒ごとがあるので、おおっぴらにやるのは避けたほうがいいよというだけの話です。

本当に言いたいこと

ここからは SlideShare の一件から離れて一般論。

そんでもって何故こんなこと書いてるかっていうと「ユーザーが見られるのをそのままダウンロードできるようにして何が悪い」的な意見が散見されるからです。

確かに、ある個人が wget や curl やらで一回だけプレゼンまるごとコピーするだけのレベルならそうですが、最初に参照した SlideShare の規約にあるように、そうしたものを自動化してサービスとして提供するのはちょっと待ってくださいな、とサービスを提供する側の人間は思ってるわけです。どのくらいの QPS なら妥当・常識的・礼儀正しくて、どのくらいの QPS だと悪用・非常識・お行儀悪いとみなされるかは様々ですが、少なくとも「ユーザーができることなら何やったっていい」という訳ではないということです。

それでもスクレーパーを書く人へ

せめて無駄な 404 Not Found とか起こさないようにしてください。たとえ 404 を返すだけでもコンピューターリソースを消費するんです。スクレーパーも誰かの役に立つのならいいんですが、404 を返すためにこちらがコンピューターリソースを浪費するなんてやってられません。

それでもスクレーパーを書く人へ (その２)

お行儀よい実装を心がけてください。4xx とか 5xx が返ってきたり、そもそも TCP レベルでコネクションが確立できない場合には、すぐにリトライするのはやめてください。特にこっちがちゃんと 429 (RFC6585)「お前リクエスト送りすぎだからペース落とせや」 って返してるのを無視されると、中の人が激おこぷんぷん丸になってしまうかもしれません。

またリトライするにしても、リクエスト queue コントロールをちゃんとして「元々予定していた QPS + リトライ分の QPS」を送りつけるなんてことをしないようにしてください。

それでもスクレーパーを書く人へ (その３)

リクエストに勝手なパラメーターを追加しないでください。多くの場合、リクエスト内の無関係なパラメーターは無視されるだけですが、CDN とか透過なキャッシュレイヤーがあった場合に、キャッシュの邪魔をする場合があります。

逆に、キャッシュを回避するためにわざとタイムスタンプっぽいパラメーターをつけてるのを見つけた日には、中の人が激おこスティックファイナリアリティぷんぷんドリームになっちゃうかも。

本当の本当に書きたかったこと

実は一度「激おこスティックファイナリアリティぷんぷんドリーム」ってブログに書いてみたかったんです。ただそれだけでここまで書きました。多分、数年後に読み返して恥ずかしい思いをするのは自分自身です。