මට ෂෙල් ස්ක්‍රිප්ට් එකක ආදානය විරාමයක් ගැනීමට අවශ්‍ය වන අතර තේරීම් සඳහා පරිශීලකයාගෙන් විමසන්න.
සම්මත Yes, Noහෝ Cancelවර්ගය ප්‍රශ්නය.
සාමාන්‍ය බාෂ් විමසුමක් තුළ මෙය සිදු කරන්නේ කෙසේද?

ෂෙල් විමසුමේදී පරිශීලක ආදානය ලබා ගැනීම සඳහා ඇති සරලම හා වඩාත්ම පුළුල් ක්‍රමය වන්නේ readවිධානයයි. එහි භාවිතය නිදර්ශනය කිරීමට හොඳම ක්‍රමය සරල නිරූපණයකි:

while true; do
    read -p "Do you wish to install this program?" yn
    case $yn in
        [Yy]* ) make install; break;;
        [Nn]* ) exit;;
        * ) echo "Please answer yes or no.";;
    esac
done

ස්ටීවන් හුවිග් විසින් පෙන්වා දෙන තවත් ක්‍රමයක් වන්නේ බාෂ්ගේ අණයිselect . භාවිතා කරන එකම උදාහරණය මෙන්න select:

echo "Do you wish to install this program?"
select yn in "Yes" "No"; do
    case $yn in
        Yes ) make install; break;;
        No ) exit;;
    esac
done

සමග selectආදාන sanitize කිරීමට අවශ්ය නැහැ - එය ලබා ගත හැකි තෝරා ගැනීම් ප්රදර්ශණය කරන අතර, ඔබ තෝරා අනුරූප ගණනාවක් ටයිප් කරන්න. එය ස්වයංක්‍රීයව ලූප වේ, එබැවින් while trueඔවුන් අවලංගු ආදානයක් ලබා දෙන්නේ නම් නැවත උත්සාහ කිරීමට ලූපයක් අවශ්‍ය නොවේ.

එසේම, ලියා ග්‍රිස් ඇගේ පිළිතුරෙන් ඉල්ලීම් භාෂාව අ nost ෙයවාදියා බවට පත් කිරීමේ ක්‍රමයක් පෙන්නුම් කළේය . බහුවිධ භාෂාවන්ට වඩා හොඳ සේවාවක් සැපයීම සඳහා මගේ පළමු උදාහරණය අනුවර්තනය කිරීම මේ වගේ විය හැකිය:

set -- $(locale LC_MESSAGES)
yesptrn="$1"; noptrn="$2"; yesword="$3"; noword="$4"

while true; do
    read -p "Install (${yesword} / ${noword})? " yn
    case $yn in
        ${yesptrn##^} ) make install; break;;
        ${noptrn##^} ) exit;;
        * ) echo "Answer ${yesword} / ${noword}.";;
    esac
done

නිසැකවම වෙනත් සන්නිවේදන නූල් මෙහි පරිවර්තනය කර නොමැත (ස්ථාපනය කරන්න, පිළිතුරු දෙන්න) එය වඩාත් සම්පුර්ණ කරන ලද පරිවර්තනයකින් ආමන්ත්‍රණය කළ යුතු නමුත් අර්ධ පරිවර්තනයක් පවා බොහෝ අවස්ථාවලදී ප්‍රයෝජනවත් වනු ඇත.

අවසාන වශයෙන්, පරීක්ෂා කරන්න විශිෂ්ට පිළිතුර විසින් එෆ් Hauri .

එක් සාමාන්‍ය ප්‍රශ්නයකට අවම වශයෙන් පිළිතුරු පහක්වත්.

මත පදනම් වෙමින්

• posix අනුකූල: ජනක සමඟ දුර්වල පද්ධති මත වැඩ කළ හැකිය කවචය පරිසරය
• bashවිශේෂිත: ඊනියා bashisms භාවිතා කිරීම

ඔබට අවශ්‍ය නම්

• සරල `` පේළියේ '' ප්‍රශ්නය / පිළිතුර (සාමාන්‍ය විසඳුම්)
• වැනි ලස්සන හැඩතල ගැන්වූ අතුරුමුහුණත් ncurses හෝ ඊට වඩා ග්‍රැෆික් භාවිතා කරමින් libgtk හෝ libqt ...
• ප්‍රබල කියවීම් ඉතිහාස හැකියාව භාවිතා කරන්න

1. පොසික්ස් ජනක විසඳුම්

ඔබට readවිධානය භාවිතා කළ හැකිය , ඉන්පසු 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

( ඇඩම් කැට්ස්ගේ ප්‍රකාශයට ස්තූතියි : ඉහත පරීක්ෂණය වඩා අතේ ගෙන යා හැකි එකක් සමඟ ප්‍රතිස්ථාපනය කර එක් දෙබලක මග හැරේ :)

POSIX, නමුත් තනි යතුරු ලක්ෂණය

නමුත් පරිශීලකයාට පහර දීමට Returnඔබට අවශ්‍ය නැතිනම් ඔබට ලිවිය හැකිය:

( සංස්කරණය: ලෙස @JonathanLeffler දක්වා, යෝජනා ඉතිරි stty ගේ වින්යාස හුදෙක් ඔවුන්ට බල වඩා හොඳ විය හැකි සිහිකල්පනාව .)

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

සටහන: මෙය යටතේ පරීක්ෂා කරන ලදීsh, bash, ksh, ඉර ඉර සහ කාර්යබහුල පෙට්ටිය!

එකම, නමුත් පැහැදිලිවම බලා සිටීම yහෝ 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

කැපවූ මෙවලම් භාවිතා කිරීම

භාවිතා ඉදිකරන ලද බොහෝ මෙවලම් ඇත libncurses, libgtk, libqtහෝ වෙනත් චිත්රක පුස්තකාල. උදාහරණයක් ලෙස, භාවිතා කිරීම whiptail:

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

ඔබේ පද්ධතිය මත පදනම්ව, ඔබට whiptailවෙනත් සමාන මෙවලමක් ආදේශ කිරීමට අවශ්‍ය විය හැකිය :

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

එහිදී 20සංවාද කොටුව උස මාර්ග සංඛ්යාව වන අතර, 60සංවාද කොටුව පළල වේ. මෙම මෙවලම් සියල්ලටම ආසන්න සින්ටැක්ස් ඇත.

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

2. විශේෂිත විසඳුම් බාෂ් කරන්න

රේඛීය ක්‍රමයේ මූලික

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

මම භාවිතා කිරීමට කැමැත්තක් දක්වන caseබැවින් yes | ja | si | ouiඅවශ්‍ය නම් පරීක්ෂා කිරීමට පවා මට හැකිය ...

අනුකූලව සමග තනි ප්රධාන ලක්ෂණය

Bash යටතේ, අපට readවිධානය සඳහා අපේක්ෂිත ආදානයේ දිග නියම කළ හැකිය :

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

Bash යටතේ, readවිධානය කල් ඉකුත් වූ පරාමිතියක් පිළිගනී , එය ප්‍රයෝජනවත් විය හැකිය.

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

3. කැපවූ මෙවලම් සඳහා සමහර උපක්‍රම

සරල yes - noඅරමුණු වලින් ඔබ්බට වඩාත් නවීන සංවාද කොටු :

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

ප්‍රගති තීරුව:

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
) 

පුංචි නිරූපණය:

#!/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

තවත් නියැදියක්? USB උපාංගය සහ USB ඉවත් කළ හැකි ගබඩා තේරීම තෝරා ගැනීම සඳහා විප්ටේල් භාවිතා කිරීම දෙස බලන්න : USBKeyChooser

5. කියවීමේ ඉතිහාසය භාවිතා කිරීම

උදාහරණයක්:

#!/bin/bash

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

myread() {
    read -e -p '> ' $1
    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

මෙම ගොනුව නිර්මාණය කරනු ඇත .myscript.history, ඔබේ $HOMEඔබ readline ඉතිහාසය විධාන, වැනි භාවිතා කළ හැකි වඩා, බහලුම් Up, Down, Ctrl+ rසහ වෙනත් අය.

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

ඔබට ගොඩනංවන ලද කියවීමේ විධානය භාවිතා කළ හැකිය ; -pපරිශීලකයාගෙන් ප්‍රශ්නයක් ඇසීමට විකල්පය භාවිතා කරන්න .

BASH4 සිට, ඔබට දැන් -iපිළිතුරක් යෝජනා කිරීමට භාවිතා කළ හැකිය :

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

(නමුත් -eඊතල යතුරු සමඟ පේළි සංස්කරණයට ඉඩ දීම සඳහා "කියවීම්" විකල්පය භාවිතා කිරීමට මතක තබා ගන්න )

ඔබට "ඔව් / නැත" තර්කනයක් අවශ්‍ය නම්, ඔබට මේ වගේ දෙයක් කළ හැකිය:

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

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

Bash මේ සඳහා තෝරාගෙන ඇත.

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

inquire ()  {
  echo  -n "$1 [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?"

...

මෙන්න මම එකට දැමූ දෙයක්:

#!/bin/sh

promptyn () {
    while true; do
        read -p "$1 " 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

මම ආරම්භකයෙක්, එබැවින් මෙය ලුණු ධාන්ය වර්ගයක් සමඟ ගන්න, නමුත් එය ක්රියා කරන බව පෙනේ.

ඔබට අවශ්‍යයි:

• Bash buildin විධාන (එනම් අතේ ගෙන යා හැකි)
• TTY පරීක්ෂා කරන්න
• පෙරනිමි පිළිතුර
• කාලය හමාරයි
• වර්ණවත් ප්‍රශ්නය

ස්නිපෙට්

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

පැහැදිලි කිරීම්

• [[ -t 0 ]] && read ...=> readTTY නම් ඇමතුම් විධානය
• read -n 1 => එක් අක්ෂරයක් සඳහා රැඳී සිටින්න
• $'\e[1;32m ... \e[0m '=> කොළ පැහැයෙන් මුද්‍රණය කරන්න
  (සුදු / කළු පසුබිම් දෙකෙහිම කියවිය හැකි බැවින් කොළ පැහැය හොඳයි)
• [[ $do_xxxx =~ ^(y|Y|)$ ]] => bash regex

කල් ඉකුත් වීම => පෙරනිමි පිළිතුර නැත

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

අවම පේළි ගණනක් සමඟ මෙය සාක්ෂාත් කර ගැනීමට ඇති පහසුම ක්‍රමය පහත පරිදි වේ:

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

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

මෙම ifපමණක් උදාහරණයක්: මේ විචල්ය කටයුතු කරන ආකාරය ඔබට භාරයි.

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

ඉන්පසු ඔබට අවශ්‍ය අනෙකුත් සියලුම දේ

මෙම විසඳුම තනි අක්ෂරයක් කියවන අතර ඔව් ප්‍රතිචාරයක් මත ශ්‍රිතයක් කැඳවයි.

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

ලස්සන ncurses වැනි ආදාන කොටුවක් ලබා ගැනීම සඳහා විධාන දෙබස් භාවිතා කරන්න :

#!/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

සංවාද පැකේජය පෙරනිමියෙන් අවම වශයෙන් SUSE Linux සමඟ ස්ථාපනය කර ඇත. පෙනේ:

POSIX කවචයක ස්ථාන-දැනුමක් ඇති "ඔව් / තේරීමක් නැත" හැසිරවිය හැකිය; LC_MESSAGESපෙදෙසි කාණ්ඩයේ ඇතුළත් කිරීම් භාවිතා කිරීමෙන් , මායාකාරිය ආදානයකට ගැලපෙන පරිදි සූදානම් කළ රෙජෙක්ස් රටා සහ දේශීයකරණය කළ ඔව් සඳහා නූල් සපයයි.

#!/usr/bin/env sh

# Getting LC_MESSAGES values into variables
# shellcheck disable=SC2046 # Intended IFS splitting
IFS='
' set -- $(locale LC_MESSAGES)

yesexpr="$1"
noexpr="$2"
yesstr="$3"
nostr="$4"
messages_codeset="$5" # unused here, but kept as documentation

# Display Yes / No ? prompt into locale
echo "$yesstr / $nostr ?"

# Read answer
read -r yn

# Test answer
case "$yn" in
# match only work with the character class from the expression
  ${yesexpr##^}) echo "answer $yesstr" ;;
  ${noexpr##^}) echo "answer $nostr" ;;
esac

සංස්කරණය කරන්න: r රික්සිදූර් සිය අදහස් දැක්වීමේදී සඳහන් කළ පරිදි :

අවාසනාවකට මෙන්, POSIX මඟින් නියම කරනුයේ පළමු දෙක පමණි (yesexpr සහ noexpr). උබුන්ටු 16 හි ඔව්ස්ටර් සහ නාස්තිය හිස් ය.

බලන්න: https://www.ee.ryerson.ca/~courses/ele709/susv4/xrat/V4_xbd_chap07.html#tag_21_07_03_06

LC_MESSAGES

මෙම yesstrසහ nostrපෙදෙසි ප්රධාන වචන හා YESSTRහා NOSTRlanginfo භාණ්ඩ කලින් පරිශීලක සොළී හා නිෂේධාත්මක ප්රතිචාර ගැලපෙන භාවිතා කරන ලදී. POSIX.1-2008 දී, yesexpr, noexpr, YESEXPR, සහ NOEXPRදීර්ඝ සාමාන්ය ප්රකාශනයක ඔවුන් විස්ථාපනය කර ඇත. නියැදි අපේක්ෂිත ප්‍රතිචාර ඇතුළත් කඩිනම් පණිවිඩ නිකුත් කිරීම සඳහා යෙදුම් සාමාන්‍ය ස්ථාන පදනම් කරගත් පණිවිඩකරණ පහසුකම් භාවිතා කළ යුතුය.

විකල්පයක් ලෙස ස්ථාන භාවිතා කිරීම බාෂ් ක්‍රමය:

#!/usr/bin/env bash

IFS=$'\n' read -r -d '' yesexpr noexpr _ < <(locale LC_MESSAGES)

printf -v yes_or_no_regex "(%s)|(%s)" "$yesexpr" "$noexpr"

printf -v prompt $"Please answer Yes (%s) or No (%s): " "$yesexpr" "$noexpr"

declare -- answer=;

until [[ "$answer" =~ $yes_or_no_regex ]]; do
  read -rp "$prompt" answer
done

if [[ -n "${BASH_REMATCH[1]}" ]]; then
  echo $"You answered: Yes"
else
  echo $"No, was your answer."
fi

පෙදෙසි පරිසරය විසින් සපයන ලද රීජෙක්ස් භාවිතා කරමින් පිළිතුර ගැලපේ.

ඉතිරි පණිවිඩ පරිවර්තනය කිරීම bash --dump-po-strings scriptnameසඳහා, ප්‍රාදේශීයකරණය සඳහා po නූල් ප්‍රතිදානය කිරීමට භාවිතා කරන්න:

#: scriptname:8
msgid "Please answer Yes (%s) or No (%s): "
msgstr ""
#: scriptname:17
msgid "You answered: Yes"
msgstr ""
#: scriptname:19
msgid "No, was your answer."
msgstr ""

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

මෙම -eවිකල්පය ඊතල සහිත යතුරු භාවිතා කරමින් ආදානය සංස්කරණය කිරීම සඳහා පරිශීලක හැකියාව ලබා දෙයි.

ඔබට යෝජනාවක් ආදානය ලෙස භාවිතා කිරීමට අවශ්‍ය නම්:

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

-i විකල්පය යෝජිත ආදානයක් මුද්‍රණය කරයි.

ඔබට පෙරනිමිය REPLYa readහි භාවිතා කළ හැකිය , සිම්පල් බවට පරිවර්තනය කර ප්‍රකාශනයක් සහිත විචල්‍යයන් සමූහයකට සංසන්දනය කරන්න.
පිටපත ද ja/ si/oui

read -rp "Do you want a demo? [y/n/c] "

[[ ${REPLY,,} =~ ^(c|cancel)$ ]] && { echo "Selected Cancel"; exit 1; }

if [[ ${REPLY,,} =~ ^(y|yes|j|ja|s|si|o|oui)$ ]]; then
   echo "Positive"
fi

තනි යතුරු එබීම පමණි

මෙන්න දිගු, නමුත් නැවත භාවිතා කළ හැකි සහ මොඩියුලර් ප්‍රවේශයකි:

• ප්‍රතිලාභ 0= ඔව් සහ 1= නැත
• එබීම අවශ්‍ය නොවේ - තනි අක්‍ෂරයක් පමණි
• enterපෙරනිමි තේරීම පිළිගැනීමට ඔබන්න
• තේරීමක් බල කිරීම සඳහා පෙරනිමි තේරීම අක්‍රිය කළ හැකිය
• zshසහ දෙකම සඳහා ක්රියා කරයි bash.

Enter එබූ විට "නැත" යන්න පෙරනිමිය

Nකැපිටල් කර ඇති බව සලකන්න . මෙහි පෙරනිමිය පිළිගෙන එන්ටර් එබූ විට:

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

[y/N]?එය ස්වයංක්‍රීයව එකතු වූ බව සලකන්න . සුපුරුදු "නැත" පිළිගනු ලැබේ, එබැවින් කිසිවක් ප්‍රතිරාවය නොවේ.

වලංගු ප්‍රතිචාරයක් ලබා දෙන තුරු නැවත විමසන්න:

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

Enter එබූ විට "ඔව්" ලෙස පෙරනිමිය

Yප්‍රාග්ධනීකරණය කර ඇති බව සලකන්න :

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

ඉහළින්, මම එන්ටර් එබූ නිසා විධානය ක්‍රියාත්මක විය.

පෙරනිමිය සක්‍රීය නැත enter- අවශ්‍ය yහෝ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

මෙන්න, 1හෝ අසත්ය ආපසු ලබා දෙන ලදි. මෙම පහළ මට්ටමේ ශ්‍රිතය සමඟ ඔබට ඔබේම [y/n]?විමසුමක් ලබා දිය යුතු බව සලකන්න .

කේතය

# 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
}

එවැනි පැරණි පෝස්ට් එකක පළ කිරීම ගැන කණගාටුයි. සති කිහිපයකට පෙර මම සමාන ගැටලුවකට මුහුණ දී සිටියෙමි, මගේ නඩුවේදී මට විසඳුමක් අවශ්‍ය වූ අතර එය මාර්ගගත ස්ථාපක-ස්ක්‍රිප්ට් තුළද ක්‍රියාත්මක විය, උදා:curl -Ss https://raw.github.com/_____/installer.sh | bash

භාවිතා read yesno < /dev/ttyමම වෙනුවෙන් නොව දඩ:

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

මෙය යමෙකුට උපකාරී වේ යැයි සිතමි.

එවැනි සරල පරිශීලක ආදානය සඳහා කිසිවෙකු බහු-රේඛා echo මෙනුව පෙන්වන පිළිතුරක් පළ නොකළ බව මම දුටුවෙමි.

#!/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

යමෙකුට එය ප්‍රයෝජනවත් හා කාලය ඉතිරි කර ගත හැකිය යන බලාපොරොත්තුවෙන් මෙම ක්‍රමය පළ කරන ලදි.

බහුවරණ අනුවාදය:

ask () {                        # $1=question $2=options
    # set REPLY
    # options: x=..|y=..
    while $(true); do
        printf '%s [%s] ' "$1" "$2"
        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 $2; do
                if [ "$REPLY" = "${o%%=*}" ]; then
                    printf '\n'
                    break
                fi
            done
        ) | grep ^ > /dev/null && return
    done
}

උදාහරණයක්:

$ 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
$

එය (පිටපත ඇතුළත) ලෙස සකසනු REPLYඇත y.

මම ඔබට යෝජනා කරන්නේ දෙබස් භාවිතා කරන්න ...

ලිනක්ස් ආධුනිකයා: ඩයලොග් භාවිතයෙන් බෑෂ් ෂෙල් ස්ක්‍රිප්ට් වැඩි දියුණු කරන්න

සංවාද විධානය මඟින් ෂෙල් ස්ක්‍රිප්ට් වල කවුළු පෙට්ටි භාවිතා කිරීම වඩාත් අන්තර්ක්‍රියාකාරී වේ.

එය සරල හා භාවිතයට පහසුය, gdialog නමින් ග්නෝම් අනුවාදයක් ද ඇත, එය හරියටම එකම පරාමිතීන් ගනී, නමුත් එය X හි GUI ශෛලිය පෙන්වයි.

Ark මාක් සහ y මිර්ඩින්ගේ පිළිතුරු වලින් ආශ්වාදයක් ලබා ගත් මම මෙම ක්‍රියාව විශ්වීය විමසුමක් සඳහා නිර්මාණය කළෙමි

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

එය මේ ආකාරයට භාවිතා කරන්න:

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

වඩාත් සාමාන්‍ය වනු ඇත්තේ:

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
}

මෙය කළ හැකි එක් සරල ක්‍රමයක් වන්නේ xargs -pහෝ gnu සමඟ ය parallel --interactive.

Xargs හි හැසිරීමට මම මීට වඩා හොඳට කැමතියි, මන්දයත් එක් එක් විධානය අනෙක් අන්තර්ක්‍රියාකාරී යුනික්ස් විධානයන් මෙන් වහාම ක්‍රියාත්මක වන නිසාය. (ඔබට අවශ්‍ය අය හරහා ගිය පසු ඔබට Ctrl-C කළ හැකිය.)

උදා:

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

එක් පේළියේ විධානයක මිතුරෙකු ලෙස මම පහත සඳහන් දෑ භාවිතා කළෙමි.

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=;

ලිඛිත දිගු ආකෘතිය, එය මේ ආකාරයට ක්‍රියා කරයි:

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=;

මම caseඑවැනි ප්‍රකාශයක් කිහිප වතාවක්ම භාවිතා කර ඇත්තෙමි , සිද්ධි ප්‍ර stat ප්තිය භාවිතා කිරීම ඒ සඳහා යාමට හොඳ ක්‍රමයකි. ඒ whileවන ecapsulates බව පුඩුවක්, caseඑය වීජ තත්ත්වය වැඩසටහන වඩාත් පාලනය පැවැත්වීමට, සහ වෙනත් බොහෝ අවශ්යතා ඉටු කර ගැනීම සඳහා ක්රියාත්මක කළ හැකි උපයෝගී කර වාරණ. සියලුම කොන්දේසි සපුරා ගත් පසු, breakවැඩසටහනක් ප්‍රධාන කොටස වෙත පාලනය නැවත ලබා දෙන a භාවිතා කළ හැකිය. එසේම, වෙනත් කොන්දේසි සපුරාලීම සඳහා, ඇත්ත වශයෙන්ම පාලන ව්‍යුහයන් සමඟ කොන්දේසි සහිත ප්‍රකාශ එකතු කළ හැකිය: caseප්‍රකාශය සහ හැකි whileලූප.

caseඔබගේ ඉල්ලීම ඉටු කිරීම සඳහා ප්‍රකාශයක් භාවිතා කිරීමේ උදාහරණය

#! /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

ඔව් / නැත / අවලංගු කරන්න

ක්රියාකාරිත්වය

#!/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
}

භාවිතය

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

පිරිසිදු පරිශීලක ආදානය සමඟ තහවුරු කරන්න

ක්රියාකාරිත්වය

#!/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
}

භාවිතය

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

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

අන් අයට ප්‍රතිචාර වශයෙන්:

ඔබට BASH4 හි නඩුව නියම කිරීමට අවශ්‍ය නැත, var, කුඩා අකුරක් සෑදීමට ',,' භාවිතා කරන්න. කියවීමේ කොටස ඇතුළත කේත තැබීමට මම තදින්ම අකමැතියි, ප්‍රති result ලය ලබාගෙන කියවීමේ කොටස IMO ට පිටතින් එය සමඟ ගනුදෙනු කරන්න. IMO වලින් ඉවත් වීම සඳහා 'q' ද ඇතුළත් කරන්න. අවසාන වශයෙන් 'ඔව්' ටයිප් කර -n1 භාවිතා කර y ඔබන්න.

උදාහරණය: පරිශීලකයාට y / n එබිය හැකි අතර q යන්නෙන් ඉවත් වීමටද හැකිය.

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

එවැනි අවස්ථා වලදී බොහෝ විට, පරිශීලකයා "ඔව්" ඇතුලත් කරන තෙක් ඔබ දිගටම ස්ක්‍රිප්ට් ක්‍රියාත්මක කළ යුතු අතර පරිශීලකයා "නැත" ඇතුළු වූ විට පමණක් නතර කළ යුතුය. පහත දැක්වෙන ස්නිපටය ඔබට මෙය සාක්ෂාත් කර ගැනීමට උපකාරී වනු ඇත!

#!/bin/bash
input="yes"
while [ "$input" == "yes" ]
do
  echo "execute script functionality here..!!"
  echo "Do you want to continue (yes/no)?"
  read input
done