Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 85d7878

Browse files
author
ma0
committedDec 15, 2016
Verificados capitulos 1 y 2
1 parent f94c6fc commit 85d7878

14 files changed

+216
-215
lines changed
 

‎es/01.0.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -16,5 +16,5 @@ En este capítulo, te mostraremos cómo instalar y configurar tu propio ambiente
1616

1717
## Links
1818

19-
- [Directorio](preface.md)
19+
- [Índice](preface.md)
2020
- Sección siguiente: [Instalación](01.1.md)

‎es/01.1.md

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -28,21 +28,21 @@ En Windows, debes instalar MinGW antes para poder instalar gcc. No olvides confi
2828
El equipo Go usa [Mercurial](http://mercurial.selenic.com/downloads/) para manejar su código fuente, por lo que debes instalar esta herramienta para poder bajar el código fuente de Go.
2929

3030
En este punto ejecuta los siguientes comandos para clonar el código fuente de Go y compilarlo. (Clonará el código fuente en tú directorio actual. Cambia tu ruta actual antes de continuar. Esto puede tomar algún tiempo.)
31-
31+
```
3232
hg clone -u release https://code.google.com/p/go
3333
cd go/src
3434
./all.bash
35-
35+
```
3636
Una instalación exitosa finalizará con el mensaje "ALL TESTS PASSED."
3737

3838
En Windows puedes lograr lo mismo ejecutando `all.bat`.
3939

4040
Si estas usando Windows el paquete de instalación establecerá tus variables de entorno automáticamente. En sistemas tipo Unix necesitas establecer estas variables de la siguiente manera. (Si tu versión de Go es mayor que 1.0 no debes establecer $GOBIN ya que estará relacionada automáticamente a tu $GOROOT/bin del que hablaremos en la sección siguiente)
41-
41+
```
4242
export GOROOT=$HOME/go
4343
export GOBIN=$GOROOT/bin
4444
export PATH=$PATH:$GOROOT/bin
45-
45+
```
4646
Si ves la siguiente información en tu pantalla, todo está listo.
4747

4848
![](images/1.1.mac.png?raw=true)
@@ -66,11 +66,11 @@ Si eres un usuario de Mac recomiendo fuertemente que bajes el paquete de 64-bits
6666
Los usuarios de Linux pueden escribir `uname -a` en la terminal para ver la información del sistema.
6767

6868
Un sistema operativo de 64-bits mostrará lo siguiente:
69-
69+
```
7070
<alguna descripción> x86_64 x86_64 x86_64 GNU/Linux
7171
// algunas versiones como Ubuntu 10.04 mostrarán de la siguiente forma
7272
x86_64 GNU/Linux
73-
73+
```
7474
En cambio los sistemas operativos de 32-bits mostrarán:
7575

7676
<alguna descripción> i686 i686 i386 GNU/Linux
@@ -92,32 +92,32 @@ Ve a la [página de descarga](https://golang.org/dl/), escoge `go1.5.3.windows-3
9292
### GVM
9393

9494
GVM es una herramienta de control de múltiples versiones de Go desarrollado por terceros, parecida a rvm para ruby. Es bien fácil de utilizar. Instala gvm escribiendo los siguientes comandos en tu terminal:
95-
95+
```
9696
bash < <(curl -s https://raw.github.com/moovweb/gvm/master/binscripts/gvm-installer)
97-
97+
```
9898
Luego instalamos Go usando los siguientes comandos:
99-
99+
```
100100
gvm install go1.0.3
101101
gvm use go1.0.3
102-
102+
```
103103
Cuando el proceso ha finalizado estamos listos.
104104

105105
### apt-get
106106

107107
Ubuntu es la versión de escritorio más popular de Linux. Utiliza `apt-get` para manejar paquetes. Podemos instalar Go usando los siguientes comandos.
108-
108+
```
109109
sudo add-apt-repository ppa:gophers/go
110110
sudo apt-get update
111111
sudo apt-get install golang-stable
112-
112+
```
113113
### Homebrew
114114

115115
Homebrew es una herramienta para manejar software comúnmente usada en la Mac. Simplemente escribe lo siguiente para instalar Go.
116-
116+
```
117117
brew install go
118-
118+
```
119119
## Links
120120

121-
- [Directorio](preface.md)
121+
- [Índice](preface.md)
122122
- Sección anterior: [Configurando el entorno de Go](01.0.md)
123123
- Sección siguiente: [$GOPATH y el ambiente de trabajo](01.2.md)

‎es/01.2.md

Lines changed: 22 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -5,9 +5,9 @@
55
Todos los comandos de Go dependen de una importante variable de entorno llamada $GOPATH. Favor notar que esta no es la variable $GOROOT que es la que muestra dónde Go está instalado. Esta variable apunta al ambiente de trabajo de Go en tu computadora (Yo uso esta ruta en mi computadora; si no tienes la misma estructura de directorios, por favor reemplaza por la que tengas).
66

77
En sistemas tipo Unix, la variable debe usar así:
8-
8+
```
99
export GOPATH=/home/apple/mygo
10-
10+
```
1111
En Windows, necesitas crear una nueva variable de entorno llamada GOPATH, luego estable su valor a `c:\mygo` (Este valor depende dónde tu ambiente de trabajo esté ubicado)
1212

1313
Está bien tener más de una ruta de ambiente de trabajo en $GOPATH, pero recuerda que debes usar `:`(`;` en Windows) para separarlos. En este punto, `go get` guardará el contenido de tu primera ruta en $GOPATH.
@@ -22,17 +22,17 @@ En este libro, utilizo `mygo` cómo mi única ruta en $GOPATH.
2222

2323
## Directorio de paquetes
2424

25-
Crea archivos de código fuente de paquetes de la siguiente forma `$GOPATH/src/mymath/sqrt.go` (`mymath` es el nombre del paquete) ( ***El autor utiliza `mymath` cómo su nombre de paquete, el mismo nombre para el directorio que contiene los archivos de código fuente del paquete)
25+
Crea archivos de código fuente de paquetes de la siguiente forma `$GOPATH/src/mymath/sqrt.go` (`mymath` es el nombre del paquete) ( **El autor utiliza `mymath` cómo su nombre de paquete, el mismo nombre para el directorio que contiene los archivos de código fuente del paquete**)
2626

2727
Cada vez que creas un paquete, deberías crear un nuevo folder en el directorio `src`. Los nombres de los directorios usualmente son los mismos que el paquete que vas a utilizar. Puedes tener directorios de múltiples niveles si lo deseas. Por ejemplo, si creas el directorio `$GOPATH/src/github.com/astaxie/beedb`, entonces la ruta del paquete sería `github.com/astaxie/beedb`. El nombre del paquete será el último directorio en tu ruta, que es `beedb` en este caso.
2828

2929
Ejecuta los siguientes comandos. (Ahora el autor mostrará unos ejemplos)
30-
30+
```
3131
cd $GOPATH/src
3232
mkdir mymath
33-
33+
```
3434
Crea un nuevo archivo llamado `sqrt.go`, escribe el siguiente contenido en el archivo.
35-
35+
```
3636
// Código fuente de $GOPATH/src/mymath/sqrt.go
3737
package mymath
3838
@@ -43,7 +43,7 @@ Crea un nuevo archivo llamado `sqrt.go`, escribe el siguiente contenido en el ar
4343
}
4444
return z
4545
}
46-
46+
```
4747
Ahora el directorio de mi paquete ha sido creado y su código ha sido escrito. Recomiendo que uses el mismo nombre para tus paquetes y sus directorios correspondientes y que los directorios contenga todo el código fuente del paquete.
4848

4949
## Compilar paquetes
@@ -54,24 +54,24 @@ Ya hemos creado nuestra paquete, pero cómo lo compilamos para propósitos prác
5454
2. Ejecuta el comando de arriba, con la diferencia de que suministras el nombre del archivo como parámetro `go install mymath`.
5555

5656
Después de compilar podemos abrir el siguiente directorio.
57-
57+
```
5858
cd $GOPATH/pkg/${GOOS}_${GOARCH}
5959
// puedes ver que el archivo fue generado
6060
mymath.a
61-
61+
```
6262
Este archivo cuyo sufijo es `.a`, es el archivo binario de nuestro paquete. Cómo lo usamos?
6363

6464
Obviamente, necesitamos crear una nueva aplicación para utilizarlo.
6565

6666
Crea una nueva aplicación llamada `mathapp`.
67-
67+
```
6868
cd $GOPATH/src
6969
mkdir mathapp
7070
cd mathapp
7171
vim main.go
72-
72+
```
7373
código
74-
74+
```
7575
//$GOPATH/src/mathapp/main.go código fuente
7676
package main
7777
@@ -83,23 +83,23 @@ código
8383
func main() {
8484
fmt.Printf("Hello, world. Sqrt(2) = %v\n", mymath.Sqrt(2))
8585
}
86-
86+
```
8787
Para compilar esta aplicación necesitas cambiar al directorio de la aplicación que en este caso es `$GOPATH/src/mathapp`, luego ejecuta el comando `go install`. Ahora deberías ver un archivo ejecutable llamado `mathapp` que se ha generado en el directorio `$GOPATH/bin/`. Para correr este programa usa el comando `./mathapp`. Deberías de ver el siguiente contenido en tu terminal:
88-
88+
```
8989
Hello world. Sqrt(2) = 1.414213562373095
90-
90+
```
9191
## Instala paquete remotos
9292

9393
Go tiene una herramienta para instalar paquetes remotos, es el comando llamado `go get`. Soporta la mayoría de comunidades de código libre, incluyendo Github, Google Code, BitBucket y Launchpad.
94-
94+
```
9595
go get github.com/astaxie/beedb
96-
96+
```
9797
Puedes usar `go get -u …` para actualizar tus paquetes remotos e incluso instalará todas sus dependencias.
9898

9999
Esta herramienta usará diferente herramientas de control de versiones para las diferentes plataformas de código libre. Por ejemplo, `git` para Github y `hg` para Google Code. Debido a esto, debes instalar estas herramientas de control de versiones antes de usar `go get`.
100100

101101
Después de ejecutar los comandos anteriormente descritos, la estructura de directorios debería verse de la siguiente forma:
102-
102+
```
103103
$GOPATH
104104
src
105105
|-github.com
@@ -110,7 +110,7 @@ Después de ejecutar los comandos anteriormente descritos, la estructura de dire
110110
|-github.com
111111
|-astaxie
112112
|-beedb.a
113-
113+
```
114114
Actualmente, `go get` clona el código fuente a la ruta $GOPATH/src, luego ejecuta `go install`.
115115

116116
Puedes usar paquetes remotos de la misma forma que usas paquetes locales.
@@ -120,7 +120,7 @@ Puedes usar paquetes remotos de la misma forma que usas paquetes locales.
120120
## Estructura completa del directorio
121121

122122
Si has seguido todos los pasos anteriores, la estructura de tu directorio se debería ver de la siguiente forma.
123-
123+
```
124124
bin/
125125
mathapp
126126
pkg/
@@ -139,13 +139,13 @@ Si has seguido todos los pasos anteriores, la estructura de tu directorio se deb
139139
beedb/
140140
beedb.go
141141
util.go
142-
142+
```
143143
Ahora puedes ver la estructura de directorios claramente; `bin` contiene los archivos ejecutables, `pkg` contiene los archivos compliados y `src` los archivos de código fuente del paquete.
144144

145145
(El formato de las variables de entorno en Windows es `%GOPATH%`, sin embargo este libro sigue principalmente el estilo Unix, así que si eres un usuario Windows debes reemplazarlo apropiadamente)
146146

147147
## Links
148148

149-
- [Directorio](preface.md)
149+
- [Índice](preface.md)
150150
- Sección anterior: [Instalación](01.1.md)
151151
- Sección siguiente: [Comandos Go](01.3.md)

‎es/01.3.md

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@ Este comando es para pruebas de compilación. Compilará paquetes dependientes d
3131
## go clean
3232

3333
Este comando es para limpiar los archivos que son generados por los compiladores, incluyendo los siguientes archivos:
34-
34+
```
3535
_obj/ // viejo directorio de object, dejado por Makefiles
3636
_test/ // viejo directorio de test, dejado por Makefiles
3737
_testmain.go // viejo directorio de gotest, dejado por Makefiles
@@ -42,7 +42,7 @@ Este comando es para limpiar los archivos que son generados por los compiladores
4242
DIR(.exe) // generado por go build
4343
DIR.test(.exe) // generado por go test -c
4444
MAINFILE(.exe) // generado por go build MAINFILE.go
45-
45+
```
4646
Usualmente utilizo este comando para limpiar mis archivos antes de subir mi proyecto a Github. Estas son herramientas útiles para pruebas locales, pero inútiles para el control de versiones.
4747

4848
## go fmt
@@ -54,12 +54,12 @@ Usualmente usamos `gofmt -w` en vez de `go fmt`. El último, no rescribirá tus
5454
## go get
5555

5656
Este comando es para obtener paquetes remotos. Hasta el momento soporta BitBucket, Github, Google Code y Launchpad. Actualmente existen dos cosas que suceden después de ejecutar este comando. La primera es que Go descarga el código fuente, luego ejecuta `go install`. Antes de que utilices este comando, asegúrate que tienes instaladas todas las herramientas relacionadas.
57-
57+
```
5858
BitBucket (Mercurial Git)
5959
Github (git)
6060
Google Code (Git, Mercurial, Subversion)
6161
Launchpad (Bazaar)
62-
62+
```
6363
Para poder usar este comando, debes instalar estas herramientas correctamente. No olvides establecer `$PATH`. Por cierto, también soporta nombres de dominios customizados. Usa `go help remote` para más detalles al respecto.
6464

6565
## go install
@@ -69,12 +69,12 @@ Este comando compila todos los paquetes y genera archivos, luego los mueve a `$G
6969
## go test
7070

7171
Este comando carga todos los archivos cuyos nombres incluyen `*_test.go` y genera archivos de pruebas, luego muestra información que se ve de la siguiente forma.
72-
72+
```
7373
ok archive/tar 0.011s
7474
FAIL archive/zip 0.022s
7575
ok compress/gzip 0.033s
7676
...
77-
77+
```
7878
Prueba todos tus archivos de prueba por defecto. Usa el comando `go help testflag` para más detalles.
7979

8080
## go doc
@@ -88,17 +88,17 @@ Ejecuta el comando `godoc -http=:8080`, luego abre `127.0.0.1:8080` en tu navega
8888
## Otros comandos
8989

9090
Go provee comandos adicionales a los que ya mostramos.
91-
91+
```
9292
go fix // actualiza código de una vieja versión antes de go1 a una nueva versión después de go1
9393
go version // muestra información de tu versión de Go
9494
go env // muestra las variables de entorno relacionadas a Go
9595
go list // lista todos los paquetes instalados
9696
go run // compila los archivos temporales y ejecuta la aplicación
97-
97+
```
9898
También hay más detalles de los comandos que hemos hablado, puedes usar el comando `go help <nombre de comando>` para mostrarlos.
9999

100100
## Links
101101

102-
- [Directorio](preface.md)
102+
- [Índice](preface.md)
103103
- Sección anterior: [$GOPATH y el ambiente de trabajo](01.2.md)
104104
- Sección siguiente: [Herramientas de Desarrollo para Go](01.4.md)

‎es/01.4.md

Lines changed: 30 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -54,14 +54,14 @@ Características de LiteIDE
5454
- Instala gocode
5555

5656
Debes instalar gocode para poder usar el completamiento inteligente
57-
57+
```
5858
go get -u github.com/nsf/gocode
59-
59+
```
6060
- Entorno de compilación
6161

6262
Cambia la configuración en LiteIDE para que se ajuste a tu sistema operativo.
6363
En Windows y usando al versión de 64-bits de Go, debes usar win64 cómo la configuración de entorno en la barra de herramientas. Luego escoge `Options`, busca `LiteEnv` en la lista de la izquierda y abre el archivo `win64.env` en la lista de la derecha.
64-
64+
```
6565
GOROOT=c:\go
6666
GOBIN=
6767
GOARCH=amd64
@@ -70,11 +70,11 @@ Características de LiteIDE
7070
7171
PATH=%GOBIN%;%GOROOT%\bin;%PATH%
7272
。。。
73-
73+
```
7474
Reemplaza `GOROOT=c:\go` con tu ruta de instalación de Go y guarda. Si tienes MinGW64, agrega `c:\MinGW64\bin` a la variable de entorno de tu path para soportar `cgo`.
7575

7676
En Linux y usando la versiónd de 64-bits de Go, debes escoger linux64 como la configuración de entorno en la barra de herramientas. Luego escoge `Options`, busca `LiteEnv` en la lista de la izquierda y abre el archivo `linux64.env` en la lista de la derecha.
77-
77+
```
7878
GOROOT=$HOME/go
7979
GOBIN=
8080
GOARCH=amd64
@@ -83,7 +83,7 @@ Características de LiteIDE
8383
8484
PATH=$GOBIN:$GOROOT/bin:$PATH
8585
。。。
86-
86+
```
8787
Reemplaza `GOROOT=$HOME/go` con tu ruta de instalación de Go y guarda.
8888
- $GOPATH
8989
$GOPATH es la ruta que contiene la lista de proyectos. Abre la herramienta de comandos (o presiona `Ctrl+` en LiteIDE), luego escribe `go help gopath` para más detalles.
@@ -141,22 +141,22 @@ Vim es un editor de texto popular para los programadores, que evolucionó de su
141141
Imagen 1.8 Completamiento inteligente en Vim para Go
142142

143143
1. Realce de sintaxis para Go
144-
144+
```
145145
cp -r $GOROOT/misc/vim/* ~/.vim/
146-
146+
```
147147
2. Habilitando el realce de sintaxis
148-
148+
```
149149
filetype plugin indent on
150150
syntax on
151-
151+
```
152152
3. Instalar [gocode](https://github.com/nsf/gocode/)
153-
153+
```
154154
go get -u github.com/nsf/gocode
155-
155+
```
156156
gocode se instalará por defecto en `$GOBIN`
157157

158158
4. Configura [gocode](https://github.com/nsf/gocode/)
159-
159+
```
160160
~ cd $GOPATH/src/github.com/nsf/gocode/vim
161161
~ ./update.bash
162162
~ gocode set propose-builtins true
@@ -166,7 +166,7 @@ Imagen 1.8 Completamiento inteligente en Vim para Go
166166
~ gocode set
167167
propose-builtins true
168168
lib-path "/home/border/gocode/pkg/linux_amd64"
169-
169+
```
170170
Explicación de la configuración de gocode:
171171

172172
propose-builtins: especifica si abrir o no el completamiento inteligente; falso por defecto.
@@ -183,16 +183,16 @@ Emcas es la llamada arma de Dios. No es solamente un editor, sino un poderoso ID
183183
Imagen 1.10 Panel principal de Emacs editando Go
184184

185185
1. Realce de sintaxis
186-
186+
```
187187
cp $GOROOT/misc/emacs/* ~/.emacs.d/
188-
188+
```
189189
2. Instalar [gocode](https://github.com/nsf/gocode/)
190-
190+
```
191191
go get -u github.com/nsf/gocode
192-
192+
```
193193
gocode se instalará por defecto en `$GOBIN`
194194
3. Configura [gocode](https://github.com/nsf/gocode/)
195-
195+
```
196196
~ cd $GOPATH/src/github.com/nsf/gocode/vim
197197
~ ./update.bash
198198
~ gocode set propose-builtins true
@@ -202,25 +202,25 @@ Imagen 1.10 Panel principal de Emacs editando Go
202202
~ gocode set
203203
propose-builtins true
204204
lib-path "/home/border/gocode/pkg/linux_amd64"
205-
205+
```
206206
4. Instalar [Auto Completion](http://www.emacswiki.org/emacs/AutoComplete)
207207
Descarga y descomprime
208-
208+
```
209209
~ make install DIR=$HOME/.emacs.d/auto-complete
210-
210+
```
211211
Configura el archivo ~/.emacs
212-
212+
```
213213
;;auto-complete
214214
(require 'auto-complete-config)
215215
(add-to-list 'ac-dictionary-directories "~/.emacs.d/auto-complete/ac-dict")
216216
(ac-config-default)
217217
(local-set-key (kbd "M-/") 'semantic-complete-analyze-inline)
218218
(local-set-key "." 'semantic-complete-self-insert)
219219
(local-set-key ">" 'semantic-complete-self-insert)
220-
220+
```
221221
Visita este [link](http://www.emacswiki.org/emacs/AutoComplete) para más detalles.
222222
5. Configura .emacs
223-
223+
```
224224
;; golang mode
225225
(require 'go-mode-load)
226226
(require 'go-autocomplete)
@@ -305,6 +305,7 @@ Imagen 1.10 Panel principal de Emacs editando Go
305305
(interactive)
306306
(show-all)
307307
(shell-command-on-region (point-min) (point-max) "go tool fix -diff"))
308+
```
308309
6. Felicitaciones, ya estás listo! Speedbar está cerrada por defecto -remueve los símbolos de comentarios en la línea `;;(speedbar 1)` para habilitar esta característica o puedes usarla a través de `M-x speedbar`.
309310

310311
## Eclipse
@@ -327,9 +328,9 @@ Imagen 1.1 Panel principal de Eclipse editando Go
327328
Necesitas instalar git en Windows, usualmente usamos [msysgit](https://code.google.com/p/msysgit/)
328329

329330
Instala gocode en la herramienta de comandos
330-
331+
```
331332
go get -u github.com/nsf/gocode
332-
333+
```
333334
También puedes instalar desde el código fuente si gustas.
334335
4. Descarga e instala [MinGW](http://sourceforge.net/projects/mingw/files/MinGW/)
335336
5. Configura los plugins.
@@ -390,10 +391,10 @@ Las personas que han trabajado con Java deben estar familiarizadas con este IDE.
390391

391392
Introduce la ubicación de tu Go sdk en el siguiente paso - básicamente es tu $GOROOT.
392393

393-
( ***Revisa este [artíclo de blog](http://wuwen.org/tips-about-using-intellij-idea-and-go/) para una configuración paso a paso *** )
394+
(**Revisa este [artíclo de blog](http://wuwen.org/tips-about-using-intellij-idea-and-go/) para una configuración paso a paso** )
394395

395396
## Links
396397

397-
- [Directorio](preface.md)
398+
- [Índice](preface.md)
398399
- Sección anterior: [Comandos Go](01.3.md)
399400
- Sección siguiente: [Resumen](01.5.md)

‎es/01.5.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,6 @@ En este capítulo hablamos acerca de como instalar Go usando tres métodos difer
44

55
## Links
66

7-
- [Directorio](preface.md)
7+
- [Índice](preface.md)
88
- Sección anterior: [Herramientas de Desarrollo para Go](01.4.md)
99
- Siguiente capítulo: [Conocimiento básico de Go](02.0.md)

‎es/02.1.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -98,6 +98,6 @@ Go usa `package` (como lo módulos en Python) para organizar los programas. La f
9898

9999
## Enlaces
100100

101-
- [Directorio](preface.md)
101+
- [Índice](preface.md)
102102
- Sección anterior: [Go, Conocimiento básico](02.0.md)
103103
- Siguiente sección: [Fundamentos de Go](02.2.md)

‎es/02.2.md

Lines changed: 87 additions & 87 deletions
Large diffs are not rendered by default.

‎es/02.3.md

Lines changed: 21 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@ Lo más útil de `if` en Go es que puede tener una instrucción de inicializaci
3030
// el siguiente código no va a compilar
3131
fmt.Println(x)
3232
```
33-
Utilice if-else para múltiples condiciones.
33+
Utiliza if-else para múltiples condiciones.
3434
```
3535
if entero == 3 {
3636
fmt.Println("entero es igual a 3")
@@ -42,7 +42,7 @@ Utilice if-else para múltiples condiciones.
4242
```
4343
### goto
4444

45-
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.
45+
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.
4646
```
4747
func myFunc() {
4848
i := 0
@@ -52,11 +52,11 @@ Go la palabra reservada `goto`, sea cuidadoso cuando la usa. `goto` tiene un sal
5252
goto Here // salta hacia el label "Here"
5353
}
5454
```
55-
El nombre del label diferencia entre mayúsculas y minúsculas.
55+
El nombre de la etiqueta diferencia entre mayúsculas y minúsculas.
5656

5757
### for
5858

59-
`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`.
59+
`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`.
6060
```
6161
for expression1; expression2; expression3 {
6262
//...
@@ -87,14 +87,14 @@ Si no son necesarios, podemos omitir a `expression1` y `expression3`.
8787
sum += sum
8888
}
8989
```
90-
Podemos omitir también el `;`. Se siente familiar? Si, es un `while`.
90+
Podemos omitir también el `;`. ¿Se siente familiar? Si, es un `while`.
9191
```
9292
sum := 1
9393
for sum < 1000 {
9494
sum += sum
9595
}
9696
```
97-
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.
97+
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.
9898
```
9999
for index := 10; index>0; index-- {
100100
if index == 5{
@@ -105,22 +105,22 @@ Hay dos operaciones importantes en los bucles que son `break` y `continue`. `bre
105105
// break imprime 10、9、8、7、6
106106
// continue imprime 10、9、8、7、6、4、3、2、1
107107
108-
`for` podría leer los datos desde un `slice` o un `map` cuando es utilizado con `range`.
108+
`for` podría leer los datos desde un `segmento` o un `mapa` cuando es utilizado con `range`.
109109
110110
for k,v:=range map {
111-
fmt.Println("map's key:",k)
112-
fmt.Println("map's val:",v)
111+
fmt.Println("llave del mapa:",k)
112+
fmt.Println("valor del mapa:",v)
113113
}
114114
```
115115
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.
116116
```
117117
for _, v := range map{
118-
fmt.Println("map's val:", v)
118+
fmt.Println("valor del mapa:", v)
119119
}
120120
```
121121
### switch
122122

123-
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.
123+
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.
124124
```
125125
switch sExpr {
126126
case expr1:
@@ -192,7 +192,7 @@ Podemos obtener la siguiente información del ejemplo anterior.
192192
- Utilizamos la palabra reservada `func` para definir la función llamada `funcName`.
193193
- Funciones tienen cero, uno o mas de un argumento, el tipo del argumento después del nombre del mismo y separados por `,`.
194194
- Las funciones pueden devolver múltiples valores.
195-
- Tiene dos valores de retorno llamados `output1` y `output2`, se pueden omitir los nombre y utilizar unicamente los tipos.
195+
- El ejemplo iene dos valores de retorno llamados `output1` y `output2`, se pueden omitir los nombre y utilizar unicamente los tipos.
196196
- Si solo hay un valor de retorno y omite el nombre, no va a necesitar comas para retornar mas valores.
197197
- Si la función no tiene valores de retorno, puede omitir la parte de retorno.
198198
- 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í.
249249
fmt.Printf("%d * %d = %d\n", x, y, xTIMESy)
250250
}
251251
```
252-
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.
252+
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.
253253
```
254254
func SumAndProduct(A, B int) (add int, Multiplied int) {
255255
add = A+B
@@ -263,7 +263,7 @@ Go soporta funciones con un número variable de argumentos. Estas funciones son
263263
```
264264
func myfunc(arg ...int) {}
265265
```
266-
`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`.
266+
`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`.
267267
```
268268
for _, n := range arg {
269269
fmt.Printf("Y el número es: %d\n", n)
@@ -295,7 +295,7 @@ Vamos a ver un ejemplo para probar lo que decimos.
295295
fmt.Println("x = ", x) // debe imprimir "x = 3"
296296
}
297297
```
298-
¿Usted vio eso? Siempre que llamamos a `add1`, y `add1` le suma uno a `a`, el valor de `x` no sufre cambios.
298+
¿Viste eso? Siempre que llamamos a `add1`, y `add1` le suma uno a `a`, el valor de `x` no sufre cambios.
299299

300300
El motivo de esto es muy sencillo: cuando llamamos a `add1`, nosotros obtenemos una copia de `x` para esto, no `x` en si mismo.
301301

@@ -323,15 +323,15 @@ Para eso necesitamos utilizar punteros. Sabemos que las variables son almacenada
323323
fmt.Println("x = ", x) // debe imprimir "x = 4"
324324
}
325325
```
326-
Ahora podemos cambiar el valor de `x` en la función. Porque usamos punteros? Cual es la ventaja?
326+
Ahora podemos cambiar el valor de `x` en la función. ¿Por qué usamos punteros? ¿Cuál es la ventaja?
327327

328328
- Usamos mas funciones que modifiquen una misma variable.
329329
- 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.
330-
- `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)
330+
- 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)
331331

332332
### defer
333333

334-
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.
334+
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.
335335
```
336336
func ReadWrite() bool {
337337
file.Open("file")
@@ -376,7 +376,7 @@ Las funciones son también variables en Go, podemos usar un `type` para definirl
376376
```
377377
type typeName func(input1 inputType1 , input2 inputType2 [, ...]) (result1 resultType1 [, ...])
378378
```
379-
Cual es la ventaja de esta característica? Entonces podemos pasar funciones como valores.
379+
¿Cuál es la ventaja de esta característica? La respuesta es que podemos pasar funciones como valores.
380380
```
381381
package main
382382
import "fmt"
@@ -418,7 +418,7 @@ Cual es la ventaja de esta característica? Entonces podemos pasar funciones com
418418
fmt.Println("Even elements of slice are: ", even)
419419
}
420420
```
421-
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.
421+
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.
422422

423423
### Panic y Recover
424424

@@ -511,6 +511,6 @@ Tenemos algunos operadores especiales para importar paquetes, y los principiante
511511

512512
## Enlaces
513513

514-
- [Indice](preface.md)
514+
- [Índice](preface.md)
515515
- Sección anterior: [Principios de Go](02.2.md)
516516
- Siguiente sección: [struct](02.4.md)

‎es/02.4.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -209,6 +209,6 @@ Go utiliza una forma muy sencilla para resolverlo. Los campos exteriores consigu
209209
```
210210
## Enlaces
211211

212-
- [Indice](preface.md)
212+
- [Índice](preface.md)
213213
- Sección anterior: [Sentencias de control y funciones](02.3.md)
214214
- Siguiente sección: [Orientado a objetos](02.5.md)

‎es/02.5.md

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@ En las ultimas dos secciones hablamos de funciones y struct, alguna vez pensaste
44

55
## Métodos
66

7-
Supongamos que definimos un struct del estilo rectángulo(rectangle), y usted busca calcular el área, por lo general vamos a usar el siguiente código para lograr este objetivo.
7+
Supongamos que definimos un struct del estilo rectángulo(rectangle), y buscas calcular el área, por lo general vamos a usar el siguiente código para lograr este objetivo.
88
```
99
package main
1010
import "fmt"
@@ -36,7 +36,7 @@ Obviamente, no es “cool”. Además el área debería ser propiedad del circul
3636

3737
Por estas razones, tenemos conceptos sobre `métodos`. `métodos` es afiliado a un tipo, tienen la misma sintaxis que una función excepto por una palabra más después de la palabra reservada `func` que es llamada receptor (`receiver`) que es el cuerpo principal de ese método.
3838

39-
Utilice el mismo ejemplo, `Rectangle.area()` pertenece al rectángulo, no como una función periférica. Mas específicamente, `length`, `width` y `area()` todos pertenecen a rectángulo.
39+
Utiliza el mismo ejemplo, `Rectangle.area()` pertenece al rectángulo, no como una función periférica. Mas específicamente, `length`, `width` y `area()` todos pertenecen a rectángulo.
4040

4141
Como dice Rob Pike.
4242

@@ -45,7 +45,7 @@ Como dice Rob Pike.
4545
Sintaxis de un método.
4646
```
4747
func (r ReceiverType) funcName(parameters) (results)
48-
```
48+
```
4949
Cambiemos el ejemplo anterior para utilizar métodos.
5050
```
5151
package main
@@ -121,7 +121,7 @@ Espero que ahora sepa como utilizar los tipos personalizados. Es similar a `type
121121

122122
Volvamos a los `métodos`.
123123

124-
Puede utilizar tantos métodos en tipos personalizados como desees.
124+
Puedes utilizar tantos métodos en tipos personalizados como desees.
125125
```
126126
package main
127127
import "fmt"
@@ -210,17 +210,17 @@ Entonces vamos a definir algunos métodos para personalizar nuestros tipos.
210210
- PaintItBlack() configuramos el color para todas las Box en BoxList a negro.
211211
- String() usamos Color como su receptor, devolvemos un string con formato de el nombre del color.
212212

213-
Es mucho mas claro cuando usamos palabras para describir nuestro requerimientos? Usualmente escribimos nuestros requerimientos antes de comenzar a programar.
213+
¿Es mucho mas claro cuando usamos palabras para describir nuestro requerimientos? Usualmente escribimos nuestros requerimientos antes de comenzar a programar.
214214

215215
### Utilizar punteros como un receptor
216216

217-
Vamos a mirar el método `SetColor`, su receptor es un puntero de tipo Box. Si, podes usar `*Box` como receptor. Porque usaríamos un puntero acá? Porque buscamos cambiar el color de Box en este método, si no usamos un puntero, solo cambiaría el valor de la copia de Box.
217+
Vamos a mirar el método `SetColor`, su receptor es un puntero de tipo Box. Si, puedes usar `*Box` como receptor. ¿Por qué usaríamos un puntero aquí? Porque buscamos cambiar el color de Box en este método, si no usamos un puntero, solo cambiaría el valor de la copia de Box.
218218

219219
Si vemos el receptor como el primer argumento de los métodos, no es difícil de entender como funcionan estos.
220220

221221
Podría decir que deberíamos usar `*b.Color=c` en vez de `b.Color=c` en el método SetColor(). Cualquiera de los dos estaría bien, porque Go lo sabe interpretar. ¿Ahora crees que Go es mas fascinante?
222222

223-
También podría decir que deberíamos usar `(&bl[i]).SetColor(BLACK)` en `PaintItBlack` porque le pasamos un puntero a `SetColor`. Una vez más, cualquiera de los dos esta bien, porque Go sabe interpretarlo correctamente!
223+
También podría decir que deberíamos usar `(&bl[i]).SetColor(BLACK)` en `PaintItBlack` porque le pasamos un puntero a `SetColor`. Una vez más, cualquiera de los dos esta bien, porque ¡Go sabe interpretarlo correctamente!
224224

225225
### Herencia de métodos
226226

@@ -298,10 +298,10 @@ Si queremos que Employee tenga su propio método llamado `SayHi`, podemos defini
298298
sam.SayHi()
299299
}
300300
```
301-
Ahora usted es capaz de escribir programas que utilicen el paradigma Orientado a Objetos, los métodos utilizan la regla de que los que tienen nombre que se inician con mayúsculas van a ser públicos o privados en caso contrario.
301+
Ahora eres capaz de escribir programas que utilicen el paradigma Orientado a Objetos, los métodos utilizan la regla de que los que tienen nombre que se inician con mayúsculas van a ser públicos o privados en caso contrario.
302302

303303
## Enlaces
304304

305-
- [Indice](preface.md)
305+
- [Índice](preface.md)
306306
- Sección anterior: [struct](02.4.md)
307307
- Siguiente sección: [interfaces](02.6.md)

‎es/02.6.md

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -187,7 +187,7 @@ Si una función usa una interfaz vacía como su tipo de argumento, esta puede ac
187187

188188
Cualquier variable puede usarse en una interfaz, entonces podemos pensar sobre como podemos usar esta característica para pasar cualquier tipo de variable a una función.
189189

190-
Por ejemplo, usamos mucho fmt.Println, pero alguna vez notaste que este acepta cualquier tipo de argumento? Si vemos el código fuente de fmt que es libre, podemos ver la siguiente definición.
190+
Por ejemplo, usamos mucho fmt.Println, pero alguna vez notaste que ¿acepta cualquier tipo de argumento? Si vemos el código fuente de fmt que es libre, podemos ver la siguiente definición.
191191
```
192192
type Stringer interface {
193193
String() string
@@ -224,13 +224,13 @@ Volviendo atrás al ejemplo de Box, podemos ver que Color también implementa la
224224
fmt.Println("The biggest one is", boxes.BiggestsColor().String())
225225
fmt.Println("The biggest one is", boxes.BiggestsColor())
226226
```
227-
Atención: Si el tipo implementa la interfaz `error`, fmt va a llamar a `error()`, entonces en este punto usted no tendrá que implementar Stringer.
227+
Atención: Si el tipo implementa la interfaz `error`, fmt va a llamar a `error()`, entonces en este punto no tendrás que implementar Stringer.
228228
229229
### Tipos de variables en un interfaz
230230
231-
Si una variable es del tipo que implementa una interfaz, sabemos que cualquier otro tipo que implemente la misma interfaz puede ser asignada a esta variable. La pregunta es ¿Como podemos saber cual es el tipo específico almacenado en la interfaz? Tenemos dos formas, que le voy a comentar a continuación.
231+
Si una variable es del tipo que implementa una interfaz, sabemos que cualquier otro tipo que implemente la misma interfaz puede ser asignada a esta variable. La pregunta es ¿Cómo podemos saber cual es el tipo específico almacenado en la interfaz? Tenemos dos formas, que te voy a comentar a continuación.
232232
233-
- Patrón de afirmación Comma-ok
233+
- Patron de Aserción Comma-ok
234234
235235
Go tiene la sintaxis `value, ok := element.(T)`. Esto comprueba si la variable es del tipo que se espero, donde value es el valor de la variable, y ok es un valor de tipo booleano, element es la variable interfaz y T es el tipo que se afirma tener.
236236
@@ -326,7 +326,7 @@ Una cosa que deberíamos recordar es que `element.(type)` no puede ser usado fue
326326
327327
### Interfaces embebidas
328328
329-
La como más atractiva es que Go tiene mucha sintaxis para la lógica embebida, como campos anónimos en un struct. No es para sorprenderse, que podamos usar interfaces también como campos anónimos, pero vamos a llamarlas `Interfaces embebidas`. Aquí, vamos a seguir las mismas reglas que para los campos anónimos. Más específicamente, si una interfaz tiene otra interfaz como una interfaz embebida, esta tendrá todos los métodos que la clase embebida tiene.
329+
La cosa más atractiva es que Go tiene mucha lógica embebida en su sintaxis, como campos anónimos en un struct. No es para sorprenderse, que podamos usar interfaces también como campos anónimos, pero vamos a llamarlas `Interfaces embebidas`. Aquí, vamos a seguir las mismas reglas que para los campos anónimos. Más específicamente, si una interfaz tiene otra interfaz como una interfaz embebida, esta tendrá todos los métodos que la clase embebida tiene.
330330
331331
Podemos ver el archivo fuente `container/heap` que tiene una definición como la siguiente.
332332
```
@@ -335,9 +335,9 @@ Podemos ver el archivo fuente `container/heap` que tiene una definición como la
335335
Push(x interface{}) //el método Push para empujar elementos a la pila
336336
Pop() interface{} //el elemento Pop que saca elementos de la pila
337337
}
338-
338+
```
339339
Podemos ver que `sort.Interface` es una interfaz embebida, por lo que la interfaz anterior tiene tres métodos que son explícitos de `sort.Interface`.
340-
340+
```
341341
type Interface interface {
342342
// Len es el número de elementos en la colección.
343343
Len() int
@@ -347,9 +347,9 @@ Podemos ver que `sort.Interface` es una interfaz embebida, por lo que la interfa
347347
// Swap intercambia los elementos con índices i y j.
348348
Swap(i, j int)
349349
}
350-
350+
```
351351
Otro ejemplo es el de `io.ReadWriter` en el paquete `io`.
352-
352+
```
353353
// io.ReadWriter
354354
type ReadWriter interface {
355355
Reader
@@ -373,7 +373,7 @@ Después de eso, necesitamos convertir el tipo reflect de el valor que tomamos a
373373
fmt.Println("kind is float64:", v.Kind() == reflect.Float64)
374374
fmt.Println("value:", v.Float())
375375
```
376-
Finalmente, si buscamos cambiar el valor que vino del tipo reflects,necesitamos hacerlo modificable. Como hablamos antes, esta es una diferencia entre pasar por valor o por referencia. El siguiente código no compilará.
376+
Finalmente, si buscamos cambiar el valor que vino del tipo reflects, necesitamos hacerlo modificable. Como hablamos antes, esta es una diferencia entre pasar por valor o por referencia. El siguiente código no compilará.
377377
```
378378
var x float64 = 3.4
379379
v := reflect.ValueOf(x)
@@ -386,10 +386,10 @@ En lugar de eso, debemos usar el siguiente código para cambiar el valor de los
386386
v := p.Elem()
387387
v.SetFloat(7.1)
388388
```
389-
Acabo de hablar sobre los conocimientos básicos de sobre el uso de reflexión (reflection), debería practicar más para entenderlo mejor.
389+
Acabamos de hablar sobre los conocimientos básicos de sobre el uso de reflexión (reflection), deberías practicar más para entenderlo mejor.
390390
391391
## Enlaces
392392
393-
- [Indice](preface.md)
393+
- [Índice](preface.md)
394394
- Sección anterior: [Orientado a objetos](02.5.md)
395395
- Siguiente sección: [Concurrencia](02.7.md)

‎es/02.7.md

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ El manejador de tareas solo usa un hilo para correr todas la goroutines, lo que
5151

5252
## Canales
5353

54-
goroutines son ejecutadas en el mismo espacio de direcciones de memoria, por lo que se tiene que mantener sincronizadas si buscas acceder a la memoria compartida. ¿Como nos comunicamos entre diferentes goroutines? Go utiliza un muy buen mecanismo de comunicación llamado `canales`(channel). Los `canales` son como dos tuberías (o pipes) en la shell de Unix: usando canales para enviar o recibir los datos. El unico tipo de datos que se puede usar en los canales es el tipo `channel` y la palabra reservada para eso es `chan`. Tenga en cuenta que para crear un nuevo `channel` debemos usar la palabra reservada `make`.
54+
goroutines son ejecutadas en el mismo espacio de direcciones de memoria, por lo que se tiene que mantener sincronizadas si buscas acceder a la memoria compartida. ¿Cómo nos comunicamos entre diferentes goroutines? Go utiliza un muy buen mecanismo de comunicación llamado `canales`(channel). Los `canales` son como dos tuberías (o pipes) en la shell de Unix: usando canales para enviar o recibir los datos. El unico tipo de datos que se puede usar en los canales es el tipo `channel` y la palabra reservada para eso es `chan`. Ten en cuenta que para crear un nuevo `channel` debemos usar la palabra reservada `make`.
5555
```
5656
ci := make(chan int)
5757
cs := make(chan string)
@@ -91,7 +91,7 @@ Enviando y recibimos los datos por defecto en bloques, por lo que es mucho mas f
9191

9292
## Buffered channels
9393

94-
Anteriormente hice una introducción sobre canales non-buffered channels (non-buffered channels), y Go también tiene 'buffered channels' que pueden guardar mas de un elemento. Por ejemplo, `ch := make(chan bool, 4)`, aca creamos un canal que puede guardar 4 elementos booleanos. Por lo tanto con este canal, somos capaces de enviar 4 elementos sin el bloqueo, pero la goroutine se bloqueará cuando intente enviar un quito elemento y la goroutine no lo recibirá.
94+
Anteriormente hice una introducción sobre canales non-buffered channels (non-buffered channels), y Go también tiene 'buffered channels' que pueden guardar mas de un elemento. Por ejemplo, `ch := make(chan bool, 4)`, aquí creamos un canal que puede guardar 4 elementos booleanos. Por lo tanto con este canal, somos capaces de enviar 4 elementos sin el bloqueo, pero la goroutine se bloqueará cuando intente enviar un quinto elemento y la goroutine no lo recibirá.
9595
```
9696
ch := make(chan type, n)
9797
@@ -147,7 +147,7 @@ Otra cosa que deber tener que recordar es que los canales son diferentes a los a
147147

148148
## Select
149149

150-
En los ejemplos anteriores, nosotros usamos solo un canal, pero ¿como podemos lidiar con mas de un canal? Go tiene la palabra reservada llamada `select` para escuchar muchos canales.
150+
En los ejemplos anteriores, nosotros usamos solo un canal, pero ¿cómo podemos lidiar con más de un canal? Go tiene la palabra reservada llamada `select` para escuchar muchos canales.
151151

152152
`select` de forma predeterminada es bloqueante, y este continua la ejecución solo cuando un canal tiene datos o recibió datos. Si varios canales están listos para usarse al mismo tiempo, select elegirá cual ejecutar al azar.
153153
```
@@ -179,9 +179,9 @@ En los ejemplos anteriores, nosotros usamos solo un canal, pero ¿como podemos l
179179
}()
180180
fibonacci(c, quit)
181181
}
182-
182+
```
183183
`select` también tiene `default`, al igual que el `switch`. Cuando todos los canales no están listos para ser usados, ejecuta el default (no espera mas por el canal).
184-
184+
```
185185
select {
186186
case i := <-c:
187187
// usa i
@@ -237,6 +237,6 @@ El paquete `runtime` tiene algunas funciones para hacer frente a las goroutines.
237237

238238
## Enlaces
239239

240-
- [Indice](preface.md)
240+
- [Índice](preface.md)
241241
- Sección anterior: [interfaces](02.6.md)
242242
- Siguiente sección: [Resumen](02.8.md)

‎es/02.8.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,6 @@ Si entendes como usar estas 25 palabras reservadas, usted ya a aprendido mucho s
2727

2828
## Enlaces
2929

30-
- [Indices](preface.md)
30+
- [Índice](preface.md)
3131
- Sección anterior: [Concurrencia](02.7.md)
3232
- Siguiente sección: [Conocimientos básicos sobre la Web](03.0.md)

0 commit comments

Comments
 (0)
Please sign in to comment.