Vlang官网文档(中文翻译)-vlang中文文档--v0.1.0_20180625

PS:主要为自己学习,,,,看的时候顺便翻译的,,,渣翻(非全人工)勿喷.

介绍

V是一种用于构建可维护软件的静态类型编译编程语言。

它与Go相似，也受到Oberon、Rust、Swift的影响。

V是一种非常简单的语言,阅读这份文档大概只需要半小时的时间,读完之后,您将学习到V的全部内容.

尽管很简单,但是它为开发人员提供了很多功能,你能用其它编程语言做的任何事情,都可以用V做到.

Hello World

fn main() {
	println('hello world')
}

函数用 fn 声明, 该函数返回值的类型在函数名后定义,在这个例子中,main函数不返回任何内容,所以函数返回值的类型被省略了.

就像在C语言和所有类C语言中一样，main函数是程序的一个入口点。

println 是为数不多的内置函数之一。它用于打印值到标准输出。

fn main() 也可以在程序中被忽略, 这在编写小程序脚本或学习语言时非常有用. 为简洁起见, 在这个例子中,将忽略fn main()

这意味着"hello world"程序可以像下面一样简单

println('hello world')

注释

// 这是一个单行注释

/* 这是一个多行注释
   /* 它可以嵌套 */
*/

函数

fn main() {
	println(add(77, 33))
	println(sub(100, 50))
}

fn add(x int, y int) int {
	return x + y
}

fn sub(x, y int) int {
	return x - y
}

同样,类型在参数名之后.

就像在Go和C中一样,函数不能重载,这使代码更简洁,提高了代码的可读性和可维护性.

函数可以在声明之前被使用,add 和 sub 两个函数的声明在 main之后, 但仍然可以在 main函数中调用. 这在V中的所有声明中都是对的.并且不需要考虑文件和声明的顺序.

变量

name := 'Bob' 
age := 20
large_number := i64(9999999999)
println(name)
println(age)
println(large_number)

使用:=将变量声明并初始化赋值,这是在V中声明变量的唯一方法.这意味着被声明的变量总会有一个初始值.

变量的类型是由给它赋的值判断出来的.要强制使用不同类型的值,请使用类型转换:表达式T(v)将值v转换为类型T。

与大多数语言不同,V只允许在函数中定义变量。不允许全局(模块级)变量.在V中没有全局状态。

mut age := 20
println(age)
age = 21
println(age)

要改变变量的值,请使用=. 在V中，变量在默认情况下是不可变的. 要更改变量的值，必须使用mut声明它。

做个尝试删除第一行中的mut,然后再编译程序..

请注意:=和=之间的区别

:=用于声明和初始化，=用于赋值。

fn main() {
	age = 21
}

这段代码不会编译成功,因为没有声明变量age.在V中,所有变量都需要声明.

fn main() {
	age := 21
}

这段代码也不会编译成功，因为声明的变量未使用会导致编译错误。(PS:和Go一样,)

fn main() {
	a := 10 
	if true {
		a := 20
	} 
}

不像大多数语言,在V中,用父范围中已经使用的名称声明变量将导致编译错误。

基本数据类型

bool 布尔

string  字符串

i8  i16  i32  i64      i128 (soon)
u8  u16  u32  u64      u128 (soon) 

byte // u8的别名  
int  // i32的别名  
rune // i32的别名, 表示Unicode

f32 f64

byteptr
voidptr

请注意,与C和Go不同,int 始终是32位整数.

字符串

name := 'Bob' 
println('Hello, $name!')  // `$`用作字符串插值
println(name.len) 

bobby := name + 'by' // + 用作字符串拼接
println(bobby) // ==> "Bobby"  

println(bobby.substr(1, 3)) // ==> "ob"  
// println(bobby[1:3]) // 这个语法很可能替代上一行用的 substr() 函数

在V中, 字符串是一个只读的字节数组.字符串数据使用UTF-8编码,

单引号和双引号都可以用来表示字符串(TODO:双引号还不支持), 为了保持一致性，vfmt将双引号转换为单引号，除非字符串包含单引号字符。

字符串是不可变的,这意味着子字符串函数非常高效. 被执行时不需要复制,不需要额外的资源.

在V中,运算符的两边都必须是相同类型的数据. 在这个代码中,如果age是一个int类型,将不会编译成功.

println('age = ' + age)

我们可以把age替换成string类型

println('age = ' + age.str())

或者使用字符串插入 (首选):

println('age = $age')

数组

nums := [1, 2, 3]
println(nums)
println(nums[1]) // ==> "2" 

mut names := ['John']
names << 'Peter' 
names << 'Sam' 
// names << 10  <-- 这将不会编译成功. `names` 是一个字符串数组. 
println(names.len) // ==> "3" 
println('Alex' in names) // ==> "false" 

// 我们也可以预先分配一定数量的元素. 
nr_ids := 50
mut ids := [0 ; nr_ids] // 这将创建一个包含50个 0 的数组

数组的类型由它的第一个元素决定: [1, 2, 3] 是一个整型数组([]int). ['a', 'b'] 是一个字符串数组 ([]string).

所有的元素必须是相同的类型, [1, 'a'] 是不行滴.

<< 是一个将值追加到数组末尾的操作符.

.len 字段(field) 返回数组的长度. 注意, 这是一个只读的字段(field), 用户不能修改它. V中所有导出的字段(field)都是只读的。.

val in array 如果数组中包含val的时候,返回true.

Maps

mut m := map[string]int{} // 目前只允许使用字符串类型的key
m['one'] = 1
println(m['one']) // ==> "1"  
println(m['bad_key']) // ==> "0"  
// TODO: 实现检查key是否存在的方法 

numbers := { // TODO:此语法尚未实现  
	'one': 1,
	'two': 2,
}

if

a := 10 
b := 20 
if a < b { 
	println('$a < $b') 
} else if a > b { 
	println('$a > $b') 
} else { 
	println('$a == $b') 
}

if 语句十分简单,并且和大多数语言类似

与其他类c的语言不同，判断的条件不需要括号，但是执行语句始终需要大括号。

if 还可以这样用:

num := 777
s := if num % 2 == 0 {
	'even'
}
else {
	'odd'
}
println(s) // ==> "odd"

`in` 运算符

in 检查数组中是否包含元素

nums := [1, 2, 3]
println(1 in nums) // ==> true

它还有助于帮助我们编写更清晰简洁的布尔表达式:

if parser.token == .plus || parser.token == .minus || parser.token == .div || parser.token == .mult {
	... 
} 

if parser.token in [.plus, .minus, .div, .mult] {
	... 
}

V 会优化这些表达式, 让上面的两个if语句都生成相同的机器码，不创建数组。

`for` 循环

V只有一个循环结构:for

numbers := [1, 2, 3, 4, 5]
for num in numbers {
	println(num)
}
names := ['Sam', 'Peter']
for i, name in names {
	println('$i) $name')  // 输出: 0) Sam
}                         //       1) Peter

for .. in 循环可以用来遍历数组中的元素. 如果需要一个索引,可以使用 for index, value in 来实现

mut sum := 0
mut i := 0
for i <= 100 {
	sum += i
	i++
}
println(sum) // ==> "5050"

这种形式的循环类似于其它语言中的while循环

如果条件判断的结果为false,将停止循环

同样，判断的条件不需要括号，执行代码始终需要大括号。

mut num := 0
for {
	num++
	if num >= 10 {
		break 
	} 
}
println(num) // ==> "10"

判断条件可以省略,结果会导致无限循环

for i := 0; i < 10; i++ {
	println(i)
}

最后,这是传统C风格的for循环 . 它比 while 方式更安全, 因为使用后者很容易忘记更新计数器,陷入死循环.

这的 i 这里不需要用 mut 声明，因为根据定义它总是可变的。

switch语句

os := 'windows' 
print('V is running on ')
switch os {
case 'darwin':
	println('macOS.')
case 'linux':
	println('Linux.')
default:
	println(os) 
}
// TODO: 用匹配表达式代替

switch语句用于在条件多的时候替代if - else 语句. 当遇到第一个case满足时,即运行,运行完后不再向下匹配.

与C不同, 每个语句块后不需要break 语句.

struct 结构体

struct Point {
	x int
	y int 
} 

p := Point{
	x: 10 
	y: 20 
} 
println(p.x) // 结构体的字段使用点 . 访问

结构体是在堆栈上分配的。要在堆上分配一个结构并获得指向它的指针，使用&前缀:

pointer := &Point{10, 10}  // 具有3个或更少字段的结构,可选初始化语法
println(pointer.x) // 指针有相同的语法访问字段

V 没有子类, 但它支持嵌入式结构

// TODO: 这将在6月晚些时候实现
struct Button {
	Widget
	title string
}

button := new_button('Click me')
button.set_pos(x, y)

// 没有嵌入,我们就得这么做
button.widget.set_pos(x,y)

访问修饰符

默认情况下,struct的字段是私有不可变的(同时也使Struct不可变),可以用它们的pub和mut访问修饰符更改,总共有五种选项:

struct Foo {
	a int     // 私有不可变的 (默认) 
mut: 
	b int     // 私有可变的
	c int     // (您可以列出具有相同访问修饰符的多个字段)   
pub: 
	d int     // 公共不可变 (只读) 
pub mut: 
	e int     // 公共, 但仅在父模块中可变  
pub mut mut: 
	f int 	  // public 父模块的内部和外部都是可变的 
}                 // (不推荐使用，这就是它如此冗长的原因)

例如，这是在内置模块中定义的字符串类型:

struct string {
	str byteptr
pub:
	len int
}

从这个定义很容易看出string是一个不可变类型。

指向字符串数据的字节指针在内置之外根本无法访问,len字段是公共的,但不是可变的(只读的).

fn main() {
	str := 'hello' 
	len := str.len // OK,一切正常  
	str.len++      // 编译错误(因为该字段是只读的)  
}

方法

struct User {
	age int 
} 

fn (u User) can_register() bool {
	return u.age > 16 
} 

user := User{age: 10} 
println(user.can_register()) // ==> "false"  

user2 := User{age: 20} 
println(user2.can_register()) // ==> "true"

V 没有类.但是你可以为类型定义方法

方法是一个带有特殊接收器参数的函数。

接收器出现在它自己的参数列表中，在fn关键字和方法名称之间。

在这个例子中, can_register 方法有一个被叫做 u的User类型接收器 . 惯例是不要使用self或this这样的接收方名称,而是使用一个简短的, 最好是一个字母的名称.

默认纯函数Pure functions by default

默认情况下，V函数是纯函数，这意味着它们的返回值只由它们的参数决定，它们的计算没有副作用。

这是由于缺少全局变量，并且默认情况下所有函数参数都是不可变的，即使在传递引用时也是如此。

然而，V并不是一种纯函数语言.可以使用相同的关键字mut修改函数参数:

struct User {
mut:
	is_registered bool 
} 

fn (u mut User) register() {
	u.is_registered = true 
} 

mut user := User{} 
println(user.is_registered) // ==> "false"  
user.register() 
println(user.is_registered) // ==> "true"

在这个例子中,接收器(第一个参数)被标记为可变的,所以register()可以改变user对象,对于非接收器参数也是如此:

fn multiply_by_2(arr mut []int) {
	for i := 0; i < arr.len; i++ {
		arr[i] *= 2
	}
}

mut nums := [1, 2, 3]
multiply_by_2(mut nums)
println(nums) // ==> "[2, 4, 6]"

注意,在你调用这个函数的时候,必须在nums前面加上mnt,这表明被调用的函数将修改值。

最好返回值而不是修改参数(最好是调用函数返回),修改参数应该只在应用程序的性能关键部分执行，以减少分配和复制。

使用 user.register() 或 user = register(user) 代替 register(mut user).

V使返回对象的修改版本变得很容易:

fn register(u User) User { 
	return { u | is_registered: true } 
}

user = register(user)

常量

const (
	PI    = 3.14
	World = '世界'
) 

println(PI)
println(World)

常量使用 const定义,它们只能在模块级别(函数之外)定义.

常量名称必须大写。这有助于将它们与变量区分开。

常量的值永远不会被修改

V常量比大多数语言更灵活,您可以分配更复杂的值:

struct Color {
        r int
        g int
        b int
}

fn (c Color) str() string { return '{$c.r, $c.g, $c.b}' }

fn rgb(r, g, 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)

V不允许全局变量,所以这非常有用

模块Modules

V是一种非常模块化的语言,鼓励创建可重用模块，而且非常简单.要创建一个新模块，请创建一个模块名称的目录，在目录中创建包含代码的.v文件:

cd ~/code/modules
mkdir mymodule
vim mymodule/mymodule.v

// mymodule.v
module mymodule

// 要导出的函数必须使用`pub`修饰符
pub fn say_hi() {
	println('hello from mymodule!')
}

您可以在mymodule/中创建任意数量的.v文件。

使用 v -lib ~/code/modules/mymodule生成它

就这样，你现在可以在你的代码中使用它:

module main

import mymodule

fn main() {
	mymodule.say_hi()
}

注意,每次调用外部函数时必须指定模块.乍一看，这似乎有些冗长,但它使代码更易于阅读和理解.因为总是很清楚从哪个模块调用哪个函数,特别是在大型代码库中。

模块名称应该简短，不超过10个字符。不允许循环导入。

您可以在任何地方创建模块。

所有模块都被静态地编译成一个可执行文件。

接口Interfaces

struct Dog {}
struct Cat {}

fn (d Dog) speak() string { 
	return 'woof'
} 

fn (c Cat) speak() string { 
	return 'meow' 
} 

interface Speaker {
	speak() string
}

fn perform(s Speaker) { 
	println(s.speak())
} 

dog := Dog{} 
cat := Cat{} 
perform(dog) // ==> "woof" 
perform(cat) // ==> "meow"

类型通过实现其方法来实现接口。没有明确的意图声明，没有“implementation”关键字。

枚举Enums

enum Color {
	red green blue 
} 

mut color := Color.red
// V knows that `color` is a `Color`. No need to use `Color.green` here.
color = .green 
println(color) // ==> "1"  TODO: print "green"?

选项/结果类型 &错误处理 Option/Result types & error handling

struct User {
	id int 
	name string
} 

struct Repo {
	users []User 
} 

fn new_repo() Repo {
	return Repo {
		users: [User{1, 'Andrew'}, User {2, 'Bob'}, User {10, 'Charles'}]
	}
} 

fn (r Repo) find_user_by_id(id int) ?User { 
	for user in r.users {
		if user.id == id {
			// V automatically wraps this into an option type  
			return user 
		} 
	} 
	return error('User $id not found') 
} 

fn main() {
	repo := new_repo() 
	user := repo.find_user_by_id(10) or { // Option types must be handled by `or` blocks  
		return  // `or` block must end with `return`, `break`, or `continue`  
	} 
	println(user.id) // ==> "10"  
	println(user.name) // ==> 'Charles'
}

V将选项和结果组合成一种类型，所以您不需要决定使用哪种类型。

将一个函数“升级”为一个可选函数所需的工作量很小:您必须添加一个?返回类型，当出现错误时返回一个错误。

如果不需要返回错误，可以简单地返回None(TODO:然而None还没实现)

这是在v中处理错误的主要方法。它们仍然是值，就像在Go中一样，但是优点是错误不能被取消处理，而且处理它们要少很多麻烦。

你也可以这样传错误信息

resp := http.get(url)?
println(resp.body)

http.get 返回 ?http.Response,返回?,所以错误会被传递到调用函数的函数

上面的代码基本是:

resp := http.get(url) or {
	panic(err)
}
println(resp.body)

泛型(7月)Generics(July)

struct Repo⟨T⟩ {
	db DB
}

fn new_repo⟨T⟩(db DB) Repo⟨T⟩ {
	return Repo⟨T⟩{db: db}
}

// 这是一个泛型函数. V将为它所使用的每种类型生成它。 
fn (r Repo⟨T⟩) find_by_id(id int) ?T {  
	table_name := T.name // 在本例中，获取类型的名称将得到表名
	return r.db.query_one⟨T⟩('select * from $table_name where id = ?', id)
}

db := new_db()
users_repo := new_repo⟨User⟩(db)
posts_repo := new_repo⟨Post⟩(db)
user := users_repo.find_by_id(1)? 
post := posts_repo.find_by_id(1)?

为了可读性,⟨⟩允许而不是< >。vfmt自动替换< >⟨⟩。

并发性Concurrency

并发模型与Go非常相似。要同时运行foo()，只需用go foo()调用它。现在，它在一个新的系统线程中启动该函数。很快goroutines和调度程序将被实现。

Decoding JSON

struct User {
	name string
	age  int 
	foo  Foo    [skip]  // Use `skip` attribute to skip certain fields 
} 

data := '{ "name": "Frodo", "age": 25 }'
user := json.decode(User, data) or {
	eprintln('Failed to decode json')
	return 
} 
println(user.name)
println(user.age)

JSON现在非常流行，这就是内置JSON支持的原因。

decode函数的第一个参数是要解码的类型。第二个参数是JSON字符串。

V生成用于JSON编码和解码的代码。不使用运行时反射。这导致了更好的性能。

测试Testing

// hello.v 
fn hello() string {
	return 'Hello world'
} 

// hello_test.v 
fn test_hello() {
    assert hello() == 'Hello world'
}

所有的测试函数都以test_开头必须放在*_test.v文件中。要运行测试，请执行 v hello_test.v. 要测试整个模块, 运行 v test mymodule.

内存管理Memory management

没有垃圾收集或引用计数。V在编译期间清理它所能清理的。例如:

fn draw_text(s string, x, y int) {
	...
}

fn draw_scene() {
	... 
	draw_text('hello $name1', 10, 10)
	draw_text('hello $name2', 100, 10)
	draw_text(strings.repeat('X', 10000), 10, 50)
	... 
}

字符串不转义draw_text，因此当函数退出时，字符串将被清除。

事实上，前两个调用根本不会导致任何分配。这两个字符串都很小，V将为它们使用预先分配的缓冲区。

对于更复杂的情况，需要手动内存管理。这个问题很快就会解决。

V将在运行时检测内存泄漏并报告它们。例如，要清理数组，可以使用free()方法:

numbers := [0; 1000000] 
...
numbers.free()

Defer

TODO

vfmt