Tutorial 22: Leer Datos con PDO Parte 1

 


¡Hola de nuevo! En los tutoriales anteriores aprendimos a crear (registrar) usuarios en nuestra base de datos usando PDO de forma segura. Ahora vamos a aprender a leer esos datos. Es decir, vamos a permitir que un usuario ya registrado pueda ingresar a la aplicación.

Piensa en esto como la puerta de entrada a una zona privada. Solo las personas que ya están registradas (con usuario y contraseña correctos) pueden pasar.

Paso 1: Preparar la Base de Datos

Antes de comenzar, revisemos nuestra base de datos en phpMyAdmin. Tenemos una tabla llamada usuarios con algunos registros. Por ejemplo, algo así:

idusuariopasswordemail
1juan1234juan@hotmail.com
4ana1234ana@hotmail.com

Nota importante: Observa que los IDs pueden no ser consecutivos (1, 4...). Esto puede pasar si borramos algunos registros directamente desde phpMyAdmin. No te preocupes por eso, MySQL continuará asignando el siguiente número disponible (el 5, luego el 6, etc.).

Paso 2: El Formulario de Ingreso (La Vista)

Lo primero que ve el usuario es un formulario para ingresar. Este formulario está en nuestra carpeta de views/modules/ y se llama ingresar.php. Debe verse así:

html
<h1>INGRESAR</h1>

<form method="post">
    <input type="text" placeholder="Usuario" name="usuarioIngreso" required>
    <input type="password" placeholder="Contraseña" name="passwordIngreso" required>
    <input type="submit" value="Enviar">
</form>

Observa los name de los campos:

  • name="usuarioIngreso"

  • name="passwordIngreso"

Estos nombres son muy importantes. ¿Por qué? Porque más adelante, en el controlador, usaremos $_POST["usuarioIngreso"] y $_POST["passwordIngreso"] para capturar lo que el usuario escribió. Si los nombres no coinciden, no podremos recibir los datos.

Y al final del archivo, tenemos el código que llama al controlador:

php
<?php
$ingreso = new MvcController();
$ingreso -> ingresoUsuarioController();
?>

Esto crea un objeto de la clase MvcController y ejecuta la función ingresoUsuarioController().

Paso 3: El Controlador de Ingreso (Recibiendo los Datos)

Ahora vamos a nuestro controlador (controller.php). Vamos a crear una nueva función llamada ingresoUsuarioController().

¡Cuidado! Tenemos un problema: tanto el formulario de registro como el de ingreso tienen campos de texto y contraseña. Si en ambos usamos el mismo name (por ejemplo, "usuario"), el controlador no sabrá si los datos vienen del registro o del ingreso.

La solución: Usar nombres diferentes en los name de los formularios. Por eso en el registro usamos usuarioRegistro y passwordRegistro, y en el ingreso usamos usuarioIngreso y passwordIngreso.

Ahora sí, escribamos la función en el controlador:

php
# INGRESO DE USUARIOS
public function ingresoUsuarioController(){

    // Preguntamos: ¿Ya se envió el formulario de ingreso?
    // Es decir, ¿existe $_POST["usuarioIngreso"]?
    if(isset($_POST["usuarioIngreso"])){

        // Organizamos los datos en un array asociativo
        $datosController = array(
            "usuario"=>$_POST["usuarioIngreso"],
            "password"=>$_POST["passwordIngreso"]
        );

        // Llamamos al modelo para que haga la consulta
        // Le pasamos los datos y el nombre de la tabla
        $respuesta = Datos::ingresoUsuarioModel($datosController, "usuarios");

        // Por ahora, solo mostramos lo que el modelo nos devuelva
        // Más adelante, aquí decidiremos si dejamos entrar al usuario o no
        echo $respuesta;

    }

}

Explicación:

  1. if(isset($_POST["usuarioIngreso"])): Verificamos que el formulario de ingreso haya sido enviado. Si no existe esa variable, significa que el usuario acaba de llegar a la página y no ha escrito nada, por lo que no ejecutamos el resto del código.

  2. $datosController = array(...): Guardamos el usuario y la contraseña en un array para enviarlos juntos al modelo.

  3. $respuesta = Datos::ingresoUsuarioModel(...): Llamamos a una función del modelo (que aún no hemos creado) y le pasamos los datos. Guardamos lo que nos devuelva en $respuesta.

  4. echo $respuesta;: Mostramos la respuesta. Esto es solo para probar que todo funciona. Después lo cambiaremos.

Paso 4: El Modelo de Ingreso (Consultando la Base de Datos)

Ahora vamos al modelo (crud.php). Vamos a crear la función ingresoUsuarioModel().

¿Qué debe hacer esta función? Debe buscar en la tabla usuarios si existe un registro con el usuario y la contraseña que nos enviaron.

La consulta SQL que necesitamos es un SELECT:

sql
SELECT * FROM usuarios WHERE usuario = 'loQueEscribioElUsuario' AND password = 'loQueEscribioElUsuario'

Pero recuerda: nunca vamos a pegar las variables directamente en la consulta SQL. Eso es peligroso. Vamos a usar marcadores de parámetros con PDO.

Escribamos la función:

php
# INGRESO USUARIO
public function ingresoUsuarioModel($datosModel, $tabla){

    // Preparamos la consulta SQL. Usamos marcadores :usuario y :password
    $stmt = Conexion::conectar()->prepare("SELECT * FROM $tabla WHERE usuario = :usuario AND password = :password");

    // Vinculamos los parámetros con los valores reales
    $stmt->bindParam(":usuario", $datosModel["usuario"], PDO::PARAM_STR);
    $stmt->bindParam(":password", $datosModel["password"], PDO::PARAM_STR);

    // Ejecutamos la consulta
    $stmt->execute();

    // Devolvemos el resultado. fetch() trae el primer registro que encuentre.
    // Si encuentra algo, devuelve un array con los datos. Si no, devuelve false.
    return $stmt->fetch();

    // Cerramos la conexión (opcional, PDO lo hace automáticamente al final)
    $stmt->close();

}

Explicación detallada:

  1. $stmt = Conexion::conectar()->prepare(...): Nos conectamos a la BD y preparamos la consulta SELECT. Los marcadores :usuario y :password son los lugares donde irán los datos reales.

  2. $stmt->bindParam(...): Vinculamos cada marcador con el valor correspondiente del array $datosModel.

    • ":usuario" se vincula con $datosModel["usuario"].

    • ":password" se vincula con $datosModel["password"].

  3. $stmt->execute(): Ejecutamos la consulta ya con los valores reemplazados de forma segura.

  4. return $stmt->fetch();: El método fetch() devuelve una fila de resultados como un array. Si el usuario y la contraseña existen en la BD, fetch() devolverá un array con todos sus datos (id, usuario, password, email). Si no existen, devolverá false.

Paso 5: Primera Prueba (Verificar que el Modelo Responde)

Ahora vamos a hacer una prueba rápida.

  1. Asegúrate de tener un usuario registrado. Por ejemplo, el usuario ana con contraseña 1234.

  2. Ve al formulario de ingreso (index.php?action=ingresar).

  3. Escribe:

    • Usuario: ana

    • Contraseña: 1234

  4. Haz clic en "Enviar".

¿Qué debería pasar?
El controlador capturará los datos, llamará al modelo, y el modelo ejecutará la consulta. Como el usuario ana con contraseña 1234 sí existe en la BD, fetch() devolverá un array con sus datos. Luego, el controlador hará un echo de ese array.

El resultado en pantalla será algo como:

text
Array ( [id] => 4 [usuario] => ana [password] => 1234 [email] => ana@hotmail.com )

¡Perfecto! Eso significa que nuestro modelo está encontrando al usuario en la base de datos.

Ahora probemos con un usuario que no exista:

  • Usuario: pedro

  • Contraseña: 1234

Al enviar, la pantalla se quedará en blanco (no muestra nada). ¿Por qué? Porque fetch() devolvió false al no encontrar al usuario, y echo false no muestra nada en pantalla.

Paso 6: Diferenciar los Nombres de los Campos (Resumen)

Para que todo funcione, es fundamental que los nombres (name) en los formularios sean diferentes cuando las funciones en el controlador hacen cosas distintas. Así evitamos confusiones.

Formulario de Registro (registro.php):

  • name="usuarioRegistro"

  • name="passwordRegistro"

  • name="emailRegistro"

Controlador - Función de Registro (controller.php):

  • $_POST["usuarioRegistro"]

  • $_POST["passwordRegistro"]

  • $_POST["emailRegistro"]

Formulario de Ingreso (ingresar.php):

  • name="usuarioIngreso"

  • name="passwordIngreso"

Controlador - Función de Ingreso (controller.php):

  • $_POST["usuarioIngreso"]

  • $_POST["passwordIngreso"]

Resumen de la Parte 1

Hoy hemos dado los primeros pasos para leer datos con PDO:

  1. Creamos un formulario de ingreso con nombres de campo específicos (usuarioIngreso, passwordIngreso).

  2. En el controlador, creamos la función ingresoUsuarioController() que captura esos datos y llama al modelo.

  3. En el modelo, creamos la función ingresoUsuarioModel() que prepara una consulta SELECT con marcadores, vincula los parámetros, ejecuta y devuelve el resultado con fetch().

  4. Probamos y vimos que cuando el usuario existe, fetch() devuelve un array con sus datos; cuando no existe, devuelve false.

En la Parte 2, aprenderemos a usar esa respuesta para decidir si dejamos entrar al usuario o no, y cómo iniciar una sesión para mantenerlo identificado mientras navega por la aplicación.



Leer Datos con PDO Parte 1 (Complemento - Prueba Visual)

¡Hola de nuevo! En el tutorial anterior aprendimos a crear la función de ingreso. Pero hay un paso muy importante que debemos ver con más detalle: la prueba de que realmente estamos recibiendo información del modelo.

Cuando programamos, es fundamental ir probando paso a paso para asegurarnos de que todo funciona antes de continuar. Vamos a hacer eso ahora.

Paso 5 (reforzado): La Prueba con echo $respuesta;

Observa esta imagen. Es el código de nuestro controlador después de agregar echo $respuesta;:

text
C:\xampp\htdocs\cursoPHP\04.PDOySQL\editado\controllers\controller.php

#INGRESO DE USUARIOS
public function ingresoUsuarioController(){
    if(isset($_POST["usuarioIngreso"])){
        
        $datosController = array(
            "usuario"=>$_POST["usuarioIngreso"],
            "password"=>$_POST["passwordIngreso"]
        );
        
        $respuesta = Datos::ingresoUsuarioModel($datosController, "usuarios");
        
        // ⚠️ PRUEBA: Mostramos lo que devuelve el modelo
        echo $respuesta;
    }
}

¿Qué estamos haciendo?
Le estamos diciendo a PHP: "Lo que sea que me devuelva el modelo (éxito, error, datos, etc.), muéstralo en la pantalla". Esto es temporal, solo para verificar que la comunicación entre el controlador y el modelo funciona correctamente.

Paso 6: Probamos con un Usuario que SÍ Existe

Ahora, según la imagen del formulario de ingreso, vamos a hacer una prueba:

text
<h1>INGRESAR</h1>

<form method="post">
    <input type="text" placeholder="Usuario" name="usuarioIngreso" required>
    <input type="password" placeholder="Contraseña" name="passwordIngreso" required>
    <input type="submit" value="Enviar">
</form>

Escenario 1: Usuario correcto

  1. Abrimos nuestro navegador y vamos a la página de ingreso:
    http://localhost/cursoPHP/04.PDOySQL/editado/index.php?action=ingresar

  2. Escribimos:

    • Usuario: ana (un usuario que ya tenemos registrado)

    • Contraseña: 1234

  3. Hacemos clic en "Enviar".

¿Qué debería pasar?

El controlador recibe los datos, llama al modelo, el modelo busca en la base de datos y encuentra al usuario. Como usamos return $stmt->fetch(); en el modelo, lo que se devuelve es un array asociativo con los datos del usuario.

Al hacer echo $respuesta;, PHP intenta mostrar ese array. El resultado en pantalla será algo como:

text
Array

O quizás veas un error como "Array to string conversion". ¿Por qué? Porque echo no sabe cómo mostrar un array completo. Pero aunque veas un error o solo la palabra "Array", ¡eso es una buena señal! Significa que el modelo SÍ encontró algo y nos devolvió un array.

Para ver el contenido real del array, podemos cambiar temporalmente echo por var_dump():

php
var_dump($respuesta);

Esto nos mostraría algo como:

text
array(4) { 
    ["id"]=> string(1) "4" 
    ["usuario"]=> string(3) "ana" 
    ["password"]=> string(4) "1234" 
    ["email"]=> string(14) "ana@hotmail.com" 
}

¡Excelente! Eso significa que nuestro modelo encontró al usuario ana en la base de datos.

Paso 7: Probamos con un Usuario que NO Existe

Escenario 2: Usuario incorrecto

  1. Volvemos al formulario de ingreso.

  2. Escribimos:

    • Usuario: pedro (un usuario que NO existe)

    • Contraseña: cualquiercosa

  3. Hacemos clic en "Enviar".

¿Qué debería pasar?

El modelo ejecuta la consulta SELECT, no encuentra ningún registro que coincida, y fetch() devuelve false.

Al hacer echo $respuesta;, PHP mostrará... nada. La pantalla se quedará en blanco. ¿Por qué? Porque echo false no produce ninguna salida visible.

Si cambiamos a var_dump($respuesta);, veremos:

text
bool(false)

Esto confirma que el modelo no encontró al usuario.

Paso 8: ¿Por qué es importante esta prueba?

Esta prueba con echo (o mejor con var_dump) nos permite verificar que:

  1. El controlador está recibiendo los datos del formulario (si no, no entraría al if).

  2. El modelo está ejecutando la consulta correctamente.

  3. La comunicación entre controlador y modelo funciona.

  4. Sabemos exactamente qué tipo de dato nos devuelve el modelo (un array si existe, false si no existe).

Con esta información, en la Parte 2 podremos tomar decisiones:

  • Si $respuesta es un array → El usuario existe, lo dejamos entrar.

  • Si $respuesta es false → El usuario no existe, mostramos un error.


organizados los archivos y carpetas:

text
-------------------------------------------------------------------
                    ESTRUCTURA DEL PROYECTO
-------------------------------------------------------------------

C:\xampp\htdocs\cursoPHP\04.PDOySQL\editado\
│
├── index.php
│
├── controllers/
│   └── controller.php
│
├── models/
│   ├── conexion.php
│   ├── crud.php
│   └── enlaces.php
│
├── views/
│   ├── template.php
│   └── modules/
│       ├── editor.php
│       ├── ingresar.php
│       ├── navegacion.php
│       ├── registro.php
│       ├── salir.php
│       └── usuarios.php
│
└── (otros archivos de configuración)

-------------------------------------------------------------------
                    DETALLE DEL ARCHIVO ingresar.php
-------------------------------------------------------------------

Línea 1:  <h1>INGRESAR</h1>
Línea 2:  
Línea 3:  <form method="post">
Línea 4:  
Línea 5:  <input type="text" placeholder="Usuario" name="usuarioIngreso" required>
Línea 6:  
Línea 7:  <input type="password" placeholder="Contraseña" name="passwordIngreso" required>
Línea 8:  
Línea 9:  <input type="submit" value="Enviar">
Línea 10: 
Línea 11: </form>
Línea 12: 
Línea 13: <?php
Línea 14: $ingreso = new MvcController();
Línea 15: $ingreso -> ingresoUsuarioController();
Línea 16: ?>

-------------------------------------------------------------------
                    PANEL LATERAL (ARCHIVOS ABIERTOS)
-------------------------------------------------------------------

Archivos actualmente abiertos en el editor:
│
├── index.php
├── template.php
├── crud.php
├── controller.php
├── ingresario.php (ingresar.php)
└── registro.php

Comentarios

Publicar un comentario

Entradas más populares de este blog

token

  ¿Qué es un token? Un  token  es una cadena de caracteres que representa información específica, como credenciales de acceso, identificadores únicos o datos de sesión. Se utilizan comúnmente en: Autenticación y autorización (JWT, tokens de acceso) Protección CSRF (Cross-Site Request Forgery) Identificación única de recursos Contraseñas de un solo uso Ejemplo pequeño en PHP: Token de autenticación simple php <?php // Función para generar un token aleatorio function generarToken ( $longitud = 32 ) { return bin2hex ( random_bytes ( $longitud ) ) ; } // Generar un token $token = generarToken ( ) ; echo "Token generado: " . $token . "\n\n" ; // Simular verificación del token (en una aplicación real se guardaría en base de datos) function verificarToken ( $tokenAlmacenado , $tokenRecibido ) { return hash_equals ( $tokenAlmacenado , $tokenRecibido ) ; } // Ejemplo de uso $tokenAlmacenado = $token ; // En la práctica, esto ven...
Leer más

¿Qué es un token y cómo se utiliza en una API?

  ¿Qué es un token y cómo se utiliza en una API? ¿Qué es un token? Un  token  es una cadena de caracteres que actúa como credencial de acceso para autenticar y autorizar a un usuario o aplicación en una API. Funciona como una "llave digital" que permite acceder a recursos protegidos sin necesidad de compartir credenciales sensibles como usuario y contraseña en cada solicitud. Tipos comunes de tokens: JWT (JSON Web Token) : Token auto-contenido con información codificada Access Token : Para acceso a recursos Refresh Token : Para renovar access tokens expirados API Key : Clave simple de identificación Ejemplo con PHP usando JWT 1. Instalación de dependencias bash composer require firebase/php-jwt 2. Generar un token JWT php <?php require 'vendor/autoload.php' ; use Firebase \ JWT \ JWT ; use Firebase \ JWT \ Key ; class TokenManager { private $secretKey = "tu_clave_secreta_muy_segura" ; private $algorithm = 'HS256' ; ...
Leer más

Generación de Credenciales API

   Generación de Credenciales API Método 1: Credenciales básicas (API Key + Secret) php <?php // Generar credenciales seguras function generarCredencialesAPI ( ) { $api_key = bin2hex ( random_bytes ( 32 ) ) ; // 64 caracteres hexadecimales $api_secret = bin2hex ( random_bytes ( 64 ) ) ; // 128 caracteres hexadecimales return [ 'api_key' => $api_key , 'api_secret' => password_hash ( $api_secret , PASSWORD_DEFAULT ) ] ; } // Generar y guardar credenciales $credenciales = generarCredencialesAPI ( ) ; // Guardar en base de datos (ejemplo) // INSERT INTO api_credentials (api_key, api_secret_hash, created_at) // VALUES (:api_key, :api_secret, NOW()) ?> Método 2: Credenciales JWT php <?php use Firebase \ JWT \ JWT ; use Firebase \ JWT \ Key ; class JWTCredentials { private $secret_key ; public function __construct ( ) { $this -> secret_key = bin2hex ( r...
Leer más