7.7.  pick

pick bietet Argumente zur Auswahl an und gibt die ausgewählten Argumente als Standard-Ausgabe aus:

 1      #!/bin/sh
 2      . 7.prompt
 3      
 4      for arg
 5      do      prompt "$arg"; read x
 6              case $x
 7              in [yYjJ]*)     echo "$arg"
 8              esac
 9      done

[Kernighan & Pike] schreibt die Idee Tom Duff zu. pick erlaubt interaktive Auswahl bei allen Kommandos:

$ pr `pick *.c` | lpr

So funktioniert die Lösung auch in einer Pipeline.

 1      #!/bin/sh
 2      . 7.prompt
 3      
 4      for arg
 5      do      prompt >&2 "$arg" '? '; read x <&2
 6              case $x
 7              in [yYjJ]*)     echo "$arg"
 8              esac
 9      done

So wählt man garantiert mit dem Terminal aus:

 1      #!/bin/sh
 2      . 7.prompt
 3      
 4      for arg
 5      do      prompt >/dev/tty "$arg" '? '; read x </dev/tty
 6              case $x
 7              in [yYjJ]*)     echo "$arg"
 8              esac
 9      done

So ist der Zugriff auf das Terminal billiger:

 1      #!/bin/sh
 2      . 7.prompt
 3      
 4      exec 3>/dev/tty 4</dev/tty
 5      
 6      for arg
 7      do      prompt >&3 "$arg" '? '; read x <&4
 8              case $x
 9              in [yYjJ]*)     echo "$arg"
10              esac
11      done

Wenn - das einzige Argument ist, wird die Standard-Eingabe angeboten:

 1      #!/bin/sh
 2      . 7.prompt
 3      
 4      case $#
 5      in 0)   exit 0
 6      ;; 1)   case "$1"
 7              in -)   while read arg
 8                      do      prompt >&2 "$arg" '? '; read x <&2
 9                              case $x
10                              in [yYjJ]*)     echo "$arg"
11                              esac
12                      done
13                      exit 0
14              esac
15      esac
16      
17      for arg
18      do      prompt >&2 "$arg" '? '; read x <&2
19              case $x
20              in [yYjJ]*)     echo "$arg"
21              esac
22      done
23      exit 0
24      

So beendet control-D die Auswahl:

 1      #!/bin/sh
 2      . 7.prompt
 3      
 4      case $#
 5      in 0)   exit 0
 6      ;; 1)   case "$1"
 7              in -)   while read arg
 8                      do
 9                        if prompt >&2 "$arg" '? '; read x <&2
10                        then
11                              case $x
12                                 in [yYjJ]*)  echo "$arg"
13                                 esac
14                        else
15                               echo
16                               exit 0
17                        fi
18                      done
19                      exit 0
20              esac
21      esac
22      
23      for arg
24      do      prompt >&2 "$arg" '? '; read x <&2
25              case $x
26              in [yYjJ]*)     echo "$arg"
27              esac
28      done
29      exit 0

Mit einer Funktion ist das besser strukturiert:

 1      #!/bin/sh
 2      
 3      c=`echo '\c'`; n=; : ${c:+${n:=-n}}; c=; : ${n:-${c:=\\c}}
 4      
 5      pick() { # arg ...
 6              if echo >&2 $n "$1 ? "$c; read x <&2
 7              then    case $x
 8                      in [yYjJ]*)     echo "$1"
 9                      esac
10              else    echo
11                      exit 0
12              fi
13      }
14      
15      case $#
16      in 0)   exit 0
17      ;; 1)   case "$1"
18              in -)   while read arg
19                      do      pick "$arg"
20                      done
21                      exit 0
22              esac
23      esac
24      
25      for arg
26      do      pick "$arg"
27      done
28      exit 0

bundle verpackt Textdateien so als Shell-Skript, daß sie am Ziel durch Ausführen des Shell-Skripts wiederhergestellt werden können:

Last modified 03/July/97