函数

函数定义

使用fn关键字定义函数

  1. fn main() {
  2.     println(add(77, 33))
  3.     println(sub(100, 50))
  4. }
  6. fn add(x int, y int) int {
  7.     return x + y
  8. }
  10. fn sub(x int, y int) int {
  11.     return x - y
  12. }

V语言的函数定义(函数签名)基本跟go一样

去除各种视觉干扰的符号,简洁清晰,而函数关键字是跟rust一样的fn,更简洁

函数的命名强制采用rust一样的小蛇式风格(lower snake case),即小写+下划线的风格，看着很舒服,而不是采用go的大小写来区分可访问性,这样就不会强制要大小写

函数访问控制

默认模块内部访问,使用pub才可以被模块外部访问

  1. module mymodule
  3. fn private_fn() { // 模块内部可以访问,模块外部不可以访问
  4. }
  6. pub fn public_fn() { // 模块内部和外部都可以访问
  7. }

函数参数

函数的参数采用的是类型后置,相同类型的相邻参数可以合并类型

函数的参数默认是不可变的,如果在函数内部要改变传进来的参数,要在函数参数的定义和调用中加上mut

  1. fn my_fn(mut arr []int) { // 1.参数定义也要是可变的
  2.     for i := 0; i < arr.len; i++ {
  3.         arr[i] *= 2
  4.     }
  5. }
  7. fn main() {
  8.     mut nums := [1, 2, 3] // 2.传进来的参数要是可变的
  9.     my_fn(mut nums) // 3.调用函数时,还需要在参数前加上mut,不然会报错
  10.     println(nums) // 返回[2, 4, 6],函数执行后,传进来的参数被改变了
  11. }

不确定个数参数也是支持的,不确定参数要放在参数的最后一个

  1. fn my_fn(i int, s string, others ...string) {
  2.     println(i)
  3.     println(s)
  4.     println(others[0])
  5.     println(others[1])
  6.     println(others[2])
  7. }
  9. fn main() {
  10.     my_fn(1, 'abc', 'de', 'fg', 'hi')
  11. }

数组可以传递给不确定参数函数,不确定参数函数之间也可以传递参数

  1. module main
  3. fn main() {
  4.     a := ['a', 'b', 'c']
  5.     println(variadic_fn_a(...a)) //数组解构赋值后,传递给不确定参数数组
  6. }
  8. fn variadic_fn_a(a ...string) string {
  9.     return variadic_fn_b(...a) //数组解构赋值后,传递给不确定参数数组
  10. }
  12. fn variadic_fn_b(a ...string) string {
  13.     a0 := a[0]
  14.     a1 := a[1]
  15.     a2 := a[2]
  16.     return '$a0$a1$a2'
  17. }

函数返回值

函数的返回值可以是单返回值,也可以是多返回值

  1. fn bar() int { //单返回值
  2.     return 2
  3. }
  5. fn foo() (int, int) { //多返回值
  6.     return 2, 3
  7. }
  9. fn some_multiret_fn(a int, b int) (int, int) {
  10.     return a + 1, b + 1 //可以返回表达式
  11. }
  13. fn main() {
  14.     a, b := foo()
  15.     println(a) // 2
  16.     println(b) // 3
  17. }

返回值也可以返回指针类型

  1. fn get_the_dao_way() voidptr { //返回通用指针
  2.     return voidptr(0)
  3. }
  5. fn multi_voidptr_ret() (voidptr, bool) { //返回通用指针
  6.     return voidptr(0), true
  7. }
  9. fn multi_&byte_ret() (&byte, bool) { //返回字节指针
  10.     return &byte(0), true
  11. }

忽略返回值

跟go一样,可以使用下划线来忽略函数的某个返回值

  1. fn main() {
  2.     a, _ := foo() // 忽略第二个返回值
  3.     _, _ := foo() // 也可以忽略全部的返回值
  4.     println(a) // 2
  5.     b := bar()
  6.     _ := bar()
  7.     println(b) // 2
  8. }
  10. fn bar() int {
  11.     return 2
  12. }
  14. fn foo() (int, int) {
  15.     return 2, 3
  16. }

函数defer语句

在函数退出前执行defer代码块,一般用来在函数执行完毕后,释放资源的占用.

一个函数可以有多个defer代码块,采用后定义先执行(后进先出)的原则.

同时在defer代码块内有一些特殊的注意事项:

  • defer代码块内不可调用return
  • defer代码块内不可嵌套定义defer代码块
  • defer代码块内调用函数时,不可向上抛转错误,例如 a=test1() ?
  1. fn main() {
  2.     println('main start')
  3.     // defer {defer_fn1()} //写成单行也可以
  4.     // defer {defer_fn2()}
  5.     defer {
  6.         defer_fn1()
  7.     }
  8.     defer {
  9.         defer_fn2()
  10.     }
  11.     println('main end')
  12. }
  14. fn defer_fn1() {
  15.     println('from defer_fn1')
  16. }
  18. fn defer_fn2() {
  19.     println('from defer_fn2')
  20. }

执行结果:

  1. main start
  2. main end
  3. from defer_fn2
  4. from defer_fn1

函数类型

相同的函数签名,表示同一类函数,可以用type定义为函数类型

  1. type Mid_fn = fn (int, string) int

函数作为参数

  1. fn sqr(n int) int {
  2.     return n * n
  3. }
  5. fn run(value int, op fn (int) int) int {
  6.     return op(value)
  7. }
  9. fn main() {
  10.     println(run(5, sqr)) // "25" sql函数作为参数传递
  11. }

函数作为返回值

  1. module main
  3. fn add(x int) int {
  4.     return x
  5. }
  7. fn sum() fn (int) int { // 函数类型作为返回值
  8.     return add
  9. }
  11. fn main() {
  12.     a := sum()
  13.     println(a(2))
  14. }

函数递归

函数也是可以递归调用的

泛型函数

参考泛型章节

函数重载

V不会有函数重载

函数默认值

函数的参数目前还没有参数默认值这个特性

内联函数

可以对函数添加[inline]注解,主要的用途是在调用C代码库的时候使用最多,内联函数跟C的内联函数概念一样,生成的也是C的内联函数

  1. [inline]
  2. pub fn width() int {
  3.     return C.sapp_width()
  4. }

详细参考:调用C代码库

匿名/内部函数

可以在函数内部定义匿名函数:

  1. import sync
  3. fn main() {
  4.     f1 := fn (a int) { // 定义函数类型变量
  5.         println('hello from f1')
  6.     }
  7.     f1(1)
  8.     f2 := fn (a int) { // 定义函数类型变量
  9.         println('hello from f2')
  10.     }
  11.     f2(1)
  12.     fn (a int) { // 匿名函数定义同时调用
  13.         println('hello from anon_fn')
  14.     }(1)
  15.     // 匿名函数结合go使用
  16.     mut wg := sync.new_waitgroup()
  17.     go fn (mut wg sync.WaitGroup) {
  18.         println('hello from go')
  19.         wg.done()
  20.     }(mut wg)
  21.     wg.wait()
  22. }

函数注解

deprecated

模块发布给其他用户使用后,如果模块的某个函数想要声明作废,可以使用作废注解

  1. [deprecated] //函数作废注解
  2. pub fn ext(path string) string {
  3.     panic('Use `filepath.ext` instead of `os.ext`') //结合panic进行报错提示
  4. }
  5. [deprecated:'可以在这里写说明'] //带说明的作废注解,编译器提示函数作废的时候会显示出来
  6. pub fn (p Point) position() (int, int) {
  7.     return p.x, p.y
  8. }
  10. [deprecated:'这是作废说明']
  11. [deprecated_after: '2021-03-01']  //在某个日期后开始作废,一定要放在deprecated后,才会警告
  12. pub fn fn1() (int, int) (int, int) {
  13.     return p.x, p.y
  14. }
  15. //函数被调用,就会出现如下警告:
  16. //warning: function `fn1` has been deprecated since 2021-03-01; 这是作废说明

inline

inline注解的功能跟C函数的inline函数一样

  1. [inline] //函数inline注解
  2. pub fn sum(x y int) int {
  3.   return x+y
  4. }
  6. [inline] //方法inline注解
  7. pub fn (p Point) position() (int, int) {
  8.     return p.x, p.y
  9. }

unsafe

参考不安全代码章节

trusted

参考不安全代码章节

live

代码热更新功能,实际生产用处不大

开发时可以使用,像脚本语言那样,保存即生效,不用重启服务器,正式发布的时候还是要去除live注解,有些麻烦

  1. module main
  3. import time
  5. [live]
  6. fn print_message() {
  7.     println('更新时间:${time.now()}')
  8.     println('该函数范围内的代码修改后,不需要重新编译运行,保存即生效')
  9. }
  11. fn main() {
  12.     for {
  13.         print_message()
  14.         time.sleep(1*time.second)
  15.     }
  16. }

运行时也需要加上-live选项,才会有效果

  1. v -live run  main.v

内置函数

V内置了一些函数,可以全局使用

dump函数

跟C语言中的dump函数功能一样,把某个表达式的数据转储,并输出

dump函数主要用于调试,比println函数更为方便,清晰

表达式被调用了几次,每次的结果如何,代码的位置,都会被清楚地打印出来

  1. fn factorial(n u32) u32 {
  2.     if dump(n <= 1) {
  3.         return dump(1)
  4.     }
  5.     return dump(n * factorial(n - 1))
  6. }
  8. fn main() {
  9.     println(factorial(5))
  10. }

输出:

  1. [xxx/main.v:2] n <= 1: false
  2. [xxx/main.v:2] n <= 1: false
  3. [xxx/main.v:2] n <= 1: false
  4. [xxx/main.v:2] n <= 1: false
  5. [xxx/main.v:2] n <= 1: true
  6. [xxx/main.v:3] 1: 1
  7. [xxx/main.v:5] n * factorial(n - 1): 2
  8. [xxx/main.v:5] n * factorial(n - 1): 6
  9. [xxx/main.v:5] n * factorial(n - 1): 24
  10. [xxx/main.v:5] n * factorial(n - 1): 120