मैं लिनक्स शैल स्क्रिप्ट में हां / नहीं / रद्द इनपुट के लिए कैसे संकेत करूं?

Question

मैं एक शेल स्क्रिप्ट में इनपुट रोकना चाहता हूं, और विकल्पों के लिए उपयोगकर्ता को संकेत देना चाहता हूं।
मानक Yes, Noया Cancelप्रकार का प्रश्न।
मैं इसे ठेठ बैश प्रॉम्प्ट में कैसे पूरा कर सकता हूं?

Comments

बस एक नोट के रूप में: संकेतों के लिए कन्वेंशन ऐसा है कि यदि आप एक [yn]विकल्प प्रस्तुत करते हैं , तो जो पूंजीकृत है वह डिफ़ॉल्ट है, अर्थात [Yn]"हां" में [yN]चूक , और "नहीं" के लिए चूक। देखें ux.stackexchange.com/a/40445/43532

— Tyzoid

ZSH से कोई भी यहाँ आ रहा है, कमांड का उपयोग करने के लिए इस उत्तर को देखेंread

— smac89

Answer 1

शेल प्रॉम्प्ट पर उपयोगकर्ता इनपुट प्राप्त करने के लिए सबसे सरल और सबसे व्यापक रूप से उपलब्ध विधि 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

एक अन्य विधि, ने बताया द्वारा स्टीवन Huwig , बैश की है 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इनपुट को सैनिटाइज करने की आवश्यकता नहीं है - यह उपलब्ध विकल्पों को प्रदर्शित करता है, और आप अपनी पसंद के अनुसार एक नंबर टाइप करते हैं। यह स्वचालित रूप से लूप भी करता है, इसलिए while trueयदि उन्हें अमान्य इनपुट दिया जाता है, तो पीछे हटने के लिए लूप की कोई आवश्यकता नहीं है ।

इसके अलावा, लेआ ग्रिस ने अपने जवाब में अनुरोध भाषा को अज्ञेय बनाने का एक तरीका दिखाया । कई भाषाओं को बेहतर तरीके से प्रस्तुत करने के लिए मेरे पहले उदाहरण को अपनाने से ऐसा लग सकता है:

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

जाहिर है कि अन्य संचार तार यहां अपरिवर्तित रहते हैं (इंस्टाल, उत्तर) जिसे अधिक पूर्ण रूप से पूर्ण किए गए अनुवाद में संबोधित करना होगा, लेकिन यहां तक ​​कि आंशिक अनुवाद भी कई मामलों में सहायक होगा।

अंत में, F. Hauri द्वारा उत्कृष्ट उत्तर देखें ।

Comments

OS X Leopard में बैश का उपयोग करना, मैं बदल exitकरने के लिए breakटैब को बंद करने जब मैं चयनित 'नहीं' से रखने के लिए।

— ट्रे पिएपिएरिएक डे

हाँ या नहीं की तुलना में लंबे समय तक विकल्पों के साथ यह कैसे काम करता है? मामले के खंड में, क्या आप कुछ लिखते हैं जैसे: प्रोग्राम इंस्टॉल करें और बाद में कुछ भी न करें) इंस्टॉल करें; टूटना;

— शॉन

@ शॉन का उपयोग कर आप पढ़ सकते हैं, निश्चित रूप से, बैश शेल के स्विच स्टेटमेंट द्वारा समर्थित किसी भी ग्लोब या रेगेक्स पैटर्न का उपयोग कर सकते हैं। यह केवल आपके पैटर्न से टाइप किए गए पाठ से मेल खाता है जब तक कि यह एक मैच नहीं पाता। चयन का उपयोग करके , विकल्पों की सूची कमांड को दी गई है और यह उन्हें उपयोगकर्ता को प्रदर्शित करता है। आपके पास सूची में आइटम तब तक हो सकते हैं जब तक आप पसंद करते हैं। मैं व्यापक उपयोग जानकारी के लिए उनके मैन पेजों की जाँच करने की सलाह देता हूँ।

— म्यर्डिन इमरोज़

क्यों वहाँ एक है breakमें selectअगर कोई पाश है?

— Jayen

@akostadinov मुझे वास्तव में अपने संपादन इतिहास को अधिक पढ़ना चाहिए। आप सही हैं, मैं गलत हूं, और मैंने जयन की सलाह के बाद बग की शुरुआत की। बाद में बग को ठीक कर दिया गया था, लेकिन संपादन अब तक अलग थे लेकिन मुझे इसे बदलना भी याद नहीं था।

— Myrddin Emrys 15

Answer 2

एक सामान्य प्रश्न के कम से कम पांच उत्तर।

इस पर निर्भर करते हुए

• POSIX आज्ञाकारी: सामान्य के साथ खराब सिस्टम पर काम कर सकता है खोल वातावरण
• दे घुमा केविशिष्ट: तथाकथित bashisms का उपयोग कर

और अगर आप चाहते हैं

• सरल `` लाइन में 'सवाल / जवाब (सामान्य समाधान)
• सुंदर स्वरूपित इंटरफेस, जैसे ncurses या libgtk या libqt का उपयोग करके अधिक चित्रमय ...
• शक्तिशाली रीडलाइन इतिहास क्षमता का उपयोग करें

1. POSIX जेनेरिक समाधान

आप 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

नोट: इसके तहत परीक्षण किया गया थाश, दे घुमा के, क्ष, पानी का छींटा तथा बिजीबॉक्स!

वही, लेकिन स्पष्ट रूप से 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यदि आवश्यक हो तो मैं भी परीक्षण कर सकता हूं ...

लाइन में साथ एकल कुंजी सुविधा

बैश के तहत, हम readकमांड के लिए इच्छित इनपुट की लंबाई निर्दिष्ट कर सकते हैं :

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

बैश के तहत, 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और अन्य।

Comments

ध्यान दें कि उपयोग के लिए विकल्प sttyप्रदान करता है :। यह सेटिंग को ठीक वैसा ही पुनर्स्थापित करता है जैसा वे पाए गए थे, जो हो सकता है या नहीं के समान हो । -gold_stty=$(stty -g); stty raw -echo; …; stty "$old_stty"stty -sane

— जोनाथन लेफ्लर

read answerरिक्त स्थान और लाइन फीड से पहले बैकस्लैश की व्याख्या करेगा, और अन्यथा उन्हें पट्टी करें जो शायद ही कभी इरादा है। SC2162 केread -r answer अनुसार उपयोग करें ।

— वेलफिगर

"रीडलाइन के इतिहास का उपयोग करना" विधि ओपी के प्रश्न के लिए बहुत अनुचित है। मुझे खुशी है कि आपने इसे वैसे भी शामिल किया। मेरे पास दर्जनों अधिक जटिल स्क्रिप्ट हैं जिन्हें मैं उस पैटर्न के साथ अपडेट करने का इरादा रखता हूं!

— ब्रूनो ब्रोंस्की

आप casePOSIX के साथ-साथ bash का उपयोग कर सकते हैं (bash विकल्प के बजाय एक वाइल्डकार्ड स्थिति का उपयोग करें:) case $answer in; [Yy]* ) echo Yes ;;, लेकिन मैं [ "$answer" != "${answer#[Yy]}" ]आपके बजाय एक अनुकूल कथन का उपयोग करना पसंद करता हूं echo "$answer" | grep -iq ^y। यह अधिक पोर्टेबल है (कुछ गैर-जीएनयू ग्रीप्स -qसही ढंग से लागू नहीं होते हैं) और इसमें सिस्टम कॉल नहीं है। की शुरुआत से या ${answer#[Yy]}हटाने के लिए पैरामीटर विस्तार का उपयोग करता है , जब कोई असमानता मौजूद होती है। यह किसी भी POSIX शेल (डैश, ksh, bash, zsh, busybox, आदि) में काम करता है। Yy$answer

— एडम काट्ज

@CarterPape हाँ, यह एक मजाक था! लेकिन इस संक्षिप्त जवाब में, आपको बहुत सारे सुझाव मिल सकते हैं (दूसरा बिंदु कम से कम 3 अलग-अलग तरीकों से मौजूद है)! और ... लगभग 5 साल से, अब आप सबसे पहले मेरी गिनती विधि के बारे में बताएंगे! ;-))

— एफ। होरी

Answer 3

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

Comments

मैं असहमत हूं, क्योंकि यह केवल डॉस में 'हां, नहीं, रद्द करें' संवाद की कार्यक्षमता का एक हिस्सा लागू करता है। इसे लागू करने में विफल रहने वाला हिस्सा इनपुट जाँच है ... जब तक कि एक वैध उत्तर प्राप्त नहीं हो जाता है तब तक लूपिंग।

— म्यरदीन एमरोज

(मूल प्रश्न का शीर्षक था "मैं एक लिनक्स शेल स्क्रिप्ट में इनपुट के लिए कैसे प्रांप्ट करूं?")

— पिस्टोस

लेकिन मूल प्रश्न विवरण अपरिवर्तित है, और हमेशा हां / नहीं / रद्द करने के संकेत के लिए प्रतिक्रिया मांगी गई है। शीर्षक मेरे मूल एक से अधिक स्पष्ट होने के लिए अद्यतन किया गया है, लेकिन प्रश्न विवरण हमेशा स्पष्ट था (मेरी राय में)।

— मिरडिन इमरोज़

Answer 4

आप अंतर्निहित रीड कमांड का उपयोग कर सकते हैं ; -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 ~/

Comments

यह ध्यान दिया जाना चाहिए कि FILEPATHवह चर नाम है जिसे आपने चुना है, और कमांड प्रॉम्प्ट के उत्तर के साथ सेट किया गया है। इसलिए यदि आप रन करने के लिए थे vlc "$FILEPATH", उदाहरण के लिए, vlcवह फ़ाइल खोल देगा।

— केन शार्प

-eदूसरे उदाहरण (साधारण हाँ / नहीं) में क्या लाभ है ?

— जेब्लिन

-e -pइसके बजाय उपयोग करने का कोई कारण -ep?

— जेब्लिन

-eध्वज / विकल्प के बिना , आप (कार्यान्वयन के आधार पर) "y" टाइप करने में सक्षम नहीं हो सकते हैं, और फिर अपना दिमाग बदल सकते हैं और इसे "n" (या उस मामले के लिए कुछ और) के साथ बदल सकते हैं; जब एक कमांड का दस्तावेजीकरण किया जाता है, तो अन्य कारणों के साथ, पठनीयता / स्पष्टता के लिए अलग से विकल्पों को सूचीबद्ध करना बेहतर होता है।

— yPhil

Answer 5

बैश ने इस उद्देश्य के लिए चयन किया है।

select result in Yes No Cancel
do
    echo $result
done

Comments

+1 सरल समाधान। केवल एक चीज: यह और संकेत देगा और प्रोमट होगा ... जब तक आप exitअंदर नहीं

— डालते हैं

(kaiser: इससे टूटने के लिए, बस EOT दर्ज करें: Ctrl-Dलेकिन निश्चित रूप से, इसका उपयोग करने वाले वास्तविक कोड को शरीर में एक ब्रेक या एक निकास की आवश्यकता होगी।)

— जोरावर

यह आपको y या n में प्रवेश करने की अनुमति नहीं देगा, हालांकि। आप 1 2 या 3 दर्ज करके चुनें

— djjeck

exitसब एक साथ स्क्रिप्ट बाहर निकल जाएगा, breakकेवल पाश आप में हैं (यदि आप एक पर हैं बाहर निकल जाएगा whileया caseपाश)

— wranvaud

Answer 6

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

Answer 7

यहाँ कुछ है जो मैंने एक साथ रखा है:

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

मैं एक शुरुआती हूं, इसलिए इसे नमक के दाने के साथ लें, लेकिन यह काम करने लगता है।

Comments

यदि आप बदलते case $yn inहैं case ${yn:-$2} inतो आप दूसरे तर्क को डिफ़ॉल्ट मान के रूप में उपयोग कर सकते हैं, Y या N.

— jchook

या डिफ़ॉल्ट के रूप में हां case $ynकरने के case "${yn:-Y}"लिए बदलें

— rubo77

Answer 8

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?"

...

Comments

कोड के प्रारूपण को संरक्षित करने के लिए प्रत्येक पंक्ति की शुरुआत में चार स्थान रखें।

— Jouni लालकृष्ण Seppänen

क्यों हम 'y' और 'n' को पैरामीटर के रूप में पूछताछ के लिए प्रदान करते हैं () यदि केस स्विच हार्डकोड हैं? वह सिर्फ दुरुपयोग के लिए पूछ रहा है। वे निश्चित पैरामीटर हैं, परिवर्तनशील नहीं हैं, इसलिए पंक्ति 2 पर प्रतिध्वनि को पढ़ना चाहिए: गूंज -n "$ 1 [/ / n]" उन्हें बदला नहीं जा सकता है, इसलिए उन्हें आपूर्ति नहीं की जानी चाहिए।

— मिरडिन इमरोज़

@MyrddinEmrys आप अपनी टिप्पणी विस्तृत कर सकते हैं? या एक लेख या कुछ कीवर्ड के लिए एक लिंक पोस्ट करें ताकि मैं अपने दम पर शोध कर सकूं।

— माटुस्स पिओत्रोस्की

@MateuszPiotrowski उत्तर को संपादित किया गया है और मैंने अपनी टिप्पणी के बाद सुधार किया है। आप इस उत्तर के सभी पिछले संस्करणों को देखने के लिए ऊपर दिए गए 'संपादित दिसंबर 23' लिंक पर क्लिक कर सकते हैं। 2008 में वापस, कोड काफी अलग था।

— मिरदीन इमरोज़

Answer 9

तुम्हें चाहिए:

• बैश बिलिन कमांड (यानी पोर्टेबल)
• 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 ...=> कॉल कमांड readअगर TTY
• read -n 1 => एक वर्ण की प्रतीक्षा करें
• $'\e[1;32m ... \e[0m '=> हरे रंग में प्रिंट
  (हरा ठीक है क्योंकि दोनों सफेद / काले रंग की पृष्ठभूमि पर पठनीय है)
• [[ $do_xxxx =~ ^(y|Y|)$ ]] => बैज रेगेक्स

टाइमआउट => डिफ़ॉल्ट उत्तर नहीं है

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

Answer 10

कम से कम लाइनों के साथ इसे प्राप्त करने का सबसे आसान तरीका इस प्रकार है:

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

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

यह ifकेवल एक उदाहरण है: यह आपके ऊपर है कि इस चर को कैसे संभाला जाए।

Answer 11

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

और फिर आप की जरूरत के अन्य सभी सामान

Answer 12

यह समाधान एक एकल चरित्र को पढ़ता है और हां प्रतिक्रिया पर एक फ़ंक्शन कहता है।

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

Comments

@Jav आपकी प्रतिक्रिया के बाद एक नई रेखा प्रिंट करता है। इसके बिना, मुद्रित होने वाली अगली चीज़ उसी पंक्ति पर आपकी प्रतिक्रिया के तुरंत बाद दिखाई देगी। echoअपने आप को देखने के लिए हटाने की कोशिश करें।

— डेनिस

Answer 13

एक अच्छा 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 लिनक्स के साथ स्थापित किया गया है। जैसा दिखता है:

Answer 14

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

-eविकल्प इनपुट तीर कुंजियों का उपयोग संपादित करने के लिए उपयोगकर्ता सक्षम बनाता है।

यदि आप सुझाव को इनपुट के रूप में उपयोग करना चाहते हैं:

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

-i विकल्प एक विचारोत्तेजक इनपुट प्रिंट करता है।

Comments

हाँ, -e -iश में काम नहीं करते (बॉर्न शेल), लेकिन सवाल विशेष रूप से टैग किया जाता है ..

— जाहिद

Answer 15

आप REPLYएक पर डिफ़ॉल्ट का उपयोग कर सकते हैं 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

Answer 16

POSIX शेल में एक स्थानीय-जागरूक "हाँ / नहीं विकल्प" को संभालना संभव है; LC_MESSAGESलोकेल श्रेणी की प्रविष्टियों का उपयोग करके , चुड़ैल इनपुट से मिलान करने के लिए रेडी-मेड RegEx पैटर्न प्रदान करती है, और स्थानीयकृत नंबर 1 के लिए तार।

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

EDIT: जैसा कि @Urhixidur ने अपनी टिप्पणी में उल्लेख किया है :

दुर्भाग्य से, POSIX केवल पहले दो (yesexpr और noexpr) को निर्दिष्ट करता है। Ubuntu 16 पर, Yesstr और nostr खाली हैं।

देखें: https://www.ee.ryerson.ca/~courses/ele709/susv4/xrat/V4_xbd_chap07.html#tag_21_07_03_06

LC_MESSAGES

yesstrऔर nostrवातावरण कीवर्ड और YESSTRऔर NOSTRआइटम langinfo पूर्व में उपयोगकर्ता मैच समर्थक और विपक्षी प्रतिक्रियाओं के लिए इस्तेमाल किया गया। 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लिए, स्थानीयकरण के लिए पीओ तार का उत्पादन करने के लिए उपयोग करें:

#: 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 ""

Comments

मैं एक भाषा अज्ञेय विकल्प के अलावा प्यार करता हूँ। बहुत बढ़िया।

— म्यरडिन इमरोज़

दुर्भाग्य से, POSIX केवल पहले दो (yesexpr और noexpr) को निर्दिष्ट करता है। Ubuntu 16 पर, Yesstr और nostr खाली हैं।

— उरिखीदुर

लेकिन रुकें! इससे भी बुरी खबर है! बैश केस स्टेटमेंट एक्सप्रेशन रेगुलर नहीं हैं, वे फाइल एक्सप्रेशन हैं। तो Ubuntu 16 का yesexpr और noexpr ("^ [yY]। *" और "^ [nN]। *", क्रमशः) एम्बेडेड अवधि के कारण पूरी तरह से विफल हो जाएगा। एक नियमित अभिव्यक्ति में, "*।" का अर्थ है "कोई भी गैर-नई वर्ण, शून्य या अधिक बार"। लेकिन एक मामले में बयान, यह एक शाब्दिक है "।" इसके बाद जितने भी पात्र हैं।

— उरिखीदुर

अंत में सबसे अच्छा जो एक शेल वातावरण में yesexprऔर उसके साथ किया जा सकता है noexpr, उसका उपयोग बैश के विशिष्ट RegEx मिलान में किया जाता हैif [[ "$yn" =~ $yesexpr ]]; then echo $"Answered yes"; else echo $"Answered no"; fi

— Léa Gris

Answer 17

एकल कुंजीपट

यहाँ एक लंबा, लेकिन पुन: प्रयोज्य और मॉड्यूलर दृष्टिकोण है:

• रिटर्न 0= हां और 1= नहीं
• कोई भी दबाव दर्ज करने की आवश्यकता नहीं है - सिर्फ एक चरित्र
• enterडिफ़ॉल्ट विकल्प को स्वीकार करने के लिए दबा सकते हैं
• चयन को बाध्य करने के लिए डिफ़ॉल्ट विकल्प को अक्षम कर सकते हैं
• दोनों के लिए काम करता है zshऔर bash।

दर्ज करते समय "नहीं" के लिए डिफ़ॉल्ट

ध्यान दें कि 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 *

दर्ज करते समय "हाँ" के लिए डिफ़ॉल्ट

ध्यान दें कि 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
}

Comments

जब मैंने इस लिपि का परीक्षण किया, तो ऊपर के स्थान के बजाय मुझे मिला, Show dangerous command [y/N]? [y/n]?औरShow dangerous command [Y/n]? [y/n]?

— इलियास करीम

धन्यवाद @IliasKarim, मैंने तय किया कि अभी।

— टॉम हेल

Answer 18

इतनी पुरानी पोस्ट पर पोस्ट करने के लिए क्षमा करें। कुछ हफ़्ते पहले मैं इसी तरह की समस्या का सामना कर रहा था, मेरे मामले में मुझे एक समाधान की आवश्यकता थी जो एक ऑनलाइन इंस्टॉलर-स्क्रिप्ट के भीतर भी काम करता था, उदाहरण के लिए: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

आशा है कि यह किसी की मदद करता है।

Comments

इसका एक महत्वपूर्ण हिस्सा इनपुट सत्यापन है। मुझे लगता है कि ttyइनपुट स्वीकार करने के लिए मेरे पहले उदाहरण को अपनाने जैसा कि आपने भी किया होगा और खराब इनपुट पर भी पासा लगाया होगा (बफर में कुछ वर्णों की कल्पना करें; आपका तरीका उपयोगकर्ता को हमेशा नहीं चुनने के लिए मजबूर करेगा )।

— मिरडिन इमरोज़

Answer 19

मैंने देखा कि किसी ने भी इस तरह के सरल उपयोगकर्ता इनपुट के लिए मल्टी-लाइन इको मेनू दिखाते हुए उत्तर पोस्ट नहीं किया है, इसलिए यहां मेरा जाना है:

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

इस पद्धति को इस उम्मीद में पोस्ट किया गया था कि कोई व्यक्ति इसे उपयोगी और समय की बचत कर सकता है।

Answer 20

एकाधिक विकल्प संस्करण:

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।

Answer 21

मेरा सुझाव है कि आप संवाद का उपयोग करें ...

लिनक्स अपरेंटिस: डायलॉग का उपयोग करके बैश शेल लिपियों में सुधार करें

संवाद कमांड शेल लिपियों में विंडो बॉक्स के उपयोग को उनके उपयोग को अधिक संवादात्मक बनाने में सक्षम बनाता है।

यह सरल और प्रयोग करने में आसान है, gdialog नामक एक सूक्ति संस्करण भी है जो सटीक समान मापदंडों को लेता है, लेकिन यह X पर GUI शैली दिखाता है।

Comments

आकस्मिक पाठक के लिए, यहां संवाद कमांड का उपयोग करते हुए एक स्निपेट देखें: stackoverflow.com/a/22893526/363573

— Stephan

Answer 22

@ मर्क और @ मिरदीन के जवाबों से प्रेरित होकर मैंने यह समारोह एक सार्वभौमिक संकेत के लिए बनाया

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"

Answer 23

अधिक सामान्य होगा:

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
}

Answer 24

ऐसा करने का एक सरल तरीका है, xargs -pगनु या विष्णु parallel --interactive।

मुझे इसके लिए xargs का व्यवहार थोड़ा बेहतर लगता है क्योंकि यह अंत में चलने के लिए yesses को इकट्ठा करने के बजाय अन्य इंटरैक्टिव यूनिक्स कमांड्स की तरह शीघ्रता से प्रत्येक कमांड को निष्पादित करता है। (आप जो चाहते थे, उसके माध्यम से प्राप्त करने के बाद आप Ctrl-C कर सकते हैं।)

जैसे,

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

Comments

बुरा नहीं है, लेकिन xargs --interactiveहाँ या नहीं तक सीमित है। जब तक कि आप सभी की जरूरत है कि पर्याप्त हो सकता है, लेकिन मेरे मूल प्रश्न ने तीन संभावित परिणामों के साथ एक उदाहरण दिया। मुझे वास्तव में यह पसंद है कि यह सुव्यवस्थित है; कई आम परिदृश्य इसकी क्षमता से लाभान्वित होंगे।

— मिरडिन इमरोज़

समझा। मेरी सोच यह थी कि "रद्द करें" का मतलब केवल आगे के सभी निष्पादन को रोकना है, जो कि यह Ctrl-C के माध्यम से समर्थन करता है, लेकिन अगर आपको रद्द (या नहीं) पर कुछ अधिक जटिल करने की आवश्यकता है तो यह पर्याप्त नहीं होगा।

— जोशुआ गोल्डबर्ग

Answer 25

एक पंक्ति कमांड के एक दोस्त के रूप में मैंने निम्नलिखित का उपयोग किया:

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

Comments

क्या आप प्रॉम्प्ट चर के उपयोग को स्पष्ट कर सकते हैं? मुझे ऐसा लगता है जैसे यह एक लाइनर के बाद मिटा दिया गया है, तो आप कुछ भी करने के लिए लाइन का उपयोग कैसे करते हैं?

— मिरडिन इमरोज़

प्रॉम्प्ट लूप के बाद मिटा दिया जाता है। क्योंकि मैं चाहता हूं कि प्रॉम्प्ट वेरिएबल को बाद में इनिशियलाइज़ किया जाए (क्योंकि मैं अधिक बार स्टेटमेंट का उपयोग कर रहा हूं)। शेल-स्क्रिप्ट में यह लाइन होने पर ही आगे बढ़ेगा यदि y | Y टाइप किया गया हो और बाहर निकलना हो तो n | N टाइप किया गया हो या फिर अन्य सभी चीज़ों के लिए इनपुट मांगना हो।

— ccDict

Answer 26

मैंने caseइस तरह के परिदृश्य में कई बार बयान का उपयोग किया है, केस स्टेटमेंट का उपयोग करना इसके बारे में जाने का एक अच्छा तरीका है। एक whileलूप, जो caseब्लॉक को इकोपलाइज़ करता है, जो एक बूलियन स्थिति का उपयोग करता है ताकि प्रोग्राम के और भी अधिक नियंत्रण रखने के लिए, और कई अन्य आवश्यकताओं को पूरा किया जा सके। सभी शर्तों के पूरा होने के बाद, एक breakका उपयोग किया जा सकता है जो कार्यक्रम के मुख्य भाग पर नियंत्रण वापस कर देगा। इसके अलावा, अन्य शर्तों को पूरा करने के लिए, निश्चित रूप से सशर्त बयानों को नियंत्रण संरचनाओं के साथ जोड़ा जा सकता है: 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

Answer 27

हाँ / नहीं / रद्द करें

समारोह

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

Answer 28

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!'

Comments

यह जटिल और नाजुक लगता है। कैसे के बारे मेंyn(){ read -s -n 1 -p '[y/n]'; test "$REPLY" = "y" ; } yn && echo success || echo failure

— ट्रिपल

Answer 29

दूसरों की प्रतिक्रिया में:

आपको BASH4 में केस को निर्दिष्ट करने की आवश्यकता नहीं है, बस एक var लोअरकेस बनाने के लिए ',,' का उपयोग करें। इसके अलावा, मैं रीड ब्लॉक के अंदर कोड डालने की दृढ़ता से नापसंद करता हूं, परिणाम प्राप्त करें और रीड ब्लॉक आईएमओ के बाहर इसके साथ व्यवहार करें। 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

Answer 30

ऐसे परिदृश्यों में अधिकांश बार, आपको स्क्रिप्ट को निष्पादित करना जारी रखने की आवश्यकता होती है जब तक कि उपयोगकर्ता "हां" दर्ज करता रहता है और केवल तभी रुकना पड़ता है जब उपयोगकर्ता "नहीं" में प्रवेश करता है। नीचे दिए गए स्निपेट आपको इसे हासिल करने में मदद करेंगे!

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