iskm/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-23 17:41:41 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #508 from holocronweaver/master

Browse Source 
[go/en][go/es] Fix several problems with Go tutorials
This commit is contained in:
Nami-Doc 2014-01-31 00:16:41 -08:00
commit bbce7c6d37
2 changed files with 184 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

191
es-es/go-es.html.markdown
View File

@ -7,16 +7,20 @@ contributors:
- ["Sonia Keys", "https://github.com/soniakeys"]
translators:
- ["Adrian Espinosa", "http://www.adrianespinosa.com"]
- ["Jesse Johnson, "https://github.com/holocronweaver"]
lang: es-es
---
Go fue creado por la necesidad de hacer el trabajo rápidamente. No es la última
tendencia en informática, pero es la forma nueva y más rápida de resolver problemas reales.
Go fue creado por la necesidad de hacer el trabajo rápidamente. No es
la última tendencia en informática, pero es la forma nueva y más
rápida de resolver problemas reales.
Tiene conceptos familiares de lenguajes imperativos con tipado
estático. Es rápido compilando y rápido al ejecutar, añade una
concurrencia fácil de entender para las CPUs de varios núcleos de hoy
en día, y tiene características que ayudan con la programación a gran
escala.
Tiene conceptos familiares de lenguajes imperativos con tipado estático.
Es rápido compilando y rápido al ejecutar, añade una concurrencia fácil de entender para las CPUs de varios núcleos de hoy en día, y tiene características que ayudan con la programación a gran escala.
Go viene con una librería estándar muy buena y una comunidad entusiasta.
```go
@ -28,15 +32,17 @@ Go viene con una librería estándar muy buena y una comunidad entusiasta.
// Main es un nombre especial que declara un ejecutable en vez de una librería.
package main
// La declaración Import declara los paquetes de librerías referenciados en este archivo.
// La declaración Import declara los paquetes de librerías
// referenciados en este archivo.
import (
"fmt" // Un paquete en la librería estándar de Go
"fmt" // Un paquete en la librería estándar de Go.
"net/http" // Sí, un servidor web!
"strconv" // Conversiones de cadenas
"strconv" // Conversiones de cadenas.
m "math" // Librería matemáticas con alias local m.
)
// Definición de una función. Main es especial. Es el punto de entrada para el ejecutable.
// Te guste o no, Go utiliza llaves.
// Definición de una función. Main es especial. Es el punto de
// entrada para el ejecutable. Te guste o no, Go utiliza llaves.
func main() {
// Println imprime una línea a stdout.
// Cualificalo con el nombre del paquete, fmt.
@ -49,19 +55,19 @@ func main() {
// Las funciones llevan parámetros entre paréntesis.
// Si no hay parámetros, los paréntesis siguen siendo obligatorios.
func beyondHello() {
var x int // Declaración de una variable. Las variables se deben declarar antes de
// utilizarlas.
var x int // Declaración de una variable.
// Las variables se deben declarar antes de utilizarlas.
x = 3 // Asignación de variables.
// Declaración "corta" con := para inferir el tipo, declarar y asignar.
y := 4
sum, prod := learnMultiple(x, y) // función devuelve dos valores
fmt.Println("sum:", sum, "prod:", prod) // simple salida
sum, prod := learnMultiple(x, y) // Función devuelve dos valores.
fmt.Println("sum:", sum, "prod:", prod) // Simple salida.
learnTypes() // < y minutes, learn more!
}
// Las funciones pueden tener parámetros y (múltiples!) valores de retorno.
func learnMultiple(x, y int) (sum, prod int) {
return x + y, x * y // devolver dos valores
return x + y, x * y // Devolver dos valores.
}
// Algunos tipos incorporados y literales.
@ -73,32 +79,33 @@ func learnTypes() {
saltos de línea.` // mismo tipo cadena
// Literal no ASCII. Los fuentes de Go son UTF-8.
g := 'Σ' // tipo rune, un alias de uint32, alberga un punto unicode.
f := 3.14195 // float64, el estándar IEEE-754 de coma flotante 64-bit
c := 3 + 4i // complex128, representado internamente por dos float64
g := 'Σ' // Tipo rune, un alias de uint32, alberga un punto unicode.
f := 3.14195 // float64, el estándar IEEE-754 de coma flotante 64-bit.
c := 3 + 4i // complex128, representado internamente por dos float64.
// Sintaxis Var con inicializadores.
var u uint = 7 // sin signo, pero la implementación depende del tamaño como en int
var u uint = 7 // Sin signo, pero la implementación depende del
// tamaño como en int.
var pi float32 = 22. / 7
// Sintáxis de conversión con una declaración corta.
n := byte('\n') // byte es un alias de uint8
n := byte('\n') // byte es un alias de uint8.
// Los Arrays tienen un tamaño fijo a la hora de compilar.
var a4 [4]int // un array de 4 ints, inicializados a 0
a3 := [...]int{3, 1, 5} // un array de 3 ints, inicializados como se indica
var a4 [4]int // Un array de 4 ints, inicializados a 0.
a3 := [...]int{3, 1, 5} // Un array de 3 ints, inicializados como se indica.
// Los Slices tienen tamaño dinámico. Los arrays y slices tienen sus ventajas
// y desventajas pero los casos de uso para los slices son más comunes.
s3 := []int{4, 5, 9} // Comparar con a3. No hay puntos suspensivos
s4 := make([]int, 4) // Asigna slices de 4 ints, inicializados a 0
var d2 [][]float64 // solo declaración, sin asignación
bs := []byte("a slice") // sintaxis de conversión de tipo
s3 := []int{4, 5, 9} // Comparar con a3. No hay puntos suspensivos.
s4 := make([]int, 4) // Asigna slices de 4 ints, inicializados a 0.
var d2 [][]float64 // Solo declaración, sin asignación.
bs := []byte("a slice") // Sintaxis de conversión de tipo.
p, q := learnMemory() // declara p, q para ser un tipo puntero a int.
p, q := learnMemory() // Declara p, q para ser un tipo puntero a int.
fmt.Println(*p, *q) // * sigue un puntero. Esto imprime dos ints.
// Los Maps son arrays asociativos dinámicos, como los hash o diccionarios
// de otros lenguajes
// Los Maps son arrays asociativos dinámicos, como los hash o
// diccionarios de otros lenguajes.
m := map[string]int{"three": 3, "four": 4}
m["one"] = 1
@ -108,23 +115,24 @@ saltos de línea.` // mismo tipo cadena
// Esto cuenta como utilización de variables.
fmt.Println(s, c, a4, s3, d2, m)
learnFlowControl() // vuelta al flujo
learnFlowControl() // Vuelta al flujo.
}
// Go posee recolector de basura. Tiene puntero pero no aritmética de punteros.
// Puedes cometer un errores con un puntero nil, pero no incrementando un puntero.
// Go posee recolector de basura. Tiene puntero pero no aritmética de
// punteros. Puedes cometer un errores con un puntero nil, pero no
// incrementando un puntero.
func learnMemory() (p, q *int) {
// q y p tienen un tipo puntero a int.
p = new(int) // función incorporada que asigna memoria.
p = new(int) // Función incorporada que asigna memoria.
// La asignación de int se inicializa a 0, p ya no es nil.
s := make([]int, 20) // asigna 20 ints a un solo bloque de memoria.
s[3] = 7 // asignar uno de ellos
r := -2 // declarar otra variable local
s := make([]int, 20) // Asigna 20 ints a un solo bloque de memoria.
s[3] = 7 // Asignar uno de ellos.
r := -2 // Declarar otra variable local.
return &s[3], &r // & toma la dirección de un objeto.
}
func expensiveComputation() int {
return 1e6
func expensiveComputation() float64 {
return m.Exp(10)
}
func learnFlowControl() {
@ -134,29 +142,31 @@ func learnFlowControl() {
}
// El formato está estandarizado por el comando "go fmt."
if false {
// pout
// Pout.
} else {
// gloat
// Gloat.
}
// Utiliza switch preferiblemente para if encadenados.
x := 1
x := 42.0
switch x {
case 0:
case 1:
// los cases no se mezclan, no requieren de "break"
case 2:
// no llega
case 42:
// Los cases no se mezclan, no requieren de "break".
case 43:
// No llega.
}
// Como if, for no utiliza paréntesis tampoco.
for x := 0; x < 3; x++ { // ++ es una sentencia
// Variables declaradas en for y if son locales de su ámbito local.
for x := 0; x < 3; x++ { // ++ es una sentencia.
fmt.Println("iteration", x)
}
// x == 1 aqui.
// x == 42 aqui.
// For es la única sentencia de bucle en Go, pero tiene formas alternativas.
for { // bucle infinito
break // solo bromeaba!
continue // no llega
for { // Bucle infinito.
break // Solo bromeaba!
continue // No llega.
}
// Como en for, := en una sentencia if significa declarar y asignar primero,
// luego comprobar y > x.
@ -165,11 +175,11 @@ func learnFlowControl() {
}
// Los literales de funciones son "closures".
xBig := func() bool {
return x > 100 // referencia a x declarada encima de la sentencia switch.
return x > 100 // Referencia a x declarada encima de la sentencia switch.
}
fmt.Println("xBig:", xBig()) // verdadero (la última vez asignamos 1e6 a x)
x /= 1e5 // esto lo hace == 10
fmt.Println("xBig:", xBig()) // ahora es falso
fmt.Println("xBig:", xBig()) // verdadero (la última vez asignamos 1e6 a x).
x /= m.Exp(9) // Esto lo hace x == e.
fmt.Println("xBig:", xBig()) // Ahora es falso.
// Cuando lo necesites, te encantará.
goto love
@ -199,16 +209,29 @@ func learnInterfaces() {
// La sintaxis de llaves es un "literal struct". Evalúa a un struct
// inicializado. La sintaxis := declara e inicializa p a este struct.
p := pair{3, 4}
fmt.Println(p.String()) // llamar al método String de p, de tipo pair.
var i Stringer // declarar i como interfaz tipo Stringer.
i = p // válido porque pair implementa Stringer
// Llamar al metodo String de i, de tipo Stringer. Misma salida que arriba
fmt.Println(p.String()) // Llamar al método String de p, de tipo pair.
var i Stringer // Declarar i como interfaz tipo Stringer.
i = p // Válido porque pair implementa Stringer.
// Llamar al metodo String de i, de tipo Stringer. Misma salida que arriba.
fmt.Println(i.String())
// Las funciones en el paquete fmt llaman al método String para preguntar a un objeto
// por una versión imprimible de si mismo
fmt.Println(p) // salida igual que arriba. Println llama al método String.
fmt.Println(i) // salida igual que arriba.
// Las funciones en el paquete fmt llaman al método String para
// preguntar a un objeto por una versión imprimible de si mismo.
fmt.Println(p) // Salida igual que arriba. Println llama al método String.
fmt.Println(i) // Salida igual que arriba.
learnVariadicParams("great", "learning", "here!")
}
// Las funciones pueden tener número variable de argumentos.
func learnVariadicParams(myStrings ...interface{}) {
// Iterar cada valor de la variadic.
for _, param := range myStrings {
fmt.Println("param:", param)
}
// Pasar valor variadic como parámetro variadic.
fmt.Println("params:", fmt.Sprintln(myStrings...))
learnErrorHandling()
}
@ -223,7 +246,7 @@ func learnErrorHandling() {
}
// Un valor de error comunica más información sobre el problema aparte de "ok".
if _, err := strconv.Atoi("non-int"); err != nil { // _ descarta el valor
// imprime "strconv.ParseInt: parsing "non-int": invalid syntax"
// Imprime "strconv.ParseInt: parsing "non-int": invalid syntax".
fmt.Println(err)
}
// Revisarmeos las interfaces más tarde. Mientras tanto,
@ -248,25 +271,28 @@ func learnConcurrency() {
go inc(-805, c)
// Leer los tres resultados del channel e imprimirlos.
// No se puede saber en que orden llegarán los resultados!
fmt.Println(<-c, <-c, <-c) // channel a la derecha, <- es el operador "recibir".
fmt.Println(<-c, <-c, <-c) // Channel a la derecha, <- es el operador "recibir".
cs := make(chan string) // otro channel, este gestiona cadenas.
cc := make(chan chan string) // un channel de cadenas de channels.
go func() { c <- 84 }() // iniciar una nueva goroutine solo para enviar un valor.
go func() { cs <- "wordy" }() // otra vez, para cs en esta ocasión
// Select tiene una sintáxis parecida a la sentencia switch pero cada caso involucra
// una operacion de channels. Selecciona un caso de forma aleatoria de los casos
// que están listos para comunicarse.
cs := make(chan string) // Otro channel, este gestiona cadenas.
ccs := make(chan chan string) // Un channel de cadenas de channels.
go func() { c <- 84 }() // Iniciar una nueva goroutine solo para
// enviar un valor.
go func() { cs <- "wordy" }() // Otra vez, para cs en esta ocasión.
// Select tiene una sintáxis parecida a la sentencia switch pero
// cada caso involucra una operacion de channels. Selecciona un caso
// de forma aleatoria de los casos que están listos para comunicarse.
select {
case i := <-c: // el valor recibido puede ser asignado a una variable
case i := <-c: // El valor recibido puede ser asignado a una variable,
fmt.Printf("it's a %T", i)
case <-cs: // o el valor puede ser descartado
case <-cs: // o el valor puede ser descartado.
fmt.Println("it's a string")
case <-cc: // channel vacío, no está listo para la comunicación.
case <-ccs: // Channel vacío, no está listo para la comunicación.
fmt.Println("didn't happen.")
}
// En este punto un valor fue devuelvto de c o cs. Uno de las dos
// goroutines que se iniciaron se ha completado, la otrá permancerá bloqueada.
// goroutines que se iniciaron se ha completado, la otrá permancerá
// bloqueada.
learnWebProgramming() // Go lo hace. Tu también quieres hacerlo.
}
@ -281,7 +307,7 @@ func learnWebProgramming() {
// Haz pair un http.Handler implementando su único método, ServeHTTP.
func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// Servir datos con un método de http.ResponseWriter
// Servir datos con un método de http.ResponseWriter.
w.Write([]byte("You learned Go in Y minutes!"))
}
```
@ -291,11 +317,12 @@ func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
La raíz de todas las cosas de Go es la [web oficial de Go](http://golang.org/).
Ahí puedes seguir el tutorial, jugar interactivamente y leer mucho.
La propia definición del lenguaje también está altamente recomendada. Es fácil de leer
e increíblemente corta (como otras definiciones de lenguajes hoy en día)
La propia definición del lenguaje también está altamente
recomendada. Es fácil de leer e increíblemente corta (como otras
definiciones de lenguajes hoy en día)
En la lista de lectura de estudiantes de Go está el código fuente de la
librería estándar. Muy bien documentada, demuestra lo mejor de Go leíble, comprendible,
estilo Go y formas Go. Pincha en el nombre de una función en la documentación
y te aparecerá el código fuente!
En la lista de lectura de estudiantes de Go está el código fuente de
la librería estándar. Muy bien documentada, demuestra lo mejor de Go
leíble, comprendible, estilo Go y formas Go. Pincha en el nombre de
una función en la documentación y te aparecerá el código fuente!

146
go.html.markdown
View File

@ -6,6 +6,7 @@ filename: learngo.go
contributors:
- ["Sonia Keys", "https://github.com/soniakeys"]
- ["Christopher Bess", "https://github.com/cbess"]
- ["Jesse Johnson", "https://github.com/holocronweaver"]
---
Go was created out of the need to get work done. It's not the latest trend
@ -30,9 +31,10 @@ package main
// Import declaration declares library packages referenced in this file.
import (
"fmt" // A package in the Go standard library
"fmt" // A package in the Go standard library.
"net/http" // Yes, a web server!
"strconv" // String conversions
"strconv" // String conversions.
m "math" // Math library with local alias m.
)
// A function definition. Main is special. It is the entry point for the
@ -53,49 +55,49 @@ func beyondHello() {
x = 3 // Variable assignment.
// "Short" declarations use := to infer the type, declare, and assign.
y := 4
sum, prod := learnMultiple(x, y) // function returns two values
fmt.Println("sum:", sum, "prod:", prod) // simple output
sum, prod := learnMultiple(x, y) // Function returns two values.
fmt.Println("sum:", sum, "prod:", prod) // Simple output.
learnTypes() // < y minutes, learn more!
}
// Functions can have parameters and (multiple!) return values.
func learnMultiple(x, y int) (sum, prod int) {
return x + y, x * y // return two values
return x + y, x * y // Return two values.
}
// Some built-in types and literals.
func learnTypes() {
// Short declaration usually gives you what you want.
s := "Learn Go!" // string type
s := "Learn Go!" // string type.
s2 := `A "raw" string literal
can include line breaks.` // same string type
can include line breaks.` // Same string type.
// non-ASCII literal. Go source is UTF-8.
g := 'Σ' // rune type, an alias for uint32, holds a unicode code point
// Non-ASCII literal. Go source is UTF-8.
g := 'Σ' // rune type, an alias for uint32, holds a unicode code point.
f := 3.14195 // float64, an IEEE-754 64-bit floating point number
c := 3 + 4i // complex128, represented internally with two float64s
f := 3.14195 // float64, an IEEE-754 64-bit floating point number.
c := 3 + 4i // complex128, represented internally with two float64's.
// Var syntax with an initializers.
var u uint = 7 // unsigned, but implementation dependent size as with int
var u uint = 7 // Unsigned, but implementation dependent size as with int.
var pi float32 = 22. / 7
// Conversion syntax with a short declaration.
n := byte('\n') // byte is an alias for uint8
n := byte('\n') // byte is an alias for uint8.
// Arrays have size fixed at compile time.
var a4 [4]int // an array of 4 ints, initialized to all 0
a3 := [...]int{3, 1, 5} // an array of 3 ints, initialized as shown
var a4 [4]int // An array of 4 ints, initialized to all 0.
a3 := [...]int{3, 1, 5} // An array of 3 ints, initialized as shown.
// Slices have dynamic size. Arrays and slices each have advantages
// but use cases for slices are much more common.
s3 := []int{4, 5, 9} // compare to a3. no ellipsis here
s4 := make([]int, 4) // allocates slice of 4 ints, initialized to all 0
var d2 [][]float64 // declaration only, nothing allocated here
bs := []byte("a slice") // type conversion syntax
s3 := []int{4, 5, 9} // Compare to a3. No ellipsis here.
s4 := make([]int, 4) // Allocates slice of 4 ints, initialized to all 0.
var d2 [][]float64 // Declaration only, nothing allocated here.
bs := []byte("a slice") // Type conversion syntax.
p, q := learnMemory() // declares p, q to be type pointer to int.
p, q := learnMemory() // Declares p, q to be type pointer to int.
fmt.Println(*p, *q) // * follows a pointer. This prints two ints.
// Maps are a dynamically growable associative array type, like the
@ -109,23 +111,23 @@ can include line breaks.` // same string type
// Output of course counts as using a variable.
fmt.Println(s, c, a4, s3, d2, m)
learnFlowControl() // back in the flow
learnFlowControl() // Back in the flow.
}
// Go is fully garbage collected. It has pointers but no pointer arithmetic.
// You can make a mistake with a nil pointer, but not by incrementing a pointer.
func learnMemory() (p, q *int) {
// Named return values p and q have type pointer to int.
p = new(int) // built-in function new allocates memory.
p = new(int) // Built-in function new allocates memory.
// The allocated int is initialized to 0, p is no longer nil.
s := make([]int, 20) // allocate 20 ints as a single block of memory
s[3] = 7 // assign one of them
r := -2 // declare another local variable
s := make([]int, 20) // Allocate 20 ints as a single block of memory.
s[3] = 7 // Assign one of them.
r := -2 // Declare another local variable.
return &s[3], &r // & takes the address of an object.
}
func expensiveComputation() int {
return 1e6
func expensiveComputation() float64 {
return m.Exp(10)
}
func learnFlowControl() {
@ -135,29 +137,31 @@ func learnFlowControl() {
}
// Formatting is standardized by the command line command "go fmt."
if false {
// pout
// Pout.
} else {
// gloat
// Gloat.
}
// Use switch in preference to chained if statements.
x := 1
x := 42.0
switch x {
case 0:
case 1:
// cases don't "fall through"
case 2:
// unreached
case 42:
// Cases don't "fall through".
case 43:
// Unreached.
}
// Like if, for doesn't use parens either.
for x := 0; x < 3; x++ { // ++ is a statement
// Variables declared in for and if are local to their scope.
for x := 0; x < 3; x++ { // ++ is a statement.
fmt.Println("iteration", x)
}
// x == 1 here.
// x == 42 here.
// For is the only loop statement in Go, but it has alternate forms.
for { // infinite loop
break // just kidding
continue // unreached
for { // Infinite loop.
break // Just kidding.
continue // Unreached.
}
// As with for, := in an if statement means to declare and assign y first,
// then test y > x.
@ -166,30 +170,17 @@ func learnFlowControl() {
}
// Function literals are closures.
xBig := func() bool {
return x > 100 // references x declared above switch statement.
return x > 100 // References x declared above switch statement.
}
fmt.Println("xBig:", xBig()) // true (we last assigned 1e6 to x)
x /= 1e5 // this makes it == 10
fmt.Println("xBig:", xBig()) // false now
fmt.Println("xBig:", xBig()) // true (we last assigned 1e6 to x).
x /= m.Exp(9) // This makes x == e.
fmt.Println("xBig:", xBig()) // false now.
// When you need it, you'll love it.
goto love
love:
// Good stuff coming up!
learnVariadicParams("great", "learning", "here!")
learnInterfaces()
}
// Functions can have variadic parameters
func learnVariadicParams(myStrings ...string) {
// iterate each value of the variadic
for _, param := range myStrings {
fmt.Println("param:", param)
}
// pass variadic value as a variadic parameter
fmt.Println("params:", fmt.Sprintln(myStrings...))
learnInterfaces() // Good stuff coming up!
}
// Define Stringer as an interface type with one method, String.
@ -213,16 +204,29 @@ func learnInterfaces() {
// Brace syntax is a "struct literal." It evaluates to an initialized
// struct. The := syntax declares and initializes p to this struct.
p := pair{3, 4}
fmt.Println(p.String()) // call String method of p, of type pair.
var i Stringer // declare i of interface type Stringer.
i = p // valid because pair implements Stringer
fmt.Println(p.String()) // Call String method of p, of type pair.
var i Stringer // Declare i of interface type Stringer.
i = p // Valid because pair implements Stringer
// Call String method of i, of type Stringer. Output same as above.
fmt.Println(i.String())
// Functions in the fmt package call the String method to ask an object
// for a printable representation of itself.
fmt.Println(p) // output same as above. Println calls String method.
fmt.Println(i) // output same as above
fmt.Println(p) // Output same as above. Println calls String method.
fmt.Println(i) // Output same as above.
learnVariadicParams("great", "learning", "here!")
}
// Functions can have variadic parameters.
func learnVariadicParams(myStrings ...interface{}) {
// Iterate each value of the variadic.
for _, param := range myStrings {
fmt.Println("param:", param)
}
// Pass variadic value as a variadic parameter.
fmt.Println("params:", fmt.Sprintln(myStrings...))
learnErrorHandling()
}
@ -237,7 +241,7 @@ func learnErrorHandling() {
}
// An error value communicates not just "ok" but more about the problem.
if _, err := strconv.Atoi("non-int"); err != nil { // _ discards value
// prints "strconv.ParseInt: parsing "non-int": invalid syntax"
// prints 'strconv.ParseInt: parsing "non-int": invalid syntax'
fmt.Println(err)
}
// We'll revisit interfaces a little later. Meanwhile,
@ -264,19 +268,19 @@ func learnConcurrency() {
// There is no telling in what order the results will arrive!
fmt.Println(<-c, <-c, <-c) // channel on right, <- is "receive" operator.
cs := make(chan string) // another channel, this one handles strings.
cc := make(chan chan string) // a channel of string channels.
go func() { c <- 84 }() // start a new goroutine just to send a value
go func() { cs <- "wordy" }() // again, for cs this time
cs := make(chan string) // Another channel, this one handles strings.
ccs := make(chan chan string) // A channel of string channels.
go func() { c <- 84 }() // Start a new goroutine just to send a value.
go func() { cs <- "wordy" }() // Again, for cs this time.
// Select has syntax like a switch statement but each case involves
// a channel operation. It selects a case at random out of the cases
// that are ready to communicate.
select {
case i := <-c: // the value received can be assigned to a variable
case i := <-c: // The value received can be assigned to a variable,
fmt.Printf("it's a %T", i)
case <-cs: // or the value received can be discarded
case <-cs: // or the value received can be discarded.
fmt.Println("it's a string")
case <-cc: // empty channel, not ready for communication.
case <-ccs: // Empty channel, not ready for communication.
fmt.Println("didn't happen.")
}
// At this point a value was taken from either c or cs. One of the two
@ -287,7 +291,7 @@ func learnConcurrency() {
// A single function from package http starts a web server.
func learnWebProgramming() {
// ListenAndServe first parameter is TCP address to listen at.
// First parameter of ListenAndServe is TCP address to listen to.
// Second parameter is an interface, specifically http.Handler.
err := http.ListenAndServe(":8080", pair{})
fmt.Println(err) // don't ignore errors
@ -295,7 +299,7 @@ func learnWebProgramming() {
// Make pair an http.Handler by implementing its only method, ServeHTTP.
func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// Serve data with a method of http.ResponseWriter
// Serve data with a method of http.ResponseWriter.
w.Write([]byte("You learned Go in Y minutes!"))
}
```