Skip to content

Latest commit

 

History

History
107 lines (88 loc) · 4.78 KB

04.1.md

File metadata and controls

107 lines (88 loc) · 4.78 KB
Raw

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.Method 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 abrió 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émoslo de nuevo. Ahora puedes ver 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.Values. 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