कई-अभिशापों के मूल सिद्धांत

Question

मैंने हाल ही में सीखा है multiple-cursors, और यह एक बहुत उपयोगी पैकेज की तरह दिखता है। मैं मूल रेपो पर प्रलेखन के माध्यम से चला गया , लेकिन कमांड अभी भी मुझे थोड़ा अस्पष्ट लगता है।

मैं तो देखा वीडियो Emacs चट्टानों में !, और वीडियो महान है, लेकिन यह क्या पर ज्यादातर केंद्रित multiple-cursorsकर रही है, बल्कि पर से करने में सक्षम है कैसे यह करने के लिए।

क्या कोई वॉक-थ्रू, ट्यूटोरियल या उदाहरण हैं जो इसकी सबसे बुनियादी कार्यक्षमता को दर्शाते हैं?

Comments

मैं multiple-cursorsसिर्फ README फाइल को पढ़कर बहुत तेजी से उठने और भागने में सक्षम था । मेरी सिफारिश सिर्फ सीखने के लिए है mc/mark-next-like-this। इसे आज़माएं, और इससे परिचित हों कि यह क्या करता है। वहाँ से README पर वापस जाएँ जब भी आपका कोई प्रश्न हो जो "मुझे आश्चर्य होता है कि यदि एकाधिक-कमर्स कर सकते हैं ..." तो उस सभी ने कहा, मुझे लगता है कि Emacs Rocks की तुलना में अधिक बुनियादी परिचय है! वीडियो शुरुआती के लिए सहायक होगा।

— nispio

पूर्णतया सहमत! बिल्कुल अस्पष्ट है कि इसका उपयोग कैसे किया जाए। मेरे पास बस मास्क लाइनें हैं, तो KB / binded के साथ mc / edit-lines करें (Mx के माध्यम से नहीं जैसा कि Github पर उल्लेख किया गया है) तो मुझे कई कर्सर दिखाई देते हैं लेकिन वे किसी भी पाठ इनपुट के बाद गायब हो जाते हैं

— Dima Fomin

Answer 1

@Bastibe के उपयोगों के अलावा, मैं कई श्रोताओं का उपयोग पंक्तियों के समूह के आरंभ / अंत से पाठ जोड़ने या हटाने के लिए करता हूं:

1. ब्याज के क्षेत्र की शुरुआत या अंत में बिंदु को स्थानांतरित करें
2. कॉल करें set-rectangular-region-anchor(जो भी कुंजी आपको पसंद हो, मुझे लगता है कि मैग्नेर्स का सुझाव था H-space, यदि आपके पास हाइपर कुंजी है)
3. जब तक आपके द्वारा संपादित की जाने वाली प्रत्येक पंक्ति पर कर्सर नहीं होता तब तक लाइन ( C-nऔर C-p) द्वारा आगे या पीछे की ओर चला गया
4. आवश्यकतानुसार पाठ डालें या हटाएं, C-eवहां परिवर्तन करने के लिए वैकल्पिक रूप से पंक्ति के अंत तक ( )।

आप लाइनों के साथ आगे और पीछे बढ़ने के लिए उपयोग कर सकते हैं forward-word, forward sentenceजो आपको प्रत्येक पंक्ति में चौथे शब्द को संपादित करने की अनुमति देता है, भले ही प्रत्येक पंक्ति पर पाठ समान न हो।

एक उदाहरण के रूप में, मैं हर समय इस तरह का काम करता हूं:

• C-u M-!ls / टेस्ट-डेट / pp5 / * fsaRETURN

  यह pp5 डायरेक्टरी के कंटेस्टेंट्स को बफर में इन्सर्ट करता है। मैं !सूची के प्रारंभ में बिंदु रखता हूं :

→

!/test-dat/pp5/ONAB-6-5_Frag#89.fsa
/test-dat/pp5/QCJB-22-5_Frag#90.fsa
/test-dat/pp5/ONGL-1-5_Frag#102.fsa
/test-dat/pp5/ONGL-1-5_Frag#78.fsa

• हर पंक्ति में कर्सर जोड़ें H-space, C-nx 4
• प्रत्येक पंक्ति को डुप्लिकेट करें C-k C-y space C-y C-a

→

!/test-dat/pp5/ONAB-6-5_Frag#89.fsa /test-dat/pp5/ONAB-6-5_Frag#89.fsa
!/test-dat/pp5/QCJB-22-5_Frag#90.fsa /test-dat/pp5/QCJB-22-5_Frag#90.fsa
!/test-dat/pp5/ONGL-1-5_Frag#102.fsa /test-dat/pp5/ONGL-1-5_Frag#102.fsa
!/test-dat/pp5/ONGL-1-5_Frag#78.fsa /test-dat/pp5/ONGL-1-5_Frag#78.fsa

• M-dx 3 C-d C-fx3 M-dx3 <के साथ चर नामों में पहले खंड को ट्रिम करें -

→

ONAB-6-5 <-! /test-dat/pp5/ONAB-6-5_Frag#89.fsa
QCJB-22-5 <-! /test-dat/pp5/QCJB-22-5_Frag#90.fsa
ONGL-1-5 <-! /test-dat/pp5/ONGL-1-5_Frag#102.fsa
ONGL-1-5 <-! /test-dat/pp5/ONGL-1-5_Frag#78.fsa

• फिर इसे लोड करने के लिए फ़ंक्शन में वास्तविक फ़ाइल नाम लपेटें: read.file ( C-d" C-e")RETURN

→

ONAB-6-5 <- read.file("/test-dat/pp5/ONAB-6-5_Frag#89.fsa")
QCJB-22-5 <- read.file("/test-dat/pp5/QCJB-22-5_Frag#90.fsa")
ONGL-1-5 <- read.file("/test-dat/pp5/ONGL-1-5_Frag#102.fsa")
ONGL-1-5 <- read.file("/test-dat/pp5/ONGL-1-5_Frag#78.fsa")

और वोइला, आपने उस लिस्टिंग को पढ़ने के लिए एक फ़ाइल लिस्टिंग को कोड में बदल दिया है। यह वास्तव में वास्तव में करने की तुलना में वर्णन करने के लिए बहुत कठिन है!

Comments

यदि आप एक ही काम अक्सर करते हैं, तो आप इसे एक कीबोर्ड मैक्रो में लपेट सकते हैं। कीबोर्ड मैक्रोज़ और multiple-cursorsवास्तव में शक्तिशाली संयोजन बना सकता है।

— nispio

@nispio सहमत! कभी-कभी मैं उसी प्रक्रिया को दोहरा रहा हूं और एक मैक्रो उपयोगी होगा। अक्सर, हालांकि, काम के प्रवाह के बीच में छोटे अंतर होते हैं जिन्हें थोड़े बदलाव की आवश्यकता होती है जो एक मैक्रो को 'तोड़' देंगे।

— टायलर

आप अक्सर उस स्थान का सही-सही वर्णन कर सकते हैं, जिस पर आप चाहते हैं कि कर्सर regexp का उपयोग करके कूद जाए। ऐसे मामलों में, का उपयोग phi-searchकमांड के साथ नेविगेट करने की तुलना में अधिक मजबूत हो सकता है जैसेM-f (x3)

— nispio

@nispio यकीन है, यह स्थिति पर निर्भर करता है। लगातार संरचित नामों के साथ शब्द द्वारा स्थानांतरित करना आसान है। मैंने कई कर्सर में खोज का उपयोग नहीं किया था क्योंकि अंतर्निहित एमएसीएस खोज कमांड एमसी के साथ भंगुर हैं। मैं इस बारे में नहीं जानता था phi-search, जो बहुत अच्छा लगता है!

— टायलर

Answer 2

मेरे पास मूल रूप से दो लगातार उपयोग के मामले हैं multiple-cursors:

• कुछ स्ट्रिंग बदलें। एक स्ट्रिंग के एक उदाहरण को चिह्नित करें , फिर उपयोग करें mc/mark-next-like-thisऔर mc/mark-previous-like-thisइसके अधिक उदाहरणों को चिह्नित करें। मैं तो तुरंत C-wहर उदाहरण को हटाने के लिए मारा , और इसके बजाय एक नया स्ट्रिंग लिखता हूं । मैं इसका उपयोग अक्सर कोड में एक चर का नाम बदलने के लिए करता हूं।
• एक साथ कई जगह संपादित करें। या तो पहले की तरह एक स्ट्रिंग के कई उदाहरणों को चिह्नित करें, लेकिन C-gअलग-अलग लाइनों के एक ही कॉलम में चिह्न का उपयोग करके या तुरंत चयन (लेकिन कर्सर नहीं) को रद्द करें और mc/edit-linesप्रति पंक्ति एक कर्सर प्राप्त करने के लिए उपयोग करें। अब आप नियमित रूप से एडिटिंग कमांड का उपयोग कर सकते हैं जो इनमें से हर एक कर्सर पर काम करते हैं।

पहला उपयोग मामला विशेष रूप से उपयोगी है expand-region। मैं है er/expand-regionकरने के लिए बाध्य C-jहै, और mc/mark-next-like-thisऔर mc/mark-previous-like-thisकरने के लिए C->और C-<। उस के साथ, मैं आसानी से शब्द बिंदु का चयन कर सकता हूं, और उस शब्द की अगली / पिछली घटना को तुरंत चिह्नित कर सकता हूं।

दूसरे उपयोग के मामले ने मेरे लिए मैक्रोज़ के अधिकांश उपयोगों को बदल दिया। मैक्रो रिकॉर्ड करने के बजाय, और फिर कई स्थानों पर आवेदन करने के बाद, मैं हर जगह पर एक कर्सर रखूँगा, और बस एक ही बार में सभी स्थानों पर ऑपरेशन करूँगा।

Comments

साभार @bastibe किसी विशेष बाइंडिंग कि आप या multiple-cursors उदाहरण के लिए सलाह देते हैं mark-next-like-thisऔर mark-previous-like-this?

— एमिलियो वाज़क्वेज़-रीना

@ user815423426 पोस्ट में उल्लिखित के रूप में, मैं उपयोग C->और के C-<लिए mark-next-like-thisऔर mark-previous-like-this।

— बस्तिबी

खोज और बदलने के लिए क्यों नहीं M720% का उपयोग करें ?

— दिमा फोमिन

Answer 3

मैं कुछ एक्सट्रा जोड़ना चाहूंगा जो मैं कभी-कभी उपयोग करता हूं multiple-cursors।

मैंने पाया है कि निम्नलिखित उपयोगी है:

आईवाई-जाना करने के लिए चार

कभी-कभी, आप अपने आप को अगले #या अगले ,या कुछ विशिष्ट परिसीमन में जाने की आवश्यकता पाते हैं । यह विशेष रूप से तब उपयोगी होता है जब आपको प्रत्येक कर्सर के लिए अलग-अलग संख्या में शब्दों को स्थानांतरित करने की आवश्यकता होती है। यह कार्य प्रदान करता है iy-go-to-charऔर iy-go-to-char-backward, जिसे आप अच्छी तरह से बांध सकते हैं और उपयोग कर सकते हैं।

विस्तार-क्षेत्र

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

कस्टम सामान

ये ऐसी चीजें हैं जो मेरे कॉन्फिग्रेशन में बिलकुल सटीक हैं, लेकिन मुझे उपयोगी लगती हैं। शायद मेरे द्वारा नहीं लिखा गया है।

इनपुट के लिए प्रॉम्प्ट
मुझे प्रत्येक कर्सर के नीचे एक अलग स्ट्रिंग लगाने के अनुरोध के जवाब में मैग्नेर्स से यह एक मिला। कोड सरल है, लेकिन इसे किसी चीज से बांधना और कई कर्सर के लिए उपयोग करना प्रत्येक स्थान पर थोड़ा अलग सामान डालने का एक आसान तरीका है।

(defun prompt-for-insert ()
  (interactive)
  (insert (read-string "Insert: ")))

बिंदु पर वृद्धि संख्या
यह या तो SO, या emacswiki से आई है। जो निश्चित नहीं है। यह अपने आप में बहुत उपयोगी है, और जब भी संयोजन में उपयोग किया जाता हैmc/insert-numbers

(defun my-increment-number-decimal (&optional arg)
  "Increment the number forward from point by 'arg'."
  (interactive "p*")
  (save-excursion
    (save-match-data
      (let (inc-by field-width answer)
        (setq inc-by (if arg arg 1))
        (skip-chars-backward "0123456789")
        (when (re-search-forward "[0-9]+" nil t)
          (setq field-width (- (match-end 0) (match-beginning 0)))
          (setq answer (+ (string-to-number (match-string 0) 10) inc-by))
          (when (< answer 0)
            (setq answer (+ (expt 10 field-width) answer)))
          (replace-match (format (concat "%0" (int-to-string field-width) "d")
                                 answer)))))))

eval-and-प्रतिस्थापित
यह सुपर शक्तिशाली है, और कुछ वास्तव में उपयोगी बिट्स 'n' टुकड़ों को सक्षम करता है। यह मूल्यांकन करता है कि कर्सर के पीछे जो भी सेक्सप है, और उसका मूल्यांकन करने के परिणाम को सम्मिलित करता है।
साथ संयोजित multiple-cursors-numbersदो की जैसे करने के लिए सम्मिलित शक्तियों, या कि हो जाता है एक श्रृंखला 0 1 2 0 1 2 0 1 2प्रत्येक पंक्ति या कुछ और के पार। (मैंने इन दोनों को उपयोगी रूप से किया है) या s.elडिफ़ॉल्ट चीजों के साथ उन थकाऊ जावा कॉन्फिग को लिखने के लिए इसका उपयोग करें । आप प्रत्येक को लिखने CONFIG_VALUE_VARIABLE, तो में बदलना है कि CONFIG_VALUE_VARIABLE = "configValueVariable"चलाकर s-camel-case।

(defun eval-and-replace ()
  (interactive)
  (let ((value (eval (preceding-sexp))))
    (kill-sexp -1)
    (insert (format "%s" value))))

Comments

iy-go-to-char सुपर सहायक है। मुझे इसकी ही खोज थी।

— हेनरिक हार्टमैन

Answer 4

1. आप जो चाहते हैं उसके अंतिम छोर पर जाएँ।
2. तब तक दबाएं C-S-bया M-S-bचयन करें जब तक कि आपको कोई भाग चयनित न मिल जाए। आप शिफ्ट बाएँ तीर का भी उपयोग कर सकते हैं।
3. फिर दबाएं C->(यदि >आपके कीबोर्ड की कुंजी के शीर्ष पर कुंजी है तो प्रेस शिफ्ट करें) जब तक कि आपको एक से अधिक आइटम नहीं मिलते।

* पीछे का चयन करना महत्वपूर्ण है या पहला चयन कर्सर को गलत स्थिति में रखेगा।