V语言06函数

朱雀 2022-10-10 11:23 143阅读 0赞

# 函数 #

`V`默认为`纯`函数,除了`io`无副作用.  
这通过`无全局`变量及`即使传递引用,函数参数默认不变`,但`V`并非纯函数式语言.  
编译器,有`-enable-globals`选项来启用`全局变量`,针对`低级应用(内核,驱动)`.

# 可变参数 #

用`变`来允许参数可变:

struct User { 
    	name string
    mut:
    	is_registered bool
    }
    
    fn (mut u User) register() { 
    	u.is_registered = 真
    }//对象.`接收器`可变
    
    mut user := User{ }
    println(user.is_registered) // "假"
    user.register()
    println(user.is_registered) // "真"
    //其他参数也一样
    fn multiply_by_2(mut arr []int) { //也要加变
    	for i in 0 .. arr.len { 
    		arr[i] *= 2
    	}
    }
    
    mut nums := [1, 2, 3]
    //也要加变
    multiply_by_2(mut nums)
    println(nums)
    // "[2, 4, 6]"

最好返回值,而不是修改参数.在减少`分配/复制`时用`参数返回`.  
因而`V`不允许修改作为参数的`基本类型`(如整),仅允许`数组/映射`可修改.  
用`user.register()或user=register(user)`来替换`register(mut user)`  
返回修改版的对象.

struct User { 
    	name          string
    	age           int
    	is_registered bool
    }
    
    fn register(u User) User { 
    	return { 
    		...u//这样.
    		is_registered: true
    	}
    }
    
    mut user := User{ 
    	name: "abc"
    	age: 23
    }
    user = register(user)
    println(user)

# 可变参数 #

fn sum(a ...int) int { 
    	mut total := 0
    	for x in a { 
    		total += x
    	}
    	return total
    }//用...整来表可变
    
    println(sum()) // 0
    println(sum(1)) // 1
    println(sum(2, 3)) // 5
    // 分解数组
    a := [2, 3, 4]
    println(sum(...a)) // <--用...前缀来解包
    b := [5, 6, 7]
    println(sum(...b)) // output: 18
    //C++是用后缀来解包.

`匿名/高阶函数`:

fn sqr(n int) int { 
    	return n * n
    }
    
    fn cube(n int) int { 
    	return n * n * n
    }
    
    fn run(value int, op fn (int) int) int { 
    	return op(value)
    }//函数.前面为值,后面为类型.
    
    fn main() { 
    	//函数可传递给其他函数
    	println(run(5, sqr)) // "25"
    	//λ函数可在其他函数中定义/声明
    	double_fn := fn (n int) int { 
    		return n + n
    	}
    	println(run(5, double_fn)) // "10"
    	//不赋值变量下传递函数
    	res := run(5, fn (n int) int { 
    		return n + n
    	})
    	println(res) // "10"
    	//函数数组/映射
    	fns := [sqr, cube]
    	println(fns[0](10)) // "100"
    	fns_map := map{ 
    		"sqr":  sqr
    		"cube": cube
    	}
    	println(fns_map["cube"](2)) // "8"
    }

# 引用 #

struct Foo { }
    
    fn (foo Foo) bar_method() { 
    	// ...
    }
    
    fn bar_function(foo Foo) { 
    	// ...
    }

函数参数`不变`,则由`编译器`决定是`值/引用`传递,不用记按`引用/值`传递.加上`&`确保总是按引用传递:

struct Foo { 
    	abc int
    }
    
    fn (foo &Foo) bar() { //&按引用.
    	println(foo.abc)
    }//`foo`仍是不变的,否则用(mut foo Foo)

`V引用`类似`Go指针/C++引用`.通用树:

struct Node<T> { 
    	val   T
    	left  &Node<T>
    	right &Node<T>
    }

# 常数 #

const (
    	pi    = 3.14
    	world = "世界"
    )//用`常`来定义`常数`.这里声明多个常.
    
    println(pi)
    println(world)

只能在`模块`级别定义`常数`.这个常是`不变`的意思.  
也可`const e = 2.71828`单独声明`常`.  
`V`常更灵活,你可赋值多个复杂值.

struct Color { 
    	r int
    	g int
    	b int
    }
    
    fn rgb(r int, g int, b int) Color { 
    	return Color{ 
    		r: r
    		g: g
    		b: b
    	}
    }
    
    const (//多个赋值
    	numbers = [1, 2, 3]
    	red     = Color{ 
    		r: 255
    		g: 0
    		b: 0
    	}
    	// 编译时求值-->现在是启动时程序求值了.
    	blue = rgb(0, 0, 255)
    )//相当于一个区块了.
    
    println(numbers)
    println(red)
    println(blue)

禁止`全局变量`,因而用`常`块.用`公`可导出`常数`.

module mymodule
    
    pub const golden_ratio = 1.61803
    
    fn calc() { 
    	println(mymodule.golden_ratio)
    }

`常块(常())`前面不能有`公`.外部用`常`,必须加`模块名`.  
常量用`snake_case`,为区别本地变量,要加`模块名`.为用`π`,内外都要用`math.pi`.只在`主`模块中放松,由`vfmt`考虑,你在`数学`模块中用`pi`最后会加上`数学`.

println(pi)//变成
    println(math.pi)

# 内置函数 #

下为完整列表

fn print(s string) //输出中打印
    fn println(s string) //打印并加换行
    
    fn eprint(s string) //输出在错误
    fn eprintln(s string) //
    
    fn exit(code int) //用自定义错误码退出程序
    fn panic(s string) //错误中打印消息并跟踪,用1错误码退出
    fn print_backtrace() //打印跟踪栈

打印,可打印`strings,numbers,arrays,maps,structs`.

struct User { 
    	name string
    	age  int
    }
    
    println(1) // "1"
    println("hi") // "hi"
    println([1, 2, 3]) // "[1, 2, 3]"
    println(User{  name: "Bob", age: 20 }) // "User{name:"Bob", age:20}"
    //自定义,加个`串`函数
    struct Color { 
    	r int
    	g int
    	b int
    }
    
    pub fn (c Color) str() string { 
    	return "{$c.r, $c.g, $c.b}"
    }
    red := Color{ 
    	r: 255
    	g: 0
    	b: 0
    }
    println(red)

根目录下所有文件,均为相同模块的部分.简单程序不必指定`模块`名,默认为`主`.  
`V`是模块化语言,鼓励创建可重用`模块`,

// myfile.v之上为mymodule目录
    module mymodule
    
    //导出用公
    pub fn say_hi() { 
    	println("我的模块,你好")
    }
    //外部使用
    import mymodule
    
    fn main() { 
    	mymodule.say_hi()
    }

<table> 
 <thead> 
  <tr> 
   <th align="left"><code>序号</code></th> 
   <th align="left">注意</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>1</code></td> 
   <td align="left">模块名要短,<code>&lt;10</code>个符.</td> 
  </tr> 
  <tr> 
   <td align="left"><code>2</code></td> 
   <td align="left">用<code>snake_case</code>格式</td> 
  </tr> 
  <tr> 
   <td align="left"><code>3</code></td> 
   <td align="left">禁止循环导入</td> 
  </tr> 
  <tr> 
   <td align="left"><code>4</code></td> 
   <td align="left">所有模块静态编译至<code>exe</code>文件</td> 
  </tr> 
 </tbody> 
</table>

模块的`初化`函数

fn init() { 
    	//模块级初化代码,初化C库很有用.
    }//抄的D的静态模块构造,可为公,自动调用该函数