Vim Script 를 배워봅시다.==

이 페이지는 vim 사용법을 알려주는 페이지는 아니다. 좀 더 vim 고급 사용자로 가기 위해서 vim-script 를 배우는 페이지다.

이 페이지를 읽기전 기본적인 buffer, window, tab, vim operator(dd, x, i) 와, insert/ex/visual mode 등에 대해 익숙한 사용자를 대상으로 한다.

크게 세가지 섹션으로 나누어서 설명할 것이다.

  • 기본적인 key map 을 이용하는 방법

  • 프로그래밍 하는 방식을 통해 접근하는 vim script, 변수나 함수, 제어구조등이 포함된다.

  • 샘플 plugin 제작을 통해 실제 vim 생태에 기여하는 방법.

.vimrc ==

기본적으로 vim 을 시작하게 되면 로드하게 되는 script 파일은 .vimrc 파일이다.

.vimrc 파일은 시스템마다 로드하는 위치와 순서가 다를 수 있다.

본인의 컴퓨터의 환경에 대해서 살펴보고 싶으면

:version

해보면 로드하는 vimrc 에 대한 정보를 알 수 있다.

조금 더 일반적인 내용에 대해서 보고 싶으면

:help vimrc
Places for your personal initializations:
    Unix		$HOME/.vimrc or $HOME/.vim/vimrc
    OS/2		$HOME/.vimrc, $HOME/vimfiles/vimrc
            or $VIM/.vimrc (or _vimrc)
    MS-Windows	$HOME/_vimrc, $HOME/vimfiles/vimrc
            or $VIM/_vimrc
    Amiga		s:.vimrc, home:.vimrc, home:vimfiles:vimrc
            or $VIM/.vimrc

위와 같이 나온다. 각 시스템에서 어떻게 동작하는지 자세한 설명도 볼 수 있다.

이 처럼 vim 은 뭔가에 대해 궁금할 때 :help something 을 이용하면 원하는 정보를 얻을 수 있다.

vim 에서는 간단히 :e ~/.vimrc 정도만 입력해도 자기 시스템에 맞는 vimrc 를 편집할 수 있다.

앞으로 설명할 스크립트들은 간단히 inline 으로 vim editor 창에 입력해도 되지만, 영구히 저장하고 싶다면 자기 시스템에 맞는 vimrc 파일에 기록하면 된다.

다음시작 때 부터 vim 은 vimrc 을 읽어들여 실행하게 된다.

:echo $MYVIMRC

으로도 확인 할 수 있다.

Echo Message ======

vim 스크립트를 본격적으로 배우기 전에 기본적인 변수확인이나 디버깅 방법을 알아야 한다.

우리가 지금까지 프로그래밍을 하면서 디버깅을 할 때 로그를 남기면서 한것과 같은 이치다.

vim 에서는 echo 내장 명령어를 통해서 변수값을 간단하게 확인할 수 있다.

:echo "hello world"

쳐보면 하단에 hello world 가 찍히는것을 볼 수 있다.

하지만 이걸로만은 뭔가 나중에 확인하기엔 부족하다. 지나간 로그에 대해서 보고 싶을 때가 있다.

:echo "hello1"
:echom "hello2"
:messages 

입력해보고 echo 과 echom 의 차이를 스스로 판단하길 바란다.

좀 더 알고 싶으면 :help echom, :help echo 를 활용하자.

comment ======

vim 에서 가독성을 높이기 위해서 주석을 달 수 있다.

~/.vimrc

" open my vimrc
nnoremap <leader>feR :source ~/.vimrc<CR>

” 뒤에 나오는 문자는 전부 무효처리 된다.

options ======

Vim 은 어떻게 동착할지에 대한 많은 옵션을 가지고 있다.

대부분 옵션들은 on/off 식으로 작동하게 되는데 :set XXX, :set noXXX 식으로 XXX 에 대한 사항을 toggle 할 수 있다.

:set number 
:set nonumber

둘다 vim 에 쳐보면 알 수 있다.

이미 vim 에 익숙한 사용자라면 잘 알겠지만 postfix 로 붙는 ? 과 ! 에 대해서도 알아둬야 한다.

:set number!

on/off 토글하기 위해서는 ! 를 붙인다.

현재 상태를 확인하기 위해서는

:set number?

끝에 ? 를 붙인다.

Basic Mapping ======

Vim 의 장점중 하나가 키맵핑을 이용해서 동작을 바꿀 수 있다는 점이다.

:map _ x

타이핑을 하고 문자 위에서 _ 를 쳐보면 문자가 지워지는 것을 볼 수 있다.

특별한 키를 위해서는 <> 으로 묶어서 표현하기도 한다. 예를 들면 , 정도가 될 수 있겠다.

map 을 쓸 때 특정모드에서만 가능하도록 매핑을 할 수 있다.

:imap jj <ESC>j 

라고 입력 후 insert 모드에서 jj 를 눌러보자.

vim 에서는 이러한 모드가 여러가지가 있는데

:help :map-modes

으로 확인해보자.

꼭 확인해봐야한다. 이 중 에서 우리가 주로 쓰는 매핑은 사람마다 다르겠지만 대체로 imap, vmap, nmap 이 3가지를 쓴다.

Recursive Mapping ======

:nmap x dd
:nmap _ x

라고 입력후에 어떤 내용이 있는 텍스트 위에서 _ 를 타이핑하면 어떤 일이 일어날까?

vim 은 _ 를 입력받아서 x 를 타이핑하게 하고, 또 vim 은 x 는 dd 니까 최종적으로 dd 를 실행하게 된다.

이러한 방식은 때때로 다른 플러그인과의 충돌을 발생시키고, 원하지 않는 결과를 만든다.

이를 위해서 vim 은 no-remap 을 제공한다.

:nnoremap x dd
:nnoremap _ x

라고 해보고 아까 했던 행동을 해보자.

Leaders ======

앞에서 정했 듯

:nnoremap x dd 

라고 정의하고 x 를 누르면 dd 가 실행되는 것을 알 수 있었다. 하지만 이러한 매핑은 기본동작을 바꾸는 좋지 않은 행동이다.

그래서

:nnnoremap -x dd

처럼 - 와 같은 접두사(prefix) 를 붙여서 이러한 동작을 지원해 줄 수 있다.

하지만 사용자가 이미 -x 와 같은 명령어를 개인적으로 매핑해서 쓴다면 해결할 방법이 없어진다.

사용자가 직접 찾아서 플러그인의 매핑된 코드를 바꿔야 한다.

이 때 leader key 를 쓰면 사용자가 매핑한 leader key 기준으로 매핑을 할 수 있다.

:let mapleader = ","
:nnoremap <leader>x dd

후에 ,x 라고 쳐보자.

이러한 leader key 의 장점은 사용자가 원하는 키로 매핑을 일괄적으로 변경할 수 있다는 점이다.

local 하에서 leader key 를 지정하고 싶다면

:help maplocalleader

를 통해 공부하자.

Load Script ======

자신이 만드는 스크립트는 앞서 설명했 듯 $MYVIMRC 경로에 저장해놓으면 vim 을 재시작할 때 불러온다고 했다.

그 경로는 :echo $MYVIMRC 를 통해 경로를 알 수 있었다.

하지만 매번 스크립트를 불러올 때, $MYVIMRC 혹은 ~/.vimrc 를 입력하기엔 고통이 따른다.

우리는 키매핑을 배웠기 때문에 다음과 같이 매핑을 한다.

:nnoremap <leader>fed :source $MYVIMRC<cr>

자기가 편한 키배열로 세팅을 하면 된다.

그리고 .vimrc 를 편집하고 저장하고, :source % 를 입력하면 스크립트를 다시 불러온다.

(여기서 % 는 현재 파일을 가리키는 특별한 문자)

여기서 :source % 또한 키매핑으로 다음과 같이

:nnoremap <leader>feR :source $MYVIMRC<cr>

할 수 있다. 하지만 이 방법도 저장하고 매번 타이핑 해야한다.

아직 배우지 않았지만 autocmd 를 이용하여 다음과 같이 설정할 수 있다.

augroup filetype_vim
autocmd!
autocmd BufWritePost *.vimrc,*.vim source $MYVIMRC
augroup END 

위 코드를 자신의 $MYVIMRC 에다 넣고 저장하고 테스트 해보라. (처음 저장시 :e % 필요할 수도 있음.)

A More Complicated Mapping ======

지금까지 간단한 키매핑을 만들어보았다.

이것만 가지고는 우리가 처음 목표로 삼았던 plugin 제작과는 거리가 멀다고 느껴질 수도 있다.

아주 조금, 복잡한 키매핑을 만들어보자.

우리가 “목표로” 하는 키매핑은 해당커서에 있는 단어에 대괄호 “[]” 로 감싸는 것이다.

어떻게 하면 될까? “일단” 키매핑을 바로 만들지 말고 어떻게 하면 해당 단어를 기계적인 방법으로 [] 로 감쌀지 생각해본다.

일단 나 같은 경우엔

bi"<esc>ww...

으로 시도해보았다. 하지만 ww 에서 다음단어의 시작으로 가서 실패했다.

두번 째 시도에선 bi”ea" 으로 성공했다.

<leader>S[

으로 매핑을 한다고 하면

:nnoremap <leader>S[ bi"<esc>ea"

이렇게 하면 된다.

감이 조금 “왔으면” 한다.

Buffer-Local Options and Mappings ======

===== key mapping ===== buffer-local 기준으로 옵션과 키매핑을 지정할 수도 있다.

:nnoremap <buffer> - x

으로 nnoremap 지정하고, :vs some.txt 후

some.txt buffer 에서 - 로 지워보려고 하면 x 명령어로 작동하지 않을 것이다.

buffer 마다 키매핑을 다르게 할 수 있단 이야기다.

nerdtree 가 설치되어있다면 nerdtree 를 열고 :nnoremap 를 타이핑 해보면

nerdtree 에서만 사용되는 키매핑을 볼 수 있다.

===== options & leader key =====

set number 과 같은 일반 옵션도 buffer 기준으로 지정 할 수 있다.

setlocal 을 통해 지정한다.

leader key 도 마찬가지로

:let maplocalleader=","
:nnoremap <localleader> x

위 처럼 local 으로 지정할 수 있다.

자세한건

:help setlocal
:help maplocalleader

참고하면 된다.

===== Shadowing =====

:nnoremap <buffer> - x
:nnoremap - i

두가지 매핑을 실행하고 - 를 눌렀을 때 어떤 결과가 나올까?

vim 은 buffer 명령어를 우선순위로 잡는다.

일반적인 프로그래밍 방식이랑 일치하며 이치에 맞아보인다.

Auto Commands ======

앞서 vimrc 로드를 위해 잠깐 소개했던 auto commands 를 정식으로 소개한다.

:autocmd BufNewFile * :echom "hi newfile"
:autocmd BufNewFile *.txt :echom "hi textfile"
:e somefile
:e somefile.txt

위 명령을 실행하고 :messages 해보자.

autocmd 는 특정한 이벤트가 발생할 때 실행할 명령어를 등록할 수 있다.

이 단문일 경우엔 in-line 으로 명령을 삽입하면 된다. 만약 여러 문장이면

뒷장에서 소개할 함수를 이용하여

:call function()

함수를 호출 할 수도 있다.

:autocmd BufNewFile * :write
     ^          ^ ^
     |          | |
     |          | 여기서부터 커맨드
     |          |
     |          대상이 되는 파일의 패턴
     |
     이벤트 종류

여기서 이벤트 종류와 파일의 패턴에 대해서 좀 더 알아보고 싶으면

:help event
:help autocmd-patterns 

을 통해 알아보도록 하자.

normal 명령어와 같이 써서 일련의 키시퀀스도 전달가능하다.

:autocmd BufWritePre *.vimrc normal gg=G 

===== Multiple Events =====

:autocmd BufWritePre *.virmc normal gg=G 
:autocmd BufRead *.virmc normal gg=G 

위 명령어는

:autocmd BufNewFile,BufRead *.html normal gg=G

이렇게 하나의 명령어로 합칠 수 있다.

===== autocmd FileType =====

:autocmd FileType javascript nnoremap <buffer> _ I//<esc>
:autocmd FileType python     nnoremap <buffer> _ I#<esc> 

FileType 에 따라 명령어를 지정할 수도 있다.

===== Buffer-local autocommands =====

:au CursorHold <buffer>  echo 'hold'
:au BufNewFile *.txt au CursorHold <buffer>  echo 'hold txtfile'
:au BufNewFile *.js au CursorHold <buffer>  echo 'hold jsfile'

autocmd 또한 buffer 단위로 명령을 지정할 수 있다.

위 명령어중 모르는 이벤트가 있을것이다. 지금까지 이 문서를 잘 따라왔다면 모르는 이벤트에 대해 어떻게 정보를 얻어야 하는지 알거라 생각한다.

즉시 실행해보자.

:help autocmd-buflocal

autocmd-buflocal 에 더 알아보고 싶으면 위 명령어를 통해 더 확인해보자.

Auto Command Groups ======

위에 소개했던 autocmd 는 사실 한가지 문제가 있었다.

이를 알아보기 위해

:au BufWrite * :echom "writing buffer."
:w
:messages

해보자. 예상대로 writing buffer 를 볼 수 있을 것이다.

여기서 멈추지 말고 한번 더

:au BufWrite * :echom "writing buffer."

를 실행하고

:w

해보자. messages 창에는 앞에 기록됐던 로그를 포함하여, 로그가 3개가 찍혀있다.

무슨 일이 일어난걸까?

vim 의 au 는 명령어들이 중첩된다.

이를 해결하기 위해 autocmd group 이라는게 있다.

:augroup testgroup
:au BufWrite * :echom "writing buffer1 in a group"
:augroup END
:augroup testgroup
:au BufWrite * :echom "writing buffer2 in a group"
:augroup END
:w

위 명령어를 실행해보자. 어떤지 살펴보자. 기대했던 결과가 나왔는가?

autocmd group 이 아까와 같은 불상사를 해결할 수 있다고 했는데, 사기 당한 기분이 들 것이다.

그렇다, augroup 조차 명령어가 중첩이 된다.

:augroup testgroup
:au!
:au BufWrite * :echom "writing buffer in a group"
:augroup END
:w

위와 같이 입력을 다시 해보고 로그를 살펴보자.

au! 는 선택된 그룹의 autocmd 명령어를 초기화 시켜준다.

자세한 사항은

:help autocmd-remove

자기의 vimrc 에 다음과 같이 augroup 을 등록시켜보자.

augroup testgroup
au!
au BufWrite * :echom "writing buffer in a group"
augroup END 

그리고 테스트를 해보자. 기대한 결과가 나오는지 확인하자.

return person.get_pets(type=””, fluffy_only=True)

Status Lines ======

vim 에서 제공하는 기능중에 현재 상태를 보여주는 곳이 있다. 그곳이 status line 이다.

:set statusline=filename:%f\ filetype:%y\ %l/%L."asdasd"

길게 설명할 것이 없이 위 명령어를 적용시켜 보자.

마치 C언어의 printf 를 보는 듯 하다.

===== General Format =====

The option consists of printf style '%' items interspersed with
normal text.  Each status line item is of the form:
%-0{minwid}.{maxwid}{item}

:help statusline 을 통해 일반적인 표현법을 보면 위처럼 설명이 나와있다.

간단히 확인하기 위해서

:set statusline=%l/%5.7L

해보자.

무한한 가능성을 statusline 에 부여하기 위해

:let g:ksoo="happy"
:set statusline=%{g:ksoo} 

해서 어떤게 나오는지 살펴보자.

Variables ======

지금까지 단일 명령어에 대한 것만 우리는 다룰 수 있었다.

이번장 부터는 정말 프로그래밍적인 관점에서 vim script 를 다뤄보려 한다.

간단히 변수 할당부터 시작해보자.

:let t = "test"
:echo t

test 라는 글자가 찍히는 것을 볼 수 있다. t 라는 변수에 문자열 “test” 를 넣은 것이다.

test 대신 숫자를 쓸 수도 있다.

:let t = 1004
:echo t

즉, vim script 변수엔 타입이 없다. 그냥 대입하면 된다.

===== Option as Variables ===== vim option 들을 변수로써 다룰 수도 있다.

예를 들어 sw(shiftwidth) 값을 echo 로 출력해보자.

:echo &sw

그렇다. 옵션에 대해서 접근하려면 &를 붙여서 접근한다. 이 & 표기는 C++의 reference 와는 전혀 성격도 다르고 관련이 없다.

&sw 는 읽기 전용의 변수가 아니다. 그래서

let &sw = &sw * 2

이런식으로 두배씩 올리는 명령도 등록 가능하다.

그러면 set 과 let 둘다 option 을 변경시킬 수 있는데 무슨 차이가 있을까?

let 은 프로그래밍적으로 제어할 수 있는 여지를 제공해주기 때문에 좀 더 프로그래머 관점에서 유연하게 옵션값을 다룰 수 있다.

===== Local Options =====

전장에서 :setlocal 이라는 명령어가 기억나나?

:setlocal 을 :let 로서 제어하는 변수가 있을것이다.

간단하게 앞에 l: 만 붙여주면 된다.

예를 들어

:let &l:sw=8

이것은 :setlocal sw=8 과 동일한 효과를 낸다. 앞서 설명했지만 let 을 이용한 방식은 프로그래밍적으로 유연성을 제공해준다.

===== Registers as Variables =====

당장 :reg 를 쳐보자.

우리가 vim 을 쓰면서 등록해뒀던 registers 가 보일것이다.

이 registers 를 변수로서 가져오는 방법이 있다.

prefix @ 를 붙이면 된다.

아무 문장이나 yy 를 통해 yank 한 후에

:echo @0 

을 타이핑해보자.

이를 이용해서 지워진 버퍼를 이용해 레지스터를 이용하는 방법은 그다지 추천되지 않는다.

왜냐면 사용자가 레지스터에 중요한 내용을 가지고 있을 가능성이 있기 때문이다.

Variable Scoping ======

전장에서 &l:something 이 기억나는가? 다양한 프로그래밍 언어에서 변수의 스코프를 지원한다.

C언어를 예를 들면

int a = 3; { int a = 5; print a } print a


블록 {} 을 기준으로 스코프가 결정된다. vim 은 텍스트 에디터답게 특이한 방식으로 변수의 스코프를 결정한다.

간단하게 버퍼 스코프를 테스트 해보자.

일단 아무 문서나 열고 

:let b:vim = “script” :echo b:vim


써보고 다른 버퍼를 열어서 또 다시

:echo b:vim


을 써보자. 두번 째 :echo 명령어에서 변수를 찾을 수 없다고 떴을 것이다.

이러한 스코프는 b: 를 포함해서 8개의 스코프가 있다. 이를 확인하기 위해서 

:help internal-variables


를 통해 한번 어떤 스코프가 있는지 살펴보자.

이번에는 친절하게 help 문서를 직접 가져왔다.

|buffer-variable| b: Local to the current buffer. |window-variable| w: Local to the current window. |tabpage-variable| t: Local to the current tab page. |global-variable| g: Global. |local-variable| l: Local to a function. |script-variable| s: Local to a |:source|’ed Vim script. |function-argument| a: Function argument (only inside a function). |vim-variable| v: Global, predefined by Vim.


언제나 help 문서를 보는 버릇을 들이자. 

## Control Statements ======

이 장부터는 test.vim 와 같은 vim 을 열어놓고 테스트 하는게 편하다.




===== if  =====

먼저 if 문을 확인하자.

test.vim 

if 1 echom “one” endif

if “string” echom “string != false?” endif


기대했던 결과가 나왔나? 아마 아닐것이다.

두번 째 echom 이 나오지 않았다. 무슨일이지?

이 현상을 좀 더 고찰하기 위해서 다음 명령을 수행해보자.

if “11” echom “wow!” endif


wow! 가 보인다. 감이 올거다. 좀 더 테스트 해보자.

echom “string” + 5 echom “10string” + 5 echom “string10” + 10


결과는 

5 15 10


아하! vim 은 string 이 정수로 평가 되는 장소에 있으면 정수로 바뀌려는 성질을 가지고 있구나.

그 변환 규칙은 문자열의 앞에 숫자가 없으면 0이 되구나!

이제 다시 한번 위에 처음 제시한 test.vim 을 보면 결과가 빠르게 이해가 될 것이다.

===== Else and Elseif =====

if 가 있으면 당연 else 가 있다.

test.vim

let k=5 if k==1 echo “k=1” elseif k>=6 echo “k>=6” else echo “k=?” endif


위 예문으로 확인하자.

===== Condition =====

위에서 다룬 비교 명령만으론 정말로 부족하다. 

문자열에 대해서 비교를 해보자.

set noignorecase if “hello” == “HELLO” echom “case INsensitive” elseif “foo” == “foo” echom “case sensitive” endif

set ignorecase if “hello” == “HELLO” echom “case INsensitive” elseif “foo” == “foo” echom “case sensitive” endif


실행하고 결과를 보자.

다른 언어들 처럼 == 는 무조건 insensitive 혹은 sensitive 둘중에 하나가 동작하는게 아니라, set ignorecase 유무에 따라 다른 동작을 하다니 어처구니가 없다.

이처럼 문자열 비교에 있어서 == 를 쓰게 되면 set ignorecase 유무에 따라 다른 동작을 하게 된다. 이는 스크립트 제작에 있어서 큰 걸림돌로 다가온다.

유저의 세팅을 믿으면 안된다.

그러면 어떻게 하나?

비교 연산자 vim 은 ==?, ==# 를 제공한다.

if “hello” ==? “HELLO” echom “case INsensitive” elseif “foo” ==? “foo” echom “case sensitive” endif

if “hello” ==# “HELLO” echom “case INsensitive” elseif “foo” ==# “foo” echom “case sensitive” endif


==? : INsensitive   ==
==# : sensitive ==


===== list type =====
다음장에서 반복문에 대해 이야기를 할텐데, 그 전에 list 자료형을 먼저 소개해야겠다.

echo [1,2,3] echo [1, [2,3]] echo [1,[2,3]][1] echo [1,[2,3]][-1] echo [1,2,3,4][0:2]


를 타이핑 해보자.

vim 의 list indexing 은 파이썬의 list 와 흡사하다. 하지만 [0:2] 에서 범위는 실제로 [0,2] 였다. (파이선은 [0,1] 범위)

indexing 에서 음수가 나오면 -1 은 마지막 요소를 가리킨다.

하나만 더 해보자.

:echo [1,2,3][:1] :echo [1,2,3][1:]


여전히 파이썬의 indexing 과 비슷하다.

또한 vim 은 string 을 indexing 으로 접근하는것을 허용한다.

:echo “hello”[1:2]


실행해보면 el 이 나온다.

===== Concatenation =====

:echo “hello”+”world” :echo “hello”.”world” :echo [1,2] + [3] :echo [100, 101, [1,2] + [3]]


문자열의 결합은 . 으로 하게 되고, 문자열의 결합을 + 로 하면 앞서 살펴 봤듯 숫자로 평가 되면서 0 이 나온다.

list 는 + 으로 결합하면 합쳐지게 된다. 이 표현은 nested 된 표현식에도 쓸 수 있고 매우 유연하게 쓸 수 있다.

===== Built-in Functions For List =====

:let var = [‘a’] :call add(var, ‘b’) :echo var :echo get(var, 0, “defaultvalue”) :echo get(var, 33, “defaultvalue2”) :echo index(var, ‘b’) :echo index(var, ‘c’)


echo 의 결과

[a, b] a defaultvalue2 1 -1


부연 설명은 하지 않겠다. 더 궁금한 사항이 있으면 :help 를 활용하자.  

===== for =====

vim 의 for 문은 기본적으로 list 를 순회하는데에 목적이 있다.

간단히 예문을 적어보자면 

for i in [1,2,3,4] echom i endfor

for [i, j] in [[1,2], [3,4]] echom i . j echom “——-“ endfor

for [i, j, k] in [[1,2,3], [4,5, 6]] echom i . j . k echom “——-“ endfor



결과

1 2 3 4 ——- 12 ——- 34

….


형태가 된다. 마지막 [i, j, k] 는 어떻게 될지 직접 실행해보라.

그리고 

let var = [[:apple_1000_banana_2000_pineapple_3000]]

이러한 listlist 가 있을 때 

apple price : 1000  
banana price : 2000  
pineapple price : 3000  

결과가 나오기 위해서 어떻게 코딩을 해야할지 풀어봐라. 농담이 아니다. 진짜 해봐야 한다.

그래야 기억에 남는다. 

그리고 vim-for 는 c-style 의 for 문을 제공하지 않는다. 

예를 들면 for(i=0; i<=10; i++) 이러한 세개의 섹션으로 이뤄진 for 문을 지원하지 않는다.

이는 while 로 처리해야 한다.

===== while =====

while 은 아주 오래된 고전적인 루프문이다.

이전에 c-style 의 for 문이 없다고 했지만 while 은 이를 100% 대체할 수 있다.

for(A; B; C) D


위와 같은 문장이 있을 때 while 은 

A while B D C endwhile


으로 1:1 대응 되는 문법이기 때문이다.

간단히 예문을 살펴보자.

let c = 1

while c <= 10 echo c let c += 1 endwhile


직접 실행해보고 결과를 살펴봐라.

그리고 

* ** * ** *****


이러한 별이 찍히도록 while 문을 사용해서 코딩해봐라.
(hint : Concatenation, while, let)

vim script 는 다른 언어랑 다르게 조금 문법이 조잡한 편이라서 이런거 직접 해보는게 도움이 된다.

지금부터는 내가 내는 문제들을 직접 코딩을 하면서 익혀야 한다. 손이 기억을 해야 나중에 필요한 것들을 무리없이 만들 수 있다.  

## Dictionary ======

Dictionary 형태의 자료형에 대해서 소개한다.

이 자료형은 매우매우 중요하다. 기본 string, number 타입은 당연히 알아야 하고 앞서 소개했던 list 도 많이 쓰지만, Dictionary 자료형태도 무지무지하게 많이 쓰인다.

다른 프로그래밍을 접해봤다면 이 자료형의 중요성과 잠재력에 대해서는 알거라 생각한다.

말이 길어졌는데, 내 문서의 특징은 "말은 짧게, 코드는 길게" 라는 철학이 있기 때문에 바로 예제 코드를 살펴보겠다.

let c = {“apple”:1000, “banana”:2000, “pineapple”:3000, “watermelon”:10000}

echo c

echo c[“apple”]

echo c[“banana”] echo c.watermelon

let index = “banana” echo c[index]

” error echo c.index

let c[“banana”] = 10 echo c[“banana”]



{key1:value1, key2:value2, ... } 형태다.

보다시피 {} 으로 표현하고 javascript 의 그것과 매우 흡사하다.

자료의 접근은 [] 또는 . 으로 한다. 하지만 . 간단하게 접근 할 수 있지만 변수를 index 로 쓰는건 안된다. 쓰임이 조금 제한된다.

자료의 변경또한 let 으로 자유롭게 가능하다.

하지만 한가지 제한이 있는데, key 는 무조건 문자열(문자)만 들어올 수 있다.


===== Remove =====



let c = {“apple”:1000, “banana”:2000, “pineapple”:3000, “watermelon”:10000} let t = remove(c, “apple”) echo t echo c

let c = {“apple”:1000, “banana”:2000, “pineapple”:3000, “watermelon”:10000} unlet c[“apple”] echo c


위 코드를 실행해보자. remove 는 삭제하면서 해당하는 key 의 value 를 리턴한다.

반면 unlet 은 그렇지 않다. remove 쓸건지 unlet 을 쓸건지는 순전히 개인적인 취향차이라고 볼 수 있다.

===== Value-Check =====

이 때 없는 값을 조회해보자. 예를 들면 c["dsjflajdfl"] 이러한 값을 echo 로 출력해보자.

error가 날 것이다. vim 은 매우 유연하여 스크립트에 일부 에러가 나더라도 밑의 문장을 계속하여 실행한다. 하지만 이러한 메세지가 뜬다면 사용자도 신뢰를 가지지 못할 것이고, 더러운 메시지가 vim 을 덮을 것이다.

그래서 해당하는 key 가 유효한지 확인하는 작업이 필요하게 된다.

크게 세가지 스타일이 있다.

let c = {“apple”:1000, “banana”:2000, “pineapple”:3000, “watermelon”:10000} try let t = remove(c, “djfldsjlk”) echo t catch echo “error” endtry “”””””””””””””””””””””””””””””””””””””””””” let c = {“apple”:1000, “banana”:2000, “pineapple”:3000, “watermelon”:10000}

if has_key(c, “asdasld”) echo “has” else echo “has not” endif “”””””””””””””””””””””””””””””””””””””””””” let value = get(c, “asdjasdjl”, “defaultvalue”) if value ==# “defaultvalue” … else … endif


try-catch 문을 이용하여 예외처리를 하거나, has_key 로 검사하거나, get 을 이용하여 defaultvalue 를 비교하면 된다.

마지막으로 dictionary 를 loop 시키는 방법에 대해서 알아본다.

let c = {“apple”:1000, “banana”:2000, “pineapple”:3000, “watermelon”:10000} echo items(c) for [i, j] in items(c) echo i . “ : “ . j endfor


먼저 items(c) 을 출력값을 보자. 앞서 설명했던 dictionary 를 listlist 로 바꿔준다.

그리고 우리는 listlists 를 loop 를 도는 방법을 배웠기 때문에 이를 활용할 수 있다.

더 알고 싶으면 :help items 를 참고하자.  

## Functions ======

대부분의 프로그래밍 언어에서처럼 vimsciprt 도 함수를 지원한다. 

어떻게 하는지 코드로 살펴보자.
===== Basic =====

function Foo() echom “hello” endfunction

call Foo()


실행해보자. 여기서 주목할 점은 함수이름의 시작이 대문자인것을 주목해야 한다. 소문자로 써보고 결과를 살펴보자.

그리고 여기서 확인한 에러 넘버 Exxx 를 기억해서 :help Exxx 를 쳐보자.

관련 내용을 확인하고 숙지하자.

function s:foo() echom “hello” endfunction call s:foo()


저번장에서 배운 scope 가 기억나는지 모르겠다.

변수뿐만 아니라 function 도 scope 를 지정할 수 있다.

반복하자면 

:help internal-variables


을 이용해서 변수를 확인해보자.

===== redefinition =====

실행했던 코드에서 다시 한번 :so % 를 해서 실행해보자.

이미 함수가 존재한다고 에러를 뿜는다. 해결은 간단하다.

function! s:foo() echom “hello” endfunction call s:foo()


앞에 ! 를 붙이면 이미 함수가 정의되어있더라도 에러를 무시하게 된다.

===== Parameters =====

다른 언어에서도 마찬가지이겠지만 vim 함수에는 파라메터가 들어갈 수 있다. 

function! s:power(name) echom “hello : “ . a:name endfunction

call s:power(“kangssu”)


vim 함수에서는 파라메터를 참조하기 위해서는 a: 라는 스코프 지정자를 사용한다.

만약 a: 를 붙이지 않는다면, vim script 는 name 을 찾을 수 없다고 에러를 뿜을 것이다.

===== ... parameter =====

function! s:power(…) echom a:0 echom a:1 echo a:000

let l:i = 0 while l:i < len(a:000) echo a:000[l:i] let l:i += 1 endwhile endfunction

call s:power(“h”, “i”, “man”)


위 코드는 ... 로 가변 인자를 받았을 때, 어떻게 접근하는지 알아볼 수 있는 코드다.

차례대로 a:0, a:1, a:2, ... 식으로 접근가능하고, 전체 리스트를 뽑기 위해서는

특별한 인덱스인 a:000 을 이용해서 접근한다.

echo a:000 의 결과를 살펴보면

[“h”, “i”, “man”]


으로 나온다.

이 배열은 len 으로 크기를 얻어올 수 있어서 while 문으로 순회가능하다.

l: 에 대해서 잘 모르겠다면 앞장을 복습해보자.

c 언어의 printf 처럼 처음인자만 문자열으로 받고 나머지만 가변인자로 받는것이 가능하다.

함수 선언부를 

function! s:power(fixed, …)


으로 바꾸고 다시 실행해보자.

===== rvalue-Parameters =====

들어온 arguments 는 read-only 다. 이를 테스트 해보자.

function! s:power(foo) let a:foo = “error” echo a:foo endfunction

call s:power(“man”)

다음과 같은 에러를 뱉을 거다. can not change read-only variable a:foo

이로서 vim 의 function 에 대해서 조금 맛을 봤다. 아직은 살짝 맛만 본 단계지만 활용하는건 너의 몫이다.

## Strings ======

vim 은 기본적으로 텍스트 에디터가 무엇인가? 문자열을 다루는 소프트웨어다. 그 문자열을 다루는 소프트웨어의 스크립트에서 가장 중요한 것은 문자열을 처리하는 방법이다.

그래서 이 장은 매우 중요하다.

그래서 마지막 부분에 예제 문제를 몇개 던져줄텐데, 꼭 코딩을 해보고 넘어가도록 하자.

===== Basic =====

:echom “100 apple” + “200 man”


결과는 300 이다.



:echom “apple 100” + “man 200”


결과는 0 이다.

기본적으로 + 연산은 오직 숫자에게만 적용된다.


:echom “apple 100” . “man 200”


결과는 apple 100man 200

===== Special Characters =====

특수한 문자 " 나 \ 를 표시하고 싶을 땐 escape 문자 \ 를 쓴다.



:echom “my name is "apple".”


실행해보자.

그리고 


:echom ‘my name is “apple”.’


실행해보자.

" 는 <\n, "> 와 같은 특수문자를 표현하기 위해 escape 문자가 필요하다.

하지만 ' 는 escape 가 필요하지 않다.

조금 더 테스트 하기 위해 


:echom ‘a’‘b’ :echom ‘a’’'’b’


두개의 명령어를 실행해보자. 

그렇다. '' 는 ' 로 나온다.

===== String Functions =====


:echo split(“sang moo hospital”) :echo split(“sang|moo|hospital”, “|”)


결과는 둘다, 
['sang', 'moo', 'hospital']

그리고 합치는 것도 가능하다.


:echo join(split(“sang moo hospital”)) :echo join(split(“sang moo hospital”), “!!”)


쳐보고 결과를 보자.

join 의 인자로 list 를 받는다. list 를 두번 째 인자를 끼워 합친 결과가 리턴된다.


## Excute ======


Excute~Excute Normal! 까지 굉장히 중요한 장이다.

사실 목차를 이것부터 해야한다고도 생각할 정도로 뭔가 만들 때 비중이 높은 챕터고, 개념을 확실히 짚고 넘어가야 한다.

execute 는 문자열로 된 식을 평가하는 함수다. 

execute “echo ‘hello’”


라고 쳐보자. 예상대로 hello 가 뜰것이다. 그렇다면 :echo 'hello' 랑 뭐가 다르냐고?

:echo getpid()


라고 쳐보자. 현재 vim 의 process id 가 뜬다. 

만약 vim 에서 현재 <process id>.txt 의 파일을 열고 싶다면 어떻게 해야할까?

먼저 시도해본다. :e getpid().txt

4443.txt 이런식의 파일이 열리길 기대했지만 vim 은 문자 그대로 getpid().txt 가 열린다.

이럴 때 execute builtin 함수가 요긴하게 쓰인다.

:execute “e “ . getpid() . “.txt”


성공한다. 4443.txt 의 파일이 열린다. 





## Normal ======

:norm[al][!] {commands}


이 때 commands 는 normal mode 에서 사용되는 키보드 스트로크의 집합이다.

예를 들면

apple banana pineapple

이라는 단어가 있을 때

banana 위에서 

:normal diw

하게 되면 banana 에서 diw 한 것과 같다.

[!] 는 현재 매핑된 key 와 관계없이 vim 고유의 매핑을 이용하고 싶을 때 사용한다.

:nnoremap w dd


으로 매핑한 상태에서 

:normal w

으로 해보고

:normal! w


으로 실행해봐라. 



## Excute Normal! ======


getpid 는 현재 프로세스의 아이디를 가져온다.

전장에서 배웠던 execute 와 normal 과의 절묘한 조합으로

커서위의 단어를 현재 프로세스아이디로 교체할 수 있다.



execute “normal! ciw”.getpid().”<ESC>”


위 코드는

execute “normal! ciw30334<ESC>” ```

이렇게 변환이 된다. normal 로만 해결할 수 없고, execute 만으로 해결할 수 없는 문제를 execute normal! 로 해결하는 모습이다.

Functional Programming ======