fn main() {
age = 21
}
Esto no compila porque age no esta declarada, pero podemos arreglarlo :
fn main() {
age := 21
}
En el modo de desarrollo, este código generará una advertencia de "variable no utilizada". En el modo de producción (v -prod foo.v) no se compilará en absoluto, como en Go:
fn main() {
a := 10
if true {
a := 20
}
}
A diferencia de la mayoría de los lenguajes, V no permite sobre escribir una variable por el ámbito de las variables, lo anterior no está permitido. Declarar una variable con un nombre que ya se utiliza en un ámbito primario dará como resultado un error de compilación.
Los tipos que tenemos son :
string
i8 i16 int i64 i128 (soon)
byte u16 u32 u64 u128 (soon)
rune // represents a Unicode code point
f32 f64
byteptr
voidptr
Veamos ejemplo de String :
name := 'Bob'
println('Hello, $name!') // `$` is used for string interpolation
println(name.len)
bobby := name + 'by' // + is used to concatenate strings
println(bobby) // "Bobby"
println(bobby[1..3]) // "ob"
mut s := 'hello '
s += 'world' // `+=` is used to append to a string
println(s) // "hello world"
En V, una cadena es una matriz de bytes de solo lectura. Los datos de cadena se codifican con UTF-8.
Los Strings son inmutables.
Las comillas simples y dobles se pueden usar para denotar cadenas. Por coherencia, vfmt convierte las comillas dobles en comillas simples a menos que la cadena contenga un carácter de comilla simple.
La sintaxis de interpolación es bastante simple. También funciona con campos: 'age = $ user.age'. Si necesita expresiones más complejas, use $ {}: 'puede registrarse = $ {user.age> 13}'.
Todos los operadores en V deben tener valores del mismo tipo en ambos lados. Este código no se compilará si age es un int:
println ('edad =' + edad)
Tenemos que convertir la edad en una cadena:
println ('edad =' + edad.str ())
o use la interpolación de cadenas (preferido):
println ('edad = $ edad')
Para denotar literales de caracteres, usemos `
a := `a`
assert 'aloha!'[0] == `a`
Para cadenas sin escapar, anteponer r:
s := r'hello\nworld'
println(s) // "hello\nworld"
Veamos unos ejemplos de arreglos :
mut nums := [1, 2, 3]
println(nums) // "[1, 2, 3]"
println(nums[1]) // "2"
nums << 4
println(nums) // "[1, 2, 3, 4]"
nums << [5, 6, 7]
println(nums) // "[1, 2, 3, 4, 5, 6, 7]"
mut names := ['John']
names << 'Peter'
names << 'Sam'
// names << 10 <-- No compila. `names` es un arreglo de tipo strings.
println(names.len) // "3"
println('Alex' in names) // "false"
names = [] // names ahora es vacío.
// También podemos preasignar una cierta cantidad de elementos.
ids := [0].repeat(50)
El tipo de matriz está determinado por el primer elemento: [1, 2, 3] es una matriz de entradas.
['a', 'b'] es una matriz de cadenas ([] cadena).
Todos los elementos deben tener el mismo tipo. [1, 'a'] si no, no se compilará.
<< es un operador que agrega un valor al final de la matriz. También puede agregar una matriz completa.
El campo .len devuelve la longitud de la matriz. Tenga en cuenta que es un campo de solo lectura y que el usuario no puede modificarlo. Todos los campos exportados son de solo lectura por defecto en V.
val en la matriz devuelve verdadero si la matriz contiene val.
Todos los arreglos pueden imprimirse fácilmente con println (arr) y convertirse en una cadena con s: = arr.str ().
Las matrices se pueden filtrar y asignar de manera eficiente con los métodos .filter () y .map ():
nums := [1, 2, 3, 4, 5, 6]
even := nums.filter(it % 2 == 0)
println(even) // [2, 4, 6]
words := ['hello', 'world']
upper := words.map(it.to_upper())
println(upper) // ['HELLO', 'WORLD']
Es una variable especial que se refiere a un elemento en los métodos de filter o map.
Unos ejemplo de mapa :
mut m := map[string]int //definimos el mapa.
m['one'] = 1
m['two'] = 2
println(m['one']) // "1"
println(m['bad_key']) // "0"
println('bad_key' in m) // Use `in` para detectar si dicha clave existe
m.delete('two')
numbers := {
'one': 1,
'two': 2,
}
Puff me quedo largo el post, en un rato sigo...
Dejo link:
