Oto mniej więcej fragment, który chcesz. Pozwól, że dowiem się, jak przekazać argumenty.

read -p "Are you sure you want to continue? <y/N> " prompt
if [[ $prompt == "y" || $prompt == "Y" || $prompt == "yes" || $prompt == "Yes" ]]
then
  # http://stackoverflow.com/questions/1537673/how-do-i-forward-parameters-to-other-command-in-bash-script
else
  exit 0
fi

Uważaj na yes | command name here :)

Aby uniknąć jawnego sprawdzania tych wariantów 'yes', możesz użyć operatora wyrażenia regularnego bash '= ~ ' z wyrażeniem regularnym:

read -p "Are you sure you want to continue? <y/N> " prompt
if [[ $prompt =~ [yY](es)* ]]
then
(etc...)

Sprawdza, czy dane wejściowe użytkownika zaczynają się od "y" lub "Y", a po nich następuje zero lub więcej "es".

Potwierdzenia można łatwo ominąć zwrotami karetki i uważam, że przydatne jest ciągłe pytanie o poprawne dane wejściowe.

Oto funkcja, która to ułatwi. "invalid input" pojawi się na czerwono, jeśli Y / N nie zostanie odebrane, a użytkownik zostanie ponownie poproszony.

prompt_confirm() {
  while true; do
    read -r -n 1 -p "${1:-Continue?} [y/n]: " REPLY
    case $REPLY in
      [yY]) echo ; return 0 ;;
      [nN]) echo ; return 1 ;;
      *) printf " \033[31m %s \n\033[0m" "invalid input"
    esac 
  done  
}

# example usage
prompt_confirm "Overwrite File?" || exit 0

Możesz zmienić domyślny znak zachęty przekazując argument

To może być hack:

Jak w pytaniu W Unix / Bash, czy "xargs-p "jest dobrym sposobem na poproszenie o potwierdzenie przed uruchomieniem jakiejkolwiek komendy?

Możemy użyć xargs do wykonania zadania:

echo ssh://[email protected]//somepath/morepath | xargs -p hg push

Oczywiście będzie to ustawione jako alias, jak hgpushrepo

Przykład:

$ echo foo | xargs -p ls -l
ls -l foo?...y
-rw-r--r--  1 mikelee    staff  0 Nov 23 10:38 foo

$ echo foo | xargs -p ls -l
ls -l foo?...n

$

Dodaj następujący plik do pliku/etc / bashrc. Skrypt ten dodaje rezydentną " funkcję "zamiast aliasu o nazwie"confirm".

function confirm( )
{
#alert the user what they are about to do.
echo "About to $@....";
#confirm with the user
read -r -p "Are you sure? [Y/n]" response
case "$response" in
    [yY][eE][sS]|[yY]) 
              #if yes, then execute the passed parameters
               "$@"
               ;;
    *)
              #Otherwise exit...
              echo "ciao..."
              exit
              ;;
esac
}

read -r -p "Are you sure? [Y/n]" response
  response=${response,,} # tolower
  if [[ $response =~ ^(yes|y| ) ]] || [[ -z $response ]]; then
      your-action-here
  fi

Oto moja wersja confirm, zmodyfikowana z wersji Jamesa:

function confirm() {
  local response msg="${1:-Are you sure} (y/[n])? "; shift
  read -r $* -p "$msg" response || echo
  case "$response" in
  [yY][eE][sS]|[yY]) return 0 ;;
  *) return 1 ;;
  esac
}

Te zmiany to:

1. użyj local, aby zapobiec kolizji nazw zmiennych
2. read Użyj $2 $3 ... do kontrolowania jego działania, więc możesz używać -n i -t
3. jeśli read wyjdzie bezskutecznie, echo linia dla urody
4. mój Git on Windows ma tylko bash-3.1 i nie ma true ani false, więc zamiast tego użyj return. Oczywiście jest to również zgodne z bash - 4.4 (obecną w Git Dla Windows).
5. użyj stylu IPython " (y / [n])", aby wyraźnie wskazać, że "n" jest domyślne.

Późno do gry, ale stworzyłem kolejny wariant confirm funkcji poprzednich odpowiedzi:

confirm ()
{
    read -r -p "$(echo $@) ? [y/N] " YESNO

    if [ "$YESNO" != "y" ]; then
        echo >&2 "Aborting"
        exit 1
    fi

    CMD="$1"
    shift

    while [ -n "$1" ]; do
        echo -en "$1\0"
        shift
    done | xargs -0 "$CMD" || exit $?
}

Aby go użyć:

confirm your_command

Cechy:

• wypisuje Twoje polecenie jako część wiersza
• przekazuje argumenty za pomocą ogranicznika NULL
• zachowuje stan wyjścia polecenia

Błędy:

• echo -en działa z bash ale może zawieść w Twojej powłoce
• może się nie udać, jeśli argumenty przeszkadzają echo lub xargs
• milion innych błędów, ponieważ skrypty powłoki są trudne

Try,

 #!/bin/bash
 pause ()
 {
 REPLY=Y
 while [ "$REPLY" == "Y" ] || [ "$REPLY" != "y" ]
 do
  echo -e "\t\tPress 'y' to continue\t\t\tPress 'n' to quit"
  read -n1 -s
      case "$REPLY" in
      "n")  exit                      ;;
      "N")  echo "case sensitive!!"   ;; 
      "y")  clear                     ;;
      "Y")  echo "case sensitive!!"   ;;
      * )  echo "$REPLY is Invalid Option"     ;;
 esac
 done
 }
 pause
 echo "Hi"

Nie jest wymagane naciśnięcie klawisza enter

• zwraca 0=Tak i 1 = Nie
• nie jest wymagane naciśnięcie klawisza enter - tylko jeden znak
• można nacisnąć enter , aby zaakceptować domyślny wybór
Można wyłączyć domyślny wybór, aby wymusić wybór]}
• Działa zarówno dla zsh jak i bash.

Domyślnie " nie " po naciśnięciu enter

Zauważ, że N jest pisana wielkimi literami. Tutaj wciśnięty jest enter, akceptując domyślne:

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

Zauważ również, że [y/N]? została automatycznie dołączona. Domyślne " nie " jest akceptowane, więc nic nie jest echem.

Re-prompt dopóki nie zostanie podana prawidłowa odpowiedź:

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

Domyślnie " tak " po naciśnięciu enter

Zauważ, że Y jest pisane wielkimi literami:

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

Powyżej, po prostu wcisnąłem enter, więc Komenda uruchomiła się.

No default on enter - require y or n

$ get_yes_keypress "Here you cannot press enter. Do you like this"
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

Tutaj, 1 lub false został zwrócony. Uwaga brak kapitalizacji w [y/n]?

Kod

# 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=$2
# Prompt using $1.
# If set, return $2 on pressing enter, useful for cancel or defualting
function get_yes_keypress {
  local prompt="${1:-Are you sure} [y/n]? "
  local enter_return=$2
  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
}

To nie jest dokładnie "Prośba o tak lub nie", ale tylko hack: alias hg push ... nie do hgpushrepo, ale do hgpushrepoconfirmedpush i zanim będę mógł przeliterować całą sprawę, lewy mózg dokonał logicznego wyboru.

Nie to samo, ale pomysł, który i tak działa.

#!/bin/bash  
i='y'  
while [ ${i:0:1} != n ]  
do  
    # Command(s)  
    read -p " Again? Y/n " i  
    [[ ${#i} -eq 0 ]] && i='y'  
done  

Wyjście:
Znowu? Y / n n
Znowu? Y / N Anything
Znowu? Y / n 7
Znowu? Y / n &
Znowu? Y / n nsijf
$

Teraz sprawdza tylko 1 znak $I read.

Poniższy kod łączy dwie rzeczy

1. Shopt - s nocasematch, który zajmie się case niewrażliwe

2. I jeśli warunek, który będzie akceptował oba dane wejściowe, albo przechodzisz Tak,Tak,Tak, y.

   Shopt-s nocasematch

   Jeżeli [[ sed-4.2.2.$LINE = ~(yes|y)$]]

   Then exit 0

   Fi

Oto moje rozwiązanie, które za pomocą zlokalizowanych regex. Więc w języku niemieckim również "j" Dla " Ja " byłoby interpretowane jako tak.

Pierwszym argumentem jest pytanie, jeśli drugim argumentem jest "y", to tak będzie domyślną odpowiedzią, w przeciwnym razie nie będzie domyślną odpowiedzią. Zwracaną wartością jest 0, jeśli odpowiedź brzmi "tak" i 1, jeśli odpowiedź brzmi "nie".

function shure(){
    if [ $# -gt 1 ] && [[ "$2" =~ ^[yY]*$ ]] ; then
        arg="[Y/n]"
        reg=$(locale noexpr)
        default=(0 1)
    else
        arg="[y/N]"
        reg=$(locale yesexpr)
        default=(1 0)
    fi
    read -p "$1 ${arg}? : " answer
    [[ "$answer" =~ $reg ]] && return ${default[1]} || return ${default[0]}
}

Oto podstawowe użycie

# basic example default is no
shure "question message" && echo "answer yes" || echo "answer no"
# print "question message [y/N]? : "

# basic example default set to yes
shure "question message" y && echo "answer yes" || echo "answer no"
# print "question message [Y/n]? : "

To może być trochę za krótkie, ale dla mojego prywatnego użytku, to działa świetnie

read -n 1 -p "Push master upstream? [Y/n] " reply; 
if [ "$reply" != "" ]; then echo; fi
if [ "$reply" != "n" ]; then
    git push upstream master
fi

read -n 1 odczytuje tylko jeden znak. Jeśli nie jest małą literą "n", zakłada się, że jest "Y".

(jeśli chodzi o prawdziwe pytanie: stwórz skrypt bash i zmień alias, aby wskazywał na ten skrypt zamiast tego, co było wskazywane wcześniej)