bash - बैश में, "क्या आप निश्चित हैं[वाई/एन]" को किसी भी कमांड या उपनाम में जोड़ने के लिए कैसे?




alias confirmation (10)

'हां' के इन रूपों की स्पष्ट रूप से जांच करने से बचने के लिए आप नियमित अभिव्यक्ति के साथ बैश नियमित अभिव्यक्ति ऑपरेटर '= ~' का उपयोग कर सकते हैं:

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

यह परीक्षण करता है कि उपयोगकर्ता इनपुट 'वाई' या 'वाई' से शुरू होता है और उसके बाद शून्य या अधिक 'es' होता है।

इस विशेष मामले में, मैं बैश में एक पुष्टिकरण जोड़ना चाहता हूं

Are you sure? [Y/n]

Mercurial के hg push ssh://[email protected]//somepath/morepath , जो वास्तव में एक उपनाम है। क्या कोई मानक कमांड है जिसे इसे प्राप्त करने के लिए उपनाम में जोड़ा जा सकता है?

कारण यह है कि hg push और hg out समान लग सकता है और कभी-कभी जब मैं hgoutrepo चाहता hgoutrepo , तो मैं आकस्मिक रूप से hgpushrepo टाइप कर सकता hgpushrepo (दोनों उपनाम हैं)।

अपडेट करें: यदि यह किसी अन्य कमांड के साथ अंतर्निर्मित कमांड की तरह कुछ हो सकता है, जैसे कि: confirm && hg push ssh://... यह बहुत अच्छा होगा ... केवल एक कमांड जो yes या no पूछ सकता है और yes अगर बाकी के साथ जारी रखें।


अपने / etc / bashrc फ़ाइल में निम्नलिखित जोड़ें। यह स्क्रिप्ट "पुष्टि" नामक उपनाम के बजाय निवासी "फ़ंक्शन" जोड़ती है।

function confirm( )
{
#alert the user what they are about to do.
echo "About to [email protected]";
#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
               "[email protected]"
               ;;
    *)
              #Otherwise exit...
              echo "ciao..."
              exit
              ;;
esac
}

खैर, यहां confirm का मेरा संस्करण है, जेम्स 'से संशोधित:

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
}

ये परिवर्तन हैं:

  1. परिवर्तनीय नामों को टकराव से रोकने के लिए local का उपयोग करें
  2. अपनी कार्रवाई को नियंत्रित करने के लिए $2 $3 ... उपयोग करें $2 $3 ... ताकि आप -n और -t उपयोग कर सकें
  3. अगर read असफल हो जाता है, तो सुंदरता के लिए एक पंक्ति फ़ीड गूंजें
  4. Git on Windows मेरे Git on Windows केवल bash-3.1 और इसमें कोई true या false नहीं true , इसलिए return उपयोग करें। बेशक, यह बैश-4.4 (विंडोज़ के लिए गिट में मौजूदा) के साथ भी संगत है।
  5. IPython-style का उपयोग करें "(y / [n])" स्पष्ट रूप से इंगित करने के लिए कि "n" डिफ़ॉल्ट है।

नीचे कोड दो चीजों का संयोजन है

  1. दुकान-नॉकसैच जो मामला असंवेदनशील देखभाल करेगा

  2. और यदि शर्त दोनों इनपुट को स्वीकार करेगी तो आप हाँ, हाँ, हाँ, वाई पास करेंगे।

    shopt -s nocasematch

    अगर [[sed-4.2.2। $ LINE = ~ (yes | y) $]]

    फिर 0 से बाहर निकलें

    फाई


प्रयत्न,

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

यह एक हैक हो सकता है:

जैसा कि प्रश्न में यूनिक्स / बैश में है, "xargs -p" किसी भी कमांड को चलाने से पहले पुष्टि के लिए संकेत देने का एक अच्छा तरीका है?

हम नौकरी करने के लिए xargs का उपयोग कर सकते हैं:

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

बेशक, यह एक उपनाम के रूप में सेट किया जाएगा, जैसे hgpushrepo

उदाहरण:

$ 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

$

यह वास्तव में "हां या नहीं hgpushrepo " है, लेकिन सिर्फ एक हैक: उर्फ hg push ... hgpushrepo को नहीं, लेकिन hgpushrepoconfirmedpush करने के लिए और जब तक मैं पूरी चीज का जादू कर सकता हूं, बाएं दिमाग ने तार्किक बना दिया है चुनाव।


यहां मेरा समाधान है कि स्थानीयकृत रेगेक्स का उपयोग करना। तो जर्मन में भी "जा" के लिए "जे" को हां के रूप में व्याख्या किया जाएगा।

पहला तर्क सवाल है, यदि दूसरा तर्क हाँ से "y" है तो डिफ़ॉल्ट उत्तर होगा अन्यथा डिफ़ॉल्ट उत्तर नहीं होगा। वापसी का मान 0 है यदि उत्तर "हां" और 1 था यदि उत्तर "नहीं" था।

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

यहां एक बुनियादी उपयोग है

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

ये हामिश के उत्तर के अधिक कॉम्पैक्ट और बहुमुखी रूप हैं। वे ऊपरी और निचले केस अक्षरों के किसी भी मिश्रण को संभालते हैं:

read -r -p "Are you sure? [y/N] " response
case "$response" in
    [yY][eE][sS]|[yY]) 
        do_something
        ;;
    *)
        do_something_else
        ;;
esac

या, बैश के लिए> = संस्करण 3.2:

read -r -p "Are you sure? [y/N] " response
if [[ "$response" =~ ^([yY][eE][sS]|[yY])+$ ]]
then
    do_something
else
    do_something_else
fi

नोट: यदि $response एक खाली स्ट्रिंग है, तो यह एक त्रुटि देगा। ठीक करने के लिए, बस उद्धरण चिह्न जोड़ें: "$response" । - तारों वाले चर में हमेशा डबल कोट्स का उपयोग करें (उदाहरण: "[email protected]" बजाय "[email protected]" का उपयोग करना पसंद करते हैं)।

या, बैश 4.x:

read -r -p "Are you sure? [y/N] " response
response=${response,,}    # tolower
if [[ "$response" =~ ^(yes|y)$ ]]
...

संपादित करें:

आपके संपादन के जवाब में, यहां बताया गया है कि आप मेरे उत्तर में पहले संस्करण के आधार पर एक confirm आदेश कैसे बनाएंगे और उपयोग करेंगे (यह अन्य दो के साथ समान रूप से काम करेगा):

confirm() {
    # call with a prompt string or use a default
    read -r -p "${1:-Are you sure? [y/N]} " response
    case "$response" in
        [yY][eE][sS]|[yY]) 
            true
            ;;
        *)
            false
            ;;
    esac
}

इस समारोह का उपयोग करने के लिए:

confirm && hg push ssh://..

या

confirm "Would you really like to do a push?" && hg push ssh://..

वही नहीं, लेकिन विचार जो वैसे भी काम करता है।

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

आउटपुट:
फिर? वाई / एन एन
फिर? वाई / एन कुछ भी
फिर? वाई / एन 7
फिर? Y n &
फिर? वाई / एन nsijf
$

अब मैं केवल $ 1 अक्षर पढ़ता हूं जो मैंने पढ़ा है।





confirmation