Administrace komentářů

To je znamenité howto! Líbí se mi, jak je uspořádané podle „speciálních znaků“, ne podle abstraktních témat typu „substituce tohoto nebo tamtoho“. Proč mi tohle přijde pozitivní: Protože ten, kdo se snaží poprvé porozumět Bash skriptům, se s největší pravděpodobností v dané chvíli pokouší spíš pochopit nějaký existující skript než napsat nový od nuly. Pro někoho v takové situaci je mnohem přínosnější kapitola „Otazník“ než kapitola „O expanzích obecně“.

Jenom je tam pár věcí, které vypadají spíš jako z doby Bashe 3.x než z doby Bashe 5.x. Nechce se mi tam registrovat a stránka „Diskuse“ je tam beztak zatím prázdná, tak aspoň tady ve zkratce prodlužce:

• Dvourozměrné pole:

  A=('abcd' 'dcba')
  Z=('zxyw' 'wxyu' 'tuxz')
  ARR=('A' 'Z')
  
  for row in "${ARR[@]}"; do
    echo "processing row: $row"
    declare -n arr="$row"  # <<< Tohle!
    for element in "${arr[@]}"; do
      echo "  processing element: $element"
    done
  done
  

• Celkově tam chybí (podle mě hyper-užitečný) „operátor“ +=:

  somestring=blah
  somestring+=' blah'
  echo "$somestring"
  
  somearray=(blah)
  somearray+=(blah)
  echo "${somearray[@]}"
  
  declare -A anotherarray
  anotherarray=(['zee']=blah)
  anotherarray+=(['foo']=blahblah ['zee']=updated_blah)
  echo "${!anotherarray[@]}"
  echo "${anotherarray[@]}"
  for index in "${!anotherarray[@]}"; do
    echo "${index} -> ${anotherarray["${index}"]}";
  done
  
  declare -i someint
  someint=2
  someint+=3
  ((someint += 4))       # trochu "jiný" +=
  someint='someint + 5'  # aritmetika obecně
  echo "$someint"
  

• V kapitole o „dvojitých kulatých závorkách“ by se hodilo uvést některé souvislosti (a co funguje s kterým „typem“ proměnné):

  declare -i a=0
  
  ((++a))
  ((a += 1))
  a=$((a + 1))
  echo "$a"
  
  a+=1
  a='a + 1'
  echo "$a"
  

• U „příkladů substituce“ chybí zmínka o jednom snadno přehlédnutelném odstavci z manuálové stránky, který však leckdy znamená úsporu hodin úsilí a třískání hlavou do stolu:

  When not performing substring expansion, using the forms documented below (e.g., :-), bash tests for a parameter that is unset or null. Omitting the colon results in a test only for a parameter that is unset.

  Tohle^^^ v tom howto sice je popsané, ale až později a jenom v souvislosti s otazníkem. Plus a minus se s tím kamarádí taky:

  var_analysis() {
    local -n var="$1"
    echo "Variable '${1}'" \
         "${var+exists ("${1}='"}${var-does not exist}${var+"'")}" \
         "and is ${var:+set ("${1}='"}${var:-empty}${var:+"'")}."
  }
  
  unset a
  var_analysis a
  a=
  var_analysis a
  a=b
  var_analysis a
  a=
  var_analysis a
  unset a
  var_analysis a
  

  Leč na tohle pozor; to se mi nezdá, i když podle odpovědí to vypadá, že je (skoro) všechno v pořádku. (TL;DR: V kombinaci s poli všechno najednou přestává být zjevné a jednoduché.)

• U veškeré té práce s poli a expanzemi chybí, jestli se dobře dívám, třešnička na dortu v podobě „vektorové“ aplikace substituce na celé pole:

  xml_files=({a..f}.xml)
  echo "${xml_files[@]}"
  text_files=("${xml_files[@]/%.xml/.txt}")
  echo "${text_files[@]}"
  

• Jo a když už jsme u toho předchozího, tyhle tečkové expanze tam taky chybí:

  echo {a..z}{0..9}
  echo \({a..z}' 's' 'indexem' '{0..9}\)
  echo -ne \({a..z}' 's' 'indexem' '{0..9}')\n'
  

• U těch „speciálních znaků masky“ velmi citelně chybí extglob, což bývá (podle mých zkušeností) ve většině dister zapnuté (jestli to už náhodou Bash nemá zapnuté implicitně pořád):

  echo /etc/@(passwd|group)
  

  Nejsou to sice úplně regexpy, ale v některých situacích to může výrazně pomoct. Ještě stojí za připomenutí, že u porovnání to funguje taky:

  [[ 'bac' = +(a|b|c) ]] && echo 'Jo!'
  

• Ůůůfuf, tohle je sice pravda, ale je to mor, neštovice a rakovina v jednom:

  Jestliže rouře předchází rezervované slovo !, stav ukončení (exit status) této roury je "logické NOT stavu ukončení" (exit status) posledního příkazu. Jinak je exit status roury stav ukončení (exit status) posledního příkazu.

  Takže, jak se s tímhle vypořádat? Jak zajistit, abychom mohli správně detekovat selhání v kterékoliv sekci dýmky? Inu, jsou dvě možnosti. Buď set -o pipefail…

  if (set -e; (exit 7;) | (exit 0;);); then
    echo 'Kurvafix, tohle uspělo! Ouha!'
  fi
  if (set -e -o pipefail; (exit 7;) | (exit 0;);); then
    echo 'Tohle se neobjeví, díky pipefail!'
  else
    echo 'Teď jsme démona chytili! Jmenuje se '"${?}."
  fi
  

  … nebo, hrůza pomyslet, pole PIPESTATUS:

  (
  set -e
  (exit 7;) | (exit 0;)
  for status in "${PIPESTATUS[@]}"; do (exit "${status}";); done
  )
  echo "Status je ${?}"': Chytili jsme ho (pracně) bez pipefail!'
  

  Tak nevím, jak kdo, ale já sázím na set -o pipefail. (Nebo když jsme na začátku souboru, tak set -e -o pipefail, protože nám to nemá co selhávat, pokud to selhání netestujeme nebo nenegujeme.)

• U těch „složených příkazů“ mi trochu chybí break a continue. Jasně, obojí je zjevné, ale možná se to hodí jako malý referenční úvod pro někoho, kdo nikdy (nijak jinak) neprogramoval.

  for ((i = 0; i < 10; ++i)); do
    if ((i % 3)); then continue; fi
    echo "$i"
  done
  

• Trochu (ale opravdu jenom trochu) tam chybí něco o file descriptorech a jejich dědění. Což vypadá neužitečně, ale jen dokud si člověk nepoloží otázku: Jak větvit dýmku?! No, není to úplně přímočaré, ale základem takových triků jsou podivně očíslované file descriptory…

  echo blah | (cat 1>&7; echo zee >&5;) 7>&1 5>&2
  

  … a další vychytávky se spoustou fantazie. Tohle samozřejmě zdaleka není celé; bude tam hrát roli řada (více či méně ad-hoc) externích souborů a dýmek.

  echo blah | cat <(cat <(cat <(cat)))
  echo blah | cat < <(cat < <(cat < <(cat)))
  

  (Bez mktemp a mkfifo to nepůjde. (Pravda, nizozemský hacker Johan van der Praase dokázal větvit dýmky jenom s mkfifo.))

• U funkcí celkem citelně chybí nějaké podrobnosti, třeba return versus exit, ale hlavně (především!) klíčové slovo local, obdoba declare, a jeho kombinace s argumenty pro declare:

  keys() {
    local -n source="$1"
    local -n target="$2"
    target=("${!source[@]}")
  }
  
  values() {
    local -n source="$1"
    local -n target="$2"
    target=("${source[@]}")
  }
  
  declare -Ar blah=([hovno]=bullshit [vole]=dude)
  declare -a blah_keys blah_values
  
  keys blah blah_keys
  values blah blah_values
  
  echo 'Keys:' "${blah_keys[@]}"
  echo 'Values:' "${blah_values[@]}"
  

  (Zdá se, že reference na proměnné lze mít jenom do hloubky rekurze 8. Při větší hloubce nastane šílené peklo, na které jsem si teď už zase vzpomněl a konečně jsem ho nahlásil.)

• Povídání o blocích (subshell, seskupení příkazů, různé cykly) by se možná hodilo doplnit o detaily kolem vstupu a výstupu z/do těchto bloků, což je hezký trik, na který se ve skriptech hodně zapomíná. Další důležitá věc je taky vstup a výstup z/do polí, tedy například readarray a read -a. Krátká ukázka všeho zmíněného:

  readarray -t entire_lines < /etc/passwd
  declare -i ctr=0
  for entire_line in "${entire_lines[@]}"; do
    echo "$entire_line"
  done |\
  while IFS=: read -a line_fields; do
    echo "Line ${ctr} in its entirety:"
    echo "  ${entire_lines[ctr]}"
    echo "Fields on line ${ctr}:"
    for line_field in "${line_fields[@]}"; do
      echo "  * $line_field"
    done
    echo "Line ${ctr} reassembled:"
    (IFS=:; echo "  ${line_fields[*]}")
    echo
    ((++ctr))
  done
  

• Zajímavý je taky vztah funkcí k proměnným (zejména lokálním):

  recursion() {
    local -ri order="$1"
    if [[ -z "${cache[order]+set}" ]]; then
      recursion $((order - 2))
      recursion $((order - 1))
      cache[order]='cache[order - 2] + cache[order - 1]'
    fi
  }
  
  fibonacci() {
    local -ri order="$1"
    local -ai cache=(0 1)
    recursion "$order"
    echo ${cache[order]}
  }
  
  for n in {92..0}; do
    printf '%#2d. ' "$n"
    fibonacci "$n"
  done
  

  (Naopak vztah funkcí ke globálním proměnným a k jmennému prostoru funkcí není zajímavý, nýbrž děsivý.) Samozřejmě jde bez rekurze všechno lépe a rychleji, jako skoro vždy:

  fibonacci() {
    local -ri order="$1"
    local -i a=0 b=1
    local -i ctr=0
    for ((;;)); do
      if ((++ctr > order)); then echo "$a"; break; fi
      b='a + b'
      if ((++ctr > order)); then echo "$b"; break; fi
      a='a + b'
    done
  }
  
  for n in {92..0}; do
    printf '%#2d. ' "$n"
    fibonacci "$n"
  done
  

  Momentálně se nedá jít přes 92, protože to přeteče.