au moins cinq réponses à une question générique.

selon

• posix conforme: pourrait fonctionner sur les systèmes pauvres avec Générique "shell environnements
• bash spécifique: l'utilisation de soi-disant bashisms

et si vous voulez

• simple `en ligne" question / réponse (solutions génériques)
• jolies interfaces formatées, comme ncurses ou plus graphique en utilisant libgtk ou libqt...
• utiliser la puissante capacité de lecture de l'histoire

1. POSIX generic solutions

vous pouvez utiliser la commande read , suivie de if ... then ... else :

echo -n "Is this a good question (y/n)? "
read answer

# if echo "$answer" | grep -iq "^y" ;then

if [ "$answer" != "${answer#[Yy]}" ] ;then
    echo Yes
else
    echo No
fi

(merci à commentaire D'Adam Katz : remplacé le test ci-dessus par un qui est plus portable et évite une fourche:)

POSIX, mais une seule touche de fonction

mais si vous ne voulez pas que l'utilisateur doit appuyer sur retour , vous pouvez écrire:

( Edited: comme @JonathanLeffler le suggère à juste titre, sauver la configuration de stty pourrait être mieux que de simplement les forcer à sane .)

echo -n "Is this a good question (y/n)? "
old_stty_cfg=$(stty -g)
stty raw -echo ; answer=$(head -c 1) ; stty $old_stty_cfg # Careful playing with stty
if echo "$answer" | grep -iq "^y" ;then
    echo Yes
else
    echo No
fi

Note: ceci a été testé sous sh , bash , ksh , dash et busybox !

même chose, mais attente explicite pour y ou n :

#/bin/sh
echo -n "Is this a good question (y/n)? "
old_stty_cfg=$(stty -g)
stty raw -echo
answer=$( while ! head -c 1 | grep -i '[ny]' ;do true ;done )
stty $old_stty_cfg
if echo "$answer" | grep -iq "^y" ;then
    echo Yes
else
    echo No
fi

à l'Aide d'outils dédiés

Il ya beaucoup d'outils qui ont été construits à l'aide libncurses , libgtk , libqt ou d'autres bibliothèques graphiques. Par exemple, en utilisant whiptail :

if whiptail --yesno "Is this a good question" 20 60 ;then
    echo Yes
else
    echo No
fi

selon votre système, vous devrez peut-être remplacer whiptail par un autre outil similaire:

dialog --yesno "Is this a good question" 20 60 && echo Yes

gdialog --yesno "Is this a good question" 20 60 && echo Yes

kdialog --yesno "Is this a good question" 20 60 && echo Yes

où 20 est la hauteur de la boîte de dialogue en nombre de lignes et 60 est la largeur de la boîte de dialogue. Ces outils ont tous la syntaxe proche de la même .

DIALOG=whiptail
if [ -x /usr/bin/gdialog ] ;then DIALOG=gdialog ; fi
if [ -x /usr/bin/xdialog ] ;then DIALOG=xdialog ; fi
...
$DIALOG --yesno ...

2. Bash solutions spécifiques

méthode de base dans la ligne méthode

read -p "Is this a good question (y/n)? " answer
case ${answer:0:1} in
    y|Y )
        echo Yes
    ;;
    * )
        echo No
    ;;
esac

je préfère utiliser case donc je pourrais même tester pour yes | ja | si | oui si nécessaire...

en ligne avec clé unique fonctionnalité

sous bash, nous pouvons spécifier la longueur d'entrée prévue pour la commande read :

read -n 1 -p "Is this a good question (y/n)? " answer

Sous bash, read commande accepte un timeout paramètre, ce qui pourrait être utile.

read -t 3 -n 1 -p "Is this a good question (y/n)? " answer
[ -z "$answer" ] && answer="Yes"  # if 'yes' have to be default choice

quelques astuces pour outils dédiés

boîtes de dialogue plus sophistiquées, au-delà de simple yes - no buts:

dialog --menu "Is this a good question" 20 60 12 y Yes n No m Maybe

de la barre de Progression:

dialog --gauge "Filling the tank" 20 60 0 < <(
    for i in {1..100};do
        printf "XXX\n%d\n%(%a %b %T)T progress: %d\nXXX\n" $i -1 $i
        sleep .033
    done
) 

petite démo:

#!/bin/sh
while true ;do
    [ -x "$(which ${DIALOG%% *})" ] || DIALOG=dialog
    DIALOG=$($DIALOG --menu "Which tool for next run?" 20 60 12 2>&1 \
            whiptail       "dialog boxes from shell scripts" >/dev/tty \
            dialog         "dialog boxes from shell with ncurses" \
            gdialog        "dialog boxes from shell with Gtk" \
            kdialog        "dialog boxes from shell with Kde" ) || exit
    clear;echo "Choosed: $DIALOG."
    for i in `seq 1 100`;do
        date +"`printf "XXX\n%d\n%%a %%b %%T progress: %d\nXXX\n" $i $i`"
        sleep .0125
      done | $DIALOG --gauge "Filling the tank" 20 60 0
    $DIALOG --infobox "This is a simple info box\n\nNo action required" 20 60
    sleep 3
    if $DIALOG --yesno  "Do you like this demo?" 20 60 ;then
        AnsYesNo=Yes; else AnsYesNo=No; fi
    AnsInput=$($DIALOG --inputbox "A text:" 20 60 "Text here..." 2>&1 >/dev/tty)
    AnsPass=$($DIALOG --passwordbox "A secret:" 20 60 "First..." 2>&1 >/dev/tty)
    $DIALOG --textbox /etc/motd 20 60
    AnsCkLst=$($DIALOG --checklist "Check some..." 20 60 12 \
        Correct "This demo is useful"        off \
        Fun        "This demo is nice"        off \
        Strong        "This demo is complex"        on 2>&1 >/dev/tty)
    AnsRadio=$($DIALOG --radiolist "I will:" 20 60 12 \
        " -1" "Downgrade this answer"        off \
        "  0" "Not do anything"                on \
        " +1" "Upgrade this anser"        off 2>&1 >/dev/tty)
    out="Your answers:\nLike: $AnsYesNo\nInput: $AnsInput\nSecret: $AnsPass"
    $DIALOG --msgbox "$out\nAttribs: $AnsCkLst\nNote: $AnsRadio" 20 60
  done

plus d'échantillon? Jetez un oeil à en utilisant whiptail pour le choix du périphérique USB et USB amovible storage selector: USBKeyChooser

5. Utiliser readline l'histoire de la

exemple:

#!/bin/bash

set -i
HISTFILE=~/.myscript.history
history -c
history -r

myread() {
    read -e -p '> ' 
    history -s ${!1}
}
trap 'history -a;exit' 0 1 2 3 6

while myread line;do
    case ${line%% *} in
        exit )  break ;;
        *    )  echo "Doing something with '$line'" ;;
      esac
  done

cela créera un fichier .myscript.history dans votre répertoire $HOME , que vous pourriez utiliser les commandes d'histoire de readline, comme Up , Down , Ctrl + r et d'autres.

echo "Please enter some input: "
read input_variable
echo "You entered: $input_variable"

vous pouvez utiliser la commande intégrée read ; utilisez l'option -p pour poser une question à l'utilisateur.

depuis BASH4, vous pouvez maintenant utiliser -i pour suggérer une réponse, de sorte que l'utilisateur n'a qu'à appuyer sur return pour l'entrer:

read -e -p "Enter the path to the file: " -i "/usr/local/etc/" FILEPATH
echo $FILEPATH

(mais n'oubliez pas d'utiliser l'option "readline" -e pour permettre l'édition de ligne avec les touches fléchées)

si vous voulez une logique "oui / non", vous pouvez faire quelque chose comme ceci:

read -e -p "
List the content of your home dir ? [Y/n] " YN

[[ $YN == "y" || $YN == "Y" || $YN == "" ]] && ls -la ~/

Bash a sélectionner à cette fin.

select result in Yes No Cancel
do
    echo $result
done

read -p "Are you alright? (y/n) " RESP
if [ "$RESP" = "y" ]; then
  echo "Glad to hear it"
else
  echo "You need more bash programming"
fi

voici quelque chose que j'ai rassemblé:

#!/bin/sh

promptyn () {
    while true; do
        read -p " " yn
        case $yn in
            [Yy]* ) return 0;;
            [Nn]* ) return 1;;
            * ) echo "Please answer yes or no.";;
        esac
    done
}

if promptyn "is the sky blue?"; then
    echo "yes"
else
    echo "no"
fi

je suis débutant, alors prenez ça avec un grain de sel, mais ça a l'air de marcher.

inquire ()  {
  echo  -n " [y/n]? "
  read answer
  finish="-1"
  while [ "$finish" = '-1' ]
  do
    finish="1"
    if [ "$answer" = '' ];
    then
      answer=""
    else
      case $answer in
        y | Y | yes | YES ) answer="y";;
        n | N | no | NO ) answer="n";;
        *) finish="-1";
           echo -n 'Invalid response -- please reenter:';
           read answer;;
       esac
    fi
  done
}

... other stuff

inquire "Install now?"

...

Vous voulez:

• Bash builtin command (i.e. portable)
• Vérifier ATS
• par Défaut, la réponse
• Timeout
• question de couleur

Extrait de

do_xxxx=y                      # In batch mode => Default is Yes
[[ -t 0 ]] &&                  # If TTY => Prompt the question
read -n 1 -p $'\e[1;32m
Do xxxx? (Y/n)\e[0m ' do_xxxx  # Store the answer in $do_xxxx
if [[ $do_xxxx =~ ^(y|Y|)$ ]]  # Do if 'y' or 'Y' or empty
then
    xxxx
fi

explications

• [[ -t 0 ]] && read ... => commande d'appel read if TTY
• read -n 1 = > attendre un caractère
• $'\e[1;32m ... \e[0m ' = > imprimer en vert
  
  (le vert est bien parce que lisible sur les deux blanc/fond noir)
• [[ $do_xxxx =~ ^(y|Y|)$ ]] = > bash regex

Timeout => par Défaut, la réponse est Non

do_xxxx=y
[[ -t 0 ]] && {                   # Timeout 5 seconds (read -t 5)
read -t 5 -n 1 -p $'\e[1;32m
Do xxxx? (Y/n)\e[0m ' do_xxxx ||  # read 'fails' on timeout
do_xxxx=n ; }                     # Timeout => answer No
if [[ $do_xxxx =~ ^(y|Y|)$ ]]
then
    xxxx
fi

la façon la plus facile d'y parvenir avec le moins de lignes est la suivante:

read -p "<Your Friendly Message here> : y/n/cancel" CONDITION;

if [ "$CONDITION" == "y" ]; then
   # do something here!
fi

le if n'est qu'un exemple: c'est à vous de gérer cette variable.

utilisez la commande read :

echo Would you like to install? "(Y or N)"

read x

# now check if $x is "y"
if [ "$x" = "y" ]; then
    # do something here!
fi

et puis tous les autres trucs que vous devez

cette solution lit un seul caractère et appelle une fonction sur une réponse oui.

read -p "Are you sure? (y/n) " -n 1
echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
    do_something      
fi

read -e -p "Enter your choice: " choice

l'option -e permet à l'utilisateur d'éditer la saisie à l'aide de touches fléchées.

si vous voulez utiliser une suggestion comme entrée:

read -e -i "yes" -p "Enter your choice: " choice

-i l'option affiche une entrée suggestive.

Désolé d'avoir posté sur un poste aussi ancien. Il y a quelques semaines, je faisais face à un problème similaire, dans mon cas, j'avais besoin d'une solution qui a également fonctionné dans un installateur-script en ligne, par exemple: curl -Ss https://raw.github.com/_____/installer.sh | bash

en utilisant read yesno < /dev/tty fonctionne très bien pour moi:

echo -n "These files will be uploaded. Is this ok? (y/n) "
read yesno < /dev/tty

if [ "x$yesno" = "xy" ];then

   # Yes
else

   # No
fi

J'espère que ça aidera quelqu'un.

pour obtenir une entrée de type ncurses, utilisez la commande dialog comme ceci:

#!/bin/bash
if (dialog --title "Message" --yesno "Want to do something risky?" 6 25)
# message box will have the size 25x6 characters
then 
    echo "Let's do something risky"
    # do something risky
else 
    echo "Let's stay boring"
fi

le paquet de dialogue est installé par défaut au moins avec SUSE Linux.

version à choix Multiple:

ask () {                        # =question =options
    # set REPLY
    # options: x=..|y=..
    while $(true); do
        printf '%s [%s] ' "" ""
        stty cbreak
        REPLY=$(dd if=/dev/tty bs=1 count=1 2> /dev/null)
        stty -cbreak
        test "$REPLY" != "$(printf '\n')" && printf '\n'
        (
            IFS='|'
            for o in ; do
                if [ "$REPLY" = "${o%%=*}" ]; then
                    printf '\n'
                    break
                fi
            done
        ) | grep ^ > /dev/null && return
    done
}

exemple:

$ ask 'continue?' 'y=yes|n=no|m=maybe'
continue? [y=yes|n=no|m=maybe] g
continue? [y=yes|n=no|m=maybe] k
continue? [y=yes|n=no|m=maybe] y
$

il positionnera REPLY à y (dans le script).

inspiré par les réponses de @Mark et @Myrddin j'ai créé cette fonction pour une invite universelle

uniprompt(){
    while true; do
        echo -e "\c"
        read opt
        array=()
        case "${array[@]}" in  *"$opt"*) eval "=$opt";return 0;; esac
        echo -e "$opt is not a correct value\n"
    done
}

utilisez - le comme ceci:

unipromtp "Select an option: (a)-Do one (x)->Do two (f)->Do three : " "a x f" selection
echo "$selection"

je vous conseille utiliser la boîte de dialogue ...

Linux Apprenti: Améliorer Bash Shell Scripts À L'Aide De Boîte De Dialogue

la commande dialog permet l'utilisation de boîtes de fenêtre dans des scripts shell pour rendre leur utilisation plus interactive.

c'est simple et facile à utiliser, il y a aussi une version gnome appelée gdialog qui prend les mêmes paramètres exacts, mais le montre GUI style sur X.

une façon simple de faire cela est avec xargs -p ou gnu parallel --interactive .

j'aime un peu mieux le comportement de xargs pour cela car il exécute chaque commande immédiatement après l'invite comme d'autres commandes unix interactives, plutôt que de collecter les yesses pour les exécuter à la fin. (Vous pouvez Ctrl-C Après que vous obtenez à travers ceux que vous vouliez.)

par exemple,

echo *.xml | xargs -p -n 1 -J {} mv {} backup/

plus générique serait:

function menu(){
    title="Question time"
    prompt="Select:"
    options=("Yes" "No" "Maybe")
    echo "$title"
    PS3="$prompt"
    select opt in "${options[@]}" "Quit/Cancel"; do
        case "$REPLY" in
            1 ) echo "You picked $opt which is option $REPLY";;
            2 ) echo "You picked $opt which is option $REPLY";;
            3 ) echo "You picked $opt which is option $REPLY";;
            $(( ${#options[@]}+1 )) ) clear; echo "Goodbye!"; exit;;
            *) echo "Invalid option. Try another one.";continue;;
         esac
     done
     return
}

Simple pression de touche seulement

Voici une approche plus longue, mais réutilisable et modulaire:

• Renvoie 0 =oui et 1 =pas de
• pas de pression entrée requise - un seul caractère
• peut appuyer sur entrer pour accepter le choix par défaut
• peut désactiver le choix par défaut pour forcer une sélection
• Works pour zsh et bash .

défaut à "non" en appuyant sur Entrée

notez que le N est capitalisé. Ici enter est pressé, en acceptant la valeur par défaut:

$ confirm "Show dangerous command" && echo "rm *"
Show dangerous command [y/N]?

note également que [y/N]? a été automatiquement ajouté. Le "non" par défaut est accepté, donc rien n'est repris.

Re-invite jusqu'à ce qu'une réponse valide est donné:

$ confirm "Show dangerous command" && echo "rm *"
Show dangerous command [y/N]? X
Show dangerous command [y/N]? y
rm *

défaut à "Oui" en appuyant sur Entrée

notez que le Y est capitalisé:

$ confirm_yes "Show dangerous command" && echo "rm *"
Show dangerous command [Y/n]?
rm *

ci-dessus, j'ai juste appuyé sur Entrée, donc la commande a couru.

Pas de défaut sur entrée - besoin de y ou n

$ get_yes_keypress "Here you cannot press enter. Do you like this [y/n]? "
Here you cannot press enter. Do you like this [y/n]? k
Here you cannot press enter. Do you like this [y/n]?
Here you cannot press enter. Do you like this [y/n]? n
$ echo $?
1

Ici, 1 ou false est retourné. Notez qu'avec cette fonction de niveau inférieur vous devrez fournir votre propre invite [y/n]? .

Code

# Read a single char from /dev/tty, prompting with "$*"
# Note: pressing enter will return a null string. Perhaps a version terminated with X and then remove it in caller?
# See https://unix.stackexchange.com/a/367880/143394 for dealing with multi-byte, etc.
function get_keypress {
  local REPLY IFS=
  >/dev/tty printf '%s' "$*"
  [[ $ZSH_VERSION ]] && read -rk1  # Use -u0 to read from STDIN
  # See https://unix.stackexchange.com/q/383197/143394 regarding '\n' -> ''
  [[ $BASH_VERSION ]] && </dev/tty read -rn1
  printf '%s' "$REPLY"
}

# Get a y/n from the user, return yes=0, no=1 enter=
# Prompt using .
# If set, return  on pressing enter, useful for cancel or defualting
function get_yes_keypress {
  local prompt="${1:-Are you sure [y/n]? }"
  local enter_return=
  local REPLY
  # [[ ! $prompt ]] && prompt="[y/n]? "
  while REPLY=$(get_keypress "$prompt"); do
    [[ $REPLY ]] && printf '\n' # $REPLY blank if user presses enter
    case "$REPLY" in
      Y|y)  return 0;;
      N|n)  return 1;;
      '')   [[ $enter_return ]] && return "$enter_return"
    esac
  done
}

# Credit: http://unix.stackexchange.com/a/14444/143394
# Prompt to confirm, defaulting to NO on <enter>
# Usage: confirm "Dangerous. Are you sure?" && rm *
function confirm {
  local prompt="${*:-Are you sure} [y/N]? "
  get_yes_keypress "$prompt" 1
}    

# Prompt to confirm, defaulting to YES on <enter>
function confirm_yes {
  local prompt="${*:-Are you sure} [Y/n]? "
  get_yes_keypress "$prompt" 0
}

yn() {
  if [[ 'y' == `read -s -n 1 -p "[y/n]: " Y; echo $Y` ]];
  then eval ;
  else eval ;
  fi }
yn 'echo yes' 'echo no'
yn 'echo absent no function works too!'

en tant qu'ami d'une commande d'une ligne j'ai utilisé ce qui suit:

while [ -z $prompt ]; do read -p "Continue (y/n)?" choice;case "$choice" in y|Y ) prompt=true; break;; n|N ) exit 0;; esac; done; prompt=;

écrit longform, il fonctionne comme ceci:

while [ -z $prompt ];
  do read -p "Continue (y/n)?" choice;
  case "$choice" in
    y|Y ) prompt=true; break;;
    n|N ) exit 0;;
  esac;
done;
prompt=;

j'ai utilisé la déclaration case plusieurs fois dans un tel scénario, l'utilisation de la déclaration de cas est une bonne façon de procéder. Une boucle while , qui écapsule le bloc case , qui utilise une condition booléenne peut être mise en œuvre afin de tenir encore plus de contrôle du programme, et remplir de nombreuses autres exigences. Après que toutes les conditions ont été remplies, un break peut être utilisé qui passera la commande de nouveau à la partie principale du programme. Aussi, pour répondre à d'autres conditions, bien sûr des déclarations conditionnelles peuvent être ajoutées pour accompagner les structures de contrôle: case déclaration et possible while boucle.

exemple d'utilisation d'une déclaration case pour répondre à votre demande

#! /bin/sh 

# For potential users of BSD, or other systems who do not
# have a bash binary located in /bin the script will be directed to
# a bourne-shell, e.g. /bin/sh

# NOTE: It would seem best for handling user entry errors or
# exceptions, to put the decision required by the input 
# of the prompt in a case statement (case control structure), 

echo Would you like us to perform the option: "(Y|N)"

read inPut

case $inPut in
    # echoing a command encapsulated by 
    # backticks (``) executes the command
    "Y") echo `Do something crazy`
    ;;
    # depending on the scenario, execute the other option
    # or leave as default
    "N") echo `execute another option`
    ;;
esac

exit

j'ai remarqué que personne n'a posté de réponse montrant le menu d'écho multi-ligne pour une entrée d'utilisateur aussi simple donc voici mon go à elle:

#!/bin/bash

function ask_user() {    

echo -e "
#~~~~~~~~~~~~#
| 1.) Yes    |
| 2.) No     |
| 3.) Quit   |
#~~~~~~~~~~~~#\n"

read -e -p "Select 1: " choice

if [ "$choice" == "1" ]; then

    do_something

elif [ "$choice" == "2" ]; then

    do_something_else

elif [ "$choice" == "3" ]; then

    clear && exit 0

else

    echo "Please select 1, 2, or 3." && sleep 3
    clear && ask_user

fi
}

ask_user

cette méthode a été affichée dans l'espoir que quelqu'un puisse la trouver utile et économe de temps.

Oui / Non / Annuler

fonction

#!/usr/bin/env bash
@confirm() {
  local message="$*"
  local result=''

  echo -n "> $message (Yes/No/Cancel) " >&2

  while [ -z "$result" ] ; do
    read -s -n 1 choice
    case "$choice" in
      y|Y ) result='Y' ;;
      n|N ) result='N' ;;
      c|C ) result='C' ;;
    esac
  done

  echo $result
}

Utilisation

case $(@confirm 'Confirm?') in
  Y ) echo "Yes" ;;
  N ) echo "No" ;;
  C ) echo "Cancel" ;;
esac

confirmer avec l'entrée de l'utilisateur propre

fonction

#!/usr/bin/env bash
@confirm() {
  local message="$*"
  local result=3

  echo -n "> $message (y/n) " >&2

  while [[ $result -gt 1 ]] ; do
    read -s -n 1 choice
    case "$choice" in
      y|Y ) result=0 ;;
      n|N ) result=1 ;;
    esac
  done

  return $result
}

Utilisation

if @confirm 'Confirm?' ; then
  echo "Yes"
else
  echo "No"
fi

en réponse à d'autres:

vous n'avez pas besoin de spécifier le cas dans BASH4 utilisez simplement le ',,' pour faire un Var en minuscules. En outre, je n'aime pas mettre le code à l'intérieur du bloc de lecture, obtenir le résultat et traiter avec elle à l'extérieur du bloc de lecture IMO. Inclure également un " q " pour quitter IMO. Enfin, pourquoi taper " oui " en utilisant-n1 et appuyez sur Y.

exemple: l'utilisateur peut appuyer sur y / n et aussi q pour simplement quitter.

ans=''
while true; do
    read -p "So is MikeQ the greatest or what (y/n/q) ?" -n1 ans
    case ${ans,,} in
        y|n|q) break;;
        *) echo "Answer y for yes / n for no  or q for quit.";;
    esac
done

echo -e "\nAnswer = $ans"

if [[ "${ans,,}" == "q" ]] ; then
        echo "OK Quitting, we will assume that he is"
        exit 0
fi

if [[ "${ans,,}" == "y" ]] ; then
        echo "MikeQ is the greatest!!"
else
        echo "No? MikeQ is not the greatest?"
fi