第五章 VimL 函数进阶 #

5.3 字典函数 #

函数引用能保存在字典，这不意外，上节就提到过，脚本内定义的 s: 前缀变量（包括函数引用），就自动保存在 s: 这个特殊字典中。关键是如何主动利用这个特性，为编程需求带来便利。在本节中，将保存在字典键中的函数引用简称为字典函数。

将已有函数保存在字典中 #

沿用上节的示例，将函数引用保存在字典中，相关代码改写如下：

" >>File: ~/.vim/vimllearn/funcref.vim

let s:dOperator = {'desc': 'some function on varargins'}
let s:dOperator['+'] = function('s:sum')
let s:dOperator['*'] = function('s:prod')

function! CalculateD(operator, ...) abort
    let l:Fnr = s:dOperator[a:operator]
    let l:result = call(l:Fnr, a:000)
    return l:result
endfunction

这里先定义了一个字典变量 s:dOperator，并用键 + 保存函数 s:sum() 的引用，用键 * 保存函数 s:prod() 的引用。然后改写 CalculateD() 函数就很简洁了，根据传入的第一参数索引字典，获得相应的函数引用，再调用之。因为直接用键索引字典，且认为没有遍历全部键的需求，所以还可以在 s:dOperator 字典加入非函数引用的键，比如 desc 保存了一条描述，字符串类型。

可以在命令行中输入 :echo CalculateD('*', 1, 2, 3, 4) 测验一下。注意到该函数没有检查传入参数是否有效的键，如 :echo CalculateD('**', 1, 2, 3, 4) 会报错。可以先用 has_key() 内置函数检查参数 a:operator 是否存在的键，更进一步，可再用 type() 函数与该键相关联的值是否函数引用。如果参数是非法的，则提前返回，至少返回什么值表示错误，那就与具体需求有关了。也许在某些情况下，不检查参数，直接让它在出错时终止脚本运行也是可接受的处理方式。

按成员的方式引用函数 #

我们知道，字典元素有两种索引方式，一是用方括号（类似列表索引），一种是用点号（类似成员索引）。不过后者只是前者的语法糖，要求键名是简单字符串（有效标志符）。因此可以用一个较有意义单词键名来代替 + * 符号键名，例如：

" >>File: ~/.vim/vimllearn/funcref.vim

let s:dOperator.sumFnr = s:dOperator['+']
let s:dOperator.prodFnr = s:dOperator['*']
echo s:dOperator.sumFnr(1, 2, 3, 4)
echo s:dOperator.prodFnr(1, 2, 3, 4)

如果之前没有在字典中定义 + 键，也可以直接用 let s:dOperator.sumFnr = function('s:sum') 获得函数引用。这里以小写字母开头的键名也可以保存函数引用。然后调用函数的写法就是 s:dOperator.sumFnr()。由于使用的是脚本局部的字典变量，须用 :source 命令重新加载脚本文件执行上例，观察这种调用方法的结果。

直接定义字典函数 #

为了在字典键中保存一个函数引用，之前其实成分了三步工作：

用 :function 命令定义一个函数；
用 function() 函数获取这个函数的引用；
用 :let 命令将这个函数引用赋值给字典的某个键。

但这三步曲（实际是两条语句）可以合起来，直接在定义函数时就将其引用保存在字典中，其语法示例如下：

" >>File: ~/.vim/vimllearn/funcref.vim

function s:dOperator.sum(...)
    let l:sum = 0
    for l:arg in a:000
        let l:sum += l:arg
    endfor
    return l:sum
endfunction

function! s:dOperator.prod(...)
    let l:prod = 1
    for l:arg in a:000
        let l:prod = l:prod * l:arg
    endfor
    return l:prod
endfunction

echo s:dOperator.sum(1, 2, 3, 4)
echo s:dOperator.prod(1, 2, 3, 4)

其实就相当于将之前的函数头 :function s:sum(...) 改为 :function s:dOperator.sum(...)，函数体功能实现完全一样。要注意的是在执行这一行之前， s:dOprator 字典必须是已定义的。然后调用该函数的用法完全一样。

请注意区分一下，s:dOperator.sumFnr 显然是一个函数引用，它引用事先已定义的 s:sum() 函数。s:dOperator.sum 也是一个函数引用，它引用的又是哪个函数呢？它引用的是即时定义的函数，它没有名字（没机会也没必要给个名字），也叫做匿名函数。在 Vim 内部，它将这样定义的匿名函数一个编号，所以也叫编号函数。

如果在脚本文件末尾写上 echo s: 这条语句，根据其输出结果，就能更清楚地分辨这些函数引用变量的异同。例如，执行结果大概相当于如下定义：

s:fnrSum = function('<SNR>77_sum')
s:fnrProd = function('<SNR>77_prod')

s:dOperator['+'] = function('<SNR>77_sum')
s:dOperator['*'] = function('<SNR>77_prod')

s:dOperator.sumFnr = function('<SNR>77_sum')
s:dOperator.prodFnr = function('<SNR>77_prod')

s:dOperator.sum = function('172')
s:dOperator.prod = function('173')

因此，s:fnrSum s:dOperator['+'] 与 s:dOperator.sumFnr 都是引用同一个函数，那就是 s:sum() 局部函数，不过 vim 自动将其修正为 <SNR>77_sum() 全局函数。而 s:dOperator.sum 则完全引用另一个函数，是编号为 172 的匿名函数。当然，你的输出中，脚本编号与函数编号极可能是不一样的。

我们知道，退化的 :function 命令可以查看打印函数定义。所以可以用 :function <SNR>77_sum 在命令行直接执行，其输出应该与脚本中定义的 s:sum() 函数一致。但是在命令行使用 :function s:sum 是错误。那匿名函数怎么查看呢，直接用编号作为参数是不行的，需用一个大括号括起来，如：

: function <SNR>77_sum
: function {173}

但是，用于获取一个函数引用的 function() 却无有效方法仅从匿名函数的编号获得其引用。如 function('173') 或 function('{173}') 都不能正常工作。匿名函数一般必须在创建时赋值给某个函数引用变量，然后只能通过该函数引用调用之。当然了，该函数引用可以再赋值给其他变量就是。

字典函数的特殊属性 #

如果仔细观察上述 :function {173} 命令输出，可以发现它在函数头定义行尾，自己添加了一个关键字 dict，表示将要定义的函数具有 dict 属性。这个属性指出该函数必须通过字典来激活调用，也就是说必须将其引用保存在字典的某个键中。然后在函数体中，可以使用 self 这个关键字，它表示调用该函数时所用到的字典变量。

例如，假设我们要在上述 s:dOperator 字典中另外加一个计算圆面积的函数。从数学上讲，圆面积只是其半径的函数，应该只要传入半径参数。但在程序中实现计算时，还要涉及一个圆周率常量。这个常量不适合放在函数内定义，当然可以定义为 s: 脚本变量，不过最好还是保存在同一个字典中。

" >>File: ~/.vim/vimllearn/funcref.vim

let s:dOperator.PI = 3.14
function! s:dOperator.area(r)
    return self.PI * a:r * a:r
endfunction

echo s:dOperator.area(2)

我们先定义了 s:dOperator.area 函数（引用），然后调用 s:dOperator.area(2) 来计算半径为 2 的圆面积。在函数定义体内用到了 self.PI，这个 self 就是调用该函数时所用到的字典变量，也即 s:dOperator。

这里，我们调用时与定义时用到的字典变量是同一个，但这不是必须的。比如，我们可以创建另一个字典 s:Math，它保存了一个 PI 键，为示区别，这个 PI 保存的圆周率精度大一些：

" >>File: ~/.vim/vimllearn/funcref.vim

let s:Math = {}
let s:Math.PI = 3.14159
let s:Math.Area = s:dOperator.area
echo s:Math.Area(2)

请观察 s:dOperator.area(2) 与 s:Math.Area(2) 计算结果的不同，表明后者调用时 self.PI 确实用到了 s:Math.PI 的值，而不是 s:dOperator.PI 的值。而且，在 s:Math 中的函数名 Area 不一定要与最初定义时所用的 area 相同。但是函数体内用到的 PI 键名，必须相同。

如果把 s:dOperator.area 这个函数（引用）赋值给普通变量（非字典键），会发生什么情况呢？尝试在脚本末尾继续添加如下代码并加载运行：

let g:Fnr = s:dOperator.area
echo g:Fnr(2)

结果它会报 E725 错误，提出不能在没有字典的情况下调用具有 dict 属性的函数。这似乎很好理解，因为在 area() 函数体内，用到了 self.PI，没有字典的话，这个 self 就无所引用了。实际上，即使在函数体内没有到用 self ，也不能绕过字典去调用字典函数。比如原来的 s:dOperator.sum() 就没用到 self，但如下代码也时非法的：

let g:Fnr = s:dOperator.sum
echo g:Fnr(1,2,3,4)

在为 g:Fnr 赋值时不会出错，在调用 g:Fnr() 时才出错。所以 vim 是通过 dict 这个函数属性来检测调用合法性的，因为这种函数体内有可能用到 self，提前终止潜在的错误，总是更安全的设计。而且，既然用到 dict ，就意味着大概率会用到 self，否则将一个非 dict 属性的函数保存在字典中，是很无趣的（虽然合法）。以下语句却不会出错：

let g:Fnr = s:dOperator.sumFnr
echo g:Fnr(1,2,3,4)

因为 s:dOperator.sumFnr 所引用的函数其实是 s:sum()，它在定义时未指定 dict 属性。所以 s:dOperator.sunFnr 只起来到一个传递变量值的中介作用，g:Fnr 也是对 s:sum() 的函数引用，当然也就可以直接调用了。

普通函数的字典属性 #

上面在定义 s:dOperator.sum 与 s:dOperator.area （对匿名函数的引用）时，并未显式写出 dict 属性。这只是 :function 定义字典函数时的语法糖，vim 会自动添加 dict 属性。

定义普通函数时也可以指定 dict 属性，例如我们另外写个计算矩形面积的函数：

function! s:area(width, height) dict
    return a:width * a:height
endfunction

" echo s:area(3, 4) |" 出错

let s:Rect = {}
let s:Rect.area = function('s:area')
echo s:Rect.area(3, 4) |" 正确

但是，由于 s:area() 函数是 dict 属性的，所以直接调用 s:area() 会出误。必须把它（的引用）放在一个字典中，如上为此专门建了个空字典变量 s:Rect，将函数引用保存在其 area 键名中，才能调用 s:Rect.area()。

因此，当一个普通函数用了 dict 属性，却没用到 self 特性，好像用处不是很大，反而限制了其正常使用。为此，将 s:area() 函数重新定义如下：

function! s:area() dict
    return self.width * self.height
endfunction

let s:Rect.width = 3
let s:Rect.height = 4
echo s:Rect.area()

取消 s:area() 的函数参数，而将 width 与 height 参数保存在 s:Rect 字典中，然后就可以无参调用 s:Rect.area() 了。这样，长、宽就相当于矩形（s:Rect）的属性，而求面积的 area() 就相当于它的方法。这就初具面向对象的特征了（这将在后续章节中再详细讨论）。

注意这里的 s:area() 函数体内用到了 self，则在函数头一定要指定 dict 属性。反之则不强制要求。

具有 dict 属性的函数，除了对过字典键引用来调用外，也可以用 call() 函数间接调用。之前已经介绍过 call() 函数，其实它还可接收第三个可选参数，按 :help call() 介绍其用法是 call({func}, {arglist} [, {dict}])。如果第一个参数（函数名或函数引用）所指代的函数具有 dict 属性，第三个参数就应该提供一个字典传递给这个函数体实现中的 self 变量。

因此，第二个版本（无参数）的 s:area() 可以这么调用：

echo call('s:area', [], s:Rect)
echo call(function('s:area'), [], s:Rect)

这两条语句都合法，不过由于使用了 s:area 字符串，必须在脚本中才能运行。当 call() 在调用 s:area() 时，s:area() 函数内的 self 也就是 s:Rect 了。

至于第一个版本带两个参数的 s:area() 则可以这么调用：

echo call('s:area', [5, 6], {})
echo call('s:area', [5, 6]) |" 出错

将参数收集在一个列表变量中，作为第二参数传入。由于函数体内未用到 self ，在第三参数随便提供一个字典变量就行，即使是个空字典 {}。但若不提供这个字典参数，则会发生运行时错误。

直接定义字典函数与间接定义的比较 #

综上再小结一下，定义字典函数（引用）有两种方式。一是直接用一条语句搞定，字典键引用了一个匿名函数；二是先定义函数，再将该有名函数的引用赋值给字典键。不妨分别称之为直接定义与间接定义。

直接定义：function dict.method()
间接定义：function Method() 与 let dict.method = function('Method')

显然，直接定义的语法更简洁方便，请尽量使用这种语法。那么间接定义的写法还有没有什么存在的意义呢？

首先，这可能是历史原因。VimL 也是随 Vim 逐步发展完善起来的，很有可能函数引用的概念先于 dict 属性与 self 变量的引入。因而也就先有分步写的字典函数引用，然后才有一步到位的语法糖写法。

其次，间接定义的函数引用有更灵活的控制权。直接定义的字典函数必定是匿名函数的引用，且隐含具有 dict 的属性，不论是否显式写出该关键词。这也就意味着不能将直接定义的字典函数引用赋值给普通函数引用变量，那是不能工作的。但在间接定义字典函数时有更多的选择，在定义函数时可根据需要是否指定 dict 属性。没有 dict 属性的函数引用可以赋值给普通变量。因此，从编码实践上建议：

直接定义的字典函数，也始终显式加上 dict 关键词，不要太依赖语言的隐式作用。
普通函数，如果实现体中需要用到 self 才加 dict 属性关键词。

最后，字典键名引用有名或匿名函数，会影响调试与错误信息。通过示例详细说明，将以下代码片断添加到本节的演示脚本末尾，并用 :source 重新加载。

" >>File: ~/.vim/vimllearn/funcref.vim

function! s:Rect.debug1() dict abort
    echo expand('<sfile>')
    Hello Vim, 我在这里就是个错误
endfunction

function! s:debug2() abort
    echo expand('<sfile>')
    Hello Vim, 我来这里也是个错误
endfunction
let s:Rect.debug2 = function('s:debug2')

function! s:Rect.test() dict " abort
    echo expand('<sfile>')
    call self.debug1()
    call self.debug2()
endfunction

function! s:test() abort
    echo expand('<sfile>')
    call s:Rect.test()
endfunction

function! Test() abort
    echo expand('<sfile>')
    call s:test()
endfunction

echo expand('<sfile>')

复用原来的字典 s:Rect，增加了两个函数引用键，其中 debug1 是直接定义的， debug2 是间接引用 s:debug2() 的。这两个函数内随意加了一行错误语句。这在加载脚本时并不会出错误，只有实际调用了相应函数才有机会出错。然后再定义了一个统一的 s:Rect.test() 函数，在其内调用这两个 debug 函数。最后还定义了 s:test() 与 Test() 函数。只有 Test() 是全局的，可以在命令行中执行 :call Test() 查看结果。在执行前先人工分析下这将发生的函数调用链：

全局函数 Test() --> 脚本函数 s:text() --> 字典函数 s:Rect.test()
[1] --> 字典函数 s:Rect.debug1() | 引用匿名函数
[2] --> 字典函数 s:Rect.debug2() | 引用 s:debug2() 函数

我这里执行 :call Test() 后输出如下，脚本编号与函数编号肯定是依环境不同的：

function Test
function Test[2]..<SNR>77_test
function Test[2]..<SNR>77_test[2]..181
function Test[2]..<SNR>77_test[2]..181[2]..180
Error detected while processing function Test[2]..<SNR>77_test[2]..181[2]..180:
line    2:
E492: Not an editor command:     Hello Vim, 我在这里就是个错误
function Test[2]..<SNR>77_test[2]..181[3]..<SNR>77_debug2
Error detected while processing function Test[2]..<SNR>77_test[2]..181[3]..<SNR>77_debug2:
line    2:
E492: Not an editor command:     Hello Vim, 我来这里也是个错误

其中，常规字体是各函数内 echo expand('<sfile>') 的正常输出，红字部分是错误语句触发的输出，即 vim 自动给出的错误提示信息。主要是触发 E492 这个错误，它说 Helle Vim 不是编辑器的有效命令。并在之前先打印出错时所在的函数名与行号。重点关注一下函数名的表示方法，例如在 s:Rect.debug1() 出错时的位置信息：

function Test[2]..<SNR>77_test[2]..181[2]..180:

对比之前的分析，第一层调用是全局函数 Test，中括号 [2] 表示在第二行调用下一层函数，即 s:test()，它被转化成 <SNR>77_test 函数名，然后第二行再调用 s:Rect.test() ，这是匿名函数，所以只能打印出编号 181，然后继续调用 s:Rect.debug1() ，它也是匿名函数，也只打印出编号 180。到这个函数就出错了，没能再调用其他函数，出错行号另起一行打印出来。

在 s:Rect.debug2() 出错时的位置信息类似：

function Test[2]..<SNR>77_test[2]..181[3]..<SNR>77_debug2:

只不过在倒数第二层的行号从第二行改为了第三行，最后一个函数名打印出了实际所引用的函数名 <SNR>77_debug2 ，也就是脚本中的 s:debug()。

这有什么差别呢？试想我们若用 VimL 开发实用功能（主要是插件时），调用链经常也会这么长或者更长。当 vim 报错时，给出一长串错误提示，我们第一反应是想知道哪里出错了，最终出错在哪个函数中。这反映在出错信息的最后一个调用函数，但是像 s:Rect.debug1() 这样的直接定义的字典函数，vim 只打印个 180 编号，可能完全不知所云。而像 s:Rect.debug2() 这个间接定义的字典函数，它会打印出函数名。即使你也不知脚本编号，那也是有迹可循，比如用 :scriptnames 检查。而且在实践中，你也不可能在很多不同脚本中都定义了相当的函数，那么不用检查脚本编号也基本能定位错误了。

还有重要一点，在开发 VimL 脚本过程中，如果修改 Bug 后重新加载脚本，那直接定义的字典函数所引用的匿名函数编号是会变化的。因为它相当于重新定义了另一个匿名函数并为字典键赋值，而原来那个匿名函数再无引用无可访问就会自动释放（垃圾回收机制）。但是，脚本编号并不会改变，除非大重构把文件名也改了。这种编号的变化性对查 Bug 也多少会有影响的。

顺便提一下，也许你也注意到了，vim 自动打印的出错位置信息，其实就是 <sfile> 的值。如果用在函数中，那就是运行到该处时完整的调用链字符串；在不同时刻从不同入口调用时还可能给出不同的值。但如果用在函数外，那就只能是在脚本文件中，<sfile> 就表示脚本文件名（故不能直接用在命令行中）。这也是 sfile 这个单词意义的来源。不过你也可以将脚本整体理解为一个函数（也是一个执行单元），其“函数名”显然就是脚本名了。

还有一点得注意，在定义 s:Rect.test() 函数时，没有加 abort 属性。按之前的建议，定义函数时始终加 abort 是良好的习惯，因为它会在出错时立即终止运行，避免更多的错乱。不过在这里，如果有 abort 属性，它在调用 self.debug1() 出错后就立即终止，self.debug2() 也就没机会调用了。由于我们想对比出错信息，要求触发所有错误，因而特意取消 abort 属性。