|
jueves, 13 de febrero de 2020
Libros de Java Code Geeks
martes, 11 de febrero de 2020
Perl 6, mejor conocido como Raku
Raku tiene la intención de llevar adelante los altos ideales de la comunidad Perl. Raku ha sido desarrollado por un equipo de voluntarios dedicados y entusiastas, y continúa desarrollándose.
Raku se ve altamente influido por la programación funcional, de esta manera, tiene clausuras, lazy evaluation, patter matching.
Programación orientada a objetos tambien se hace presente y incluye genéricos, roles y polimorfismo.
Paralelismo, concurrencia y asincronía, tambien incluido el soporte multinúcleo
Gramáticas definibles para la coincidencia de patrones y el procesamiento de cadenas generalizado
Mecanografía opcional y gradual
Dejo link : https://www.raku.org/
lunes, 10 de febrero de 2020
El lenguaje de programación V, Parte 8
V puede manejar datos nulos con resultados opcionales :
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 {
return user
}
}
return error('User $id not found')
}
fn main() {
repo := new_repo()
user := repo.find_user_by_id(10) or { // Los tipos de opciones deben manejarse mediante bloques `or`
return // El bloque `or` debe terminar con` return`, `break` o` continue`
}
println(user.id) // "10"
println(user.name) // "Charles"
}
V combina Opcionales y Resultado en un solo tipo, por lo que no necesita decidir cuál usar.
Si no necesita devolver un error, simplemente puede devolver none.
Esta es la forma principal de manejar los errores en V. Es similar a Go, pero la ventaja es que los errores pueden ser manejados, y manejarlos es mucho menos complicado.
err se define dentro de un bloque or y se establece el mensaje de error. err está vacío si no se devolvió algún error.
user := repo.find_user_by_id(7) or {
println(err) // "User 7 not found"
return
}
También puede propagar errores:
resp := http.get(url)?
println(resp.body)
http.get devuelve? http.Response. Se llamó con?, Por lo que el error se propaga a la función de llamada (que debe devolver un opcional) o en caso de que los cables principales entren en pánico.
Básicamente, el código anterior es una versión más corta de
resp := http.get(url) or {
panic(err)
}
println(resp.body)
V no tiene una forma de forzar el desenvolvimiento de un opcional (como el desenvolvimiento de Rust () o el de Swift). Tienes que usar o {panic (err)} en su lugar.
V también tienen generics :
struct Repo<T> {
db DB
}
fn new_repo<T>(db DB) Repo<T> {
return Repo<T>{db: db}
}
// Esta es una función genérica.
fn (r Repo<T>) find_by_id(id int) ?T {
table_name := T.name // en este ejemplo, obtener el nombre del tipo nos da el nombre de la tabla
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)?
Dejo link: https://vlang.io/
viernes, 7 de febrero de 2020
El lenguaje de programación V, Parte 7
Seguimos con V
V es un lenguaje muy modular. Se recomienda crear módulos reutilizables y es muy simple hacerlo. Para crear un nuevo módulo, crea un directorio con el nombre del módulo y los archivos .v con código:
cd ~/code/modules
mkdir mymodule
vim mymodule/mymodule.v
module mymodule
pub fn say_hi() {
println('hola desde mi modulo!')
}
Puede tener tantos archivos .v en mymodule / como desee.
Compílelo con v build module
~/code/modules/mymodule.
Eso es todo, ahora puedes usarlo en tu código:
module main
import mymodule
fn main() {
mymodule.say_hi()
}
Tenga en cuenta que debe especificar el módulo cada vez que llama a una función externa. Esto hace que el código sea mucho más legible y fácil de entender, ya que siempre está claro qué función se llama desde qué módulo. Especialmente en proyectos grandes.
Los nombres de los módulos deben ser cortos, de menos de 10 caracteres. No se permiten importaciones circulares.
Puede crear módulos en cualquier lugar.
Todos los módulos se compilan en un solo ejecutable.
Si desea escribir un módulo que invoque automáticamente algún código de configuración cuando se importe (tal vez desee llamar a algunas funciones de la biblioteca C), escriba una función de inicio del módulo dentro del módulo:
fn init() {
// your setup code here ...
}
La función init no puede ser pública. Se llamará automáticamente.
Un tipo implementa una interfaz mediante la implementación de sus métodos. No hay una declaración explícita de intención, no hay palabras clave "implementa".
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"
enum Color {
red green blue
}
fn main() {
mut color := Color.red
// V sabe que color es un color por ende podemos suprimir Color.
color = .green
println(color) // "1"
if color == .green {
println("it's green")
}
}
Dejo link: https://vlang.io/
Dé un vistazo a cómo se verá el futuro con IA
Me llego el siguiente mail de microsoft, sobre un ebook gratuito :
|
martes, 28 de enero de 2020
El lenguaje de programación V, Parte 6
Seguimos con V
V tiene funciones de orden superior :
fn sqr(n int) int {
return n * n
}
fn run(value int, op fn(int) int) int {
return op(value)
}
fn main() {
println(run(5, sqr)) // "25"
}
Si un argumento de función es inmutable, V puede pasarlo por valor o por referencia. El compilador toma la decisión, y el desarrollador no necesita pensar en ello.
Ya no necesita recordar si debe pasar la estructura por valor o por referencia.
Hay una manera de garantizar que la estructura siempre se pase por referencia agregando &:fn (foo &Foo) bar() {
println(foo.abc)
}
En general, las referencias V son similares a los punteros Go y las referencias C ++. Por ejemplo, una definición de estructura de árbol se vería así:
struct Node<T> {
val T
left &Node
right &Node
}
Las variables globales no están permitidas, por lo que esto puede ser realmente útil.
Al nombrar constantes, se debe usar snake_case. Muchas personas prefieren todos las letras en mayúsculas: TOP_CITIES. Esto no funcionaría bien en V, porque los consts son mucho más poderosos que en otros lenguajes. Pueden representar estructuras complejas, y esto se usa con bastante frecuencia ya que no hay globales:
println('Top cities: $TOP_CITIES.filter(.usa)')
vs
println('Top cities: $top_cities.filter(.usa)')
Con println podemos imprimir lo que se nos de la gana:
println(1) // "1"
println('hi') // "hi"
println([1,2,3]) // "[1, 2, 3]"
println(User{name:'Bob', age:20}) // "User{name:'Bob', age:20}"
Dejo link: https://vlang.io/
Comandos útiles en Docker
Bueno, esto es un post para mi, más que nada, quiero documentar comandos útiles de docker que he usado y seguro me voy a olvidar.
Si debemos copiar un archivo a nuestro contenedor utilizamos docker cp
docker cp foo.txt nombreDeContenedor:/foo.txt
Necesitamos hacer algo con un archivo dentro del contenedor, mover, borrar, copiar, etc... archivos. Podemos utilizar docker exec, veamos un ejemplo, creemos un archivo :
docker exec -it nombreDeContenedor touch /tmp/ejemplo.txt
Hacer una carpeta:
docker exec -it ejemplo mkdir path/nombreDeLaCarpeta
Listar los contenedores que tengo:
docker container ls
Necesitamos saber si nuestro contenedor esta corriendo:
docker ps
Parar el contenedor :
docker stop nombreDeContenedor
Iniciar un contenedor :
docker start nombreDeContenedor
Remover un contenedor:
docker rm nombreDeContenedor
Queremos bajar una imagen :
docker pull nombreImagen
Queremos ver las imagenes que tenemos descargadas :
docker images
Remover una imagen :
docker rmi nombreImagen
Queremos ver información de las imagenes , tamaño , fecha creacion nombre …
docker info
Y estos son los comandos que más uso ...
sábado, 25 de enero de 2020
Como levantar una base de datos Oracle en Docker?
Antes que nada vamos instalar docker : https://docs.docker.com/install/
Luego de instalar docker, se debe hacer una cuenta y aceptar los términos y condiciones de uso de la imagen de Oracle 12.2.1c en el siguiente link:
https://hub.docker.com/u/emanuelpeg/content/sub-58a32504-c6af-4941-8558-061121a0243d
Luego debemos correr docker, para ello podemos ejecutar esta comando en Fedora :
sudo systemctl start docker
Luego debemos loguearnos por consola con el siguiente comando:
docker login
Con este comando, nos logiamos, y docker va a saber que aceptamos los términos y condiciones.
Luego debemos bajar la imagen con :
docker pull store/oracle/database-enterprise:12.2.0.1
Con este comando, bajamos la imagen de oracle, la imagen sería un template con el cual podemos crear containers que tengan base de datos propiamente dichas.
Luego tenemos que crear un container que es la instancia propia de la base, vamos a llamar ejemplo a nuestro container.
docker run -d -it --name ejemplo -p 1521:1521 store/oracle/database-enterprise:12.2.0.1
Como se puede ver se mapeo el puerto 1521 con el 1521 del equipo, esto se puede cambiar si el puerto esta siendo utilizado.
Con docker ps podemos ver si levanto el container con :
docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
c8aea60c0230 store/oracle/database-enterprise:12.2.0.1 "/bin/sh -c '/bin/ba…" 38 seconds ago Up 36 seconds (health: starting) 0.0.0.0:1521->1521/tcp, 5500/tcp ejemplo
Docker creo un container con la base de datos oracle y publico el puerto 1521 para que podamos conectarnos.
Los datos de conexión son :
User : SYS (dba user)
Password : Oradoc_db1
Oracle-sid : ORCLCDB
Estos datos son creados a partir de la imagen de oracle, y simplemente son datos por defecto.
Debemos conectarnos con estos datos para utilizar la base. Para ello utilizamos sqlplus :
$ docker exec -it ejemplo bash -c "source /home/oracle/.bashrc; sqlplus sys/Oradoc_db1@ORCLCDB as sysdba"
Con sqlplus podemos crear usuarios, base de datos, tablas, etc...
Para importar base de datos necesitamos tener un .dmp de la base a importar, yo importaré baseDeEjemplo.dmp
Creamos una carpeta para guardar los backups :
docker exec -it ejemplo mkdir /home/oracle/backups
Debemos copiar este archivo al container :
docker cp baseDeEjemplo.dmp ejemplo:/home/oracle/backups
Ahora debemos importar el dump, con el siguiente comando:
docker exec -it ejemplo bash -c "source /home/oracle/.bashrc; impdp usario/pass@ORCLCDB remap_schema=origen:destino directory= backups dumpfile=baseDeEjemplo.dmp logfile=unLog.log”
Se debe tener la carpeta backup registrada en oracle.
Para conectarnos con un cliente debemos utilizar los siguientes datos :
host=0.0.0.0:1521
SID=ORCLCDB
password = sys
username = Oradoc_db1
Por último, si dejamos de utilizar docker podemos parar el container con
docker stop ejemplo
y podemos iniciar la instancia con start
docker start ejemplo
Dejo link: https://hub.docker.com/u/emanuelpeg/content/sub-58a32504-c6af-4941-8558-061121a0243d?ref=login
jueves, 23 de enero de 2020
Sextos pasos en GIT
Seguimos con GIT.
Administrando branches : Si deseamos lista todas las branches :
$ git branch
Siempre hay una branch llamada ”master”, y es en la que comienzas por defecto.
Algunos aconsejan dejar la rama ”master” sin tocar y el crear nuevas branches para tus propios cambios. El branch ”master” es una convención útil. Otros pueden asumir que tu repositorio tiene un branch con este nombre, y que contiene la versión oficial del proyecto. Puedes renombrar o destruir la branch ”master”, pero también podrías respetar esta costumbre.
Después de un rato puedes notar que estás creando branches de corta vida de manera frecuente por razones similares: cada branch sirve simplemente para salvar el estado actual y permitirte saltar a un estado anterior para solucionar un bug de alta prioridad o algo.
Es análogo a cambiar el canal de la TV temporalmente, para ver que otra cosa están dando. Pero en lugar de apretar un par de botones, tienes que crear, hacer checkout y eliminar branches y commits temporales. Por suerte, Git tiene un atajo que es tan conveniente como un control remoto de TV:
$ git stash
Esto guarda el estado actual en un lugar temporal (un stash) y restaura el estado anterior. Tu directorio de trabajo se ve idéntico a como estaba antes de que comenzaras a editar, y puedes solucionar bugs, traer cambios desde otros repositorios, etc. Cuando quieras volver a los cambios del stash, escribe:
$ git stash apply
Puedes tener varios stashes, y manipularlos de varias maneras. Como es de imaginar, Git mantiene branches de manera interna para lograr este truco mágico.
Aplicaciones como Mozilla Firefox permiten tener varias pestañas y ventanas abiertas. Cambiar de pestaña te da diferente contenido en la misma ventana.
Los branches en git son como pestañas para tu directorio de trabajo. Siguiendo esta analogía, el clonar es como abrir una nueva ventana. La posibilidad de ambas cosas es lo que mejora la experiencia del usuario.
En un nivel más alto, varios window managers en Linux soportan múltiples escritorios. Usar branches en Git es similar a cambiar a un escritorio diferente, mientras clonar es similar a conectar otro monitor para ganar un nuevo escritorio.
Otro ejemplo es el programa screen. Esta joya permite crear, destruir e intercambiar entre varias sesiones de terminal sobre la misma terminal. En lugar de abrir terminales nuevas (clone), puedes usar la misma si ejecutas screen (branch). De hecho, puedes hacer mucho más con screen, pero eso es un asunto para otro manual.
Usar clone, branch y merge, es rápido y local en Git, animándote a usar la combinación que más te favorezca. Git te permite trabajar exactamente como prefieras.
miércoles, 22 de enero de 2020
C++ 17 en detalle
Quiero recomendarles el siguiente libro gratuito de C++ 17 :
Free ebook for every developer
Download your copy of the eBook "C++17 IN DETAIL - Part 1"
Explore the Exciting Features of the New C++ Standard
Explore the Exciting Features of the New C++ Standard
What you will learn:
- What was removed from the language and what is deprecated
- How the language is more precise: for example, thanks to expression evaluation order guarantees
- What the new features of templates are, like if constexpr or fold expressions
- What the new standard attributes are
- How you can write cleaner and more expressive code thanks to structured binding, inline variables, compile-time if or template argument deduction for classes
lunes, 20 de enero de 2020
El lenguaje de programación V, Parte 5
Seguimos con V
Al igual que Go, podemos definir métodos para estructuras :
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 no tiene clases. Pero puede definir métodos de tipos.
Un método es una función con un argumento receptor especial.
El receptor aparece en su propia lista de argumentos entre la palabra clave fn y el nombre del método.
En este ejemplo, el método can_register tiene un receptor de tipo Usuario llamado u. La convención no es usar nombres de receptores como self o this, sino un nombre corto, preferiblemente de una letra.
Las funciones V son puras por defecto, lo que significa que sus valores de retorno solo están determinados por sus argumentos, y su evaluación no tiene efectos secundarios.
Esto se logra por falta de variables globales y todos los argumentos de función son inmutables por defecto, incluso cuando se pasan referencias.
Sin embargo, V no es un lenguaje funcional puro. Es posible modificar los argumentos de la función utilizando la misma palabra clave 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"
En este ejemplo, el receptor (que es simplemente el primer argumento) se marca como mutable, por lo que register() puede cambiar el objeto de usuario. Lo mismo funciona con argumentos no receptores:
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]"
Tengamos en cuenta que debe agregar mut antes de nums cuando llamemos a esta función. Esto deja en claro que la función que se llama modificará el valor.
Es preferible devolver valores en lugar de modificar argumentos. La modificación de argumentos solo debe hacerse en partes críticas de su aplicación para reducir las asignaciones y la copia.
Por esta razón, V no permite modificar argumentos primitivos como enteros, solo tipos complejos como matrices y mapas.
Se debe usarr user.register() o user = register (user) en lugar de register (mut user).
V facilita la devolución de una versión modificada de un objeto:
fn register(u User) User {
return { u | is_registered: true }
}
user = register(user)
Dejo link: https://vlang.io/
domingo, 19 de enero de 2020
El lenguaje de programación V, Parte 4
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:
jueves, 16 de enero de 2020
El lenguaje de programación V, Parte 3
Seguimos con V
Veamos un ejemplo del condicional :
a := 10
b := 20
if a < b {
println('$a < $b')
} else if a > b {
println('$a > $b')
} else {
println('$a == $b')
}
Si las declaraciones son bastante directas y similares a la mayoría de los otros lenguajes.
A diferencia de otros lenguajes tipo C, no hay paréntesis que rodeen la condición, y las llaves siempre son necesarias.
si, se puede usar como una expresión:
num := 777
s := if num % 2 == 0 {
'even'
}
else {
'odd'
}
println(s) // "odd"
in permite verificar si una matriz o un mapa contiene un elemento.
nums := [1, 2, 3]
println(1 in nums) // true
m := {'one': 1, 'two': 2}
println('one' in m) // true
También es útil para escribir expresiones booleanas más claras y compactas:
if parser.token == .plus || parser.token == .minus ||
parser.token == .div || parser.token == .mult {
...
}
if parser.token in [.plus, .minus, .div, .mult] {
...
}
V optimiza tales expresiones, por lo tanto, si las declaraciones anteriores producen el mismo código de máquina, no se crean matrices.
V tiene solo una construcción de bucle: for.
numbers := [1, 2, 3, 4, 5]
for num in numbers {
println(num)
}
names := ['Sam', 'Peter']
for i, name in names {
println('$i) $name') // Output: 0) Sam
}
El valor en el bucle se usa para recorrer elementos de una matriz. Si se requiere un índice, se puede usar una forma alternativa para el índice.
Tengamos en cuenta que el valor es de solo lectura. Si necesita modificar la matriz mientras realiza el bucle, debe usar la indexación:
mut numbers := [1, 2, 3, 4, 5]
for i, num in numbers {
println(num)
numbers[i] = 0
}
mut sum := 0
mut i := 0
for i <= 100 {
sum += i
i++
}
println(sum) // "5050"
Esta forma del bucle es similar a los bucles while en otros lenguajes.
El bucle dejará de iterar una vez que la condición booleana se evalúe como falsa.
No hay paréntesis que rodeen la condición, y siempre se requieren llaves.
mut num := 0
for {
num++
if num >= 10 {
break
}
}
println(num) // "10"
La condición puede omitirse, esto da como resultado un bucle infinito.
for i := 0; i < 10; i++ {
// Don't print 6
if i == 6 {
continue
}
println(i)
}
Finalmente, está el estilo tradicional C para loop. Es más seguro que la forma `while` porque con esta última es fácil olvidarse de actualizar el contador y quedarse atascado en un bucle infinito.
Aquí no necesito ser declarado con mut ya que siempre será mutable por definición.
Dejo link:
https://vlang.io/
miércoles, 15 de enero de 2020
Libros Gratis de Java Geeks
|
El lenguaje de programación V, Parte 2
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:
Suscribirse a:
Entradas (Atom)
