內建

Nvim 的 :help 頁面,從 原始碼 使用 tree-sitter-vimdoc 解析器產生


內建函式 builtin-functions
關於依用途分組的函式,請參閱 function-list

1. 詳細資訊 builtin-function-details

abs({expr}) abs()
回傳 {expr} 的絕對值。當 {expr} 的計算結果為 浮點數 時,abs() 回傳一個 浮點數。當 {expr} 可以轉換為 數字 時,abs() 回傳一個 數字。否則,abs() 會給出錯誤訊息並回傳 -1。範例
echo abs(1.456)
1.456
echo abs(-5.456)
5.456
echo abs(-4)
4
參數
{expr} (數字)
回傳
(數字)
acos({expr}) acos()
回傳 {expr} 的反餘弦值,以弧度為單位,以 浮點數 形式回傳,範圍在 [0, pi] 之間。{expr} 的計算結果必須為 浮點數 或範圍在 [-1, 1] 之間的 數字。如果 {expr} 超出範圍 [-1, 1],則回傳 NaN。如果 {expr} 不是 浮點數數字,則回傳 0.0。範例
echo acos(0)
1.570796
echo acos(-0.5)
2.094395
參數
{expr} (數字)
回傳
(數字)
add({object}, {expr}) add()
將項目 {expr} 附加到 列表Blob {object}。回傳結果的 列表Blob。範例
let alist = add([1, 2, 3], item)
call add(mylist, "woodstock")
請注意,當 {expr}列表 時,它會作為單一項目附加。使用 extend() 來串連 列表。當 {object}Blob 時,則 {expr} 必須為數字。使用 insert() 在另一個位置新增項目。如果 {object} 不是 列表Blob,則回傳 1。
參數
{object} (任意)
{expr} (任意)
回傳
(任意) 結果的 列表Blob,如果 {object} 不是 列表Blob,則回傳 1。
and({expr}, {expr}) and()
對兩個引數執行位元 AND 運算。引數會轉換為數字。列表、字典或浮點數引數會導致錯誤。另請參閱 or()xor()。範例
let flag = and(bits, 0x80)
參數
{expr} (數字)
{expr1} (數字)
回傳
(整數)
api_info() api_info()
回傳 api-metadata 的字典。
以易於理解的格式檢視
lua vim.print(vim.fn.api_info())
回傳
(表格)
append({lnum}, {text}) append()
{text}列表 時:將 列表 中的每個項目作為文字行附加到目前緩衝區中第 {lnum} 行的下方。否則,將 {text} 作為一行文字附加到目前緩衝區中第 {lnum} 行的下方。接受任何類型的項目並將其轉換為字串。{lnum} 可以為零,以在第一行之前插入一行。{lnum} 的使用方式與 getline() 相同。失敗時回傳 1 ({lnum} 超出範圍或記憶體不足),成功時回傳 0。當 {text} 為空列表時,無論 {lnum} 的值為何,都會回傳零。範例
let failed = append(line('$'), "# THE END")
let failed = append(0, ["Chapter 1", "the beginning"])
參數
{lnum} (整數)
{text} (字串|字串[])
回傳
(0|1)
appendbufline({buf}, {lnum}, {text}) appendbufline()
append() 類似,但在緩衝區 {expr} 中附加文字。
此函式僅適用於已載入的緩衝區。如果需要,請先呼叫 bufload()
關於 {buf} 的用法,請參閱 bufname()
{lnum} 是要附加在其下方的行號。請注意,使用 line() 會使用目前的緩衝區,而不是要附加文字的緩衝區。使用 "$" 在緩衝區末尾附加。不支援其他字串值。
成功時回傳 0,失敗時回傳 1。
如果 {buf} 不是有效的緩衝區或 {lnum} 無效,則會顯示錯誤訊息。範例
let failed = appendbufline(13, 0, "# THE START")
但是,當 {text} 為空列表時,不會針對無效的 {lnum} 給出錯誤,因為實際上不會使用 {lnum}
參數
{buf} (整數|字串)
{lnum} (整數)
{text} (字串)
回傳
(0|1)
argc([{winid}]) argc()
結果為引數清單中的檔案數量。請參閱 arglist。如果未提供 {winid},則會使用目前視窗的引數清單。如果 {winid} 為 -1,則會使用全域引數清單。否則,{winid} 會指定要使用其引數清單的視窗:視窗編號或視窗 ID。如果 {winid} 引數無效,則回傳 -1。
參數
{winid} (整數?)
回傳
(整數)
argidx() argidx()
結果是引數清單中的目前索引。0 是第一個檔案。argc() - 1 是最後一個檔案。請參閱 arglist
回傳
(整數)
arglistid([{winnr} [, {tabnr}]]) arglistid()
回傳引數清單 ID。這是一個用於識別正在使用的引數清單的數字。全域引數清單使用零。請參閱 arglist。如果引數無效,則回傳 -1。
不使用引數時,會使用目前的視窗。僅使用 {winnr} 時,會使用目前索引標籤頁面中的此視窗。使用 {winnr}{tabnr} 時,會使用指定索引標籤頁面中的視窗。{winnr} 可以是視窗編號或 視窗 ID
參數
{winnr} (整數?)
{tabnr} (整數?)
回傳
(整數)
argv([{nr} [, {winid}]]) argv()
結果為引數清單中的第 {nr} 個檔案。請參閱 arglist。「argv(0)」是第一個檔案。範例
let i = 0
while i < argc()
  let f = escape(fnameescape(argv(i)), '.')
  exe 'amenu Arg.' .. f .. ' :e ' .. f .. '<CR>'
  let i = i + 1
endwhile
如果沒有 {nr} 引數,或當 {nr} 為 -1 時,則會回傳包含整個 arglist列表
{winid} 引數會指定視窗 ID,請參閱 argc()。關於 Vim 命令列引數,請參閱 v:argv
如果引數清單中不存在第 {nr} 個引數,則回傳空字串。如果 {winid} 引數無效,則回傳空列表。
參數
{nr} (整數?)
{winid} (整數?)
回傳
(字串|字串[])
asin({expr}) asin()
回傳 {expr} 的反正弦值,以弧度為單位,以 浮點數 形式回傳,範圍在 [-pi/2, pi/2] 之間。{expr} 的計算結果必須為 浮點數 或範圍在 [-1, 1] 之間的 數字。如果 {expr} 超出範圍 [-1, 1],則回傳 NaN。如果 {expr} 不是 浮點數數字,則回傳 0.0。範例
echo asin(0.8)
0.927295
echo asin(-0.5)
-0.523599
參數
{expr} (任意)
回傳
(數字)
assert_beeps({cmd}) assert_beeps()
執行 {cmd},如果它未產生嗶聲或視覺響鈴,則將錯誤訊息新增至 v:errors。另請參閱 assert_fails()assert_nobeep()assert-return
參數
{cmd} (字串)
回傳
(0|1)
assert_equal({expected}, {actual} [, {msg}]) assert_equal()
{expected}{actual} 不相等時,會將錯誤訊息新增至 v:errors 並回傳 1。否則回傳零。assert-return 錯誤的格式為「Expected {expected} but got {actual}」。當 {msg} 存在時,會將其作為前綴,並包含從指令碼執行時的斷言位置。
沒有自動轉換,字串「4」與數字 4 不同。數字 4 與浮點數 4.0 不同。此處不使用 'ignorecase' 的值,大小寫始終重要。範例
call assert_equal('foo', 'bar', 'baz')
會將以下內容新增至 v:errors
test.vim 第 12 行:baz: Expectedfoo but gotbar
參數
{expected} (任意)
{actual} (任意)
{msg} (任意?)
回傳
(0|1)
assert_equalfile({fname_one}, {fname_two}) assert_equalfile()
當檔案 {fname_one}{fname_two} 未包含完全相同的文字時,會將錯誤訊息新增至 v:errors。另請參閱 assert-return。當 {fname_one}{fname_two} 不存在時,錯誤訊息會提及這一點。
參數
{fname_one} (字串)
{fname_two} (字串)
回傳
(0|1)
assert_exception({error} [, {msg}]) assert_exception()
當 v:exception 未包含字串 {error} 時,會將錯誤訊息新增至 v:errors。另請參閱 assert-return。這可以用於斷言命令擲回例外。使用錯誤編號,後接冒號,可以避免翻譯問題
try
  commandthatfails
  call assert_false(1, 'command should have failed')
catch
  call assert_exception('E492:')
endtry
參數
{error} (任意)
{msg} (任意?)
回傳
(0|1)
assert_fails()
assert_fails({cmd} [, {error} [, {msg} [, {lnum} [, {context}]]]]) 執行 {cmd},如果它未產生錯誤,或在錯誤訊息中找不到 {error} 時,會將錯誤訊息新增至 v:errors。另請參閱 assert-return
{error} 為字串時,必須在第一個回報的錯誤中逐字找到。大多數情況下,這會是包含冒號的錯誤代碼,例如「E123:」。
call assert_fails('bad cmd', 'E987:')
{error} 為包含一或兩個字串的 列表 時,這些字串會用作模式。第一個模式會與第一個回報的錯誤比對
call assert_fails('cmd', ['E987:.*expected bool'])
如果存在第二個模式,則會與最後一個回報的錯誤比對。若只要比對最後一個錯誤,請對第一個錯誤使用空字串
call assert_fails('cmd', ['', 'E987:'])
如果 {msg} 為空,則不會使用。在傳遞 {lnum} 引數時,執行此操作以取得預設訊息。E1115
{lnum} 存在且不為負數,且 {error} 引數存在並符合時,會將其與回報錯誤的行號進行比較。這可能是函式或指令碼中的行號。E1116
{context} 存在時,會將其用作模式,並與 {lnum} 所在的內容 (指令碼名稱或函式名稱) 比對。
請注意,嗶聲不被視為錯誤,而某些失敗的命令只會發出嗶聲。請對這些命令使用 assert_beeps()
參數
{cmd} (字串)
{error} (任意?)
{msg} (任意?)
{lnum} (整數?)
{context} (任意?)
回傳
(0|1)
assert_false({actual} [, {msg}]) assert_false()
{actual} 不是 false 時,會像 assert_equal() 一樣,將錯誤訊息加入到 v:errors 中。錯誤訊息的格式為「Expected False but got {actual}」。如果存在 {msg},則會在錯誤訊息前加上此訊息,並且在從腳本執行時,會加上 assert 所在的位置。另請參閱 assert-return
當值為零時,即為 false。當 {actual} 不是數字時,assert 會失敗。
參數
{actual} (任意)
{msg} (任意?)
回傳
(0|1)
assert_inrange({lower}, {upper}, {actual} [, {msg}]) assert_inrange()
此函數會斷言數字和 Float 值。當 {actual} 小於 {lower} 或大於 {upper} 時,會將錯誤訊息加入到 v:errors 中。另請參閱 assert-return。錯誤訊息的格式為「Expected range {lower} - {upper}, but got {actual}」。如果存在 {msg},則會在錯誤訊息前加上此訊息。
參數
{lower} (number)
{upper} (number)
{actual} (number)
{msg} (string?)
回傳
(0|1)
assert_match({pattern}, {actual} [, {msg}]) assert_match()
{pattern}{actual} 不匹配時,會將錯誤訊息加入到 v:errors 中。另請參閱 assert-return。錯誤訊息的格式為「Pattern {pattern} does not match {actual}」。如果存在 {msg},則會在錯誤訊息前加上此訊息,並且在從腳本執行時,會加上 assert 所在的位置。
{pattern} 的使用方式與 expr-=~ 相同:匹配總是像設定了 'magic''cpoptions' 為空一樣進行,無論 'magic''cpoptions' 的實際值為何。
{actual} 會被當作字串使用,會自動進行轉換。使用 "^" 和 "$" 來匹配文字的開頭和結尾。同時使用兩者來匹配整個文字。
範例
call assert_match('^f.*o$', 'foobar')
將會產生一個字串,並加入到 v:errors
test.vim 第 12 行:Pattern '^f.*o$' does not matchfoobar
參數
{pattern} (string)
{actual} (string)
{msg} (string?)
回傳
(0|1)
assert_nobeep({cmd}) assert_nobeep()
執行 {cmd},如果產生嗶聲或視覺鈴聲,則將錯誤訊息加入到 v:errors 中。另請參閱 assert_beeps()
參數
{cmd} (字串)
回傳
(0|1)
assert_notequal({expected}, {actual} [, {msg}]) assert_notequal()
assert_equal() 相反:當 {expected}{actual} 相等時,將錯誤訊息加入到 v:errors 中。另請參閱 assert-return
參數
{expected} (任意)
{actual} (任意)
{msg} (任意?)
回傳
(0|1)
assert_notmatch({pattern}, {actual} [, {msg}]) assert_notmatch()
assert_match() 相反:當 {pattern}{actual} 匹配時,將錯誤訊息加入到 v:errors 中。另請參閱 assert-return
參數
{pattern} (string)
{actual} (string)
{msg} (string?)
回傳
(0|1)
assert_report({msg}) assert_report()
使用字串 {msg} 直接回報測試失敗。永遠回傳 1。
參數
{msg} (string)
回傳
(0|1)
assert_true({actual} [, {msg}]) assert_true()
{actual} 不是 true 時,會像 assert_equal() 一樣,將錯誤訊息加入到 v:errors 中。另請參閱 assert-return。當值為非零數字或 v:true 時,即為 TRUE。當 {actual} 不是數字或 v:true 時,assert 會失敗。如果提供 {msg},則會在預設訊息前加上此訊息,並且在從腳本執行時,會加上 assert 所在的位置。
參數
{actual} (任意)
{msg} (string?)
回傳
(0|1)
atan({expr}) atan()
回傳 {expr} 的反正切主值,以弧度為單位,範圍在 [-pi/2, +pi/2] 之間,型別為 Float{expr} 的計算結果必須為 FloatNumber。如果 {expr} 不是 FloatNumber,則回傳 0.0。範例
echo atan(100)
1.560797
echo atan(-4.01)
-1.326405
參數
{expr} (數字)
回傳
(數字)
atan2({expr1}, {expr2}) atan2()
回傳 {expr1} / {expr2} 的反正切值,以弧度為單位,範圍在 [-pi, pi] 之間,型別為 Float{expr1}{expr2} 的計算結果必須為 FloatNumber。如果 {expr1}{expr2} 不是 FloatNumber,則回傳 0.0。範例
echo atan2(-1, 1)
-0.785398
echo atan2(1, -1)
2.356194
參數
{expr1} (數字)
{expr2} (number)
回傳
(數字)
blob2list({blob}) blob2list()
回傳一個 List,其中包含 Blob {blob} 中每個位元組的數值。範例
blob2list(0z0102.0304)        " returns [1, 2, 3, 4]
blob2list(0z)                " returns []
發生錯誤時回傳空的 List。list2blob() 執行相反的操作。
參數
{blob} (any)
回傳
(any[])
browse({save}, {title}, {initdir}, {default}) browse()
顯示檔案請求器。只有當 "has("browse")" 回傳 TRUE 時(僅在某些 GUI 版本中)才有效。輸入欄位為:當 TRUE 時,{save} 選擇要寫入的檔案,{title} 為請求器的標題,{initdir} 為開始瀏覽的目錄,{default} 為預設檔案名稱。當按下「取消」按鈕、發生錯誤或無法瀏覽時,會回傳空字串。
參數
{save} (any)
{title} (string)
{initdir} (string)
{default} (string)
回傳
(0|1)
browsedir({title}, {initdir}) browsedir()
顯示目錄請求器。只有當 "has("browse")" 回傳 TRUE 時(僅在某些 GUI 版本中)才有效。在不支援目錄瀏覽器的系統上,會使用檔案瀏覽器。在這種情況下:選擇要使用的目錄中的檔案。輸入欄位為:{title} 為請求器的標題,{initdir} 為開始瀏覽的目錄。當按下「取消」按鈕、發生錯誤或無法瀏覽時,會回傳空字串。
參數
{title} (string)
{initdir} (string)
回傳
(0|1)
bufadd({name}) bufadd()
使用名稱 {name}(必須是字串)將緩衝區加入到緩衝區清單中。如果檔案 {name} 的緩衝區已存在,則回傳該緩衝區編號。否則回傳新建立的緩衝區編號。當 {name} 為空字串時,總是會建立新的緩衝區。緩衝區不會設定 'buflisted',而且尚未載入。若要將一些文字加入到緩衝區,請使用以下方式
let bufnr = bufadd('someName')
call bufload(bufnr)
call setbufline(bufnr, 1, ['some', 'text'])
發生錯誤時回傳 0。
參數
{name} (string)
回傳
(整數)
bufexists({buf}) bufexists()
結果為 Number,如果存在名為 {buf} 的緩衝區,則為 TRUE。如果 {buf} 參數是數字,則使用緩衝區編號。數字零為目前視窗的替代緩衝區。
如果 {buf} 參數是字串,則必須完全符合緩衝區名稱。名稱可以是
相對於目前目錄。
完整路徑。
'buftype' 設定為 "nofile" 的緩衝區名稱。
URL 名稱。將會找到未列出的緩衝區。請注意,說明檔案在其 :buffers 的輸出中會以短名稱列出,但 bufexists() 需要使用其長名稱才能找到它們。bufexists() 可能會回報緩衝區存在,但是若要將名稱與 :buffer 命令一起使用,您可能需要使用 expand()。特別是在 MS-Windows 中,對於 "c:\DOCUME~1" 格式的 8.3 名稱。使用 "bufexists(0)" 來測試是否存在替代檔案名稱。
參數
{buf} (any)
回傳
(0|1)
buflisted({buf}) buflisted()
結果為 Number,如果存在名為 {buf} 的緩衝區,且該緩衝區已列出(已設定 'buflisted' 選項),則為 TRUE{buf} 參數的使用方式與 bufexists() 相同。
參數
{buf} (any)
回傳
(0|1)
bufload({buf}) bufload()
確保已載入緩衝區 {buf}。當緩衝區名稱參考現有檔案時,則會讀取該檔案。否則緩衝區將會是空的。如果緩衝區已載入,則不會有任何變更。如果緩衝區與檔案沒有關聯,則不會讀取任何檔案(例如,當 'buftype' 為 "nofile" 時)。如果緩衝區檔案存在現有的交換檔案,則不會有任何對話方塊,仍然會載入緩衝區。{buf} 參數的使用方式與 bufexists() 相同。
參數
{buf} (any)
bufloaded({buf}) bufloaded()
結果為 Number,如果存在名為 {buf} 的緩衝區,且該緩衝區已載入(顯示在視窗中或隱藏),則為 TRUE{buf} 參數的使用方式與 bufexists() 相同。
參數
{buf} (any)
回傳
(0|1)
bufname([{buf}]) bufname()
結果為緩衝區的名稱。主要與 :ls 命令顯示的相同,但不使用特殊名稱,例如 "[No Name]"。如果省略 {buf},則使用目前緩衝區。如果 {buf} 為 Number,則會給定該緩衝區編號的名稱。數字零為目前視窗的替代緩衝區。如果 {buf} 為 String,則會將其用作 file-pattern 來與緩衝區名稱匹配。這始終像設定了 'magic''cpoptions' 為空一樣進行。當有多個匹配項時,會回傳空字串。"" 或 "%" 可用於目前緩衝區,"#" 可用於替代緩衝區。優先使用完全匹配,否則接受在緩衝區名稱的開頭、結尾或中間的匹配。如果您只想要完全匹配,請將 "^" 放在模式的開頭,將 "$" 放在模式的結尾。首先找到已列出的緩衝區。如果已列出的緩衝區有單一匹配項,則會回傳該項。接下來會搜尋未列出的緩衝區。如果 {buf} 為 String,但您想將其用作緩衝區編號,請將其強制轉換為 Number,方法是將零加到該項
echo bufname("3" + 0)
如果緩衝區不存在,或沒有名稱,則會回傳空字串。
echo bufname("#")        " alternate buffer name
echo bufname(3)                " name of buffer 3
echo bufname("%")        " name of current buffer
echo bufname("file2")        " name of buffer where "file2" matches.
參數
{buf} (integer|string?)
回傳
(string)
bufnr([{buf} [, {create}]]) bufnr()
此函數的結果是緩衝區的編號,如同 :ls 命令所顯示的。關於 {buf} 的使用,請參閱上方的 bufname()。如果緩衝區不存在,則會回傳 -1。或者,如果存在 {create} 參數且為 TRUE,則會建立一個新的、未列出的緩衝區,並回傳其編號。bufnr("$") 是最後一個緩衝區。
let last_buffer = bufnr("$")
結果是一個數字,它是現有緩衝區中最高的緩衝區編號。請注意,並非所有編號較小的緩衝區都一定存在,因為 ":bwipeout" 可能已將它們移除。請使用 bufexists() 來測試緩衝區是否存在。
參數
{buf} (integer|string?)
{create} (any?)
回傳
(整數)
bufwinid({buf}) bufwinid()
結果是一個數字,它是與緩衝區 {buf} 關聯的第一個視窗的 視窗 ID。關於 {buf} 的使用,請參閱上方的 bufname()。如果緩衝區 {buf} 不存在或沒有這樣的視窗,則會回傳 -1。範例
echo "A window containing buffer 1 is " .. (bufwinid(1))
僅處理目前的標籤頁。請參閱 win_findbuf() 以尋找更多。
參數
{buf} (any)
回傳
(整數)
bufwinnr({buf}) bufwinnr()
類似 bufwinid(),但回傳視窗編號而不是 視窗 ID。如果緩衝區 {buf} 不存在或沒有這樣的視窗,則會回傳 -1。範例
echo "A window containing buffer 1 is " .. (bufwinnr(1))
此編號可與 CTRL-W_w 和 ":wincmd w" :wincmd 搭配使用。
參數
{buf} (any)
回傳
(整數)
byte2line({byte}) byte2line()
回傳目前緩衝區中位於位元組計數 {byte} 的字元所在的行號。這包含行尾字元,取決於目前緩衝區的 'fileformat' 選項。第一個字元的位元組計數為一。另請參閱 line2byte()go:goto
如果 {byte} 值無效,則回傳 -1。
參數
{byte} (any)
回傳
(整數)
byteidx({expr}, {nr} [, {utf16}]) byteidx()
回傳字串 {expr} 中第 {nr} 個字元的位元組索引。第一個字元使用零,則會回傳零。如果沒有多位元組字元,則回傳值等於 {nr}。組合字元不會單獨計算,它們的位元組長度會加到前面的基本字元中。請參閱下方的 byteidxcomp() 以單獨計算組合字元。當 {utf16} 存在且為 TRUE 時,{nr} 會用作字串 {expr} 中的 UTF-16 索引,而不是字元索引。UTF-16 索引是當字串以 16 位元字組編碼時的索引。如果指定的 UTF-16 索引位於字元的中間 (例如在 4 位元組字元中),則會回傳該字元中第一個位元組的位元組索引。有關更多資訊,請參閱 字串偏移編碼。範例
echo matchstr(str, ".", byteidx(str, 3))
將會顯示第四個字元。另一種方法執行相同的操作
let s = strpart(str, byteidx(str, 3))
echo strpart(s, 0, byteidx(s, 1))
另請參閱 strgetchar()strcharpart()
如果字元少於 {nr} 個,則回傳 -1。如果恰好有 {nr} 個字元,則會回傳字串的位元組長度。請參閱 charidx()utf16idx() 以分別從位元組索引取得字元和 UTF-16 索引。範例
echo byteidx('a😊😊', 2)        " returns 5
echo byteidx('a😊😊', 2, 1)        " returns 1
echo byteidx('a😊😊', 3, 1)        " returns 5
參數
{expr} (任意)
{nr} (integer)
{utf16} (any?)
回傳
(整數)
byteidxcomp({expr}, {nr} [, {utf16}]) byteidxcomp()
類似 byteidx(),但組合字元會被視為單獨的字元計算。範例
let s = 'e' .. nr2char(0x301)
echo byteidx(s, 1)
echo byteidxcomp(s, 1)
echo byteidxcomp(s, 2)
第一個和第三個 echo 的結果為 3 (「e」加上組合字元為 3 個位元組),第二個 echo 的結果為 1 (「e」為一個位元組)。
參數
{expr} (任意)
{nr} (integer)
{utf16} (any?)
回傳
(整數)
call({func}, {arglist} [, {dict}]) call() E699 使用 列表 {arglist} 中的項目作為引數呼叫函數 {func}{func} 可以是 函式參考 或函數的名稱。a:firstline 和 a:lastline 會設定為游標所在的行。回傳所呼叫函數的回傳值。{dict} 用於具有 "dict" 屬性的函數。它會用來設定區域變數 "self"。 字典函數
參數
{func} (any)
{arglist} (any)
{dict} (any?)
回傳
(any)
ceil({expr}) ceil()
回傳大於或等於 {expr} 的最小整數值,類型為 浮點數 (向上捨入)。{expr} 必須計算為 浮點數數字。範例
echo ceil(1.456)
2.0
echo ceil(-5.456)
-5.0
echo ceil(4.0)
4.0
如果 {expr} 不是 浮點數數字,則回傳 0.0。
參數
{expr} (數字)
回傳
(數字)
chanclose({id} [, {stream}]) chanclose()
關閉通道或與其關聯的特定串流。對於作業,{stream} 可以是 "stdin"、"stdout"、"stderr" 或 "rpc" 其中之一 (關閉以 "rpc":v:true 啟動的作業的 stdin/stdout)。如果省略 {stream},則會關閉所有串流。如果通道是 pty,則這將關閉 pty 主端,並向作業程序傳送 SIGHUP。對於 socket,只有一個串流,應該省略 {stream}
參數
{id} (integer)
{stream} (string?)
回傳
(0|1)
changenr() changenr()
回傳最近變更的編號。此編號與 :undolist 顯示的編號相同,並且可以與 :undo 命令搭配使用。進行變更時,它是該變更的編號。在重做之後,它是重做變更的編號。在復原之後,它比復原變更的編號小一。如果復原清單為空,則回傳 0。
回傳
(整數)
chansend({id}, {data}) chansend()
將資料傳送至通道 {id}。對於作業,它會將資料寫入程序的 stdin。對於 stdio 通道 channel-stdio,它會寫入 Nvim 的 stdout。如果寫入成功,則回傳寫入的位元組數,否則回傳 0。有關更多資訊,請參閱 通道位元組
{data} 可以是字串、可轉換為字串的物件、Blob 或列表。如果 {data} 是列表,則項目將以換行符號連接;項目中的任何換行符號都將以 NUL 傳送。若要傳送最後一個換行符號,請包含一個最後的空字串。範例
call chansend(id, ["abc", "123\n456", ""])
將傳送 "abc<NL>123<NUL>456<NL>"。
chansend() 寫入原始資料,而非 RPC 訊息。如果通道是使用 "rpc":v:true 建立的,則通道會預期 RPC 訊息,請改用 rpcnotify()rpcrequest()
參數
{id} (number)
{data} (string|string[])
回傳
(0|1)
char2nr({string} [, {utf8}]) char2nr()
回傳 {string} 中第一個字元的數字值。範例
echo char2nr(" ")        " returns 32
echo char2nr("ABC")        " returns 65
echo char2nr("á")        " returns 225
echo char2nr("á"[0])        " returns 195
echo char2nr("\<M-x>")        " returns 128
非 ASCII 字元始終被視為 UTF-8 字元。{utf8} 會被忽略,它僅為了向後相容而存在。組合字元是單獨的字元。nr2char() 執行相反的操作。
如果 {string} 不是 字串,則回傳 0。
參數
{string} (string)
{utf8} (any?)
回傳
(0|1)
charclass({string}) charclass()
回傳 {string} 中第一個字元的字元類別。字元類別為以下其中之一:0 空白 1 標點符號 2 單字字元 (取決於 'iskeyword') 3 表情符號 其他特定的 Unicode 類別。類別用於模式和單字移動中。如果 {string} 不是 字串,則回傳 0。
參數
{string} (string)
回傳
(0|1|2|3|'other')
charcol({expr} [, {winid}]) charcol()
col() 相同,但會回傳以 {expr} 給定的欄位位置的字元索引,而不是位元組位置。
範例:如果游標位於第 5 行文字「여보세요」中的「세」上
echo charcol('.')        " returns 3
echo col('.')                " returns 7
參數
{expr} (string|integer[])
{winid} (整數?)
回傳
(整數)
charidx({string}, {idx} [, {countcc} [, {utf16}]]) charidx()
回傳 {string} 中位於 {idx} 的位元組的字元索引。第一個字元的索引為零。如果沒有多位元組字元,則回傳值等於 {idx}
當省略 {countcc} 或為 FALSE 時,組合字元不會單獨計算,它們的位元組長度會加到前面的基本字元中。當 {countcc}TRUE 時,組合字元會被視為單獨的字元計算。
{utf16} 存在且為 TRUE 時,{idx} 會用作字串 {expr} 中的 UTF-16 索引,而不是位元組索引。
如果引數無效或少於 {idx} 個位元組,則回傳 -1。如果恰好有 {idx} 個位元組,則會回傳字串的字元長度。
如果第一個引數不是字串,第二個引數不是數字,或當存在第三個引數且不是零或一時,則會產生錯誤並回傳 -1。
請參閱 byteidx()byteidxcomp() 以從字元索引取得位元組索引,以及 utf16idx() 以從字元索引取得 UTF-16 索引。有關更多資訊,請參閱 字串偏移編碼。範例
echo charidx('áb́ć', 3)                " returns 1
echo charidx('áb́ć', 6, 1)        " returns 4
echo charidx('áb́ć', 16)                " returns -1
echo charidx('a😊😊', 4, 0, 1)        " returns 2
參數
{string} (string)
{idx} (integer)
{countcc} (boolean?)
{utf16} (boolean?)
回傳
(整數)
chdir({dir}) chdir()
將目前的工作目錄變更為 {dir}。目錄變更的範圍取決於目前視窗的目錄
如果目前視窗具有視窗本機目錄 (:lcd),則會變更視窗本機目錄。
否則,如果目前的標籤頁具有本機目錄 (:tcd),則會變更標籤頁本機目錄。
否則,會變更全域目錄。{dir} 必須是字串。如果成功,則會回傳先前的運作目錄。將此傳遞至另一個 chdir() 以還原目錄。如果失敗,則會回傳空字串。
範例
let save_dir = chdir(newdir)
if save_dir != ""
   " ... do some work
   call chdir(save_dir)
endif
參數
{dir} (string)
回傳
(string)
cindent({lnum}) cindent()
根據 C 縮排規則,取得第 {lnum} 行的縮排量,如同 'cindent'。縮排以空格計算,'tabstop' 的值相關。{lnum} 的使用方式與 getline() 中相同。當 {lnum} 無效時,會回傳 -1。請參閱 C 縮排
參數
{lnum} (整數)
回傳
(整數)
clearmatches([{win}]) clearmatches()
清除先前為目前視窗定義的所有比對,這些比對由 matchadd():match 命令所建立。若指定了 {win},則會使用具有此數字或視窗 ID 的視窗,而非目前視窗。
參數
{win} (integer?)
col({expr} [, {winid}]) col()
結果是一個數字,它是以 {expr} 給定的欄位位置的位元組索引。如需接受的位置,請參閱 getpos()。當 {expr} 為 "$" 時,表示游標行的末尾,因此結果是游標行中的位元組數加一。此外,{expr} 可以是 [lnum, col]:一個具有行號和欄號的 List。當欄號為 "$" 時,這在取得特定行的最後一欄時最有用。當 "lnum" 或 "col" 超出範圍時,col() 會傳回零。
使用可選的 {winid} 參數,會取得該視窗的值,而不是目前視窗的值。
若要取得行號,請使用 line()。若要同時取得兩者,請使用 getpos()
若要取得螢幕欄位位置,請使用 virtcol()。若要取得字元位置,請使用 charcol()
請注意,只能使用目前檔案中的標記。
範例
echo col(".")                        " column of cursor
echo col("$")                        " length of cursor line plus one
echo col("'t")                        " column of mark t
echo col("'" .. markname)        " column of mark markname
第一欄是 1。如果 {expr} 無效或找不到 ID 為 {winid} 的視窗,則會傳回 0。對於大寫標記,該欄實際上可能在另一個緩衝區中。對於游標位置,當 'virtualedit' 處於啟用狀態時,如果游標位於行尾之後,則欄位會高一位。此外,當使用 <Cmd> 對應時,游標不會移動,這可以用來取得插入模式中的欄位。
imap <F2> <Cmd>echo col(".").."\n"<CR>
參數
{expr} (string|integer[])
{winid} (整數?)
回傳
(整數)
complete({startcol}, {matches}) complete() E785 設定插入模式完成的匹配項。只能在插入模式中使用。您需要使用帶有 CTRL-R = 的對應 (請參閱 i_CTRL-R)。它在 CTRL-O 之後或使用表達式對應時不起作用。{startcol} 是完成文字開始所在的行中的位元組偏移量。游標之前的文字是要被匹配項取代的原始文字。使用 col('.') 表示空字串。"col('.') - 1" 將會用匹配項取代一個字元。{matches} 必須是一個 List。每個 List 項目都是一個匹配項。如需可能的項目種類,請參閱 complete-items'completeopt' 中的 "longest" 會被忽略。請注意,在呼叫此函式後,您需要避免插入任何會導致完成停止的內容。可以使用 CTRL-NCTRL-P 選擇匹配項,與插入模式完成的通常情況相同。如果已指定,則會顯示快顯功能表,請參閱 ins-completion-menu。範例
inoremap <F5> <C-R>=ListMonths()<CR>
func ListMonths()
  call complete(col('.'), ['January', 'February', 'March',
    \ 'April', 'May', 'June', 'July', 'August', 'September',
    \ 'October', 'November', 'December'])
  return ''
endfunc
這不是很有用,但它展示了它的運作方式。請注意,會傳回空字串,以避免插入零。
參數
{startcol} (integer)
{matches} (any[])
complete_add({expr}) complete_add()
{expr} 新增至匹配項清單。只能由使用 'completefunc' 選項指定的函式使用。如果失敗(空字串或記憶體不足),則傳回 0,如果新增了匹配項,則傳回 1,如果匹配項已在清單中,則傳回 2。如需 {expr} 的說明,請參閱 complete-functions。它與 'omnifunc' 會傳回的清單中的一個項目相同。
參數
{expr} (任意)
回傳
(0|1|2)
complete_check() complete_check()
檢查在尋找完成匹配項時是否已輸入按鍵。這是為了在尋找匹配項需要一些時間時使用。當要中止搜尋匹配項時,傳回 TRUE,否則傳回零。只能由使用 'completefunc' 選項指定的函式使用。
回傳
(0|1)
complete_info([{what}]) complete_info()
傳回一個具有插入模式完成相關資訊的 Dictionary。請參閱 ins-completion。項目如下:mode 目前完成模式名稱字串。如需數值,請參閱 complete_info_mode。pum_visible 如果快顯功能表可見,則為 TRUE。請參閱 pumvisible()。items 完成匹配項清單。每個項目都是一個字典,包含 "word"、"abbr"、"menu"、"kind"、"info" 和 "user_data" 條目。請參閱 complete-items。selected 選取的項目索引。第一個索引為零。如果沒有選取任何項目,則索引為 -1(僅顯示輸入的文字,或在使用 <Up><Down> 按鍵且未選取任何項目後的最後一個完成項目)inserted 已插入的字串。[尚未實作] preview_winid 資訊浮動預覽視窗 ID。preview_bufnr 資訊浮動預覽緩衝區 ID。
complete_info_mode
mode 值為:"" 不在完成模式中 "keyword" 關鍵字完成 i_CTRL-X_CTRL-N "ctrl_x" 剛按下 CTRL-X i_CTRL-X "scroll" 使用 i_CTRL-X_CTRL-Ei_CTRL-X_CTRL-Y 滾動 "whole_line" 整行 i_CTRL-X_CTRL-L "files" 檔案名稱 i_CTRL-X_CTRL-F "tags" 標籤 i_CTRL-X_CTRL-] "path_defines" 定義完成 i_CTRL-X_CTRL-D "path_patterns" 包含完成 i_CTRL-X_CTRL-I "dictionary" 字典 i_CTRL-X_CTRL-K "thesaurus" 同義詞庫 i_CTRL-X_CTRL-T "cmdline" Vim 命令列 i_CTRL-X_CTRL-V "function" 使用者定義的完成 i_CTRL-X_CTRL-U "omni" Omni 完成 i_CTRL-X_CTRL-O "spell" 拼字建議 i_CTRL-X_s "eval" complete() 完成 "unknown" 其他內部模式
如果提供了可選的 {what} 清單參數,則只會傳回 {what} 中列出的項目。{what} 中不支援的項目會被靜默忽略。
若要取得快顯功能表的位置和大小,請參閱 pum_getpos()。在 CompleteChanged 事件期間,也可在 v:event 中使用。
如果發生錯誤,則會傳回空的 Dictionary
範例
" Get all items
call complete_info()
" Get only 'mode'
call complete_info(['mode'])
" Get only 'mode' and 'pum_visible'
call complete_info(['mode', 'pum_visible'])
參數
{what} (any[]?)
回傳
(表格)
confirm({msg} [, {choices} [, {default} [, {type}]]]) confirm()
confirm() 會向使用者提供一個對話方塊,使用者可以從中做出選擇。它會傳回選擇的數字。對於第一個選擇,此數字為 1。
{msg} 會在一個對話方塊中顯示,並以 {choices} 作為替代選項。當 {choices} 遺失或為空時,會使用 "&OK" (且會翻譯)。{msg} 是一個字串,請使用 '\n' 加入換行符號。只有在某些系統上,當字串不符合時,才會換行。
{choices} 是一個字串,其中個別選項以 '\n' 分隔,例如:
confirm("Save changes?", "&Yes\n&No\n&Cancel")
「&」之後的字母是該選項的快速鍵。因此,您可以輸入 'c' 來選取「取消」。快速鍵不必是第一個字母
confirm("file has been modified", "&Save\nSave &All")
對於主控台,每個選項的第一個字母會用作預設快速鍵。會忽略大小寫。
可選的 {type} 字串參數會提供對話方塊的類型。它可以是下列值之一:"Error"、"Question"、"Info"、"Warning" 或 "Generic"。只有第一個字元是相關的。如果省略了 {type},則會使用 "Generic"。
可選的 {type} 參數會提供對話方塊的類型。這僅用於 Win32 GUI 的圖示。它可以是下列值之一:"Error"、"Question"、"Info"、"Warning" 或 "Generic"。只有第一個字元是相關的。如果省略了 {type},則會使用 "Generic"。
如果使用者按下 <Esc>CTRL-C 或另一個有效的中斷按鍵來中止對話方塊,則 confirm() 會傳回 0。
範例
let choice = confirm("What do you want?",
                     \ "&Apples\n&Oranges\n&Bananas", 2)
if choice == 0
     echo "make up your mind!"
elseif choice == 3
     echo "tasteful"
else
     echo "I prefer bananas myself."
endif
在 GUI 對話方塊中,會使用按鈕。按鈕的配置取決於 'guioptions' 中的 'v' 旗標。如果包含此旗標,則按鈕會始終垂直放置。否則,confirm() 會嘗試將按鈕放在一條水平線上。如果它們不符合,則無論如何都會使用垂直配置。對於某些系統,會始終使用水平配置。
參數
{msg} (string)
{choices} (string?)
{default} (integer?)
{type} (string?)
回傳
(整數)
copy({expr}) copy()
建立 {expr} 的複本。對於數字和字串,這與直接使用 {expr} 沒有區別。當 {expr}List 時,會建立淺層複本。這表示可以在不變更複本的情況下變更原始的 List,反之亦然。但是這些項目是相同的,因此變更項目會變更兩個 Lists 的內容。會以與 List 類似的方式複製 Dictionary。另請參閱 deepcopy()
參數
{expr} (任意)
回傳
(any)
cos({expr}) cos()
Float 傳回以弧度測量的 {expr} 的餘弦。{expr} 必須評估為 FloatNumber。如果 {expr} 不是 FloatNumber,則傳回 0.0。範例
echo cos(100)
0.862319
echo cos(-4.01)
-0.646043
參數
{expr} (數字)
回傳
(數字)
cosh({expr}) cosh()
Float 傳回 {expr} 的雙曲餘弦,範圍為 [1, inf]。{expr} 必須評估為 FloatNumber。如果 {expr} 不是 FloatNumber,則傳回 0.0。範例
echo cosh(0.5)
1.127626
echo cosh(-0.5)
-1.127626
參數
{expr} (數字)
回傳
(數字)
count({comp}, {expr} [, {ic} [, {start}]]) count() E706 傳回值為 {expr} 的項目在 字串列表字典 {comp} 中出現的次數。
如果給定 {start},則從具有此索引的項目開始計算。{start} 只能與 列表 一起使用。
當給定 {ic} 且為 TRUE 時,會忽略大小寫。
{comp} 是字串時,會傳回 {expr} 不重疊出現的次數。當 {expr} 是空字串時,傳回零。
參數
{comp} (字串|表格|any[])
{expr} (任意)
{ic} (布林值?)
{start} (整數?)
回傳
(整數)
ctxget([{index}]) ctxget()
傳回一個 字典,表示 contextcontext-stack 頂部的 {index} 位置 (參見 context-dict)。如果未給定 {index},則假設為 0 (即:頂部)。
參數
{index} (整數?)
回傳
(表格)
ctxpop() ctxpop()
彈出並恢復 context-stack 頂部的 context
回傳
(any)
ctxpush([{types}]) ctxpush()
將目前編輯器狀態 (context) 推送到 context-stack 上。如果給定 {types} 且為 字串列表,則指定要包含在推送的 context 中的 context-types。否則,會包含所有 context types。
參數
{types} (字串[]?)
回傳
(any)
ctxset({context} [, {index}]) ctxset()
context-stack 頂部 {index} 位置的 context 設定為 {context} 所代表的 context。{context} 是一個包含 context 資料的字典 (context-dict)。如果未給定 {index},則假設為 0 (即:頂部)。
參數
{context} (表格)
{index} (整數?)
回傳
(any)
ctxsize() ctxsize()
傳回 context-stack 的大小。
回傳
(any)
cursor({lnum}, {col} [, {off}]) cursor()
cursor({list}) 將游標定位在行 {lnum} 中位元組計數為 {col} 的位置。第一欄為 1。
當有一個參數 {list} 時,會將其用作包含兩個、三個或四個項目的 列表:[{lnum}, {col}] [{lnum}, {col}, {off}] [{lnum}, {col}, {off}, {curswant}] 這就像 getpos()getcurpos() 的傳回值,但不包含第一個項目。
若要使用 {col} 作為字元計數來定位游標,請使用 setcursorcharpos()
不會變更跳轉列表。{lnum} 的使用方式與 getline() 相同,但如果 {lnum} 為零,游標將停留在目前行。如果 {lnum} 大於緩衝區中的行數,游標將會定位在緩衝區中的最後一行。如果 {col} 大於該行中的位元組數,游標將會定位在該行中的最後一個字元。如果 {col} 為零,游標將會停留在目前欄。如果給定 {curswant},則會用它來設定垂直移動時的首選欄。否則會使用 {col}
當使用 'virtualedit' 時,{off} 指定從字元開頭開始的螢幕欄偏移量。例如,<Tab> 內或最後一個字元後面的位置。如果可以設定位置,則傳回 0,否則傳回 -1。
參數
{list} (整數[])
回傳
(any)
debugbreak({pid}) debugbreak()
專門用於中斷正在除錯的程式。它會導致程序 {pid} 收到 SIGTRAP。其他程序的行為未定義。參見 terminal-debug。(傳送 SIGINT 到非 MS-Windows 的程序 {pid})
如果成功中斷程式,則傳回 TRUE。否則傳回 FALSE
參數
{pid} (整數)
回傳
(any)
deepcopy({expr} [, {noref}]) deepcopy() E698 建立 {expr} 的複本。對於數字和字串,這與直接使用 {expr} 沒有區別。當 {expr}列表 時,會建立完整複本。這表示可以變更原始 列表,而不會變更複本,反之亦然。當項目是 列表 時,會以遞迴方式建立其複本。因此,變更複本中的項目不會變更原始 列表 的內容。
當省略 {noref} 或為零時,只會複製一次包含的 列表字典。所有參考都會指向此單一複本。如果將 {noref} 設定為 1,則每次出現 列表字典 都會產生一個新的複本。這也表示循環參考會導致 deepcopy() 失敗。E724
巢狀結構最多可達 100 層。當有項目參考回較高層級時,如果將 {noref} 設定為 1,則進行深度複製將會失敗。另請參見 copy()
參數
{expr} (任意)
{noref} (布林值?)
回傳
(any)
delete({fname} [, {flags}]) delete()
沒有 {flags}{flags} 為空時:刪除名稱為 {fname} 的檔案。
{fname} 是符號連結時,這也適用。會刪除符號連結本身,而不是它指向的內容。
{flags} 是 "d" 時:刪除名稱為 {fname} 的目錄。如果目錄 {fname} 不為空,則此操作會失敗。
{flags} 是 "rf" 時:遞迴刪除名稱為 {fname} 的目錄及其中的所有內容。小心! 注意:在 MS-Windows 上,無法刪除正在使用的目錄。
結果是一個數字,如果刪除操作成功,則為 0/false,如果刪除失敗或部分失敗,則為 -1/true。
參數
{fname} (字串)
{flags} (字串?)
回傳
(整數)
deletebufline({buf}, {first} [, {last}]) deletebufline()
從緩衝區 {buf} 刪除從 {first}{last} (包含) 的行。如果省略 {last},則僅刪除行 {first}。成功時傳回 0,失敗時傳回 1。
此函式僅適用於已載入的緩衝區。如果需要,請先呼叫 bufload()
如需 {buf} 的使用,請參見上方的 bufname()
{first}{last} 的使用方式與 getline() 相同。請注意,當使用 line() 時,這會參考目前的緩衝區。使用 "$" 來參考緩衝區 {buf} 中的最後一行。
參數
{buf} (整數|字串)
{first} (整數|字串)
{last} (整數|字串?)
回傳
(any)
dictwatcheradd({dict}, {pattern}, {callback}) dictwatcheradd()
將監看器新增到字典。字典監看器由三個元件識別
一個字典 ({dict});
一個金鑰模式 ({pattern})。
一個函式 ({callback})。
呼叫此函式後,對 {dict} 以及與 {pattern} 匹配的金鑰所做的任何變更都會導致叫用 {callback}
例如,若要監看所有全域變數
silent! call dictwatcherdel(g:, '*', 'OnDictChanged')
function! OnDictChanged(d,k,z)
  echomsg string(a:k) string(a:z)
endfunction
call dictwatcheradd(g:, '*', 'OnDictChanged')
目前 {pattern} 只接受非常簡單的模式,該模式可以在字串結尾包含 "*",在這種情況下,它會比對每個以 "*" 之前的子字串開頭的金鑰。這表示如果 "*" 不是 {pattern} 的最後一個字元,則只會比對與 {pattern} 完全相同的金鑰。
{callback} 接收三個引數
正在監看的字典。
已變更的金鑰。
包含金鑰新舊值的字典。
可以透過檢查第三個引數中存在的金鑰來判斷變更類型
如果同時包含 oldnew,則表示已更新金鑰。
如果只包含 new,則表示已新增金鑰。
如果只包含 old,則表示已刪除金鑰。
外掛程式可以使用此函式來實作具有驗證和剖析邏輯的選項。
參數
{dict} (表格)
{pattern} (string)
{callback} (函式)
回傳
(any)
dictwatcherdel({dict}, {pattern}, {callback}) dictwatcherdel()
移除使用 dictwatcheradd() 新增的監看器。所有三個引數都必須與傳遞至 dictwatcheradd() 的引數匹配,監看器才能成功刪除。
參數
{dict} (any)
{pattern} (string)
{callback} (函式)
回傳
(any)
did_filetype() did_filetype()
當正在執行自動指令且 FileType 事件已觸發至少一次時,傳回 TRUE。可用於避免在偵測檔案類型的指令碼中再次觸發 FileType 事件。FileType 如果使用了 :setf FALLBACK,則傳回 FALSE。編輯另一個檔案時,計數器會重設,因此這實際上會檢查目前緩衝區是否已觸發 FileType 事件。這允許開始編輯另一個緩衝區的自動指令設定 'filetype' 並載入語法檔案。
回傳
(any)
diff_filler({lnum}) diff_filler()
傳回行 {lnum} 上方的填補行數。這些是在另一個差異視窗中於此點插入的行。這些填補行會顯示在顯示器中,但不存在於緩衝區中。{lnum} 的使用方式與 getline() 相同。因此,"." 是目前行,"'m" 是標記 m 等。如果目前的視窗不在差異模式中,則傳回 0。
參數
{lnum} (整數)
回傳
(any)
diff_hlID({lnum}, {col}) diff_hlID()
傳回差異模式中位於行 {lnum}、欄 {col} (位元組索引) 的醒目提示 ID。如果目前行沒有差異變更,則傳回零。{lnum} 的使用方式與 getline() 相同。因此,"." 是目前行,"'m" 是標記 m 等。{col} 對於最左欄為 1,{lnum} 對於第一行為 1。醒目提示 ID 可與 synIDattr() 搭配使用,以取得有關醒目提示的語法資訊。
參數
{lnum} (整數)
{col} (整數)
回傳
(any)
digraph_get({chars}) digraph_get() E1214 返回 {chars} 的雙字母組合。這應該是一個正好包含兩個字元的字串。如果 {chars} 不僅僅是兩個字元,或者 {chars} 的雙字母組合不存在,則會產生錯誤並返回一個空字串。
另請參閱 digraph_getlist()
範例
" Get a built-in digraph
echo digraph_get('00')                " Returns '∞'
" Get a user-defined digraph
call digraph_set('aa', 'あ')
echo digraph_get('aa')                " Returns 'あ'
參數
{chars} (string)
回傳
(any)
digraph_getlist([{listall}]) digraph_getlist()
返回雙字母組合的列表。如果給定 {listall} 參數且為 TRUE,則返回所有雙字母組合,包括預設的雙字母組合。否則,僅返回使用者定義的雙字母組合。
另請參閱 digraph_get()
範例
" Get user-defined digraphs
echo digraph_getlist()
" Get all the digraphs, including default digraphs
echo digraph_getlist(1)
參數
{listall} (boolean?)
回傳
(any)
digraph_set({chars}, {digraph}) digraph_set()
將雙字母組合 {chars} 加入列表。{chars} 必須是包含兩個字元的字串。{digraph} 是一個包含一個 UTF-8 編碼字元的字串。 E1215 請注意,組合字元不會被忽略。此函數與 :digraphs 命令相似,但可用於加入以空白字元開頭的雙字母組合。
如果 digraph 已註冊,則函數結果為 v:true。如果失敗,將顯示錯誤訊息並返回 v:false。
如果您想一次定義多個雙字母組合,可以使用 digraph_setlist()
範例
call digraph_set('  ', 'あ')
參數
{chars} (string)
{digraph} (string)
回傳
(any)
digraph_setlist({digraphlist}) digraph_setlist()
digraph_set() 類似,但此函數可以一次加入多個雙字母組合。{digraphlist} 是一個由列表組成的列表,其中每個列表包含兩個字串,分別為 {chars}{digraph},如 digraph_set() 中所示。 E1216 範例
call digraph_setlist([['aa', 'あ'], ['ii', 'い']])
它類似於以下內容
for [chars, digraph] in [['aa', 'あ'], ['ii', 'い']]
      call digraph_set(chars, digraph)
endfor
除了該函數會在第一個錯誤後返回,後續的雙字母組合將不會被加入。
參數
{digraphlist} (table<integer,string[]>)
回傳
(any)
empty({expr}) empty()
如果 {expr} 為空,則返回數值 1,否則返回零。
ListDictionary 沒有任何項目時,即為空。
String 的長度為零時,即為空。
NumberFloat 的值為零時,即為空。
v:falsev:null 為空,v:true 不為空。
Blob 的長度為零時,即為空。
參數
{expr} (任意)
回傳
(any)
environ() environ()
以字典形式返回所有環境變數。您可以像這樣檢查環境變數是否存在
echo has_key(environ(), 'HOME')
請注意,變數名稱可能是駝峰式命名;要忽略大小寫,請使用此方法
echo index(keys(environ()), 'HOME', 0, 1) != -1
回傳
(any)
escape({string}, {chars}) escape()
使用反斜線跳脫 {string} 中出現的 {chars} 字元。範例
echo escape('c:\program files\vim', ' \')
結果為
c:\\program\ files\\vim
另請參閱 shellescape()fnameescape()
參數
{string} (string)
{chars} (string)
回傳
(any)
eval({string}) eval()
評估 {string} 並返回結果。特別適用於將 string() 的結果轉回原始值。這適用於數值、浮點數、字串、Blob 和它們的組合。也適用於指向現有函數的 Funcref
參數
{string} (string)
回傳
(any)
eventhandler() eventhandler()
當在事件處理程式內時返回 1。也就是說,當 Vim 在等待使用者輸入字元時被中斷時,例如,將檔案拖放到 Vim 上。這表示無法使用互動式命令。否則返回零。
回傳
(any)
executable({expr}) executable()
此函數檢查是否存在名稱為 {expr} 的可執行檔。{expr} 必須是不帶任何引數的程式名稱。
executable() 使用 $PATH 的值和/或程式的正常搜尋路徑。 PATHEXT
在 MS-Windows 上,可以選擇性地包含 ".exe"、".bat" 等。然後會嘗試 $PATHEXT 中的擴展名。因此,如果 "foo.exe" 不存在,則可以找到 "foo.exe.bat"。如果未設定 $PATHEXT,則會使用 ".com;.exe;.bat;.cmd"。可以在 $PATHEXT 中單獨使用點來嘗試使用不帶擴展名的名稱。當 'shell' 看起來像 Unix shell 時,也會嘗試不加擴展名的名稱。在 MS-Windows 上,它僅檢查檔案是否存在且不是目錄,而不是是否真的可執行。在 MS-Windows 上,始終會找到與 Vim 可執行檔位於同一目錄中的可執行檔(它在 啟動時會新增到 $PATH)。 NoDefaultCurrentDirectoryInExePath
在 MS-Windows 上,通常也會找到 Vim 目前工作目錄中的可執行檔,但可以透過設定 $NoDefaultCurrentDirectoryInExePath 環境變數來停用此功能。
結果是一個數值:1 表示存在,0 表示不存在。可以使用 exepath() 取得可執行檔的完整路徑。
參數
{expr} (string)
回傳
(0|1)
execute({command} [, {silent}]) execute()
執行 {command} 並捕獲其輸出。如果 {command}String,則返回 {command} 的輸出。如果 {command}List,則返回串連的輸出。{command} 中的換行符號不被識別。範例
echo execute('echon "foo"')
foo
echo execute(['echon "foo"', 'echon "bar"'])
foobar
可選的 {silent} 引數可以具有以下值:"" 不使用 :silent、"silent" 使用 :silent、"silent!" 使用 :silent!。預設值為 "silent"。請注意,與 :redir 不同,使用 "silent!" 會丟棄錯誤訊息。
若要取得行列表,請在結果上使用 split()
execute('args')->split("\n")
此函數在 沙箱中不可用。請注意:如果巢狀,外部的 execute() 將不會觀察到內部呼叫的輸出。請注意:文字屬性(醒目提示)不會被捕獲。若要在目前視窗以外的視窗中執行命令,請使用 win_execute()
參數
{command} (string|string[])
{silent} (''|'silent'|'silent!'?)
回傳
(string)
exepath({expr}) exepath()
如果 {expr} 是可執行檔且以(部分或完整)路徑給定,或在 $PATH 中找到,則返回 {expr} 的完整路徑。否則返回空字串。如果 {expr} 以 "./" 開頭,則會使用目前目錄
參數
{expr} (string)
回傳
(string)
exists({expr}) exists()
結果是一個數值,如果已定義 {expr},則為 TRUE,否則為零。
若要檢查是否支援的功能,請使用 has()。若要檢查檔案是否存在,請使用 filereadable()
{expr} 引數是一個字串,其中包含以下其中之一:varname 內部變數(請參閱 dict.key internal-variables)。也適用於 curly-braces-names 的 list[i]、Dictionary 條目、List 項目等。請注意,評估索引可能會導致無效運算式的錯誤訊息。例如:
let l = [1, 2, 3]
echo exists("l[5]")
0
echo exists("l[xx]")
E121:未定義變數:xx 0 &option-name Vim 選項(僅檢查是否存在,而不是是否真的有效)+option-name 有效的 Vim 選項。$ENVNAME 環境變數(也可以透過與空字串比較來完成)*funcname 內建函數(請參閱 functions)或使用者定義函數(請參閱 user-function)。也適用於作為 Funcref 的變數。:cmdname Ex 命令:內建命令、使用者命令或命令修飾符 :command。返回:1 表示與命令的開頭匹配、2 表示與命令的完整匹配、3 表示與多個使用者命令匹配。若要檢查是否支援某個命令,請務必檢查傳回值是否為 2。:2match :2match 命令。:3match :3match 命令(但您可能不應該使用它,它保留供內部使用)#event 為此事件定義的自動命令 #event#pattern 為此事件和模式定義的自動命令(模式按字元逐字擷取並與自動命令模式進行比較)#group 自動命令群組存在 #group#event 為此群組和事件定義的自動命令。#group#event#pattern 為此群組、事件和模式定義的自動命令。##event 支援此事件的自動命令。
範例
echo exists("&mouse")
echo exists("$HOSTNAME")
echo exists("*strftime")
echo exists("*s:MyFunc")
echo exists("*MyFunc")
echo exists("*v:lua.Func")
echo exists("bufcount")
echo exists(":Make")
echo exists("#CursorHold")
echo exists("#BufReadPre#*.gz")
echo exists("#filetypeindent")
echo exists("#filetypeindent#FileType")
echo exists("#filetypeindent#FileType#*")
echo exists("##ColorScheme")
符號(&/$/*/#)與名稱之間不得有空格。名稱後不得有額外字元,儘管在少數情況下會忽略此規則。將來可能會更嚴格,因此請勿指望這一點!有效範例
echo exists(":make")
無效範例
echo exists(":make install")
請注意,引數必須是字串,而不是變數本身的名稱。例如
echo exists(bufcount)
這不會檢查 "bufcount" 變數是否存在,而是取得 "bufcount" 的值,並檢查該值是否存在。
參數
{expr} (string)
回傳
(0|1)
exp({expr}) exp()
Float 格式返回 {expr} 的指數,範圍為 [0, inf]。{expr} 必須評估為 FloatNumber。如果 {expr} 不是 FloatNumber,則返回 0.0。範例
echo exp(2)
7.389056
echo exp(-1)
0.367879
參數
{expr} (數字)
回傳
(any)
expand({string} [, {nosuf} [, {list}]]) expand()
展開 {string} 中的萬用字元和以下特殊關鍵字。適用 'wildignorecase'
如果給定 {list} 且為 TRUE,則會返回 List。否則,結果為 String,當有多個匹配項時,它們會以 <NL> 字元分隔。
如果展開失敗,結果為空字串。不包含不存在的檔案名稱,除非 {string} 不是以 '%'、'#' 或 '<' 開頭,請參閱下文。
{string} 以 '%'、'#' 或 '<' 開頭時,展開會像對待具有相關修飾符的 cmdline-special 變數一樣進行。以下是簡短的概述
% 目前檔案名稱 # 備用檔案名稱 #n 備用檔案名稱 n <cfile> 滑鼠游標下的檔案名稱 <afile> 自動指令檔案名稱 <abuf> 自動指令緩衝區編號(作為字串!)<amatch> 自動指令匹配的名稱 <cexpr> 滑鼠游標下的 C 運算式 <sfile> 來源指令碼檔案或函數名稱 <slnum> 來源指令碼行號或函數行號 <sflnum> 指令碼檔案行號,即使在函數中也是如此 <SID> "<SNR>123_",其中 "123" 是目前的指令碼 ID <SID> <script> 來源指令碼檔案,或定義目前函數的指令碼檔案 <stack> 呼叫堆疊 <cword> 滑鼠游標下的單字 <cWORD> 滑鼠游標下的 WORD <client> 上次收到的訊息的 {clientid} 修飾符::p 展開為完整路徑 :h 開頭(已移除最後一個路徑元件) :t 結尾(僅限最後一個路徑元件) :r 根(已移除一個擴展名) :e 僅限擴展名
範例
let &tags = expand("%:p:h") .. "/tags"
請注意,當展開以 '%'、'#' 或 '<' 開頭的字串時,會忽略任何後續文字。這無效
let doesntwork = expand("%:h.bak")
使用此方法
let doeswork = expand("%:h") .. ".bak"
另請注意,展開 "<cfile>" 和其他項目僅返回引用的檔案名稱,而不會進一步展開。如果 "<cfile>" 是 "~/.cshrc",您需要再執行一次 expand() 才能將 "~/" 展開為首頁目錄的路徑
echo expand(expand("<cfile>"))
變數與後續修飾符之間不得有空格。可以使用 fnamemodify() 函數來修改一般檔案名稱。
當使用 '%' 或 '#',且目前或備用檔名未定義時,會使用空字串。在沒有名稱的緩衝區中使用 "%:p" 會產生目前目錄,並加上 '/'。當 'verbose' 設定時,如果參數無法展開,展開 '%'、'#' 和 <> 項目將會產生錯誤訊息。
{string} 不是以 '%'、'#' 或 '<' 開頭時,它會像在命令列中展開檔案名稱一樣展開。'suffixes''wildignore' 會被使用,除非給定了可選的 {nosuf} 參數且為 TRUE。會包含不存在檔案的名稱。"**" 項目可用於在目錄樹中搜尋。例如,要在目前目錄及以下找到所有 "README" 檔案:
echo expand("**/README")
expand() 也可用於展開僅在 shell 中已知的變數和環境變數。但這可能會很慢,因為可能會使用 shell 來進行展開。請參閱 expr-env-expand。展開的變數仍然會像檔案名稱列表一樣處理。當環境變數無法展開時,它會保持不變。因此 ":echo expand('$FOOBAR')" 會產生 "$FOOBAR"。
請參閱 glob() 以尋找現有檔案。請參閱 system() 以取得外部命令的原始輸出。
參數
{string} (string)
{nosuf} (boolean?)
{list} (nil|false?)
回傳
(string)
expandcmd({string} [, {options}]) expandcmd()
展開字串 {string} 中的特殊項目,就像對 Ex 命令(例如 :edit)所做的一樣。這會展開特殊關鍵字,就像 expand() 一樣,以及 {string} 中任何位置的環境變數。"~user" 和 "~/path" 只會在開頭展開。
{options} Dict 參數中支援以下項目: errmsg 如果設定為 TRUE,則在展開期間遇到錯誤時會顯示錯誤訊息。預設情況下,不會顯示錯誤訊息。
傳回展開後的字串。如果在展開期間遇到錯誤,則會傳回未修改的 {string}
範例
echo expandcmd('make %<.o')
make /path/runtime/doc/builtin.o
echo expandcmd('make %<.o', {'errmsg': v:true})
參數
{string} (string)
{options} (table?)
回傳
(any)
extend({expr1}, {expr2} [, {expr3}]) extend()
{expr1}{expr2} 必須都是 列表字典
如果它們是 列表:將 {expr2} 附加到 {expr1}。如果給定 {expr3},則將 {expr2} 的項目插入到 {expr1} 中索引為 {expr3} 的項目之前。當 {expr3} 為零時,插入到第一個項目之前。當 {expr3} 等於 len({expr1}) 時,則附加 {expr2}。範例
echo sort(extend(mylist, [7, 5]))
call extend(mylist, [2, 3], 1)
{expr1}{expr2} 是相同的列表時,複製的項目數等於列表的原始長度。例如,當 {expr3} 為 1 時,您會得到 N 個第一個項目的新副本(其中 N 是列表的原始長度)。使用 add() 將一個項目串連到列表。要將兩個列表串連成一個新列表,請使用 + 運算子
let newlist = [1, 2, 3] + [4, 5]
如果它們是 字典:將 {expr2} 中的所有條目新增到 {expr1}。如果 {expr1}{expr2} 中都存在鍵,則使用 {expr3} 來決定要執行什麼操作:{expr3} = "keep":保留 {expr1} 的值 {expr3} = "force":使用 {expr2} 的值 {expr3} = "error":給出錯誤訊息 E737
當省略 {expr3} 時,則假設為 "force"。
{expr2} 不為空時,{expr1} 會被變更。如有必要,請先複製 {expr1}{expr2} 保持不變。當 {expr1} 被鎖定且 {expr2} 不為空時,操作會失敗。傳回 {expr1}。發生錯誤時傳回 0。
參數
{expr1} (table)
{expr2} (table)
{expr3} (table?)
回傳
(any)
extendnew({expr1}, {expr2} [, {expr3}]) extendnew()
extend() 類似,但不是將項目新增到 {expr1},而是建立並傳回一個新的列表或字典。{expr1} 保持不變。
參數
{expr1} (table)
{expr2} (table)
{expr3} (table?)
回傳
(any)
feedkeys({string} [, {mode}]) feedkeys()
{string} 中的字元會被放入佇列中進行處理,就像它們來自對應或由使用者輸入一樣。
預設情況下,字串會新增到預輸入緩衝區的末尾,因此如果仍在執行對應,則字元會出現在它們之後。使用 'i' 標誌在其他字元之前插入,它們將在任何來自對應的字元之前,下一個被執行。
此函數不會等待 {string} 中包含的按鍵被處理。
要將特殊按鍵包含到 {string} 中,請使用雙引號和 "\..." 表示法 expr-quote。例如,feedkeys("\<CR>") 會模擬按下 <Enter> 鍵。但 feedkeys('\<CR>') 會推送 5 個字元。<Ignore> 鍵碼可用於在不執行任何操作的情況下退出等待字元的狀態。
{mode} 是一個字串,可以包含以下字元標誌: 'm' 重新對應按鍵。這是預設值。如果沒有 {mode},則按鍵會被重新對應。 'n' 不要重新對應按鍵。 't' 將按鍵視為輸入處理;否則它們會被視為來自對應。這對於復原、開啟摺疊等至關重要。 'L' 低階輸入。不使用其他標誌。 'i' 插入字串而不是附加(請參閱上文)。 'x' 執行命令,直到預輸入為空。這與使用 ":normal!" 類似。您可以多次呼叫 feedkeys() 而不使用 'x',然後使用 'x' 呼叫一次(可能使用空的 {string})來執行所有預輸入。請注意,當 Vim 在插入模式中結束時,它的行為將如同輸入了 <Esc>,以避免陷入等待在腳本繼續執行之前輸入字元的困境。請注意,如果您設法在執行命令時呼叫 feedkeys(),從而遞迴呼叫它,則所有預輸入都將被最後一次呼叫使用。 '!' 與 'x' 一起使用時,不會結束插入模式。可以在設定計時器稍後退出插入模式時在測試中使用。對測試 CursorHoldI 很有用。
傳回值始終為 0。
參數
{string} (string)
{mode} (string?)
回傳
(any)
filecopy({from}, {to}) filecopy()
將名稱為 {from} 指向的檔案複製到 {to}。結果是一個數字,如果檔案複製成功,則為 TRUE,如果失敗則為 FALSE。如果已存在名稱為 {to} 的檔案,則會失敗。請注意,它尚未處理目錄。
此函數在 沙箱中不可用。
參數
{from} (string)
{to} (string)
回傳
(0|1)
filereadable({file}) filereadable()
結果是一個數字,當存在名稱為 {file} 的檔案並且可以讀取時,該數字為 TRUE。如果 {file} 不存在,或是一個目錄,則結果為 FALSE{file} 是任何表達式,它被用作字串。如果您不關心檔案是否可讀,您可以使用 glob(){file} 會按原樣使用,您可能需要先展開萬用字元。
echo filereadable('~/.vimrc')
0
echo filereadable(expand('~/.vimrc'))
1
參數
{file} (string)
回傳
(0|1)
filewritable({file}) filewritable()
結果是一個數字,當存在名稱為 {file} 的檔案並且可以寫入時,該數字為 1。如果 {file} 不存在,或不可寫入,則結果為 0。如果 {file} 是一個目錄,並且我們可以寫入它,則結果為 2。
參數
{file} (string)
回傳
(0|1)
filter({expr1}, {expr2}) filter()
{expr1} 必須是 列表字串Blob字典。對於 {expr1} 中的每個項目,計算 {expr2},當結果為零或 false 時,從 列表字典中移除該項目。對於 Blob 中的每個位元組和 字串中的每個字元也是如此。
{expr2} 必須是 字串Funcref
如果 {expr2}字串,在 {expr2} 內,v:val 具有目前項目的值。對於 字典v:key 具有目前項目的鍵,對於 列表v:key 具有目前項目的索引。對於 Blobv:key 具有目前位元組的索引。對於 字串v:key 具有目前字元的索引。範例
call filter(mylist, 'v:val !~ "OLD"')
移除出現 "OLD" 的項目。
call filter(mydict, 'v:key >= 8')
移除鍵低於 8 的項目。
call filter(var, 0)
移除所有項目,從而清除 列表字典
請注意,{expr2} 是表達式的結果,然後再次用作表達式。通常最好使用 字面字串來避免必須使用雙反斜線。
如果 {expr2}Funcref,則它必須接受兩個參數:1. 目前項目的鍵或索引。2. 目前項目的值。如果應保留該項目,該函數必須傳回 TRUE。範例,保留列表的奇數項目
func Odd(idx, val)
  return a:idx % 2 == 1
endfunc
call filter(mylist, function('Odd'))
使用 lambda 時會更短
call filter(myList, {idx, val -> idx * val <= 42})
如果您不使用 "val",則可以省略它
call filter(myList, {idx -> idx % 2 == 1})
對於 列表字典,操作是在原地完成的。如果您希望它保持未修改狀態,請先複製一份。
let l = filter(copy(mylist), 'v:val =~ "KEEP"')
傳回 {expr1},即被篩選過的 ListDictionary,或是一個新的 BlobString。當評估 {expr2} 時遇到錯誤,{expr1} 中剩餘的項目將不會被處理。當 {expr2} 是一個 Funcref 時,函數內部的錯誤會被忽略,除非該函數定義時使用了 "abort" 標誌。
參數
{expr1} (string|table)
{expr2} (string|function)
回傳
(any)
finddir({name} [, {path} [, {count}]]) finddir()
{path} 中尋找目錄 {name}。支援向下和向上遞迴目錄搜尋。關於 {path} 的語法,請參閱 檔案搜尋
傳回第一個找到的匹配項的路徑。當找到的目錄位於當前目錄之下時,會傳回相對路徑。否則,會傳回完整路徑。如果 {path} 被省略或為空,則會使用 'path' 選項。
如果提供了可選的 {count},則會在 {path} 中尋找 {name} 的第 {count} 個匹配項,而不是第一個。當 {count} 為負數時,會以 List 的形式傳回所有匹配項。
如果未找到該目錄,則傳回空字串。
這與 ex 命令 :find 非常相似。
參數
{name} (string)
{path} (string?)
{count} (integer?)
回傳
(any)
findfile({name} [, {path} [, {count}]]) findfile()
finddir() 類似,但尋找的是檔案而不是目錄。使用 'suffixesadd' 選項。範例
echo findfile("tags.vim", ".;")
從當前檔案的目錄向上搜尋,直到找到檔案 "tags.vim"。
參數
{name} (string)
{path} (string?)
{count} (any?)
回傳
(any)
flatten({list} [, {maxdepth}]) flatten()
{list} 平坦化到 {maxdepth} 層級。如果沒有 {maxdepth},則結果是一個沒有巢狀結構的 List,就像 {maxdepth} 是一個非常大的數字一樣。{list} 會就地修改,如果您不希望這樣,請使用 flattennew()E900
{maxdepth} 表示在巢狀列表中的變更深度。當 {maxdepth} 為 0 時,{list} 不會被修改。{maxdepth} 必須是正數。
如果發生錯誤,則傳回數字零。
範例
echo flatten([1, [2, [3, 4]], 5])
[1, 2, 3, 4, 5]
echo flatten([1, [2, [3, 4]], 5], 1)
[1, 2, [3, 4], 5]
參數
{list} (any[])
{maxdepth} (integer?)
回傳
(any[]|0)
flattennew({list} [, {maxdepth}]) flattennew()
flatten() 類似,但會先複製 {list}
參數
{list} (any[])
{maxdepth} (integer?)
回傳
(any[]|0)
float2nr({expr}) float2nr()
透過省略小數點後面的部分,將 {expr} 轉換為 Number。{expr} 的評估結果必須是 FloatNumber。如果 {expr} 不是 FloatNumber,則傳回 0。當 {expr} 的值超出 Number 的範圍時,結果會截斷為 0x7fffffff 或 -0x7fffffff (或者當啟用 64 位元 Number 支援時,則截斷為 0x7fffffffffffffff 或 -0x7fffffffffffffff)。NaN 的結果為 -0x80000000 (或者當啟用 64 位元 Number 支援時,則為 -0x8000000000000000)。範例
echo float2nr(3.95)
3
echo float2nr(-23.45)
-23
echo float2nr(1.0e100)
2147483647 (或 9223372036854775807)
echo float2nr(-1.0e150)
-2147483647 (或 -9223372036854775807)
echo float2nr(1.0e-100)
0
參數
{expr} (數字)
回傳
(any)
floor({expr}) floor()
傳回小於或等於 {expr} 的最大整數值,以 Float 形式表示(向下捨入)。{expr} 的評估結果必須是 FloatNumber。如果 {expr} 不是 FloatNumber,則傳回 0.0。範例
echo floor(1.856)
1.0
echo floor(-5.456)
-6.0
echo floor(4.0)
4.0
參數
{expr} (數字)
回傳
(any)
fmod({expr1}, {expr2}) fmod()
傳回 {expr1} / {expr2} 的餘數,即使除法無法表示。對於某個整數 i,傳回 {expr1} - i * {expr2},使得如果 {expr2} 非零,則結果與 {expr1} 的符號相同,且量值小於 {expr2} 的量值。如果 {expr2} 為零,則傳回值為零。傳回的值為 Float{expr1}{expr2} 的評估結果必須是 FloatNumber。如果 {expr1}{expr2} 不是 FloatNumber,則傳回 0.0。範例
echo fmod(12.33, 1.22)
0.13
echo fmod(-12.33, 1.22)
-0.13
參數
{expr1} (數字)
{expr2} (number)
回傳
(any)
fnameescape({string}) fnameescape()
{string} 逸出,以便用作檔案名稱命令引數。所有具有特殊含義的字元(例如 '%''|')都會使用反斜線逸出。對於大多數系統,逸出的字元為 " \t\n*?[{`$\\%#'\"|!<".}。對於檔案名稱中出現反斜線的系統,則取決於 'isfname' 的值。開頭的 '+' 和 '>' 也會被逸出(在 :edit:write 之後是特殊的)。單獨的 "-" 也會被逸出(在 :cd 之後是特殊的)。如果發生錯誤,則傳回空字串。範例
let fname = '+some str%nge|name'
exe "edit " .. fnameescape(fname)
會導致執行
edit \+some\ str\%nge\|name
參數
{string} (string)
回傳
(string)
fnamemodify({fname}, {mods}) fnamemodify()
根據 {mods} 修改檔案名稱 {fname}{mods} 是一個字串,其中包含類似於在命令列上用於檔案名稱的字元。請參閱 檔案名稱修飾符。範例
echo fnamemodify("main.c", ":p:h")
結果為
/home/user/vim/vim/src
如果 {mods} 為空或使用了不支援的修飾符,則會傳回 {fname}。當 {fname} 為空時,{mods} 為 ":h" 會傳回 ".",以便 :cd 可以與其一起使用。這與沒有緩衝區名稱的 expand('%:h') 不同,後者會傳回空字串。注意: 環境變數在 {fname} 中不起作用,請先使用 expand()
參數
{fname} (字串)
{mods} (string)
回傳
(string)
foldclosed({lnum}) foldclosed()
結果是一個 Number。如果行 {lnum} 位於關閉的摺疊中,則結果是該摺疊中第一行的行號。如果行 {lnum} 不在關閉的摺疊中,則傳回 -1。{lnum} 的使用方式與 getline() 相同。因此,"." 是目前行,"'m" 是標記 m,依此類推。
參數
{lnum} (整數)
回傳
(整數)
foldclosedend({lnum}) foldclosedend()
結果是一個 Number。如果行 {lnum} 位於關閉的摺疊中,則結果是該摺疊中最後一行的行號。如果行 {lnum} 不在關閉的摺疊中,則傳回 -1。{lnum} 的使用方式與 getline() 相同。因此,"." 是目前行,"'m" 是標記 m,依此類推。
參數
{lnum} (整數)
回傳
(整數)
foldlevel({lnum}) foldlevel()
結果是一個 Number,它是目前緩衝區中行 {lnum} 的摺疊層級。對於巢狀摺疊,會傳回最深層級。如果行 {lnum} 上沒有摺疊,則傳回零。摺疊是開啟還是關閉都沒有關係。當在更新摺疊時(從 'foldexpr' 中)使用時,對於尚未更新且摺疊層級未知的行,會傳回 -1。作為一種特殊情況,通常可以使用上一行的層級。{lnum} 的使用方式與 getline() 相同。因此,"." 是目前行,"'m" 是標記 m,依此類推。
參數
{lnum} (整數)
回傳
(整數)
foldtext() foldtext()
傳回一個 String,用於顯示關閉的摺疊。這是 'foldtext' 選項使用的預設函數,且應該只從評估 'foldtext' 時呼叫。它使用 v:foldstartv:foldendv:folddashes 變數。傳回的字串如下所示
+-- 45 lines: abcdef
前導破折號的數量取決於摺疊層級。"45" 是摺疊中的行數。"abcdef" 是摺疊中第一個非空白行的文字。會移除前導空白、"//" 或 "/*",以及 'foldmarker''commentstring' 選項中的文字。當用於繪製實際的摺疊文字時,該行的其餘部分將會使用 'fillchars' 設定中的摺疊字元填滿。當沒有摺疊時,會傳回空字串。
回傳
(string)
foldtextresult({lnum}) foldtextresult()
傳回在行 {lnum} 的關閉摺疊所顯示的文字。會在適當的上下文中評估 'foldtext'。當 {lnum} 沒有關閉的摺疊時,會傳回空字串。{lnum} 的使用方式與 getline() 相同。因此,"." 是目前行,"'m" 是標記 m,依此類推。當匯出摺疊文字時(例如匯出到 HTML)很有用。
參數
{lnum} (整數)
回傳
(string)
foreach({expr1}, {expr2}) foreach()
{expr1} 必須是 ListStringBlobDictionary。對於 {expr1} 中的每個項目,執行 {expr2}{expr1} 不會被修改;其值可能會被修改,如同 :lockvar 1。E741 請參閱 map()filter() 以修改 {expr1}
{expr2} 必須是 字串Funcref
如果 {expr2}字串,在 {expr2} 內,v:val 具有目前項目的值。對於 字典v:key 具有目前項目的鍵,對於 列表v:key 具有目前項目的索引。對於 Blobv:key 具有目前位元組的索引。對於 字串v:key 具有目前字元的索引。範例
call foreach(mylist, 'let used[v:val] = v:true')
這會記錄 {expr1} 列表中存在的項目。
請注意,{expr2} 是運算式的結果,然後會被用作命令。通常最好使用 字面字串,以避免必須使用雙反斜線。
如果 {expr2} 是一個 Funcref,它必須接受兩個參數:1. 目前項目的鍵或索引。2. 目前項目的值。使用 lambda 時,如果它只接受一個參數,不會產生錯誤。如果函式傳回一個值,則會被忽略。
在所有情況下都傳回 {expr1}。當執行 {expr2} 時遇到錯誤時,{expr1} 中不會再處理其他項目。當 {expr2} 是一個 Funcref 時,函式內部的錯誤會被忽略,除非該函式在定義時使用了 "abort" 旗標。
參數
{expr1} (string|table)
{expr2} (string|function)
回傳
(any)
fullcommand({name}) fullcommand()
從簡短的命令縮寫名稱取得完整的命令名稱;有關命令縮寫的詳細資訊,請參閱 20.2
字串參數 {name} 可能以 : 開頭,並且可以包含 [range],這些會被略過且不會傳回。如果命令不存在或不明確(針對使用者定義的命令),則傳回空字串。
例如,fullcommand('s')fullcommand('sub')fullcommand(':%substitute') 都會傳回 "substitute"。
參數
{name} (string)
回傳
(string)
funcref({name} [, {arglist}] [, {dict}]) funcref()
function() 類似,但是傳回的 Funcref 會透過參考來查找函式,而不是透過名稱。當稍後重新定義函式 {name} 時,這很重要。
function() 不同,{name} 必須是現有的使用者函式。它只有在自動載入的函式已經載入時才會運作(為了避免僅打算使用函式名稱時錯誤地載入自動載入腳本,請改用 function())。{name} 不能是內建函式。發生錯誤時傳回 0。
參數
{name} (string)
{arglist} (any?)
{dict} (any?)
回傳
(any)
function({name} [, {arglist}] [, {dict}]) function() partial E700 E923 傳回一個 Funcref 變數,該變數指向函式 {name}{name} 可以是使用者定義函式或內部函式的名稱。
{name} 也可以是 Funcref 或 partial。當它是 partial 時,會使用其中儲存的 dict,且不允許使用 {dict} 參數。例如:
let FuncWithArg = function(dict.Func, [arg])
let Broken = function(dict.Func, [arg], dict)
當使用 Funcref 時,將會透過 {name} 找到該函式,即使稍後重新定義也是如此。使用 funcref() 來保留相同的函式。
當存在 {arglist}{dict} 時,這會建立 partial。這表示參數列表和/或字典會儲存在 Funcref 中,並在呼叫 Funcref 時使用。
這些參數會傳遞給函式,位於其他參數之前,但在來自 method 的任何參數之後。範例
func Callback(arg1, arg2, name)
"...
endfunc
let Partial = function('Callback', ['one', 'two'])
"...
call Partial('name')
如同使用以下方式叫用函式
call Callback('one', 'two', 'name')
使用 method
func Callback(one, two, three)
"...
endfunc
let Partial = function('Callback', ['two'])
"...
eval 'one'->Partial('three')
如同使用以下方式叫用函式
call Callback('one', 'two', 'three')
可以巢狀呼叫 function(),以將更多參數新增至 Funcref。額外的參數會附加到參數列表的末尾。範例
func Callback(arg1, arg2, name)
"...
endfunc
let Func = function('Callback', ['one'])
let Func2 = function(Func, ['two'])
"...
call Func2('name')
如同使用以下方式叫用函式
call Callback('one', 'two', 'name')
只有在呼叫 "dict" 函式時,字典才有用。在這種情況下,{dict} 會以 "self" 的形式傳遞。範例
function Callback() dict
   echo "called for " .. self.name
endfunction
"...
let context = {"name": "example"}
let Func = function('Callback', context)
"...
call Func()        " will echo: called for example
當沒有額外參數時,不需要使用 function(),如果 Callback() 定義為 context.Callback(),則以下兩者是等效的
let Func = function('Callback', context)
let Func = context.Callback
可以組合使用參數列表和字典
function Callback(arg1, count) dict
"...
endfunction
let context = {"name": "example"}
let Func = function('Callback', ['one'], context)
"...
call Func(500)
如同使用以下方式叫用函式
call context.Callback('one', 500)
發生錯誤時回傳 0。
參數
{name} (string)
{arglist} (any?)
{dict} (any?)
回傳
(any)
garbagecollect([{atexit}]) garbagecollect()
清除具有循環參考的未使用 列表字典
幾乎不需要叫用此函式,因為當 Vim 記憶體不足或在 'updatetime' 之後等待使用者按下按鍵時,會自動執行此函式。沒有循環參考的項目在變成未使用時總是會被釋放。如果您在長時間執行的腳本中刪除了具有循環參考的非常大的 列表 和/或 字典,這會很有用。
當可選的 {atexit} 參數為 1 時,如果之前未執行垃圾收集,則在退出 Vim 時也會執行垃圾收集。這在檢查記憶體洩漏時很有用。
垃圾收集不會立即執行,而是僅在安全執行時才執行。這是在等待使用者輸入字元時。
參數
{atexit} (boolean?)
回傳
(any)
get({list}, {idx} [, {default}]) get() get()-list列表 {list} 取得項目 {idx}。當此項目不可用時,傳回 {default}。當省略 {default} 時,傳回零。
參數
{list} (any[])
{idx} (integer)
{default} (any?)
回傳
(any)
get({blob}, {idx} [, {default}]) get()-blob
Blob {blob} 取得位元組 {idx}。當此位元組不可用時,傳回 {default}。當省略 {default} 時,傳回 -1。
參數
{blob} (string)
{idx} (integer)
{default} (any?)
回傳
(any)
get({dict}, {key} [, {default}]) get()-dict
字典 {dict} 取得具有鍵 {key} 的項目。當此項目不可用時,傳回 {default}。當省略 {default} 時,傳回零。有用的範例
let val = get(g:, 'var_name', 'default')
如果 g:var_name 存在,則會取得其值,如果不存在,則會使用 "default"。
參數
{dict} (table<string,any>)
{key} (string)
{default} (any?)
回傳
(any)
get({func}, {what}) get()-func
Funcref {func} 取得項目 {what}{what} 的可能值為:"name" 函式名稱 "func" 函式 "dict" 字典 "args" 包含參數的列表 "arity" 包含函式接受的參數數目資訊(減去 {arglist})的字典,具有以下欄位:required 位置參數的數目 optional 除了必要參數之外的可選參數數目 varargs 如果函式接受可變數目的參數,則為 TRUE ...
注意:如果 Funcref 的 {arglist} 包含的參數比 Funcref 預期的多,則不會發生錯誤,且不會驗證。
發生錯誤時傳回零。
參數
{func} (function)
{what} (string)
回傳
(any)
getbufinfo([{buf}]) getbufinfo()
getbufinfo([{dict}]) 取得緩衝區的資訊,以字典的列表形式傳回。
不帶參數時,會傳回所有緩衝區的資訊。
當參數是 字典 時,只會傳回符合指定條件的緩衝區。可以在 {dict} 中指定以下鍵:buflisted 只包含已列出的緩衝區。bufloaded 只包含已載入的緩衝區。bufmodified 只包含已修改的緩衝區。
否則,{buf} 指定要傳回資訊的特定緩衝區。關於 {buf} 的使用,請參閱上面的 bufname()。如果找到緩衝區,則傳回的列表會包含一個項目。否則,結果會是一個空列表。
每個傳回的列表項目都是一個字典,其中包含以下項目:bufnr 緩衝區編號。changed 如果緩衝區已修改,則為 TRUE。changedtick 對緩衝區所做的變更次數。command 如果緩衝區屬於命令列視窗 cmdwin,則為 TRUE。hidden 如果緩衝區已隱藏,則為 TRUE。lastused 時間戳記,以秒為單位,如 localtime(),表示緩衝區上次使用的時間。listed 如果緩衝區已列出,則為 TRUE。lnum 在目前視窗中開啟緩衝區時使用的行號。僅當緩衝區過去曾在視窗中顯示時有效。如果您想要指定視窗中最後已知的游標位置的行號,請使用 line()
echo line('.', {winid})
linecount 緩衝區中的行數(僅在載入時有效)loaded 如果已載入緩衝區,則為 TRUE。name 緩衝區中檔案的完整路徑。signs 放置在緩衝區中的符號列表。每個列表項目都是一個字典,其中包含以下欄位:id 符號識別碼 lnum 行號 name 符號名稱 variables 指向包含緩衝區本地變數的字典的參考。windows 顯示此緩衝區的 window-ID 列表
範例
for buf in getbufinfo()
    echo buf.name
endfor
for buf in getbufinfo({'buflisted':1})
    if buf.changed
        " ....
    endif
endfor
若要取得緩衝區本地選項,請使用
getbufvar({bufnr}, '&option_name')
參數
{dict} (vim.fn.getbufinfo.dict?)
回傳
(vim.fn.getbufinfo.ret.item[])
getbufline({buf}, {lnum} [, {end}]) getbufline()
傳回一個 列表,其中包含從緩衝區 {buf}{lnum}{end}(包含)的行。如果省略 {end},則會傳回一個只包含行 {lnum}列表。若要只取得該行,請參閱 getbufoneline()
如需 {buf} 的使用,請參見上方的 bufname()
對於 {lnum}{end},可以使用 "$" 表示緩衝區的最後一行。否則,必須使用數字。
{lnum} 小於 1 或大於緩衝區中的行數時,會傳回一個空的 列表
{end} 大於緩衝區中的行數時,會將其視為 {end} 設定為緩衝區中的行數。當 {end}{lnum} 之前時,會傳回一個空的 列表
此函式僅適用於已載入的緩衝區。對於未載入和不存在的緩衝區,會傳回一個空的 列表
範例
let lines = getbufline(bufnr("myfile"), 1, "$")
參數
{buf} (整數|字串)
{lnum} (整數)
{end_} (integer?)
回傳
(any)
getbufoneline({buf}, {lnum}) getbufoneline()
getbufline() 類似,但只取得一行並將其以字串形式傳回。
參數
{buf} (整數|字串)
{lnum} (整數)
回傳
(string)
getbufvar({buf}, {varname} [, {def}]) getbufvar()
結果是緩衝區 {buf} 中選項或本地緩衝區變數 {varname} 的值。請注意,必須使用不帶 "b:" 的名稱。{varname} 參數是一個字串。當 {varname} 為空時,會傳回一個包含所有緩衝區本地變數的 字典。當 {varname} 等於 "&" 時,會傳回一個包含所有緩衝區本地選項的 字典。否則,當 {varname} 以 "&" 開頭時,會傳回緩衝區本地選項的值。這也適用於全域或緩衝區本地選項,但不適用於全域變數、視窗本地變數或視窗本地選項。關於 {buf} 的使用,請參閱上面的 bufname()。當緩衝區或變數不存在時,會傳回 {def} 或空字串,並且不會顯示錯誤訊息。範例
        let bufmodified = getbufvar(1, "&mod")
        echo "todo myvar = " .. getbufvar("todo", "myvar")
Parameters: ~
  • {buf} (`integer|string`)
  • {varname} (`string`)
  • {def} (`any?`)
Return: ~
  (`any`)
getcellwidths() getcellwidths()
傳回一個 列表,其中包含 setcellwidths() 所覆寫的字元範圍的儲存格寬度。格式與 setcellwidths() 的參數相同。如果沒有字元範圍覆寫其儲存格寬度,則會傳回一個空列表。
回傳
(any)
getchangelist([{buf}]) getchangelist()
傳回緩衝區 {buf}變更列表。關於 {buf} 的使用,請參閱上面的 bufname()。如果緩衝區 {buf} 不存在,則會傳回一個空列表。
傳回的列表包含兩個項目:一個包含變更位置的列表,以及目前在該列表中的位置。變更列表中的每個項目都是一個字典,包含以下項目:col 欄號 coladd 'virtualedit' 的欄位偏移量 lnum 行號 如果緩衝區 {buf} 是目前的緩衝區,則目前位置指的是在列表中的位置。對於其他緩衝區,它會被設定為列表的長度。
參數
{buf} (integer|string?)
回傳
(table[])
getchar([{expr}]) getchar()
從使用者或輸入流取得單一字元。如果省略 {expr},則會等待直到有字元可用。如果 {expr} 為 0,則僅在有字元可用時才會取得字元。否則傳回零。如果 {expr} 為 1,則僅檢查是否有字元可用,而不會將其消耗掉。如果沒有字元可用,則傳回零。如果您偏好總是取得字串,請使用 getcharstr()
在沒有 {expr} 以及 {expr} 為 0 的情況下,會傳回一個完整的字元或特殊按鍵。如果它是一個單一字元,則結果是一個數字。使用 nr2char() 將其轉換為字串。否則會傳回一個包含編碼字元的字串。對於特殊按鍵,它是一個以 0x80(十進位:128)開頭的位元組序列字串。這與字串 "\<Key>" 的值相同,例如 "\<Left>"。當使用未包含在字元中的修飾符(shift、control、alt)時,傳回的值也是一個字串。
{expr} 為 0 且按下 Esc 鍵時,Vim 會稍作延遲,以判斷這是否為跳脫序列的開頭。
{expr} 為 1 時,只會傳回第一個位元組。對於單一位元組字元,它本身就是一個數字。使用 nr2char() 將其轉換為字串。
使用 getcharmod() 來取得任何額外的修飾符。
當使用者點擊滑鼠按鈕時,會傳回滑鼠事件。然後可以在 v:mouse_colv:mouse_lnumv:mouse_winidv:mouse_win 中找到位置。也可以使用 getmousepos()。滑鼠移動事件將會被忽略。此範例會將滑鼠定位在它通常應該發生的位置
let c = getchar()
if c == "\<LeftMouse>" && v:mouse_win > 0
  exe v:mouse_win .. "wincmd w"
  exe v:mouse_lnum
  exe "normal " .. v:mouse_col .. "|"
endif
沒有提示,您必須以某種方式向使用者表明必須輸入字元。螢幕不會重繪,例如調整視窗大小時。
該字元沒有對應的映射。按鍵碼會被取代,因此當使用者按下 <Del> 鍵時,您會取得 <Del> 鍵的程式碼,而不是原始字元序列。範例
getchar() == "\<Del>"
getchar() == "\<S-Left>"
此範例重新定義 "f" 以忽略大小寫
nmap f :call FindChar()<CR>
function FindChar()
  let c = nr2char(getchar())
  while col('.') < col('$') - 1
    normal l
    if getline('.')[col('.') - 1] ==? c
      break
    endif
  endwhile
endfunction
參數
{expr} (0|1?)
回傳
(整數)
getcharmod() getcharmod()
結果是一個數字,表示使用 getchar() 或以其他方式取得的最後一個字元的修飾符狀態。這些值會加總在一起:2 shift 4 control 8 alt (meta) 16 meta(當它與 ALT 不同時)32 滑鼠雙擊 64 滑鼠三擊 96 滑鼠四擊(== 32 + 64)128 command (Mac) 或 super。僅會取得未包含在字元本身的修飾符。因此,Shift-a 會產生 "A",而沒有修飾符。如果未使用修飾符,則傳回 0。
回傳
(整數)
getcharpos({expr}) getcharpos()
取得字串 {expr} 的位置。與 getpos() 相同,但傳回的列表中的欄號是字元索引,而不是位元組索引。如果 getpos() 傳回一個非常大的欄號,等於 v:maxcol,則 getcharpos() 會傳回最後一個字元的字元索引。
範例:如果游標位於第 5 行文字「여보세요」中的「세」上
getcharpos('.')                returns [0, 5, 3, 0]
getpos('.')                returns [0, 5, 7, 0]
參數
{expr} (string)
回傳
(integer[])
getcharsearch() getcharsearch()
將目前的字元搜尋資訊傳回為 {dict},其中包含以下項目
char 先前用於字元搜尋的字元 (tfTF);如果未執行字元搜尋,則為空字串 forward 字元搜尋的方向;向前為 1,向後為 0 until 字元搜尋的類型;tT 字元搜尋為 1,fF 字元搜尋為 0
這對於始終讓 ;, 無論先前字元搜尋的方向如何,都向前/向後搜尋很有用
nnoremap <expr> ; getcharsearch().forward ? ';' : ','
nnoremap <expr> , getcharsearch().forward ? ',' : ';'
另請參閱 setcharsearch()
回傳
(表格)
getcharstr([{expr}]) getcharstr()
以字串形式從使用者或輸入流取得單一字元。如果省略 {expr},則會等待直到有字元可用。如果 {expr} 為 0 或 false,則僅在有字元可用時才會取得字元。否則傳回空字串。如果 {expr} 為 1 或 true,則僅檢查是否有字元可用,而不會將其消耗掉。如果沒有字元可用,則傳回空字串。否則,這會像 getchar() 一樣運作,只是數字結果會轉換為字串。
參數
{expr} (0|1?)
回傳
(string)
getcmdcomplpat() getcmdcomplpat()
傳回目前命令列的完成模式。僅在編輯命令列時有效,因此需要使用 c_CTRL-\_ec_CTRL-R_=。另請參閱 getcmdtype()setcmdpos()getcmdline()getcmdprompt()getcmdcompltype()setcmdline()。如果未定義完成,則傳回空字串。
回傳
(string)
getcmdcompltype() getcmdcompltype()
傳回目前命令列完成的類型。僅在編輯命令列時有效,因此需要使用 c_CTRL-\_ec_CTRL-R_=。請參閱 :command-completion 以取得傳回的字串。另請參閱 getcmdtype()setcmdpos()getcmdline()getcmdprompt()getcmdcomplpat()setcmdline()。如果未定義完成,則傳回空字串。
回傳
(string)
getcmdline() getcmdline()
傳回目前的命令列輸入。僅在編輯命令列時有效,因此需要使用 c_CTRL-\_ec_CTRL-R_=。範例
cmap <F7> <C-\>eescape(getcmdline(), ' \')<CR>
另請參閱 getcmdtype()getcmdpos()setcmdpos()getcmdprompt()setcmdline()。在輸入密碼或使用 inputsecret() 時,傳回空字串。
回傳
(string)
getcmdpos() getcmdpos()
以位元組計數傳回命令列中游標的位置。第一欄是 1。僅在編輯命令列時有效,因此需要使用 c_CTRL-\_ec_CTRL-R_= 或表達式對應。否則傳回 0。另請參閱 getcmdtype()setcmdpos()getcmdline()getcmdprompt()setcmdline()
回傳
(整數)
getcmdprompt() getcmdprompt()
在使用 input()confirm() 等函式時,傳回目前的命令列提示。僅在編輯命令列時有效,因此需要使用 c_CTRL-\_ec_CTRL-R_=。另請參閱 getcmdtype()getcmdline()getcmdpos()setcmdpos()setcmdline()
回傳
(string)
getcmdscreenpos() getcmdscreenpos()
以位元組計數傳回命令列中游標的螢幕位置。第一欄是 1。它會新增提示位置,而不是 getcmdpos()。僅在編輯命令列時有效,因此需要使用 c_CTRL-\_ec_CTRL-R_= 或表達式對應。否則傳回 0。另請參閱 getcmdpos()setcmdpos()getcmdline()setcmdline()
回傳
(any)
getcmdtype() getcmdtype()
傳回目前的命令列類型。可能傳回的值為: : 一般 Ex 命令 > 除錯模式命令 debug-mode / 向前搜尋命令 ? 向後搜尋命令 @ input() 命令 - :insert:append 命令 = i_CTRL-R_=。僅在編輯命令列時有效,因此需要使用 c_CTRL-\_ec_CTRL-R_= 或表達式對應。否則傳回空字串。另請參閱 getcmdpos()setcmdpos()getcmdline()
回傳
(':'|'>'|'/'|'?'|'@'|'-'|'=')
getcmdwintype() getcmdwintype()
傳回目前的 命令列視窗類型。可能傳回的值與 getcmdtype() 相同。如果不在命令列視窗中,則傳回空字串。
回傳
(':'|'>'|'/'|'?'|'@'|'-'|'=')
getcompletion({pat}, {type} [, {filtered}]) getcompletion()
傳回命令列完成匹配項的列表。字串 {type} 引數指定了其用途。支援以下完成類型
arglist 引數列表中的檔案名稱 augroup 自動命令群組 buffer 緩衝區名稱 breakpoint :breakadd:breakdel 子選項 cmdline cmdline-completion 結果 color 色彩配置 command Ex 命令 compiler 編譯器 compilers 自訂, {func} 自訂完成,透過 {func} 定義 customlist, {func} 自訂完成,透過 {func} 定義 diff_buffer :diffget:diffput 完成 dir 目錄名稱 dir_in_path 'cdpath' 中的目錄名稱 environment 環境變數名稱 event 自動命令事件 expression Vim 表達式 file 檔案和目錄名稱 file_in_path 'path' 中的檔案和目錄名稱 filetype 檔案類型名稱 'filetype' function 函式名稱 help 說明主題 highlight 醒目提示群組 history :history 子選項 keymap 鍵盤對應 locale 地區設定名稱(如 locale -a 的輸出) mapclear 緩衝區引數對應 mapping 對應名稱 menu 選單 messages :messages 子選項 option 選項 packadd 選用的套件 pack-add 名稱 runtime :runtime 完成 scriptnames 已來源的腳本名稱 :scriptnames shellcmd Shell 命令 shellcmdline 帶有檔案名稱引數的 Shell 命令列 sign :sign 子選項 syntax 語法檔案名稱 'syntax' syntime :syntime 子選項 tag 標籤 tag_listfiles 標籤,檔案名稱 user 使用者名稱 var 使用者變數
如果 {pat} 是空字串,則會傳回所有匹配項。否則,只會傳回與 {pat} 相符的項目。請參閱 萬用字元以了解如何在 {pat} 中使用特殊字元。
如果可選的 {filtered} 旗標設定為 1,則會套用 'wildignore' 來過濾結果。否則會傳回所有符合的項目。'wildignorecase' 選項始終會套用。
如果 'wildoptions' 選項包含 "fuzzy",則會使用模糊比對來取得完成比對。否則會使用正規表示式比對。因此,此函式會遵循使用者偏好,這與命令列上的行為相同。如果您不想要這樣,可以在呼叫 getcompletion() 之前將 'wildoptions' 設定為空,然後再還原它。
如果 {type} 是 "cmdline",則會傳回 cmdline-completion 的結果。例如,要完成 ":call" 命令後面的可能值
echo getcompletion('call ', 'cmdline')
如果沒有符合的項目,則會傳回空列表。{type} 的無效值會產生錯誤。
參數
{pat} (string)
{type} (string)
{filtered} (boolean?)
回傳
(string[])
getcurpos([{winid}]) getcurpos()
取得游標的位置。這類似於 getpos('.'),但會在列表中包含額外的 "curswant" 項目
[0, lnum, col, off, curswant]
"curswant" 數字是垂直移動游標時的首選欄位。在 $ 命令之後,它將會是一個非常大的數字,等於 v:maxcol。另請參閱 getcursorcharpos()getpos()。第一個 "bufnum" 項目始終為零。游標的位元組位置會在 "col" 中傳回。要取得字元位置,請使用 getcursorcharpos()
可選的 {winid} 引數可以指定視窗。它可以是視窗編號或 視窗 ID。會傳回最後已知的游標位置,如果它不是目前的視窗,則對於緩衝區的目前值而言,這可能是無效的。如果 {winid} 無效,則會傳回一個包含零的列表。
這可以用於儲存和還原游標位置
let save_cursor = getcurpos()
MoveTheCursorAround
call setpos('.', save_cursor)
請注意,這僅在視窗內有效。請參閱 winrestview() 以還原更多狀態。
參數
{winid} (整數?)
回傳
(any)
getcursorcharpos([{winid}]) getcursorcharpos()
getcurpos() 相同,但傳回的 List 中的欄位編號是字元索引而不是位元組索引。
範例:游標位於第 3 行的 '보' 上,文字為 "여보세요"
getcursorcharpos()        " returns [0, 3, 2, 0, 3]
getcurpos()                " returns [0, 3, 4, 0, 3]
參數
{winid} (整數?)
回傳
(any)
getcwd([{winnr} [, {tabnr}]]) getcwd()
沒有引數時,會傳回有效的目前目錄名稱。使用 {winnr}{tabnr} 時,會傳回該範圍的工作目錄,並忽略 'autochdir'。索引標籤和視窗會由各自的編號識別,0 表示目前的索引標籤或視窗。遺失的索引標籤編號表示 0。因此,下列項目是等效的
getcwd(0)
getcwd(0, 0)
如果 {winnr} 是 -1,則會忽略它,只會解析索引標籤。{winnr} 可以是視窗編號或 視窗 ID。如果 {winnr}{tabnr} 都是 -1,則會傳回全域工作目錄。如果引數無效,則會擲回錯誤。E5000 E5001 E5002
參數
{winnr} (整數?)
{tabnr} (整數?)
回傳
(string)
getenv({name}) getenv()
傳回環境變數 {name} 的值。{name} 引數是一個字串,沒有前置的 '$'。範例
myHome = getenv('HOME')
當變數不存在時,會傳回 v:null。這與設定為空字串的變數不同。另請參閱 expr-env
參數
{name} (string)
回傳
(string)
getfontname([{name}]) getfontname()
沒有引數時,會傳回正在使用的一般字型名稱。就像用於 Normal 反白群組 hl-Normal 的字型一樣。使用引數時,會檢查字串 {name} 是否為有效的字型名稱。如果不是,則會傳回空字串。否則會傳回實際的字型名稱,如果 GUI 不支援取得真實名稱,則會傳回 {name}。僅在 GUI 執行時有效,因此在您的 vimrc 或 gvimrc 檔案中無效。請在 GUI 啟動後立即使用 GUIEnter 自動指令來使用此函式。
參數
{name} (string?)
回傳
(string)
getfperm({fname}) getfperm()
結果是一個字串,它是給定檔案 {fname} 的讀取、寫入和執行權限。如果 {fname} 不存在或其目錄無法讀取,則會傳回空字串。結果的形式為 "rwxrwxrwx",其中每組 "rwx" 旗標依序表示檔案擁有者、檔案所屬群組和其他使用者的權限。如果使用者沒有給定的權限,則此旗標會由字串 "-" 取代。範例
echo getfperm("/etc/passwd")
echo getfperm(expand("~/.config/nvim/init.vim"))
這(從安全角度來看)應該會顯示字串 "rw-r--r--" 甚至是 "rw-------"。
若要設定權限,請使用 setfperm()
參數
{fname} (字串)
回傳
(string)
getfsize({fname}) getfsize()
結果是一個數字,它是給定檔案 {fname} 的大小(以位元組為單位)。如果 {fname} 是目錄,則會傳回 0。如果找不到檔案 {fname},則會傳回 -1。如果 {fname} 的大小太大而無法放入數字中,則會傳回 -2。
參數
{fname} (字串)
回傳
(整數)
getftime({fname}) getftime()
結果是一個數字,它是給定檔案 {fname} 的上次修改時間。該值以自 1970 年 1 月 1 日起的秒數測量,可以傳遞給 strftime()。另請參閱 localtime()strftime()。如果找不到檔案 {fname},則會傳回 -1。
參數
{fname} (字串)
回傳
(整數)
getftype({fname}) getftype()
結果是一個字串,它是給定檔案 {fname} 的檔案類型描述。如果 {fname} 不存在,則會傳回空字串。以下是不同檔案類型及其結果的表格:一般檔案 "file"、目錄 "dir"、符號連結 "link"、區塊裝置 "bdev"、字元裝置 "cdev"、Socket "socket"、FIFO "fifo"、所有其他 "other"。範例
getftype("/home")
請注意,只有在支援它的系統上才會傳回「連結」等類型。在某些系統上,只會傳回 "dir" 和 "file"。
參數
{fname} (字串)
回傳
('file'|'dir'|'link'|'bdev'|'cdev'|'socket'|'fifo'|'other')
getjumplist([{winnr} [, {tabnr}]]) getjumplist()
傳回指定視窗的跳躍列表
沒有引數時,會使用目前視窗。使用 {winnr} 時,只會使用目前索引標籤頁面中的此視窗。{winnr} 也可以是 視窗 ID。使用 {winnr}{tabnr} 時,會使用指定索引標籤頁面中的視窗。如果 {winnr}{tabnr} 無效,則會傳回空列表。
傳回的列表包含兩個項目:一個包含跳躍位置的列表,以及列表中最後使用的跳躍位置編號。跳躍位置列表中的每個項目都是一個字典,其中包含下列項目:bufnr 緩衝區編號、col 欄位編號、coladd 'virtualedit' 的欄位位移、filename 檔案名稱(如果可用)、lnum 行號
參數
{winnr} (整數?)
{tabnr} (整數?)
回傳
(vim.fn.getjumplist.ret)
getline({lnum} [, {end}]) getline()
沒有 {end} 時,結果是一個字串,它是目前緩衝區中的第 {lnum} 行。範例
getline(1)
{lnum} 是不以數字開頭的字串時,會呼叫 line() 將字串轉換為數字。若要取得游標下的行
getline(".")
{lnum} 是小於 1 或大於緩衝區中行數的數字時,會傳回空字串。
給定 {end} 時,結果會是一個 List,其中每個項目都是目前緩衝區中從 {lnum}{end} 範圍內的行,包括第 {end} 行。{end} 的使用方式與 {lnum} 相同。會靜默忽略不存在的行。當 {end}{lnum} 之前時,會傳回空的 List。範例
let start = line('.')
let end = search("^$") - 1
let lines = getline(start, end)
若要從另一個緩衝區取得行,請參閱 getbufline()getbufoneline()
參數
{lnum} (integer|string)
{end_} (nil|false?)
回傳
(string)
getloclist({nr} [, {what}]) getloclist()
傳回一個 List,其中包含視窗 {nr} 的位置列表中的所有項目。{nr} 可以是視窗編號或 視窗 ID。當 {nr} 為零時,會使用目前視窗。
對於位置列表視窗,會傳回顯示的位置列表。對於無效的視窗編號 {nr},會傳回空列表。否則,與 getqflist() 相同。
如果提供了可選的 {what} 字典引數,則會以字典形式傳回 {what} 中列出的項目。請參閱 getqflist() 以了解 {what} 中支援的項目。
除了 getqflist(){what} 中支援的項目外,getloclist() 也支援下列項目
filewinid 用於顯示位置列表檔案的視窗 ID。此欄位僅在從位置列表視窗呼叫時適用。如需詳細資訊,請參閱 location-list-file-window
如果視窗 {nr} 沒有位置列表,則會傳回包含預設值的 Dictionary。如果視窗 {nr} 不存在,則會傳回空 Dictionary。
範例(另請參閱 getqflist-examples
echo getloclist(3, {'all': 0})
echo getloclist(5, {'filewinid': 0})
參數
{nr} (integer)
{what} (table?)
回傳
(any)
getmarklist([{buf}]) getmarklist()
如果沒有 {buf} 引數,則會傳回包含所有全域標記相關資訊的 Listmark
如果指定了可選的 {buf} 引數,則會傳回在緩衝區 {buf} 中定義的本機標記。如需 {buf} 的用法,請參閱 bufname()。如果 {buf} 無效,則會傳回空列表。
傳回的 List 中的每個項目都是一個 Dict,其中包含下列項目:mark 標記名稱,前面加上 "'"、pos 一個 List,其中包含標記的位置:[bufnum、lnum、col、off]。如需詳細資訊,請參閱 getpos()。file 檔案名稱
如需取得特定標記的相關資訊,請參閱 getpos()
參數
{buf} (integer??)
回傳
(vim.fn.getmarklist.ret.item[])
getmatches([{win}]) getmatches()
傳回 List,其中包含先前由 matchadd():match 命令為目前視窗定義的所有比對。getmatches()setmatches() 結合使用時很有用,因為 setmatches() 可以還原由 getmatches() 儲存的比對列表。如果指定了 {win},則會使用此編號或視窗 ID 的視窗,而不是目前視窗。如果 {win} 無效,則會傳回空列表。範例
echo getmatches()
[{"group": "MyGroup1", "pattern": "TODO",
"priority": 10, "id": 1}, {"group": "MyGroup2",
"pattern": "FIXME", "priority": 10, "id": 2}]
let m = getmatches()
call clearmatches()
echo getmatches()
[]
call setmatches(m)
echo getmatches()
[{"group": "MyGroup1", "pattern": "TODO",
"priority": 10, "id": 1}, {"group": "MyGroup2",
"pattern": "FIXME", "priority": 10, "id": 2}]
unlet m
參數
{win} (integer?)
回傳
(any)
getmousepos() getmousepos()
傳回一個 Dictionary,其中包含滑鼠最後一次已知的位置。這可以用於滑鼠點擊的映射。項目包括:screenrow 螢幕列 screencol 螢幕欄 winid 點擊的視窗 ID winrow "winid" 內的列 wincol "winid" 內的欄 line "winid" 內的文字行 column "winid" 內的文字欄 coladd 從點擊字元開始的螢幕欄位偏移量。所有數字都是從 1 開始的。
如果不在視窗上方,例如在命令列中,則只有 "screenrow" 和 "screencol" 有效,其他值為零。
當在視窗下方的狀態列或視窗右側的垂直分隔線上時,"line" 和 "column" 的值為零。
當位置在文字之後時,"column" 是文字的位元組長度加一。
如果滑鼠懸停在可聚焦的浮動視窗上,則會使用該視窗。
當使用 getchar() 時,Vim 變數 v:mouse_lnumv:mouse_colv:mouse_winid 也會提供這些值。
回傳
(vim.fn.getmousepos.ret)
getpid() getpid()
傳回一個數字,該數字是 Vim 程序的程序 ID。這是一個唯一的數字,直到 Vim 退出。
回傳
(整數)
getpos({expr}) getpos()
取得字串 {expr} 的位置。{expr} 可接受的值為:. 游標位置。$ 目前緩衝區的最後一行。'x 標記 x 的位置(如果未設定標記,則所有值都傳回 0)。w0 目前視窗中可見的第一行(如果顯示未更新,例如在靜默 Ex 模式中,則為 1)。w$ 目前視窗中可見的最後一行(如果沒有可見的行,則比 "w0" 少 1)。v 當不在視覺模式時,傳回游標位置。在視覺模式中,傳回視覺區域的另一端。一個很好的思考方式是,在視覺模式中,"v" 和 "." 互補。雖然 "." 指的是游標位置,但 "v" 指的是 v_o 將游標移動到的位置。因此,您可以一起使用 "v" 和 "." 來處理字元式視覺模式中的所有選取內容。如果游標位於字元式視覺區域的末尾,則 "v" 指的是同一視覺區域的開頭。如果游標位於字元式視覺區域的開頭,則 "v" 指的是同一視覺區域的結尾。"v" 與 '<'> 的不同之處在於它會立即更新。請注意,可以使用另一個檔案中的標記。然後,行號將套用到另一個緩衝區。
結果是一個包含四個數字的 List:[bufnum, lnum, col, off] "bufnum" 為零,除非使用像 '0 或 'A 這樣的標記,否則它是標記的緩衝區編號。"lnum" 和 "col" 是緩衝區中的位置。第一欄為 1。"off" 數字為零,除非使用 'virtualedit'。然後它是螢幕欄位中從字元開始的偏移量。例如,<Tab> 內的位置或最後一個字元之後的位置。
若要取得游標位置,請參閱 getcurpos()。傳回 List 中的欄號是該行中的位元組位置。若要取得行中的字元位置,請使用 getcharpos()
請注意,對於 '< 和 '>,視覺模式很重要:當它是 "V"(視覺行模式)時,'< 的欄為零,而 '> 的欄是一個等於 v:maxcol 的大數字。可能會傳回一個非常大的欄號,等於 v:maxcol,在這種情況下,它表示「在行尾之後」。如果 {expr} 無效,則傳回一個所有數字都為零的列表。
這可以用於儲存和還原標記的位置
let save_a_mark = getpos("'a")
" ...
call setpos("'a", save_a_mark)
另請參閱 getcharpos()getcurpos()setpos()
參數
{expr} (string)
回傳
(integer[])
getqflist([{what}]) getqflist()
傳回一個 List,其中包含目前的所有快速修正錯誤。每個列表項目都是一個具有以下條目的字典:bufnr 具有檔案名稱的緩衝區編號,使用 bufname() 取得名稱 module 模組名稱 lnum 緩衝區中的行號(第一行為 1)end_lnum 如果項目是多行,則為行號的結尾 col 欄號(第一欄為 1)end_col 如果項目有範圍,則為欄號的結尾 vcol TRUE:「col」是視覺欄 FALSE:「col」是位元組索引 nr 錯誤編號 pattern 用於定位錯誤的搜尋模式 text 錯誤的描述 type 錯誤類型,'E'、'1' 等。valid TRUE:已識別的錯誤訊息 user_data 與項目關聯的自訂資料,可以是任何類型。
如果沒有錯誤列表或該列表為空,則傳回一個空列表。具有不存在的緩衝區編號的快速修正列表條目會傳回 "bufnr" 設定為零(注意:某些函數接受替代緩衝區的緩衝區編號零,您可能需要明確檢查是否為零)。
有用的應用:在多個檔案中尋找模式比對,並對它們執行某些操作
vimgrep /theword/jg *.c
for d in getqflist()
   echo bufname(d.bufnr) ':' d.lnum '=' d.text
endfor
如果提供了可選的 {what} 字典引數,則只會傳回 {what} 中列出的項目,作為字典。{what} 中支援下列字串項目:changedtick 取得對列表所做的變更總數 quickfix-changedtick context 取得 quickfix-context efm 剖析 "lines" 時要使用的 errorformat。如果不存在,則會使用 'errorformat' 選項值。id 取得具有 quickfix-ID 的快速修正列表資訊;零表示目前列表或由 "nr" 指定的列表的 ID idx 取得此列表中位於此索引處的快速修正項目資訊,該列表由 "id" 或 "nr" 指定。如果設定為零,則會使用目前的項目。請參閱 quickfix-index items 快速修正列表項目 lines 使用 'efm' 剖析行列表,並傳回產生的項目。只接受 List 類型。目前的快速修正列表不會修改。請參閱 quickfix-parse。nr 取得此快速修正列表的資訊;零表示目前的快速修正列表,「$」表示最後一個快速修正列表 qfbufnr 顯示在快速修正視窗中的緩衝區編號。如果快速修正緩衝區不存在,則傳回 0。請參閱 quickfix-buffer。size 快速修正列表中的項目數 title 取得列表標題 quickfix-title winid 取得快速修正 視窗 ID all 以上所有快速修正屬性 {what} 中的非字串項目會被忽略。若要取得特定項目的值,請將其設定為零。如果 "nr" 不存在,則會使用目前的快速修正列表。如果同時指定了 "nr" 和非零 "id",則會使用由 "id" 指定的列表。若要取得快速修正堆疊中的列表數,請在 {what} 中將 "nr" 設定為「$」。傳回字典中的 "nr" 值包含快速修正堆疊大小。指定 "lines" 時,會忽略除了 "efm" 之外的所有其他項目。傳回的字典包含項目 "items",其中包含項目列表。
傳回的字典包含下列項目:changedtick 對列表所做的變更總數 quickfix-changedtick context 快速修正列表內容。請參閱 quickfix-context。如果不存在,則設定為 ""。id 快速修正列表 ID quickfix-ID。如果不存在,則設定為 0。idx 列表中快速修正項目的索引。如果不存在,則設定為 0。items 快速修正列表項目。如果不存在,則設定為空列表。nr 快速修正列表編號。如果不存在,則設定為 0 qfbufnr 顯示在快速修正視窗中的緩衝區編號。如果不存在,則設定為 0。size 快速修正列表中的項目數。如果不存在,則設定為 0。title 快速修正列表標題文字。如果不存在,則設定為 ""。winid 快速修正 視窗 ID。如果不存在,則設定為 0
範例(另請參閱 getqflist-examples
echo getqflist({'all': 1})
echo getqflist({'nr': 2, 'title': 1})
echo getqflist({'lines' : ["F1:10:L10"]})
參數
{what} (table?)
回傳
(any)
getreg([{regname} [, 1 [, {list}]]]) getreg()
結果是一個字串,它是暫存器 {regname} 的內容。範例
let cliptext = getreg('*')
如果未設定暫存器 {regname},則結果是一個空字串。{regname} 引數必須是字串。
getreg('=') 傳回運算式暫存器的最後一個評估值。(用於映射中。)getreg('=', 1) 傳回運算式本身,以便可以使用 setreg() 還原。對於其他暫存器,額外的引數會被忽略,因此您可以隨時提供它。
如果存在 {list} 且為 TRUE,則結果類型會變更為 List。每個列表項目都是一行文字。如果您關心暫存器內可能存在的零位元組,請使用它:如果沒有第三個引數,則 NL 和零位元組都表示為 NL(請參閱 NL-used-for-Nul)。如果未設定暫存器,則會傳回一個空列表。
如果未指定 {regname},則會使用 v:register
參數
{regname} (string?)
{list} (nil|false?)
回傳
(string)
getreginfo([{regname}]) getreginfo()
傳回關於暫存器 {regname} 的詳細資訊,以包含下列條目的 Dictionary 形式傳回:regcontents 暫存器 {regname} 中包含的行列表,如 getreg({regname}, 1, 1)。regtype 暫存器 {regname} 的類型,如 getregtype() 中所述。isunnamed 布林值旗標,如果此暫存器目前由未命名的暫存器指向,則為 v:true。points_to 對於未命名的暫存器,給出目前指向的暫存器的單字母名稱(請參閱 quotequote)。例如,在使用 dd 刪除一行之後,此欄位將為 "1",這是取得已刪除文字的暫存器。
{regname} 引數是字串。如果 {regname} 無效或未設定,則會傳回一個空字典。如果未指定 {regname},則會使用 v:register。傳回的字典可以傳遞到 setreg()
參數
{regname} (string?)
回傳
(表格)
getregion({pos1}, {pos2} [, {opts}]) getregion()
從緩衝區中傳回從 {pos1}{pos2} 的字串列表。
{pos1}{pos2} 都必須是包含四個數字的 List。請參閱 getpos() 取得列表的格式。可以指定來自不同緩衝區的位置,但請注意 getregion-notes 中的限制。
可選引數 {opts} 是 Dict,並支援下列項目
type 指定區域的選取類型。請參閱 getregtype() 取得可能的值,但可以省略寬度,且不能使用空字串。(預設值:"v")
exclusive 如果為 TRUE,則針對結束位置使用獨佔選取。(預設值:遵循 'selection')
您可以使用 visualmode() 取得最後的選取類型。如果「視覺模式」處於啟用狀態,請使用 mode() 來取得「視覺模式」(例如,在 :vmap 中)。此函數可用於取得起點和終點位於不同欄位的文字,例如 字元式視覺選取
getregion-notes
請注意
{pos1}{pos2} 的順序無關緊要,它始終會回傳從左上角位置到右下角位置的內容。
如果啟用了 'virtualedit',且區域超出行的末尾,則結果行會以空格填充。
如果區域是區塊式且起點或終點位於多字元的中間,則不會包含該字元,但其選取的部分會替換為空格。
如果 {pos1}{pos2} 不在同一個緩衝區中,則會回傳空清單。
{pos1}{pos2} 必須屬於 bufloaded() 緩衝區。
它會在目前的視窗環境中評估,如果緩衝區顯示在具有不同 'virtualedit''list' 值的視窗中,則會有差異。
範例
xnoremap <CR>
\ <Cmd>echom getregion(
\ getpos('v'), getpos('.'), #{ type: mode() })<CR>
參數
{pos1} (table)
{pos2} (table)
{opts} (table?)
回傳
(string[])
getregionpos({pos1}, {pos2} [, {opts}]) getregionpos()
getregion() 相同,但會回傳描述由 {pos1}{pos2} 綁定的緩衝區文字區段的位置清單。每個區段是每行的兩個位置。
[[{start_pos}, {end_pos}], ...]
位置是一個含有四個數字的 清單:[bufnum, lnum, col, off] 「bufnum」是緩衝區編號。「lnum」和「col」是緩衝區中的位置。第一欄為 1。如果起始位置的「off」數字不為零,則它是從字元開始處的螢幕欄位偏移量。例如,在 <Tab> 內或最後一個字元之後的位置。如果結束位置的「off」數字不為零,則它是未包含在選取範圍內的字元第一個儲存格的偏移量,否則會包含其所有儲存格。
除了 getregion() 支援的選項外,{opts} 也支援以下選項
eol 如果為 TRUE,則以「col」值表示超出行的末尾的位置,該值比行的長度多 1。如果為 FALSE,則位置會限制在其行內,且如果行是空的或選取範圍完全超出行的末尾,則兩個位置都會使用 0 的「col」值。(預設值:FALSE
參數
{pos1} (table)
{pos2} (table)
{opts} (table?)
回傳
(integer[][][])
getregtype([{regname}]) getregtype()
結果是一個字串,它是暫存器 {regname} 的類型。該值將會是以下其中之一:「v」表示 字元式 文字,「V」表示 行式 文字,「<CTRL-V>{width}」表示 區塊式視覺 文字,「」表示空的或不明的暫存器。<CTRL-V> 是一個值為 0x16 的字元。{regname} 引數是一個字串。如果未指定 {regname},則會使用 v:register
參數
{regname} (string?)
回傳
(string)
getscriptinfo([{opts}]) getscriptinfo()
依據來源順序回傳一個 清單,其中包含有關所有來源的 Vim 指令檔的資訊,就像 :scriptnames 顯示的內容一樣。
可選的 Dict 引數 {opts} 支援以下可選項目:name 指令檔名稱比對模式。如果指定了,且未指定「sid」,則會回傳符合模式「name」的指令檔相關資訊。sid 指令檔 ID <SID>。如果指定了,則只會回傳 ID 為「sid」的指令檔相關資訊,並忽略「name」。
回傳的清單中的每個項目都是一個 Dict,其中包含以下項目:autoload 永遠設定為 FALSE。functions 指令檔中定義的指令檔本機函數名稱清單。只有在使用 {opts} 中的「sid」項目指定特定指令檔時才會出現。name Vim 指令檔名稱。sid 指令檔 ID <SID>。variables 包含指令檔本機變數的字典。只有在使用 {opts} 中的「sid」項目指定特定指令檔時才會出現。請注意,這是一個複本,無法使用此字典變更指令檔本機變數的值。version Vim 指令檔版本,永遠為 1。
範例
echo getscriptinfo({'name': 'myscript'})
echo getscriptinfo({'sid': 15})[0].variables
參數
{opts} (table?)
回傳
(vim.fn.getscriptinfo.ret[])
gettabinfo([{tabnr}]) gettabinfo()
如果未指定 {tabnr},則會將所有索引標籤頁面的資訊以 清單 的形式回傳。每個清單項目都是一個 字典。否則,{tabnr} 會指定索引標籤頁面的編號,並回傳該索引標籤頁面的資訊。如果索引標籤頁面不存在,則會回傳空清單。
每個清單項目都是一個 字典,其中包含以下項目:tabnr 索引標籤頁面編號。variables 對包含索引標籤頁面本機變數的字典的參照。windows 索引標籤頁面中的 視窗 ID 清單。
參數
{tabnr} (整數?)
回傳
(any)
gettabvar({tabnr}, {varname} [, {def}]) gettabvar()
取得索引標籤頁面 {tabnr} 中索引標籤本機變數 {varname} 的值。t:var 索引標籤的編號從 1 開始。{varname} 引數是一個字串。當 {varname} 為空時,會回傳包含所有索引標籤本機變數的字典。請注意,必須使用不含「t:」的名稱。當索引標籤或變數不存在時,會回傳 {def} 或空字串,且沒有錯誤訊息。
參數
{tabnr} (integer)
{varname} (string)
{def} (any?)
回傳
(any)
gettabwinvar({tabnr}, {winnr}, {varname} [, {def}]) gettabwinvar()
取得索引標籤頁面 {tabnr} 中視窗 {winnr} 的視窗本機變數 {varname} 的值。{varname} 引數是一個字串。當 {varname} 為空時,會回傳包含所有視窗本機變數的字典。當 {varname} 等於「&」時,會將所有視窗本機選項的值以 字典 的形式取得。否則,當 {varname} 以「&」開頭時,會取得視窗本機選項的值。請注意,{varname} 必須是不含「w:」的名稱。索引標籤的編號從 1 開始。對於目前的索引標籤頁面,請使用 getwinvar(){winnr} 可以是視窗編號或 視窗 ID。當 {winnr} 為零時,會使用目前的視窗。這也適用於全域選項、緩衝區本機選項和視窗本機選項,但不適用於全域變數或緩衝區本機變數。當索引標籤、視窗或變數不存在時,會回傳 {def} 或空字串,且沒有錯誤訊息。範例
let list_is_on = gettabwinvar(1, 2, '&list')
echo "myvar = " .. gettabwinvar(3, 1, 'myvar')
若要取得所有視窗本機變數,請使用
gettabwinvar({tabnr}, {winnr}, '&')
參數
{tabnr} (integer)
{winnr} (integer)
{varname} (string)
{def} (any?)
回傳
(any)
gettagstack([{winnr}]) gettagstack()
結果是一個 Dict,它是視窗 {winnr} 的標籤堆疊。{winnr} 可以是視窗編號或 視窗 ID。如果未指定 {winnr},則會使用目前的視窗。當視窗 {winnr} 不存在時,會回傳空的 Dict。
回傳的字典包含以下項目:curidx 堆疊中的目前索引。當位於堆疊頂端時,會設定為 (length + 1)。堆疊底部的索引為 1。items 堆疊中的項目清單。每個項目都是一個字典,其中包含以下所述的項目。length 堆疊中的項目數。
堆疊中的每個項目都是一個字典,其中包含以下項目:bufnr 從標籤跳躍之前的游標位置開始的目前跳躍的緩衝區編號。如需回傳清單的格式,請參閱 getpos()。matchnr 目前相符的標籤編號。當找到名稱的多個相符標籤時使用。tagname 標籤的名稱
如需標籤堆疊的詳細資訊,請參閱 tagstack
參數
{winnr} (整數?)
回傳
(any)
gettext({text}) gettext()
如果可能,會翻譯字串 {text}。這主要用於分散式 Vim 指令檔中。當產生訊息翻譯時,{text} 會由 xgettext 擷取,翻譯人員可以在 .po 檔案中新增翻譯的訊息,且當呼叫 gettext() 時,Vim 會查閱翻譯。對於 {text},雙引號字串是較佳的選擇,因為 xgettext 不理解單引號字串中的跳脫字元。
參數
{text} (字串)
回傳
(any)
getwininfo([{winid}]) getwininfo()
以含有字典的 清單 形式回傳視窗相關資訊。
如果提供 {winid},則會以包含一個項目的 清單 形式回傳具有該 ID 的視窗相關資訊。如果視窗不存在,則結果為空清單。
如果沒有 {winid},則會回傳所有索引標籤頁面中所有視窗的相關資訊。
每個清單項目都是一個 字典,其中包含以下項目:botline 最後一個完整顯示的緩衝區行。bufnr 視窗中的緩衝區編號。height 視窗高度(不包括 winbar)。loclist 如果顯示位置清單則為 1。quickfix 如果為 quickfix 或位置清單視窗則為 1。terminal 如果為終端視窗則為 1。tabnr 索引標籤頁面編號。topline 第一個顯示的緩衝區行。variables 對包含視窗本機變數的字典的參照。width 視窗寬度。winbar 如果視窗有工具列則為 1,否則為 0。wincol 視窗最左側的螢幕欄;來自 win_screenpos() 的「col」。textoff 由任何 'foldcolumn''signcolumn' 和文字前面的行號所佔用的欄位數。winid 視窗 ID。winnr 視窗編號。winrow 視窗最頂端的螢幕列;來自 win_screenpos() 的「row」。
參數
{winid} (整數?)
回傳
(vim.fn.getwininfo.ret.item[])
getwinpos([{timeout}]) getwinpos()
結果是一個 List,包含兩個數字,分別是 getwinposx()getwinposy() 的結果組合:[x 座標, y 座標]。{timeout} 可以用來指定等待終端回應的毫秒數。如果省略,則預設使用 100 毫秒。
遠端終端機請使用較長的時間。當使用小於 10 的值,且在該時間內沒有收到回應時,如果有的話,會返回先前回報的位置。這可以用來輪詢位置,並在這期間執行其他工作。
while 1
  let res = getwinpos(1)
  if res[0] >= 0
    break
  endif
  " Do some work here
endwhile
參數
{timeout} (integer?)
回傳
(any)
getwinposx() getwinposx()
結果是一個數字,表示 GUI Vim 視窗左側的 X 軸座標,單位是像素。如果資訊不可用,則結果會是 -1。此值可以用於 :winpos
回傳
(整數)
getwinposy() getwinposy()
結果是一個數字,表示 GUI Vim 視窗頂部的 Y 軸座標,單位是像素。如果資訊不可用,則結果會是 -1。此值可以用於 :winpos
回傳
(整數)
getwinvar({winnr}, {varname} [, {def}]) getwinvar()
類似於目前標籤頁的 gettabwinvar()。範例:
        let list_is_on = getwinvar(2, '&list')
        echo "myvar = " .. getwinvar(1, 'myvar')
Parameters: ~
  • {winnr} (`integer`)
  • {varname} (`string`)
  • {def} (`any?`)
Return: ~
  (`any`)
glob({expr} [, {nosuf} [, {list} [, {alllinks}]]]) glob()
展開 {expr} 中的檔案萬用字元。請參閱 萬用字元 以了解特殊字元的使用方法。
除非提供選用的 {nosuf} 引數且為 TRUE,否則會套用 'suffixes''wildignore' 選項:符合 'wildignore' 中模式的名稱將會被跳過,而 'suffixes' 會影響比對結果的排序。'wildignorecase' 則永遠適用。
{list} 存在且為 TRUE 時,結果會是包含所有符合檔案的 List。使用 List 的優點是,您還可以正確取得包含換行符號的檔案名稱。否則,結果會是一個字串,當有多個符合項目時,它們會以 <NL> 字元分隔。
如果展開失敗,結果會是空字串或空 List。
如果您需要執行複雜的操作,例如限制比對項目的數量,您也可以使用 readdir()
不會包含不存在檔案的名稱。只有在符號連結指向現有檔案時,才會將其包含在內。但是,當 {alllinks} 引數存在且為 TRUE 時,則會包含所有符號連結。
在大多數系統上,可以使用反引號從任何外部命令取得檔案名稱。範例:
let tagfiles = glob("`find . -name tags -print`")
let &tags = substitute(tagfiles, "\n", ",", "g")
反引號內程式的結果應該是每行一個項目。項目內部允許有空格。
請參閱 expand() 以展開特殊 Vim 變數。請參閱 system() 以取得外部命令的原始輸出。
參數
{expr} (string)
{nosuf} (boolean?)
{list} (boolean?)
{alllinks} (boolean?)
回傳
(any)
glob2regpat({string}) glob2regpat()
將 glob() 使用的檔案模式轉換為搜尋模式。結果可以用來比對作為檔案名稱的字串。例如:
if filename =~ glob2regpat('Make*.mak')
  " ...
endif
這等效於:
if filename =~ '^Make.*\.mak$'
  " ...
endif
{string} 是空字串時,結果是 "^$",比對空字串。請注意,結果取決於系統。在 MS-Windows 上,反斜線通常表示路徑分隔符號。
參數
{string} (string)
回傳
(any)
globpath({path}, {expr} [, {nosuf} [, {list} [, {alllinks}]]]) globpath() 對於 {path} 中所有目錄的字串 {expr} 執行 glob(),並將結果串連起來。範例:
echo globpath(&rtp, "syntax/c.vim")
{path} 是以逗號分隔的目錄名稱列表。每個目錄名稱都會加在 {expr} 的前面,並像 glob() 一樣展開。必要時會插入路徑分隔符號。若要在目錄名稱內加入逗號,請使用反斜線跳脫。請注意,在 MS-Windows 上,目錄可能會有尾隨的反斜線,如果在後面加上逗號,請將其移除。如果其中一個目錄的展開失敗,則不會有錯誤訊息。
除非提供選用的 {nosuf} 引數且為 TRUE,否則會套用 'suffixes''wildignore' 選項:符合 'wildignore' 中模式的名稱將會被跳過,而 'suffixes' 會影響比對結果的排序。
{list} 存在且為 TRUE 時,結果會是包含所有符合檔案的 List。使用 List 的優點是,您還可以正確取得包含換行符號的檔案名稱。否則,結果會是一個字串,當有多個符合項目時,它們會以 <NL> 字元分隔。範例:
echo globpath(&rtp, "syntax/c.vim", 0, 1)
{alllinks} 的使用方式與 glob() 相同。
可以使用 "**" 項目在目錄樹中搜尋。例如,若要尋找 'runtimepath' 及其下方目錄中所有的 "README.txt" 檔案:
echo globpath(&rtp, "**/README.txt")
不支援向上搜尋和限制 "**" 的深度,因此使用 'path' 不一定總是能正常運作。
參數
{path} (string)
{expr} (string)
{nosuf} (boolean?)
{list} (boolean?)
{alllinks} (boolean?)
回傳
(any)
has({feature}) has()
如果支援 {feature},則返回 1,否則返回 0。{feature} 引數是功能名稱,例如 "nvim-0.2.1" 或 "win32",請參閱下方。另請參閱 exists()
若要取得系統名稱,請在 Lua 中使用 vim.uv.os_uname()
print(vim.uv.os_uname().sysname)
如果程式碼有語法錯誤,Vimscript 可能會跳過該行其餘部分。請將 :if:endif 放在不同的行上,以避免語法錯誤
if has('feature')
  let x = this_breaks_without_the_feature()
endif
Vim 的編譯時功能名稱 (以 "+" 開頭) 不會被識別,因為 Nvim 總是使用所有可能的功能進行編譯。feature-compile
功能名稱可以是:1. Nvim 版本。例如,"nvim-0.2.1" 功能表示 Nvim 的版本是 0.2.1 或更高版本
if has("nvim-0.2.1")
  " ...
endif
2. 執行階段條件或其他虛擬功能。例如,"win32" 功能會檢查目前的系統是否為 Windows
if has("win32")
  " ...
endif
feature-list
支援的虛擬功能名稱列表:acl ACL 支援。bsd BSD 系統 (不是 macOS,請使用 "mac" 表示)。clipboard 提供可用的 剪貼簿。fname_case 檔案名稱中的大小寫有區別 (對於 Darwin 和 MS-Windows,此項不存在)。gui_running Nvim 有 GUI。iconv 可以使用 iconv() 進行轉換。linux Linux 系統。mac macOS 系統。nvim 這是 Nvim。python3 舊版 Vim python3 介面。has-python pythonx 舊版 Vim python_x 介面。has-pythonx sun SunOS 系統。ttyin 輸入是終端機 (tty)。ttyout 輸出是終端機 (tty)。unix Unix 系統。vim_starting啟動 期間為 True。win32 Windows 系統 (32 位元或 64 位元)。win64 Windows 系統 (64 位元)。wsl WSL (適用於 Linux 的 Windows 子系統) 系統。
has-patch
3. Vim 修補程式。例如,"patch123" 功能表示目前的 v:version 中已包含 Vim 修補程式 123
if v:version > 602 || v:version == 602 && has("patch148")
  " ...
endif
4. Vim 版本。例如,"patch-7.4.237" 功能表示 Nvim 與 Vim 版本 7.4.237 或更高版本相容。
if has("patch-7.4.237")
  " ...
endif
參數
{feature} (string)
回傳
(0|1)
has_key({dict}, {key}) has_key()
結果是一個數字,如果 Dictionary {dict} 有一個以 {key} 為鍵的項目,則為 TRUE。否則為 FALSE。{key} 引數是一個字串。
參數
{dict} (表格)
{key} (string)
回傳
(0|1)
haslocaldir([{winnr} [, {tabnr}]]) haslocaldir()
結果是一個數字,當視窗透過 :lcd 設定了本機路徑時,或者當 {winnr} 為 -1 且標籤頁透過 :tcd 設定了本機路徑時,則為 1,否則為 0。
標籤頁和視窗會以各自的編號識別,0 表示目前標籤頁或視窗。遺失引數表示 0。因此,以下是等效的:
echo haslocaldir()
echo haslocaldir(0)
echo haslocaldir(0, 0)
使用 {winnr} 在目前的標籤頁中使用該視窗。使用 {winnr}{tabnr} 在該標籤頁中使用該視窗。{winnr} 可以是視窗編號或 視窗 ID。如果 {winnr} 為 -1,則會忽略它,只會解析標籤頁。如果引數無效,則會擲回錯誤。E5000 E5001 E5002
參數
{winnr} (整數?)
{tabnr} (整數?)
回傳
(0|1)
hasmapto({what} [, {mode} [, {abbr}]]) hasmapto()
結果是一個數字,如果存在一個對應,在 rhs (對應到的內容) 的某處包含 {what},而且這個對應存在於 {mode} 指示的其中一個模式中,則為 TRUE。引數 {what}{mode} 是字串。當 {abbr} 存在且為 TRUE 時,請使用縮寫而非對應。別忘了指定插入模式和/或命令列模式。全域對應和目前緩衝區的本機對應都會檢查是否有符合項目。如果找不到符合的對應,則會返回 FALSE。以下字元會在 {mode} 中被識別:n 一般模式 v 可視和選取模式 x 可視模式 s 選取模式 o 運算子等待模式 i 插入模式 l 語言引數 ("r"、"f"、"t" 等) c 命令列模式。當省略 {mode} 時,會使用 "nvo"。
此函式適用於檢查 Vim 腳本中是否已存在對函式的對應。範例:
if !hasmapto('\ABCdoit')
   map <Leader>d \ABCdoit
endif
只有在沒有對 "\ABCdoit" 的對應時,才會將對應安裝到 "\ABCdoit"。
參數
{what} (any)
{mode} (string?)
{abbr} (boolean?)
回傳
(0|1)
histadd({history}, {item}) histadd()
將字串 {item} 加入到歷史記錄 {history} 中,{history} 可以是以下其中之一:hist-names
"cmd" 或 ":" 命令列歷史記錄、"search" 或 "/" 搜尋模式歷史記錄、"expr" 或 "=" 已輸入的表達式歷史記錄、"input" 或 "@" 輸入行歷史記錄、"debug" 或 ">" 除錯命令歷史記錄。若為空,則清除目前或上次使用的歷史記錄。{history} 字串不需要是完整名稱,一個字元就足夠。如果 {item} 已經存在於歷史記錄中,它將被移動成為最新的項目。結果是一個數字:如果操作成功則為 TRUE,否則返回 FALSE。
範例
call histadd("input", strftime("%Y %b %d"))
let date=input("Enter date: ")
此函數在 沙箱中不可用。
參數
{history} (string)
{item} (any)
回傳
(0|1)
histdel({history} [, {item}]) histdel()
清除 {history},即刪除其所有條目。有關 {history} 的可能值,請參閱 hist-names
如果參數 {item} 的求值結果為字串,則將其用作正規表示式。所有符合該表達式的條目都將從歷史記錄中刪除(如果有的話)。大小寫必須匹配,除非使用 "\c" /\c。如果 {item} 的求值結果為數字,則將其解釋為索引,請參閱 :history-indexing。如果存在,則將刪除相應的條目。
操作成功則返回 TRUE,否則返回 FALSE。
範例:清除表達式暫存器歷史記錄
call histdel("expr")
從搜尋歷史記錄中移除所有以 "*" 開頭的條目
call histdel("/", '^\*')
以下三個是等效的
call histdel("search", histnr("search"))
call histdel("search", -1)
call histdel("search", '^' .. histget("search", -1) .. '$')
刪除最後一個搜尋模式,並使用倒數第二個搜尋模式用於 "n" 命令和 'hlsearch'
call histdel("search", -1)
let @/ = histget("search", -1)
參數
{history} (string)
{item} (any?)
回傳
(0|1)
histget({history} [, {index}]) histget()
結果是一個字串,是來自 {history} 中索引為 {index} 的條目。有關 {history} 的可能值,請參閱 hist-names,有關 {index} 的資訊,請參閱 :history-indexing。如果沒有這樣的條目,則返回空字串。當省略 {index} 時,將使用歷史記錄中最新的項目。
範例:重做歷史記錄中倒數第二個搜尋。
execute '/' .. histget("search", -2)
定義一個 Ex 命令 ":H {num}",它支援重新執行來自 :history 輸出的第 {num} 個條目。
command -nargs=1 H execute histget("cmd", 0+<args>)
參數
{history} (string)
{index} (integer|string?)
回傳
(string)
histnr({history}) histnr()
結果是 {history} 中目前條目的數字。有關 {history} 的可能值,請參閱 hist-names。如果發生錯誤,則返回 -1。
範例
let inp_index = histnr("expr")
參數
{history} (string)
回傳
(整數)
hlID({name}) hlID()
結果是一個數字,它是名稱為 {name} 的高亮群組的 ID。當高亮群組不存在時,返回零。這可以用於檢索有關高亮群組的資訊。例如,要取得 "Comment" 群組的背景顏色:
echo synIDattr(synIDtrans(hlID("Comment")), "bg")
參數
{name} (string)
回傳
(整數)
hlexists({name}) hlexists()
結果是一個數字,如果存在名為 {name} 的高亮群組,則為 TRUE。當群組以某種方式定義時,就會發生這種情況。不一定是在為其定義高亮顯示時,它也可能已用於語法項目。
參數
{name} (string)
回傳
(0|1)
hostname() hostname()
結果是一個字串,它是 Vim 目前正在執行的機器名稱。長度超過 256 個字元的機器名稱將被截斷。
回傳
(string)
iconv({string}, {from}, {to}) iconv()
結果是一個字串,它是從編碼 {from} 轉換為編碼 {to} 的文字 {string}。當轉換完全失敗時,返回空字串。當某些字元無法轉換時,它們會被 "?" 取代。編碼名稱是 iconv() 函式庫函式可以接受的任何名稱,請參閱 ":!man 3 iconv"。請注意,Vim 對於所有 Unicode 編碼都使用 UTF-8,從/到 UCS-2 的轉換會自動變更為使用 UTF-8。無論如何,您都不能在字串中使用 UCS-2,因為它包含 NUL 位元組。
參數
{string} (string)
{from} (string)
{to} (string)
回傳
(any)
id({expr}) id()
傳回一個 字串,它是容器類型(ListDictBlobPartial)的唯一識別碼。可以保證,對於上述類型,id(v1) ==# id(v2) 傳回 true 的條件是 type(v1) == type(v2) && v1 is v2。請注意,v:_null_stringv:_null_listv:_null_dictv:_null_blob 具有相同的 id() 和不同的類型,因為它們在內部表示為 NULL 指標。id() 傳回容器指標的十六進位表示法 (例如 0x994a40),與 `asprintf("%p", {expr})` 相同,但不建議依賴傳回值的確切格式。
不保證 id(no_longer_existing_container) 不會等於其他某些 id():新的容器可能會重複使用垃圾回收容器的識別碼。
參數
{expr} (任意)
回傳
(any)
indent({lnum}) indent()
結果是一個數字,它是目前緩衝區中 {lnum} 行的縮排。縮排是以空格計算的,'tabstop' 的值相關。{lnum} 的使用方式與 getline() 中相同。當 {lnum} 無效時,返回 -1。
參數
{lnum} (integer|string)
回傳
(整數)
index({object}, {expr} [, {start} [, {ic}]]) index()
{object} 中尋找 {expr} 並傳回其索引。有關使用 lambda 選取項目的資訊,請參閱 indexof()
如果 {object}List,則傳回項目值等於 {expr} 的最低索引。沒有自動轉換,因此字串 "4" 與數字 4 不同。而且數字 4 與浮點數 4.0 不同。'ignorecase' 的值在此處未使用,大小寫區分,如 {ic} 引數所示。
如果 {object}Blob,則傳回位元組值等於 {expr} 的最低索引。
如果給定 {start},則從索引為 {start} 的項目開始尋找(對於相對於結尾的項目,可能為負數)。
當給定 {ic} 且為 TRUE 時,忽略大小寫。否則,大小寫必須匹配。
當在 {object} 中找不到 {expr} 時,返回 -1。範例:
let idx = index(words, "the")
if index(numbers, 123) >= 0
  " ...
endif
參數
{object} (任意)
{expr} (任意)
{start} (整數?)
{ic} (布林值?)
回傳
(any)
indexof({object}, {expr} [, {opts}]) indexof()
傳回 {object}{expr} 為 v:true 的項目的索引。{object} 必須是 ListBlob
如果 {object}List,則針對 List 中的每個項目求值 {expr},直到表達式為 v:true 並傳回此項目的索引。
如果 {object}Blob,則針對 Blob 中的每個位元組求值 {expr},直到表達式為 v:true 並傳回此位元組的索引。
{expr} 必須是 字串Funcref
如果 {expr}字串:如果 {object}List,則在 {expr} 內部,v:key 具有目前 List 項目的索引,v:val 具有項目的值。如果 {object}Blob,則在 {expr} 內部,v:key 具有目前位元組的索引,v:val 具有位元組值。
如果 {expr}Funcref,則它必須採用兩個引數:1. 目前項目的索引或索引鍵。2. 目前項目的值。如果找到該項目且應該停止搜尋,則函式必須傳回 TRUE
選用引數 {opts} 是一個 Dict,並支援下列項目:startidx 從具有此索引的項目開始評估 {expr};對於相對於結尾的項目,可能為負數。當 {expr} 對所有項目求值均為 v:false 時,返回 -1。範例:
let l = [#{n: 10}, #{n: 20}, #{n: 30}]
echo indexof(l, "v:val.n == 20")
echo indexof(l, {i, v -> v.n == 30})
echo indexof(l, "v:val.n == 20", #{startidx: 1})
參數
{object} (任意)
{expr} (任意)
{opts} (table?)
回傳
(any)
input({prompt} [, {text} [, {completion}]]) input()
參數
{prompt} (string)
{text} (string?)
{completion} (string?)
回傳
(any)
input({opts}) 結果是一個字串,它是使用者在命令列上輸入的任何內容。{prompt} 引數可以是提示字串,也可以是空白字串(不顯示提示)。可以在提示中使用 '\n' 來開始新的一行。
在第二種形式中,它接受一個包含以下索引鍵的字典,可以省略任何索引鍵
索引鍵 預設值 說明
prompt "" 與第一種形式中的 {prompt} 相同。default "" 與第一種形式中的 {text} 相同。completion 無 與第一種形式中的 {completion} 相同。cancelreturn "" 取消對話框時傳回的值。highlight 無 高亮處理常式:Funcref
使用 :echohl 設定的高亮顯示用於提示。輸入的方式與命令列相同,具有相同的編輯命令和對應。為 input() 輸入的行有一個單獨的歷史記錄。範例:
if input("Coffee or beer? ") == "beer"
  echo "Cheers!"
endif
如果存在選用引數 {text} 且不為空,則將其用作預設回覆,就像使用者輸入此內容一樣。範例:
let color = input("Color? ", "white")
選用引數 {completion} 指定輸入所支援的完成類型。如果沒有它,則不會執行完成。支援的完成類型與可以使用 "-complete=" 引數提供給使用者定義命令的類型相同。有關更多資訊,請參閱 :command-completion。範例:
let fname = input("File: ", "", "file")
input()-highlight E5400 E5402 可選的 highlight 鍵允許指定用於高亮顯示使用者輸入的函式。此函式會接收使用者輸入作為其唯一引數,並且必須傳回一個包含 3 元組的列表 [hl_start_col, hl_end_col + 1, hl_group],其中 hl_start_col 是第一個高亮顯示的欄位,hl_end_col 是最後一個高亮顯示的欄位(+ 1!),hl_group 是用於高亮顯示的 :hi 群組。 E5403 E5404 E5405 E5406 hl_start_col 和 hl_end_col + 1 都必須指向多位元組字元的開頭(高亮顯示不能中斷多位元組字元),hl_end_col + 1 可能等於輸入長度。起始欄位必須在範圍 [0, len(input)) 中,結束欄位必須在範圍 (hl_start_col, len(input)] 中,各區段必須依序排列,使下一個 hl_start_col 大於或等於上一個 hl_end_col。
範例(嘗試使用括號輸入一些內容)
highlight RBP1 guibg=Red ctermbg=red
highlight RBP2 guibg=Yellow ctermbg=yellow
highlight RBP3 guibg=Green ctermbg=green
highlight RBP4 guibg=Blue ctermbg=blue
let g:rainbow_levels = 4
function! RainbowParens(cmdline)
  let ret = []
  let i = 0
  let lvl = 0
  while i < len(a:cmdline)
    if a:cmdline[i] is# '('
      call add(ret, [i, i + 1, 'RBP' .. ((lvl % g:rainbow_levels) + 1)])
      let lvl += 1
    elseif a:cmdline[i] is# ')'
      let lvl -= 1
      call add(ret, [i, i + 1, 'RBP' .. ((lvl % g:rainbow_levels) + 1)])
    endif
    let i += 1
  endwhile
  return ret
endfunction
call input({'prompt':'>','highlight':'RainbowParens'})
高亮顯示函式對於每個新顯示的輸入字串至少會被呼叫一次,在重新繪製命令列之前。預期該函式在單次 input() 呼叫期間是純粹的,亦即對於相同的輸入產生相同的輸出,因此輸出可能會被記憶化。該函式的執行方式如同在 :silent 修飾符下執行。如果該函式導致任何錯誤,在目前的 input() 呼叫期間將會略過該函式。
如果命令列包含阿拉伯文字元,則會停用高亮顯示。
注意:此函式不得用於啟動檔案,針對僅在 GUI 模式下執行的版本(例如,Win32 GUI)。 注意:當從對應中呼叫 input() 時,它會消耗該對應中剩餘的字元,因為對應的處理方式就像字元是輸入的一樣。在 input() 之前使用 inputsave(),在 input() 之後使用 inputrestore() 以避免這種情況。另一種解決方案是避免在對應中出現後續字元,例如,使用 :execute:normal
具有對應的範例
nmap \x :call GetFoo()<CR>:exe "/" .. Foo<CR>
function GetFoo()
  call inputsave()
  let g:Foo = input("enter search pattern: ")
  call inputrestore()
endfunction
參數
{opts} (table)
回傳
(any)
inputlist({textlist}) inputlist()
{textlist} 必須是字串的 List。此 List 會被顯示,每行一個字串。將會提示使用者輸入一個數字,該數字會被傳回。使用者也可以使用滑鼠點擊來選擇項目,如果滑鼠在命令列中啟用('mouse' 為 "a" 或包含 "c")。對於第一個字串,會傳回 0。當點擊第一個項目上方時,會傳回一個負數。當點擊提示時,會傳回比 {textlist} 長度多一的值。請確保 {textlist} 的條目少於 'lines',否則它將無法運作。最好將條目編號放在字串的開頭。並在第一個項目中放入提示。範例
        let color = inputlist(['Select color:', '1. red',
                \ '2. green', '3. blue'])
Parameters: ~
  • {textlist} (`string[]`)
Return: ~
  (`any`)
inputrestore() inputrestore()
還原先前使用 inputsave() 儲存的預輸入。應該呼叫的次數與呼叫 inputsave() 的次數相同。不過,呼叫更多次是無害的。當沒有任何內容要還原時傳回 TRUE,否則傳回 FALSE。
回傳
(any)
inputsave() inputsave()
保留預輸入(也來自對應),並清除它,以便後續的提示從使用者取得輸入。提示後應接著一個匹配的 inputrestore()。可以使用多次,在這種情況下,必須要有相同數量的 inputrestore() 呼叫。當記憶體不足時傳回 TRUE,否則傳回 FALSE。
回傳
(any)
inputsecret({prompt} [, {text}]) inputsecret()
此函式的運作方式與 input() 函式非常相似,但有兩個例外:a) 使用者的回應將會顯示為一系列星號("*"),從而保持條目的機密性,並且 b) 使用者的回應將不會記錄在輸入的 history 堆疊中。結果是一個字串,即使用者在命令列上實際輸入以回應所發出提示的任何內容。 注意:不支援命令列完成。
參數
{prompt} (string)
{text} (string?)
回傳
(any)
insert({object}, {item} [, {idx}]) insert()
{object}ListBlob 時,將 {item} 插入其開頭。
如果指定了 {idx},則在索引為 {idx} 的項目之前插入 {item}。如果 {idx} 為零,則它會像省略 {idx} 一樣,放在第一個項目之前。也可以使用負的 {idx},請參閱 list-index。-1 會插入到最後一個項目之前。
傳回結果 ListBlob。範例
let mylist = insert([2, 3, 5], 1)
call insert(mylist, 4, -1)
call insert(mylist, 6, len(mylist))
最後一個範例可以使用 add() 更簡單地完成。請注意,當 {item}List 時,它會以單一項目的形式插入。使用 extend() 來串連 Lists
參數
{object} (任意)
{item} (any)
{idx} (integer?)
回傳
(any)
interrupt() interrupt()
中斷腳本執行。它的運作方式或多或少像使用者輸入 CTRL-C,大多數命令不會執行,並且控制權會返回給使用者。這對於從較低層次中止執行很有用,例如在自動命令中。範例
function s:check_typoname(file)
   if fnamemodify(a:file, ':t') == '['
       echomsg 'Maybe typo'
       call interrupt()
   endif
endfunction
au BufWritePre * call s:check_typoname(expand('<amatch>'))
回傳
(any)
invert({expr}) invert()
位元反轉。引數會轉換為數字。List、Dict 或 Float 引數會導致錯誤。範例
let bits = invert(bits)
參數
{expr} (數字)
回傳
(any)
isabsolutepath({path}) isabsolutepath()
結果是一個數字,當 {path} 是絕對路徑時,該數字為 TRUE。在 Unix 上,當路徑以 '/' 開頭時,會被視為絕對路徑。在 MS-Windows 上,當路徑以可選的磁碟機前綴開頭,並接著 '\' 或 '/' 時,會被視為絕對路徑。UNC 路徑始終是絕對路徑。範例
echo isabsolutepath('/usr/share/')        " 1
echo isabsolutepath('./foobar')                " 0
echo isabsolutepath('C:\Windows')        " 1
echo isabsolutepath('foobar')                " 0
echo isabsolutepath('\\remote\file')        " 1
參數
{path} (string)
回傳
(0|1)
isdirectory({directory}) isdirectory()
結果是一個數字,當名稱為 {directory} 的目錄存在時,該數字為 TRUE。如果 {directory} 不存在,或者不是目錄,則結果為 FALSE{directory} 是任何運算式,它會被用作字串。
參數
{directory} (string)
回傳
(0|1)
isinf({expr}) isinf()
如果 {expr} 是正無限大,則傳回 1,如果是負無限大,則傳回 -1,否則傳回 0。
echo isinf(1.0 / 0.0)
1
echo isinf(-1.0 / 0.0)
-1
參數
{expr} (數字)
回傳
(1|0|-1)
islocked({expr}) islocked() E786 結果是一個數字,當 {expr} 是鎖定變數的名稱時,該數字為 TRUE。字串引數 {expr} 必須是變數、List 項目或 Dictionary 條目的名稱,而不是變數本身!範例
let alist = [0, ['a', 'b'], 2, 3]
lockvar 1 alist
echo islocked('alist')                " 1
echo islocked('alist[1]')        " 0
{expr} 是不存在的變數時,您會收到錯誤訊息。使用 exists() 來檢查是否存在。
參數
{expr} (任意)
回傳
(0|1)
isnan({expr}) isnan()
如果 {expr} 是值為 NaN 的浮點數,則傳回 TRUE
echo isnan(0.0 / 0.0)
1
參數
{expr} (數字)
回傳
(0|1)
items({dict}) items()
傳回包含 {dict} 所有鍵值對的 List。每個 List 項目都是包含兩個項目的列表:{dict} 條目的鍵以及此條目的值。該 List 的順序是任意的。另請參閱 keys()values()。範例
for [key, value] in items(mydict)
   echo key .. ': ' .. value
endfor
也支援 List 或 String 引數。在這些情況下,items() 會傳回一個包含索引和索引處值的 List。
參數
{dict} (any)
回傳
(any)
jobpid({job}) jobpid()
傳回 job-id {job} 的 PID(處理程序識別碼)。
參數
{job} (integer)
回傳
(整數)
jobresize({job}, {width}, {height}) jobresize()
job-id {job} 的虛擬終端視窗調整為 {width} 個欄位和 {height} 列。如果作業不是使用 "pty":v:true 啟動的,則會失敗。
參數
{job} (integer)
{width} (integer)
{height} (integer)
回傳
(any)
jobstart({cmd} [, {opts}]) jobstart()
注意:在 Lua 中,請優先使用 vim.system()(除非使用 pty 選項)。
產生 {cmd} 作為作業。如果 {cmd} 是 List,則直接執行(不使用 'shell')。如果 {cmd} 是 String,則在 'shell' 中執行,如下所示
call jobstart(split(&shell) + split(&shellcmdflag) + ['{cmd}'])
(有關詳細資訊,請參閱 shell-unquoting。)
範例
call jobstart('nvim -h', {'on_stdout':{j,d,e->append(line('.'),d)}})
成功時傳回 job-id,如果引數無效(或作業表格已滿),則傳回 0,如果 {cmd}[0] 或 'shell' 不可執行,則傳回 -1。傳回的 job-id 是有效的 channel-id,表示作業的 stdio 串流。使用 chansend()(如果已啟用 "rpc",則使用 rpcnotify()rpcrequest())將資料傳送到 stdin,並使用 chanclose() 關閉串流而不停止作業。
請參閱 job-controlRPC
注意:在 Windows 上,如果 {cmd} 是 List
cmd[0] 必須是可執行檔(而不是「內建」)。如果它在 $PATH 中,則可以按名稱呼叫,無需擴充功能
call jobstart(['ping', 'neovim.io'])
如果它是完整或部分路徑,則需要擴充功能
call jobstart(['System32\ping.exe', 'neovim.io'])
{cmd} 會被摺疊為 CommandLineToArgvW 所預期的引號引數字串 https://msdn.microsoft.com/bb776391,除非 cmd[0] 是某種形式的 "cmd.exe"。
jobstart-env
作業環境初始化如下:$NVIM 會設定為父 Nvim 的 v:servername $NVIM_LISTEN_ADDRESS 會取消設定 $NVIM_LOG_FILE 會取消設定 $VIM 會取消設定 $VIMRUNTIME 會取消設定 您可以使用 env 選項來設定這些。
jobstart-options
{opts} 是一個具有以下鍵的字典:clear_env: (boolean) env 完全定義作業環境,而不是合併目前環境。cwd: (string, default=|current-directory|) 作業的工作目錄。detach: (boolean) 分離作業處理程序:當 Nvim 結束時,它不會被終止。如果處理程序在 Nvim 之前結束,則會呼叫 on_exit。env: (dict) 環境變數 name:value 配對的對應,用於延伸(或使用 "clear_env" 替換)目前環境。jobstart-env height: (number) pty 終端機的高度。on_exit: (function) 當作業結束時會呼叫的回呼函數。on_stdout: (function) 當作業發出 stdout 資料時會呼叫的回呼函數。on_stderr: (function) 當作業發出 stderr 資料時會呼叫的回呼函數。overlapped: (boolean) 為傳遞給子處理程序的 stdio 設定 FILE_FLAG_OVERLAPPED。僅適用於 MS-Windows;在其他平台上會被忽略。pty: (boolean) 將作業連接到新的虛擬終端機,並將其串流連接到主檔案描述符。on_stdout 接收所有輸出,on_stderr 會被忽略。terminal-start rpc: (boolean) 使用 msgpack-rpc 通過 stdio 與作業進行通訊。然後 on_stdout 會被忽略,但仍然可以使用 on_stderr。stderr_buffered: (boolean) 收集資料直到 EOF(串流關閉)才呼叫 on_stderrchannel-buffered stdout_buffered: (boolean) 收集資料直到 EOF(串流關閉)才呼叫 on_stdoutchannel-buffered stdin: (string) "pipe"(預設值)將作業的 stdin 連接到通道,或 "null" 取消連接 stdin。width: (number) pty 終端機的寬度。
{opts} 作為 self 字典傳遞給回呼函數;呼叫者可以設定其他鍵來傳遞應用程式特定的資料。
傳回值
成功時傳回 通道 ID
引數無效時傳回 0
如果 {cmd}[0] 不可執行則傳回 -1。另請參閱 工作控制通道msgpack-rpc
參數
{cmd} (string|string[])
{opts} (table?)
回傳
(any)
jobstop({id}) jobstop()
透過傳送 SIGTERM 給工作程序來停止 工作 ID {id}。如果程序在逾時後未終止,則會傳送 SIGKILL。當工作終止時,將會呼叫其 on_exit 處理常式(如果有的話)。請參閱 工作控制
對於有效的工作 ID 傳回 1,對於無效的 ID 傳回 0,包括已結束或已停止的工作。
參數
{id} (integer)
回傳
(any)
jobwait({jobs} [, {timeout}]) jobwait()
等待工作及其 on_exit 處理常式完成。
{jobs} 是要等待的 工作 ID 清單。{timeout} 是以毫秒為單位的最大等待時間。如果省略或為 -1,則會永遠等待。
逾時時間為 0 可用於檢查工作的狀態
let running = jobwait([{job-id}], 0)[0] == -1
在 jobwait() 期間,可能會呼叫不在 {jobs} 清單中的工作的回呼函數。除非回呼函數呼叫 :redraw,否則螢幕不會重新繪製。
傳回一個長度為 len({jobs}) 的整數清單,其中每個整數是相應工作的狀態:如果工作已結束,則為結束代碼;如果超過逾時時間,則為 -1;如果工作被中斷(透過 CTRL-C),則為 -2;如果工作 ID 無效,則為 -3。
參數
{jobs} (integer[])
{timeout} (integer?)
回傳
(any)
join({list} [, {sep}]) join()
{list} 中的項目連接成一個字串。當指定 {sep} 時,它會放在項目之間。如果省略 {sep},則會使用單個空格。請注意,{sep} 不會加在結尾。您可能也想在那裡加上它
let lines = join(mylist, "\n") .. "\n"
字串項目會原封不動地使用。清單字典 會像使用 string() 一樣轉換為字串。相反的函數是 split()
參數
{list} (any[])
{sep} (string?)
回傳
(any)
json_decode({expr}) json_decode()
{expr} 從 JSON 物件轉換。接受 readfile() 樣式的清單作為輸入,以及一般字串。可能會輸出任何 Vim 值。在以下情況下,它會輸出 msgpack-special-dict:1. 字典包含重複的鍵。2. 字串包含 NUL 位元組。如果包含 NUL 位元組的字串是字典鍵,則會發出兩個特殊字典:一個用於字典,一個用於字串。
注意: 函數始終將其輸入視為 UTF-8。JSON 標準僅允許少數幾種編碼,其中建議使用 UTF-8,且它是唯一一個需要支援的編碼。非 UTF-8 字元是錯誤的。
參數
{expr} (任意)
回傳
(any)
json_encode({expr}) json_encode()
{expr} 轉換為 JSON 字串。接受 msgpack-special-dict 作為輸入。不會轉換 Funcref、具有非字串鍵的對應 (可以使用 msgpack-special-dict 建立)、具有自我參照容器的值、包含非 UTF-8 字元的字串、包含為代理對保留的碼點的偽 UTF-8 字串(此類字串不是有效的 UTF-8 字串)。不可列印的字元會轉換為 "\u1234" 跳脫字元或像 "\t" 這樣的特殊跳脫字元,其他字元則會按原樣傾印。Blob 會轉換為個別位元組的陣列。
參數
{expr} (任意)
回傳
(any)
keys({dict}) keys()
傳回包含 {dict} 所有鍵的 清單清單 的順序是任意的。另請參閱 items()values()
參數
{dict} (表格)
回傳
(any)
keytrans({string}) keytrans()
將按鍵的內部位元組表示形式轉換為可用於 :map 的形式。例如
let xx = "\<C-Home>"
echo keytrans(xx)
<C-Home>
參數
{string} (string)
回傳
(any)
len({expr}) len() E701 結果是一個數字,即引數的長度。當 {expr} 是字串或數字時,會像 strlen() 一樣使用位元組的長度。當 {expr}清單 時,會傳回 清單 中項目的數量。當 {expr}Blob 時,會傳回位元組的數量。當 {expr}字典 時,會傳回 字典 中項目的數量。否則會產生錯誤並傳回零。
參數
{expr} (任意)
回傳
(any)
libcall({libname}, {funcname}, {argument}) libcall() E364 E368 在執行階段程式庫 {libname} 中呼叫具有單個引數 {argument} 的函數 {funcname}。這對於呼叫您專門製作與 Vim 一起使用的程式庫中的函數很有用。由於只能有一個引數,因此呼叫標準程式庫函數相當有限。結果是函數傳回的字串。如果函數傳回 NULL,則在 Vim 中會顯示為空字串 ""。如果函數傳回數字,請使用 libcallnr()!如果 {argument} 是數字,則會作為 int 傳遞給函數;如果 {argument} 是字串,則會作為以 null 結尾的字串傳遞。
libcall() 允許您在無需重新編譯程式的情況下,編寫自己的 Vim '外掛程式' 擴充功能。它並非呼叫系統函數的方法!如果您嘗試這樣做,Vim 很可能會崩潰。
對於 Win32,您編寫的函數必須放置在 DLL 中,並使用正常的 C 呼叫慣例(而非 Windows 系統 DLL 中使用的 Pascal)。函數必須只接受一個參數,即字元指標或長整數,且必須傳回字元指標或 NULL。傳回的字元指標必須指向在函數傳回後仍保持有效的記憶體 (例如,DLL 中的靜態資料)。如果它指向已配置的記憶體,則該記憶體將會洩漏。在函數中使用靜態緩衝區應該可以,它會在卸載 DLL 時釋放。
警告: 如果函數傳回無效的指標,Vim 可能會崩潰!如果函數傳回數字,也會發生這種情況,因為 Vim 會認為它是指標。對於 Win32 系統,{libname} 應該是 DLL 的檔案名稱,不含 ".DLL" 後綴。只有在 DLL 不在常用的位置時,才需要完整路徑。對於 Unix:編譯您自己的外掛程式時,請記住物件程式碼必須編譯為與位置無關 ('PIC')。範例
        echo libcall("libc.so", "getenv", "HOME")
Parameters: ~
  • {libname} (`string`)
  • {funcname} (`string`)
  • {argument} (`any`)
Return: ~
  (`any`)
libcallnr({libname}, {funcname}, {argument}) libcallnr()
libcall() 一樣,但用於傳回 int 而非字串的函數。範例
echo libcallnr("/usr/lib/libc.so", "getpid", "")
call libcallnr("libc.so", "printf", "Hello World!\n")
call libcallnr("libc.so", "sleep", 10)
參數
{libname} (string)
{funcname} (string)
{argument} (any)
回傳
(any)
line({expr} [, {winid}]) line()
有關接受的位置,請參閱 getpos()
若要取得欄號,請使用 col()。若要同時取得兩者,請使用 getpos()
使用可選的 {winid} 參數,會取得該視窗的值,而不是目前視窗的值。
對於 {expr}{winid} 的無效值,傳回 0。
範例
echo line(".")                        " line number of the cursor
echo line(".", winid)                " idem, in window "winid"
echo line("'t")                        " line number of mark t
echo line("'" .. marker)        " line number of mark marker
若要在開啟檔案時跳至最後一個已知位置,請參閱 last-position-jump
參數
{expr} (string|integer[])
{winid} (整數?)
回傳
(整數)
line2byte({lnum}) line2byte()
傳回緩衝區中第 {lnum} 行從頭開始的位元組計數。這包括行尾字元,具體取決於目前緩衝區的 'fileformat' 選項。第一行傳回 1。使用 UTF-8 編碼,忽略 'fileencoding'。這也可用於取得最後一行下方那一行的位元組計數
echo line2byte(line("$") + 1)
這是緩衝區大小加一。如果 'fileencoding' 為空,則為檔案大小加一。{lnum} 的使用方式與 getline() 相同。當 {lnum} 無效時,傳回 -1。另請參閱 byte2line()go:goto
參數
{lnum} (整數)
回傳
(整數)
lispindent({lnum}) lispindent()
根據 lisp 縮排規則取得第 {lnum} 行的縮排量,與 'lisp' 相同。縮排以空格計算,'tabstop' 的值相關。{lnum} 的使用方式與 getline() 相同。當 {lnum} 無效時,傳回 -1。
參數
{lnum} (整數)
回傳
(any)
list2blob({list}) list2blob()
傳回一個 Blob,串連 {list} 中的所有數字值。範例
echo list2blob([1, 2, 3, 4])        " returns 0z01020304
echo list2blob([])                " returns 0z
發生錯誤時傳回空的 Blob。如果其中一個數字為負數或大於 255,則會產生錯誤 E1239
blob2list() 的功能相反。
參數
{list} (any[])
回傳
(any)
list2str({list} [, {utf8}]) list2str()
{list} 中的每個數字轉換為字元字串並將它們全部串連起來。範例
echo list2str([32])                " returns " "
echo list2str([65, 66, 67])        " returns "ABC"
可以使用 (速度較慢的) 以下方式完成相同操作
echo join(map(list, {nr, val -> nr2char(val)}), '')
str2list() 的功能相反。
始終使用 UTF-8 編碼,{utf8} 選項無效,且僅為了向後相容而存在。使用 UTF-8,組合字元會如預期般運作
echo list2str([97, 769])        " returns "á"
發生錯誤時傳回空字串。
參數
{list} (any[])
{utf8} (boolean?)
回傳
(any)
localtime() localtime()
傳回目前時間,以自 1970 年 1 月 1 日起的秒數測量。另請參閱 strftime()strptime()getftime()
回傳
(any)
log({expr}) log()
Float 形式傳回 {expr} 的自然對數(以 e 為底)。{expr} 必須評估為範圍在 (0, inf] 中的 FloatNumber。如果 {expr} 不是 FloatNumber,則傳回 0.0。範例
echo log(10)
2.302585
echo log(exp(5))
5.0
參數
{expr} (數字)
回傳
(any)
log10({expr}) log10()
Float 形式傳回 Float {expr} 以 10 為底的對數。{expr} 必須評估為 FloatNumber。如果 {expr} 不是 FloatNumber,則傳回 0.0。範例
echo log10(1000)
3.0
echo log10(0.01)
-2.0
參數
{expr} (數字)
回傳
(any)
luaeval({expr} [, {expr}]) luaeval()
評估 Lua 運算式 {expr} 並傳回其轉換為 Vim 資料結構的結果。有關更多詳細資訊,請參閱 lua-eval
參數
{expr} (string)
{expr1} (any[]?)
回傳
(any)
map({expr1}, {expr2}) map()
{expr1} 必須是 ListStringBlobDictionary。當 {expr1}ListDictionary 時,將 {expr1} 中的每個項目替換為計算 {expr2} 的結果。對於 Blob,每個位元組都會被替換。對於 String,每個字元(包括組合字元)都會被替換。如果項目類型變更,您可能需要使用 mapnew() 來建立新的 List 或 Dictionary。
{expr2} 必須是 StringFuncref
如果 {expr2}String,在 {expr2} 內,v:val 具有目前項目的值。對於 Dictionaryv:key 具有目前項目的鍵,而對於 Listv:key 具有目前項目的索引。對於 Blobv:key 具有目前位元組的索引。對於 Stringv:key 具有目前字元的索引。範例:
call map(mylist, '"> " .. v:val .. " <"')
這會在 "mylist" 中的每個項目之前加上 "> ",之後加上 " <"。
請注意,{expr2} 是運算式的結果,然後再次用作運算式。通常最好使用字串文字來避免必須使用雙反斜線。您仍然必須使用雙引號。
如果 {expr2}Funcref,則會使用兩個引數呼叫它:1. 目前項目的鍵或索引。2. 目前項目的值。該函數必須返回該項目新的值。變更每個值為 "key-value" 的範例:
func KeyValue(key, val)
  return a:key .. '-' .. a:val
endfunc
call map(myDict, function('KeyValue'))
使用 lambda 時會更短
call map(myDict, {key, val -> key .. '-' .. val})
如果您不使用 "val",則可以省略它
call map(myDict, {key -> 'item: ' .. key})
如果您不使用 "key",則可以使用短名稱
call map(myDict, {_, val -> 'item: ' .. val})
對於 ListDictionary,此操作會就地進行。如果您希望它保持未修改狀態,請先複製一份
let tlist = map(copy(mylist), ' v:val .. "\t"')
傳回 {expr1},即被篩選過的 ListDictionary,或是一個新的 BlobString。當評估 {expr2} 時遇到錯誤,{expr1} 中剩餘的項目將不會被處理。當 {expr2} 是一個 Funcref 時,函數內部的錯誤會被忽略,除非該函數定義時使用了 "abort" 標誌。
參數
{expr1} (string|table|any[])
{expr2} (string|function)
回傳
(any)
maparg({name} [, {mode} [, {abbr} [, {dict}]]]) maparg()
{dict} 省略或為零時:傳回模式 {mode} 中對應 {name} 的右側 (rhs)。傳回的 String 會像在 ":map" 命令清單的輸出中一樣轉換特殊字元。當 {dict} 為 TRUE 時,會傳回一個字典,請參閱下方。若要取得所有對應的清單,請參閱 maplist()
當沒有 {name} 的對應時,如果 {dict} 為 FALSE,則會傳回空的 String,否則會傳回空的 Dict。當 {name} 的對應為空時,則會傳回 "<Nop>"。
{name} 可以具有特殊鍵名稱,就像在 ":map" 命令中一樣。
{mode} 可以是以下字串之一:"n" Normal "v" Visual (包括 Select) "o" Operator-pending "i" Insert "c" Cmd-line "s" Select "x" Visual "l" langmap 語言對應 "t" Terminal "" Normal、Visual 和 Operator-pending。當省略 {mode} 時,會使用 "" 的模式。
{abbr} 存在且為 TRUE 時,請使用縮寫而不是對應。
{dict} 存在且為 TRUE 時,傳回包含對應所有資訊的字典,其中包含以下項目:mapping-dict
"lhs" 對應的 {lhs},如輸入時的樣子。"lhsraw" 對應的 {lhs},如原始位元組。"lhsrawalt" 對應的 {lhs},如原始位元組,替代形式,僅當與 "lhsraw" 不同時存在。"rhs" 對應的 {rhs},如輸入時的樣子。"callback" Lua 函數,如果 RHS 定義為此。"silent" 對於 :map-silent 對應為 1,否則為 0。"noremap" 如果對應的 {rhs} 不可重新對應,則為 1。"script" 如果對應是以 <script> 定義,則為 1。"expr" 對於運算式對應 (:map-<expr>) 為 1。"buffer" 對於緩衝區本地對應 (:map-local) 為 1。"mode" 定義對應的模式。除了上面提到的模式之外,還會使用以下字元:" " Normal、Visual 和 Operator-pending "!" Insert 和 Commandline 模式 (mapmode-ic) "sid" 腳本本地 ID,用於 <sid> 對應 (<SID>)。對於特殊內容為負數。"scriptversion" 腳本的版本,始終為 1。"lnum" "sid" 中的行號,如果未知則為零。"nowait" 不等待其他較長的對應。( :map-<nowait>)。"abbr" 如果這是 縮寫,則為 True。"mode_bits" Nvim 的 "mode" 內部二進位表示法。mapset() 會忽略此項;僅使用 "mode"。有關使用範例,請參閱 maplist()。這些值來自 src/nvim/state_defs.h,未來可能會變更。
該字典可用於使用 mapset() 還原對應。
會先檢查目前緩衝區的本地對應,然後檢查全域對應。即使已對應按鍵,此函數也可以用於對應按鍵,並讓它執行原始對應。草圖
exe 'nnoremap <Tab> ==' .. maparg('<Tab>', 'n')
參數
{name} (string)
{mode} (string?)
{abbr} (boolean?)
{dict} (false?)
回傳
(string)
mapcheck({name} [, {mode} [, {abbr}]]) mapcheck()
檢查在模式 {mode} 中是否有與 {name} 比對的對應。有關 {mode}{name} 中的特殊名稱,請參閱 maparg()。當 {abbr} 存在且為非零時,請使用縮寫而不是對應。如果對應以 {name} 開頭,且對應等於 {name} 的開頭,則會發生比對。
比對對應 "a" "ab" "abc"
mapcheck("a") 是 是 是 mapcheck("abc") 是 是 是 mapcheck("ax") 是 否 否 mapcheck("b") 否 否 否
maparg() 的不同之處在於,mapcheck() 會尋找與 {name} 比對的對應,而 maparg() 只會尋找完全符合 {name} 的對應。當沒有以 {name} 開頭的對應時,會傳回空的 String。如果有一個,則會傳回該對應的 RHS。如果有數個以 {name} 開頭的對應,則會傳回其中一個的 RHS。如果 RHS 為空,則會是 "<Nop>"。會先檢查目前緩衝區的本地對應,然後檢查全域對應。此函數可用於檢查是否可以在沒有歧義的情況下新增對應。範例:
if mapcheck("_vv") == ""
   map _vv :set guifont=7x13<CR>
endif
這可以避免在已存在 "_v" 或 "_vvv" 的對應時,新增 "_vv" 對應。
參數
{name} (string)
{mode} (string?)
{abbr} (boolean?)
回傳
(any)
maplist([{abbr}]) maplist()
傳回所有對應的 List。每個 List 項目都是一個 Dict,與 maparg() 傳回的相同,請參閱 mapping-dict。當 {abbr} 存在且為 TRUE 時,請使用縮寫而不是對應。
顯示 rhs 中具有 "MultiMatch" 的所有對應的範例
echo maplist()->filter({_, m ->
        \ match(get(m, 'rhs', ''), 'MultiMatch') >= 0
        \ })
要尋找特定 :map-modes 的對應可能會很棘手。mapping-dict 的 "mode_bits" 可以簡化此作業。例如,Normal、Insert 或 Command-line 模式的 mode_bits 為 0x19。若要尋找這些模式中可用的所有對應,您可以執行以下操作
let saved_maps = []
for m in maplist()
    if and(m.mode_bits, 0x19) != 0
        eval saved_maps->add(m)
    endif
endfor
echo saved_maps->mapnew({_, m -> m.lhs})
mode_bits 的值定義在 Nvim 的 src/nvim/state_defs.h 檔案中,您可以使用 :map-commands 和 "maplist()" 在執行階段探索它們。範例
omap xyzzy <Nop>
let op_bit = maplist()->filter(
    \ {_, m -> m.lhs == 'xyzzy'})[0].mode_bits
ounmap xyzzy
echo printf("Operator-pending mode bit: 0x%x", op_bit)
參數
{abbr} (0|1?)
回傳
(table[])
mapnew({expr1}, {expr2}) mapnew()
類似於 map(),但不是替換 {expr1} 中的項目,而是建立並傳回新的 List 或 Dictionary。{expr1} 保持不變。項目仍然可以透過 {expr2} 變更,如果您不想要這樣,請先使用 deepcopy()
參數
{expr1} (any)
{expr2} (any)
回傳
(any)
mapset({mode}, {abbr}, {dict}) mapset()
mapset({dict}) 從字典還原對應,可能由 maparg()maplist() 傳回。當 dict.buffer 為 true 時,會在目前緩衝區上設定緩衝區對應;由呼叫者確保預期的緩衝區是目前緩衝區。此功能允許將對應從一個緩衝區複製到另一個緩衝區。dict.mode 值可能會還原涵蓋多個模式的單一對應,例如使用 '!'、' '、"nox" 或 'v' 的模式值。E1276
在第一種形式中,{mode}{abbr} 應該與呼叫 maparg() 的相同。E460 {mode} 用於定義設定對應的模式,而不是 {dict} 中的 "mode" 項目。儲存和還原對應的範例:
let save_map = maparg('K', 'n', 0, 1)
nnoremap K somethingelse
" ...
call mapset('n', 0, save_map)
請注意,如果您要取代多個模式中的對應,例如使用 :map!,則需要儲存/還原它們的全部對應,因為它們可能會有所不同。
在第二種形式中,使用 {dict} 作為唯一的引數,則從字典中取得模式和縮寫。範例
let save_maps = maplist()->filter(
                        \ {_, m -> m.lhs == 'K'})
nnoremap K somethingelse
cnoremap K somethingelse2
" ...
unmap K
for d in save_maps
    call mapset(d)
endfor
參數
{dict} (boolean)
回傳
(any)
match({expr}, {pat} [, {start} [, {count}]]) match()
{expr}List 時,這會傳回 {pat} 比對的第一個項目的索引。每個項目都用作 String,ListDictionary 會像回音一樣使用。
否則,{expr} 會用作 String。結果是一個 Number,表示 {expr}{pat} 比對的索引(位元組偏移)。
在第一個字元或 List 項目處的比對會傳回零。如果沒有比對,則會傳回 -1。
若要取得子比對,請參閱 matchlist()。範例
echo match("testing", "ing")        " results in 4
echo match([1, 'x'], '\a')        " results in 1
有關如何使用 {pat} 的資訊,請參閱 string-matchstrpbrk()
Vim 沒有 strpbrk() 函數。但是您可以執行以下操作
let sepidx = match(line, '[.,;: \t]')
strcasestr()
Vim 沒有 strcasestr() 函數。但是您可以將 "\c" 新增至模式以忽略大小寫
let idx = match(haystack, '\cneedle')
如果指定 {start},則搜尋會從 String 中的位元組索引 {start}List 中的項目 {start} 開始。但是,結果仍然是從第一個字元/項目計算的索引。範例
echo match("testing", "ing", 2)
結果再次為 "4"。
echo match("testing", "ing", 4)
結果再次為 "4"。
echo match("testing", "t", 2)
結果為「3」。對於字串,如果 {start} > 0,則如同字串從 {start} 個位元組後開始,因此「^」會在 {start} 處匹配。但當指定 {count} 時,則如同忽略 {start} 位元組之前的匹配(為了保持向後相容性,這有點複雜)。對於字串,如果 {start} < 0,則會被設為 0。對於列表,索引從結尾開始計算。如果 {start} 超出範圍(對於字串,{start} > strlen({expr}),或對於列表{start} > len({expr})),則返回 -1。
當給定 {count} 時,使用第 {count} 個匹配。當在字串中找到匹配時,搜尋下一個匹配會從下一個字元開始。因此,此範例的結果為 1。
echo match("testing", "..", 0, 2)
列表中,搜尋會繼續在下一個項目中進行。請注意,當加入 {count} 時,{start} 的運作方式會改變,請參閱上方說明。
match-pattern
請參閱 pattern 以取得可接受的模式。 'ignorecase' 選項用於設定模式是否忽略大小寫。'smartcase' 不會被使用。匹配始終像設定了 'magic''cpoptions' 為空一樣進行。請注意,優先匹配開頭處,因此當模式使用「*」(任意數量的匹配)時,它傾向於在開頭找到零個匹配,而不是在文字中更下方找到多個匹配。
參數
{expr} (string|any[])
{pat} (string)
{start} (整數?)
{count} (integer?)
回傳
(any)
matchadd() E798 E799 E801 E957 matchadd({group}, {pattern} [, {priority} [, {id} [, {dict}]]]) 定義要在目前視窗中突顯的模式(「匹配」)。它將使用 {group} 突顯。返回一個識別號碼 (ID),可用於使用 matchdelete() 刪除匹配。ID 與視窗綁定。匹配區分大小寫且為 magic 模式,除非在 {pattern} 中明確覆寫了大小寫敏感性或 magic 模式。 'magic''smartcase''ignorecase' 選項不會被使用。「Conceal」值是特殊的,它會導致匹配被隱藏。
可選的 {priority} 參數會為匹配指定優先順序。具有較高優先順序的匹配會覆蓋具有較低優先順序的匹配的突顯。優先順序指定為整數(負數也例外)。如果未指定 {priority} 參數,則預設優先順序為 10。 'hlsearch' 的優先順序為零,因此所有優先順序大於零的匹配都會覆蓋它。語法突顯(參閱 'syntax')是一種單獨的機制,無論選擇的優先順序為何,匹配始終會覆蓋語法突顯。
可選的 {id} 參數允許請求特定的匹配 ID。如果指定的 ID 已被使用,則會出現錯誤訊息,且不會新增匹配。ID 指定為正整數(排除零)。ID 1、2 和 3 分別保留給 :match:2match:3match。3 保留給 matchparen 外掛程式使用。如果未指定 {id} 參數或指定為 -1,則 matchadd() 會自動選擇一個可用的 ID,該 ID 至少為 1000。
可選的 {dict} 參數允許使用其他自訂值。目前,它用於指定一個匹配專用的隱藏字元,該字元將針對 hl-Conceal 突顯的匹配顯示。字典可以具有以下成員:
conceal 特殊字元,用於取代匹配顯示(僅適用於 hl-Conceal 突顯的匹配,請參閱 :syn-cchar) window 使用具有此數字或視窗 ID 的視窗,而不是目前視窗。
匹配的數量沒有限制,:match 命令就是這種情況。
發生錯誤時,返回 -1。
範例
highlight MyGroup ctermbg=green guibg=green
let m = matchadd("MyGroup", "TODO")
刪除模式
call matchdelete(m)
matchadd():match 定義的匹配清單可從 getmatches() 取得。可以使用 clearmatches() 在一個操作中刪除所有匹配。
參數
{group} (integer|string)
{pattern} (string)
{priority} (integer?)
{id} (integer?)
{dict} (string?)
回傳
(any)
matchaddpos({group}, {pos} [, {priority} [, {id} [, {dict}]]]) matchaddpos()matchadd() 相同,但需要一個位置清單 {pos} 而不是模式。此命令比 matchadd() 快,因為它不處理正規表示式,並且它會設定緩衝區行邊界以重新繪製畫面。當需要快速新增和刪除匹配時(例如,突顯匹配的括號)應使用此命令。E5030 E5031 {pos} 是一個位置清單。每個位置可以是下列其中一個:
數字。將突顯整行。第一行的編號為 1。
包含一個數字的清單,例如 [23]。將突顯具有此數字的整行。
包含兩個數字的清單,例如 [23, 11]。第一個數字是行號,第二個數字是欄號(第一欄是 1,該值必須對應於 col() 將傳回的位元組索引)。將突顯此位置的字元。
包含三個數字的清單,例如 [23, 11, 3]。如上所示,但第三個數字指定突顯的位元組長度。
將靜默忽略行號為零和負數的項目,以及欄號和長度為負數的項目。
發生錯誤時,返回 -1。
範例
highlight MyGroup ctermbg=green guibg=green
let m = matchaddpos("MyGroup", [[23, 24], 34])
刪除模式
call matchdelete(m)
matchaddpos() 新增的匹配會由 getmatches() 返回。
參數
{group} (integer|string)
{pos} (any[])
{priority} (integer?)
{id} (integer?)
{dict} (string?)
回傳
(any)
matcharg({nr}) matcharg()
選取使用 :match:2match:3match 命令設定的第 {nr} 個匹配項目。返回一個包含兩個元素的列表:使用的突顯群組的名稱,以及使用的模式。當 {nr} 不是 1、2 或 3 時,返回一個空的列表。當沒有設定匹配項目時,返回 ['','']。這有助於儲存和還原 :match。使用 :match 命令突顯匹配限制為三個匹配。matchadd() 沒有此限制。
參數
{nr} (integer)
回傳
(any)
matchbufline({buf}, {pat}, {lnum}, {end}, [, {dict}]) matchbufline()
傳回緩衝區 {buf} 中,從 {lnum}{end} 的行中,{pat} 匹配的匹配列表
{lnum}{end} 可以是行號,也可以是字串「$」以表示 {buf} 中的最後一行。
{dict} 參數支援下列項目: submatches 包含子匹配資訊 (/\()
對於每個匹配,會返回一個具有下列項目的 字典: byteidx 匹配的起始位元組索引 lnum 出現匹配的行號 text 匹配的字串 請注意,單行中可能有多個匹配。
此函式僅適用於已載入的緩衝區。如果需要,請先呼叫 bufload()
有關某些選項設定對模式的影響的資訊,請參閱 match-pattern
{buf} 不是有效的緩衝區、未載入緩衝區或 {lnum}{end} 無效時,則會發生錯誤並返回空的 列表
範例
" Assuming line 3 in buffer 5 contains "a"
echo matchbufline(5, '\<\k\+\>', 3, 3)
[{'lnum': 3, 'byteidx': 0, 'text': 'a'}]
" Assuming line 4 in buffer 10 contains "tik tok"
echo matchbufline(10, '\<\k\+\>', 1, 4)
[{'lnum': 4, 'byteidx': 0, 'text': 'tik'}, {'lnum': 4, 'byteidx': 4, 'text': 'tok'}]
如果存在 {submatch} 且為 v:true,則也會返回類似 "\1"、"\2" 等子匹配。範例
" Assuming line 2 in buffer 2 contains "acd"
echo matchbufline(2, '\(a\)\?\(b\)\?\(c\)\?\(.*\)', 2, 2
                            \ {'submatches': v:true})
[{'lnum': 2, 'byteidx': 0, 'text': 'acd', 'submatches': ['a', '', 'c', 'd', '', '', '', '', '']}] 「submatches」列表始終包含 9 個項目。如果找不到子匹配,則會為該子匹配返回一個空字串。
參數
{buf} (string|integer)
{pat} (string)
{lnum} (string|integer)
{end_} (string|integer)
{dict} (table?)
回傳
(any)
matchdelete({id} [, {win}]) matchdelete() E802 E803 刪除先前由 matchadd() 或其中一個 :match 命令定義的 ID 為 {id} 的匹配。如果成功,則返回 0,否則返回 -1。請參閱 matchadd() 的範例。可以使用 clearmatches() 在一個操作中刪除所有匹配。如果指定了 {win},則使用具有此數字或視窗 ID 的視窗,而不是目前視窗。
參數
{id} (integer)
{win} (integer?)
回傳
(any)
matchend({expr}, {pat} [, {start} [, {count}]]) matchend()
match() 相同,但返回匹配後第一個字元的索引。範例
echo matchend("testing", "ing")
結果為「7」。 strspn() strcspn() Vim 沒有 strspn() 或 strcspn() 函式,但可以使用 matchend() 來執行此操作
let span = matchend(line, '[a-zA-Z]')
let span = matchend(line, '[^a-zA-Z]')
除非沒有匹配時返回 -1。
如果給定 {start},則其含義與 match() 相同。
echo matchend("testing", "ing", 2)
結果為「7」。
echo matchend("testing", "ing", 5)
結果為「-1」。當 {expr}列表 時,結果等於 match()
參數
{expr} (任意)
{pat} (string)
{start} (整數?)
{count} (integer?)
回傳
(any)
matchfuzzy({list}, {str} [, {dict}]) matchfuzzy()
如果 {list} 是字串列表,則會返回一個包含 {list} 中與 {str} 模糊匹配的所有字串的 列表。返回的列表中的字串會根據匹配分數排序。
可選的 {dict} 參數始終支援下列項目: matchseq 當此項目存在時,僅返回包含 {str} 中給定序列的字元的匹配。 limit 要返回的 {list} 中的最大匹配數。零表示沒有限制。
如果 {list} 是字典列表,則可選的 {dict} 參數支援下列其他項目: key 與 {str} 模糊匹配的項目索引鍵。此項目的值應為字串。 text_cb Funcref,將針對 {list} 中的每個項目呼叫,以取得模糊匹配的文字。這應接受字典項目作為參數,並返回該項目用於模糊匹配的文字。
{str} 會被視為字面字串,不支援正規表達式比對。{str} 支援的最大長度為 256。
{str} 包含多個以空白分隔的單字時,會回傳包含所有這些單字的字串列表。
如果沒有符合的字串或發生錯誤,則會回傳一個空列表。如果 {str} 的長度大於 256,則會回傳一個空列表。
當指定 {limit} 時,matchfuzzy() 將會在 {list} 中尋找最多此數量的相符項目,並以排序順序回傳。
請參閱 模糊比對 以取得更多關於模糊比對字串的資訊。
範例
echo matchfuzzy(["clay", "crow"], "cay")
結果為 ["clay"]。
echo getbufinfo()->map({_, v -> v.name})->matchfuzzy("ndl")
結果為一個模糊比對 "ndl" 的緩衝區名稱列表。
echo getbufinfo()->matchfuzzy("ndl", {'key' : 'name'})
結果為一個模糊比對 "ndl" 的緩衝區資訊字典列表,其中包含緩衝區名稱。
echo getbufinfo()->matchfuzzy("spl",
                             \ {'text_cb' : {v -> v.name}})
結果為一個模糊比對 "spl" 的緩衝區資訊字典列表,其中包含緩衝區名稱。
echo v:oldfiles->matchfuzzy("test")
結果為一個模糊比對 "test" 的檔案名稱列表。
let l = readfile("buffer.c")->matchfuzzy("str")
結果為 "buffer.c" 中模糊比對 "str" 的行列表。
echo ['one two', 'two one']->matchfuzzy('two one')
結果為 ['two one', 'one two']
echo ['one two', 'two one']->matchfuzzy('two one',
                             \ {'matchseq': 1})
結果為 ['two one']
參數
{list} (any[])
{str} (string)
{dict} (string?)
回傳
(any)
matchfuzzypos({list}, {str} [, {dict}]) matchfuzzypos()
matchfuzzy() 相同,但回傳相符字串的列表、{str} 中字元相符的位置列表,以及比對分數的列表。您可以使用 byteidx() 將字元位置轉換為位元組位置。
如果 {str} 在一個字串中多次比對成功,則只會回傳最佳比對的位置。
如果沒有符合的字串或發生錯誤,則會回傳一個包含三個空列表項目的列表。
範例
echo matchfuzzypos(['testing'], 'tsg')
結果為 [["testing"], [[0, 2, 6]], [99]]
echo matchfuzzypos(['clay', 'lacy'], 'la')
結果為 [["lacy", "clay"], [[0, 1], [1, 2]], [153, 133]]
echo [{'text': 'hello', 'id' : 10}]
        \ ->matchfuzzypos('ll', {'key' : 'text'})
結果為 [[{"id": 10, "text": "hello"}], [[2, 3]], [127]]
參數
{list} (any[])
{str} (string)
{dict} (string?)
回傳
(any)
matchlist({expr}, {pat} [, {start} [, {count}]]) matchlist()
match() 相同,但回傳一個 列表。列表中的第一個項目是相符的字串,與 matchstr() 會回傳的相同。後續項目是子比對,例如 :substitute 中的 "\1"、"\2" 等。當一個可選的子比對沒有比對到時,會使用一個空字串。範例
echo matchlist('acd', '\(a\)\?\(b\)\?\(c\)\?\(.*\)')
結果為:['acd', 'a', '', 'c', 'd', '', '', '', '', ''] 當沒有比對時,會回傳一個空列表。
您可以傳入一個列表,但這不是很有用。
參數
{expr} (任意)
{pat} (string)
{start} (整數?)
{count} (integer?)
回傳
(any)
matchstr({expr}, {pat} [, {start} [, {count}]]) matchstr()
match() 相同,但回傳相符的字串。範例
echo matchstr("testing", "ing")
結果為 "ing"。當沒有比對時,會回傳 ""。如果指定了 {start},其含義與 match() 相同。
echo matchstr("testing", "ing", 2)
結果為 "ing"。
echo matchstr("testing", "ing", 5)
結果為 ""。當 {expr}列表 時,會回傳相符的項目。類型不會變更,不一定是字串。
參數
{expr} (任意)
{pat} (string)
{start} (整數?)
{count} (integer?)
回傳
(any)
matchstrlist({list}, {pat} [, {dict}]) matchstrlist()
回傳 {list} 中與 {pat} 相符的項目 列表{list} 是字串的 列表{pat} 會與 {list} 中的每個字串進行比對。
{dict} 參數支援下列項目: submatches 包含子匹配資訊 (/\()
對於每個比對,會回傳一個包含以下項目的 字典:byteidx:比對開始的位元組索引。idx:比對在 {list} 中的索引。text:相符的字串。submatches:子比對的列表。只有在 {dict} 中將 "submatches" 設定為 v:true 時才會出現。
有關某些選項設定對模式的影響的資訊,請參閱 match-pattern
範例
echo matchstrlist(['tik tok'], '\<\k\+\>')
[{'idx': 0, 'byteidx': 0, 'text': 'tik'}, {'idx': 0, 'byteidx': 4, 'text': 'tok'}]
echo matchstrlist(['a', 'b'], '\<\k\+\>')
[{'idx': 0, 'byteidx': 0, 'text': 'a'}, {'idx': 1, 'byteidx': 0, 'text': 'b'}]
如果存在 "submatches" 且為 v:true,則也會回傳子比對,例如 "\1"、"\2" 等。範例
echo matchstrlist(['acd'], '\(a\)\?\(b\)\?\(c\)\?\(.*\)',
                            \ #{submatches: v:true})
[{'idx': 0, 'byteidx': 0, 'text': 'acd', 'submatches': ['a', '', 'c', 'd', '', '', '', '', '']}] "submatches" 列表始終包含 9 個項目。如果找不到子比對,則該子比對會回傳一個空字串。
參數
{list} (string[])
{pat} (string)
{dict} (table?)
回傳
(any)
matchstrpos({expr}, {pat} [, {start} [, {count}]]) matchstrpos()
matchstr() 相同,但回傳相符的字串、比對的起始位置和結束位置。範例
echo matchstrpos("testing", "ing")
結果為 ["ing", 4, 7]。當沒有比對時,會回傳 ["", -1, -1]。如果指定了 {start},其含義與 match() 相同。
echo matchstrpos("testing", "ing", 2)
結果為 ["ing", 4, 7]。
echo matchstrpos("testing", "ing", 5)
結果為 ["", -1, -1]。當 {expr}列表 時,會回傳相符的項目、{pat} 比對成功的第一個項目的索引、起始位置和結束位置。
echo matchstrpos([1, '__x'], '\a')
結果為 ["x", 1, 2, 3]。類型不會變更,不一定是字串。
參數
{expr} (任意)
{pat} (string)
{start} (整數?)
{count} (integer?)
回傳
(any)
max({expr}) max()
回傳 {expr} 中所有項目的最大值。範例
echo max([apples, pears, oranges])
{expr} 可以是 列表字典。對於字典,它會回傳字典中所有值的最大值。如果 {expr} 既不是列表也不是字典,或者 {expr} 中的其中一個項目不能用作數字,則會導致錯誤。空的 列表字典 會導致零。
參數
{expr} (任意)
回傳
(any)
menu_get({path} [, {modes}]) menu_get()
回傳一個 列表,其中包含描述 選單(由 :menu:amenu 等定義),包括 隱藏選單字典
{path} 會根據名稱比對選單,如果 {path} 為空字串,則會比對所有選單。範例
echo menu_get('File','')
echo menu_get('')
{modes} 是由零或多個模式組成的字串(請參閱 maparg()建立選單 以取得模式列表)。"a" 表示「全部」。
範例
nnoremenu &Test.Test inormal
inoremenu Test.Test insert
vnoremenu Test.Test x
echo menu_get("")
會回傳類似以下內容
[ {
  "hidden": 0,
  "name": "Test",
  "priority": 500,
  "shortcut": 84,
  "submenus": [ {
    "hidden": 0,
    "mappings": {
      i": {
        "enabled": 1,
        "noremap": 1,
        "rhs": "insert",
        "sid": 1,
        "silent": 0
      },
      n": { ... },
      s": { ... },
      v": { ... }
    },
    "name": "Test",
    "priority": 500,
    "shortcut": 0
  } ]
} ]
參數
{path} (string)
{modes} (string?)
回傳
(any)
menu_info({name} [, {mode}]) menu_info()
回傳關於模式 {mode} 中指定的選單 {name} 的資訊。選單名稱應指定,但不含快捷鍵字元 ('&')。如果 {name} 為 "",則會回傳頂層選單名稱。
{mode} 可以是以下字串之一:"n" 普通模式 "v" 視覺模式(包括選取模式) "o" 操作符等待模式 "i" 插入模式 "c" 命令列模式 "s" 選取模式 "x" 視覺模式 "t" 終端機作業模式 "" 普通、視覺和操作符等待模式 "!" 插入和命令列模式。當省略 {mode} 時,會使用 "" 的模式。
回傳一個包含以下項目的 字典:accel:選單項目的加速鍵文字。 選單文字 display:顯示名稱(不含 '&' 的名稱)。enabled:如果此選單項目已啟用,則為 v:true。請參閱 :menu-enable。icon:圖示檔案的名稱(用於工具列)。 工具列圖示 iconidx:內建圖示的索引。modes:定義選單的模式。除了上述模式外,還會使用以下字元:" " 普通、視覺和操作符等待模式。name:選單項目名稱。noremenu:如果選單項目的 {rhs} 不可重新對應,則為 v:true,否則為 v:false。priority:選單順序優先級。 選單優先級。rhs:選單項目的右手側。回傳的字串已轉換特殊字元,如 ":menu" 命令清單的輸出。當選單項目的 {rhs} 為空時,則回傳 "<Nop>"。script:如果允許對 {rhs} 進行腳本本地重新對應,則為 v:true,否則為 v:false。請參閱 :menu-script。shortcut:快捷鍵(選單名稱中 '&' 之後的字元)。 選單快捷鍵 silent:如果選單項目是以 <silent> 引數建立,則為 v:true。 :menu-silent。submenus:包含所有子選單名稱的 列表。僅當選單項目有子選單時才會出現。
如果找不到選單項目,則會回傳一個空字典。
範例
echo menu_info('Edit.Cut')
echo menu_info('File.Save', 'n')
" Display the entire menu hierarchy in a buffer
func ShowMenu(name, pfx)
  let m = menu_info(a:name)
  call append(line('$'), a:pfx .. m.display)
  for child in m->get('submenus', [])
    call ShowMenu(a:name .. '.' .. escape(child, '.'),
                                \ a:pfx .. '    ')
  endfor
endfunc
new
for topmenu in menu_info('').submenus
  call ShowMenu(topmenu, '')
endfor
參數
{name} (string)
{mode} (string?)
回傳
(any)
min({expr}) min()
回傳 {expr} 中所有項目的最小值。範例
echo min([apples, pears, oranges])
{expr} 可以是 列表字典。對於字典,它會回傳字典中所有值的最小值。如果 {expr} 既不是列表也不是字典,或者 {expr} 中的其中一個項目不能用作數字,則會導致錯誤。空的 列表字典 會導致零。
參數
{expr} (任意)
回傳
(any)
mkdir({name} [, {flags} [, {prot}]]) mkdir() E739 建立目錄 {name}
當存在 {flags} 時,它必須是一個字串。空字串沒有任何作用。
{flags} 可以包含以下字元標記:"p":將根據需要建立中間目錄。"D":{name} 將在目前函式結束時刪除,但不會遞迴刪除。 :defer "R":{name} 將在目前函式結束時遞迴刪除。 :defer
請注意,當 {name} 有多個部分且使用 "p" 時,某些目錄可能已經存在。只會排定要刪除第一個建立的目錄及其內容。例如,當使用
call mkdir('subdir/tmp/autoload', 'pR')
且 "subdir" 已經存在時,則會排定刪除 "subdir/tmp",如同使用
defer delete('subdir/tmp', 'rf')
如果指定了 {prot},則會用來設定新目錄的保護位元。預設值為 0o755 (rwxr-xr-x:使用者可讀寫,其他人可讀)。使用 0o700 可使其對其他人不可讀。
{prot} 會套用到 {name} 的所有部分。因此,如果您建立 /tmp/foo/bar,則 /tmp/foo 會以 0o700 建立。範例
call mkdir($HOME .. "/tmp/foo/bar", "p", 0o700)
此函數在 沙箱中不可用。
如果您嘗試建立一個已存在的目錄,且將 {flags} 設定為 "p",則 mkdir() 會靜默結束。
函式結果為數值,若呼叫成功則為 TRUE,若目錄建立失敗或部分失敗則為 FALSE。
參數
{name} (string)
{flags} (字串?)
{prot} (string?)
回傳
(any)
mode([{expr}]) mode()
傳回一個字串,指示目前模式。如果提供了 {expr} 且其評估結果為非零數值或非空字串 (non-zero-arg),則傳回完整模式,否則僅傳回第一個字母。另請參閱 state()
n 一般模式 no 等待運算子 nov 等待運算子 (強制字元式 o_v) noV 等待運算子 (強制行式 o_V) noCTRL-V 等待運算子 (強制區塊式 o_CTRL-V) CTRL-V 為單一字元 niI 在插入模式中使用 i_CTRL-O 的一般模式 niR 在取代模式中使用 i_CTRL-O 的一般模式 niV 在虛擬取代模式中使用 i_CTRL-O 的一般模式 nt 在 終端模擬器中的一般模式 (插入模式會進入終端模式) ntT 在 終端模式中使用 t_CTRL-\_CTRL-O 的一般模式 v 字元可視模式 vs 在選取模式中使用 v_CTRL-O 的字元可視模式 V 行可視模式 Vs 在選取模式中使用 v_CTRL-O 的行可視模式 CTRL-V 區塊可視模式 CTRL-Vs 在選取模式中使用 v_CTRL-O 的區塊可視模式 s 字元選取模式 S 行選取模式 CTRL-S 區塊選取模式 i 插入模式 ic 插入模式完成 compl-generic ix 插入模式 i_CTRL-X 完成 R 取代模式 R Rc 取代模式完成 compl-generic Rx 取代模式 i_CTRL-X 完成 Rv 虛擬取代 gR Rvc 虛擬取代模式完成 compl-generic Rvx 虛擬取代模式 i_CTRL-X 完成 c 命令列編輯 cr 命令列編輯覆蓋模式 c_<Insert> cv Vim Ex 模式 gQ cvr 覆蓋模式下的 Vim Ex 模式 c_<Insert> r 按 Enter 提示 rm -- 更多 -- 提示 r? 某種 :confirm 查詢 ! Shell 或外部命令正在執行 t 終端模式:按鍵傳送至工作
這在 'statusline' 選項或 RPC 呼叫中很有用。在大多數其他地方,它總是傳回 "c" 或 "n"。請注意,未來可能會加入更多模式和更具體的模式。最好不要比較整個字串,而僅比較前導字元。另請參閱 visualmode()
參數
{expr} (any?)
回傳
(any)
msgpackdump({list} [, {type}]) msgpackdump()
將 Vimscript 物件列表轉換為 msgpack。傳回值是一個 readfile() 樣式的列表。當 {type} 包含 "B" 時,則傳回 Blob。範例
call writefile(msgpackdump([{}]), 'fname.mpack', 'b')
或者,使用 Blob
call writefile(msgpackdump([{}], 'B'), 'fname.mpack')
這會將單個 0x80 位元組寫入 `fname.mpack` 檔案(具有零個項目的字典在 messagepack 中由 0x80 位元組表示)。
限制:E5004 E5005 1. 無法轉儲 Funcref。2. 無法轉儲引用自身的容器。3. 字典鍵始終轉儲為 STR 字串。4. 其他字串和 Blob 始終轉儲為 BIN 字串。5. 點 3 和 4 不適用於 msgpack-special-dict
參數
{list} (any)
{type} (any?)
回傳
(any)
msgpackparse({data}) msgpackparse()
readfile() 樣式的列表或 Blob 轉換為 Vimscript 物件列表。範例
let fname = expand('~/.config/nvim/shada/main.shada')
let mpack = readfile(fname, 'b')
let shada_objects = msgpackparse(mpack)
這會將 ~/.config/nvim/shada/main.shada 檔案讀取到 `shada_objects` 列表中。
限制:1. 除非使用泛型映射 (msgpack-special-map) 轉儲 messagepack 映射,否則不會保留映射順序。2. 由於剖析器旨在保留所有未變動的資料(除了 1.),因此某些字串會剖析為 msgpack-special-dict 格式,這不方便使用。 msgpack-special-dict
某些 messagepack 字串可能會剖析為特殊字典。特殊字典是字典,其
1. 精確包含兩個鍵:`_TYPE` 和 `_VAL`。2. `_TYPE` 鍵是 v:msgpack_types 變數中找到的其中一種型別。3. `_VAL` 的值具有以下格式 (索引鍵欄包含 v:msgpack_types 中索引鍵的名稱)
鍵 值
nil 零,轉儲時忽略。由於引入了 v:null,因此不會由 msgpackparse() 傳回。boolean 一或零。轉儲時,僅檢查值是否為 Number。由於引入了 v:truev:false,因此不會由 msgpackparse() 傳回。integer 具有四個數字的 List:符號 (-1 或 1)、最高兩個位元、具有第 62 位元到第 31 位元的數字、最低 31 位元。即,為了取得實際數字,將需要使用類似以下的程式碼
_VAL[0] * ((_VAL[1] << 62)
           & (_VAL[2] << 31)
           & _VAL[3])
具有此型別的特殊字典將在以下其中一種情況下出現在 msgpackparse() 輸出中:1. Number 是 32 位元,且值高於 INT32_MAX 或低於 INT32_MIN。2. Number 是 64 位元,且值高於 INT64_MAX。它不可能低於 INT64_MIN,因為 msgpack C 剖析器不支援此類值。float Float。此值不可能出現在 msgpackparse() 輸出中。string String,或如果二進位字串包含零位元組,則為 Blob。由於引入了 blob,此值不可能出現在 msgpackparse() 輸出中。array List。此值不可能出現在 msgpackparse() 輸出中。 msgpack-special-map
map 具有兩個項目 (索引鍵和值) 的 ListList。如果剖析的映射包含下列其中一個索引鍵,則此值將出現在 msgpackparse() 輸出中:1. 任何不是字串的索引鍵 (包括二進位字串)。2. 內部有 NUL 位元組的字串。3. 重複的索引鍵。ext 具有兩個值的 List:第一個是表示擴充型別的帶正負號的整數。第二個是 readfile() 樣式的字串列表。
參數
{data} (any)
回傳
(any)
nextnonblank({lnum}) nextnonblank()
傳回等於或低於 {lnum} 的第一個非空白行的行號。範例
if getline(nextnonblank(1)) =~ "Java" | endif
{lnum} 無效或等於或低於它的位置沒有非空白行時,則傳回零。{lnum} 的使用方式與 getline() 相同。另請參閱 prevnonblank()
參數
{lnum} (整數)
回傳
(any)
nr2char({expr} [, {utf8}]) nr2char()
傳回具有單一字元的字串,其數值為 {expr}。範例
echo nr2char(64)                " returns '@'
echo nr2char(32)                " returns ' '
"utf-8" 的範例
echo nr2char(300)                " returns I with bow character
始終使用 UTF-8 編碼,{utf8} 選項無效,且僅為了回溯相容性而存在。請注意,檔案中的 NUL 字元使用 nr2char(10) 指定,因為 NUL 以換行字元表示。nr2char(0) 是真正的 NUL,並終止字串,因此會產生空字串。
參數
{expr} (integer)
{utf8} (boolean?)
回傳
(any)
nvim_...({...}) nvim_...() E5555 eval-api 呼叫 nvim api 函式。引數的型別檢查將比大多數其他內建函式更嚴格。例如,如果預期為整數,則必須傳入 Number,而不會自動轉換 String。由 bufnr() 傳回的緩衝區號碼可用作 nvim_buf_... 函式的第一個引數。所有預期物件 (緩衝區、視窗或索引標籤頁面) 的函式也可以採用數值 0 來表示目前 (焦點) 物件。
參數
{...} (any)
回傳
(any)
or({expr}, {expr}) or()
對兩個引數執行位元 OR 運算。引數會轉換為數字。清單、字典或浮點引數會導致錯誤。另請參閱 `and()` 和 `xor()`。範例
let bits = or(bits, 0x80)
原理:這是一個函式而不是像許多語言一樣使用 "|" 字元的原因是,Vi 一直使用 "|" 來分隔命令。在許多地方,如果不清楚 "|" 是運算子還是命令分隔符號。
參數
{expr} (數字)
{expr1} (數字)
回傳
(any)
pathshorten({path} [, {len}]) pathshorten()
縮短路徑 {path} 中的目錄名稱,並傳回結果。尾部 (檔案名稱) 會保持不變。路徑中的其他元件縮減為 {len} 個字母的長度。如果省略 {len} 或小於 1,則會使用 1(單個字母)。前導的 '~' 和 '.' 字元會保留。範例
echo pathshorten('~/.config/nvim/autoload/file1.vim')
~/.c/n/a/file1.vim
echo pathshorten('~/.config/nvim/autoload/file2.vim', 2)
~/.co/nv/au/file2.vim
路徑是否存在並不重要。發生錯誤時傳回空字串。
參數
{path} (string)
{len} (integer?)
回傳
(any)
perleval({expr}) perleval()
評估 perl 運算式 {expr} 並傳回其轉換為 Vim 資料結構的結果。數字和字串會原樣傳回 (字串會複製)。清單會以 Vim List 型別表示。字典會以 Vim Dictionary 型別表示,非字串索引鍵會導致錯誤。
注意:如果您想要陣列或雜湊,{expr} 必須傳回對它的參考。範例
echo perleval('[1 .. 4]')
[1, 2, 3, 4]
參數
{expr} (任意)
回傳
(any)
pow({x}, {y}) pow()
傳回 {x} 對指數 {y} 的次方,作為 Float{x}{y} 必須評估為 FloatNumber。如果 {x}{y} 不是 FloatNumber,則傳回 0.0。範例
echo pow(3, 3)
27.0
echo pow(2, 16)
65536.0
echo pow(32, 0.20)
2.0
參數
{x} (number)
{y} (number)
回傳
(any)
prevnonblank({lnum}) prevnonblank()
傳回大於等於 {lnum} 的第一個非空白行的行號。範例:
let ind = indent(prevnonblank(v:lnum - 1))
{lnum} 無效,或者在其之上沒有非空白行時,傳回零。{lnum} 的使用方式與 getline() 相同。另請參閱 nextnonblank()
參數
{lnum} (整數)
回傳
(any)
printf({fmt}, {expr1} ...) printf()
傳回一個字串,其中 {fmt} 中的 "%" 項目會被格式化後的對應參數取代。範例:
echo printf("%4d: E%d %.30s", lnum, errno, msg)
可能會產生:
" 99: E42 asdfasdfasdfasdfasdfasdfasdf"
當用作 方法 時,基礎會作為第二個參數傳遞。
Compute()->printf("result: %d")
您可以使用 call() 將項目作為列表傳遞。
常用的項目有: %s 字串 %6S 字串在 6 個顯示儲存格中靠右對齊 %6s 字串在 6 個位元組中靠右對齊 %.9s 字串截斷為 9 個位元組 %c 單一位元組 %d 十進位數字 %5d 十進位數字,以空格填充至 5 個字元 %b 二進位數字 %08b 二進位數字,以零填充至至少 8 個字元 %B 使用大寫字母的二進位數字 %x 十六進位數字 %04x 十六進位數字,以零填充至至少 4 個字元 %X 使用大寫字母的十六進位數字 %o 八進位數字 %f 浮點數,格式為 12.23、inf、-inf 或 nan %F 浮點數,格式為 12.23、INF、-INF 或 NAN %e 浮點數,格式為 1.23e3、inf、-inf 或 nan %E 浮點數,格式為 1.23E3、INF、-INF 或 NAN %g 浮點數,根據值使用 %f 或 %e %G 浮點數,根據值使用 %F 或 %E %% % 字元本身 %p 指向容器的指標表示法
轉換規格以 '%' 開頭,並以轉換類型結尾。所有其他字元都會原封不動地複製到結果中。
"%" 開啟一個轉換規格。以下參數會依序出現:
% [pos-argument] [flags] [field-width] [.precision] type
pos-argument 最多一個位置參數指定符。它們的形式為 {n$},其中 n >= 1。
flags 零個或多個以下旗標:
# 值應轉換為「替代形式」。對於 c、d 和 s 轉換,此選項無效。對於 o 轉換,會增加數字的精確度,以強制輸出字串的第一個字元為零(除非使用明確的零精確度列印零值)。對於 x 和 X 轉換,非零結果會在前面加上字串 "0x"(或 X 轉換的 "0X")。
0 (零) 零填充。對於所有轉換,轉換後的值會在左邊填充零而不是空格。如果數字轉換 (d、o、x 和 X) 指定了精確度,則會忽略 0 旗標。
- 負欄位寬度旗標;轉換後的值會在欄位邊界上靠左對齊。轉換後的值會在右邊填充空格,而不是在左邊填充空格或零。如果同時給定 - 和 0,則 - 會覆蓋 0。
' ' (空格) 在有符號轉換 (d) 產生的正數之前應保留空格。
+ 符號必須始終放在有符號轉換產生的數字之前。如果同時使用 + 和空格,則 + 會覆蓋空格。
field-width 一個可選的十進位數字字串,指定最小欄位寬度。如果轉換後的值的位元組數少於欄位寬度,則會在左邊(或右邊,如果已給定左對齊旗標)填充空格,以填滿欄位寬度。對於 S 轉換,計數單位為儲存格。
.precision 一個可選的精確度,格式為句點 '.' 後面跟著一個可選的數字字串。如果省略數字字串,則將精確度視為零。這會給出 d、o、x 和 X 轉換要顯示的最小位數、s 轉換要從字串列印的最大位元組數,或 S 轉換要從字串列印的最大儲存格數。對於浮點數,它是小數點後的位數。
type 一個字元,指定要套用的轉換類型,請參閱下方。
欄位寬度或精確度,或兩者都可以使用星號 "*" 而不是數字字串來表示。在這種情況下,Number 參數會提供欄位寬度或精確度。負欄位寬度會被視為左對齊旗標,後跟正欄位寬度;負精確度會被視為遺失。範例:
echo printf("%d: %.*s", nr, width, line)
這會將 "line" 中使用的文字長度限制為 "width" 位元組。
如果要格式化的參數是使用位置參數指定符指定的,並且使用 '*' 來表示要使用數字參數來指定寬度或精確度,則要使用的參數也必須使用 {n$} 位置參數指定符來指定。請參閱 printf-$
轉換指定符及其含義如下:
printf-d printf-b printf-B printf-o printf-x printf-X dbBoxX Number 參數會轉換為有符號十進位 (d)、無符號二進位 (b 和 B)、無符號八進位 (o) 或無符號十六進位 (x 和 X) 記數法。字母 "abcdef" 用於 x 轉換;字母 "ABCDEF" 用於 X 轉換。精確度(如果有的話)會給出必須出現的最小位數;如果轉換後的值需要的位數較少,則會在左邊填充零。在任何情況下,不存在或小的欄位寬度都不會導致數值欄位截斷;如果轉換的結果寬於欄位寬度,則會擴展欄位以包含轉換結果。修飾符 'h' 表示參數為 16 位元。修飾符 'l' 表示參數為長整數。大小將為 32 位元或 64 位元,取決於您的平台。"ll" 修飾符表示參數為 64 位元。b 和 B 轉換指定符永遠不會採用寬度修飾符,並且始終假設其參數為 64 位元整數。一般而言,這些修飾符沒有用處。當從參數得知類型時,它們會被忽略。
i 為 d 的別名 D 為 ld 的別名 U 為 lu 的別名 O 為 lo 的別名
printf-c
c Number 參數會轉換為一個位元組,並寫入結果字元。
printf-s
s 會使用 String 參數的文字。如果指定了精確度,則不會使用超過指定數量的位元組。如果參數不是 String 類型,則會以與 ":echo" 相同的格式自動轉換為文字。printf-S
S 會使用 String 參數的文字。如果指定了精確度,則不會使用超過指定數量的顯示儲存格。
printf-f E807 f F Float 參數會轉換為 123.456 形式的字串。精確度會指定小數點後的位數。當精確度為零時,會省略小數點。當未指定精確度時,會使用 6。非常大的數字(超出範圍或除以零)會產生 "inf" 或 "-inf"(使用 %f 時)(使用 %F 時則為 INF 或 -INF)。 "0.0 / 0.0" 會產生 "nan"(使用 %f 時)(使用 %F 時則為 NAN)。範例:
echo printf("%.2f", 12.115)
12.12 請注意,四捨五入取決於系統函式庫。如有疑問,請使用 round()
printf-e printf-E e E Float 參數會轉換為 1.234e+03 或 1.234E+03 形式的字串,當使用 'E' 時。精確度會指定小數點後的位數,與 'f' 相同。
printf-g printf-G g G 如果值介於 0.001(含)和 10000000.0(不含)之間,則會像使用 'f' 一樣轉換 Float 參數。否則,'g' 會使用 'e',而 'G' 會使用 'E'。當未指定精確度時,會移除多餘的零和 '+' 符號,除了小數點後緊接著的零以外。因此,10000000.0 會產生 1.0e7。
printf-%
% 會寫入 '%'。不會轉換任何參數。完整的轉換規格為 "%%"。
當預期 Number 參數時,也會接受 String 參數並自動轉換。當預期 Float 或 String 參數時,也會接受 Number 參數並自動轉換。任何其他參數類型都會導致錯誤訊息。
E766 E767 {exprN} 參數的數量必須與 "%" 項目完全匹配。如果參數不足或太多,則會給出錯誤。最多可以使用 18 個參數。
printf-$
在某些語言中,當單字的順序與英文中的對應訊息不同時,錯誤和資訊訊息會更易於閱讀。為了適應具有不同單字順序的翻譯,可以使用位置參數來表示這一點。例如:
#, c-format
msgid "%s returning %s"
msgstr "waarde %2$s komt terug van %1$s"
在此範例中,句子中的 2 個字串參數在輸出中會反轉。
echo printf(
    "In The Netherlands, vim's creator's name is: %1$s %2$s",
    "Bram", "Moolenaar")
在荷蘭,vim 的建立者名稱為:Bram Moolenaar
echo printf(
    "In Belgium, vim's creator's name is: %2$s %1$s",
    "Bram", "Moolenaar")
在比利時,vim 的建立者名稱為:Moolenaar Bram
寬度(和精確度)可以使用 '*' 指定符來指定。在這種情況下,您必須在參數列表中指定欄位寬度位置。
echo printf("%1$*2$.*3$d", 1, 2, 3)
001
echo printf("%2$*3$.*1$d", 1, 2, 3)
2
echo printf("%3$*1$.*2$d", 1, 2, 3)
03
echo printf("%1$*2$.*3$g", 1.4142, 2, 3)
1.414
您可以混合使用直接指定寬度和/或精確度以及透過位置參數指定的方式
echo printf("%1$4.*2$f", 1.4142135, 6)
1.414214
echo printf("%1$*2$.4f", 1.4142135, 6)
1.4142
echo printf("%1$*2$.*3$f", 1.4142135, 6, 2)
1.41
當欄位寬度或精確度導致字串長度超過 6400 個字元時,您會收到溢位錯誤 E1510
E1500
您不能混合使用位置參數和非位置參數
echo printf("%s%1$s", "One", "Two")
E1500:無法混合使用位置參數和非位置參數:%s%1$s
E1501
您不能在格式字串中跳過位置參數
echo printf("%3$s%1$s", "One", "Two", "Three")
E1501:格式參數 2 在 $-style 格式中未使用:%3$s%1$s
E1502
您可以重複使用 [欄位寬度](或 [精確度])參數
echo printf("%1$d at width %2$d is: %01$*2$d", 1, 2)
寬度 2 時的 1 為:01
但是,您不能將其用作不同的類型
echo printf("%1$d at width %2$ld is: %01$*2$d", 1, 2)
E1502:位置參數 2 用作欄位寬度,並重複用作不同的類型:long int/int
E1503
當使用位置參數,但未提供正確的參數數量時,會引發錯誤
echo printf("%1$d at width %2$d is: %01$*2$.*3$d", 1, 2)
E1503:位置參數 3 超出範圍:%1$d 在寬度 %2$d 時為:%01$*2$.*3$d
僅回報第一個錯誤
echo printf("%01$*2$.*3$d %4$d", 1, 2)
E1503:位置參數 3 超出範圍:%01$*2$.*3$d %4$d
E1504
一個位置參數可以使用多次
echo printf("%1$s %2$s %1$s", "One", "Two")
一 二 一
但是,您不能第二次使用不同的類型
echo printf("%1$s %2$s %1$d", "One", "Two")
E1504:位置參數 1 類型使用不一致:int/string
E1505
導致格式字串格式錯誤的各種其他錯誤會導致
echo printf("%1$d at width %2$d is: %01$*2$.3$d", 1, 2)
E1505:無效的格式指定符:%1$d 在寬度 %2$d 時為:%01$*2$.3$d
E1507
此內部錯誤表示用來解析位置格式參數的邏輯遇到了其他無法回報的問題。如果您遇到此情況,請向 Vim 提交錯誤報告,並複製使用的確切格式字串和參數。
參數
{fmt} (string)
{expr1} (any?)
回傳
(string)
prompt_getprompt({buf}) prompt_getprompt()
傳回緩衝區 {buf} 的有效提示文字。{buf} 可以是緩衝區名稱或編號。請參閱 prompt-buffer
如果緩衝區不存在或不是提示緩衝區,則會返回空字串。
參數
{buf} (整數|字串)
回傳
(any)
prompt_setcallback({buf}, {expr}) prompt_setcallback()
將緩衝區 {buf} 的提示回呼函數設定為 {expr}。當 {expr} 為空字串時,則會移除回呼函數。這只有在 {buf}'buftype' 設定為 "prompt" 時才會生效。
當按下 Enter 鍵時,會調用此回呼函數。目前的緩衝區將永遠是提示緩衝區。在調用回呼函數之前,會為提示添加一個新行,因此調用回呼函數的提示將位於倒數第二行。如果回呼函數想要在緩衝區中添加文字,則必須將其插入到最後一行之上,因為那是目前提示所在的位置。這也可以非同步完成。調用回呼函數時,會帶有一個參數,即在提示中輸入的文字。如果使用者僅輸入 Enter 鍵,則此參數可以為空字串。範例
   func s:TextEntered(text)
     if a:text == 'exit' || a:text == 'quit'
       stopinsert
       " Reset 'modified' to allow the buffer to be closed.
       " We assume there is nothing useful to be saved.
       set nomodified
       close
     else
       " Do something useful with "a:text".  In this example
       " we just repeat it.
       call append(line('$') - 1, 'Entered: "' .. a:text .. '"')
     endif
   endfunc
   call prompt_setcallback(bufnr(), function('s:TextEntered'))
Parameters: ~
  • {buf} (`integer|string`)
  • {expr} (`string|function`)
Return: ~
  (`any`)
prompt_setinterrupt({buf}, {expr}) prompt_setinterrupt()
將緩衝區 {buf} 的回呼函數設定為 {expr}。當 {expr} 為空字串時,則會移除回呼函數。這只有在 {buf}'buftype' 設定為 "prompt" 時才會生效。
當在插入模式下按下 CTRL-C 時,會調用此回呼函數。如果沒有設定回呼函數,Vim 將會像在任何緩衝區中一樣退出插入模式。
參數
{buf} (整數|字串)
{expr} (string|function)
回傳
(any)
prompt_setprompt({buf}, {text}) prompt_setprompt()
將緩衝區 {buf} 的提示設定為 {text}。您很可能希望 {text} 以空格結尾。只有在 {buf}'buftype' 設定為 "prompt" 時,結果才會可見。範例
call prompt_setprompt(bufnr(''), 'command: ')
參數
{buf} (整數|字串)
{text} (字串)
回傳
(any)
pum_getpos() pum_getpos()
如果彈出式選單(請參閱 ins-completion-menu)不可見,則會返回一個空的 Dictionary,否則,會返回一個具有以下鍵的 Dictionary: height 可見項目數量 width 螢幕單元格 row 頂部螢幕列(0 為第一列) col 最左側螢幕欄(0 為第一欄) size 項目總數 scrollbar 如果可見,則為 TRUE
這些值與 CompleteChanged 期間的 v:event 中的值相同。
回傳
(any)
pumvisible() pumvisible()
當彈出式選單可見時,返回非零值,否則返回零。請參閱 ins-completion-menu。這可以用於避免某些會移除彈出式選單的操作。
回傳
(any)
py3eval({expr}) py3eval()
評估 Python 表達式 {expr},並返回其轉換為 Vim 資料結構的結果。數字和字串會按原樣返回(但字串會被複製,Unicode 字串會額外轉換為 UTF-8)。列表會表示為 Vim List 類型。字典會表示為 Vim Dictionary 類型,其中鍵會轉換為字串。
參數
{expr} (任意)
回傳
(any)
pyeval({expr}) pyeval() E858 E859 評估 Python 表達式 {expr},並返回其轉換為 Vim 資料結構的結果。數字和字串會按原樣返回(但字串會被複製)。列表會表示為 Vim List 類型。字典會表示為 Vim Dictionary 類型,非字串鍵會導致錯誤。
參數
{expr} (任意)
回傳
(any)
pyxeval({expr}) pyxeval()
評估 Python 表達式 {expr},並返回其轉換為 Vim 資料結構的結果。使用 Python 2 或 3,請參閱 python_x'pyxversion'。另請參閱:pyeval()py3eval()
參數
{expr} (任意)
回傳
(any)
rand([{expr}]) rand()
使用 {expr} 作為種子,以 xoshiro128** 演算法產生一個偽隨機數 Number。為了保持一致性,即使在 64 位系統上,返回的數字也是 32 位。可以使用 srand() 初始化 {expr},並由 rand() 更新。如果省略 {expr},則會使用並更新一個內部種子值。如果 {expr} 無效,則返回 -1。
範例
echo rand()
let seed = srand()
echo rand(seed)
echo rand(seed) % 16  " random number 0 - 15
參數
{expr} (number?)
回傳
(any)
range({expr} [, {max} [, {stride}]]) range() E726 E727 返回一個包含 Numbers 的 List
如果僅指定 {expr}:[0, 1, ..., {expr} - 1]
如果指定了 {max}:[{expr}, {expr} + 1, ..., {max}]
如果指定了 {stride}:[{expr}, {expr} + {stride}, ..., {max}](每次將 {expr} 增加 {stride},且不會產生超出 {max} 的值)。當最大值比開始值小一時,結果為空列表。當最大值比開始值小一以上時,則會發生錯誤。範例
echo range(4)                " [0, 1, 2, 3]
echo range(2, 4)        " [2, 3, 4]
echo range(2, 9, 3)        " [2, 5, 8]
echo range(2, -2, -1)        " [2, 1, 0, -1, -2]
echo range(0)                " []
echo range(2, 0)        " error!
參數
{expr} (任意)
{max} (integer?)
{stride} (integer?)
回傳
(any)
readblob({fname} [, {offset} [, {size}]]) readblob()
以二進位模式讀取檔案 {fname},並返回一個 Blob。如果指定了 {offset},則從指定的偏移量讀取檔案。如果它是負值,則將其用作從檔案末尾開始的偏移量。例如,要讀取最後 12 個位元組
echo readblob('file.bin', -12)
如果指定了 {size},則只會讀取指定的大小。例如,要讀取檔案的前 100 個位元組
echo readblob('file.bin', 0, 100)
如果 {size} 為 -1 或省略,則會讀取從 {offset} 開始的所有資料。當 {size} 明確設定時,這也可以用於從 Unix 上的字元裝置讀取資料。只有在裝置支援搜尋時,才能使用 {offset}。否則,它應該為零。例如,要從串列控制台讀取 10 個位元組
echo readblob('/dev/ttyS0', 0, 10)
當無法開啟檔案時,會給出錯誤訊息,並且結果為空的 Blob。當偏移量超出檔案末尾時,結果為空的 blob。當嘗試讀取比可用位元組更多的位元組時,結果會被截斷。另請參閱 readfile()writefile()
參數
{fname} (字串)
{offset} (integer?)
{size} (integer?)
回傳
(any)
readdir({directory} [, {expr}]) readdir()
返回 {directory} 中包含檔案和目錄名稱的列表。如果您不需要執行複雜的操作(例如限制符合的數量),也可以使用 glob()
當省略 {expr} 時,會包含所有條目。當給定 {expr} 時,會對其求值以檢查要執行什麼操作:如果 {expr} 的結果為 -1,則不會處理任何其他條目。如果 {expr} 的結果為 0,則此條目不會被新增到列表中。如果 {expr} 的結果為 1,則此條目會被新增到列表中。每次求值 {expr} 時,v:val 都會設定為條目名稱。當 {expr} 為函數時,名稱會作為引數傳遞。例如,要取得以 ".txt" 結尾的檔案列表
echo readdir(dirname, {n -> n =~ '.txt$'})
要跳過隱藏檔案和備份檔案
echo readdir(dirname, {n -> n !~ '^\.\|\~$'})
如果您想要取得目錄樹
function! s:tree(dir)
    return {a:dir : map(readdir(a:dir),
    \ {_, x -> isdirectory(x) ?
    \          {x : s:tree(a:dir .. '/' .. x)} : x})}
endfunction
echo s:tree(".")
錯誤時返回空的 List。
參數
{directory} (string)
{expr} (integer?)
回傳
(any)
readfile({fname} [, {type} [, {max}]]) readfile()
讀取檔案 {fname} 並返回一個 List,檔案的每一行都是一個項目。行會以 NL 字元分隔。以 CR 分隔的 Macintosh 檔案會產生單個長行(除非某處出現 NL)。所有 NUL 字元都會被替換為 NL 字元。當 {type} 包含 "b" 時,會使用二進位模式
當最後一行以 NL 結尾時,會新增一個額外的空列表項目。
不會移除 CR 字元。否則
會移除 NL 之前出現的 CR 字元。
最後一行是否以 NL 結尾並不重要。
會從文字中移除任何 UTF-8 位元組順序標記。當給定 {max} 時,這會指定要讀取的最大行數。如果您只想檢查檔案的前十行,則此功能很有用
for line in readfile(fname, '', 10)
  if line =~ 'Date' | echo line | endif
endfor
{max} 為負數時,會返回檔案末尾的 -{max} 行,或盡可能多返回。當 {max} 為零時,結果為空列表。請注意,如果沒有 {max},則會將整個檔案讀取到記憶體中。另請注意,無法識別編碼。如果需要,請將檔案讀取到緩衝區中。已過時(請改用 readblob()):當 {type} 包含 "B" 時,會返回一個 Blob,其中包含未修改的檔案二進位資料。當無法開啟檔案時,會給出錯誤訊息,並且結果為空列表。另請參閱 writefile()
參數
{fname} (字串)
{type} (string?)
{max} (integer?)
回傳
(any)
reduce({object}, {func} [, {initial}]) reduce() E998 會針對 {object} 中的每個項目呼叫 {func},其中 {object} 可以是 StringListBlob。呼叫 {func} 時,會帶有兩個引數:目前為止的結果和目前的項目。處理完所有項目後,會返回結果。
{initial} 是初始結果。當省略時,會使用 {object} 中的第一個項目,並且會先針對第二個項目呼叫 {func}。如果未給定 {initial}{object} 為空,則無法計算結果,會產生 E998 錯誤。
範例
echo reduce([1, 3, 5], { acc, val -> acc + val })
echo reduce(['x', 'y'], { acc, val -> acc .. val }, 'a')
echo reduce(0z1122, { acc, val -> 2 * acc + val })
echo reduce('xyz', { acc, val -> acc .. ',' .. val })
參數
{object} (任意)
{func} (function)
{initial} (any?)
回傳
(any)
reg_executing() reg_executing()
返回正在執行的暫存器的單個字母名稱。當沒有暫存器正在執行時,則返回空字串。請參閱 @
回傳
(any)
reg_recorded() reg_recorded()
返回上次記錄的暫存器的單個字母名稱。當尚未記錄任何內容時,則返回空字串。請參閱 qQ
回傳
(any)
reg_recording() reg_recording()
傳回正在錄製的暫存器單字母名稱。當未錄製時,傳回空字串。請參閱 q
回傳
(any)
reltime() reltime()
reltime({start}) reltime({start}, {end}) 傳回表示時間值的項目。該項目是一個列表,其項目取決於系統。該項目可以傳遞給 reltimestr() 以將其轉換為字串,或傳遞給 reltimefloat() 以轉換為浮點數。
不帶引數時,它會傳回目前的「相對時間」,這是一個實現定義的值,僅當作為 reltime()reltimestr()reltimefloat() 的引數使用時才有意義。
帶一個引數時,它會傳回自引數中指定的時間以來經過的時間。帶兩個引數時,它會傳回 {start}{end} 之間經過的時間。
{start}{end} 引數必須是由 reltime() 傳回的值。發生錯誤時傳回零。
注意:localtime() 傳回目前的(非相對)時間。
參數
{start} (any?)
{end_} (any?)
回傳
(any)
reltimefloat({time}) reltimefloat()
傳回表示 {time} 時間值的浮點數。時間單位為秒。範例:let start = reltime() call MyFunction() let seconds = reltimefloat(reltime(start)) 請參閱 reltimestr() 關於額外負擔的註解。另請參閱 profiling。如果發生錯誤,則傳回空字串
參數
{time} (any)
回傳
(any)
reltimestr({time}) reltimestr()
傳回表示 {time} 時間值的字串。這是秒數、小數點和微秒數。範例
let start = reltime()
call MyFunction()
echo reltimestr(reltime(start))
請注意,命令的額外負擔將會加到時間中。開頭的空格用於使字串對齊美觀。您可以使用 split() 來移除它。
echo split(reltimestr(reltime(start)))[0]
另請參閱 profiling。如果發生錯誤,則傳回空字串
參數
{time} (any)
回傳
(any)
remove({list}, {idx}) remove()
remove({list}, {idx}, {end}) 不帶 {end}:從 List {list} 中移除位於 {idx} 的項目,並傳回該項目。帶 {end}:從 {idx}{end} (包含) 移除項目,並傳回包含這些項目的 List。當 {idx} 指向與 {end} 相同的項目時,會傳回包含一個項目的列表。當 {end} 指向 {idx} 之前的項目時,這會發生錯誤。請參閱 list-index 以取得 {idx}{end} 的可能值。發生錯誤時傳回零。範例
echo "last item: " .. remove(mylist, -1)
call remove(mylist, 0, 9)
使用 delete() 移除檔案。
參數
{list} (any[])
{idx} (integer)
{end_} (integer?)
回傳
(any)
remove({blob}, {idx}) remove({blob}, {idx}, {end}) 不帶 {end}:從 Blob {blob} 中移除位於 {idx} 的位元組,並傳回該位元組。帶 {end}:從 {idx}{end} (包含) 移除位元組,並傳回包含這些位元組的 Blob。當 {idx} 指向與 {end} 相同的位元組時,會傳回包含一個位元組的 Blob。當 {end} 指向 {idx} 之前的位元組時,這會發生錯誤。發生錯誤時傳回零。範例
echo "last byte: " .. remove(myblob, -1)
call remove(mylist, 0, 9)
參數
{blob} (any)
{idx} (integer)
{end_} (integer?)
回傳
(any)
remove({dict}, {key}) 從 {dict} 中移除具有索引鍵 {key} 的項目,並傳回該項目。範例
echo "removed " .. remove(dict, "one")
如果 {dict} 中沒有 {key},這會發生錯誤。發生錯誤時傳回零。
參數
{dict} (any)
{key} (string)
回傳
(any)
rename({from}, {to}) rename()
將名稱為 {from} 的檔案重新命名為名稱為 {to}。這也應該適用於跨檔案系統移動檔案。結果是一個數字,如果檔案重新命名成功,則為 0,如果重新命名失敗,則為非零值。注意:如果 {to} 存在,則會覆寫它而不發出警告。此函數在 sandbox 中不可用。
參數
{from} (string)
{to} (string)
回傳
(any)
repeat({expr}, {count}) repeat()
重複 {expr} {count} 次,並傳回串連的結果。範例
let separator = repeat('-', 80)
{count} 為零或負數時,結果為空。當 {expr}ListBlob 時,結果是 {expr} 串連 {count} 次。範例
let longlist = repeat(['a', 'b'], 3)
結果為 ['a', 'b', 'a', 'b', 'a', 'b']。
參數
{expr} (任意)
{count} (integer)
回傳
(any)
resolve({filename}) resolve() E655 在 MS-Windows 上,當 {filename} 是捷徑(.lnk 檔案)時,會以簡化形式傳回捷徑指向的路徑。在 Unix 上,重複解析 {filename} 的所有路徑元件中的符號連結,並傳回簡化的結果。為了處理連結迴圈,符號連結的解析會在 100 次迭代後停止。在其他系統上,傳回簡化的 {filename}。簡化步驟與 simplify() 相同。resolve() 會保留指定目前目錄的前導路徑元件(如果結果仍然是相對路徑名稱),並且也會保留尾隨路徑分隔符號。
參數
{filename} (string)
回傳
(any)
reverse({object}) reverse()
反轉 {object} 中項目的順序。{object} 可以是 ListBlobString。對於列表和 Blob,項目會就地反轉,並傳回 {object}。對於字串,則會傳回新的字串。如果 {object} 不是列表、Blob 或字串,則傳回零。如果您希望列表或 Blob 保持不變,請先建立副本
let revlist = reverse(copy(mylist))
參數
{object} (任意)
回傳
(any)
round({expr}) round()
{expr} 四捨五入到最接近的整數值,並將其以 Float 的形式傳回。如果 {expr} 位於兩個整數值的中間,則使用較大的值(遠離零)。{expr} 必須評估為 FloatNumber。如果 {expr} 不是 FloatNumber,則傳回 0.0。範例
echo round(0.456)
0.0
echo round(4.5)
5.0
echo round(-4.5)
-5.0
參數
{expr} (數字)
回傳
(any)
rpcnotify({channel}, {event} [, {args}...]) rpcnotify()
透過 RPC{event} 傳送到 {channel},並立即傳回。如果 {channel} 為 0,則會將事件廣播到所有通道。範例
au VimLeave call rpcnotify(0, "leaving")
參數
{channel} (integer)
{event} (string)
{args} (any?)
回傳
(any)
rpcrequest({channel}, {method} [, {args}...]) rpcrequest()
傳送請求到 {channel},以透過 RPC 叫用 {method},並封鎖直到收到回應為止。範例
let result = rpcrequest(rpc_chan, "func", 1, 2, 3)
參數
{channel} (integer)
{method} (string)
{args} (any?)
回傳
(any)
rubyeval({expr}) rubyeval()
評估 Ruby 表達式 {expr},並將其結果轉換為 Vim 資料結構。數字、浮點數和字串會按原樣傳回(但會複製字串)。陣列表示為 Vim List 類型。雜湊表示為 Vim Dictionary 類型。其他物件則表示為其 "Object#to_s" 方法產生的字串。
參數
{expr} (任意)
回傳
(any)
screenattr({row}, {col}) screenattr()
screenchar() 類似,但傳回屬性。這是一個相當任意的數字,只能用於與其他位置的屬性進行比較。當 row 或 col 超出範圍時,傳回 -1。
參數
{row} (integer)
{col} (整數)
回傳
(any)
screenchar({row}, {col}) screenchar()
結果是一個數字,即螢幕上位置 [row, col] 的字元。這適用於每個可能的螢幕位置,包括狀態列、視窗分隔符號和命令列。左上角的位置是第一列、第一欄。該字元不包含組合字元。對於雙位元組編碼,它可能只有第一個位元組。這主要是用於測試。當 row 或 col 超出範圍時,傳回 -1。
參數
{row} (integer)
{col} (整數)
回傳
(any)
screenchars({row}, {col}) screenchars()
結果是一個 List 數字。第一個數字與 screenchar() 傳回的相同。其他數字是基本字元頂部的組合字元。這主要是用於測試。當 row 或 col 超出範圍時,傳回空列表。
參數
{row} (integer)
{col} (整數)
回傳
(any)
screencol() screencol()
結果是一個數字,即游標目前的螢幕欄。最左邊的欄的編號為 1。此函數主要用於測試。
注意:一律傳回目前的螢幕欄,因此,如果在命令中使用(例如:「:echo screencol()」),它會傳回命令列內的欄,而命令執行時該欄為 1。若要取得檔案中的游標位置,請使用下列其中一個對應
nnoremap <expr> GG ":echom " .. screencol() .. "\n"
nnoremap <silent> GG :echom screencol()<CR>
noremap GG <Cmd>echom screencol()<CR>
回傳
(any)
screenpos({winid}, {lnum}, {col}) screenpos()
結果會是一個字典 (Dict),其中包含在視窗 {winid} 中,位於緩衝區的第 {lnum} 行和第 {col} 列的文字字元的螢幕位置。{col} 是一個以 1 為起始的位元組索引。此字典具有以下成員:row (螢幕列)、col (第一個螢幕欄)、endcol (最後一個螢幕欄) 以及 curscol (游標螢幕欄)。如果指定的位置不可見,則所有值均為零。「endcol」值與「col」不同,當字元佔用多個螢幕儲存格時。「例如,對於 Tab,「col」可以是 1,「endcol」可以是 8。「curscol」值是游標將放置的位置。對於 Tab,它將與「endcol」相同,而對於雙寬字元,它將與「col」相同。隱藏功能在此處會被忽略,欄號會視為 'conceallevel' 為零的情況。您可以將游標設定到正確的位置,並使用 screencol() 取得包含 隱藏 功能的值。如果位置在關閉的摺疊中,則會傳回第一個字元的螢幕位置,且不使用 {col}。如果 {winid} 無效,則會傳回空的字典。
參數
{winid} (integer)
{lnum} (整數)
{col} (整數)
回傳
(any)
screenrow() screenrow()
結果會是一個數字,它是游標的目前螢幕列。頂部列的編號為 1。此函式主要用於測試。或者,您也可以使用 winline()
注意:screencol() 相同的限制。
回傳
(any)
screenstring({row}, {col}) screenstring()
結果會是一個字串,其中包含螢幕上位置 [row, col] 的基本字元和任何組合字元。這類似於 screenchars(),但會傳回包含字元的字串。這主要用於測試。當 row 或 col 超出範圍時,會傳回空字串。
參數
{row} (integer)
{col} (整數)
回傳
(any)
search({pattern} [, {flags} [, {stopline} [, {timeout} [, {skip}]]]]) search() 搜尋 regexp 樣式 {pattern}。搜尋從游標位置開始 (您可以使用 cursor() 來設定它)。
找到符合項目後,會傳回其行號。如果沒有符合項目,則會傳回 0,且游標不會移動。不會顯示錯誤訊息。若要取得符合的字串,請使用 matchbufline()
{flags} 是一個字串,其中可以包含以下字元旗標:'b' 向後搜尋,而非向前搜尋 'c' 接受游標位置的符合項目 'e' 移動到符合項目的結尾 'n' 不要移動游標 'p' 傳回符合的子樣式編號 (請參閱下方) 's' 將 ' 標記設定在游標先前的位置 'w' 繞回到檔案結尾 'W' 不要繞回到檔案結尾 'z' 從游標欄開始搜尋,而不是從零開始 如果未指定 'w' 或 'W',則會套用 'wrapscan' 選項。
如果提供 's' 旗標,則僅在移動游標時才會設定 ' 標記。's' 旗標不能與 'n' 旗標結合使用。
會使用 'ignorecase''smartcase''magic'
當未提供 'z' 旗標時,向前搜尋始終從第零欄開始,然後會跳過游標之前的符合項目。當 'cpo' 中存在 'c' 旗標時,下一個搜尋會從符合項目之後開始。如果沒有 'c' 旗標,則下一個搜尋會從符合項目開始後的一欄開始。這對於重疊的符合項目很重要。請參閱 cpo-c。您也可以插入 "\ze" 來變更符合項目結束的位置,請參閱 /\ze
向後搜尋且提供 'z' 旗標時,搜尋會從第零欄開始,因此不會找到目前行的符合項目 (除非繞回到檔案結尾)。
當提供 {stopline} 引數時,搜尋會在搜尋此行後停止。這適用於將搜尋限制在某個範圍的行。範例
let match = search('(', 'b', line("w0"))
let end = search('END', '', line("w$"))
當使用 {stopline} 且不為零時,這也表示搜尋不會繞回到檔案結尾。零值等於未提供引數。
當提供 {timeout} 引數時,搜尋會在經過超過這個毫秒數時停止。因此,當 {timeout} 為 500 時,搜尋會在半秒後停止。該值不得為負數。零值如同未提供引數。
注意:僅在搜尋時才考慮逾時,評估 {skip} 運算式時則不考慮。
如果提供了 {skip} 運算式,則會在游標位於符合項目開頭時進行評估。如果評估結果為非零值,則會跳過此符合項目。例如,這可用於跳過註解或字串中的符合項目。{skip} 可以是字串 (會評估為運算式)、函式參考或 lambda。當省略或空白時,會接受每個符合項目。當評估 {skip} 造成錯誤時,搜尋會中止並傳回 -1。search()-sub-match
使用 'p' 旗標時,傳回的值會是 \(\) 中第一個子符合項目的值加一。如果沒有任何子符合項目,但整個樣式符合,則為 1。若要取得欄號,請使用 searchpos()
除非使用 'n' 旗標,否則游標會位於符合項目處。
範例 (會檢查引數清單中的所有檔案)
let n = 1
while n <= argc()            " loop over all files in arglist
  exe "argument " .. n
  " start at the last char in the file and wrap for the
  " first search to find match at start of file
  normal G$
  let flags = "w"
  while search("foo", flags) > 0
    s/foo/bar/g
    let flags = "W"
  endwhile
  update                    " write the file if modified
  let n = n + 1
endwhile
使用一些旗標的範例
echo search('\<if\|\(else\)\|\(endif\)', 'ncpe')
這會在游標下方或之後搜尋關鍵字 "if"、"else" 和 "endif"。由於有 'p' 旗標,因此會根據找到哪個關鍵字傳回 1、2 或 3,如果搜尋失敗則傳回 0。將游標放在行的第一個字詞上
if (foo == 0) | let foo = foo + 1 | endif
函式會傳回 1。如果沒有 'c' 旗標,函式會找到 "endif" 並傳回 3。如果游標位於 "if" 的 "f" 上,則在沒有 'e' 旗標的情況下也會發生相同的事情。'n' 旗標會告訴函式不要移動游標。
參數
{pattern} (string)
{flags} (字串?)
{stopline} (integer?)
{timeout} (integer?)
{skip} (string|function?)
回傳
(any)
searchcount([{options}]) searchcount()
取得或更新上次搜尋計數,就像在沒有 'shortmess' 中的 "S" 旗標時顯示的計數一樣。即使 'shortmess' 包含 "S" 旗標,此功能也有效。
這會傳回 字典。如果未設定先前的樣式且未指定 "pattern",則字典為空。
鍵值 類型 含義
current 數字 符合項目的目前位置;如果游標位置在第一個符合項目之前,則為 0 exact_match 布林值 如果 "current" 與 "pos" 符合,則為 1,否則為 0 total 數字 找到的符合項目總數 incomplete 數字 0:搜尋已完全完成 1:重新計算已逾時 2:超過最大計數
關於 {options},請參閱下文。
若要在按下 nN 時取得上次搜尋計數,請使用 recompute: 0 呼叫此函式。這有時會傳回錯誤的資訊,因為 nN 的最大計數為 99。如果超過 99,結果必須是最大計數 + 1 (100)。如果您想要取得正確的資訊,請指定 recompute: 1
" result == maxcount + 1 (100) when many matches
let result = searchcount(#{recompute: 0})
" Below returns correct result (recompute defaults
" to 1)
let result = searchcount()
此函式適用於將計數新增至 'statusline'
function! LastSearchCount() abort
  let result = searchcount(#{recompute: 0})
  if empty(result)
    return ''
  endif
  if result.incomplete ==# 1     " timed out
    return printf(' /%s [?/??]', @/)
  elseif result.incomplete ==# 2 " max count exceeded
    if result.total > result.maxcount &&
    \  result.current > result.maxcount
      return printf(' /%s [>%d/>%d]', @/,
      \             result.current, result.total)
    elseif result.total > result.maxcount
      return printf(' /%s [%d/>%d]', @/,
      \             result.current, result.total)
    endif
  endif
  return printf(' /%s [%d/%d]', @/,
  \             result.current, result.total)
endfunction
let &statusline ..= '%{LastSearchCount()}'
" Or if you want to show the count only when
" 'hlsearch' was on
" let &statusline ..=
" \   '%{v:hlsearch ? LastSearchCount() : ""}'
您也可以更新搜尋計數,這在 CursorMovedCursorMovedI 自動命令中很有用
autocmd CursorMoved,CursorMovedI *
  \ let s:searchcount_timer = timer_start(
  \   200, function('s:update_searchcount'))
function! s:update_searchcount(timer) abort
  if a:timer ==# s:searchcount_timer
    call searchcount(#{
    \ recompute: 1, maxcount: 0, timeout: 100})
    redrawstatus
  endif
endfunction
這也可以用來使用指定的樣式計算目前緩衝區中符合的文字,方法是使用 "pattern"
" Count '\<foo\>' in this buffer
" (Note that it also updates search count)
let result = searchcount(#{pattern: '\<foo\>'})
" To restore old search count by old pattern,
" search again
call searchcount()
{options} 必須是 字典。它可以包含
鍵值 類型 含義
recompute 布林值 如果為 TRUE,則會像執行 nN 一樣重新計算計數。否則,會傳回上次計算的結果 (當在 'shortmess' 中沒有 "S" 時,使用 nN,或已呼叫此函式)。(預設:TRUE) pattern 字串 如果已指定此項目,且與 @/ 不同,則會重新計算。這與在呼叫此函式之前執行以下命令的效果相同
let @/ = pattern
(預設:@/) timeout 數字 0 或負數表示沒有逾時。重新計算結果的逾時毫秒數 (預設:0) maxcount 數字 0 或負數表示沒有限制。重新計算結果時符合文字的最大計數。如果搜尋超過總計數,「total」值會變成 maxcount + 1 (預設:0) pos 清單 重新計算結果時的 [lnum, col, off] 值。這會變更 "current" 結果值。請參閱 cursor()getpos() (預設:游標的位置)
參數
{options} (table?)
回傳
(any)
searchdecl({name} [, {global} [, {thisblock}]]) searchdecl()
搜尋 {name} 的宣告。
如果 {global} 引數為非零值,其運作方式類似 gD,會尋找檔案中的第一個符合項目。否則,其運作方式類似 gd,會尋找函式中的第一個符合項目。
如果 {thisblock} 引數為非零值,則會忽略在游標位置之前結束的 {} 區塊中的符合項目。避免找到僅在另一個範圍內有效的變數宣告。
會將游標移動到找到的符合項目。成功時傳回零,失敗時傳回非零值。範例
if searchdecl('myvar') == 0
   echo getline('.')
endif
參數
{name} (string)
{global} (boolean?)
{thisblock} (boolean?)
回傳
(any)
searchpair()
searchpair({start}, {middle}, {end} [, {flags} [, {skip} [, {stopline} [, {timeout}]]]]) 搜尋巢狀開始-結束配對的符合項目。這可用於尋找符合 "if" 的 "endif",同時忽略其間的其他 if/endif 配對。搜尋從游標處開始。預設為向前搜尋,在 {flags} 中包含 'b' 可向後搜尋。如果找到符合項目,游標會放置在該項目處,並傳回行號。如果未找到符合項目,則會傳回 0 或 -1,且游標不會移動。不會顯示錯誤訊息。
{start}{middle}{end} 是樣式,請參閱 pattern。它們不得包含 \( \) 配對。允許使用 \%( \)。當 {middle} 不為空時,從任一方向搜尋時都會找到它,但僅當不在巢狀開始-結束配對中時。典型的用法是
echo searchpair('\<if\>', '\<else\>', '\<endif\>')
{middle} 保留為空白,即可跳過 "else"。
{flags} 'b'、'c'、'n'、's'、'w' 和 'W' 的用法與 search() 相同。此外:'r' 重複搜尋直到找不到更多匹配項;會找到最外層的配對。隱含 'W' 旗標。'm' 返回匹配次數,而非匹配所在的行號;當使用 'r' 時,會 > 1。 注意:使用 'W' 旗標幾乎總是個好主意,以避免環繞到檔案末尾。
當找到 {start}{middle}{end} 的匹配項時,會評估 {skip} 表達式,游標會定位在匹配項的開始處。如果此匹配項要被跳過,則應返回非零值。例如,因為它在註解或字串內。當 {skip} 被省略或為空時,每個匹配項都會被接受。當評估 {skip} 導致錯誤時,搜尋會中止並返回 -1。{skip} 可以是字串、lambda、funcref 或 partial。任何其他類型的資料都會導致函數失敗。
關於 {stopline}{timeout} 請參閱 search()
會使用 'ignorecase' 的值。'magic' 會被忽略,模式會像開啟一樣使用。
搜尋會從游標所在位置開始。在搜尋方向上,下一個字元的 {start}{middle}{end} 匹配項是第一個找到的匹配項。範例:
if 1
  if 2
  endif 2
endif 1
當從 "if 2" 開始,游標在 "i" 上,並向前搜尋時,會找到 "endif 2"。當從 "if 2" 前一個字元開始時,會找到 "endif 1"。這是因為會先找到 "if 2",然後將其視為從 "if 2" 到 "endif 2" 的巢狀 if/endif。當向後搜尋且 {end} 超過一個字元時,在模式結尾放置 "\zs" 可能會很有用,這樣當游標在與結尾的匹配項內時,會找到匹配的開頭。
範例,尋找 Vim 腳本中的 "endif" 命令:
echo searchpair('\<if\>', '\<el\%[seif]\>', '\<en\%[dif]\>', 'W',
\ 'getline(".") =~ "^\\s*\""')
游標必須在要尋找匹配項的 "if" 上或之後。請注意,使用單引號字串是為了避免必須將反斜線加倍。skip 表達式僅捕獲行首的註解,而不是命令之後的註解。此外,一行中間的單字 "en" 或 "if" 也會被視為匹配項。另一個範例,搜尋與 "}" 匹配的 "{":
echo searchpair('{', '', '}', 'bW')
當游標在要尋找匹配項的 "}" 上或之前時,此方法有效。要拒絕語法高亮標記為字串的匹配項:
echo searchpair('{', '', '}', 'bW',
     \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string"')
參數
{start} (string)
{middle} (string)
{end_} (string)
{flags} (字串?)
{skip} (string|function?)
{stopline} (integer?)
{timeout} (integer?)
回傳
(整數)
searchpairpos()
searchpairpos({start}, {middle}, {end} [, {flags} [, {skip} [, {stopline} [, {timeout}]]]]) 與 searchpair() 相同,但會返回一個 List,其中包含匹配項的行和欄位置。 List 的第一個元素是行號,第二個元素是匹配項的欄位置的位元組索引。如果找不到匹配項,則返回 [0, 0]。
let [lnum,col] = searchpairpos('{', '', '}', 'n')
如需更大且更有用的範例,請參閱 match-parens
參數
{start} (string)
{middle} (string)
{end_} (string)
{flags} (字串?)
{skip} (string|function?)
{stopline} (integer?)
{timeout} (integer?)
回傳
([integer, integer])
searchpos()
searchpos({pattern} [, {flags} [, {stopline} [, {timeout} [, {skip}]]]]) 與 search() 相同,但會返回一個 List,其中包含匹配項的行和欄位置。 List 的第一個元素是行號,第二個元素是匹配項的欄位置的位元組索引。如果找不到匹配項,則返回 [0, 0]。範例:
let [lnum, col] = searchpos('mypattern', 'n')
如果給定 'p' 旗標,則會有一個額外的項目,其中包含子模式匹配編號 search()-sub-match。範例:
let [lnum, col, submatch] = searchpos('\(\l\)\|\(\u\)', 'np')
在此範例中,當找到小寫字母 /\l 時,"submatch" 為 2,當找到大寫字母 /\u 時,"submatch" 為 3。
參數
{pattern} (string)
{flags} (字串?)
{stopline} (integer?)
{timeout} (integer?)
{skip} (string|function?)
回傳
(any)
serverlist() serverlist()
返回伺服器位址清單,如果所有伺服器都已停止,則返回空清單。serverstart() serverstop() 範例:
echo serverlist()
回傳
(any)
serverstart([{address}]) serverstart()
{address} 開啟一個 socket 或具名管道,並監聽 RPC 訊息。用戶端可以將 API 命令傳送到返回的位址來控制 Nvim。
返回位址字串(可能與 {address} 引數不同,請參閱下文)。
如果 {address} 具有冒號 (":"),則它是 TCP/IPv4/IPv6 位址,其中最後一個 ":" 分隔主機和連接埠(空或零會指定隨機連接埠)。
否則,{address} 是具名管道的路徑(Windows 除外)。
如果 {address} 沒有斜線 ("/"),則會將其視為此格式中產生路徑的 "name" 部分:
stdpath("run").."/{name}.{pid}.{counter}"
如果省略 {address},則名稱為 "nvim"。
echo serverstart()
=> /tmp/nvim.bram/oknANW/nvim.15430.5
列出所有 Nvim 伺服器的範例 bash 命令:
ls ${XDG_RUNTIME_DIR:-${TMPDIR}nvim.${USER}}/*/nvim.*.0
範例具名管道:
if has('win32')
  echo serverstart('\\.\pipe\nvim-pipe-1234')
else
  echo serverstart('nvim.sock')
endif
範例 TCP/IP 位址:
echo serverstart('::1:12345')
參數
{address} (string?)
回傳
(any)
serverstop({address}) serverstop()
關閉 {address} 的管道或 socket。如果 {address} 有效,則返回 TRUE,否則返回 FALSE。如果 v:servername 已停止,則會將其設定為 serverlist() 中下一個可用的位址。
參數
{address} (string)
回傳
(any)
setbufline({buf}, {lnum}, {text}) setbufline()
將緩衝區 {buf} 中的行 {lnum} 設定為 {text}。這與指定緩衝區的 setline() 類似。
此函式僅適用於已載入的緩衝區。如果需要,請先呼叫 bufload()
要插入行,請使用 appendbufline()
{text} 可以是設定一行的字串,也可以是設定多行的字串 List。如果 List 延伸到最後一行以下,則會新增這些行。如果 List 為空,則不會變更任何內容,並返回零。
如需 {buf} 的使用,請參見上方的 bufname()
{lnum} 的用法與 setline() 相同。使用 "$" 來引用緩衝區 {buf} 中的最後一行。當 {lnum} 剛好在最後一行下方時,{text} 會新增到最後一行下方。成功時返回 0,失敗時返回 1。
如果 {buf} 不是有效的緩衝區,或 {lnum} 無效,則會顯示錯誤訊息。
參數
{buf} (整數|字串)
{lnum} (整數)
{text} (字串|字串[])
回傳
(any)
setbufvar({buf}, {varname}, {val}) setbufvar()
將緩衝區 {buf} 中的選項或本機變數 {varname} 設定為 {val}。這也適用於全域或本機視窗選項,但不適用於全域或本機視窗變數。對於本機視窗選項,全域值不會變更。關於 {buf} 的使用,請參閱上文的 bufname(){varname} 引數是一個字串。請注意,必須使用沒有 "b:" 的變數名稱。範例:
call setbufvar(1, "&mod", 1)
call setbufvar("todo", "myvar", "foobar")
此函數在 沙箱中不可用。
參數
{buf} (整數|字串)
{varname} (string)
{val} (any)
回傳
(any)
setcellwidths({list}) setcellwidths()
指定字元範圍的儲存格寬度覆寫。這會告知 Vim 在終端機中顯示時字元的寬度(以螢幕儲存格計算)。這些值會覆寫 'ambiwidth'。範例:
call setcellwidths([
             \ [0x111, 0x111, 1],
             \ [0x2194, 0x2199, 2],
             \ ])
{list} 引數是一個 List 的 List,每個 List 包含三個數字:[{low}, {high}, {width}]。E1109 E1110 {low}{high} 可以相同,在這種情況下,這會參照一個字元。否則,它是從 {low}{high}(包括)的字元範圍。E1111 E1114 僅可使用值為 0x80 或更高的字元。
{width} 必須為 1 或 2,表示螢幕儲存格中的字元寬度。E1112
如果引數無效,也會在範圍與另一個範圍重疊時顯示錯誤。E1113
如果新值導致 'fillchars''listchars' 無效,則會拒絕該值並顯示錯誤。
要清除覆寫,請傳遞空的 {list}
call setcellwidths([])
您可以使用指令碼 $VIMRUNTIME/scripts/emoji_list.lua 來查看已知 emoji 字元的效果。在文字中移動游標,以檢查終端機的儲存格寬度是否與 Vim 對每個 emoji 的了解相符。如果看起來不正確,您需要調整 {list} 引數。
參數
{list} (any[])
回傳
(any)
setcharpos({expr}, {list}) setcharpos()
setpos() 相同,但使用指定的欄號作為字元索引,而不是行中的位元組索引。
範例:在第 8 行中具有文字 "여보세요":
call setcharpos('.', [0, 8, 4, 0])
將游標定位在第四個字元 '요' 上。
call setpos('.', [0, 8, 4, 0])
將游標定位在第二個字元 '보' 上。
參數
{expr} (string)
{list} (整數[])
回傳
(any)
setcharsearch({dict}) setcharsearch()
將目前的字元搜尋資訊設定為 {dict},其中包含下列一個或多個項目:
char 字元,將用於後續的 ,; 命令;空字串清除字元搜尋;1 表示字元搜尋的前向方向;0 表示字元搜尋的後向方向;直到字元搜尋類型;1 表示 tT 字元搜尋,0 表示 fF 字元搜尋
這對於從指令碼儲存/還原使用者的字元搜尋可能很有用。
let prevsearch = getcharsearch()
" Perform a command which clobbers user's search
call setcharsearch(prevsearch)
另請參閱 getcharsearch()
參數
{dict} (string)
回傳
(any)
setcmdline({str} [, {pos}]) setcmdline()
將命令列設定為 {str},並將游標位置設定為 {pos}。如果省略 {pos},則游標會定位在文字之後。成功時返回 0,未編輯命令列時返回 1。
參數
{str} (string)
{pos} (integer?)
回傳
(any)
setcmdpos({pos}) setcmdpos()
將命令列中的游標位置設定為位元組位置 {pos}。第一個位置為 1。使用 getcmdpos() 取得目前位置。僅在編輯命令列時有效,因此您必須使用 c_CTRL-\_ec_CTRL-R_=c_CTRL-R_CTRL-R 並搭配 '='。對於 c_CTRL-\_ec_CTRL-R_CTRL-R 並搭配 '=',位置會在命令列設定為表達式後設定。對於 c_CTRL-R_=,位置會在評估表達式之後,但在插入結果文字之前設定。當數字太大時,游標會放在該行的末尾。小於 1 的數字會產生未定義的結果。成功時返回 0,未編輯命令列時返回 1。
參數
{pos} (integer)
回傳
(any)
setcursorcharpos({lnum}, {col} [, {off}]) setcursorcharpos()
setcursorcharpos({list}) 與 cursor() 相同,但使用指定的欄位號碼作為字元索引,而不是行中的位元組索引。
範例:在第 4 行有文字 "여보세요"
call setcursorcharpos(4, 3)
將游標放置在第三個字元 '세' 上。
call cursor(4, 3)
將游標放置在第一個字元 '여' 上。
參數
{list} (整數[])
回傳
(any)
setenv({name}, {val}) setenv()
將環境變數 {name} 設定為 {val}。範例
call setenv('HOME', '/home/myhome')
{val}v:null 時,會刪除該環境變數。另請參閱 expr-env
參數
{name} (string)
{val} (string)
回傳
(any)
setfperm({fname}, {mode}) setfperm() chmod{fname} 的檔案權限設定為 {mode}{mode} 必須是包含 9 個字元的字串。其格式為 "rwxrwxrwx",其中每組 "rwx" 旗標依序代表檔案擁有者、檔案所屬群組以及其他使用者的權限。'-' 字元表示關閉權限,任何其他字元表示開啟權限。不支援多位元組字元。
例如,"rw-r-----" 表示使用者具有讀寫權限、群組具有讀取權限,而其他使用者無法存取。"xx-x-----" 也會執行相同的操作。
成功時返回非零值,失敗時返回零。
若要讀取權限,請參閱 getfperm()
參數
{fname} (字串)
{mode} (string)
回傳
(any)
setline({lnum}, {text}) setline()
將目前緩衝區的第 {lnum} 行設定為 {text}。若要插入行,請使用 append()。若要在另一個緩衝區中設定行,請使用 setbufline()
{lnum} 的使用方式與 getline() 相同。當 {lnum} 剛好在最後一行下方時,{text} 將會新增至最後一行下方。{text} 可以是任何類型或任何類型的列表,每個項目都會轉換為字串。當 {text} 是空列表時,不會進行任何變更,並返回 FALSE。
如果成功,則會返回 FALSE。如果失敗(很可能是因為 {lnum} 無效),則會返回 TRUE。
範例
call setline(5, strftime("%c"))
{text}列表 時,第 {lnum} 行和後續行將設定為列表中的項目。範例
call setline(5, ['aaa', 'bbb', 'ccc'])
這等效於:
for [n, l] in [[5, 'aaa'], [6, 'bbb'], [7, 'ccc']]
  call setline(n, l)
endfor
注意: 不會設定 '[ 和 ']' 標記。
參數
{lnum} (整數)
{text} (any)
回傳
(any)
setloclist({nr}, {list} [, {action} [, {what}]]) setloclist()
建立或取代或新增至視窗 {nr} 的位置列表。{nr} 可以是視窗編號或 視窗 ID。當 {nr} 為零時,會使用目前視窗。
對於位置列表視窗,會修改顯示的位置列表。對於無效的視窗編號 {nr},會返回 -1。否則,與 setqflist() 相同。另請參閱 位置列表
對於 {action},請參閱 setqflist-action
如果提供了選用的 {what} 字典引數,則僅會設定 {what} 中列出的項目。如需 {what} 中支援的索引鍵列表,請參閱 setqflist()
參數
{nr} (integer)
{list} (any)
{action} (string?)
{what} (table?)
回傳
(any)
setmatches({list} [, {win}]) setmatches()
還原由 getmatches() 儲存的目前視窗的相符項列表。如果成功,則返回 0,否則返回 -1。在還原列表之前,會清除所有目前的相符項。請參閱 getmatches() 的範例。如果指定了 {win},則使用具有此編號或視窗 ID 的視窗,而不是目前視窗。
參數
{list} (any)
{win} (integer?)
回傳
(any)
setpos({expr}, {list}) setpos()
設定字串 {expr} 的位置。可能的值:. 游標 'x 標記 x
{list} 必須是包含四個或五個數字的 列表:[bufnum, lnum, col, off] [bufnum, lnum, col, off, curswant]
"bufnum" 是緩衝區編號。可以使用零表示目前緩衝區。設定大寫標記時,"bufnum" 會用於標記位置。對於其他標記,它會指定要在其中設定標記的緩衝區。您可以使用 bufnr() 函數將檔案名稱轉換為緩衝區編號。對於設定游標和 ' 標記,會忽略 "bufnum",因為這些標記與視窗相關聯,而不是與緩衝區相關聯。不會變更跳躍列表。
"lnum" 和 "col" 是緩衝區中的位置。第一個欄位是 1。使用零 "lnum" 來刪除標記。如果 "col" 小於 1,則會使用 1。若要使用字元計數而不是位元組計數,請使用 setcharpos()
只有在設定 'virtualedit' 時才會使用 "off" 數字。接著,它會是螢幕欄中從字元開頭開始的偏移量。例如,<Tab> 內的或最後一個字元後面的位置。
只有在設定游標位置時才會使用 "curswant" 數字。它會設定垂直移動游標時的首選欄位。當 "curswant" 數字遺失時,不會設定首選欄位。當其存在並設定標記位置時,不會使用它。
請注意,對於 '< 和 '>,變更行號可能會導致標記有效地被交換,使得 '< 永遠在 '> 之前。
當可以設定位置時返回 0,否則返回 -1。如果 {expr} 無效,則會顯示錯誤訊息。
另請參閱 setcharpos()getpos()getcurpos()
這不會還原垂直移動的首選欄位;如果您使用此方法設定游標位置,則 jk 移動會跳到先前的欄位!請使用 cursor() 來同時設定首選欄位。另請參閱 winrestview() 中的 "curswant" 索引鍵。
參數
{expr} (string)
{list} (整數[])
回傳
(any)
setqflist({list} [, {action} [, {what}]]) setqflist()
建立或取代或新增至快速修正列表。
如果提供了選用的 {what} 字典引數,則僅會設定 {what} 中列出的項目。會忽略第一個 {list} 引數。如需 {what} 中支援的項目,請參閱下方。 setqflist-what
{what} 不存在時,會使用 {list} 中的項目。每個項目都必須是字典。會忽略 {list} 中的非字典項目。每個字典項目可以包含下列項目
bufnr 緩衝區編號;必須是有效緩衝區的編號 filename 檔案名稱;僅在 "bufnr" 不存在或無效時使用。 module 模組名稱;如果給定,則會在快速修正錯誤視窗中使用,而不是檔案名稱。 lnum 檔案中的行號 end_lnum 行的結尾,如果項目跨越多行 pattern 用於找出錯誤的搜尋模式 col 欄位號碼 vcol 當非零時:"col" 是視覺欄位;當為零時:"col" 是位元組索引 end_col 結尾欄位,如果項目跨越多個欄位 nr 錯誤編號 text 錯誤的描述 type 單字元錯誤類型,例如 'E'、'W' 等。 valid 已辨識的有效錯誤訊息 user_data 與項目相關聯的自訂資料,可以是任何類型。
"col"、"vcol"、"nr"、"type" 和 "text" 項目是選用的。可以使用 "lnum" 或 "pattern" 項目來找出相符的錯誤行。如果 "filename" 和 "bufnr" 項目不存在,或 "lnum" 或 "pattern" 項目都不存在,則不會將該項目當成錯誤行處理。如果同時存在 "pattern" 和 "lnum",則會使用 "pattern"。如果未提供 "valid" 項目,則當 "bufnr" 是有效緩衝區或 "filename" 存在時,會設定有效旗標。如果您提供空的 {list},則會清除快速修正列表。請注意,此列表與 getqflist() 返回的列表並不完全相同。
{action} 值:setqflist-action E927 'a' 將 {list} 中的項目新增至現有的快速修正列表。如果沒有現有的列表,則會建立新的列表。
'r' 將目前快速修正列表中的項目取代為 {list} 中的項目。這也可用於清除列表。
call setqflist([], 'r')
'u' 類似於 'r',但會嘗試保留快速修正列表中的目前選取範圍。 'f' 會釋放快速修正堆疊中的所有快速修正列表。
如果 {action} 不存在或設定為 ' ',則會建立新的列表。新的快速修正列表會新增至堆疊中目前快速修正列表之後,並釋放所有後續列表。若要將新的快速修正列表新增至堆疊的結尾,請將 {what} 中的 "nr" 設定為 "$"。
可以在字典 {what} 中指定下列項目: context 快速修正列表環境。請參閱 快速修正環境 efm 從 "lines" 剖析文字時要使用的 errorformat。如果此項目不存在,則會使用 'errorformat' 選項值。請參閱 快速修正剖析 id 快速修正列表識別碼 快速修正 ID idx "id" 或 "nr" 所指定之快速修正列表中目前項目的索引。如果設定為 '$',則會將列表中最後一個項目設定為目前項目。請參閱 快速修正索引 items 快速修正項目列表。與 {list} 引數相同。 lines 使用 'errorformat' 來剖析行列表,並將產生的項目新增至快速修正列表 {nr}{id}。僅支援 列表 值。請參閱 快速修正剖析 nr 快速修正堆疊中的列表編號;零表示目前的快速修正列表,而 "$" 表示最後一個快速修正列表。 quickfixtextfunc 取得要在快速修正視窗中顯示之文字的函數。該值可以是函數名稱或函數參照或 Lambda。如需如何撰寫函數和範例的說明,請參閱 快速修正視窗函數。 title 快速修正列表標題文字。請參閱 快速修正標題。 會忽略 {what} 中不支援的索引鍵。如果 "nr" 項目不存在,則會修改目前的快速修正列表。在建立新的快速修正列表時,可以將 "nr" 設定為大於快速修正堆疊大小的值。在修改快速修正列表時,若要保證修改的是正確的列表,應使用 "id" 而不是 "nr" 來指定列表。
範例 (另請參閱 setqflist-examples)
call setqflist([], 'r', {'title': 'My search'})
call setqflist([], 'r', {'nr': 2, 'title': 'Errors'})
call setqflist([], 'a', {'id':qfid, 'lines':["F1:10:L10"]})
成功時返回零,失敗時返回 -1。
此函數可用於建立獨立於 'errorformat' 設定的快速修正列表。使用類似 :cc 1 的命令跳到第一個位置。
參數
{list} (vim.quickfix.entry[])
{action} (string?)
{what} (vim.fn.setqflist.what?)
回傳
(any)
setreg({regname}, {value} [, {options}]) setreg()
將暫存器 {regname} 設定為 {value}。如果 {regname} 為 "" 或 "@",則會使用未命名的暫存器 '"'。{regname} 引數是字串。
{value} 可以是 getreg()getreginfo() 返回的任何值,包括 ListDict。如果 {options} 包含 "a" 或 {regname} 為大寫字母,則該值會被附加。
{options} 也可以包含暫存器類型規範:"c" 或 "v" 字元模式、"l" 或 "V" 行模式、"b" 或 "<CTRL-V>" 區塊模式。如果數字緊隨 "b" 或 "<CTRL-V>" 之後,則會將此數字用作選取的寬度 - 如果未指定,則區塊的寬度會設定為最長行中的字元數(將 <Tab> 計為 1 個字元)。如果 {options} 包含 "u" 或 '"',則未命名的暫存器會設定為指向暫存器 {regname}
如果 {options} 不包含任何暫存器設定,則預設為使用字元模式,除非字串 {value}<NL> 結尾,或是列表 {value} 使用行模式。永遠不會自動選擇區塊模式。成功則返回零,失敗則返回非零值。
E883
注意: 您可能無法使用包含多個項目的 List 來設定搜尋和表達式暫存器。不包含項目的列表的作用類似於空字串。
範例
call setreg(v:register, @*)
call setreg('*', @%, 'ac')
call setreg('a', "1\n2\n3", 'b5')
call setreg('"', { 'points_to': 'a'})
此範例顯示如何使用函式來儲存和還原暫存器
let var_a = getreginfo()
call setreg('a', var_a)
let var_a = getreg('a', 1, 1)
let var_amode = getregtype('a')
" ....
call setreg('a', var_a, var_amode)
注意: 如果不使用 getreg() 的第三個參數,您可能無法可靠地還原暫存器值,因為在沒有它的情況下,換行符號和 Nul 位元組都會被表示為換行符號,請參閱 NL-used-for-Nul
您也可以透過附加空白來變更暫存器的類型
        call setreg('a', '', 'al')
Parameters: ~
  • {regname} (`string`)
  • {value} (`any`)
  • {options} (`string?`)
Return: ~
  (`any`)
settabvar({tabnr}, {varname}, {val}) settabvar()
在索引標籤頁面 {tabnr} 中將索引標籤本地變數 {varname} 設定為 {val}t:var {varname} 引數是一個字串。請注意,必須使用沒有 "t:" 的變數名稱。索引標籤的編號從 1 開始。此函式在 沙箱 中不可用。
參數
{tabnr} (integer)
{varname} (string)
{val} (any)
回傳
(any)
settabwinvar({tabnr}, {winnr}, {varname}, {val}) settabwinvar()
將視窗 {winnr} 中的選項或本地變數 {varname} 設定為 {val}。索引標籤的編號從 1 開始。對於目前的索引標籤頁面,請使用 setwinvar(){winnr} 可以是視窗編號或 視窗 ID。當 {winnr} 為零時,會使用目前的視窗。這也適用於全域或本機緩衝區選項,但不適用於全域或本機緩衝區變數。對於本機緩衝區選項,全域值不會變更。請注意,必須使用沒有 "w:" 的變數名稱。範例
call settabwinvar(1, 1, "&list", 0)
call settabwinvar(3, 2, "myvar", "foobar")
此函數在 沙箱中不可用。
參數
{tabnr} (integer)
{winnr} (integer)
{varname} (string)
{val} (any)
回傳
(any)
settagstack({nr}, {dict} [, {action}]) settagstack()
使用 {dict} 修改視窗 {nr} 的標籤堆疊。{nr} 可以是視窗編號或 視窗 ID
如需 {dict} 中支援的項目列表,請參閱 gettagstack()。"curidx" 在變更標籤堆疊之前生效。E962
標籤堆疊的修改方式取決於 {action} 引數
如果 {action} 不存在或設定為 'r',則會替換標籤堆疊。
如果 {action} 設定為 'a',則 {dict} 中的新項目會被推送(新增)到標籤堆疊。
如果 {action} 設定為 't',則會移除標籤堆疊中目前項目或 {dict} 中的 "curidx" 的所有項目,然後將新項目推送到堆疊。
目前索引會設定為修改後標籤堆疊長度加一。
成功時返回零,失敗時返回 -1。
範例(如需更多範例,請參閱 tagstack-examples):清空視窗 3 的標籤堆疊
call settagstack(3, {'items' : []})
儲存並還原標籤堆疊
let stack = gettagstack(1003)
" do something else
call settagstack(1003, stack)
unlet stack
參數
{nr} (integer)
{dict} (any)
{action} (string?)
回傳
(any)
setwinvar({nr}, {varname}, {val}) setwinvar()
與目前索引標籤頁面的 settabwinvar() 類似。範例
        call setwinvar(1, "&list", 0)
        call setwinvar(2, "myvar", "foobar")
Parameters: ~
  • {nr} (`integer`)
  • {varname} (`string`)
  • {val} (`any`)
Return: ~
  (`any`)
sha256({string}) sha256()
傳回一個包含 64 個十六進位字元的字串,這是 {string} 的 SHA256 檢查總和。
參數
{string} (string)
回傳
(any)
shellescape({string} [, {special}]) shellescape()
逸出 {string} 以用作 shell 命令引數。
在 Windows 上,當未設定 'shellslash' 時,會將 {string} 括在雙引號中,並將 {string} 內的所有雙引號加倍。否則會將 {string} 括在單引號中,並將所有 "'" 取代為 "'\''"。
{special} 引數會額外逸出 Vim 命令中使用的關鍵字。如果它是 非零引數
諸如 "!"、"%"、"#" 和 "<cword>" 等特殊項目(如 expand() 中所列)將以反斜線開頭。反斜線會被 :! 命令再次移除。
<NL> 字元會被逸出。
如果 'shell' 的結尾包含 "csh"
"!" 字元將會被逸出。這是因為 csh 和 tcsh 即使在單引號中也會使用 "!" 來進行歷史記錄取代。
<NL> 字元會被逸出(如果 {special}非零引數,則會逸出兩次)。
如果 'shell' 的結尾包含 "fish",則 "\" 字元將會被逸出,因為在 fish 中,它會在單引號內用作逸出字元。
搭配 :! 命令使用的範例
exe '!dir ' .. shellescape(expand('<cfile>'), 1)
這會產生游標下檔案的目錄清單。搭配 system() 使用的範例
call system("chmod +w -- " .. shellescape(expand("%")))
另請參閱 ::S
參數
{string} (string)
{special}boolean?
回傳
(any)
shiftwidth([{col}]) shiftwidth()
傳回 'shiftwidth' 的有效值。這是 'shiftwidth' 值,除非它是零,在這種情況下,它是 'tabstop' 值。為了在縮排外掛程式中保持向後相容性,請使用此
if exists('*shiftwidth')
  func s:sw()
    return shiftwidth()
  endfunc
else
  func s:sw()
    return &sw
  endfunc
endif
然後使用 s:sw() 而不是 &sw。
當有一個引數 {col} 時,這會用作要傳回 'shiftwidth' 值的欄號。這對於 'vartabstop' 功能很重要。如果未提供 {col} 引數,則會假設為第 1 欄。
參數
{col}integer?
回傳
(整數)
sign_define({name} [, {dict}]) sign_define()
sign_define({list}) 定義一個名為 {name} 的新標記或修改現有標記的屬性。這類似於 :sign-define 命令。
{name} 前面加上唯一的文字,以避免名稱衝突。沒有像放置標記一樣的 {group}
{name} 可以是字串或數字。選用的 {dict} 引數會指定標記屬性。支援以下值:icon:標記的點陣圖檔案的完整路徑。linehl:用於標記放置的整行的反白顯示群組。priority:標記的預設優先順序值。numhl:用於放置標記的行號的反白顯示群組。text:當沒有圖示或未使用 GUI 時顯示的文字。texthl:用於文字項目的反白顯示群組。culhl:當游標與標記位於同一行且啟用 'cursorline' 時,用於文字項目的反白顯示群組。
如果名為 {name} 的標記已存在,則會更新標記的屬性。
可以使用一個引數 {list} 來定義標記列表。每個列表項目都是一個字典,其中包含上述 {dict} 中的項目和標記名稱的 "name" 項目。
成功時返回 0,失敗時返回 -1。當使用一個引數 {list} 時,會針對每個已定義的標記傳回一個值列表。
範例
call sign_define("mySign", {
        \ "text" : "=>",
        \ "texthl" : "Error",
        \ "linehl" : "Search"})
call sign_define([
        \ {'name' : 'sign1',
        \  'text' : '=>'},
        \ {'name' : 'sign2',
        \  'text' : '!!'}
        \ ])
參數
{list} (vim.fn.sign_define.dict[])
回傳
((0|-1)[])
sign_getdefined([{name}]) sign_getdefined()
取得已定義標記及其屬性的列表。這類似於 :sign-list 命令。
如果未提供 {name},則會傳回所有已定義標記的列表。否則,會傳回指定標記的屬性。
傳回值中的每個列表項目都是一個字典,其中包含以下項目:icon:標記的點陣圖檔案的完整路徑。linehl:用於標記放置的整行的反白顯示群組;如果未設定,則不存在。name:標記的名稱。priority:標記的預設優先順序值。numhl:用於放置標記的行號的反白顯示群組;如果未設定,則不存在。text:當沒有圖示或未使用 GUI 時顯示的文字。texthl:用於文字項目的反白顯示群組;如果未設定,則不存在。culhl:當游標與標記位於同一行且啟用 'cursorline' 時,用於文字項目的反白顯示群組;如果未設定,則不存在。
如果沒有標記且找不到 {name},則傳回空的列表。
範例
" Get a list of all the defined signs
echo sign_getdefined()
" Get the attribute of the sign named mySign
echo sign_getdefined("mySign")
參數
{name} (string?)
回傳
(vim.fn.sign_getdefined.ret.item[])
sign_getplaced([{buf} [, {dict}]]) sign_getplaced()
傳回放置在緩衝區或所有緩衝區中的標記列表。這類似於 :sign-place-list 命令。
如果指定了選用的緩衝區名稱 {buf},則僅傳回放置在該緩衝區中的標記列表。如需 {buf} 的用法,請參閱 bufname()。選用的 {dict} 可以包含以下項目:group:僅選取此群組中的標記。id:選取具有此識別碼的標記。lnum:選取放置在此行的標記。如需 {lnum} 的用法,請參閱 line()。如果 {group} 為 "*",則會傳回所有群組(包括全域群組)中的標記。如果未提供 {group} 或為空字串,則僅會傳回全域群組中的標記。如果未提供引數,則會傳回放置在所有緩衝區中的全域群組中的標記。請參閱 sign-group
傳回值中的每個列表項目都是一個字典,其中包含以下項目:bufnr:具有標記的緩衝區編號。signs:放置在 {bufnr} 中的標記列表。每個列表項目都是一個字典,其中包含下面列出的項目
每個標記的字典包含以下條目: group 標記群組。若為全域群組則設為 ''。id 標記的識別碼。lnum 標記所在行的行號。name 已定義標記的名稱。priority 標記的優先順序。
緩衝區中返回的標記會依據其行號和優先順序排序。
失敗或沒有放置任何標記時,返回空列表。
範例
" Get a List of signs placed in eval.c in the
" global group
echo sign_getplaced("eval.c")
" Get a List of signs in group 'g1' placed in eval.c
echo sign_getplaced("eval.c", {'group' : 'g1'})
" Get a List of signs placed at line 10 in eval.c
echo sign_getplaced("eval.c", {'lnum' : 10})
" Get sign with identifier 10 placed in a.py
echo sign_getplaced("a.py", {'id' : 10})
" Get sign with id 20 in group 'g1' placed in a.py
echo sign_getplaced("a.py", {'group' : 'g1',
                                \  'id' : 20})
" Get a List of all the placed signs
echo sign_getplaced()
參數
{buf} (integer|string?)
{dict} (vim.fn.sign_getplaced.dict?)
回傳
(vim.fn.sign_getplaced.ret.item[])
sign_jump({id}, {group}, {buf}) sign_jump()
開啟緩衝區 {buf} 或跳至包含 {buf} 的視窗,並將游標定位在群組 {group} 中標記 {id} 的位置。這類似於 :sign-jump 指令。
如果 {group} 為空字串,則使用全域群組。關於 {buf} 的用法,請參閱 bufname()
返回標記的行號。如果參數無效,則返回 -1。
範例
" Jump to sign 10 in the current buffer
call sign_jump(10, '', '')
參數
{id} (integer)
{group} (string)
{buf} (整數|字串)
回傳
(整數)
sign_place({id}, {group}, {name}, {buf} [, {dict}]) sign_place()
在檔案或緩衝區 {buf}{lnum} 行處放置定義為 {name} 的標記,並將 {id}{group} 指派給標記。這類似於 :sign-place 指令。
如果標記識別碼 {id} 為零,則會配置一個新的識別碼。否則,將使用指定的數字。{group} 是標記群組名稱。要使用全域標記群組,請使用空字串。{group} 作為 {id} 的命名空間,因此兩個群組可以使用相同的 ID。有關更多資訊,請參閱 sign-identifiersign-group
{name} 指的是已定義的標記。{buf} 指的是緩衝區名稱或數字。有關可接受的值,請參閱 bufname()
可選的 {dict} 參數支援以下條目:lnum 檔案或緩衝區 {buf} 中要放置標記的行號。有關可接受的值,請參閱 line()。priority 標記的優先順序。有關更多資訊,請參閱 sign-priority
如果未指定可選的 {dict},則會修改群組 {group} 中已放置的標記 {id} 以使用已定義的標記 {name}
成功時返回標記識別碼,失敗時返回 -1。
範例
" Place a sign named sign1 with id 5 at line 20 in
" buffer json.c
call sign_place(5, '', 'sign1', 'json.c',
                                \ {'lnum' : 20})
" Updates sign 5 in buffer json.c to use sign2
call sign_place(5, '', 'sign2', 'json.c')
" Place a sign named sign3 at line 30 in
" buffer json.c with a new identifier
let id = sign_place(0, '', 'sign3', 'json.c',
                                \ {'lnum' : 30})
" Place a sign named sign4 with id 10 in group 'g3'
" at line 40 in buffer json.c with priority 90
call sign_place(10, 'g3', 'sign4', 'json.c',
                \ {'lnum' : 40, 'priority' : 90})
參數
{id} (integer)
{group} (string)
{name} (string)
{buf} (整數|字串)
{dict} (vim.fn.sign_place.dict?)
回傳
(整數)
sign_placelist({list}) sign_placelist()
放置一個或多個標記。這類似於 sign_place() 函式。{list} 參數指定要放置的標記列表。每個列表項目都是一個字典,包含以下標記屬性:buffer 緩衝區名稱或數字。有關可接受的值,請參閱 bufname()。group 標記群組。{group} 作為 {id} 的命名空間,因此兩個群組可以使用相同的 ID。如果未指定或設定為空字串,則使用全域群組。有關更多資訊,請參閱 sign-group。id 標記識別碼。如果未指定或為零,則會配置一個新的唯一識別碼。否則,將使用指定的數字。有關更多資訊,請參閱 sign-identifier。lnum 緩衝區中要放置標記的行號。有關可接受的值,請參閱 line()。name 要放置的標記名稱。有關更多資訊,請參閱 sign_define()。priority 標記的優先順序。當一行上放置多個標記時,將使用優先順序最高的標記。如果未指定,則使用預設值 10,除非標記定義另有規定。有關更多資訊,請參閱 sign-priority
如果 {id} 指的是現有的標記,則會修改現有的標記以使用指定的 {name} 和/或 {priority}
返回標記識別碼的列表。如果放置標記失敗,則相應的列表項目會設定為 -1。
範例
" Place sign s1 with id 5 at line 20 and id 10 at line
" 30 in buffer a.c
let [n1, n2] = sign_placelist([
        \ {'id' : 5,
        \  'name' : 's1',
        \  'buffer' : 'a.c',
        \  'lnum' : 20},
        \ {'id' : 10,
        \  'name' : 's1',
        \  'buffer' : 'a.c',
        \  'lnum' : 30}
        \ ])
" Place sign s1 in buffer a.c at line 40 and 50
" with auto-generated identifiers
let [n1, n2] = sign_placelist([
        \ {'name' : 's1',
        \  'buffer' : 'a.c',
        \  'lnum' : 40},
        \ {'name' : 's1',
        \  'buffer' : 'a.c',
        \  'lnum' : 50}
        \ ])
參數
{list} (vim.fn.sign_placelist.list.item[])
回傳
(integer[])
sign_undefine([{name}]) sign_undefine()
sign_undefine({list}) 刪除先前定義的標記 {name}。這類似於 :sign-undefine 指令。如果未提供 {name},則會刪除所有已定義的標記。
可以使用一個參數 {list} 來取消定義標記的列表。每個列表項目都是一個標記的名稱。
成功時返回 0,失敗時返回 -1。對於一個參數的 {list} 呼叫,會返回一個值列表,每個值對應一個未定義的標記。
範例
" Delete a sign named mySign
call sign_undefine("mySign")
" Delete signs 'sign1' and 'sign2'
call sign_undefine(["sign1", "sign2"])
" Delete all the signs
call sign_undefine()
參數
{list} (string[]?)
回傳
(integer[])
sign_unplace({group} [, {dict}]) sign_unplace()
移除先前在一個或多個緩衝區中放置的標記。這類似於 :sign-unplace 指令。
{group} 是標記群組名稱。要使用全域標記群組,請使用空字串。如果將 {group} 設定為 "*",則會使用包括全域群組在內的所有群組。{group} 中的標記會根據 {dict} 中的條目選擇。支援 {dict} 中的以下可選條目:buffer 緩衝區名稱或數字。請參閱 bufname()。id 標記識別碼。如果未提供 {dict},則會移除 {group} 中的所有標記。
成功時返回 0,失敗時返回 -1。
範例
        " Remove sign 10 from buffer a.vim
        call sign_unplace('', {'buffer' : "a.vim", 'id' : 10})
        " Remove sign 20 in group 'g1' from buffer 3
        call sign_unplace('g1', {'buffer' : 3, 'id' : 20})
        " Remove all the signs in group 'g2' from buffer 10
        call sign_unplace('g2', {'buffer' : 10})
        " Remove sign 30 in group 'g3' from all the buffers
        call sign_unplace('g3', {'id' : 30})
        " Remove all the signs placed in buffer 5
        call sign_unplace('*', {'buffer' : 5})
        " Remove the signs in group 'g4' from all the buffers
        call sign_unplace('g4')
        " Remove sign 40 from all the buffers
        call sign_unplace('*', {'id' : 40})
        " Remove all the placed signs from all the buffers
        call sign_unplace('*')
Parameters: ~
  • {group} (`string`)
  • {dict} (`vim.fn.sign_unplace.dict?`)
Return: ~
  (`0|-1`)
sign_unplacelist({list}) sign_unplacelist()
從一個或多個緩衝區中移除先前放置的標記。這類似於 sign_unplace() 函式。
{list} 參數指定要移除的標記列表。每個列表項目都是一個字典,包含以下標記屬性:buffer 緩衝區名稱或數字。有關可接受的值,請參閱 bufname()。如果未指定,則會從所有緩衝區中移除指定的標記。group 標記群組名稱。如果未指定或設定為空字串,則使用全域標記群組。如果設定為 "*",則會使用包括全域群組在內的所有群組。id 標記識別碼。如果未指定,則會移除指定群組中的所有標記。
返回一個列表,如果成功移除對應的標記,則該列表的項目設定為 0,如果失敗則設定為 -1。
範例
" Remove sign with id 10 from buffer a.vim and sign
" with id 20 from buffer b.vim
call sign_unplacelist([
        \ {'id' : 10, 'buffer' : "a.vim"},
        \ {'id' : 20, 'buffer' : 'b.vim'},
        \ ])
參數
{list} (vim.fn.sign_unplacelist.list.item)
回傳
((0|-1)[])
simplify({filename}) simplify()
盡可能簡化檔案名稱,而不改變其含義。不會解析快捷方式(在 MS-Windows 上)或符號連結(在 Unix 上)。如果 {filename} 中的第一個路徑元件指定目前目錄,這也將適用於結果。也不會移除尾部的路徑分隔符。在 Unix 上,"//path" 不會變更,但 "///path" 會簡化為 "/path"(這遵循 Posix 標準)。範例
simplify("./dir/.././/file/") == "./file/"
注意: 只有當 "dir" 是可搜尋的目錄或不存在時,才會移除 "dir/.." 組合。在 Unix 上,當 "dir" 是同一目錄中的符號連結時也會移除。為了在簡化路徑名稱之前解析所有相關的符號連結,請使用 resolve()
參數
{filename} (string)
回傳
(any)
sin({expr}) sin()
以弧度為單位返回 {expr} 的正弦值,作為 Float{expr} 必須評估為 FloatNumber。如果 {expr} 不是 FloatNumber,則返回 0.0。範例
echo sin(100)
-0.506366
echo sin(-4.01)
0.763301
參數
{expr} (數字)
回傳
(any)
sinh({expr}) sinh()
Float 形式返回 {expr} 的雙曲正弦值,範圍為 [-inf, inf]。{expr} 必須評估為 FloatNumber。如果 {expr} 不是 FloatNumber,則返回 0.0。範例
echo sinh(0.5)
0.521095
echo sinh(-0.9)
-1.026517
參數
{expr} (數字)
回傳
(any)
slice({expr}, {start} [, {end}]) slice()
類似於使用 切片 "expr[start : end]",但 "end" 是獨佔的。對於字串,索引用作字元索引,而不是位元組索引。此外,組合成的字元會被視為前一個基本字元的一部分。當省略 {end} 時,切片會持續到最後一個項目。當 {end} 為 -1 時,會省略最後一個項目。如果 {start}{end} 無效,則返回空值。
參數
{expr} (任意)
{start} (integer)
{end_} (integer?)
回傳
(any)
sockconnect({mode}, {address} [, {opts}]) sockconnect()
將套接字連線到位址。如果 {mode} 是 "pipe",則 {address} 應該是本機網域套接字(在 Unix 上)或具名管道(在 Windows 上)的路徑。如果 {mode} 是 "tcp",則 {address} 應該採用 "host:port" 的形式,其中 host 應該是 IP 位址或主機名稱,而 port 是連接埠號碼。
對於 "pipe" 模式,請參閱 luv-pipe-handle。對於 "tcp" 模式,請參閱 luv-tcp-handle
返回 通道 ID。使用 chanclose() 關閉套接字。使用 chansend() 通過位元組套接字傳送資料,使用 rpcrequest()rpcnotify() 與 RPC 套接字通訊。
{opts} 是一個可選的字典,包含以下鍵:on_data:當從套接字讀取資料時呼叫的回呼函數。data_buffered:以 channel-buffered 模式讀取套接字資料。rpc:如果設定,將使用 msgpack-rpc 通過套接字通訊。返回
成功時的通道 ID(大於零)
參數無效或連線失敗時為 0。
參數
{mode} (string)
{address} (string)
{opts} (table?)
回傳
(any)
sort({list} [, {how} [, {dict}]]) sort() E702 就地排序 {list} 中的項目。返回 {list}
如果想要保留列表不被修改,請先建立副本。
let sortedlist = sort(copy(mylist))
{how} 省略或為字串時,sort() 會使用每個項目的字串表示形式進行排序。數字會排在字串之後,列表 會排在數字之後。若要在目前緩衝區中排序文字,請使用 :sort
當給定 {how} 且其為 'i' 時,會忽略大小寫。為了向後相容,可以使用值 1 來忽略大小寫。零表示不忽略大小寫。
當給定 {how} 且其為 'l' 時,會使用目前的排序區域設定進行排序。實作細節:使用 strcoll() 來比較字串。請參閱 :language 來檢查或設定排序區域設定。v:collate 也可用於檢查目前的區域設定。使用區域設定排序通常會忽略大小寫。範例
" ö is sorted similarly to o with English locale.
language collate en_US.UTF8
echo sort(['n', 'o', 'O', 'ö', 'p', 'z'], 'l')
['n', 'o', 'O', 'ö', 'p', 'z']
" ö is sorted after z with Swedish locale.
language collate sv_SE.UTF8
echo sort(['n', 'o', 'O', 'ö', 'p', 'z'], 'l')
['n', 'o', 'O', 'p', 'z', 'ö']
這在 Mac 上無法正常運作。
當給定 {how} 且其為 'n' 時,所有項目都將以數值方式排序(實作細節:這會使用 strtod() 函式來剖析數字,字串、列表、字典和函式參考將被視為 0)。
當給定 {how} 且其為 'N' 時,所有項目都將以數值方式排序。這類似於 'n',但包含數字的字串將用作它們所代表的數字。
當給定 {how} 且其為 'f' 時,所有項目都將以數值方式排序。所有值都必須是數字或浮點數。
{how}函式參考 或函式名稱時,會呼叫此函式來比較項目。該函式會以兩個項目作為引數來呼叫,如果它們相等則必須傳回零,如果第一個項目排序在第二個項目之後則傳回 1 或更大的值,如果第一個項目排序在第二個項目之前則傳回 -1 或更小的值。
{dict} 用於具有 "dict" 屬性的函式。它將用於設定局部變數 "self"。 字典函式
排序是穩定的,比較相等的項目(作為數字或字串)將保留它們的相對位置。例如,當按數字排序時,文字字串將彼此相鄰排序,順序與它們最初的順序相同。
範例
func MyCompare(i1, i2)
   return a:i1 == a:i2 ? 0 : a:i1 > a:i2 ? 1 : -1
endfunc
eval mylist->sort("MyCompare")
此特定簡單案例的較短比較版本,它會忽略溢位
func MyCompare(i1, i2)
   return a:i1 - a:i2
endfunc
對於簡單的運算式,您可以使用 lambda
eval mylist->sort({i1, i2 -> i1 - i2})
參數
{list} (any)
{how} (string|function?)
{dict} (any?)
回傳
(any)
soundfold({word}) soundfold()
傳回 {word} 的聲音摺疊等效形式。針對目前視窗使用 'spelllang' 中第一個支援聲音摺疊的語言。'spell' 必須設定。當無法進行聲音摺疊時,{word} 會以未修改的形式傳回。這可用於提出拼字建議。請注意,此方法可能相當慢。
參數
{word} (string)
回傳
(any)
spellbadword([{sentence}]) spellbadword()
沒有引數:結果是游標下方或之後拼寫錯誤的單字。游標會移動到錯誤單字的開頭。如果在游標行中找不到錯誤單字,則結果為空字串,且游標不會移動。
有引數:結果是 {sentence} 中第一個拼寫錯誤的單字。如果沒有拼字錯誤,則結果為空字串。
傳回值是一個包含兩個項目的列表
拼寫錯誤的單字或空字串。
拼字錯誤的類型:"bad" 拼字錯誤 "rare" 罕用字 "local" 僅在其他地區有效的單字 "caps" 單字應該以大寫字母開頭 範例
echo spellbadword("the quik brown fox")
[quik,bad]
會使用目前視窗的拼字資訊和 'spelllang' 的值。
參數
{sentence} (string?)
回傳
(any)
spellsuggest({word} [, {max} [, {capital}]]) spellsuggest()
傳回一個 列表,其中包含用來取代 {word} 的拼字建議。當給定 {max} 時,最多會傳回此數量的建議。否則最多會傳回 25 個建議。
當給定 {capital} 引數且其為非零值時,只會提供以大寫字母開頭的建議。在使用 'spellcapcheck' 進行比對後使用此引數。
{word} 可以是拼寫錯誤的單字,後接其他文字。這允許連接兩個被拆開的單字。建議也包含後續的文字,因此您可以取代一行。
{word} 也可能是一個正確的單字。然後會傳回類似的單字。{word} 本身不包含在建議中,儘管它可能會以大寫形式出現。
會使用目前視窗的拼字資訊。會使用 'spelllang''spellsuggest' 的值。
參數
{word} (string)
{max} (integer?)
{capital} (boolean?)
回傳
(any)
split({string} [, {pattern} [, {keepempty}]]) split()
{string} 建立一個 列表。當 {pattern} 省略或為空時,每個以空白分隔的字元序列都會變成一個項目。否則,會在 {pattern} 比對的位置分割字串,並移除比對的字元。'ignorecase' 在這裡不會使用,請加入 \c 以忽略大小寫。/\c 除非給定 {keepempty} 引數且其為非零值,否則會省略第一個或最後一個空的項目。當 {pattern} 比對至少一個字元或當 {keepempty} 為非零值時,會保留其他空的項目。範例
let words = split(getline('.'), '\W\+')
若要將字串分割成個別字元
for c in split(mystring, '\zs') | endfor
如果您想要保留分隔符號,您也可以在模式結尾使用 '\zs'
echo split('abc:def:ghi', ':\zs')
['abc:', 'def:', 'ghi']
分割第一個元素可能為空的表格
let items = split(line, ':', 1)
相反的函式是 join()
參數
{string} (string)
{pattern} (string?)
{keepempty} (boolean?)
回傳
(any)
sqrt({expr}) sqrt()
傳回浮點數 {expr} 的非負平方根,類型為 浮點數{expr} 的評估結果必須是 浮點數數字。當 {expr} 為負數時,結果為 NaN(非數字)。如果 {expr} 不是 浮點數數字,則傳回 0.0。範例
echo sqrt(100)
10.0
echo sqrt(-4.01)
str2float("nan") NaN 可能不同,這取決於系統程式庫。
參數
{expr} (數字)
回傳
(any)
srand([{expr}]) srand()
初始化 rand() 使用的種子
如果未給定 {expr},則種子值會透過讀取 /dev/urandom(如果可能),或使用 time(NULL)(又稱為紀元時間)來初始化;這只有秒級的精確度。
如果給定 {expr},則它必須是數字。它會用來初始化種子值。這適用於測試或當需要可預測的序列時。
範例
let seed = srand()
let seed = srand(userinput)
echo rand(seed)
參數
{expr} (number?)
回傳
(any)
state([{what}]) state()
傳回一個字串,其中包含表示目前狀態的字元。這在回呼中特別有用,它們想要執行可能不總是安全的工作。大致上,其運作方式如下
回呼使用 state() 來檢查工作是否安全可以執行。是:然後立即執行。否:將工作新增至工作佇列,並新增一個 SafeState 自動指令。
當觸發 SafeState 並執行您的自動指令時,請使用 state() 檢查工作是否可以立即執行,如果可以,則將其從佇列中移除並執行。如果佇列現在為空,則移除自動指令。另請參閱 mode()
當給定 {what} 時,只會新增此字串中的字元。例如,這會檢查畫面是否已捲動
if state('s') == ''
   " screen has not scrolled
這些字元表示狀態,通常表示某些作業忙碌中:m 映射中間,:normal 指令、feedkeys() 或 stuffed 指令 o 運算子擱置,例如在 d 之後 a 插入模式自動完成作用中 x 執行自動指令 S 不觸發 SafeState,例如在 f 或計數之後 c 呼叫回呼,包括計時器(重複使用以表示遞迴,最多可達 "ccc")s 畫面已捲動以顯示訊息
參數
{what} (string?)
回傳
(any)
stdioopen({opts}) stdioopen()
搭配 --headless,這會將 stdin 和 stdout 開啟為 通道。只能呼叫一次。請參閱 channel-stdio。此函式不會處理 stderr,請參閱 v:stderr
使用 chanclose() 關閉 stdio 控制代碼。使用 chansend() 將資料傳送到 stdout,並使用 rpcrequest()rpcnotify() 透過 RPC 進行通訊。
{opts} 是一個字典,具有以下索引鍵:on_stdin:在寫入 stdin 時呼叫的回呼。on_print:在 Nvim 需要列印訊息時呼叫的回呼,其中訊息(其類型為字串)作為唯一引數。stdin_buffered:在 channel-buffered 模式中讀取 stdin。rpc:如果設定,則會使用 msgpack-rpc 透過 stdio 進行通訊 傳回
成功時的 通道 ID(值永遠為 1)
引數無效時傳回 0
參數
{opts} (table)
回傳
(any)
stdpath({what}) stdpath() E6100 傳回各種預設檔案和目錄的 標準路徑位置。
{what} 類型 描述
cache 字串 快取目錄:外掛程式等的任意暫時儲存空間。config 字串 使用者設定目錄。init.vim 儲存在此處。config_dirs 列表 其他設定目錄。data 字串 使用者資料目錄。data_dirs 列表 其他資料目錄。log 字串 記錄目錄(也供外掛程式使用)。run 字串 執行目錄:用於通訊端、具名管道等的暫時本機儲存空間。state 字串 工作階段狀態目錄:用於儲存檔案草稿、交換、復原、shada
範例
echo stdpath("config")
參數
{what} ('cache'|'config'|'config_dirs'|'data'|'data_dirs'|'log'|'run'|'state')
回傳
(字串|字串[])
str2float({string} [, {quoted}]) str2float()
將字串 {string} 轉換為浮點數。這與在表達式中使用浮點數的效果大致相同,請參閱 floating-point-format。但它更寬容一些。例如,「1e40」是被接受的,但在表達式中您需要寫成「1.0e40」。十六進制形式「0x123」也被接受,但其他形式(如二進制或八進制)則不接受。當 {quoted} 存在且非零時,點號前的嵌入單引號會被忽略,因此「1'000.0」表示一千。數字後的文字會被靜默忽略。小數點始終是「.」,無論 locale 設定為何。逗號會結束數字:「12,345.67」會被轉換為 12.0。您可以使用 substitute() 來移除千位分隔符號。
let f = str2float(substitute(text, ',', '', 'g'))
如果轉換失敗,則返回 0.0。
參數
{string} (string)
{quoted} (boolean?)
回傳
(any)
str2list({string} [, {utf8}]) str2list()
返回一個列表,其中包含代表字串 {string} 中每個字元的數值。範例:
echo str2list(" ")                " returns [32]
echo str2list("ABC")                " returns [65, 66, 67]
list2str() 執行相反的操作。
始終使用 UTF-8 編碼,{utf8} 選項沒有作用,存在僅是為了向後相容。使用 UTF-8 時,組合字元會被正確處理。
        echo str2list("á")                " returns [97, 769]
Parameters: ~
  • {string} (`string`)
  • {utf8} (`boolean?`)
Return: ~
  (`any`)
str2nr({string} [, {base}]) str2nr()
將字串 {string} 轉換為數字。{base} 是轉換的基數,它可以是 2、8、10 或 16。當 {quoted} 存在且非零時,嵌入的單引號會被忽略,因此「1'000'000」表示一百萬。
{base} 被省略時,使用基數 10。這也表示開頭的零不會像預設的字串轉數字轉換那樣,導致使用八進制轉換。範例:
let nr = str2nr('0123')
{base} 為 16 時,開頭的「0x」或「0X」會被忽略。使用不同的基數,結果將為零。同樣地,當 {base} 為 8 時,開頭的「0」、「0o」或「0O」會被忽略;當 {base} 為 2 時,開頭的「0b」或「0B」會被忽略。數字後的文字會被靜默忽略。
如果 {string} 為空或發生錯誤,則返回 0。
參數
{string} (string)
{base} (integer?)
回傳
(any)
strcharlen({string}) strcharlen()
結果是一個數字,表示字串 {string} 中的字元數。組合字元會被忽略。strchars() 可以計算字元數,但會將組合字元分開計算。
如果 {string} 為空或發生錯誤,則返回 0。
另請參閱 strlen()strdisplaywidth()strwidth()
參數
{string} (string)
回傳
(any)
strcharpart({src}, {start} [, {len} [, {skipcc}]]) strcharpart()
strpart() 類似,但使用字元索引和長度,而不是位元組索引和長度。當 {skipcc} 被省略或為零時,組合字元會被分開計算。當 {skipcc} 設定為 1 時,組合字元會被視為前一個基本字元的一部分,類似於 slice()。當使用字元索引指向不存在的字元時,該字元會被省略,並被計為一個字元。例如:
echo strcharpart('abc', -1, 2)
結果為 'a'。
發生錯誤時傳回空字串。
參數
{src} (string)
{start} (integer)
{len} (integer?)
{skipcc} (boolean?)
回傳
(any)
strchars({string} [, {skipcc}]) strchars()
結果是一個數字,表示字串 {string} 中的字元數。當 {skipcc} 被省略或為零時,組合字元會被分開計算。當 {skipcc} 設定為 1 時,組合字元會被忽略。strcharlen() 始終會執行此操作。
發生錯誤時傳回零。
另請參閱 strlen()strdisplaywidth()strwidth()
{skipcc} 僅在 7.4.755 之後可用。為了向後相容,您可以定義一個包裝函式:
if has("patch-7.4.755")
  function s:strchars(str, skipcc)
    return strchars(a:str, a:skipcc)
  endfunction
else
  function s:strchars(str, skipcc)
    if a:skipcc
      return strlen(substitute(a:str, ".", "x", "g"))
    else
      return strchars(a:str)
    endif
  endfunction
endif
參數
{string} (string)
{skipcc} (boolean?)
回傳
(整數)
strdisplaywidth({string} [, {col}]) strdisplaywidth()
結果是一個數字,表示字串 {string}{col} 開始時(第一欄為零)在螢幕上佔用的顯示單元格數。當 {col} 被省略時,使用零。否則,它是要開始的螢幕欄位。這對於 Tab 字元很重要。會使用目前視窗的選項設定。這對於任何顯示不同的內容都很重要,例如 'tabstop''display'。當 {string} 包含具有東亞寬度類別模糊的字元時,此函式的傳回值取決於 'ambiwidth'。發生錯誤時返回零。另請參閱 strlen()strwidth()strchars()
參數
{string} (string)
{col}integer?
回傳
(整數)
strftime({format} [, {time}]) strftime()
結果是一個字串,它是格式化的日期和時間,由 {format} 字串指定。使用給定的 {time},如果未給定時間,則使用目前時間。接受的 {format} 取決於您的系統,因此這不是可攜式的!請參閱 C 函式 strftime() 的手冊頁,了解格式。結果的最大長度為 80 個字元。另請參閱 localtime()getftime()strptime()。可以使用 :language 命令來變更語言。範例:
  echo strftime("%c")                   " Sun Apr 27 11:49:23 1997
  echo strftime("%Y %b %d %X")           " 1997 Apr 27 11:53:25
  echo strftime("%y%m%d %T")           " 970427 11:53:55
  echo strftime("%H:%M")                   " 11:55
  echo strftime("%c", getftime("file.c"))
                                   " Show mod time of file.c.
Parameters: ~
  • {format} (`string`)
  • {time} (`number?`)
Return: ~
  (`string`)
strgetchar({str}, {index}) strgetchar()
取得 {str}{index} 位置的字元對應的數字。這使用基於零的字元索引,而不是位元組索引。此處將組合字元視為個別字元。使用 nr2char() 將數字轉換為字串。如果 {index} 無效,則返回 -1。另請參閱 strcharpart()strchars()
參數
{str} (string)
{index} (integer)
回傳
(整數)
stridx({haystack}, {needle} [, {start}]) stridx()
結果是一個數字,表示字串 {needle}{haystack} 中第一次出現的位元組索引。如果指定了 {start},則搜尋會從索引 {start} 開始。這可以用於尋找第二個匹配項:
let colon1 = stridx(line, ":")
let colon2 = stridx(line, ":", colon1 + 1)
搜尋會區分大小寫。對於模式搜尋,請使用 match()。如果 {needle} 未出現在 {haystack} 中,則返回 -1。另請參閱 strridx()。範例:
echo stridx("An Example", "Example")     " 3
echo stridx("Starting point", "Start")   " 0
echo stridx("Starting point", "start")   " -1
strstr() strchr() stridx() 的運作方式與 C 函式 strstr() 類似。當使用單個字元時,它的運作方式與 strchr() 類似。
參數
{haystack} (string)
{needle} (string)
{start} (整數?)
回傳
(整數)
string({expr}) string()
返回轉換為字串的 {expr}。如果 {expr} 是數字、浮點數、字串、Blob 或它們的組合,則可以使用 eval() 將結果重新剖析回原本的型態。
{expr} 型別 結果
字串 字串 數字 123 浮點數 123.123456 或 1.123456e8 或 str2float('inf') Funcref function('name') Blob 0z00112233.44556677.8899 列表 [項目, 項目] 字典 {鍵: 值, 鍵: 值} 請注意,在字串值中,' 字元會重複。另請參閱 strtrans()。 注意 2:輸出格式主要與 YAML 相容,但無限和 NaN 浮點數值表示除外,這些表示使用 str2float()。 字串也會以字面形式轉儲,只會逸出單引號,這不允許使用 YAML 來重新剖析二進位字串。 eval() 應該始終適用於字串和浮點數,並且這是唯一正式的方法。如果您需要與其他應用程式共用資料,請使用 msgpackdump()json_encode()
參數
{expr} (任意)
回傳
(string)
strlen({string}) strlen()
結果是一個數字,表示字串 {string} 的位元組長度。如果引數為數字,則會先將其轉換為字串。對於其他型別,會給出錯誤並返回零。如果您想要計算多位元組字元的數量,請使用 strchars()。另請參閱 len()strdisplaywidth()strwidth()
參數
{string} (string)
回傳
(整數)
strpart({src}, {start} [, {len} [, {chars}]]) strpart()
結果是一個字串,它是 {src} 的一部分,從位元組 {start} 開始,位元組長度為 {len}。當 {chars} 存在且為 TRUE 時,{len} 是字元位置的數量(組合字元不會分開計算,因此「1」表示一個基本字元和任何後續的組合字元)。要將 {start} 計算為字元而不是位元組,請使用 strcharpart()
當選取不存在的位元組時,這不會導致錯誤,這些位元組會被簡單地省略。如果遺失 {len},則複製會從 {start} 繼續到 {src} 的結尾。
echo strpart("abcdefg", 3, 2)    " returns 'de'
echo strpart("abcdefg", -2, 4)   " returns 'ab'
echo strpart("abcdefg", 5, 4)    " returns 'fg'
echo strpart("abcdefg", 3)         " returns 'defg'
注意: 要取得第一個字元,{start} 必須為 0。例如,要取得游標下的字元:
strpart(getline("."), col(".") - 1, 1, v:true)
發生錯誤時傳回空字串。
參數
{src} (string)
{start} (integer)
{len} (integer?)
{chars} (0|1?)
回傳
(string)
strptime({format}, {timestring}) strptime()
結果是一個數字,它是代表 {timestring} 中日期和時間的 Unix 時間戳記,預期 {timestring} 會符合 {format} 中指定的格式。
接受的 {format} 取決於您的系統,因此這不是可攜式的!請參閱 C 函式 strptime() 的手冊頁,了解格式。尤其要避免使用「%c」。$TZ 的值也很重要。
如果無法使用 {format} 剖析 {timestring},則返回零。如果您不知道 {timestring} 的格式,您可以嘗試不同的 {format} 值,直到獲得非零結果。
另請參閱 strftime()。範例:
echo strptime("%Y %b %d %X", "1997 Apr 27 11:49:23")
862156163
echo strftime("%c", strptime("%y%m%d %T", "970427 11:53:55"))
Sun Apr 27 11:53:55 1997
echo strftime("%c", strptime("%Y%m%d%H%M%S", "19970427115355") + 3600)
Sun Apr 27 12:53:55 1997
參數
{format} (string)
{timestring} (string)
回傳
(整數)
strridx({haystack}, {needle} [, {start}]) strridx()
結果是一個數字,表示字串 {needle}{haystack} 中最後一次出現的位元組索引。當指定了 {start} 時,會忽略此索引之後的匹配項。這可以用於尋找先前匹配項之前的匹配項:
let lastcomma = strridx(line, ",")
let comma2 = strridx(line, ",", lastcomma - 1)
搜尋會區分大小寫。對於模式搜尋,請使用 match()。如果 {needle} 未出現在 {haystack} 中,則返回 -1。如果 {needle} 為空,則返回 {haystack} 的長度。另請參閱 stridx()。範例:
echo strridx("an angry armadillo", "an")             3
strrchr()
當使用單個字元時,它的運作方式與 C 函式 strrchr() 類似。
參數
{haystack} (string)
{needle} (string)
{start} (整數?)
回傳
(整數)
strtrans({string}) strtrans()
結果是一個字串,它是 {string},其中所有不可列印字元都被轉換為可列印字元 'isprint'。就像它們在視窗中顯示的方式一樣。範例:
echo strtrans(@a)
這會在暫存器 a 中顯示換行符號為「^@」,而不是開始新的一行。
發生錯誤時傳回空字串。
參數
{string} (string)
回傳
(string)
strutf16len({string} [, {countcc}]) strutf16len()
結果是一個數字,表示字串 {string} 中的 UTF-16 碼元數(在將其轉換為 UTF-16 之後)。
{countcc} 為 TRUE 時,組合字元會被分開計算。當 {countcc} 被省略或為 FALSE 時,組合字元會被忽略。
發生錯誤時傳回零。
另請參閱 strlen()strcharlen()。範例:
echo strutf16len('a')                " returns 1
echo strutf16len('©')                " returns 1
echo strutf16len('😊')                " returns 2
echo strutf16len('ą́')                " returns 1
echo strutf16len('ą́', v:true)        " returns 3
參數
{string} (string)
{countcc} (0|1?)
回傳
(整數)
strwidth({string}) strwidth()
結果是一個數字,表示字串 {string} 佔用的顯示單元格數。Tab 字元計為一個單元格,或者使用 strdisplaywidth()。當 {string} 包含具有東亞寬度類別模糊的字元時,此函式的傳回值取決於 'ambiwidth'。發生錯誤時返回零。另請參閱 strlen()strdisplaywidth()strchars()
參數
{string} (string)
回傳
(整數)
submatch({nr} [, {list}]) submatch() E935 僅用於 :substitute 命令或 substitute() 函數中的表達式。返回匹配文本的第 {nr} 個子匹配。當 {nr} 為 0 時,返回整個匹配文本。請注意,字串中的 NL 可以代表多行匹配的換行符,或者文本中的 NUL 字元。另請參閱 sub-replace-expression
如果存在 {list} 且非零,則 submatch() 返回字串列表,類似於帶有兩個參數的 getline()。文字中的 NL 字元表示文字中的 NUL 字元。僅對於 :substitute 返回多個項目,在 substitute() 內部,此列表將始終包含一個或零個項目,因為沒有真正的換行符。
當遞迴使用 substitute() 時,只能獲取目前(最深層)呼叫中的子匹配。
錯誤時返回空字串或列表。
範例
s/\d\+/\=submatch(0) + 1/
echo substitute(text, '\d\+', '\=submatch(0) + 1', '')
這會找到行中的第一個數字並將其加一。換行符作為換行字元包含在內。
參數
{nr} (integer)
{list} (nil?)
回傳
(string)
substitute({string}, {pat}, {sub}, {flags}) substitute()
結果是一個字串,它是 {string} 的副本,其中 {pat} 的第一個匹配項會被 {sub} 替換。當 {flags} 為 "g" 時,{string} 中所有符合 {pat} 的匹配項都會被替換。否則,{flags} 應為 ""。
這就像 ":substitute" 命令(不帶任何旗標)一樣工作。但是 {pat} 的匹配始終像設定了 'magic' 選項並且 'cpoptions' 為空一樣完成(以使腳本具有可移植性)。 'ignorecase' 仍然相關,如果您想要忽略或匹配大小寫並忽略 'ignorecase',請使用 /\c/\C。不會使用 'smartcase'。有關如何使用 {pat} 的資訊,請參閱 string-match
{sub} 中的 "~" 不會被先前的 {sub} 替換。請注意,{sub} 中的某些程式碼具有特殊含義 sub-replace-special。例如,要將某個內容替換為 "\n"(兩個字元),請使用 "\\\\n" 或 '\\n'。
{pat}{string} 中不匹配時,將返回未修改的 {string}
範例
let &path = substitute(&path, ",\\=[^,]*$", "", "")
這會移除 'path' 選項的最後一個組成部分。
echo substitute("testing", ".*", "\\U\\0", "")
結果為 "TESTING"。
{sub} 以 "\=" 開頭時,剩餘部分將被解釋為表達式。請參閱 sub-replace-expression。範例
echo substitute(s, '%\(\x\x\)',
   \ '\=nr2char("0x" .. submatch(1))', 'g')
{sub} 是一個函式參考時,會呼叫該函式,並帶有一個可選參數。範例
echo substitute(s, '%\(\x\x\)', SubNr, 'g')
可選參數是一個列表,其中包含整個匹配字串以及最多九個子匹配,類似於 submatch() 返回的內容。範例
echo substitute(s, '%\(\x\x\)', {m -> '0x' .. m[1]}, 'g')
發生錯誤時傳回空字串。
參數
{string} (string)
{pat} (string)
{sub} (string)
{flags} (string)
回傳
(string)
swapfilelist() swapfilelist()
返回交換檔案名稱的列表,類似於 "vim -r" 顯示的內容。請參閱 -r 命令參數。 'directory' 選項用於檢查的目錄。如果您只想取得目前目錄中的交換檔案列表,請暫時將 'directory' 設定為一個點
        let save_dir = &directory
        let &directory = '.'
        let swapfiles = swapfilelist()
        let &directory = save_dir
Return: ~
  (`string[]`)
swapinfo({fname}) swapinfo()
結果是一個字典,其中包含關於交換檔案 {fname} 的資訊。可用的欄位包括:version Vim 版本 user 使用者名稱 host 主機名稱 fname 原始檔案名稱 pid 建立交換檔案的 Nvim 進程的 PID,如果未執行則為零。mtime 最後修改時間(以秒為單位) inode 可選:檔案的 INODE 編號 dirty 如果檔案已修改則為 1,如果未修改則為 0 如果失敗,則會新增一個帶有原因的 "error" 項目:Cannot open file: 找不到檔案或無法存取 Cannot read file: 無法讀取第一個區塊 Not a swap file: 不包含正確的區塊 ID Magic number mismatch: 第一個區塊中的資訊無效
參數
{fname} (字串)
回傳
(any)
swapname({buf}) swapname()
結果是緩衝區 {buf} 的交換檔案路徑。有關 {buf} 的用法,請參閱上面的 bufname()。如果緩衝區 {buf} 是目前緩衝區,則結果等於 :swapname(除非沒有交換檔案)。如果緩衝區 {buf} 沒有交換檔案,則返回空字串。
參數
{buf} (整數|字串)
回傳
(string)
synID({lnum}, {col}, {trans}) synID()
結果是一個數字,它是目前視窗中位置 {lnum}{col} 處的語法 ID。語法 ID 可以與 synIDattr()synIDtrans() 一起使用,以取得有關文字的語法資訊。
最左側欄的 {col} 為 1,第一行的 {lnum} 為 1。適用 'synmaxcol',在較長的行中,將返回零。請注意,當位置位於最後一個字元之後時(游標可以在插入模式下),synID() 會返回零。 {lnum} 的用法與 getline() 相同。
{trans}TRUE 時,透明項目會縮減為它們顯示的項目。當想要知道有效顏色時,這很有用。當 {trans}FALSE 時,將返回透明項目。當想要知道哪個語法項目有效時(例如,在括號內),這很有用。警告:此函數可能非常慢。透過正向瀏覽檔案可以獲得最佳速度。
發生錯誤時傳回零。
範例(回顯游標下語法項目的名稱)
echo synIDattr(synID(line("."), col("."), 1), "name")
參數
{lnum} (整數)
{col} (整數)
{trans} (0|1)
回傳
(整數)
synIDattr({synID}, {what} [, {mode}]) synIDattr()
結果是一個字串,它是語法 ID {synID}{what} 屬性。這可用於取得有關語法項目的資訊。{mode} 可以是 "gui" 或 "cterm",以取得該模式的屬性。當省略 {mode} 或使用無效值時,將使用目前作用中高亮的屬性(GUI 或 cterm)。使用 synIDtrans() 來追蹤連結的高亮群組。 {what} 結果 "name" 語法項目的名稱 "fg" 前景顏色(GUI:用於設定顏色的顏色名稱,cterm:以字串表示的顏色編號,term:空字串) "bg" 背景顏色(與 "fg" 相同) "font" 字型名稱(僅在 GUI 中可用) highlight-font "sp" 特殊顏色(與 "fg" 相同) guisp "fg#" 類似 "fg",但適用於 GUI,且 GUI 正在以 "#RRGGBB" 格式執行的名稱 "bg#" 類似 "fg#",但適用於 "bg" "sp#" 類似 "fg#",但適用於 "sp" "bold" 如果粗體則為 "1" "italic" 如果斜體則為 "1" "reverse" 如果反向則為 "1" "inverse" 如果反向(= 反向)則為 "1" "standout" 如果突出則為 "1" "underline" 如果有底線則為 "1" "undercurl" 如果有波浪底線則為 "1" "underdouble" 如果有雙底線則為 "1" "underdotted" 如果有點狀底線則為 "1" "underdashed" 如果有虛線底線則為 "1" "strikethrough" 如果有刪除線則為 "1" "altfont" 如果有替代字型則為 "1" "nocombine" 如果為 nocombine 則為 "1"
發生錯誤時傳回空字串。
範例(回顯游標下語法項目的顏色)
echo synIDattr(synIDtrans(synID(line("."), col("."), 1)), "fg")
也可以用作 方法
echo synID(line("."), col("."), 1)->synIDtrans()->synIDattr("fg")
參數
{synID} (integer)
{what} (string)
{mode} (string?)
回傳
(string)
synIDtrans({synID}) synIDtrans()
結果是一個數字,它是 {synID} 的轉換語法 ID。這是用於高亮顯示字元的語法群組 ID。將追蹤使用 ":highlight link" 給定的高亮連結。
發生錯誤時傳回零。
參數
{synID} (integer)
回傳
(整數)
synconcealed({lnum}, {col}) synconcealed()
結果是一個包含三個項目的 列表:1. 如果位置 {lnum}{col} 處的字元不屬於可隱藏區域,則列表中的第一個項目為 0;如果是,則為 1。{lnum} 的用法與 getline() 相同。 2. 列表中的第二個項目是一個字串。如果第一個項目為 1,則第二個項目包含將顯示以取代隱藏文字的文字,具體取決於 'conceallevel''listchars' 的目前設定。 3. 列表中的第三個也是最後一個項目是一個數字,表示該行中符合的特定語法區域。當字元未被隱藏時,值為零。如果兩個連續區域具有相同的替換字元,則可以偵測到新可隱藏區域的開始。例如,如果文字為 "123456",且 "23" 和 "45" 都被隱藏並由字元 "X" 替換,則
呼叫返回
synconcealed(lnum, 1) [0, '', 0] synconcealed(lnum, 2) [1, 'X', 1] synconcealed(lnum, 3) [1, 'X', 1] synconcealed(lnum, 4) [1, 'X', 2] synconcealed(lnum, 5) [1, 'X', 2] synconcealed(lnum, 6) [0, '', 0]
注意:不考慮 matchadd() 高亮項目,因為語法和匹配高亮是兩種不同的機制 syntax-vs-match
參數
{lnum} (整數)
{col} (整數)
回傳
([integer, string, integer])
synstack({lnum}, {col}) synstack()
返回一個 列表,它是目前視窗中位置 {lnum}{col} 處的語法項目堆疊。 {lnum} 的用法與 getline() 相同。列表中的每個項目都是一個 ID,類似於 synID() 返回的內容。列表中的第一個項目是外部區域,後面的項目包含在該項目中。最後一個是 synID() 返回的內容,除非未高亮顯示整個項目或它是透明項目。此函數對於偵錯語法檔案很有用。範例顯示游標下的語法堆疊
for id in synstack(line("."), col("."))
   echo synIDattr(id, "name")
endfor
當使用 {lnum}{col} 指定的位置無效時,會返回一個空列表。行中最後一個字元之後的位置和空行中的第一列是有效位置。
參數
{lnum} (整數)
{col} (整數)
回傳
(integer[])
system({cmd} [, {input}]) system() E677 注意:在 Lua 中,首選 vim.system()
取得 {cmd} 的輸出作為 字串systemlist() 返回一個 列表),並將 v:shell_error 設定為錯誤碼。 {cmd} 的處理方式與 jobstart() 中相同:如果 {cmd} 是一個列表,它會直接執行(不使用 'shell')。如果 {cmd} 是一個字串,它會像這樣在 'shell' 中執行
call jobstart(split(&shell) + split(&shellcmdflag) + ['{cmd}'])
不應用於互動式指令。
結果為字串,已過濾以避免平台特定的怪異行為。
<CR><NL> 會被取代為 <NL>
NUL 字元會被取代為 SOH (0x01)
範例
echo system(['ls', expand('%:h')])
如果 {input} 是字串,它會被寫入管道並作為標準輸入傳遞給指令。該字串會原樣寫入,不會變更行分隔符號。如果 {input}List,它會像 writefile() 一樣寫入管道,其中 {binary} 設為 "b"(即,在每個列表項目之間加入換行符號,而列表項目內的換行符號會轉換為 NUL)。當提供 {input} 且它是有效的緩衝區 ID 時,緩衝區的內容會逐行寫入檔案,每行以 NL 終止(且在文字有 NL 的地方以 NUL 終止)。E5677
注意:system() 無法寫入或讀取背景化的 ("&") shell 指令,例如
echo system("cat - &", "foo")
這等同於
$ echo foo | bash -c 'cat - &'
管道會在輸入傳送到它之前斷開(除非被 shell 重新導向語法覆寫)。請改用 jobstart()
注意:請使用 shellescape()::S,搭配 expand()fnamemodify(),以跳脫指令引數中的特殊字元。'shellquote''shellxquote' 必須正確設定。範例
echo system('ls '..shellescape(expand('%:h')))
echo system('ls '..expand('%:h:S'))
與 ":!cmd" 不同,這裡不會自動檢查已變更的檔案。請使用 :checktime 強制檢查。
參數
{cmd} (string|string[])
{input} (string|string[]|integer?)
回傳
(string)
systemlist({cmd} [, {input} [, {keepempty}]]) systemlist()
system() 相同,但會傳回一個 List,其中包含以 NL 分隔的行(輸出的一部分),且 NUL 已轉換為 NL。輸出與 readfile(){binary} 引數設為 "b" 時的輸出相同,但最後的換行符號不會保留,除非 {keepempty} 非零。請注意,在 MS-Windows 上您可能會取得尾隨的 CR 字元。
若要查看 "echo hello" 和 "echo -n hello" 之間的差異,請使用 system()split()
echo split(system('echo hello'), '\n', 1)
發生錯誤時傳回空字串。
參數
{cmd} (string|string[])
{input} (string|string[]|integer?)
{keepempty} (integer?)
回傳
(string[])
tabpagebuflist([{arg}]) tabpagebuflist()
結果為 List,其中每個項目是目前標籤頁中與每個視窗相關聯的緩衝區編號。{arg} 指定要使用的標籤頁編號。省略時會使用目前的標籤頁。當 {arg} 無效時,會傳回數字零。若要取得所有標籤中所有緩衝區的列表,請使用此指令
let buflist = []
for i in range(tabpagenr('$'))
   call extend(buflist, tabpagebuflist(i + 1))
endfor
請注意,一個緩衝區可能會出現在多個視窗中。
參數
{arg} (integer?)
回傳
(any)
tabpagenr([{arg}]) tabpagenr()
結果為數字,即目前標籤頁的編號。第一個標籤頁的編號為 1。
選用的引數 {arg} 支援下列值:$ 最後一個標籤頁的編號(標籤頁計數)。# 最後存取的標籤頁的編號(g<Tab> 會前往該標籤頁)。如果沒有先前的標籤頁,則會傳回 0。此數字可以用於 :tab 指令。
發生錯誤時傳回零。
參數
{arg} ('$'|'#'?)
回傳
(整數)
tabpagewinnr({tabarg} [, {arg}]) tabpagewinnr()
winnr() 類似,但適用於標籤頁 {tabarg}{tabarg} 指定要使用的標籤頁編號。{arg} 的使用方式與 winnr() 相同
省略時會傳回目前的視窗編號。這是前往此標籤頁時將使用的視窗。
當為 "$" 時,會傳回視窗的編號。
當為 "#" 時,會傳回先前的視窗編號。有用的範例
tabpagewinnr(1)            " current window of tab page 1
tabpagewinnr(4, '$')    " number of windows in tab page 4
{tabarg} 無效時,會傳回零。
參數
{tabarg} (integer)
{arg} ('$'|'#'?)
回傳
(整數)
tagfiles() tagfiles()
傳回一個 List,其中包含用於搜尋目前緩衝區標籤的檔案名稱。這是展開的 'tags' 選項。
回傳
(string[])
taglist({expr} [, {filename}]) taglist()
傳回一個 List,其中包含與規則運算式 {expr} 匹配的標籤。
如果傳遞 {filename},它會以與 :tselect 相同的方式優先處理結果。請參閱 tag-priority{filename} 應為檔案的完整路徑。
每個列表項目都是一個字典,其中至少包含下列項目:name 標籤的名稱。filename 定義標籤的檔案名稱。它是相對於目前目錄的路徑或完整路徑。cmd 用於在檔案中尋找標籤的 ex 指令。kind 標籤的類型。此項目的值取決於語言特定的類型值。僅在使用 Universal/Exuberant ctags 或 hdrtag 產生的標籤檔時可用。static 檔案特定的標籤。如需更多資訊,請參閱 static-tag。可能會出現更多項目,取決於標籤檔的內容:access、implementation、inherits 和 signature。如需這些欄位的相關資訊,請參閱 ctags 文件。對於 C 程式碼,可能會出現 "struct"、"class" 和 "enum" 欄位,它們會提供標籤所包含的實體的名稱。
ex 指令 "cmd" 可以是 ex 搜尋模式、行號或行號後接位元組號。
如果沒有匹配的標籤,則會傳回空列表。
若要取得完全符合的標籤,應在 {expr} 中使用錨點 '^' 和 '$'。這也會使函式執行得更快。如需有關標籤搜尋規則運算式模式的更多資訊,請參閱 tag-regexp
如需有關 Vim 如何尋找標籤檔的資訊,請參閱 'tags'。如需不同 ctags 工具產生的標籤檔格式資訊,請參閱 tags-file-format
參數
{expr} (任意)
{filename} (string?)
回傳
(any)
tan({expr}) tan()
以弧度為單位傳回 {expr} 的正切值,以範圍 [-inf, inf] 中的 Float 形式傳回。{expr} 必須評估為 FloatNumber。如果 {expr} 不是 FloatNumber,則傳回 0.0。範例
echo tan(10)
0.648361
echo tan(-4.01)
-1.181502
參數
{expr} (數字)
回傳
(數字)
tanh({expr}) tanh()
以範圍 [-1, 1] 中的 Float 形式傳回 {expr} 的雙曲正切值。{expr} 必須評估為 FloatNumber。如果 {expr} 不是 FloatNumber,則傳回 0.0。範例
echo tanh(0.5)
0.462117
echo tanh(-1)
-0.761594
參數
{expr} (數字)
回傳
(數字)
tempname() tempname()
產生一個(不存在的)檔案名稱,位於 Nvim 根目錄 tempdir 中。指令碼可以使用該檔案名稱作為臨時檔案。範例
let tmpfile = tempname()
exe "redir > " .. tmpfile
回傳
(string)
termopen({cmd} [, {opts}]) termopen()
在連接到目前(未修改)緩衝區的新偽終端機工作階段中衍生 {cmd}。參數和行為與 jobstart() 相同,但 "pty"、"width"、"height" 和 "TERM" 會被忽略: "height" 和 "width" 取自目前的視窗。請注意,termopen() 隱含 jobstart() 的 "pty" 引數,因此具有 jobstart() 中記載的含義。
傳回與 jobstart() 相同的值。
終端機環境會如 jobstart-env 中初始化,但 $TERM 會設為 "xterm-256color"。完整行為在 terminal 中說明。
參數
{cmd} (string|string[])
{opts} (table?)
回傳
(any)
test_garbagecollect_now() test_garbagecollect_now()
garbagecollect() 類似,但會立即執行。必須直接呼叫此項,以避免內部存在任何結構,且在呼叫任何函式之前必須先設定 v:testingE1142
回傳
(any)
timer_info([{id}]) timer_info()
傳回包含計時器相關資訊的列表。當提供 {id} 時,只會傳回此計時器的資訊。當計時器 {id} 不存在時,會傳回空列表。當省略 {id} 時,會傳回所有計時器的資訊。
每個計時器的資訊會儲存在 Dictionary 中,其中包含下列項目:"id" 計時器 ID、"time" 計時器的起始時間、"repeat" 計時器仍會觸發的次數;-1 表示永遠觸發、"callback" 回呼
參數
{id} (integer?)
回傳
(any)
timer_pause({timer}, {paused}) timer_pause()
暫停或取消暫停計時器。暫停的計時器在其時間到期時不會呼叫其回呼。如果已過足夠的時間,則取消暫停計時器可能會導致立即呼叫回呼。
暫停計時器有助於避免在短時間內呼叫回呼。
如果 {paused} 評估為非零的 Number 或非空字串,則會暫停計時器,否則會取消暫停計時器。請參閱 non-zero-arg
參數
{timer} (integer)
{paused} (boolean)
回傳
(any)
timer_start({time}, {callback} [, {options}]) timer_start() timer 建立計時器並傳回計時器 ID。
{time} 是等待時間,以毫秒為單位。這是呼叫回呼之前的最短時間。當系統忙碌或 Vim 沒有等待輸入時,時間會更長。可以使用零來在 Vim 回到主迴圈時執行回呼。
{callback} 是要呼叫的函式。它可以是函式的名稱或 Funcref。它會使用一個引數呼叫,即計時器 ID。僅當 Vim 等待輸入時,才會呼叫回呼。
{options} 是一個字典。支援的項目:"repeat" 重複回呼的次數。-1 表示永遠重複。預設值為 1。如果計時器連續三次發生錯誤,則會取消重複。
發生錯誤時,返回 -1。
範例
func MyHandler(timer)
  echo 'Handler called'
endfunc
let timer = timer_start(500, 'MyHandler',
        \ {'repeat': 3})
這會以 500 毫秒間隔呼叫 MyHandler() 三次。
參數
{time} (number)
{callback} (string|function)
{options} (table?)
回傳
(any)
timer_stop({timer}) timer_stop()
停止計時器。不再呼叫計時器回呼。{timer} 是 timer_start() 傳回的 ID,因此它必須是數字。如果 {timer} 不存在,則不會產生錯誤。
參數
{timer} (integer)
回傳
(any)
timer_stopall() timer_stopall()
停止所有計時器。不再呼叫計時器回呼。如果某些計時器行為異常,則很有用。如果沒有計時器,則不會產生錯誤。
回傳
(any)
tolower({expr}) tolower()
結果是所給定字串的副本,所有大寫字元都會轉換為小寫(就像對字串套用 gu 一樣)。如果發生錯誤,則傳回空字串。
參數
{expr} (string)
回傳
(string)
toupper({expr}) toupper()
結果是所給定字串的副本,所有小寫字元都會轉換為大寫(就像對字串套用 gU 一樣)。如果發生錯誤,則傳回空字串。
參數
{expr} (string)
回傳
(string)
tr({src}, {fromstr}, {tostr}) tr()
結果會是 {src} 字串的副本,其中所有出現在 {fromstr} 中的字元都會被 {tostr} 字串中相同位置的字元取代。因此,{fromstr} 中的第一個字元會被翻譯成 {tostr} 中的第一個字元,依此類推。這就像 unix 的 "tr" 命令一樣。此程式碼也能正確處理多位元組字元。
發生錯誤時傳回空字串。
範例
echo tr("hello there", "ht", "HT")
傳回 "Hello THere"
echo tr("<blob>", "<>", "{}")
傳回 "{blob}"
參數
{src} (string)
{fromstr} (string)
{tostr} (string)
回傳
(string)
trim({text} [, {mask} [, {dir}]]) trim()
傳回 {text} 字串,其中任何在 {mask} 中的字元都會從 {text} 的開頭和/或結尾移除。
如果沒有給定 {mask},或是空字串,則 {mask} 為所有直到 0x20 的字元,包含 Tab、空格、NL 和 CR,再加上不斷行空格字元 0xa0。
可選的 {dir} 參數指定從何處移除字元:0 從 {text} 的開頭和結尾移除,1 只從 {text} 的開頭移除,2 只從 {text} 的結尾移除。省略時,兩端都會被修剪。
此函式可正確處理多位元組字元。發生錯誤時傳回空字串。
範例
echo trim("   some text ")
傳回 "some text"
echo trim("  \r\t\t\r RESERVE \t\n\x0B\xA0") .. "_TAIL"
傳回 "RESERVE_TAIL"
echo trim("rm<Xrm<>X>rrm", "rm<>")
傳回 "Xrm<>X" (中間的字元不會被移除)
echo trim("  vim  ", " ", 2)
傳回 " vim"
參數
{text} (字串)
{mask} (string?)
{dir} (0|1|2?)
回傳
(string)
trunc({expr}) trunc()
傳回小於或等於 {expr} 的最大整數值,以 Float 型態表示 (朝零截斷)。{expr} 的計算結果必須為 FloatNumber。如果 {expr} 不是 FloatNumber,則傳回 0.0。範例
echo trunc(1.456)
1.0
echo trunc(-5.456)
-5.0
echo trunc(4.0)
4.0
參數
{expr} (數字)
回傳
(整數)
type({expr}) type()
結果是一個數字,表示 {expr} 的類型。與其直接使用數字,不如使用 v:t_ 變數,其值如下:數字:0 v:t_number 字串:1 v:t_string 函式參考:2 v:t_func 列表:3 v:t_list 字典:4 v:t_dict 浮點數:5 v:t_float 布林值:6 v:t_bool (v:falsev:true) Null:7 (v:null) Blob:10 v:t_blob 為了向後相容,可以使用此方法
if type(myvar) == type(0) | endif
if type(myvar) == type("") | endif
if type(myvar) == type(function("tr")) | endif
if type(myvar) == type([]) | endif
if type(myvar) == type({}) | endif
if type(myvar) == type(0.0) | endif
if type(myvar) == type(v:true) | endif
與其檢查 v:null 類型,不如直接檢查 v:null,因為它是此類型的唯一值
if myvar is v:null | endif
要檢查 v:t_ 變數是否存在,請使用此方法
if exists('v:t_number') | endif
參數
{expr} (任意)
回傳
(整數)
undofile({name}) undofile()
傳回寫入時,名稱為 {name} 的檔案將使用的復原檔案名稱。這會使用 'undodir' 選項,尋找存在的目錄。它不會檢查復原檔案是否存在。{name} 會始終展開為完整路徑,因為這是內部使用的路徑。如果 {name} 為空,undofile() 會傳回空字串,因為沒有檔案名稱的緩衝區不會寫入復原檔案。與 :wundo:rundo 搭配使用時很有用。
參數
{name} (string)
回傳
(string)
undotree([{buf}]) undotree()
傳回目前緩衝區,或如果給定 {buf},則傳回指定緩衝區的復原樹的目前狀態。結果是一個字典,其中包含下列項目:"seq_last" 最後使用的最高復原序列號。"seq_cur" 復原樹中目前位置的序列號。當某些變更被復原時,此數字與 "seq_last" 不同。"time_cur" 最後一次用於 :earlier 和相關命令的時間。使用 strftime() 轉換為可讀取的格式。"save_last" 上次寫入檔案的次數。尚未寫入時為零。"save_cur" 復原樹中目前位置的次數。"synced" 當最後的復原區塊被同步時,為非零值。當等待使用者輸入時,會發生這種情況。請參閱 undo-blocks。"entries" 包含復原區塊資訊的字典列表。
"entries" 列表中的第一個項目是最舊的復原項目。每個列表項目都是一個 Dictionary,其中包含下列項目:"seq" 復原序列號。與 :undolist 中顯示的相同。"time" 變更發生時的時間戳記。使用 strftime() 轉換為可讀取的格式。"newhead" 只會出現在最後新增的項目中。這標記最後的變更以及後續變更將新增的位置。"curhead" 只會出現在最後復原的項目中。這標記復原樹中的目前位置,即 redo 命令將使用的區塊。如果在最後的變更後沒有復原任何內容,則此項目不會出現在任何位置。"save" 只會出現在寫入檔案之前的最後一個區塊中。數字是寫入計數。第一次寫入的數字為 1,最後一次寫入的數字為上述的 "save_last"。"alt" 替代項目。這又是復原區塊的列表。每個項目可能又會有一個 "alt" 項目。
參數
{buf} (integer|string?)
回傳
(vim.fn.undotree.ret)
uniq({list} [, {func} [, {dict}]]) uniq() E882 就地移除 {list} 中重複相鄰項目的第二個及後續副本。傳回 {list}。如果您希望列表保持不變,請先複製一份
let newlist = uniq(copy(mylist))
預設的比較函式會使用每個項目的字串表示法。關於 {func}{dict} 的使用,請參閱 sort()
如果 {list} 不是 List,則傳回零。
參數
{list} (any)
{func} (any?)
{dict} (any?)
回傳
(any[]|0)
utf16idx({string}, {idx} [, {countcc} [, {charidx}]]) utf16idx()
charidx() 相同,但傳回 {string} 中位於 {idx} 的位元組的 UTF-16 碼位索引 (在將其轉換為 UTF-16 之後)。
{charidx} 存在且為 TRUE 時,{idx} 會被當成字串 {string} 中的字元索引,而不是位元組索引。UTF-8 序列中間的 {idx} 會向下捨入到該序列的開頭。
如果引數無效,或者 {string} 中的位元組少於 {idx} 個,則傳回 -1。如果正好有 {idx} 個位元組,則傳回字串中 UTF-16 碼位的長度。
請參閱 byteidx()byteidxcomp() 以取得從 UTF-16 索引取得位元組索引,並參閱 charidx() 以取得從 UTF-16 索引取得字元索引。有關更多資訊,請參閱 string-offset-encoding。範例
echo utf16idx('a😊😊', 3)        " returns 2
echo utf16idx('a😊😊', 7)        " returns 4
echo utf16idx('a😊😊', 1, 0, 1)        " returns 2
echo utf16idx('a😊😊', 2, 0, 1)        " returns 4
echo utf16idx('aą́c', 6)                " returns 2
echo utf16idx('aą́c', 6, 1)        " returns 4
echo utf16idx('a😊😊', 9)        " returns -1
參數
{string} (string)
{idx} (integer)
{countcc} (boolean?)
{charidx} (boolean?)
回傳
(整數)
values({dict}) values()
傳回包含 {dict} 所有值的 ListList 的順序是任意的。另請參閱 items()keys()。如果 {dict} 不是 Dict,則傳回零。
參數
{dict} (any)
回傳
(any)
virtcol({expr} [, {list} [, {winid}]]) virtcol()
結果是一個數字,它是以 {expr} 給定的檔案位置的螢幕欄位。也就是說,當螢幕寬度不受限制時,該位置的字元所佔用的最後一個螢幕位置。當位置有一個 <Tab> 時,傳回的數字將是 <Tab> 結尾的欄位。例如,對於欄位 1 中的 <Tab>'ts' 設定為 8,它會傳回 8。隱藏會被忽略。如要取得位元組位置,請使用 col()
關於 {expr} 的使用,請參閱 getpos()col()。當 {expr} 為 "$" 時,表示游標行的結尾,因此結果是游標行中的儲存格數量加一。
當使用 'virtualedit' 時,{expr} 可以是 [lnum, col, off],其中 "off" 是從字元開頭到螢幕欄位的偏移量。例如,<Tab> 內或最後一個字元後的位置。當省略 "off" 時,會使用零。當虛擬編輯在目前模式下啟用時,可以傳回超出該行結尾的位置。另請參閱 'virtualedit'
如果 {list} 存在且非零,則 virtcol() 會傳回一個列表,其中包含字元佔用的第一個和最後一個螢幕位置。
使用可選的 {winid} 參數,會取得該視窗的值,而不是目前視窗的值。
請注意,只能使用目前檔案中的標記。範例
" With text "foo^Lbar" and cursor on the "^L":
echo virtcol(".")        " returns 5
echo virtcol(".", 1)        " returns [4, 5]
echo virtcol("$")        " returns 9
" With text "          there", with 't at 'h':
echo virtcol("'t")        " returns 6
第一欄為 1。發生錯誤時會傳回 0 或 [0, 0]。
一個更進階的範例,它會回應所有行的最大長度
echo max(map(range(1, line('$')), "virtcol([v:val, '$'])"))
參數
{expr} (string|integer[])
{list} (boolean?)
{winid} (整數?)
回傳
(any)
virtcol2col({winid}, {lnum}, {col}) virtcol2col()
結果是一個數字,它是視窗 {winid} 中緩衝區行 {lnum} 和虛擬欄位 {col} 的字元位元組索引。
如果緩衝區行 {lnum} 是空行,則會傳回 0。
如果 {col} 大於行 {lnum} 中的最後一個虛擬欄位,則會傳回最後一個虛擬欄位中字元的位元組索引。
對於多位元組字元,會傳回字元中第一個位元組的欄位號碼。
{winid} 引數可以是視窗號碼或 視窗 ID。如果此值為零,則會使用目前的視窗。
如果視窗 {winid} 不存在,或者緩衝區行 {lnum} 或虛擬欄位 {col} 無效,則傳回 -1。
另請參閱 screenpos()virtcol()col()
參數
{winid} (integer)
{lnum} (整數)
{col} (整數)
回傳
(any)
visualmode([{expr}]) visualmode()
結果是一個字串,描述目前緩衝區中最後使用的視覺模式。最初它會傳回空字串,但一旦使用視覺模式,它會分別為字元方式、行方式或區塊方式視覺模式傳回 "v"、"V" 或 "<CTRL-V>" (單個 CTRL-V 字元)。範例
exe "normal " .. visualmode()
這會進入與之前相同的視覺模式。如果您希望根據使用的視覺模式採取不同的動作,這在腳本中也很有用。如果視覺模式處於活動狀態,請使用 mode() 來取得視覺模式 (例如,在 :vmap 中)。如果提供了 {expr},且其評估結果為非零數值或非空字串,則視覺模式將會被清除,並傳回舊值。請參閱 non-zero-arg
參數
{expr} (boolean?)
回傳
(any)
wait({timeout}, {condition} [, {interval}]) wait()
等待直到 {condition} 評估為 TRUE,其中 {condition} 是包含運算式的 函式參考字串
{timeout} 是最大等待時間,以毫秒為單位,-1 表示永遠等待。
條件會在使用者事件、內部事件以及每隔 {interval} 毫秒 (預設值:200) 評估一次。
傳回狀態整數: 0 表示條件在逾時前滿足; -1 表示超過逾時時間; -2 表示函式被中斷 (透過 CTRL-C); -3 表示發生錯誤
參數
{timeout} (integer)
{condition} (any)
{interval} (number?)
回傳
(any)
wildmenumode() wildmenumode()
當 wildmenu 處於活動狀態時,傳回 TRUE,否則傳回 FALSE。請參閱 'wildmenu''wildmode'。這可以用於映射中,以便優雅地處理 'wildcharm' 選項。(僅對 mapmode-c 映射有意義)。
例如,要使 <c-j> 在 wildmode 中像 <down> 一樣工作,請使用
cnoremap <expr> <C-j> wildmenumode() ? "\<Down>\<Tab>" : "\<c-j>"
(注意:這需要適當設定 'wildcharm' 選項)。
回傳
(any)
win_execute({id}, {command} [, {silent}]) win_execute()
execute() 類似,但在視窗 {id} 的上下文中執行。視窗將臨時設為目前視窗,而不會觸發自動指令或變更目錄。執行 {command} 時會觸發自動指令,這可能會產生意外的副作用。如果需要,請使用 :noautocmd。範例
call win_execute(winid, 'syntax enable')
使用 setwinvar() 執行相同的操作不會觸發自動指令,也不會實際顯示語法高亮。
當視窗 {id} 不存在時,不會給出錯誤,且會傳回空字串。
參數
{id} (integer)
{command} (string)
{silent} (boolean?)
回傳
(any)
win_findbuf({bufnr}) win_findbuf()
傳回一個 列表,其中包含包含緩衝區 {bufnr} 的視窗的 視窗 ID。如果沒有,則列表為空。
參數
{bufnr} (integer)
回傳
(integer[])
win_getid([{win} [, {tab}]]) win_getid()
取得指定視窗的 視窗 ID。如果缺少 {win},則使用目前視窗。使用 {win} 時,這是視窗編號。頂部視窗的編號為 1。如果沒有 {tab},則使用目前的標籤頁,否則使用編號為 {tab} 的標籤頁。第一個標籤頁的編號為 1。如果找不到視窗,則傳回零。
參數
{win} (integer?)
{tab} (integer?)
回傳
(整數)
win_gettype([{nr}]) win_gettype()
傳回視窗類型:「autocmd」自動指令視窗。用於執行自動指令的臨時視窗。「command」命令列視窗 cmdwin (空) 一般視窗「loclist」位置列表視窗「popup」浮動視窗 api-floatwin 「preview」預覽視窗 預覽視窗「quickfix」快速修正視窗 「unknown」找不到視窗 {nr}
如果省略 {nr},則傳回目前視窗的類型。如果給定 {nr},則傳回此視窗的類型,以編號或 視窗 ID 表示。
另請參閱 'buftype' 選項。
參數
{nr} (整數?)
回傳
('autocmd'|'command'|''|'loclist'|'popup'|'preview'|'quickfix'|'unknown')
win_gotoid({expr}) win_gotoid()
跳至 ID 為 {expr} 的視窗。這也可能會變更目前的標籤頁。如果成功,則傳回 TRUE,如果找不到視窗,則傳回 FALSE。
參數
{expr} (integer)
回傳
(0|1)
win_id2tabwin({expr}) win_id2tabwin()
傳回一個列表,其中包含 ID 為 {expr} 的視窗的標籤頁編號和視窗編號:[tabnr, winnr]。如果找不到視窗,則傳回 [0, 0]。
參數
{expr} (integer)
回傳
(any)
win_id2win({expr}) win_id2win()
傳回 ID 為 {expr} 的視窗的視窗編號。如果目前標籤頁中找不到視窗,則傳回 0。
參數
{expr} (integer)
回傳
(any)
win_move_separator({nr}, {offset}) win_move_separator()
將視窗 {nr} 的垂直分隔線 (即右邊框) 移動 {offset} 個欄位,就像使用滑鼠拖曳一樣。{nr} 可以是視窗編號或 視窗 ID。正數 {offset} 向右移動,負數 {offset} 向左移動。移動視窗的垂直分隔線會變更視窗的寬度以及與垂直分隔線相鄰的其他視窗的寬度。移動的幅度可能會小於指定的幅度 (例如,由於維持 'winminwidth')。如果可以找到視窗,則傳回 TRUE,否則傳回 FALSE。這對於最右邊的視窗和全寬視窗會失敗,因為它右側沒有分隔線。僅適用於目前的標籤頁。 E1308
參數
{nr} (integer)
{offset} (integer)
回傳
(any)
win_move_statusline({nr}, {offset}) win_move_statusline()
將視窗 {nr} 的狀態列 (即底部邊框) 移動 {offset} 列,就像使用滑鼠拖曳一樣。{nr} 可以是視窗編號或 視窗 ID。正數 {offset} 向下移動,負數 {offset} 向上移動。移動視窗的狀態列會變更視窗的高度以及與狀態列相鄰的其他視窗的高度。移動的幅度可能會小於指定的幅度 (例如,由於維持 'winminheight')。如果可以找到視窗,則傳回 TRUE,否則傳回 FALSE。僅適用於目前的標籤頁。
參數
{nr} (integer)
{offset} (integer)
回傳
(any)
win_screenpos({nr}) win_screenpos()
以包含兩個數字的列表形式傳回視窗 {nr} 的螢幕位置:[列, 欄]。第一個視窗的位置始終為 [1, 1],除非有標籤列,否則為 [2, 1]。{nr} 可以是視窗編號或 視窗 ID。對於目前視窗,請使用零。如果找不到視窗,則傳回 [0, 0]。
參數
{nr} (integer)
回傳
(any)
win_splitmove({nr}, {target} [, {options}]) win_splitmove()
暫時切換到視窗 {target},然後將視窗 {nr} 移動到與 {target} 相鄰的新分割畫面。與 :split 等命令不同,不會建立新的視窗 (移動後,視窗 {nr}視窗 ID 不會變更)。
{nr}{target} 都可以是視窗編號或 視窗 ID。兩者都必須位於目前的標籤頁中。
成功時傳回零,失敗時傳回非零值。
{options} 是一個 字典,其中包含以下可選項目:「vertical」當為 TRUE 時,會像使用 :vsplit 一樣垂直建立分割畫面。「rightbelow」當為 TRUE 時,分割畫面會建立在下方或右側 (如果為垂直)。當為 FALSE 時,則建立在上方或左側 (如果為垂直)。如果不存在,則使用 'splitbelow''splitright' 的值。
參數
{nr} (integer)
{target} (integer)
{options} (table?)
回傳
(any)
winbufnr({nr}) winbufnr()
結果是一個數字,它是與視窗 {nr} 相關聯的緩衝區編號。{nr} 可以是視窗編號或 視窗 ID。當 {nr} 為零時,會傳回目前視窗中緩衝區的編號。當視窗 {nr} 不存在時,會傳回 -1。範例
echo "The file in the current window is " .. bufname(winbufnr(0))
參數
{nr} (integer)
回傳
(整數)
wincol() wincol()
結果是一個數字,它是游標在視窗中的虛擬欄。這是從視窗左側開始計算螢幕儲存格。最左邊的欄是 1。
回傳
(整數)
windowsversion() windowsversion()
結果是一個字串。對於 MS-Windows,它會指出作業系統版本。例如,Windows 10 是「10.0」,Windows 8 是「6.2」,Windows XP 是「5.1」。對於非 MS-Windows 系統,結果為空字串。
回傳
(string)
winheight({nr}) winheight()
結果是一個數字,它是視窗 {nr} 的高度。{nr} 可以是視窗編號或 視窗 ID。當 {nr} 為零時,會傳回目前視窗的高度。當視窗 {nr} 不存在時,會傳回 -1。現有視窗的高度始終為零或以上。這不包含任何視窗工具列行。範例
echo "The current window has " .. winheight(0) .. " lines."
參數
{nr} (integer)
回傳
(整數)
winlayout([{tabnr}]) winlayout()
結果是一個巢狀列表,其中包含標籤頁中視窗的版面配置。
如果沒有 {tabnr},則使用目前的標籤頁,否則使用編號為 {tabnr} 的標籤頁。如果找不到標籤頁 {tabnr},則傳回空列表。
對於葉視窗,它會傳回
["leaf", {winid}]
對於形成欄的水平分割視窗,它會傳回
["col", [{nested list of windows}]]
對於形成列的垂直分割視窗,它會傳回
["row", [{nested list of windows}]]
範例
" Only one window in the tab page
echo winlayout()
['leaf', 1000]
" Two horizontally split windows
echo winlayout()
['col', [['leaf', 1000], ['leaf', 1001]]]
" The second tab page, with three horizontally split
" windows, with two vertically split windows in the
" middle window
echo winlayout(2)
['col', [['leaf', 1002], ['row', [['leaf', 1003],
                    ['leaf', 1001]]], ['leaf', 1000]]]
參數
{tabnr} (整數?)
回傳
(any)
winline() winline()
結果會是一個數字,代表游標在視窗中的螢幕行號。這個行號是從視窗頂端開始計算的。第一行為 1。如果游標被移動,檔案的視圖會先更新,這可能會導致捲動。
回傳
(整數)
winnr([{arg}]) winnr()
結果會是一個數字,代表目前視窗的編號。最上層的視窗編號為 1。對於彈出視窗則返回零。
可選參數 {arg} 支援以下值: $ 最後一個視窗的編號(視窗計數)。 # 最後存取的視窗編號(CTRL-W_p 會跳至的視窗)。如果沒有上一個視窗,或上一個視窗位於另一個標籤頁,則返回 0。在某些情況下可能指向目前視窗(例如,當評估 'statusline' 表達式時)。{N}j 目前視窗下方第 N 個視窗的編號(CTRL-W_j 會跳至的視窗)。{N}k 目前視窗上方第 N 個視窗的編號(CTRL-W_k 會跳至的視窗)。{N}h 目前視窗左邊第 N 個視窗的編號(CTRL-W_h 會跳至的視窗)。{N}l 目前視窗右邊第 N 個視窗的編號(CTRL-W_l 會跳至的視窗)。這個數字可以與 CTRL-W_w 和 ":wincmd w" :wincmd 一起使用。當 {arg} 無效時,會給出錯誤並返回零。另請參閱 tabpagewinnr()win_getid()。範例
let window_count = winnr('$')
let prev_window = winnr('#')
let wnum = winnr('3k')
參數
{arg} (string|integer?)
回傳
(any)
winrestcmd() winrestcmd()
返回一系列的 :resize 指令,應該可以還原目前的視窗大小。只有在沒有開啟或關閉視窗,且目前視窗和標籤頁沒有改變時,才能正常運作。範例
let cmd = winrestcmd()
call MessWithWindowSizes()
exe cmd
回傳
(any)
winrestview({dict}) winrestview()
使用 winsaveview() 返回的 Dictionary 來還原目前視窗的視圖。注意:{dict} 不必包含 winsaveview() 返回的所有值。如果缺少值,那些設定將不會被還原。因此您可以使用
call winrestview({'curswant': 4})
這只會將游標的 curswant 值(游標在垂直移動時想要移動到的列)設定為第 5 列(是的,就是 5),而所有其他設定將保持不變。如果您手動設定游標位置,這會很有用。
如果您已更改這些值,結果將無法預測。如果視窗大小已更改,結果將不會相同。
參數
{dict} (vim.fn.winrestview.dict)
回傳
(any)
winsaveview() winsaveview()
返回一個 Dictionary,其中包含用於還原目前視窗視圖的資訊。使用 winrestview() 來還原視圖。如果您有一個會在緩衝區中跳躍的映射,並且您想要返回原始視圖,這會很有用。這不會儲存摺疊資訊。使用 'foldenable' 選項暫時關閉摺疊,這樣在移動時不會展開摺疊。這可能會產生副作用。傳回值包含: lnum 游標行號 col 游標列(注意:第一列為零,與 getcurpos() 返回的值相反) coladd 游標列偏移量,用於 'virtualedit' curswant 用於垂直移動的列(注意:第一列為零,與 getcurpos() 返回的值相反)。在 $ 命令後,它將是一個非常大的數字,等於 v:maxcol。topline 視窗中的第一行 topfill 填充行,僅在 diff 模式中使用 leftcol 顯示的第一列;僅在 'wrap' 關閉時使用 skipcol 跳過的列數。請注意,不會儲存任何選項值。
回傳
(vim.fn.winsaveview.ret)
winwidth({nr}) winwidth()
結果會是一個數字,代表視窗 {nr} 的寬度。{nr} 可以是視窗編號或 window-ID。當 {nr} 為零時,會返回目前視窗的寬度。當視窗 {nr} 不存在時,會返回 -1。現有的視窗始終具有零或更大的寬度。範例
echo "The current window has " .. winwidth(0) .. " columns."
if winwidth(0) <= 50
  50 wincmd |
endif
若要取得終端機或螢幕大小,請參閱 'columns' 選項。
參數
{nr} (integer)
回傳
(any)
wordcount() wordcount()
結果會是一個字典,包含目前緩衝區的位元組/字元/單字統計資訊。這與 g_CTRL-G 提供的資訊相同。傳回值包含: bytes 緩衝區中的位元組數 chars 緩衝區中的字元數 words 緩衝區中的單字數 cursor_bytes 游標位置之前的位元組數(不在 Visual 模式下) cursor_chars 游標位置之前的字元數(不在 Visual 模式下) cursor_words 游標位置之前的單字數(不在 Visual 模式下) visual_bytes 視覺選取的位元組數(僅在 Visual 模式下) visual_chars 視覺選取的字元數(僅在 Visual 模式下) visual_words 視覺選取的單字數(僅在 Visual 模式下)
回傳
(any)
writefile({object}, {fname} [, {flags}]) writefile()
{object}List 時,將其寫入檔案 {fname}。每個列表項目都以 NL 分隔。每個列表項目必須是 String 或 Number。所有的 NL 字元都會被 NUL 字元取代。插入 CR 字元需要在將 {list} 傳遞給 writefile() 之前完成。
{object}Blob 時,將位元組不修改地寫入檔案 {fname},即使未指定二進制模式也是如此。
{flags} 必須是字串。這些字元會被識別:
'b' 使用二進制模式:最後一個列表項目之後不會有 NL。末尾的空項目會導致檔案中的最後一行以 NL 結尾。
'a' 使用附加模式,行會附加到檔案末尾
call writefile(["foo"], "event.log", "a")
call writefile(["bar"], "event.log", "a")
'D' 在目前函數結束時刪除檔案。這就像
defer delete({fname})
當不在函數中時會失敗。另請參閱 :defer
's' 在寫入檔案後呼叫 fsync()。如果可能,這會將檔案刷新到磁碟。這會花費更多時間,但可以避免在系統崩潰時遺失檔案。
'S' 不會呼叫 fsync(),即使設定了 'fsync' 也是如此。
{flags} 不包含 "S" 或 "s" 時,如果設定了 'fsync' 選項,則會呼叫 fsync()。
現有檔案會被覆寫,如果可能的話。
當寫入失敗時會返回 -1,否則返回 0。如果無法建立檔案或寫入失敗,則會顯示錯誤訊息。
另請參閱 readfile()。若要逐位元組複製檔案
let fl = readfile("foo", "b")
call writefile(fl, "foocopy", "b")
參數
{object} (任意)
{fname} (字串)
{flags} (字串?)
回傳
(any)
xor({expr}, {expr}) xor()
對兩個引數執行位元 XOR 運算。引數會轉換為數字。List、Dict 或 Float 引數會導致錯誤。另請參閱 and()or()。範例
let bits = xor(bits, 0x80)
參數
{expr} (數字)
{expr1} (數字)
回傳
(any)

2. 在字串中匹配模式 string-match

這是幾個函數之間的共同點。通常使用 pattern 中解釋的 regexp 模式來尋找緩衝區行中的匹配項。當使用模式在字串中尋找匹配項時,幾乎所有運作方式都相同。不同之處在於,字串的處理方式就像它是一行。當它包含 "\n" 字元時,這不會被視為模式的換行符號。可以使用模式中的 "\n" 或 "." 來匹配它。範例
let a = "aaaa\nxxxx"
echo matchstr(a, "..\n..")
" aa
" xx
echo matchstr(a, "a.x")
" a
" x
別忘了 "^" 只會匹配字串的第一個字元,而 "$" 只會匹配字串的最後一個字元。它們不會匹配 "\n" 之後或之前。
主要
命令索引
快速參考