lostecho/build-web-application-with-golang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Verificados capitulos 1 y 2

Browse Source
This commit is contained in:
ma0
2016-12-14 21:50:21 -05:00
parent f94c6fce61
commit 85d7878ae0
14 changed files with 217 additions and 216 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
es/02.3.md
View File

@@ -30,7 +30,7 @@ Lo más útil de `if` en Go es que puede tener una instrucción de inicializaci
// el siguiente código no va a compilar
fmt.Println(x)
```
Utilice if-else para múltiples condiciones.
Utiliza if-else para múltiples condiciones.
```
if entero == 3 {
fmt.Println("entero es igual a 3")
@@ -42,7 +42,7 @@ Utilice if-else para múltiples condiciones.
```
### goto
Go la palabra reservada `goto`, sea cuidadoso cuando la usa. `goto` tiene un salto hacia el `label` hacia el cuerpo de el mismo bloque de código.
Go la palabra reservada `goto`, se cuidadoso cuando la usas. `goto` tiene un salto hacia la `etiqueta` en el cuerpo de el mismo bloque de código.
```
func myFunc() {
i := 0
@@ -52,11 +52,11 @@ Go la palabra reservada `goto`, sea cuidadoso cuando la usa. `goto` tiene un sal
goto Here // salta hacia el label "Here"
}
```
El nombre del label diferencia entre mayúsculas y minúsculas.
El nombre de la etiqueta diferencia entre mayúsculas y minúsculas.
### for
`for` es la lógica de control mas poderosa en Go, puede leer los datos en los bucles y realizar operaciones iterativas, al igual que un típico `while`.
`for` es la lógica de control mas poderosa en Go, puede leer los datos en los ciclos y realizar operaciones iterativas, al igual que un típico `while`.
```
for expression1; expression2; expression3 {
//...
@@ -87,14 +87,14 @@ Si no son necesarios, podemos omitir a `expression1` y `expression3`.
sum += sum
}
```
Podemos omitir también el `;`. Se siente familiar? Si, es un `while`.
Podemos omitir también el `;`. ¿Se siente familiar? Si, es un `while`.
```
sum := 1
for sum < 1000 {
sum += sum
}
```
Hay dos operaciones importantes en los bucles que son `break` y `continue`. `break` salta afuera del bucle, y `continue` salta el bucle actual y continua en el siguiente. Si usted anida bucles, utilice `break` para saltar al bucle que esta junto.
Hay dos operaciones importantes en los ciclos que son `break` y `continue`. `break` salta afuera del ciclo, y `continue` salta el ciclo actual y continua en el siguiente. Si usted anida ciclos, utilice `break` para saltar al bucle que esta junto.
```
for index := 10; index>0; index-- {
if index == 5{
@@ -105,22 +105,22 @@ Hay dos operaciones importantes en los bucles que son `break` y `continue`. `bre
// break imprime 10、9、8、7、6
// continue imprime 10、9、8、7、6、4、3、2、1
`for` podría leer los datos desde un `slice` o un `map` cuando es utilizado con `range`.
`for` podría leer los datos desde un `segmento` o un `mapa` cuando es utilizado con `range`.
for k,v:=range map {
fmt.Println("map's key:",k)
fmt.Println("map's val:",v)
fmt.Println("llave del mapa:",k)
fmt.Println("valor del mapa:",v)
}
```
Como Go soporta el retorno de valores múltiples y nos da errores de compilación cuando utiliza valores que no fueron definidos, por eso puede necesitar utilizar `_` para descartar algunos valores de retorno.
```
for _, v := range map{
fmt.Println("map's val:", v)
fmt.Println("valor del mapa:", v)
}
```
### switch
A veces puede pensar que esta utilizando demasiados valores `if-else` para implementar alguna lógica, también puede pensar que no se ve bien y que no sea correcto para mantener a futuro. Ahora es tiempo para utilizar `switch` para resolver este problema.
A veces puedes pensar que estas utilizando demasiados valores `if-else` para implementar alguna lógica, también puedes pensar que no se ve bien y que no sea correcto para mantener a futuro. Ahora es tiempo para utilizar `switch` para resolver este problema.
```
switch sExpr {
case expr1:
@@ -192,7 +192,7 @@ Podemos obtener la siguiente información del ejemplo anterior.
- Utilizamos la palabra reservada `func` para definir la función llamada `funcName`.
- Funciones tienen cero, uno o mas de un argumento, el tipo del argumento después del nombre del mismo y separados por `,`.
- Las funciones pueden devolver múltiples valores.
- Tiene dos valores de retorno llamados `output1` y `output2`, se pueden omitir los nombre y utilizar unicamente los tipos.
- El ejemplo iene dos valores de retorno llamados `output1` y `output2`, se pueden omitir los nombre y utilizar unicamente los tipos.
- Si solo hay un valor de retorno y omite el nombre, no va a necesitar comas para retornar mas valores.
- Si la función no tiene valores de retorno, puede omitir la parte de retorno.
- Si la función tiene valores de retorno, va a necesitar utilizar `return` en alguna parte del cuerpo de la función.
@@ -249,7 +249,7 @@ Vamos a utilizar el ejemplo anterior aquí.
fmt.Printf("%d * %d = %d\n", x, y, xTIMESy)
}
```
En el ejemplo anterior devolvemos dos valores sin nombre, y usted también puede nombrarlos. Si nombramos los valores de retornos, solo vamos a utilizar `return` para devolver para devolver bien los valores ya que se inicializan en la función automáticamente. Debe tener en cuenta que si sus funciones se van a utilizar fuera del paquete, lo que significa que los nombre de las funciones inician con mayúsculas, es mejor que escriba la sentencia mas completa para `return`; esto hace que es código sea mas legible.
En el ejemplo anterior devolvemos dos valores sin nombre, y tu también puedes nombrarlos. Si nombramos los valores de retorno, solo vamos a utilizar `return` para devolver para devolver bien los valores ya que se inicializan en la función automáticamente. Debes tener en cuenta que si tus funciones se van a utilizar fuera del paquete, lo que significa que los nombre de las funciones inician con mayúsculas, es mejor que escriba la sentencia mas completa para `return`; esto hace que es código sea mas legible.
```
func SumAndProduct(A, B int) (add int, Multiplied int) {
add = A+B
@@ -263,7 +263,7 @@ Go soporta funciones con un número variable de argumentos. Estas funciones son
```
func myfunc(arg ...int) {}
```
`arg …int` le dice a Go que esta función tiene argumentos variables. Tenga en cuenta que estos argumentos son de tipo `int`. En el cuerpo de la función , `arg` será un `slice` de `int`.
`arg …int` le dice a Go que esta función tiene argumentos variables. Ten en cuenta que estos argumentos son de tipo `int`. En el cuerpo de la función , `arg` será un `segmento` de `enteros`.
```
for _, n := range arg {
fmt.Printf("Y el número es: %d\n", n)
@@ -295,7 +295,7 @@ Vamos a ver un ejemplo para probar lo que decimos.
fmt.Println("x = ", x) // debe imprimir "x = 3"
}
```
¿Usted vio eso? Siempre que llamamos a `add1`, y `add1` le suma uno a `a`, el valor de `x` no sufre cambios.
¿Viste eso? Siempre que llamamos a `add1`, y `add1` le suma uno a `a`, el valor de `x` no sufre cambios.
El motivo de esto es muy sencillo: cuando llamamos a `add1`, nosotros obtenemos una copia de `x` para esto, no `x` en si mismo.
@@ -323,15 +323,15 @@ Para eso necesitamos utilizar punteros. Sabemos que las variables son almacenada
fmt.Println("x = ", x) // debe imprimir "x = 4"
}
```
Ahora podemos cambiar el valor de `x` en la función. Porque usamos punteros? Cual es la ventaja?
Ahora podemos cambiar el valor de `x` en la función. ¿Por qué usamos punteros? ¿Cuál es la ventaja?
- Usamos mas funciones que modifiquen una misma variable.
- Tiene un bajo costo utilizar direcciones de memoria (8 bytes), la copia no es una forma eficiente tanto en el tiempo como en el espacio para pasar variables.
- `string`, `slice`, `map` son tipos de referenciados, por eso ellos por defecto utilizan punteros cuando se pasan a funciones. (Atención: si necesitas cambiar el tamaño de un `slice`, vas a necesitar pasar el puntero de forma explicita)
- Las `cadenas`, `segmentos` y `mapas` son tipos de referenciados, por eso ellos por defecto utilizan punteros cuando se pasan a funciones. (Atención: si necesitas cambiar el tamaño de un `segmento`, vas a necesitar pasar el puntero de forma explicita)
### defer
Go tiene un muy buen diseño llamado `defer`, uno puede tener muchas declaraciones de `defer` en una función; ellos se ejecutan en orden inverso cuando el programa ejecuta el final de la función. Especialmente cuando el programa abre un recurso como un archivo, estos archivos tienen que ser cerrados antes de que la función devuelva un error. Vamos a ver algún ejemplo.
Go tiene una palabra reservada muy bien diseñada llamada `defer`, puedes tener muchas declaraciones de `defer` en una función; ellas se ejecutan en orden inverso cuando el programa ejecuta el final de la función. Es útil especialmente cuando el programa abre un recurso como un archivo, estos archivos tienen que ser cerrados antes de que la función devuelva un error. Vamos a ver algún ejemplo.
```
func ReadWrite() bool {
file.Open("file")
@@ -376,7 +376,7 @@ Las funciones son también variables en Go, podemos usar un `type` para definirl
```
type typeName func(input1 inputType1 , input2 inputType2 [, ...]) (result1 resultType1 [, ...])
```
Cual es la ventaja de esta característica? Entonces podemos pasar funciones como valores.
¿Cuál es la ventaja de esta característica? La respuesta es que podemos pasar funciones como valores.
```
package main
import "fmt"
@@ -418,7 +418,7 @@ Cual es la ventaja de esta característica? Entonces podemos pasar funciones com
fmt.Println("Even elements of slice are: ", even)
}
```
Es muy útil cuando usamos interfaces. Como puede ver `testInt` es una variable que tiene como tipo una función, y devuelve valores y el argumento de `filter` es el mismo que el de `testInt`. Por lo tanto, tenemos una lógica mas compleja en nuestro programa, y hacemos nuestro código mas flexible.
Es muy útil cuando usamos interfaces. Como puedes ver `testInt` es una variable que tiene como tipo una función, y devuelve valores y el argumento de `filter` es el mismo que el de `testInt`. Por lo tanto, tenemos una lógica mas compleja en nuestro programa, y hacemos nuestro código mas flexible.
### Panic y Recover
@@ -511,6 +511,6 @@ Tenemos algunos operadores especiales para importar paquetes, y los principiante
## Enlaces
- [Indice](preface.md)
- [Índice](preface.md)
- Sección anterior: [Principios de Go](02.2.md)
- Siguiente sección: [struct](02.4.md)