translated chapter 4 sections 0 and 1 from scratch
This commit is contained in:
ma0
23
es/04.0.md
Normal file
23
es/04.0.md
Normal file
@@ -0,0 +1,23 @@
|
||||
# 4 Formularios de Usuarios
|
||||
|
||||
Un formulario de usuario es algo que es usado comunmente cuando desarrollamos aplicaciones web. El provee la habilidad de comunicarse entre clientes y servidores. Debes estar familiarizado con los formularios si eres un desarrollador web; si eres un programador C/C++ te puedes estar preguntando, ¿qué es un formulario de usuario?
|
||||
|
||||
Un formulario es un área que contiene elementos de de formulario. Los usuarios pueden ingresar información en los elementos como en campos de texto, listas desplegables, botones circulares, cajas de chequeo, etc. nOsotros utilizamos la etiqueta `<form>` para definir formularios.
|
||||
```
|
||||
<form>
|
||||
...
|
||||
elementos de entrada
|
||||
...
|
||||
</form>
|
||||
```
|
||||
Go tiene muchas funciones muy convenientes para lidiar con formularios de usuario. Facilmente puedes obtener la información de un formulario en una petición HTTP, y se pueden integrar fácilmente en tus aplicaciones propias. En la sección 4.1, vamos a hablar de como manejar la información de los formularios en Go. También que no puedes confiar en cualquier datao que viene del lado del cliente, primero debes validar los datos antes de usarlos. Vamos a ir a través de algunos ejemplos de como podemos validar la información de los formularios en la sección 4.2.
|
||||
|
||||
Decimos que HTTP es un procolo sin estado. ¿Cómo podemos identificar que varios formularios vienen del mismo usuario? y ¿cómo nos damos cuenta que un formulario solo puede ser enviado una vez? Miraremos algunos detalles concernientes a las cookies (una cookie es un segmento de información que puede ser guardado en el lado del cluente y agregado al encabezado de la petición cuando la petición es enviada al servidor) en los capítulos 4.3 y 4.4.
|
||||
|
||||
Otro caso de uso común para los formularios es subir archivos. En la sección 4.5, aprenderás como hacer esto y también como controlar el tamaño del archivo que vas a subir antes de subirlo, en Go.
|
||||
|
||||
## Links
|
||||
|
||||
- [Índice](preface.md)
|
||||
- Sección anterior: [Resumen](03.5.md)
|
||||
- Siguiente sección: [Procesando la entrada de los formularios](04.1.md)
|
||||
107
es/04.1.md
Normal file
107
es/04.1.md
Normal file
@@ -0,0 +1,107 @@
|
||||
# 4.1 Procesando las entradas de los formularios
|
||||
|
||||
Antes de comenzar, vamos a echarle un vistazo a un formulario típico de usuario, guardado como `login.gtpl` en tu carpeta de proyecto.
|
||||
```
|
||||
<html>
|
||||
<head>
|
||||
<title></title>
|
||||
</head>
|
||||
<body>
|
||||
<form action="/login" method="post">
|
||||
Nombre de Usuario:<input type="text" name="username">
|
||||
Contraseña:<input type="password" name="password">
|
||||
<input type="submit" value="Ingresar">
|
||||
</form>
|
||||
</body>
|
||||
</html>
|
||||
```
|
||||
Este formulario va a ser enviado a `/login` en el servidor. Después que el usuario de click en el botón Ingresar, la información va a ser enviada al manejador `login` registrado en nuestro enrutador. Entonces necesitamos saber qué método se usa, el POST o el GET.
|
||||
|
||||
Es fácil darnos cuenta usando el paquete `http`. Veamos como manejar los formularios en la página de Ingreso.
|
||||
```
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"html/template"
|
||||
"log"
|
||||
"net/http"
|
||||
"strings"
|
||||
)
|
||||
|
||||
func sayhelloName(w http.ResponseWriter, r *http.Request) {
|
||||
r.ParseForm() // Análizar los parámetros URL enviados, entonces analizar el paquete para analizar el cuerpo del paquete, para peticiones POST.
|
||||
// precaución: Si no se llama al método ParseForm, la siguiente unformación no podra ser obtenida del Formulario
|
||||
fmt.Println(r.Form) // Imprime la información del lado del servidor
|
||||
fmt.Println("path", r.URL.Path)
|
||||
fmt.Println("scheme", r.URL.Scheme)
|
||||
fmt.Println(r.Form["url_long"])
|
||||
for k, v := range r.Form {
|
||||
fmt.Println("key:", k)
|
||||
fmt.Println("val:", strings.Join(v, ""))
|
||||
}
|
||||
fmt.Fprintf(w, "Hello astaxie!") // Escrite la respuesta
|
||||
}
|
||||
|
||||
func login(w http.ResponseWriter, r *http.Request) {
|
||||
fmt.Println("method:", r.Method) //get request method
|
||||
if r.Method == "GET" {
|
||||
t, _ := template.ParseFiles("login.gtpl")
|
||||
t.Execute(w, nil)
|
||||
} else {
|
||||
r.ParseForm()
|
||||
// Parte lógica de la función login
|
||||
fmt.Println("username:", r.Form["username"])
|
||||
fmt.Println("password:", r.Form["password"])
|
||||
}
|
||||
}
|
||||
|
||||
func main() {
|
||||
http.HandleFunc("/", sayhelloName) // Definimos la regla del enrutador
|
||||
http.HandleFunc("/login", login)
|
||||
err := http.ListenAndServe(":9090", nil) // Definimos el puerto de escucha
|
||||
if err != nil {
|
||||
log.Fatal("ListenAndServe: ", err)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Aquí usamos el método `r.Methoc` para obtener el tipo de petición, el cual retornará uno de los siguientes verbos: "GET", "POST", "PUT", etc.
|
||||
|
||||
En la función `login`, usamos `r.Method` para verificar si es una petición a la página o una petición para procesar los datos. En otras palabras, verificamos si el usuario solo abró la página o está intentando ingresar. Únicamente mostramos la página cuando viene desde un método GET, y ejecuta la lógica cuando viene un método POST.
|
||||
|
||||
Podrás ver la interfaz cuando visitas `http://127.0.0.1:9090/login` en tu navegador.
|
||||
|
||||
|
||||
|
||||
Figure 4.1 Interfaz de ingreso de usuario
|
||||
|
||||
El servidor no va a imprimir nada hasta que nosotros escribamos un usuario y contraseña, porque el manejador no analizará los datos hasta que llamemos `r.ParseForm()`. Agreguemos `r.ParseForm()` antes de `fmt.Println("username:", r.Form["username"])`, compilemos el programa e intentémolo de nuevo. Ahora puedes ve la información en la consola del servidor.
|
||||
|
||||
`r.Form` contiene todos los argumentos de la petición, por ejemplo la cadena de consulta en la URL y la información en el POST y PUT. Si la información tiene conflictos, como parámetros que tienen el mismo nombre, el servidor almacenará la información en un segmento con múltiples valores. La documentación de Go dice que Go guardará la información de las peticiones GET y el POST en diferentes lugares.
|
||||
|
||||
Trata de cambiar la URL de ingreso de `http://127.0.0.1:9090/login` a `http://127.0.0.1:9090/login?username=astaxie` en el archivo `login.gtpl`, prueba de nuevo, Y podrás ver el segmento en el lado del servidor.
|
||||
|
||||
|
||||
|
||||
Figure 4.2 Server prints request data
|
||||
|
||||
El tipo de `request.Form` es `url.Value`. Y lo guarda en el formato `llave=valor`.
|
||||
```
|
||||
v := url.Values{}
|
||||
v.Set("name", "Ava")
|
||||
v.Add("friend", "Jess")
|
||||
v.Add("friend", "Sarah")
|
||||
v.Add("friend", "Zoe")
|
||||
// v.Encode() == "name=Ava&friend=Jess&friend=Sarah&friend=Zoe"
|
||||
fmt.Println(v.Get("name"))
|
||||
fmt.Println(v.Get("friend"))
|
||||
fmt.Println(v["friend"])
|
||||
```
|
||||
**Recomendaciones** Las peticiones tienen la habilidad de acceder información por medio del método `FormValue()`. Por ejemplo, puedes cambiar de `r.Form["username"]` a `r.FormValue("username")`, y Go llamará `r.ParseForm` automáticamente. Nota que se retornará el primer valor, si existen varias llaves con el mismo nombre y retornará una cadena vacía si no existe el argumento.
|
||||
|
||||
## Links
|
||||
|
||||
- [Indice](preface.md)
|
||||
- Sección anterior: [Formulario de entrada de los usuario](04.0.md)
|
||||
- Siguiente sección: [Verificando las entradas](04.2.md)
|
||||
Reference in New Issue
Block a user