О каких темных углах Вим твоя мама никогда не говорила?

Не может быть того, что 99% пользователей Vim не знают, но это то, что я использую каждый день и что любой Linux + Vim poweruser должен знать.

Основная команда, но чрезвычайно полезна.

:w !sudo tee %

Я часто забываю sudo перед редактированием файла. У меня нет прав на запись. Когда я пришел, чтобы сохранить этот файл и получить ошибку разрешения, я просто выдаю эту команду vim, чтобы сохранить файл без необходимости сохранения его в временном файле, а затем снова скопировать его.

Вы, очевидно, должны быть в системе с установленным sudo и иметь права sudo.

Что-то, что я недавно обнаружил, что я подумал, было очень круто:

:earlier 15m

Возвращает документ обратно, как это было 15 минут назад. Может принимать различные аргументы за количество времени, которое вы хотите откат, и зависит от undolevels. Может быть отменено с помощью противоположной команды :later

:! [command] выполняет внешнюю команду, пока вы находитесь в Vim.

Но добавьте точку после двоеточия, :.! [command], и она выведет вывод команды в текущее окно. Это : . !

Например:

:.! ls

Я использую это много для таких вещей, как добавление текущей даты в документ, который я печатаю:

:.! date

Не совсем неясно, но есть несколько команд "delete in", которые чрезвычайно полезны, например..

• diw, чтобы удалить текущее слово
• di( для удаления внутри текущего пароля
• di", чтобы удалить текст между кавычками

Другие можно найти на :help text-objects

de Удалите все до конца слова, нажав. в твоем сердце.

ci (xyz [Esc] - Это странно. Здесь "i" не означает режим вставки, а означает внутри скобки. Таким образом, эта последовательность разрезает текст внутри скобки, в которых вы находитесь, и заменяет ее "xyz", а также работает внутри квадратного и фигурного скобок - просто сделайте ci [или ci {соответственно. Естественно, вы можете сделать di (если вы просто хотите удалить весь текст без ввода текста вы также можете сделать a вместо i, если вы хотите также удалить круглые скобки, а не только текст внутри них.

ci " - сокращает текст в текущих кавычках

ciw - сокращает текущее слово. Это работает так же, как и предыдущее, за исключением того, что ( заменяется на w.

C - отрежьте остальную часть линии и переключитесь в режим вставки.

ZZ - сохранить и закрыть текущий файл (WAY быстрее, чем Ctrl-F4, чтобы закрыть текущую вкладку!)

ddp - переместить текущую строку на одну строку вниз

xp - переместить текущий символ в одну позицию вправо

U - верхний регистр, поэтому viwU поддерживает слово

~ - переключает регистр, поэтому viw~ будет обращать вспять весь текст

Ctrl + u/Ctrl + d прокрутите страницу полуэкрана вверх или вниз. Это кажется более полезным, чем обычный полноэкранный пейджинг, поскольку он упрощает просмотр того, как связаны два экрана. Для тех, кто по-прежнему хочет прокручивать весь экран за один раз, нажмите Ctrl + f для Forward и Ctrl + b для Backward. Ctrl + Y и Ctrl + E прокручиваются вниз или вверх по одной строке за раз.

Сумасшедшая, но очень полезная команда - zz - она ​​прокручивает экран, чтобы эта линия отображалась посередине. Это отлично подходит для размещения фрагмента кода, над которым вы работаете, в центре вашего внимания. Команды sibling - zt и zb - делают эту строку верхней или нижней на экране, что не так полезно.

% находит и переходит к соответствующей скобке.

de - удалить из курсора в конец слова (вы также можете сделать dE для удаления до следующего пробела)

bde - удалить текущее слово, разделитель слева направо

df [пробел] - удалять до и включать следующее пространство

dt. - удалить до следующей точки

dd - удалить всю строку

ye (или yE) - текст yanks отсюда до конца слова

ce - прорезает конец слова

bye - копирует текущее слово (заставляет меня задаться вопросом, что делает "привет"!)

yy - копирует текущую строку

cc - сокращает текущую строку, вы также можете сделать S. Там также нижняя крышка S, которая обрезает текущий символ и переключается в режим вставки.

viwy или viwc. Yank или изменить текущее слово. Нажмите w несколько раз, чтобы продолжать выбирать каждое последующее слово, используйте b для перемещения назад

vi { - выберите весь текст в квадратных скобках. va {- выберите весь текст, включая {} s

vi (p - выделите все внутри() s и замените вставляемым текстом

b и e перемещайте курсор по слову, аналогично тому, как обычно Ctrl + Arrows. Определение слова несколько отличается, хотя несколько последовательных delmiters рассматриваются как одно слово. Если вы начинаете посередине слова, нажатие b всегда приведет вас к началу текущего слова, и каждый последующий b перейдет к началу следующего слова. Точно так же и легко запомнить, e получает курсор до конца текущего и каждого последующего слова.

, аналогичный b/e, capital b и e перемещать курсор по одному слову, используя только пробелы в качестве разделителей.

столица D (сделайте глубокий вдох) Удаляет остальную часть строки справа от курсора, такую ​​же, как Shift + End/Del в обычных редакторах (обратите внимание на 2 нажатия клавиши - Shift + D - вместо 3)

То, что я редко нахожу в большинстве учебников Vim, но он НЕОБХОДИМ полезен (по крайней мере для меня), это

g; and g,

для перемещения (вперед, назад) через список изменений.

Позвольте мне показать, как я его использую. Иногда мне нужно скопировать и вставить фрагмент кода или строки, например, шестнадцатеричный цветовой код в файле CSS, поэтому я ищу, прыгаю (не заботясь о том, где находится матч), скопируйте его, а затем отскочите назад (g;) туда, где Я редактировал код, чтобы вставить его. Нет необходимости создавать отметки. Simpler.

Только мои 2центы.

:%!xxd

Сделайте vim в шестнадцатеричном редакторе.

:%!xxd -r

Revert.

Предупреждение: если вы не редактируете с двоичным кодом (-b), вы можете повредить файл. - Джош Ли в комментариях.

Иногда параметр в вашем .vimrc будет переопределен плагином или автокомандой. Для отладки этого полезной трюки является использование команды verbose в сочетании с: set. Например, чтобы выяснить, где cident получил set/unset:

:verbose set cindent?

Это приведет к тому, что:

cindent
    Last set from /usr/share/vim/vim71/indent/c.vim

Это также работает с картами и бликами. (Спасибо joeytwiddle за указание на это.) Например:

:verbose nmap U
n  U             <C-R>
        Last set from ~/.vimrc

:verbose highlight Normal
Normal         xxx guifg=#dddddd guibg=#111111 font=Inconsolata Medium 14
        Last set from ~/src/vim-holodark/colors/holodark.vim

gv

Выбирает последний визуальный выбор.

Хотите посмотреть на свою историю команд?

q:

Затем просмотрите, отредактируйте и, наконец, выполните команду.

Вы делаете аналогичные изменения в двух файлах и переключаетесь между ними? (Скажем, исходные и заголовочные файлы?)

:set hidden
:map <TAB> :e#<CR>

Затем перейдите туда и обратно между этими файлами.

Не уверен, что это вообще считается темно-угловым, но я только что узнал об этом...

:g/match/y A

будет копировать все строки, содержащие "совпадение" в регистр "a/@a. (Капитализация как A делает vim добавлением янки вместо замены предыдущего содержимого регистра.) Я использовал его очень недавно при создании таблиц стилей Internet Explorer.

:%TOhtml

Создает html-рендеринг текущего файла.

Vim откроет URL-адрес, например

vim http://stackoverflow.com/

Приятно, если вам нужно подтянуть источник страницы для справки.

Макросы могут вызывать другие макросы и также могут вызывать себя.

например:

qq0dwj@qq@q

... удалит первое слово из каждой строки до конца файла.

Это довольно простой пример, но он демонстрирует очень мощную функцию vim

Предполагая, что вы скомпилировали поддержку Perl и/или Ruby, :rubydo и :perldo будут запускать один-лайнер Ruby или Perl в каждой строке диапазона (по умолчанию для всего буфера), с $_, привязанным к текст текущей строки (минус новая строка). Манипуляция $_ изменит текст этой строки.

Вы можете использовать это, чтобы делать определенные вещи, которые легко сделать на языке сценариев, но не так очевидны с помощью встроенных Vim. Например, чтобы изменить порядок слов в строке:

:perldo $_ = join ' ', reverse split

Вставить случайную строку из 8 символов (A-Z) в конце каждой строки:

:rubydo $_ += ' ' + (1..8).collect{('A'..'Z').to_a[rand 26]}.join

Вы ограничены действиями по одной строке за раз, и вы не можете добавлять новые строки.

^ O и ^ I

Перейдите в более старую/новую позицию. Когда вы перемещаетесь по файлу (путем поиска, перемещения команд и т.д.), Vim воспроизводит эти "прыжки", поэтому вы можете повторять эти прыжки назад (^ O - O для старых) и вперед (^ я - рядом с я на клавиатуре). Я считаю, что это очень полезно при написании кода и выполнении большого количества запросов.

г

Перейдите в положение, в котором режим вставки был остановлен последним. Я часто нахожусь в редактировании, а затем что-то ищу. Чтобы вернуться в место редактирования, нажмите gi.

гс

поместите курсор на имя файла (например, включите заголовочный файл), нажмите gf и файл откроется

Gf

похож на gf, но распознает формат "[имя файла]: [номер строки]". Нажатие gF откроет [имя файла] и установит курсор на [номер строки].

^ P и ^ N

Автоматическое заполнение текста при редактировании (^ P - предыдущее совпадение и ^ N следующее совпадение)

^ Х ^ л

Пока редактирование завершается в той же строке (полезно для программирования). Вы пишете код, а затем помните, что у вас есть тот же код где-то в файле. Просто нажмите ^ X ^ L и завершена полная строка

^ X ^ F

Заполните имена файлов. Вы пишете "/etc/pass" Хмм. Вы забыли имя файла. Просто нажмите ^ X ^ F и имя файла будет завершено

^ Z или: sh

Переместить временную оболочку. Если вам нужно быстрое избиение:

• нажмите ^ Z (чтобы поместить vi в фоновом режиме), чтобы вернуться в исходную оболочку и нажмите fg, чтобы вернуться в vim назад.
• нажмите: sh, чтобы перейти к суб-оболочке и нажмите ^ D/exit, чтобы вернуться в vi back

" insert range ip's
"
"          ( O O )
" =======oOO=(_)==OOo======

:for i in range(1,255) | .put='10.0.0.'.i | endfor

Ввод == исправит отступ текущей строки на основе указанной выше строки.

Собственно, вы можете сделать одно = знак, за которым следует любая команда перемещения. = {движение}

Например, вы можете использовать движение%, которое перемещается между соответствующими фигурками. Поместите курсор на {в следующем коде:

if (thisA == that) {
//not indented
if (some == other) {
x = y;
}
}

И нажмите =%, чтобы мгновенно получить это:

if (thisA == that) {
    //not indented
    if (some == other) {
        x = y;
    }
}

В качестве альтернативы вы можете сделать = a { внутри блока кода, вместо того, чтобы позиционировать себя прямо на символе {.

Это хороший трюк, чтобы повторно открыть текущий файл с другой кодировкой:

:e ++enc=cp1250 %:p

Полезно, когда вам нужно работать с устаревшими кодировками. Поддерживаемые кодировки перечислены в таблице под encoding-values (см. help encoding-values). Подобная вещь также работает для ++ff, так что вы можете повторно открыть файл с завершением строки Windows/Unix, если вы впервые ошибетесь (см. help ff).

imap jj <esc>

Давайте посмотрим, какой небольшой редактор IDE выполнит транспонирование столбцов.

:%s/\(.*\)^I\(.*\)/\2^I\1/

Объяснение

\( и \) заключается в том, как запомнить материал в regex-land. И \1, \2 и т.д. - это то, как извлекать запоминающиеся вещи.

>>> \(.*\)^I\(.*\)

Помните все, за которым следует ^I (вкладка), за которым следует все.

>>> \2^I\1

Замените вышеуказанный материал на "2-й материал, который вы запомнили", а затем "1-й материал, который вы запомнили" - по существу, выполнив транспонирование.

Не совсем темный секрет, но мне нравится вставлять следующее отображение в мой .vimrc файл, поэтому я могу нажать "-" (минус) в любое время, чтобы открыть файл-проводник, чтобы отображать файлы, смежные с тем, который я только что редактировал. В файловом проводнике я могу нажать другой "-", чтобы переместиться вверх по одному каталогу, обеспечивая бесшовный просмотр сложных структур каталогов (например, тех, которые используются в настоящее время средами MVC):

map - :Explore<cr>

Они могут быть полезны и для кого-то. Мне нравится прокручивать экран и одновременно перемещать курсор:

map <c-j> j<c-e>
map <c-k> k<c-y>

Навигация по вкладкам - мне нравятся вкладки, и мне нужно легко перемещаться между ними:

map <c-l> :tabnext<enter>
map <c-h> :tabprevious<enter>

Только в Mac OS X: Навигация по Safari-подобной вкладке:

map <S-D-Right> :tabnext<cr>
map <S-D-Left> :tabprevious<cr>

Часто мне нравится изменять текущие каталоги во время редактирования, поэтому мне нужно указывать пути меньше.

cd %:h

Мне нравится использовать 'sudo bash', и мой системный администратор ненавидит это. Он заблокировал "sudo", поэтому его можно было использовать только с несколькими командами (ls, chmod, chown, vi и т.д.), Но я смог использовать vim для получения корневой оболочки:

bash$ sudo vi +'silent !bash' +q
Password: ******
root#

Я часто использую много окон, когда я работаю над проектом, и иногда мне нужно изменить их размер. Вот что я использую:

map + <C-W>+
map - <C-W>-

Эти сопоставления позволяют увеличить и уменьшить размер текущего окна. Это довольно просто, но быстро.

:r! <command>

вставляет вывод внешней команды в буфер.

Сделайте некоторую математику и получите результат непосредственно в тексте:

:r! echo $((3 + 5 + 8))

Получить список файлов для компиляции при записи Makefile:

:r! ls *.c

Не смотрите на тот факт, что вы читаете в википедии, прямо вставьте его в документ, который вы пишете:

:r! lynx -dump http://en.wikipedia.org/wiki/Whatever

Не скрытая особенность, но очень полезная и экономия времени.

Если вы хотите сохранить сеанс открытых буферов, вкладок, маркеров и других параметров, вы можете сделать следующее:

mksession session.vim

Вы можете открыть сеанс, используя:

vim -S session.vim

Карта F5 для быстрого ROT13 вашего буфера:

map <F5> ggg?G``

Вы можете использовать его в качестве ключа босса:).

Я нашел этот сегодня через NSFAQ:

Комментировать блоки кода.

Войдите в режим Blockwise Visual, нажав CTRL-V.

Отметьте блок, который вы хотите прокомментировать.

Нажмите я (капитал I) и введите строку комментария в начале строки. (//для С++)

Нажмите "ESC", и все выбранные линии будут//добавлены в начало строки.

Я использую vim для практически любого редактирования текста, который я делаю, поэтому часто использую копии и вставки. Проблема в том, что vim по умолчанию часто искажает импортированный текст с помощью вставки. Способ остановить это - использовать

:set paste

перед тем, как вставлять ваши данные. Это не позволит ему испортиться.

Обратите внимание, что вам нужно будет выпустить :set nopaste для восстановления автоматического отступа. Альтернативные способы вставки предварительно форматированного текста - это регистры буфера обмена (* и +) и :r!cat (вам нужно будет закончить вложенный фрагмент с помощью ^ D).

Иногда также полезно включить высококонтрастную цветовую схему. Это можно сделать с помощью

:color blue

Я заметил, что он не работает на всех версиях vim, которые я использую, но он работает на большинстве.

Ctrl-n, в то время как в режиме вставки автоматически будет завершено любое слово, которое вы вводите, на основе всех слов, которые находятся в открытых буферах. Если имеется более одного совпадения, он предоставит вам список возможных слов, которые можно выполнить с помощью ctrl-n и ctrl-p.

Здесь что-то не очевидное. Если у вас много пользовательских плагинов/расширений в вашем домашнем доме, и вам иногда нужно работать с su/sudo/..., тогда это может быть полезно.

В вашем ~/.bashrc:

export VIMINIT=":so $HOME/.vimrc"

В вашем ~/.vimrc:

if $HOME=='/root'
        if $USER=='root'
                if isdirectory('/home/your_typical_username')
                        let rtuser = 'your_typical_username'
                elseif isdirectory('/home/your_other_username')
                        let rtuser = 'your_other_username'
                endif
        else
                let rtuser = $USER
        endif
        let &runtimepath = substitute(&runtimepath, $HOME, '/home/'.rtuser, 'g')
endif

Это позволит вашим локальным плагинам загружаться - каким бы способом вы не пользовались для изменения пользователя.

Вам также может потребоваться извлечь *.swp файлы из вашего текущего пути и в ~/vimtmp (это относится к .vimrc):

if ! isdirectory(expand('~/vimtmp'))
   call mkdir(expand('~/vimtmp'))
endif
if isdirectory(expand('~/vimtmp'))
   set directory=~/vimtmp
else
   set directory=.,/var/tmp,/tmp
endif

Кроме того, некоторые сопоставления, которые я использую для упрощения редактирования, делают ctrl + s работать как escape и ctrl + h/l переключают вкладки:

inoremap <C-s> <ESC>
vnoremap <C-s> <ESC>
noremap <C-l> gt
noremap <C-h> gT

gg=G

Исправляет отпечаток для всего файла. Мне не хватало моего верного <C-a><C-i> в Eclipse, но только что узнал, что vim красиво его обрабатывает.

Изменение sudo write:

в .vimrc

cmap w!! w !sudo tee % >/dev/null

После перезагрузки vim вы можете сделать "sudo save" как

:w!!

Возможность запуска Vim в режимах на основе клиента/сервера.

Например, предположим, что вы работаете над проектом с большим количеством буферов, вкладок и другой информации, сохраненной в файле сеанса session.vim.

Вы можете открыть сеанс и создать сервер, выполнив следующую команду:

vim --servername SAMPLESERVER -S session.vim

Обратите внимание, что вы можете открывать обычные текстовые файлы, если вы хотите создать сервер, и это необязательно будет сеансом.

Теперь предположим, что вы находитесь в другом терминале и вам нужно открыть другой файл. Если вы открываете его регулярно, выпуская:

vim new_file.txt

Ваш файл будет открыт в отдельном буфере Vim, что затрудняет взаимодействие с файлами на вашем сеансе. Чтобы открыть new_file.txt в новой вкладке на вашем сервере, используйте следующую команду:

vim --servername SAMPLESERVER --remote-tab-silent new_file.txt

Если сервер не работает, этот файл будет открыт как обычный файл.

Поскольку предоставление этих флагов каждый раз, когда вы хотите их запустить, очень утомительно, вы можете создать отдельный псевдоним для создания клиента и сервера.

Я разместил следующие файлы в файле bashrc:

alias vims='vim --servername SAMPLESERVER'
alias vimc='vim --servername SAMPLESERVER --remote-tab-silent'

Дополнительную информацию об этом можно найти по адресу: http://vimdoc.sourceforge.net/htmldoc/remote.html

Я часто хочу выделить конкретное имя слова/функции, но не хочу искать его еще один экземпляр:

map m* *#

HOWTO: Автоматическое заполнение Ctags при использовании Vim в Bash. Для всех, кто использует Vim и Ctags, я написал небольшую функцию автокомпонента для Bash. Добавьте следующее в ваш файл ~/.bash_completion (создайте его, если он не существует):

Спасибо за стильные штаны за его многочисленные исправления и улучшения.

_vim_ctags() {
    local cur prev

    COMPREPLY=()
    cur="${COMP_WORDS[COMP_CWORD]}"
    prev="${COMP_WORDS[COMP_CWORD-1]}"

    case "${prev}" in
        -t)
            # Avoid the complaint message when no tags file exists
            if [ ! -r ./tags ]
            then
                return
            fi

            # Escape slashes to avoid confusing awk
            cur=${cur////\\/}

            COMPREPLY=( $(compgen -W "`awk -vORS=" "  "/^${cur}/ { print \\$1 }" tags`" ) )
            ;;
        *)
            _filedir_xspec
            ;;
    esac
}

# Files matching this pattern are excluded
excludelist='*.@(o|O|so|SO|so.!(conf)|SO.!(CONF)|a|A|rpm|RPM|deb|DEB|gif|GIF|jp?(e)g|JP?(E)G|mp3|MP3|mp?(e)g|MP?(E)G|avi|AVI|asf|ASF|ogg|OGG|class|CLASS)'

complete -F _vim_ctags -f -X "${excludelist}" vi vim gvim rvim view rview rgvim rgview gview

После перезапуска сеанса Bash (или создания нового) вы можете ввести:

код:

~$ vim -t MyC<tab key>

и он автоматически завершит тег так же, как для файлов и каталогов:

код:

MyClass MyClassFactory
~$ vim -t MyC

Я считаю, что это действительно полезно, когда я вскакиваю в исправление ошибок.

: setlocal autoread

Авто перезагружает текущий буфер, особенно полезный при просмотре файлов журнала, и он почти выполняет функции "хвоста" в unix изнутри vim.

Проверка ошибок компиляции изнутри vim. установите переменную makeprg в зависимости от языка, скажем, для perl

: setlocal makeprg = perl\-c \%

Для PHP

установить makeprg = php\-l\%
set errorformat =% m\in\%f\on\line\%l

Выдача ": make" запускает связанный makeprg и отображает ошибки/предупреждения компиляции в окне quickfix и может легко перейти к соответствующим номерам строк.

Хотите IDE?

: make запустит make файл в текущем каталоге, проанализирует вывод компилятора, затем вы можете использовать: cn и: cp, чтобы выполнить ошибки компилятора, открывая каждый файл и ища соответствующий номер строки.

': синтаксис on' включает подсветку синтаксиса vim.

% также хорош, если вы хотите разделить файлы по двум различным копиям проекта, не изнашивая мизинец (от корня проекта1):

:vert diffs /project2/root/%

Из-за латентности и отсутствия цветов (мне нравятся цветовые схемы:) Мне не нравится программирование на удаленных машинах в PuTTY. Поэтому я разработал этот трюк, чтобы обойти эту проблему. Я использую его в Windows.

Вам понадобится

• 1x gVim
• 1x rsync на удаленных и локальных машинах
• 1x SSH private key auth на удаленном компьютере, поэтому вам не нужно вводить пароль
• 1x Страница
• 1x PuTTY

Настройка удаленного компьютера

Настройте rsync, чтобы сделать ваш рабочий каталог доступным. Я использую туннель SSH и разрешаю только соединения из туннеля:

address = 127.0.0.1
hosts allow = 127.0.0.1
port = 40000
use chroot = false
[bledge_ce]
    path = /home/xplasil/divine/bledge_ce
    read only = false

Затем запустите rsyncd:   rsync --daemon --config = rsyncd.conf

Настройка локального компьютера

Установите rsync из Cygwin. Начать и загрузить свой секретный ключ для удаленной машины. Если вы используете туннелирование SSH, запустите PuTTY, чтобы создать туннель. Создайте пакетный файл push.bat в рабочем каталоге, который будет загружать измененные файлы на удаленную машину с помощью rsync:

rsync --blocking-io *.cc *.h SConstruct rsync://localhost:40001/bledge_ce

SConstruct - это файл сборки для scons. Измените список файлов в соответствии с вашими потребностями. Замените localhost именем удаленной машины, если вы не используете туннелирование SSH.

Настройка Vim Теперь это легко. Мы будем использовать функцию quickfix (: make и список ошибок), но компиляция будет запущена на удаленном компьютере. Поэтому нам нужно установить makeprg:

set makeprg=push\ &&\ plink\ -batch\ [email protected]\ \"cd\ /home/xplasil/divine/bledge_ce\ &&\ scons\ -j\ 2\"

Это сначала запустит задачу push.bat для загрузки файлов, а затем выполнит команды на удаленной машине с помощью SSH (Plink из PuTTY). Команда сначала меняет каталог на рабочий каталог, а затем начинает сборку (я использую scons).

Результаты сборки будут удобно отображаться в вашем локальном списке ошибок gVim.

==========================================================
In normal mode
==========================================================
gf ................ open file under cursor in same window --> see :h path
Ctrl-w f .......... open file under cursor in new window
Ctrl-w q .......... close current window
Ctrl-w 6 .......... open alternate file --> see :h #
gi ................ init insert mode in last insertion position
'0 ................ place the cursor where it was when the file was last edited

Я был уверен, что кто-то уже разместил бы это, но здесь идет.

Возьмите любую систему сборки, которая вам нравится; make, mvn, ant, что угодно. В корне каталога проекта создайте файл команд, которые вы используете все время, например:

mvn install
mvn clean install
... и т.д.

Чтобы сделать сборку, наведите курсор на строку и введите!! sh. То есть фильтровать эту строку; напишите его в оболочку и замените ее результатами.

Журнал сборки заменяет строку, готовую прокрутку, поиск, что угодно.

Когда вы закончите просмотр журнала, введите u, чтобы отменить, и вы вернетесь в свой файл команд.

Я использую Vim для всего. Когда я редактирую сообщение электронной почты, я использую:

gqap (или gwap)

чтобы легко и правильно переформатировать по принципу "один за другим", даже с цитированием символов leadin. Для достижения этой функциональности я также добавляю:

-c 'set fo=tcrq' -c 'set tw=76'

чтобы вызвать редактор снаружи. Одним из примечательных дополнений было бы добавить " a" в параметр fo (formatoptions). Это автоматически переформатирует абзац при вводе и навигации по содержимому, но может вмешиваться или вызывать проблемы с ошибочным или нечетным форматированием, содержащимся в сообщении.

Введите символ из его шестнадцатеричного значения (режим вставки):

<C-Q>x[type the hexadecimal byte]

Поместите это в свой .vimrc, чтобы иметь команду для красивой печати xml:

function FormatXml()
    %s:\(\S\)\(<[^/]\)\|\(>\)\(</\):\1\3\r\2\4:g
    set filetype=xml
    normal gg=G
endfunction

command FormatXml :call FormatXml()

set colorcolumn=+1 или set cc=+1 для vim 7.3

При работе над проектом, где процесс сборки медленный, я всегда создаю в фоновом режиме и передаю вывод в файл с именем errors.err(что-то вроде make debug 2>&1 | tee errors.err). Это позволяет мне продолжить редактирование или просмотр исходного кода во время процесса сборки. Когда он будет готов (используя pynotify на GTK, чтобы сообщить мне, что он завершен), я могу посмотреть на результат в vim, используя quickfix. Начните с выпуска: cf [ile], который считывает файл ошибки и переходит к первой ошибке. Мне лично нравится использовать cwindow, чтобы получить результат сборки в отдельном окне.

Перед копированием и вставкой в ​​stackoverflow:

:retab 1
:% s/^I/ /g
:% s/^/    /

Теперь скопируйте и вставьте код.

Как указано в комментариях:

retab 1. Это устанавливает размер закладки в один. Но он также проходит через код и добавляет дополнительные вкладки и пробелы, так что форматирование не перемещает какой-либо текст (т.е. Текст выглядит одинаково после ratab).

% s/^ I//g: Обратите внимание, что ^ я - результат попадания вкладки. Это выполняет поиск всех вкладок и заменяет их одним пробелом. Поскольку мы просто сделали retab, это не должно приводить к изменению форматирования, но так как попадание вкладок на сайт ударяется и промахивается, это хорошо, чтобы удалить их.

% s/^/     /: Заменить начало строки четырьмя пробелами. Поскольку вы не можете на самом деле заменить начало строки чем-либо, он вставляет четыре пробела в начале строки (это необходимо для форматирования SO, чтобы выделить код).

:sp %:h - список каталогов /file -chooser с использованием текущего каталога файлов

(относится к комментарию в подсказке rampion cd, но у меня пока нет комментариев)

В режиме вставки ctrl + x, ctrl + p завершается (с меню возможных завершений, если это вам нравится), текущий длинный идентификатор, который вы печатаете.

if (SomeCall(LONG_ID_ <-- type c-x c-p here
            [LONG_ID_I_CANT_POSSIBLY_REMEMBER]
             LONG_ID_BUT_I_NEW_IT_WASNT_THIS_ONE
             LONG_ID_GOSH_FORGOT_THIS
             LONG_ID_ETC
             ∶

Чтобы сделать vim немного больше похожим на редактор IDE:

• set nu - для номеров строк в левом поле.
• set cul - выделяет строку, содержащую курсор.

Мне нравится команда ls.

In Insert mode 
<C-A>   - Increments the number under cursor 
<C-X>   - Decrements the number under cursor

Это будет очень полезно, если мы хотим генерировать порядковые номера в vim
Допустим, если мы хотим вставить строки 1-10 с номерами от 1 до 10 [например, "1" в 1-й строке, "2" на 2-й строке..]
вставьте "0" в первую строку и скопируйте строку и прошлые 9 раз Чтобы все строки отображали "0".

Запустите следующую команду Ex

:g/^/exe "norm " . line(".") . "\<C-A>"

Чтобы скопировать текст из Vim в буфер обмена для другого используемого приложения, выберите текст, который вы хотите скопировать в визуальном режиме, а затем нажмите "+ y". Таким образом, вы можете легко вставить текст в другие приложения.

Это особенно полезно, если вы разделили окно по вертикали и хотите скопировать что-то из правого окна. Использование set mouse = r не поможет вам в этой ситуации, так как он также выберет все в левом окне.

Обратите внимание, что ваш vim должен быть скомпилирован с поддержкой xterm.

отобразить макросы

Я довольно часто считаю полезным "на лету" определять какое-то ключевое отображение так же, как и макрос. Твист здесь заключается в том, что отображение является рекурсивным и выполняется до тех пор, пока оно не сработает.

Пример:

enum ProcStats
{
        ps_pid,
        ps_comm,
        ps_state,
        ps_ppid,
        ps_pgrp,
:map X /ps_<CR>3xixy<Esc>X

дает:

enum ProcStats
{
        xypid,
        xycomm,
        xystate,
        xyppid,
        xypgrp,

Просто глупый пример:).

Я полностью осознаю все недостатки - так получилось, что в некоторых случаях я нашел это весьма полезным. Также может быть интересно посмотреть его на работе;).

Многократное

Движения для смешивания с другими командами, больше здесь.

tx
fx
Fx

Используйте свои любимые инструменты в Vim.

:r !python anything you want or awk or Y something

Повторите в визуальном режиме, мощный в сочетании с подсказками выше.

;

Создайте функцию для выполнения текущего буфера, используя его shebang (если он установлен) и вызовите его с помощью crtl-x.

map <C-X> :call CallInterpreter()<CR>

au BufEnter *
\ if match (getline(1) , '^\#!') == 0 |
\   execute("let b:interpreter = getline(1)[2:]") |
\ endif

fun! CallInterpreter()
    if exists("b:interpreter")
        exec("! ".b:interpreter." %")
    endif
endfun

Несколько полезных:

:set nu # displays lines
:44     # go to line 44
'.      # go to last modification line

Мой любимый: Ctrl + n ЗАВЕРШЕНИЕ СЛОВА!

Я собирал их на протяжении многих лет.

" Pasting in normal mode should append to the right of cursor
nmap <C-V>      a<C-V><ESC>
" Saving
imap <C-S>      <C-o>:up<CR>
nmap <C-S>      :up<CR>
" Insert mode control delete
imap <C-Backspace> <C-W>
imap <C-Delete> <C-O>dw
nmap    <Leader>o       o<ESC>k
nmap    <Leader>O       O<ESC>j
" tired of my typo
nmap :W     :w

Ни одно из следующего не является действительно несгибаемым, но я считаю его чрезвычайно полезным.

Тривиальные привязки, но я просто не могу жить без. Он позволяет перемещать hjkl-стиль в режиме вставки (используя клавишу ctrl). В нормальном режиме: ctrl-k/j прокручивает половину экрана вверх/вниз, а ctrl-l/h переходит в следующий/предыдущий буфер. Отображения μ и ings особенно подходят для AZERTY-клавиатуры и переходят к следующей/предыдущей ошибкам.

imap <c-j> <Down>
imap <c-k> <Up>
imap <c-h> <Left>
imap <c-l> <Right>
nmap <c-j> <c-d>
nmap <c-k> <c-u>
nmap <c-h> <c-left>
nmap <c-l> <c-right>

nmap ù :cp<RETURN>
nmap µ :cn<RETURN>

Небольшая функция, которую я написал для выделения функций, глобалов, макросов, структур и typedef. (Могут быть медленными на очень больших файлах). Каждый тип получает различную подсветку (см. ": Help group-name", чтобы получить представление о текущих настройках колормита) Использование: сохранить файл с помощью ww (по умолчанию "\ ww" ). Для этого вам нужны ctags.

nmap <Leader>ww :call SaveCtagsHighlight()<CR>

"Based on: http://stackoverflow.com/questions/736701/class-function-names-highlighting-in-vim
function SaveCtagsHighlight()
    write

    let extension = expand("%:e")
    if extension!="c" && extension!="cpp" && extension!="h" && extension!="hpp"
        return
    endif

    silent !ctags --fields=+KS *
    redraw!

    let list = taglist('.*')
    for item in list
        let kind = item.kind

        if     kind == 'member'
            let kw = 'Identifier'
        elseif kind == 'function'
            let kw = 'Function'
        elseif kind == 'macro'
            let kw = 'Macro'
        elseif kind == 'struct'
            let kw = 'Structure'
        elseif kind == 'typedef'
            let kw = 'Typedef'
        else
            continue
        endif

        let name = item.name
        if name != 'operator=' && name != 'operator ='
            exec 'syntax keyword '.kw.' '.name
        endif
    endfor
    echo expand("%")." written, tags updated"
endfunction

У меня есть привычка писать много кода и функций, и я не люблю писать для них прототипы. Поэтому я создал некоторую функцию для создания списка прототипов в исходном файле стиля C. Он поставляется в двух вариантах: один, который удаляет формальное имя параметра и сохраняет его. Я просто обновляю весь список каждый раз, когда мне нужно обновить прототипы. Это позволяет избежать наличия прототипов и определений функций синхронизации. Также нужны ctags.

"Usage: in normal mode, where you want the prototypes to be pasted:
":call GenerateProptotypes()
function GeneratePrototypes()
    execute "silent !ctags --fields=+KS ".expand("%")
    redraw!
    let list = taglist('.*')
    let line = line(".")
    for item in list
        if item.kind == "function"  &&  item.name != "main"
            let name = item.name
            let retType = item.cmd
            let retType = substitute( retType, '^/\^\s*','','' )
            let retType = substitute( retType, '\s*'.name.'.*', '', '' ) 

            if has_key( item, 'signature' )
                let sig = item.signature
                let sig = substitute( sig, '\s*\w\+\s*,',        ',',   'g')
                let sig = substitute( sig, '\s*\w\+\(\s)\)', '\1', '' )
            else
                let sig = '()'
            endif
            let proto = retType . "\t" . name . sig . ';'
            call append( line, proto )
            let line = line + 1
        endif
    endfor
endfunction


function GeneratePrototypesFullSignature()
    "execute "silent !ctags --fields=+KS ".expand("%")
    let dir = expand("%:p:h");
    execute "silent !ctags --fields=+KSi --extra=+q".dir."/* "
    redraw!
    let list = taglist('.*')
    let line = line(".")
    for item in list
        if item.kind == "function"  &&  item.name != "main"
            let name = item.name
            let retType = item.cmd
            let retType = substitute( retType, '^/\^\s*','','' )
            let retType = substitute( retType, '\s*'.name.'.*', '', '' ) 

            if has_key( item, 'signature' )
                let sig = item.signature
            else
                let sig = '(void)'
            endif
            let proto = retType . "\t" . name . sig . ';'
            call append( line, proto )
            let line = line + 1
        endif
    endfor
endfunction

Попробуйте использовать perltidy для форматирования командой = нормального режима

:set equalprg=perltidy

Заменить все

  :%s/oldtext/newtext/igc

Дайте a заменить все:)

Используйте правую кнопку мыши для переключения режима вставки в gVim со следующими настройками в ~/.gvimrc:

"
"------------------------------------------------------------------
" toggle insert mode <--> 'normal mode with the <RightMouse>-key
"------------------------------------------------------------------
nnoremap  <RightMouse> <Insert>
inoremap  <RightMouse> <ESC>
"

Я хотел бы упорядочить некоторые свои собственные файлы конфигурации в after-directory. Это особенно полезно для ftplugin.

Вы можете избежать записи длинного списка augroup в вашем .vimrc файле вместо отдельных файлов для каждого типа.

Но, очевидно, каталог .vim/ftplugin делает то же самое, что и .vim/after/ftplugin, но я предпочел бы оставить каталог .vim для плагинов vim.

Мой любимый рецепт переключения между окнами:

function! SwitchPrevWin()
    let l:winnr_index = winnr()
    if l:winnr_index > 1
       let l:winnr_index -= 1
    else
       "set winnr_index to max window open
        let l:winnr_index = winnr('$')
    endif
    exe l:winnr_index . "wincmd w" 
endfunction

nmap <M-z> :call SwitchPrevWin()
imap <M-z> <ESC>:call SwitchPrevWin()

nmap <C-z> :wincmd w
imap <C-z> <ESC>:wincmd w

Mine использует макросы вместо поисковых запросов - иногда лучше сочетать макрос с визуальным режимом.

за этот поток

Для префикса набора строк я использую один из двух разных подходов:

Один подход - это выбор блока (упомянутый sth). В общем, вы можете выбрать прямоугольную область ctrl-V, за которой следует движение курсора. Когда вы выделите прямоугольник, нажав shift-I, вставьте символы в левой части прямоугольника, или shift-A добавит их в правой части прямоугольника. Таким образом, вы можете использовать эту технику для создания прямоугольника, который включает в себя самый левый столбец строк, которые вы хотите префикс, нажмите shift-I, введите префикс, а затем нажмите escape.

Другой подход заключается в использовании замены (как упоминал Брайан Агнью). Подстановка Брайана повлияет на весь файл (% в команде означает "все строки" ). Чтобы затронуть всего несколько строк, самый простой способ - нажать shift-V (который позволяет визуально-линейный режим), находясь на первой/последней строке, а затем перейти к последней/первой строке. Затем введите:

: s/^/YOUR PREFIX/

^ - регулярное выражение (в этом случае начало строки). Набрав это в режиме визуальной линии, вы увидите '<,' > вставленный перед s автоматически. Это означает, что диапазон подстановки будет визуальным выбором.

Дополнительный совет: если ваш префикс содержит косые черты, вы можете либо сбежать от них с помощью обратной косой черты, либо вы можете использовать другой символ пунктуации в качестве разделителя в команде. Например, чтобы добавить комментарии к строке С++, я обычно пишу:

: s: ^://:

Для добавления суффикса подход подстановки, как правило, проще, если все ваши строки не будут иметь одинаковую длину. Просто используйте $для шаблона вместо ^, и ваша строка будет добавлена ​​вместо предварительно отложенного.

Если вы хотите одновременно добавить префикс и суффикс, вы можете сделать что-то вроде этого:

: s/.*/PREFIX и SUFFIX/

.. * соответствует всей строке. И в замене помещается совпадающий текст (целая строка) назад, но теперь он добавит ваш префикс и суффикс.

BTW: при комментировании кода вы, вероятно, захотите раскомментировать его позже. Вы можете использовать визуальный блок (ctrl-V), чтобы выбрать косые черты, а затем нажать d, чтобы удалить их, или вы можете использовать подстановку (возможно, с визуальным выбором линии, сделанным с помощью shift-V), чтобы удалить ведущие косые черты, подобные этому

: s://::

Сопоставления для перемещения движений на текущей экранной линии в режиме обертывания. Некоторое время назад я обнаружил это в комментарии к контенту Vim, и это оказалось весьма удобным.

function! ScreenMovement(movement)
  if &wrap
    return "g" . a:movement
  else
    return a:movement
  endif
endfunction
onoremap <silent> <expr> j ScreenMovement("j")
onoremap <silent> <expr> k ScreenMovement("k")
onoremap <silent> <expr> 0 ScreenMovement("0")
onoremap <silent> <expr> ^ ScreenMovement("^")
onoremap <silent> <expr> $ ScreenMovement("$")
nnoremap <silent> <expr> j ScreenMovement("j")
nnoremap <silent> <expr> k ScreenMovement("k")
nnoremap <silent> <expr> 0 ScreenMovement("0")
nnoremap <silent> <expr> ^ ScreenMovement("^")
nnoremap <silent> <expr> $ ScreenMovement("$")

Некоторые из моих must-haves:

cscope + ctags + vim, который можно найти в Интернете.

Некоторые сокращения для быстрого запуска новых файлов кода, например:

ab cpph #include <iostream><CR>#include <string><CR>#include <cstdlib><CR>#include <cassert><CR>#include <vector><CR>#include <
stdexcept><CR>using namespace std;<CR>int main(int argc, char *argv[]) {
ab perlh #!/usr/bin/perl<CR>use strict;<CR>use warnings;<CR>
ab chdr #include <stdio.h><CR>#include <sys/types.h><CR>#include <unistd.h><CR>#include <stdlib.h><CR>#include <sys/stat.h><CR>
#include <sys/wait.h><CR>#include <string.h><CR>int main(int argc, char *argv[]) {
ab xhtmlhdr <?xml version="1.0" encoding="UTF-8"?><CR><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.o
rg/TR/xhtml1/DTD/xhtml1-strict.dtd"><CR><html xmlns="http://www.w3.org/1999/xhtml"><CR>  <head><CR>  <title></title><CR><link h
ref="/style.css" rel="STYLESHEET" type="text/css"><CR></head>

Например, cpph вставляет базовый скелет файла main.cc

Существует также мое отображение функциональных клавиш:

map <F1> <Esc>:w<CR>:perl $e = `./error.pl`; my ($f,$l,@w) = split(":",$e); my $w=join(":",@w); $curwin->Cursor($l,0); VIM::Msg($w);<CR>
map <F2> :wincmd w<CR>
map <F3> :wincmd s<CR>
map <F4> :wincmd v<CR>
map <F5> :wincmd o<CR>
map <F6> :sball<CR>
map <F7> :wq<CR>
map <F8> :wincmd q<CR>
map <F9> :wincmd -<CR>
map <F10> :wincmd +<CR>
map <F11> :wincmd <<CR>
map <F12> :wincmd ><CR>

В этом случае my F1 отображается, чтобы поместить курсор на следующую ошибку, которая должна быть исправлена ​​для миграции исходного кода.

map _ ebi"^[ea"^[

Эта карта создаст _ quote строку