Tutorial 7: Creando la Clase Whisper para Manejar Archivos

¡Hola y bienvenido de nuevo!

En esta lección vamos a crear una clase PHP llamada Whisper que contendrá todos los métodos (funciones) necesarios para nuestra aplicación. Esta clase nos permitirá organizar mejor el código y hacerlo más reutilizable y profesional.

---

📋 Contenido del Tutorial

1. Entendiendo las clases y métodos en PHP

2. Creando la clase Whisper

3. Definiendo el método upload

4. Instanciando la clase en init.php

5. Usando el objeto en index.php

6. Probando la funcionalidad

7. Código completo

8. Explicación detallada

9. Próximos pasos

---

🏗️ 1. Entendiendo las clases y métodos en PHP

¿Qué es una clase?

Una clase es como un "molde" o "plantilla" que define las propiedades y comportamientos de un objeto. Piensa en ella como el plano de una casa.

php

class Casa {
    // Propiedades (características)
    public $color;
    public $puertas;
    
    // Métodos (acciones)
    public function abrirPuerta() {
        // Código para abrir la puerta
    }
}

¿Qué es un método?

Un método es simplemente una función que pertenece a una clase. En lugar de llamarla "función", en programación orientada a objetos la llamamos "método".

php

// Función normal (fuera de una clase)
function saludar() {
    echo "Hola";
}

// Método (dentro de una clase)
class Usuario {
    public function saludar() {
        echo "Hola";
    }
}

¿Por qué usar clases?

Beneficio	Explicación
Organización	Agrupa funciones relacionadas
Reutilización	Puedes usar la misma clase en diferentes partes
Mantenimiento	Es más fácil modificar código en un solo lugar
Escalabilidad	Fácil de extender con nuevas funcionalidades

---

📁 2. Creando la clase Whisper

Ubicación del archivo

Vamos a crear un nuevo archivo en la carpeta backend/classes/:

text

whisper/
├── backend/
│   ├── init.php
│   └── classes/
│       └── Whisper.php    # ¡Nuevo archivo!
├── frontend/
│   ├── css/
│   ├── images/
│   └── js/
└── index.php

Estructura básica de la clase

php

<?php
class Whisper {
    // Aquí irán todos los métodos (funciones)
}
?>

Reglas para nombrar clases:

• ✅ Comenzar con mayúscula: Whisper, FileUploader, Database

• ✅ Usar CamelCase: MyClass, UserProfile

• ✅ Nombre descriptivo: Whisper (describe lo que hace)

---

📤 3. Definiendo el método upload

Creando el método

php

<?php
class Whisper {
    public function upload($file) {
        return $file;
    }
}
?>

Explicación del código

Parte	Explicación
public	Visibilidad - significa que se puede acceder desde cualquier lugar
function	Palabra clave para definir un método
upload	Nombre del método (lo que hace)
($file)	Parámetro - el archivo que se va a procesar
return $file;	Devuelve el archivo (por ahora solo lo retorna)

Visibilidad en PHP

Modificador	Acceso desde
public	Cualquier lugar (dentro y fuera de la clase)
protected	Dentro de la clase y clases heredadas
private	Solo dentro de la misma clase

php

class Ejemplo {
    public function metodoPublico() {
        // Accesible desde cualquier lugar
    }
    
    protected function metodoProtegido() {
        // Accesible desde la clase y clases hijas
    }
    
    private function metodoPrivado() {
        // Solo accesible desde esta clase
    }
}

---

🔗 4. Instanciando la clase en init.php

¿Qué es instanciar?

Instanciar significa crear un objeto a partir de una clase. Es como construir una casa usando el plano.

php

// La clase es el "plano"
class Casa {
    public $color;
}

// Instanciar es "construir" una casa real
$miCasa = new Casa();
$miCasa->color = "rojo";

Código en init.php

php

<?php
    // Requerir el archivo de la clase
    require 'classes/Whisper.php';
    
    // Instanciar la clase (crear un objeto)
    $whisperObj = new Whisper();
?>

Explicación detallada

require 'classes/Whisper.php';

• Incluye el archivo que contiene la clase

• Si el archivo no existe, PHP detiene la ejecución con un error fatal

$whisperObj = new Whisper();

• Crea una nueva instancia (objeto) de la clase Whisper

• $whisperObj ahora contiene todos los métodos y propiedades de la clase

Comparación: require vs include

Función	Diferencia
require	Error fatal si el archivo no existe (detiene la ejecución)
include	Advertencia si el archivo no existe (continúa la ejecución)
require_once	Requiere el archivo solo una vez
include_once	Incluye el archivo solo una vez

En nuestro caso usamos require porque la clase es esencial para la aplicación.

---

💻 5. Usando el objeto en index.php

Llamando al método upload

Ahora que tenemos el objeto $whisperObj, podemos usar su método upload():

php

<?php
    include 'backend/init.php';
    
    if ($_SERVER['REQUEST_METHOD'] === "POST") {
        if (isset($_FILES['file'])) {
            if (!empty($_FILES['file']['name'])) {
                $fileType = $_FILES['file']['type'];
                
                // Usar el objeto Whisper para procesar el archivo
                $result = $whisperObj->upload($_FILES['file']);
                
                // Mostrar el resultado (para debug)
                var_dump($result);
            }
        } else {
            $error = "Please select a file to convert into a text";
        }
    }
?>

Explicación del código

$whisperObj->upload($_FILES['file'])

• $whisperObj es el objeto que creamos en init.php

• -> es el operador para acceder a métodos y propiedades

• upload() es el método que definimos en la clase

• $_FILES['file'] es el archivo que enviamos como parámetro

var_dump($result)

• Muestra información detallada del resultado

• Útil para debugging (ver qué contiene la variable)

---

🧪 6. Probando la funcionalidad

Paso 1: Asegurar la estructura de archivos

Verifica que tengas esta estructura:

text

whisper/
├── backend/
│   ├── init.php
│   └── classes/
│       └── Whisper.php
└── index.php

Paso 2: Contenido de los archivos

backend/classes/Whisper.php:

php

<?php
class Whisper {
    public function upload($file) {
        return $file;
    }
}

backend/init.php:

php

<?php
    require 'classes/Whisper.php';
    $whisperObj = new Whisper();

index.php (parte superior):

php

<?php
    include 'backend/init.php';
    
    if ($_SERVER['REQUEST_METHOD'] === "POST") {
        if (isset($_FILES['file'])) {
            if (!empty($_FILES['file']['name'])) {
                $fileType = $_FILES['file']['type'];
                $result = $whisperObj->upload($_FILES['file']);
                var_dump($result);
            }
        } else {
            $error = "Please select a file to convert into a text";
        }
    }
?>

Paso 3: Probar en el navegador

1. Abrir la aplicación:

   text

   http://localhost/whisper/

2. Seleccionar un archivo:

   • Haz clic en "Upload File"

   • Selecciona cualquier archivo (video, audio, o incluso una imagen)

3. Ver el resultado:

   • Verás algo como esto en la página:

   text

   array(5) {
     ["name"]=> string(9) "video.mp4"
     ["type"]=> string(9) "video/mp4"
     ["tmp_name"]=> string(24) "/tmp/phpXyZ123"
     ["error"]=> int(0)
     ["size"]=> int(1234567)
   }

Solución de problemas

❌ Error: "Class 'Whisper' not found"

Problema: El archivo de la clase no se está cargando correctamente
Solución:

php

// Verifica la ruta en init.php
require 'classes/Whisper.php';  // Correcto
require 'classes/whisper.php';  // Incorrecto (mayúsculas)

❌ Error: "Failed to open stream"

Problema: El archivo Whisper.php no existe en la ruta especificada
Solución:

• Verifica que el archivo esté en backend/classes/Whisper.php

• Verifica el nombre exacto (mayúsculas/minúsculas)

❌ Error: "Call to undefined method"

Problema: El método upload no existe en la clase
Solución:

php

class Whisper {
    public function upload($file) {  // Asegúrate de que el nombre coincida
        return $file;
    }
}

---

📝 7. Código completo

Archivo: backend/classes/Whisper.php

php

<?php
/**
 * Clase Whisper - Maneja la subida y procesamiento de archivos
 * 
 * Esta clase contiene todos los métodos relacionados con el manejo
 * de archivos para la aplicación de transcripción.
 */
class Whisper {
    
    /**
     * Método upload - Procesa y sube el archivo
     * 
     * @param array $file Arreglo $_FILES con la información del archivo
     * @return array El archivo procesado
     */
    public function upload($file) {
        // Por ahora solo retorna el archivo sin modificar
        // Más adelante agregaremos validaciones y procesamiento
        return $file;
    }
}
?>

Archivo: backend/init.php

php

<?php
/**
 * Archivo de inicialización de la aplicación
 * Aquí se cargan todas las clases y configuraciones necesarias
 */

// Cargar la clase Whisper
require 'classes/Whisper.php';

// Crear una instancia (objeto) de la clase Whisper
// Este objeto estará disponible en toda la aplicación
$whisperObj = new Whisper();

// Aquí se cargarán más clases en el futuro
// require 'classes/Database.php';
// $db = new Database();

// Definir constantes globales
// define('UPLOAD_DIR', __DIR__ . '/../assets/uploads/');
?>

Archivo: index.php (sección PHP)

php

<?php
    // Cargar la configuración inicial
    include 'backend/init.php';
    
    // Variable para almacenar mensajes de error
    $error = null;
    
    // Verificar si la solicitud es POST (se envió el formulario)
    if ($_SERVER['REQUEST_METHOD'] === "POST") {
        
        // Verificar si el archivo está presente en la solicitud
        if (isset($_FILES['file'])) {
            
            // Verificar que el nombre del archivo no esté vacío
            if (!empty($_FILES['file']['name'])) {
                
                // Obtener el tipo MIME del archivo
                $fileType = $_FILES['file']['type'];
                
                // Llamar al método upload de la clase Whisper
                $result = $whisperObj->upload($_FILES['file']);
                
                // Mostrar el resultado para debugging
                // En producción, esto se eliminaría o se mostraría de otra forma
                var_dump($result);
                
            } else {
                // El archivo está vacío (no se seleccionó ningún archivo)
                $error = "Please select a file to convert into a text";
            }
            
        } else {
            // No se encontró el archivo en la solicitud
            $error = "Please select a file to convert into a text";
        }
    }
?>

---

📖 8. Explicación detallada

Flujo de la aplicación

text

1. Usuario selecciona archivo
   ↓
2. JavaScript detecta el cambio y envía el formulario
   ↓
3. El servidor recibe una solicitud POST
   ↓
4. PHP ejecuta index.php
   ↓
5. index.php incluye init.php
   ↓
6. init.php requiere Whisper.php
   ↓
7. init.php crea $whisperObj = new Whisper()
   ↓
8. index.php verifica que la solicitud sea POST
   ↓
9. index.php verifica que exista el archivo
   ↓
10. index.php llama a $whisperObj->upload($_FILES['file'])
   ↓
11. El método upload() procesa el archivo
   ↓
12. El resultado se muestra en la página

Diagrama de clases

text

┌─────────────────────┐
│      Whisper        │
├─────────────────────┤
│ + upload($file)     │  ← Método público
│ + convert($file)    │  ← (Futuro)
│ + save($data)       │  ← (Futuro)
└─────────────────────┘
         ▲
         │
    Instancia (objeto)
         │
    $whisperObj

Conceptos clave de POO (Programación Orientada a Objetos)

Concepto	Definición	Ejemplo en nuestro código
Clase	Plantilla para crear objetos	class Whisper { ... }
Objeto	Instancia de una clase	$whisperObj = new Whisper();
Método	Función dentro de una clase	public function upload($file) { ... }
Propiedad	Variable dentro de una clase	public $uploadDir; (futuro)
Visibilidad	Nivel de acceso	public, protected, private

---

🎯 9. Próximos pasos

Lo que hemos logrado

✅ Creación de la clase Whisper
✅ Definición del método upload
✅ Instanciación de la clase en init.php
✅ Uso del objeto en index.php
✅ Prueba básica de funcionamiento

Lo que viene en la próxima lección

En la siguiente lección vamos a:

1. Agregar validaciones al método upload

2. Verificar el tipo de archivo (video/audio)

3. Mover el archivo a la carpeta de uploads

4. Generar nombres únicos para los archivos

5. Manejar errores de subida de archivos

Avance del código de la próxima lección

php

class Whisper {
    private $allowedTypes = ['video/mp4', 'video/x-msvideo', 'audio/mpeg'];
    private $maxSize = 500 * 1024 * 1024; // 500MB
    private $uploadDir = '../assets/uploads/';
    
    public function upload($file) {
        // 1. Validar tipo de archivo
        if (!$this->validateType($file['type'])) {
            throw new Exception("Tipo de archivo no soportado");
        }
        
        // 2. Validar tamaño
        if (!$this->validateSize($file['size'])) {
            throw new Exception("El archivo excede el tamaño máximo");
        }
        
        // 3. Generar nombre único
        $filename = $this->generateUniqueName($file['name']);
        
        // 4. Mover el archivo
        $destination = $this->uploadDir . $filename;
        if (!move_uploaded_file($file['tmp_name'], $destination)) {
            throw new Exception("Error al mover el archivo");
        }
        
        // 5. Retornar información del archivo
        return [
            'name' => $filename,
            'path' => $destination,
            'type' => $file['type'],
            'size' => $file['size']
        ];
    }
}

---

❓ Preguntas frecuentes

¿Qué es una clase en PHP?

• Una clase es un molde que define propiedades y métodos para crear objetos

• Permite organizar el código y reutilizarlo

¿Qué es un método?

• Es una función que pertenece a una clase

• Define el comportamiento de los objetos

¿Por qué usamos public en el método?

• public permite que el método sea accesible desde cualquier lugar

• Si usáramos private, solo podría usarse dentro de la clase

¿Qué es new en PHP?

• new es el operador que crea una instancia (objeto) de una clase

• Ejemplo: $obj = new MiClase();

¿Por qué necesito require el archivo de la clase?

• PHP necesita saber qué es la clase antes de usarla

• require carga el archivo que contiene la definición de la clase

¿Qué diferencia hay entre una función y un método?

• Una función es independiente y se define fuera de una clase

• Un método pertenece a una clase y se define dentro de ella

¿Qué es var_dump() y por qué lo usamos?

• var_dump() muestra información detallada de una variable

• Lo usamos para debugging (ver qué contiene el archivo subido)

---

🎓 Ejercicio práctico

Ejercicio 1: Agregar un nuevo método

Agrega un método getFileInfo() a la clase Whisper que devuelva información detallada del archivo:

php

class Whisper {
    public function upload($file) {
        return $file;
    }
    
    // Nuevo método
    public function getFileInfo($file) {
        return [
            'name' => $file['name'],
            'size' => $file['size'] / 1024 . ' KB',
            'type' => $file['type'],
            'extension' => pathinfo($file['name'], PATHINFO_EXTENSION)
        ];
    }
}

Ejercicio 2: Usar el nuevo método

En index.php, después de llamar a upload, usa el nuevo método:

php

$result = $whisperObj->upload($_FILES['file']);
$info = $whisperObj->getFileInfo($_FILES['file']);
var_dump($info);

---

¡Excelente trabajo! Ahora tenemos una clase PHP bien estructurada que manejará toda la lógica de subida de archivos. En la próxima lección, agregaremos funcionalidades reales para procesar los archivos con Whisper.