वी (एम) में संपादन करने वाली फ़ाइल को कैसे निष्पादित करें

Question

फ़ाइल का निष्पादन कैसे करें कि मैं Vi (m) में संपादन कर रहा हूं और विभाजित विंडो (जैसे SciTE) में आउटपुट मिलता है?

बेशक मैं इसे इस तरह निष्पादित कर सकता था:

:!scriptname

लेकिन क्या स्क्रिप्ट नाम लिखने से बचना है और स्क्रीन के ठीक नीचे विभाजन विंडो में आउटपुट कैसे प्राप्त करना है?

Comments

:!% आपको 'स्क्रिप्टनाम' लिखने से बचने देगा। नीचे दिए गए समाधान बेहतर हैं, लेकिन मुझे लगा कि मैं आपके द्वारा तय किए गए मामले में इसका उल्लेख करूंगा:% काफी अच्छा है।

— overthink

एक और नोट, आप वर्तमान फ़ाइल के पूर्ण पथ को संदर्भित करने के लिए%: p (केवल% के बजाय) का उपयोग कर सकते हैं। यदि आपकी वर्तमान निर्देशिका कहीं और है तो यह आवश्यक हो सकता है।

— एंडी 5'09

रूबी लिपियों को चलाने के लिए: रूबी% चाल चलेगी

— एलेक्सिस पेरियर

! @andy:%: पी भी निर्देशिका $ पथ में किया जा रहा नहीं होने resolves

— MayTheSForceBeWithYou

और :!"%:p"व्हॉट्सएप से निपटने के लिए।

— OJFord

Answer 1

नहीं है makeआदेश। यह makeprgविकल्प में सेट कमांड चलाता है । %वर्तमान फ़ाइल नाम के लिए प्लेसहोल्डर के रूप में उपयोग करें । उदाहरण के लिए, यदि आप एक अजगर स्क्रिप्ट का संपादन कर रहे थे:

:set makeprg=python\ %

हां, आपको अंतरिक्ष से भागने की जरूरत है। इसके बाद आप बस चला सकते हैं:

:make

यदि आप चाहें, तो आप autowriteविकल्प सेट कर सकते हैं और इसे चलाने से पहले अपने आप सहेज लेंगे makeprg:

:set autowrite

यह निष्पादित भाग को हल करता है। उस आउटपुट को विभाजित विंडो में प्राप्त करने का कोई तरीका न जानें, जिसमें फ़ाइल को पुनर्निर्देशन शामिल नहीं है।

Comments

दरअसल, आपके समाधान में आउटपुट को एक विभाजित विंडो में मिलता है। :copenचलाने के द्वारा निर्मित "त्रुटि सूची" को खोलने के लिए उपयोग करें :make। अपनी खिड़की। दुर्भाग्य से, आउटपुट को ठीक से स्वरूपित करने के लिए, errorformatविकल्प का कुछ अंतिम रूप देना आवश्यक है। अन्यथा आउटपुट जीसीटी के प्रारूप के अनुसार माना जाएगा।

— कॉन्सपिसेसी कम्पाइलर

आप "फाइनैग्लिंग" त्रुटिफॉर्म के बारे में निश्चित हैं। यह कुछ पर्ल कोड जैसा मैंने देखा है ...

— आर। मार्टिनो फर्नांडिस

यह सुविधा vim से परियोजना के 'मेक' के लिए उपलब्ध है (क्षमता की तरह आईडीई देता है)। ब्रायन कारपर का समाधान ( :let f=expand("%")|vnew|execute '.!ruby "' . f . '"') हालांकि गूढ़ दिखता है, ठीक उसी तरह से काम करता है जैसा प्रश्न के लेखक ने पूछा है।

— अजयकुमारबसुथकर

Answer 2

वर्तमान बफ़र फ़ाइल नाम का उपयोग करने के लिए, उपयोग करें %। इसे एक चर में लाने के लिए आप expand()फ़ंक्शन का उपयोग कर सकते हैं । नई बफर के साथ एक नई विंडो खोलने के लिए, का उपयोग करें :newया :vnew। वर्तमान बफ़र में एक कमांड से आउटपुट को पाइप करने के लिए, उपयोग करें :.!। यह सब एक साथ डालें:

:let f=expand("%")|vnew|execute '.!ruby "' . f . '"'

स्पष्ट रूप rubyसे जो कुछ भी आप चाहते हैं उसके साथ प्रतिस्थापित करना। मैंने इस्तेमाल किया executeइसलिए मैं उद्धरण चिह्नों के साथ फ़ाइलनाम को घेर सकता हूं, इसलिए यदि फ़ाइल नाम में स्थान है तो यह काम करेगा।

Comments

@baboonWorksFine उपयोग :command! R let f=expand("%")|vnew|execute '.!ruby "' . f . '"'सिर्फ उपयोग करने में सक्षम होना :Rअपने आदेश पर अमल करने

— xorpaul

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

— --उसम

Answer 3

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

उदाहरण के लिए:

! node %

कमांड प्रॉम्प्ट विंडो खोलने और कमांड लॉन्च करने के बराबर है:

cd my_current_directory 
node my_current_file

विवरण के लिए "विम टिप्स: बाहरी कमांड के साथ काम करना" देखें।

Answer 4

मेरे पास मेरे vimrc में एक शॉर्टकट है:

nmap <F6> :w<CR>:silent !chmod 755 %<CR>:silent !./% > .tmp.xyz<CR>
     \ :tabnew<CR>:r .tmp.xyz<CR>:silent !rm .tmp.xyz<CR>:redraw!<CR>

यह वर्तमान बफर को लिखता है, वर्तमान फ़ाइल को निष्पादन योग्य बनाता है (केवल यूनिक्स), इसे निष्पादित करता है (केवल यूनिक्स) और आउटपुट को .tmp.xyz पर पुनर्निर्देशित करता है, फिर एक नया टैब बनाता है, फ़ाइल को पढ़ता है और फिर उसे हटा देता है।

इसे तोड़कर:

:w<CR>                             write current buffer
:silent !chmod 755 %<CR>           make file executable
:silent !./% > .tmp.xyz<CR>        execute file, redirect output
:tabnew<CR>                        new tab
:r .tmp.xyz<CR>                    read file in new tab
:silent !rm .tmp.xyz<CR>           remove file
:redraw!<CR>                       in terminal mode, vim get scrambled
                                   this fixes it

Comments

मुझे आपका समाधान बहुत पसंद आया, और इसे इस्तेमाल करने के कुछ समय बाद, मुझे लगा कि इसमें सुधार किया जा सकता है। तो यहाँ मेरा :w<CR>:silent !chmod +x %:p<CR>:silent !%:p 2>&1 | tee ~/.vim/output<CR>:split ~/.vim/output<CR>:redraw!<CR>इस पर ध्यान है: - यह दोनों को stdout और stderr को अस्थायी फ़ाइल में रीडायरेक्ट करता है, और ऐसा करने से पहले, यह सब कुछ stdout को प्रिंट करता है, इसलिए यदि कोई स्क्रिप्ट आपको चलाने के लिए लंबा समय लेती है तो आप वास्तव में इसे देख सकते हैं। इसके अलावा, यह निर्देशिका-स्वतंत्र है (मुझे उनके पूर्ण पथ द्वारा फ़ाइलें खोलने पर त्रुटियाँ हो रही थीं)। यह अंतःक्रियात्मक रूप से स्क्रिप्ट नहीं चलाता है, और मुझे इसे बनाने का कोई तरीका नहीं मिला है।

— किरिल जी

fyi - @Cyril के समाधान पर, मुझे पाइप प्रतीक से बचना पड़ा: | -> \ |

— एमफेटिस

Answer 5

शेल स्क्रिप्ट के लिए मैंने उपयोग किया है

:set makeprg=%

:make

Answer 6

विम 8 में एक इंटरेक्टिव टर्मिनल बनाया गया है। स्प्लिट पेन में करंट बैश स्क्रिप्ट चलाने के लिए:

:terminal bash %

या कम के लिए

:ter bash %

% मौजूदा फ़ाइल नाम के लिए फैलता है।

से :help terminal:

The terminal feature is optional, use this to check if your Vim has it:
    echo has('terminal')
If the result is "1" you have it.

Answer 7

मैं मानचित्रों के माध्यम से थोड़ा अधिक घुसपैठ तंत्र का उपयोग करता हूं:

map ;e :w<CR>:exe ":!python " . getreg("%") . "" <CR>

बस इसे बनाता है इसलिए मुझे बचाने की ज़रूरत नहीं है, फिर जाओ। बस जाओ।

Comments

यदि आप स्वत: संचय विकल्प सेट करते हैं, तो आप चला सकते हैं: बनाओ और इसे ... ऑटो पहले बचाता है।

— आर। मार्टिनो फर्नांडिस

Answer 8

आप विम के प्लगइन बीएक्सईसी का उपयोग कर सकते हैं । मेरी जानकारी में नवीनतम संस्करण 0.5 है।

फिर:

$ mkdir -p ~/.vim/plugin
$ mv bexec-0.5.vba ~/.vim/plugin
$ vim ~/.vim/plugin/bexec-0.5.vba

.Vba फ़ाइल को संपादित करते समय अपने आप को अंदर करें:

:so %

कुछ आउटपुट आपको यह बताएंगे कि bexec.vim को दस्तावेज़ीकरण, आदि के रूप में लिखा गया है।

अब, आप अपने परीक्षण को खोल सकते हैं (जो भी भाषा की पटकथा जिसमें # ठीक से काम कर रहा है!

:Bexec 

नोट: मैं चाहता था कि विभाजन क्षैतिज के बजाय ऊर्ध्वाधर हो, इसलिए मैंने किया:

$ grep -i -n split ~/.vim/plugin/bexec.vim | grep -i hor
102:    let bexec_splitdir = "hor" " hor|ver
261:        exec {"ver":"vsp", "hor":"sp"}[g:bexec_splitdir]

और "hor" से "ver" के मान को बदल दिया ।।

मुझे पता है कि यह एक पुराना सवाल है, लेकिन मुझे उम्मीद है कि इससे किसी को मदद मिल सकती है। कौरसेरा के स्टार्टअप इंजीनियरिंग कोर्स को ले कर मैं एक ही मुद्दे पर चल रहा हूं जहां प्रोफेसर पलाजी Emacs का उपयोग करते हैं और मुझे Emss पसंद नहीं है।

Comments

आपको अपने स्थानीय .vimrc में वरीयता संबंधी सेटिंग्स बदलनी चाहिए। bexec "bexec_splitdir = 'hor'" सेटिंग देता है जो प्लगइन कोड को संशोधित किए बिना ऐसा कर सकता है।

— सौरभ हिरानी

Answer 9

@SethKriticos और @Cyril उत्तरों के आधार पर मैं अब निम्नलिखित का उपयोग करता हूं:

function! Setup_ExecNDisplay()
  execute "w"
  execute "silent !chmod +x %:p"
  let n=expand('%:t')
  execute "silent !%:p 2>&1 | tee ~/.vim/output_".n
  " I prefer vsplit
  "execute "split ~/.vim/output_".n
  execute "vsplit ~/.vim/output_".n
  execute "redraw!"
  set autoread
endfunction

function! ExecNDisplay()
  execute "w"
  let n=expand('%:t')
  execute "silent !%:p 2>&1 | tee ~/.vim/output_".n
  " I use set autoread
  "execute "1 . 'wincmd e'"
endfunction

:nmap <F9> :call Setup_ExecNDisplay()<CR>
:nmap <F2> :call ExecNDisplay()<CR>

अपनी स्क्रिप्ट को निष्पादित करने और अपनी आउटपुट फ़ाइल को टी करने के लिए नई विंडो और F2 सेटअप करने के लिए F9 का उपयोग करें।

मैंने आउटपुट फ़ाइल नाम में स्क्रिप्ट का नाम भी जोड़ा है, ताकि आप एक ही समय में कई स्क्रिप्ट के लिए इसका उपयोग कर सकें।

Answer 10

अपने में .vimrcआप इस फ़ंक्शन को पेस्ट कर सकते हैं

function! s:ExecuteInShell(command)
  let command = join(map(split(a:command), 'expand(v:val)'))
  let winnr = bufwinnr('^' . command . '$')
  silent! execute ':w'
  silent! execute  winnr < 0 ? 'vnew ' . fnameescape(command) : winnr . 'wincmd w'
  setlocal buftype=nowrite bufhidden=wipe nobuflisted noswapfile nowrap number
  silent! execute 'silent %!'. command
  silent! redraw
  silent! execute 'au BufUnload <buffer> execute bufwinnr(' . bufnr('#') . ') . ''wincmd w'''
  silent! execute 'nnoremap <silent> <buffer> <LocalLeader>r :call <SID>ExecuteInShell(''' . command . ''')<CR>'
  silent! execute 'wincmd w'
  " echo 'Shell command ' . command . ' executed.'
endfunction
command! -complete=shellcmd -nargs=+ Shell call s:ExecuteInShell(<q-args>)
cabbrev shell Shell

उसके बाद, उदाहरण के रूप में vimरन कमांड :shell python ~/p.pyमें। और आउटपुट आपको स्प्लिट्ड विंडो में मिलेगा। + p.pyउदाहरण के रूप में परिवर्तनों के बाद आप फिर से उसी कमांड को चलाएंगे, यह फ़ंक्शन फिर से नई विंडो नहीं बनाएगा, यह पिछले (उसी) स्प्लिटेड विंडो में परिणाम प्रदर्शित करेगा।

Comments

यह बहुत बढ़िया है, धन्यवाद! जब बफर फिर से लिखा जाता है तो आप इसे फिर से कैसे बदल सकते हैं?

— इलाजी 6

Answer 11

@xorpaul

मैं काफी समय से इस स्क्रिप्ट (अजगर / विंडोज) की तलाश में था। जैसा कि विंडोज में कोई "टी" नहीं है, मैंने इसे इसे बदल दिया:

function! Setup_ExecNDisplay()
  execute "w"
  let n=expand('%:t')
  execute "silent ! python % > d:\\temp\\output_".n ." 2>&1"
  execute "vsplit d:\\temp\\output_".n
  execute "redraw!"
  set autoread
endfunction

function! ExecNDisplay()
  execute "w"
  let n=expand('%:t')
  execute "silent ! python % > d:\\temp\\output_".n . " 2>&1"
endfunction

:nmap <F9> :call Setup_ExecNDisplay()<CR>
:nmap <F2> :call ExecNDisplay()<CR>

Answer 12

जैसा कि नीचे दिखाया गया है, बस कोलोन और विस्मयादिबोधक चिह्न का उपयोग करें

:! <script_name>

Answer 13

मैं प्लगइन quickrun की सिफारिश करेंगे । यह कॉन्फ़िगर करने के लिए तेज़ और सरल है। यहाँ थोड़ा प्रदर्शन है: