मैं कैसे bash में एक अंक के n repetitions इनपुट करते हैं, अंतःक्रियात्मक रूप से

Question

मैं कमांड चलाना चाहता हूं

foo --bar=baz <16 zeroes>

मैं 16 शून्य कुशलतापूर्वक कैसे टाइप करूं? यदि मैं पकड़ता हूं Altऔर दबाता हूं तो 1 6 0यह अगली चीज को 160 बार दोहराएगा, जो कि मैं नहीं चाहता। एमएसीएस में मैं या तो उपयोग कर सकता हूं Alt-[number]या Ctrl-u 1 6 Ctrl-u 0फिर बैश में Ctrl-u, वर्तमान में टाइप की जा रही लाइन को मारता है और अगला शून्य लाइन में 0 जोड़ देता है।

यदि मैं करता हूँ

foo --bar=baz $(printf '0%.0s' {1..16})

फिर historyठीक ऊपर दिखाया गया है, और नहीं foo --bar=baz 0000000000000000; यानी बाश मैं जैसा चाहता हूं वैसा व्यवहार नहीं करता। ( संपादित करें : बिंदु जा रहा है, मैं $(...)कमांड प्रतिस्थापन का उपयोग किए बिना कुछ संख्या में शून्य इनपुट करना चाहता हूं )

(*) मुझे लगता है कि "कुशलतापूर्वक" की एक तकनीकी परिभाषा है "ओ (लॉग एन) कीस्ट्रोक्स" के साथ, अधिमानतः कीस्ट्रोक्स की संख्या 16 में अंकों की संख्या के बराबर है (16 के सभी मूल्यों के लिए) प्लस शायद एक स्थिर; emacs उदाहरण इस परिभाषा के अनुसार कुशल है।

Comments

लगता है जैसे आप किसी भी तरह से मारना चाहते हैं know what you want to do। एक जटिल नेस्टेड कमांड में, यह कैसे पता चलेगा कि आप किन हिस्सों में इतिहास के निष्पादन के परिणाम को कमांड के विपरीत देखना चाहते थे? चर के बारे में क्या? शॉर्ट बैश में हमेशा codeइतिहास में होता है, न कि कोड को निष्पादित करने का परिणाम।

— नास्तिक

@meuh, Altअपने आप से किसी भी चरित्र को नहीं भेजता है, इसलिए ऑल्ट को दबाने और रिलीज करने का कोई प्रभाव नहीं होगा जहां तक bashचिंतित है।

— स्टीफन चेज़लस

@Unbeliever मैं क्या मतलब है और यह ठीक हो जाएगा

— बिल्ली

@Unbeliever: मेरे एडिट को देखें - पैराग्राफ के साथ करने की बात यह historyथी कि मैं कमांड प्रतिस्थापन का उपयोग किए बिना अंकों को इनपुट करना चाहूंगा।

— जोनास कोल्कर

जब भी आप अपने लिए स्वचालित रूप से टाइप की गई चीजें चाहते हैं, AutoKey उपयोग करने के लिए एक महान उपयोगिता है। इसके साथ, आप वाक्यांश प्रतिस्थापन का निर्माण कर सकते हैं, या पायथन मैक्रोज़ को पूरा कर सकते हैं जो आपको लगभग कुछ भी पसंद आएगा जब एक ट्रिगर वाक्यांश टाइप किया जाता है या हॉटकी दबाया जाता है। मैंने इसे एक उत्तर के रूप में शामिल नहीं किया क्योंकि इसके लिए एक जीयूआई डेस्कटॉप वातावरण की आवश्यकता है और बाकी के उत्तर नहीं हैं - और इस प्रकार यह आमतौर पर लागू होता है।

— जो

Answer 1

प्रयत्न

प्रतिध्वनि Alt+1Alt+6Ctrl+V०

उन 16 शून्य (आप Alt1 और 6 दोनों के लिए पकड़ कर सकते हैं) सम्मिलित करने के लिए 6 प्रमुख स्ट्रोक (कम से कम एक यूएस / यूके QWERTY कीबोर्ड मानकर )।

आप मानक viमोड ( set -o vi) और प्रकार का भी उपयोग कर सकते हैं :

इको 0 Escx16p

(6 कुंजी स्ट्रोक भी)।

emacsमोड के बराबर है और है कि एक ही चरित्र की तुलना में अधिक दोहराने के लिए इस्तेमाल किया जा सकता ( ) में काम करता है , लेकिन नहीं में ।echo 0Ctrl+WAlt+1Alt+6Ctrl+Yzshbash

वे सभी भी काम करेंगे zsh(और tcshजहां से आता है)। इसके साथ zsh, आप चर विस्तार पट्टियों का उपयोग भी कर सकते हैं और उनका विस्तार कर सकते हैं Tab:

गूंज $ {(एल: 16 :: 0 :)}Tab

(स्पष्ट रूप से बहुत अधिक कीस्ट्रोक)।

साथ bash, आप भी कर सकते हैं bashअपने विस्तार $(printf '0%.0s' {1..16})के साथ Ctrl+Alt+E। ध्यान दें कि यह लाइन पर सब कुछ (हालांकि ग्लब्स नहीं) का विस्तार करेगा।

कम से कम कुंजी स्ट्रोक के खेल को खेलने के लिए, आप कुछ कुंजी को एक विजेट से बांध सकते हैं जो बार- बार फैलता <some-number>Xहै । और बेस 36 में इसे और भी कम करने के लिए है।X<some-number><some-number>

के साथ zsh(बाध्य F8):

repeat-string() {
  REPLY=
  repeat $1 REPLY+=$2
}
expand-repeat() {
  emulate -L zsh
  set -o rematchpcre
  local match mbegin mend MATCH MBEGIN MEND REPLY
  if [[ $LBUFFER =~ '^(.*?)([[:alnum:]]+)(.)$' ]]; then
    repeat-string $((36#$match[2])) $match[3]
    LBUFFER=$match[1]$REPLY
  else
    return 1
  fi
}
zle -N expand-repeat
bindkey "$terminfo[kf8]" expand-repeat

फिर, 16 शून्य के लिए, आप टाइप करें:

गूंज g0F8

(3 कीस्ट्रोक्स) जहां gहै 16आधार 36 में।

अब हम इसे एक कुंजी में कम कर सकते हैं जो उन 16 शून्य को सम्मिलित करता है, हालांकि यह धोखा होगा। हम F2दो 0एस (या दो $STRING, 0 डिफ़ॉल्ट रूप से) से बांध सकते हैं , F33 0एस तक, F1F616 0एस ... 19 तक ... संभावनाएं अनंत हैं जब आप मनमाना विजेट परिभाषित कर सकते हैं।

शायद मुझे यह उल्लेख करना चाहिए कि यदि आप 0कुंजी दबाते हैं और पकड़ते हैं , तो आप केवल एक कीस्ट्रोल के साथ जितने चाहें उतने शून्य सम्मिलित कर सकते हैं। :-)

Comments

viऔर दूसरों के लिए कई विविधताएं प्रदान करने के लिए धन्यवाद !

— मार्क स्टीवर्ट

Answer 2

मान लें कि आपके टर्मिनल एमुलेटर कीस्ट्रोके (जैसे कि टैब को स्विच करने के लिए) नहीं खाता है -प्लेन xterm काम करता है - आप दबा सकते हैं Alt-1 6 Ctrl-V 0। संख्या और वर्ण को दोहराने के लिए नियंत्रण-वी की आवश्यकता है (यदि आप एक पत्र दोहरा रहे थे, तो आपको इसकी आवश्यकता नहीं होगी)।

(यह एक रीडलाइन विशेषता है जिसे इस प्रकार जाना जाता है digit-argument, इसलिए आपको bindइसमें शामिल संशोधक कुंजियों को बदलने में सक्षम होना चाहिए )

Comments

धन्यवाद, फीचर सहित नाम उपयोगी है जब मेरे जैसे लोग इन सवालों पर ठोकर खाते हैं। थोड़ा और अधिक पढ़ने के लिए संबंधित लिंक: एसओ प्रश्न और बैश मैनुअल

— प्रशंसा की

Answer 3

Emacs में, मैं आम तौर C-qपर अंक इनपुट से उपसर्ग तर्क को अलग करने के लिए उपयोग करूँगा ।

बैश का उपयोग करता है Ctrl+vके बजाय C-q, Xon / XOFF प्रवाह नियंत्रण के साथ समस्याओं से बचने के लिए।

तो आप उपयोग कर सकते हैं Alt+1 Alt+6 Ctrl+v 0।

Answer 4

एक अन्य विकल्प चार शून्य टाइप करना है और फिर माउस का उपयोग करके इसे तीन और बार कॉपी और पेस्ट करना है। चयन करने के लिए डबल-क्लिक करें, क्लिक करने के लिए मध्य 3 पर क्लिक करें।

Comments

या इसे गोल्फ करें / एक शून्य को टाइप करके कुछ और धोखा दें , 2 पाने के लिए चयन करें और पेस्ट करें; चयन करें और पेस्ट करें कि 4 प्राप्त करें; 8 के लिए चयन करें और पेस्ट करें, और फिर से 16 के लिए। यह बहुत :) :)

— जेफ स्कॉलर

हाँ, लेकिन 4 जीरो टाइप करना और उन्हें दोहराना-चिपकाना उन्हें मेरे लिए भुगतान बनाम प्रयास का इष्टतम स्तर लगता है। अतिरिक्त नकल और चिपकाने वाले सभी काम की तरह लगते हैं।

— कैस

Answer 5

मैक्रोज़ के साथ खेलना:

फ़ंक्शन कुंजी F8को दो अंतिम शब्द (पिछले स्थान तक) (F8 कुंजी कोड का उपयोग करके पाया गया Ctrl-V F8) से गुणा करें :

$ bind '"\e[19~": "\C-w\C-y\C-y"'

उसी पाठ को भेजकर इसे स्थायी बनाया जा सकता है ~/.inputrc

$ echo '"\e[19~": "\C-w\C-y\C-y"' >> ~/.inputrc

फिर टाइप करें:

प्रतिध्वनि ०F8F8F8F8

2 ^ 4 गुना शून्य पाने के लिए। (अभी भी 5 कीस्ट्रोक्स)।

या प्रकार:

गूंज पुस्तकF8F8F8

2 ^ 3 पुस्तक शब्द पाने के लिए।

अभी भी तेज:

4 से गुणा करें:

$ bind '"\e[19~": "\C-w\C-y\C-y\C-w\C-y\C-y"'

प्रतिध्वनि ०F8F8

3 कुंजी।

8 से गुणा करें (फ़ंक्शन कुंजी के समान संख्या)

$ bind '"\e[19~": "\C-w\C-y\C-y\C-w\C-y\C-y\C-w\C-y\C-y"'

गूंज ००F8

अभी भी 3 कुंजी।

धोखा?

16 से गुणा करके धोखा।

$ bind '"\e[19~": "\C-w\C-y\C-y\C-w\C-y\C-y\C-w\C-y\C-y\C-w\C-y\C-y"'

प्रतिध्वनि ०F8

केवल 2 की-बोर्ड। (और अभी भी एक उपयोगी सरल कार्य)

^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ (बेस 36? हाह!) :-P

पूरी तरह से धोखा:

$ bind '"\e[19~": "0000000000000000"'

गूंज F8

बस 1 (हाँ: एक ) कीस्ट्रोक।

---

---

इसके लिए बाध्यकारी बदलना ctrl+U:

इसे भेजें ~/.inputrc:

echo '"\C-u": universal-argument >> ~/.inputrc

~/.inputrcफ़ाइल को फिर से पढ़ें :

ctrl+Xctrl+R

जैसा कि emacs में हमेशा होता है (जैसा आप चाहते थे):

फू - बबर = बाज ctrl+U१६ ctrl+U०

7 कुंजी ("सेटिंग" के बाद)।

थोड़ा छोटा:

"सार्वभौमिक-तर्क" के डिफ़ॉल्ट "4 से गुणा" करें और इसके साथ समाप्त करें

 ctrl+V 0 

फू - बबर = बाज ctrl+Uctrl+Uctrl+V०

केवल 5 कुंजी।

alt+nपहुंच का उपयोग करना (arg: n)

फू - बबर = बाज Alt+16Ctrl+V०

16 शून्य प्राप्त करने के लिए यह 6 कुंजी है।

कोई कीबोर्ड शॉर्टकट नहीं बदलना:

अपने बैश में यदि आपके पास bash C-u kills the currently-being-typed line।
ऐसा इसलिए "\C-u":है क्योंकि यह बाँध है unix-line-discard।

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

तो ctrl+uमिटा दिया और ctrl+yवापस क्या मिटा दिया गया था।
एक साफ लाइन पर: 00इसे मिटा दें और इसे बनाने के लिए इसे दो बार वापस करें 0000। (8 शून्य)
प्राप्त करने के लिए दोहराएं 00000000, अंत में कमांड टाइप करें और दो बार वापस जाएं।

पहला सेट (7 कुंजी ctrlदबाए रखें ):

00 ctrl+Uctrl+Yctrl+Y ctrl+U 

दूसरा सेट (5 कुंजी)

ctrl+Uctrl+Yctrl+Y ctrl+U 

इरेज़ रिंग में आठ शून्य मिलेंगे, फिर आप जो चाहें टाइप करें:

 फू - बबर = बाज ctrl-Y ctrl-Y 

लेना:

foo --bar=baz 0000000000000000

विचार प्राप्त करने के बाद, आप भी, टाइप करें कि आपको क्या चाहिए, लाइन की शुरुआत पर जाएं ( ctrl-Y), ऊपर के रूप में (आठ शून्य तक) अंत में जाएं ( ctrl-E) और दो बार yank।

फू - बबर = बाज ctrl-A00ctrl-Uctrl-Yctrl-Y ctrl-Uctrl-Yctrl-Y ctrl-U ctrl-Ectrl-Yctrl-Y

वह 15 कुंजी (कमांड के पास) है।
कम नहीं, मुझे पता है, लेकिन जो उपलब्ध था उसके साथ ही काम कर रहा है।

यह थोड़ा छोटा है:

0000 ctrl-U ctrl-Y ctrl-Y ctrl-Y ctrl-Y ctrl-A foo --bar = baz

वह 11 चाबियां हैं

Comments

मेरे उत्तर का संपादन देखें ;-)

— स्टीफन चेज़लस

मैक्रो का उपयोग करना बेस 36? केवल zsh में? C'mon ... मेरा संपादन देखें :-P

— sorontar

हाँ, बेस 36 गाल में थोड़ी सी जीभ थी। मुझे आपका F<n>अंतिम शब्द <n>बार दोहरा कर पसंद है ।

— स्टीफन चेजलस

ध्यान दें कि सभी टर्मिनल F8 पर समान अनुक्रम नहीं भेजते हैं (हालांकि अधिकांश जो GNU / लिनक्स सिस्टम पर मिलते हैं ^[[19~) भेजते हैं । "$(tput kf8)"टर्मोफ डेटाबेस (या $terminfoहैश इन zsh) से जानकारी प्राप्त करने के लिए देखें ।

— स्टीफन चेज़लस

@ स्टीफनचैलेजेलस हां, यह सही है। या बस का उपयोग करेंctrl-v F8

— 12

Answer 6

कैस के उत्तर की भिन्नता के रूप में , टाइप करें

प्रिंटफ 0%। s '{1..16}Enter

और फिर इसे (एक बार) कॉपी और पेस्ट करने के लिए माउस का उपयोग करें। तर्क से, यह O (लॉग एन) है, लेकिन चूंकि यह (len (str (n)) + 20) है, आप इसे अक्षम मान सकते हैं। लेकिन ध्यान दें:

• मैं एक चरित्र को काट देने में सक्षम था - मेरे सिस्टम पर, %.sजैसा व्यवहार करना चाहिए लगता है %.0s।
• यदि आप 0000000000000000एक तर्क के रूप में कई कमांड चलाना चाहते हैं , तो आपको केवल एक बार ऐसा करने की आवश्यकता है।

ग्लेन जैकमैन बताते हैं कि (जहां संख्या एक धनात्मक पूर्णांक है) संख्या शून्य (और एक नई रेखा) की एक स्ट्रिंग को मुद्रित करेगा , क्योंकि प्रारूप में तारांकन तर्क से क्षेत्र की चौड़ाई लेने के लिए कहता है। विशेष रूप से, 16 शून्य मुद्रित करेगा। लेकिन यह एक विशेष मामला है जो केवल संभालता है ।  प्रिंट करेगा , और प्रिंट करेगा और एक त्रुटि संदेश। इसके विपरीत, इस उत्तर में अन्य कमांड स्ट्रिंग्स का उत्पादन करेंगे ( या नीचे देखें )।printf "%0*d\n" number 0printfprintf "%0*d" 16 0 0printf "%0*d" 16 123450000000000012345printf "%0*d" 16 foo0000000000000000123451234512345…foofoofoo…7%7%7%...

यदि आप बार-बार ऐसा करने जा रहे हैं, तो आप शेल फ़ंक्शन को परिभाषित करके इसे सुव्यवस्थित कर सकते हैं:

rep() { printf -- "$1%.0s" $(seq 1 "$2"); printf "\n"; }

टिप्पणियाँ:

• का प्रयोग करें $(seq 1 "$2")बजाय (1.."$2"}देखते हैं - क्योंकि बाद इच्छा काम नहीं यह , यह , यह , और यह । ध्यान दें कि उन सवालों के जवाब में से कुछ का उपयोग करने का सुझाव देते हैं eval, लेकिन यह आमतौर पर अनुशंसित नहीं है।
• प्रारूप स्ट्रिंग ( $1%.0s) दोहरे उद्धरण चिह्नों में होना चाहिए (एकल उद्धरणों के बजाय) क्योंकि इसमें एक पैरामीटर ( $1) है।
• के साथ शुरू होने वाले मूल्यों --से रक्षा करना है ।$1-
• के "%.0s$1"बजाय का उपयोग करके आप समान सुरक्षा प्राप्त कर सकते हैं "$1%.0s"।
• किसी भी तरह से, एक $1मूल्य युक्त %यह गला घोंटना होगा।

• यदि आप $1युक्त मूल्यों को संभालने में सक्षम होना चाहते हैं %, तो करें

  rep() { local i; for ((i=0; i<$2; i++)); do printf '%s' "$1"; done; printf "\n"; }

इसके अलावा, एक बार जब आप इस तरह के एक फ़ंक्शन को परिभाषित करते हैं, तो आप इस तरह की चीजें कर सकते हैं

foo --bar=baz "$(rep 0 16)"

की तुलना में थोड़ा कम टाइपिंग है "$(printf '0%.0s' {1..16})"।

Comments

वैकल्पिक रूप printf "%0*d" 16 0से 16 शून्य मुद्रित करेगा। प्रारूप में तारांकन तर्कों से क्षेत्र की चौड़ाई

— लेगा