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

finished translation of chapter 7

Browse Source
This commit is contained in:
ma0
2017-01-01 21:18:40 -05:00
parent cefe7e6a65
commit 958aca0a58
3 changed files with 311 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
es/07.5.md Normal file
View File

@@ -0,0 +1,144 @@
# 7.5 Archivos
Los archivos son objetos esenciales en cada computador. No es una sorpresa que las aplicaciones web también hagan un uso de ellos. En esta sección vamos a aprender cómo operar archivos en Go.
## Directorios
En Go, la mayoría de las operaciones de archivos están localizadas en el paquete `os`. Aquí hay algunas de las funciones:
- `func Mkdir(name string, perm FileMode) error`
Crea un directorio `name` y los permisos `perm`, ejemplo: 0777.
- `func MkdirAll(path string, perm FileMode) error`
Crea múltiples directorios de acuerdo al `path`, como `astaxie/test1/test2`.
- `func Remove(name string) error`
Elimina el directorio `name`. Retorna un error si no hay directorio o no está vacío.
- `func RemoveAll(path string) error`
Elimina múltiples directorios de acuerdo al `path`. Los directorios no serán eliminados si `path` es una ruta simple.
Código de ejemplo:
```
package main
import (
"fmt"
"os"
)
func main() {
os.Mkdir("astaxie", 0777)
os.MkdirAll("astaxie/test1/test2", 0777)
err := os.Remove("astaxie")
if err != nil {
fmt.Println(err)
}
os.RemoveAll("astaxie")
}
```
## Archivos
### Crear y abrir archivos
Existen dos funciones para crear archivos:
- `func Create(name string) (file *File, err Error)`
Crea un archivo `name` y retorna un objeto de lectura escritura con los permisos 0666.
- `func NewFile(fd uintptr, name string) *File`
Crea un archivo y retorna un retorna un objeto archivo.
También hay dos funciones para abrir archivos:
- `func Open(name string) (file *File, err Error)`
Abre un archivo `name` con permisos de solo lectura, llamando a `OpenFile` por debajo.
- `func OpenFile(name string, flag int, perm uint32) (file *File, err Error)`
Abre un archivo `name`. `flag` es el modo de abertura, como solo lectura, lectura-escritura, etc. `perm` son los permisos del archivo.
### Escribir archivos
Funciones para escribir archivos:
- `func (file *File) Write(b []byte) (n int, err Error)`
Escribr contenido binario a un archivo.
- `func (file *File) WriteAt(b []byte, off int64) (n int, err Error)`
Escribe un archivo binario en una posición específica del archivo.
- `func (file *File) WriteString(s string) (ret int, err Error)`
Escribe una cadena en un archivo.
Código de ejemplo:
```
package main
import (
"fmt"
"os"
)
func main() {
userFile := "astaxie.txt"
fout, err := os.Create(userFile)
if err != nil {
fmt.Println(userFile, err)
return
}
defer fout.Close()
for i := 0; i < 10; i++ {
fout.WriteString("Just a test!\r\n")
fout.Write([]byte("Just a test!\r\n"))
}
}
```
### Read files
Funciones para leer archivos:
- `func (file *File) Read(b []byte) (n int, err Error)`
Lee la información a `b`
- `func (file *File) ReadAt(b []byte, off int64) (n int, err Error)`
Lee l ainformación de `off` a `b`
Código de ejemplo:
```
package main
import (
"fmt"
"os"
)
func main() {
userFile := "asatxie.txt"
fl, err := os.Open(userFile)
if err != nil {
fmt.Println(userFile, err)
return
}
defer fl.Close()
buf := make([]byte, 1024)
for {
n, _ := fl.Read(buf)
if 0 == n {
break
}
os.Stdout.Write(buf[:n])
}
}
```
### Eliminar archivos
Go usa la misma función para eliminar archivos y directorios:
- `func Remove(name string) Error`
Elimina un archivo o directorio `name` (***si termina en `/` significa que es un directorio***)
## Enlaces
- [Índice](preface.md)
- Sección previa: [Plantillas](07.4.md)
- Siguiente sección: [Cadenas](07.6.md)

158
es/07.6.md Normal file
View File

@@ -0,0 +1,158 @@
# 7.6 Cadenas
En la web, casi todo lo que vemos (incluidos entradas de usuario, accesos a bases de datos, etc), es representado como cadenas. Las cadenas son una parte importante del desarrollo web. En muchos casos también necesitamos separarlas, unirlas, convertirlas o de otra manera, manipular las cadenas. En esta sección vamos a introducir los paquetes `strings` y `strconv` de la librería estándar de Go.
## strings
Las siguientes funciones son del paquete `strings`. Veamos la documentación oficial para mas detalles:
- `func Contains(s, substr string) bool`
Verifica si `s` contiene una subcadena `substr`, retorna un valor booleano.
```
fmt.Println(strings.Contains("seafood", "foo"))
fmt.Println(strings.Contains("seafood", "bar"))
fmt.Println(strings.Contains("seafood", ""))
fmt.Println(strings.Contains("", ""))
//Salida:
//true
//false
//true
//true
```
- `func Join(a []string, sep string) string`
Combina cadenas de un segmento con un separador `sep`.
```
s := []string{"foo", "bar", "baz"}
fmt.Println(strings.Join(s, ", "))
//Salida:
//foo, bar, baz
```
- `func Index(s, sep string) int `
Encuentra el índice de `sep` en la cadena `s`, retorna -1 si no es encontrado.
```
fmt.Println(strings.Index("chicken", "ken"))
fmt.Println(strings.Index("chicken", "dmr"))
//Salida:
//4
//-1
```
- `func Repeat(s string, count int) string`
Repite `s` `count` veces.
```
fmt.Println("ba" + strings.Repeat("na", 2))
//Salida: banana
```
- f`unc Replace(s, old, new string, n int) string`
Reemplaza la cadena `old` con la cadena `new` en `s`. `n` es el número de reemplazos. Si n es menos que 0, se reemplaza en todos los casos.
```
fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))
fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))
//Output:oinky oinky oink
//moo moo moo
```
- `func Split(s, sep string) []string`
Separa una cadena `s` con el separador `sep` en un segmento.
```
fmt.Printf("%q\n", strings.Split("a,b,c", ","))
fmt.Printf("%q\n", strings.Split("a man a plan a canal panama", "a "))
fmt.Printf("%q\n", strings.Split(" xyz ", ""))
fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))
//Output:["a" "b" "c"]
//["" "man " "plan " "canal panama"]
//[" " "x" "y" "z" " "]
//[""]
```
- `func Trim(s string, cutset string) string`
Elimina `cutset` de `s` si está al final o al comienzo.
```
fmt.Printf("[%q]", strings.Trim(" !!! Achtung !!! ", "! "))
Output:["Achtung"]
```
- `func Fields(s string) []string`
Elimina los espacios de una cadena y la separa en un segmento.
```
fmt.Printf("Fields are: %q", strings.Fields(" foo bar baz "))
//Output:Fields are: ["foo" "bar" "baz"]
```
## strconv
Las siguientes funciones son del paquete `strconv`. Como es usual, por favor vea la documentación oficial para mas detalles:
- Concatenar series, convertir información a cadenas y concatenar a un segmento de bytes.
```
package main
import (
"fmt"
"strconv"
)
func main() {
str := make([]byte, 0, 100)
str = strconv.AppendInt(str, 4567, 10)
str = strconv.AppendBool(str, false)
str = strconv.AppendQuote(str, "abcdefg")
str = strconv.AppendQuoteRune(str, '单')
fmt.Println(string(str))
}
```
- Formatear series, convertir tipos de datos a cadenas.
```
package main
import (
"fmt"
"strconv"
)
func main() {
a := strconv.FormatBool(false)
b := strconv.FormatFloat(123.23, 'g', 12, 64)
c := strconv.FormatInt(1234, 10)
d := strconv.FormatUint(12345, 10)
e := strconv.Itoa(1023)
fmt.Println(a, b, c, d, e)
}
```
- Analizar series, convertir cadenas a otros tipos.
```
package main
import (
"fmt"
"strconv"
)
func main() {
a, err := strconv.ParseBool("false")
if err != nil {
fmt.Println(err)
}
b, err := strconv.ParseFloat("123.23", 64)
if err != nil {
fmt.Println(err)
}
c, err := strconv.ParseInt("1234", 10, 64)
if err != nil {
fmt.Println(err)
}
d, err := strconv.ParseUint("12345", 10, 64)
if err != nil {
fmt.Println(err)
}
e, err := strconv.Itoa("1023")
if err != nil {
fmt.Println(err)
}
fmt.Println(a, b, c, d, e)
}
```
## Enlaces
- [Índice](preface.md)
- Sección previa: [Archivos](07.5.md)
- Siguiente sección: [Resumen](07.7.md)

9
es/07.7.md Normal file
View File

@@ -0,0 +1,9 @@
# 7.7 Resumen
En este capítulo, introducimos algunas herraminetas para el procesamiento de texto, como XML, JSON, Expresiones Regulares, y también hablamos de plantillas. XML y JSON son herramientas para transferencia de datos, puedes representar casi cualquier tipo de información usando estos dos formatos. Las expresiones regulares son una herramienta poderosa para buscar, reemplazar y cortar contenido de texto. Con las plantillas, fácilmente puedes combinar información dinámica con archivos estáticos. Estas herramientas son útiles para el desarrollo de aplicaciones web. Espero que ahora tengas una mejor idea de como procesar y mostrar contenido usando Go.
## Enlaces
- [Índice](preface.md)
- Sección previa: [Cadenas](07.6.md)
- Siguiente capítulo: [Servicios web](08.0.md)