OK, so you want to edit/view all the files matching certain pattern on vi from command prompt. How would you do it?
Search files using usual “find” command, then translate new line in result to space using “tr” command and feed the list to vi – simple! Here you go:

vi `find . -name *.sh  | tr '\n' ' '`

My personal vimrc file on Windows (known as HOME\_virmrc). For gVim, it sets the font to Consolas. For gVim and vim, it sets tabs to four spaces, and uses intelligent auto-indent behavior – the kind I expect from a fresh Fedora install of vim.

set guifont=Consolas:h10
winsize 120 40
set nobackup
set nowritebackup
set bs=2
syntax on

set tabstop=4
set shiftwidth=4
set expandtab

set cindent
set smartindent
set autoindent
set cinkeys=0{,0}

http://blog.sina.com.cn/s/blog_46dac66f010002xz.html

善用Vim：实例系列(2)(2006-04-22 21:40:25)

分类：VIM/text

[本文说明] 写过多篇Vim应用小文，为方便阅读，现做整理，并删除旧文。以后凡Vim文章，皆归入此系列。另，为便于搜索，统一vim、gvim及大小写为Vim。　–xbeta　2007年12月20日

[本文目录] 1 处理word目录 2 改变大小写 3 制作极点单字库

1 处理word目录

任务：

　　从word中把目录复制出来，去除多余信息(标题编号、页码)

命令：

　　%s/\d\|\.\|\s//gc

结果：

　　转瞬间200多行1000多字符烟消云灭

附图：

2 改变大小写

刚才在BBS上回答了一个问题，当然，这个问题并不复杂。就是“如何把一个文本文件中的大写字母全部替换成小写”。http://www.newsmth.net/bbscon.php?board=NewSoftware&id=840511

　　Word当然可以。

　　但作为文本，首先想到的还是gVIM，用它如何操作呢？

　　打开文件后，不用任何鼠标、菜单，只须在键盘上按下“ggguG”就行了。

　　极品软件就是这样：唯有功能强到极致，操作才能简到极致！

解释一下：ggguG分作三段gg gu G

gg=光标到文件第一个字符

gu=把选定范围全部小写

G=到文件结束

3 制作极点单字库

用五笔，我习惯输入单字。为此，就要把词库中的多字词去除。

（之所以不设定为单字模式，因为定义了一些其他词，如bis=http://blog.sina.com.cn/m/xbeta等）

极点有一个这样的工具，但我用的不熟。

想到了强大的VIM文本编辑器，一试，果然成功，并且简便。

与大家分享如下。(如果试验请谨慎，先做好备份。本文作者不对后果承担任何责任)

并感谢杜老师在极点5.0中更正了极点设置后VIM会崩溃的问题。

极点词库格式很简单，编码1-4字母，几个词，用空格分开。例如下:

　　｜aaff 蓬蓬勃勃 苷

　　｜aafg 葡萄干

　　｜aafh 苏东坡

　　｜aafn 工场

　　｜aafo 蘜

要去除多于1字的词语，只要2行命令就OK。

用VIM打开词库文件。

执行命令

　　:.,$s/ \S\{2,}\( \|$\)/ /gc

和

　　:.,$g/^\a\{1,4} $/normal dd

保存，就完了。

只要2行命令，而每条命令又如此古怪，大家可以想见VIM之功能强大。

　　VI是UNIX下文本编辑器的鼻祖。也就是说，基于它有很多改进的分支。

　　而VIM则是其中影响力最大的一支。它的第一个版本出现于1976年(哪个软件还有如此长的历史而依然活跃)。

　　我以前知道并用过盗版的Ultraedit、Editplus、Emeditor，认识VIM后将它们全舍弃了。

　　你能设想VIM是免费开源的吗？

　　VIM在windows平台下的版本是gVIM，我用的就是它。

　　安装后(包括多国语言文件、插件、语法文件)占空间20M。其实，最少只要一个exe文件不到2M就可以用了。

　　有兴趣的可以到华军下载一个。再到网上找找教程，或到水木社区smth.org的VIM版。

:.,$s/ \S\{2,}\( \|$\)/ /gc

解释如下：

　　:表示外部命令

　　.,$表示当前行到全文结束

　　s表示替换

共有三个/

　　前两个//之间是要被替换的旧字符串(正则表达式)。“ \S\{1,}\( \|$\)”表示“先有一个空格，再有1-N个非空字符，然后是一个空格或行尾”。

　　后两个//之间是要替换为的新字符串，本例中，为一个空格。

　　gc表示替换所有匹配的情况，并且每次要用户手工确认(这是为了直观和谨慎，如果有把握，可以不确认，直接执行)。

:.,$g/^\a\{1,4} $/normal dd

解释如下：

　　:表示外部命令

　　g表示找到某个字符串，然后执行某个操作

　　第一个/之后是要找的字符串，“^\a\{2,4} $”表示找“行首，然后是2-4个英文字母，然后空格，然后行尾”

　　第二个/之后是要执行的命令，“normal dd”，在VIM中是删除本行。

（本篇完）

You can set additional options in vim to make your programming life easier. You can add these options to .vimrc in your home folder so that they are loaded every time you start vim.

vim ~/.vimrc

set autoindent
set smartindent
set tabstop=4
set shiftwidth=4
syntax on
colo murphy

To know what each option does,  just type:

:help <option>

For example to know about autoindent, type:

:help autoindent

gvim

By default, gvim uses courier font. To set your own font, create a file .gvimrc in your home and add set guifont option:

vim ~/.gvimrc

set guifont=Bitstream\ Vera\ Sans\ Mono\ 9

Another useful option is to set the window size:

set lines=100 columns=130

Note that gvim reads options from .vimrc as well. But vim will not read options from .gvimrc

Other resources of interest

• vim as an IDE
• CRefVim : a C-reference manual especially designed for Vim
• c.vim : C/C++ IDE — Write and run programs. Insert statements, idioms, comments etc.
• Exuberant ctags (sudo apt-get install exuberant-ctags)
• Taglist plugin

Установить плагин taglist для выпадающего списка функций по Ctrl + пробел
" Цветовая схема
color desert
" Убрать правый тулбар
set guioptions-=r
" Подсветка синтаксиса
filetype on
filetype plugin on
syntax on
" Нумерация строк
set nu
" размеры окна
set lines=30
set columns=135
" Отключить создание файлов бекапа и свапа
set nobackup
set nowritebackup
set noswapfile
" Список используемых кодировок для автоматического их определения
set fileencodings=utf-8,koi8-r,cp1251,cp866
" Меню выбора кодировки текста (utf8, cp1251, koi8-r, cp866)
menu Кодировка.utf-8 :e ++enc=utf8 <CR>
menu Кодировка.windows-1251 :e ++enc=cp1251<CR>
menu Кодировка.koi8-r :e ++enc=koi8-r<CR>
menu Кодировка.cp866 :e ++enc=cp866<CR>
" Недаразумение
set iskeyword=@,a-z,A-Z,48-57,_,128-175,192-255
" Размер отступов
set shiftwidth=2
" Размеры табуляций
set tabstop=2
set softtabstop=2
" Преобразование Таба в пробелы
set expandtab
" Скрыть панель в gui версии ибо она не нужна
set guioptions-=T
" Сделать строку команд высотой в одну строку
set ch=1
" Включить автоотступы
set autoindent
" Не сворачивать длинные строки
set nowrap
" ------------------------------ "
"              PHP               "
" ------------------------------ "
" Включить фолдинг для блогов классов/функций
let php_folding=0
" Подсветка SQL
let php_sql_query=1
" Подстветка HTML
let php_htmlInStrings=1
" Подстветка базовых функций PHP
let php_baselib=1
" ------------------------------ "
"       Сочетания клавиш         "
" ------------------------------ "
" C-D - удаление текущей строки
nmap <C-D> dd
imap <C-D> <esc>dda
vmap <C-D> <esc>dda
" Окрыть новую вкладку
imap <C-T> <esc>:tabnew<cr>
vmap <C-пробел для автодополнения
inoremap <C-space> <C-x><C-o>
"Ctrl-w - удаление текущего буфера
nmap <C-w> :bd<cr>
imap <C-w> <esc>:bd<cr>
" Сохранить файл
nmap <C-S> :w<cr>
imap <C-S> <esc>:w<cr>a
vmap <C-S> <esc>:w<cr>a
" Копировать
vmap <C-C> "+ya
" Вклеить
imap <C-V> <esc>"+gpa
" Вырезать
vmap <C-X> "+xa
" Отменить
imap <C-Z> <esc>ua
" Вернуть
imap <C-Y> <esc><C-R>
" Выделить все
nmap <C-A> ggVG
imap <C-A> <esc>ggVG
vmap <C-A> <esc>ggVG
" F11 - показать окно Taglist
map <F11> :TlistToggle<cr>
vmap <F11> <esc>:TlistToggle<cr>
imap <F11> <esc>:TlistToggle<cr>
" F12 - обозреватель файлов
map <F12> :Ex<cr>
vmap <F12> <esc>:Ex<cr>i
imap <F12> <esc>:Ex<cr>i
" Открыть пустую вкладку
nmap <C-T> :tabnew<cr>
imap <C-T> <esc>:tabnew<cr>
vmap <C-T> <esc>:tabnew<cr>
" Такая фича, чтобы при нажатии на шифт можно было выделять блок стрелочками
" ну или другми клавишами типа h/j/k/l
" не решено
"
"if version >= 700
"   По умолчанию проверка орфографии выключена.
"    setlocal spell spelllang=

Como continuo sem tempo em colocar algumas coisas aqui (principalmente de estar estudando bastante para o projeto da faculdade – JPacman), eu estou apenas postando curiosidades, dicas, etc. Resolvi fazer este post, pois é uma dica muito boa, principalmente para quem não é apegado a grandes IDE’s e seus pesados e “poderosos” recursos. Estou falando do Vim, o melhor editor de texto já feito. É muito comum utilizar o vi ou o vim quando se está em ambiente unix-based, porém o que muita gente não sabe, é que é possível utilizar o vim no Windows. Não há muito o que explicar, basta entrar nesse link e realizar o download para win32.

Existem muitos artigos e flamewars (principalmente entre vim x emacs) sobre “a melhor IDE para se desenvolver qualquer coisa”. Não vou dizer qual a melhor, até mesmo porque a melhor é a que você gostar mais, mas nesse artigo vou tratar de um programa bem rico e customizável: o VIM.

De início, utilizar o vim parece um “parto”. Tudo é comando, as teclas de atalho mais conhecidas não funcionam, aquela interface simples chega a dar repulsa. Felizmente, isso passa. Nada do que um bom :help para aprender a mexer mo bichinho. Seguir o tutorial padrão do sistema é uma ótima ideia para se aprender o básico, e, daí, aproveitar o máximo que esse editor de textos pode proporcionar.

Uma das características principais do vim é sua customização. Praticamente tudo é customizável, e até programável. A possibilidade de fazer plugins e outras coisas mais como “syntax highlight” vão incrementando sua área de edição a ponto de deixar da maneira que você quiser.

Já utilizo o vim há um tempo, inicialmente para montar HTML + CSS e atualmente para programar em Rails. Praticamente abandonei o Eclipse e o Aptana para utilizar somente o vim. Para chegar a tal ponto de “migrar” de IDE, tive que passar por um relativo processo de customização do editor para que ele ficasse “no ponto”. Existe um arquivo chamado “.vimrc” na pasta raiz da aplicação. É lá que você vai aplicar as alterações propostas nesse artigo.

O arquivo que disponibilizo é uma versão customizada do vim criada por mim, e está todo comentado.

Inicialmente, recomendo a instalação dos seguintes plugins:

• NERDTree :: Lista os arquivos em árvore
• colorsel :: Seleciona uma cor hexadecimal
• html_autoclosetag :: Fecha as tags HTML com seu “par”
• ir_black :: Color scheme elegante e organizado

Depois, instale um corretor ortográfico da língua portuguesa. Para isso você precisará ter a versão 7 ou superior do vim.

• Faça o download do dicionário
• Descompacte o arquivo
• No vim, digite o comando ‘:mkspell pt /caminho/do/descompactamento/pt_BR’
• Copie o arquivo gerado para a pasta ~/.vim/spell/
• Ative a correção: ‘:set spell’
• Escolha o dicionário: ‘:set spelllang=pt’

Pronto, esses são os plugins que eu recomendo para a utilização do vim e transformá-lo numa verdadeira IDE, mas não basta só isso. Vamos agora para o principal: o arquivo de configuração .vimrc. Eu configurei um arquivo que pode ser utilizado tanto no vim para windows como na versão linux. Peguei um apanhado de configurações da internet e personalizei ao meu gosto. Acredito que provavelmente seja do gosto da maioria.

Se você utiliza o vim no Windows, adicione seguinte linha no início do arquivo:

source $VIMRUNTIME/vimrc_example.vim

Abaixo, o arquivo comentado e explicado.

"""""""""""""""""""""""""""""""""""
" CONFIGURAÇÕES PADRONIZADAS GOGS "
"""""""""""""""""""""""""""""""""""

set number                  " Numera as linhas
set nobackup                " Não salva arquivos de backup~
set wildmode=longest,list   " Completa o comando com TAB igual o bash

set ignorecase              " Ignora o case sensitive nas buscas
set smartcase               " Se tiver alguma letra maiúscula, ativa o case sensitive

filetype plugin indent on   " Detecta o tipo de arquivo e já aplica a indentação
set smartindent             " Auto-indenta
"set expandtab               " Identa com espaços

set tabstop=2               " Quantidade de espaços por identação
set shiftwidth=2            " Quantidade de espaços da auto-indentação

colorscheme ir_black        " Escolhe o tema

" Corretor ortográfico
set spelllang=pt            " Escolhe o dicionário

" Atalhos para plugins
map <F5> :NERDTree<CR>
map <F6> :ColorSel<CR>
map <F7> :set spell<CR>

" Cria e escolhe as abas
map <C-t> :tabnew<CR>
map <C-TAB> :tabnext<CR>
map <C-S-TAB> :tabprevious<CR>

" Mover texto com os TABs
vnoremap < <gv
vnoremap > >gv
map <TAB> >
map <S-TAB> <

" Auto-fecha parênteses, chaves etc.
inoremap { {}<LEFT>
inoremap ( ()<LEFT>
inoremap [ []<LEFT>
inoremap " ""<LEFT>
inoremap ' ''<LEFT>

" Auto-completa segundo a sintaxe, caso não haja dicionário omnicomplete
setlocal omnifunc=syntaxcomplete#Complete

" Função que usa o omnicomplete apenas com o TAB
function! CleverTab()
 if strpart( getline('.'), 0, col('.')-1 ) =~ '^\s*$'
 return "\<Tab>"
 elseif exists('&omnifunc') && &omnifunc != ''
 return "\<C-X>\<C-O>"
 else
 return "\<Tab>"
 endif
endfunction
inoremap <Tab> <C-R>=CleverTab()<CR>

""""""""""""""""""""""""
" Menus personalizados "
""""""""""""""""""""""""

" SVN
menu SVN.Status   :!svn status<CR>
menu SVN.-SEP1-   :<Nop>
menu SVN.Update   :!svn update<CR>
menu SVN.Commit   :!svn commit -m=" "<CR>
menu SVN.-SEP2-   :<Nop>
menu SVN.Ajuda    :!svn help<CR>

"""""""""""""""""""""""""""""
" Atalhos de teclado comuns "
"""""""""""""""""""""""""""""

" Permite selecionar com SHIFT + SETA como no Windows
set selectmode=mouse,key
set mousemodel=popup
set keymodel=startsel,stopsel
set selection=exclusive

" Backspace no modo de visão apaga a seleção
vnoremap <BS> d

" CTRL-X e SHIFT-Del corta
vnoremap <C-X> "+x
vnoremap <S-Del> "+x

" CTRL-C e CTRL-Insert copia
vnoremap <C-C> "+y
vnoremap <C-Insert> "+y

" CTRL-V e SHIFT-Insert cola
map <C-V>             "+gP
map <S-Insert>        "+gP
imap <C-V>            <C-R>+
imap <S-Insert>       <C-R>+
cmap <C-V>            <C-R>+
cmap <S-Insert>       <C-R>+

" CTRL-S salva
noremap <C-S>        :update<CR>
vnoremap <C-S>       <C-C>:update<CR>
inoremap <C-S>       <C-O>:update<CR>

" CTRL-Z desfaz
noremap <C-Z> u
inoremap <C-Z> <C-O>u

" CTRL-Y refaz
noremap <C-Y> <C-R>
inoremap <C-Y> <C-O><C-R>

" CTRL-A seleciona tudo
noremap <C-A> gggH<C-O>G
inoremap <C-A> <C-O>gg<C-O>gH<C-O>G
cnoremap <C-A> <C-C>gggH<C-O>G
onoremap <C-A> <C-C>gggH<C-O>G
snoremap <C-A> <C-C>gggH<C-O>G
xnoremap <C-A> <C-C>ggVG

" CTRL-F4 fecha a janela
noremap <C-F4> <C-W>c
inoremap <C-F4> <C-O><C-W>c
cnoremap <C-F4> <C-C><C-W>c
onoremap <C-F4> <C-C><C-W>c

" Plugins recomendados:
" - NERDTree :: Lista os arquivos em árvore
" - colorsel :: Seleciona uma cor hexadecimal
" - ir_black :: Color scheme bem bonito
" Para utilizar o SVN, basta usar o comando que executa comandos externos,
" como por exemplo: ':!svn up'

" Corretor ortográfico em português brasileiro:
" - Faça o download do dicionário em: http://www.broffice.org/verortografico/baixar
" - Descompacte o arquivo
" - No vim, digite o comando ':mkspell pt pt_BR'
" - Copie o arquivo gerado para a pasta ~/.vim/spell/
" - Ative a correção: ':set spell'
" - Escolha o dicionário: ':set spelllang=pt'

Vim is my favorite text editor (sorry Emacs guys). Anything that I write on my computer gets written in Vim. I used to be a word processor fan until they started to annoy me with spell-check. While I love how word processors can fix my spelling mistakes, I want them to do it after I write. I absolutely hate how they underline every misspelling. Writing and editing are two separate processes and writing always goes first. That’s why I started to blog using Vim.

There are a lot of great things about Vim, but before you dive in, know that it takes some adjusting if you’ve never used a command-line text editor. You don’t get your open and save buttons like you do in most applications. Everything you do in Vim is done with the keyboard, which in turn means that you need to learn some commands, and some of them are a little odd to say the least. How about we start with the basics though, shall we?

If you haven’t brought up a terminal window yet, do so. Ready? Okay, here we go. Type vim and press Enter. You should be greeted by a nice welcome screen or you’ll be met with an error saying that it doesn’t exist. If you received the latter and you’re on Ubuntu, type sudo apt-get install vim and you should be good to go.

Once you reach that nice intro screen, you’ll probably realize that you can’t type anything. This is because you have to press ‘i’ to enter insert mode. Write a little bit, just to test it out. When you have some text down, press the ‘Esc’ key. This exits insert mode. Now I can show you some of Vim’s commands.

The commands you are going to use the most are :w, :q!, and ZZ. The :w command tells Vim to write the buffer out to a file (in simple terms, it saves your work), while :q tells Vim that you want to quit. Try typing something without saving and exit using :q. It won’t let you will it? You see, if you modify a buffer without writing that buffer to a file, Vim won’t let you quit. That’s why you should use :q! instead. It overrides that default behavior, letting you quit without saving. You can combine the save and quit commands with ZZ.

Those commands are all you need to know to start using Vim, but there are tons more. One easy way to learn them all (or to avoid using them) is to use GVim. GVim is Vim with a graphical interface. It teaches you by showing the keyboard commands next to the actions in the menu. For example, it will say ‘Paste’ in the menu, but to the right of it you’ll see "+gP. This makes GVim a great app if you’re just getting started.

The true power of Vim lies in it’s simplicity. It separates the two parts of the writing process (writing and editing), by forcing you to do only one at a time. It also helps you concentrate on your work. No distractions, no notifications, just a clean environment where you put your thoughts into words.

Vim can be used by programmers as well. It supports syntax highlighting for a variety of languages and has many features just for developers. In fact, Vim is meant more for programming than writing, but it does both equally well.

For more information about Vim, go over to www.vim.org where you can read some documentation and download Vim for other platforms. I also highly recommend downloading GVim (it’s at the Vim website). It helps during the learning process and will get you up and running in no time.

vim as of version 7 had introduced built-in spellchecker. I had not used till date, but recently checked it out. So, to turn it on, type command
set spell
If you have some text on your vim and you turn sell on with above command, you will see red underlines for words that vim thinks are incorrectly spelled. Of course, while coding you might not want spell check, so you can turn it off by
set nospell
Now, about navigation and correction.
To go to next spelling error, the keyboard command is ]s to go to previous error, the command is [s. To see spelling suggestions, while the cursor is on word with error, press =z and it presents a list of possible words to choose from. Just type the number corresponding to the word that you are interested in, and you are all set.

When working in a mixed environment, you are bound to run into those ^M characters at the end of your lines at some point.  Here is a great link describing how to fix it.  They talk about vi, but gVim works the same way.

Oracle Applications – Business & Technology: Removing ”^M” from SQL*Loader datafile

I’ve been trying so many text editors for Ubuntu and i ended up using gvim + cream.

To install gvim: sudo aptitude install gvim ( Or you can use GUI Add/Remove Applications and search for gvim )

To install cream, download the .deb file from its homepage

Cream screenshot

I love GVIM as an editor but my only gripe with it was, I was not able to figure out how to copy to clipboard and how to paste from clipboard. Finally after lots of poking around I did figure it out.

Copying from clipboard:
In insert mode press <shift> + <insert>

Copying to clipboard:
Once you visually select the content to copy, press *y

I’m starting to really like this. I’m much more confident and often I don’t need to think twice before using a command. Today I have used many times the “yank & put” keys along with v,V (selection)  and o,O (new line before of after the current line). I am not required to think. So far, so good.

Today I had real opportunity to use gVim so I decided to install ViEmu for Visual Studio and give it a try. A had a lot of code to write on a recent application I’m working on so why not.

I’m starting to get a hand on basic navigation and on inserting/appending removing/deleting characters. It’s too soon to know I it had improved my productivity yet, but I’m still learning so let’s see in a couple of days how it goes.

Not been typing much today, but I wanted at least to clear something. How do I cut/paste inside gVim.

First you need to enter the selection mode by hitting "v". Then move the cursor to select text using h, j, k, l, w, e, etc. When the text is selected, hit "d". This will cut the text. Now hit "p" to put the line back.

On another note, I talked about vi/vim to some of my colleagues and friends and everyone is just laughing at me. Everyone seems to agree that there is no points in learning this and should stick with "what everyone do". I do hope to show them what it’s really about.  

In my blog http://ioconnor.wordpress.com/2009/04/24/javascript-testing/ I looked into some tools to help in my JavaScript development. I haven’t had the time, (or urge?), to do anything until this morning. This morning though I got JavaScriptLint working. The documentation at the site is less than adequate so I’m adding notes here to help me if I need to install it again in the future.

1. The Linux download is here: http://www.javascriptlint.com/download.htm
2. After decompressing it you’ll notice there is only a single horribly wrong README.html file. To get things working compile it by going to the src directory and typing:
   make -f Makefile.ref
3. A jsl will now be found in jsl-0.3.0/src/Linux_All_DBG.OBJ/jsl. To make it generally accessible do something like:
   ln -s /whatever/jsl-0.3.0/src/Linux_All_DBG.OBJ /my/bin/jsl
4. Running jsl will show the parameters that are needed. If you are like me you’ll wonder where the configuration file is that they mention. It’s not on their website and it certainly is nowhere on my disk. So I googled around until I found it, or close to what it should probaly be, and have copied it down below. I called the file “jsl.conf” and stuck it in /my/bin/jsl.conf.
5. It’s all fine and good running it on the command line. It even looks at the javascript code in html files. I found quite a few questionable pieces of code and one clear mistake on my part that fortunately was not causing any problems. From the command line type something like:
   jsl -conf /my/bin/jsl.conf -process /my/dev/taxes2.html
   The -conf /my/bin/jsl.conf is optional.
6. To run it from within vim by pressing the <F9> key edit the vimrc file and include something like:
   map <F9> : call JavaScriptLint()<CR>
   func! JavaScriptLint()
   exec “w” “Save the file
   exec “!jsl -conf /my/bin/jsl.conf -process % “
   endfunc

I might change this so the editor dumps me on the line that’s bad with an error message. Or into an error file that can be toggled back and forth from. However it is usable enough for me in it’s current form.

The conf file I’m using looks like this:

#
# Configuration File for JavaScript Lint 0.3.0
# Developed by Matthias Miller (http://www.JavaScriptLint.com)
#
# This configuration file can be used to lint a collection of scripts, or to enable
# or disable warnings for scripts that are linted via the command line.
#

### Warnings
# Enable or disable warnings based on requirements.
# Use “+WarningName” to display or “-WarningName” to suppress.
#
+no_return_value # function {0} does not always return a value
+duplicate_formal # duplicate formal argument {0}
+equal_as_assign # test for equality (==) mistyped as assignment (=)?{0}
+var_hides_arg # variable {0} hides argument
+redeclared_var # redeclaration of {0} {1}
+anon_no_return_value # anonymous function does not always return a value
+missing_semicolon # missing semicolon
+meaningless_block # meaningless block; curly braces have no impact
+comma_separated_stmts # multiple statements separated by commas (use semicolons?)
+unreachable_code # unreachable code
+missing_break # missing break statement
+missing_break_for_last_case # missing break statement for last case in switch
+comparison_type_conv # comparisons against null, 0, true, false, or an empty string allowing implicit type conversion (use === or !==)
+inc_dec_within_stmt # increment (++) and decrement (–) operators used as part of greater statement
+useless_void # use of the void type may be unnecessary (void is always undefined)
+multiple_plus_minus # unknown order of operations for successive plus (e.g. x+++y) or minus (e.g. x—y) signs
+use_of_label # use of label
+block_without_braces # block statement without curly braces
+leading_decimal_point # leading decimal point may indicate a number or an object member
+trailing_decimal_point # trailing decimal point may indicate a number or an object member
+octal_number # leading zeros make an octal number
+nested_comment # nested comment
+misplaced_regex # regular expressions should be preceded by a left parenthesis, assignment, colon, or comma
+ambiguous_newline # unexpected end of line; it is ambiguous whether these lines are part of the same statement
+empty_statement # empty statement or extra semicolon
-missing_option_explicit # the “option explicit” control comment is missing
+partial_option_explicit # the “option explicit” control comment, if used, must be in the first script tag
+dup_option_explicit # duplicate “option explicit” control comment
+useless_assign # useless assignment
+ambiguous_nested_stmt # block statements containing block statements should use curly braces to resolve ambiguity
+ambiguous_else_stmt # the else statement could be matched with one of multiple if statements (use curly braces to indicate intent)
+missing_default_case # missing default case in switch statement
+duplicate_case_in_switch # duplicate case in switch statements
+default_not_at_end # the default case is not at the end of the switch statement
+legacy_cc_not_understood # couldn’t understand control comment using /*@keyword@*/ syntax
+jsl_cc_not_understood # couldn’t understand control comment using /*jsl:keyword*/ syntax
+useless_comparison # useless comparison; comparing identical expressions
+with_statement # with statement hides undeclared variables; use temporary variable instead
+trailing_comma_in_array # extra comma is not recommended in array initializers
+assign_to_function_call # assignment to a function call
+parseint_missing_radix # parseInt missing radix parameter

### Output format
# Customize the format of the error message.
# __FILE__ indicates current file path
# __FILENAME__ indicates current file name
# __LINE__ indicates current line
# __ERROR__ indicates error message
#
# Visual Studio syntax (default):
+output-format __FILE__(__LINE__): __ERROR__
# Alternative syntax:
#+output-format __FILE__:__LINE__: __ERROR__

### Context
# Show the in-line position of the error.
# Use “+context” to display or “-context” to suppress.
#
-context

### Semicolons
# By default, assignments of an anonymous function to a variable or
# property (such as a function prototype) must be followed by a semicolon.
#
+lambda_assign_requires_semicolon

### Control Comments
# Both JavaScript Lint and the JScript interpreter confuse each other with the syntax for
# the /*@keyword@*/ control comments and JScript conditional comments. (The latter is
# enabled in JScript with @cc_on@). The /*jsl:keyword*/ syntax is preferred for this reason,
# although legacy control comments are enabled by default for backward compatibility.
#
+legacy_control_comments

### JScript Function Extensions
# JScript allows member functions to be defined like this:
# function MyObj() { /*constructor*/ }
# function MyObj.prototype.go() { /*member function*/ }
#
# It also allows events to be attached like this:
# function window::onload() { /*init page*/ }
#
# This is a Microsoft-only JavaScript extension. Enable this setting to allow them.
#
-jscript_function_extensions

### Defining identifiers
# By default, “option explicit” is enabled on a per-file basis.
# To enable this for all files, use “+always_use_option_explicit”
-always_use_option_explicit

# Define certain identifiers of which the lint is not aware.
# (Use this in conjunction with the “undeclared identifier” warning.)
#
# Common uses for webpages might be:
#+define window
#+define document

### Interactive
# Prompt for a keystroke before exiting.
#+pauseatend

### Files
# Specify which files to lint
# Use “+recurse” to enable recursion (disabled by default).
# To add a set of files, use “+process FileName”, “+process Folder\Path\*.js”,
# or “+process Folder\Path\*.htm”.
#
#+process jsl-test.js

~/.vimrc


set fileencoding=utf-8
//here is encoding of file
set fileencodings=ucs-bom,gb18030,utf-8,default
//here is the list for try


From http://vim.dindinx.net/orig/html/options.txt.php

Que tal usar um editor de texto que serve para editar sites da internet, criar código em javascript, programar em python e ainda por cima fazer tudo isso com uma rapidez e eficiência enorme?

Tente o Vim!

• Documentação
• Download

Pese a que en mi paso a Mac, intenté darle una oportunidad a Textmate, no he podido. Y es que tras unas cuantas semanas me he dado cuenta de que mis líneas de código tenían lindezas como :wq y cosas así. Tuve que volver a Vim. Por varios motivos:

• Me he hecho a él
• Aún no conozco sus límites
• Lo puedo ejecutar en cualquier máquina: hoy he tenido que picar código en un Windows, y Vim y el vimrc que llevo siempre conmigo, me han salvado la vida.

El caso es que GoLo pese a que suele usar Vim para modificar cosas del sistema, a la hora de la verdad abre el Eclipse, y para según que cosas es normal (yo soy el primero que lo hace) pero para programar en Python, Perl o Php, me parece una burrada. Desde que empecé a usar Vim de verdad, suelo llevar encima una pequeña Moleskine donde voy apuntando truquillos que me van haciendo más y más rápido a la hora de picar código. De este cuadernito he hecho una selección que le vendrá a GoLo que ni pintada Si no eres GoLo, también puedes usarla ¡Y hasta comentar!

Inserciones (en modo normal)

• i : empiezas a escribir a la izquierda de la letra sobre la que tienes el cursor
• I : empiezas a escribir al principio de la línea en la que estás
• a : empiezas a escribir a la derecha de la letra donde tienes el cursor
• A : empiezas a escribir al final de la línea en la que estás
• o : empiezas a escribir en la linea de abajo. Importantísimo.
• O: empiezas a escribir en la línea de arriba

Moverse por el texto (en modo normal)

• e : pone el cursor al final de la línea
• b: pone el cursor al principio de la línea
• yy : copia la línea actual
• dd : corta la línea actual
• y3y o d3d: copia o corta 3 líneas, hacia abajo desde la que está el cursor. Esto es genial para mover grandes bloques de texto de un lugar a otro. (Si GoLo, si, como me dijiste que hace el Eclipse )

Otros, pero no menos importantes

• :1,$ s/hola/mundo/g : reemplaza de la línea 1 hasta el final todas las palabras “hola” por “mundo”. Si cambiamos $ por un 5, lo hará en las 5 primeras líneas, y si cambiamos el 1 por un 5 lo hará de la línea 5 hasta el final. Si solo lo queremos para un pequeño bloque de texto, pues, tan sencillo como poner las dos líneas entre las que quieres acotar. En que le coges el tranquillo, lo echas de menos en todas las
• :set nu : activa la numeración
• :tabnew : abre nueva pestaña
• gt : para moverse entre las pestañas. Comodísimo.
• :tab sba : abre todos los buffers activos en pestañas. Utilísimo.

Me dejo muchos en el tintero, pero estos son imprescindibles Seguiré añadiendo más poco a poco para la sección de Vím GoLo, espero haberte convencido

如果不习惯于“老老实实”地一行一行添加注释符的话，可以试下 EnhancedCommentify 这个 Vim 的插件。它对支持目前大多数文件格式的注释，如 PHP、Python、Java、C/C++ 等等。

下载地址

执行 :call EnhancedCommentify(‘yes’,'comment’) 即对当前行进行注释；反之，执行 :call EnhancedCommentify(‘yes’,'decomment’) 则对当前行进行反注释。

为了使用方便，可以对上面的命令进行键盘映射：

" 设置注释
map <F2> <Esc><Esc>:call EnhancedCommentify('yes','comment')<CR>
" 取消注释
map <F3> <Esc><Esc>:call EnhancedCommentify('yes','decomment')<CR>

具体的使用方法，可以查看插件里面的 doc。

Have fun

This post will be updated every time I have to do something in vim taking more than a few seconds to get right. Or when I find interesting reference information I don’t know or forget on a regular basis. The idea is to include everything I do and need with vim in this post.

I prefer using gvim for some reason. Don’t really have a reason I can remember. The useless toolbar on top can be turned off with:

set guioptions-=T

The most useful command in all of vi/vim land I have ever used is the following held within the .vimrc or whatever. It allows the line under the cursor to be executed. With clever useage vi becomes very useful. I’ve used it on all versions of vi for decades.

:map ** “zyy:@z

along with the following that needs to sometimes be modified heavily depending on the version of vi. This allows you to bounce between the two buffers with just a keystroke. (Removing the ability to use the standard ‘;’ for what it was intended for.)

:map ; :e#

When viewing a downloaded google spreadsheet in csv format of all deposits the following displays the summary of each deposit

:g/^\d\{1,3},”\p\{-}”,200

Removes the first 7 words of each line and replaces them with “rm “. Helpful when editing a file made with “ls > file”.

:%s/\(\S\+\s\+\)\{7\}\(.*\)/rm \2 /

Using vim’s internal sort. Start by marking the beginning and ending line with say ‘b’ and ‘e’. (Note the ‘}’ does not help in specifying range unfortunately.) Then type:

:’b,’esort

I’m always forgetting vim’s regexps metacharacters. The following I stole from this excellent guide http://www.geocities.com/volontir/

.	any character except new line
\s	whitespace character
\S	non whitespace character
\d	digit
\D	non-digit
\x	hex digit
\X	non-hex digit
\o	octal digit
\O	non-octal digit
\h	head of word character (a,b,c…z, A,B,C…Z and _)
\H	non-head of word character
\p	printable character
\P	like \p, but excluding digits
\w	word character
\W	non-word character
\a	alphabetic character
\A	non-alphabetic character
\l	lowercase character
\L	non-lowercase character
\u	uppercase character
\U	non-uppercase character

Non-greedy quantifiers where n and m are positive integers (>0):

\{-}	matches 0 or more of the preceding atom, as few as possible
\{-n,m}	matches 1 to m of the preceding characters…
\{-n,}	matches at least 1 or more of the preceding characters…
\{-,m}	matches 1 or more of the preceding characters…

The greedy options have all the obvious non-greedy options plus the semi-obvious extras as follow

\{n}	Matches exactly n characters. It is not greedy or non-greedy.
*	Greedily matches 0 or more of the preceding whatever. “.*” matches everything including an empty line. Notice there is no backslash before the ‘*’
\+	Matches 1 or more of the preceding whatever.
\=	Matches 0 or 1 of the preceding whatever.

There are valuable replacement options:

&	The entire part matched by the pattern.
\1	When 1 is used it is the first pattern. A 0 is the same as the & above and probably makes more sense. I don’t know if two digit numbers can be used or if it stops at 9.
~	The previously substituted string.
\L \U \E \e	Turns upper or lower case on until either of the end control characters are encountered.
\r	Splits the line in two by adding a return character.
\l \u	Makes the next character upper or lower case.