Veamos un ejemplo de macheo:
os := 'windows'
print('V is running on ')
match os {
'darwin' { println('macOS.') }
'linux' { println('Linux.') }
else { println(os) }
}
s := match number {
1 { 'one' }
2 { 'two' }
else {
println('this works too')
'many'
}
}
Una declaración de coincidencia es una forma más corta de escribir una secuencia de declaraciones if - else. Cuando se encuentra una rama coincidente, se ejecutará el siguiente bloque de instrucciones y se devolverá la expresión final. La rama else se evaluará cuando ninguna otra rama coincida.
Tambien podemos utilizar enums:
enum Color {
red
blue
green
}
fn is_red_or_blue(c Color) bool {
return match c {
.red { true }
.blue { true }
else { false }
}
}
También tenemos structs :
struct Point {
x int
y int
}
p := Point{
x: 10
y: 20
}
println(p.x) // Se accede a los campos de estructura utilizando un punto
Las estructuras se asignan en la pila. Para asignar una estructura en el montón y obtener una referencia a ella, use el prefijo &:
// Sintaxis de inicialización alternativa para estructuras con 3 campos o menos
p: = &Point {10, 10}
// Las referencias tienen la misma sintaxis para acceder a los campos
println (p.x)
El tipo de p es &Point. Es una referencia a Point. Las referencias son similares a los punteros Go y las referencias de C ++.
V no tiene subclases, pero admite estructuras incrustadas como Go:
struct Button {
Widget
title string
}
button := new_button('Click me')
button.set_pos(x, y)
button.widget.set_pos(x,y)
Los campos de estructura son privados e inmutables por defecto (haciendo que las estructuras también sean inmutables). Sus modificadores de acceso se pueden cambiar con pub y mut. En total, hay 5 opciones posibles:
struct Foo {
a int // privado inmutable (predeterminado)
mut:
b int // privado mutable
c int // (puede enumerar varios campos con el mismo modificador de acceso)
pub:
d int // público inmutable (solo lectura)
pub mut:
e int // público, pero mutable solo en el módulo principal
__global:
f int // público y mutable tanto dentro como fuera del módulo principal
} // (no se recomienda usar, es por eso que la palabra clave 'global'
// comienza con __)
Por ejemplo, aquí está el tipo de cadena definido en el módulo integrado:
struct string {
str byteptr
pub:
len int
}
Es fácil ver a partir de esta definición que la cadena es un tipo inmutable.
El puntero de byte con los datos de la cadena no es accesible fuera de la construcción. El campo de len es público, pero no mutable:
fn main() {
str := 'hello'
len := str.len // OK
str.len++ // Compilation error
}
Dejo link:
