Aquí tienes 10 trucos avanzados que todo programador PHP (y otros lenguajes) debería conocer.

1. Edición Rápida en Múltiples Archivos con “Find in Files”

¿Necesitas cambiar una función en varios archivos a la vez?

• Ctrl + Shift + F (Windows/Linux) o Cmd + Shift + F (Mac).
• Busca un término (ej: function getUser).
• ¡Puedes editar directamente en los resultados!

👉 Ejemplo PHP: Cambiar mysql_query a PDO en todo un proyecto.

2. Selección Rápida de Bloques de Código

En lugar de seleccionar línea por línea:

• Ctrl + Shift + M → Selecciona contenido entre paréntesis (), llaves {} o corchetes [].
• Ctrl + Shift + J → Selecciona todo el contenido de un bloque (ideal para funciones PHP).

3. Reordenar Líneas con Drag & Drop

¿Quieres mover una función o línea sin cortar y pegar?

• Mantén Ctrl + Shift y arrastra la línea (o bloque) hacia arriba/abajo.
• Útil para reorganizar métodos en una clase PHP.

4. Comandos Rápidos con la Palabra Clave

Olvídate de buscar en menús:

• Ctrl + P → Escribe @ para saltar a funciones/métodos (útil en archivos PHP grandes).
• Ctrl + R → Lista todas las funciones/clases del archivo actual.

5. Editar HTML/XML con “Emmet” (Ahorra Tiempo en Vistas PHP)

Sublime incluye Emmet para generar código HTML rápido:

• Escribe div.container>ul>li*5 y presiona Tab → Genera una lista con 5 elementos.
• Funciona en archivos PHP con bloques HTML.

6. Dividir la Pantalla en Columnas (Sin Plugins)

¿Quieres comparar dos archivos o ver código y resultado?

• Alt + Shift + 2 → Divide en 2 columnas.
• Alt + Shift + 1 → Vuelve a una sola vista.

7. Expandir/Contraer Bloques de Código Rápidamente

• Ctrl + K + 1 → Contraer todos los bloques de nivel 1 (útil para ocultar funciones PHP).
• Ctrl + K + J → Expande todo.

8. Buscar y Reemplazar con Expresiones Regulares

¿Necesitas refactorizar código masivamente?

• Ctrl + H → Activa Regex (.*).
• Ejemplo PHP: Cambiar $var = old_function(); a $var = new_function(); en todo el proyecto.

9. Snippets Personalizados para PHP

Crea tus propios atajos para código repetitivo:

1. Tools > Developer > New Snippet
2. Ejemplo para un foreach en PHP:

xml

<snippet>
    <content><![CDATA[
foreach ($${1:array} as $${2:key} => $${3:value}) {
    ${4:// code}
}
]]></content>
    <tabTrigger>foreach</tabTrigger>
</snippet>

• Al escribir foreach + Tab, se autocompletará.

10. Navegación por Pestañas sin Mouse

• Ctrl + Tab → Cambia entre pestañas recientes.
• Ctrl + PgUp/PgDown → Navega entre pestañas en orden.

En este artículo, aprenderás:
✅ Qué es filter_var() y por qué usarlo
✅ Diferencias entre validación y sanitización
✅ Filtros más útiles para formularios, emails y URLs
✅ Ejemplos prácticos de uso

1. ¿Qué es filter_var()?

filter_var() es una función de PHP que permite validar y sanitizar datos aplicando filtros predefinidos. Es más seguro que funciones obsoletas como htmlspecialchars() o expresiones regulares complejas en algunos casos.

Sintaxis básica:

php

filter_var($valor, $filtro, $opciones);

• $valor: Dato a filtrar (ej: $_POST['email']).
• $filtro: Tipo de filtro a aplicar (ej: FILTER_VALIDATE_EMAIL).
• $opciones (opcional): Configuraciones adicionales.

2. Validación vs. Sanitización

3. Filtros Más Útiles

Validación de datos comunes

Sanitización de datos peligrosos

4. Ejemplos Prácticos

Validar un formulario de contacto

php

$email = $_POST['email'] ?? '';
$url = $_POST['website'] ?? '';
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
    echo "El email no es válido";
    } elseif (!filter_var($url, FILTER_VALIDATE_URL)) {
    echo "La URL no es válida";
    } else {
    echo "Datos correctos, procesando...";
    }

Sanitizar una entrada para evitar XSS

$comentario = $_POST['comentario'] ?? '';
$comentario_limpio = filter_var($comentario, FILTER_SANITIZE_SPECIAL_CHARS);

echo $comentario_limpio; // Convierte <script> en &lt;script&gt;

Validar y sanitizar un número entero

php

$edad = $_POST['edad'] ?? '';
$edad_limpia = filter_var($edad, FILTER_SANITIZE_NUMBER_INT);
if (filter_var($edad_limpia, FILTER_VALIDATE_INT, ["options" => ["min_range" => 18, "max_range" => 99]])) {
    echo "Edad válida: $edad_limpia";
    } else {
    echo "Edad debe ser entre 18 y 99";
    }

5. Conclusión

✅ filter_var() es una herramienta poderosa para validar y sanitizar datos.
✅ Reduce riesgos de inyección de código y ataques XSS.
✅ Es más seguro que funciones antiguas como mysql_real_escape_string().

Como podremos ver todo tiene su lógica, tendremos un método para cada una de las funcionalidades de un carrito de compras convencional, insertar, actualizar, eliminar etc, así que antes de comenzar veamos un listado de los métodos y funciones más importantes y que hacen:

• • El método add

Pasando un array de clave valor nos insertará un producto dentro del carrito, si ese producto ya existe lo que hace es actualizar la cantidad de unidades.

• • La función remove_producto

Pasando un unique_id, que no es más que un identificador único de cada producto que conseguimos encriptando con md5 la id del producto, eliminará por completo todas las unidades de ese producto.

• • El método get_content

Nos devuelve un array con todos los productos del carrito y la información de cada uno de ellos.

• • El método precio_total

Devuelve el precio total del carrito de compras, por defecto, si el carrito está vacío el valor es de 0.

• • El método artículos_total

Devuelve el número total de artículos del carrito, por defecto, si el carrito está vacío el valor es de 0.

• • La función destroy

Elimina por completo el carrito de compras, una vez hecho, nuestro carrito tendrá valor NULL.

Clase carrito de compras con php

Toda nuestra lógica estará dentro de una clase que llamaremos Carrito.class.php, así que creo que es un buen momento de crear un proyecto vacío y dentro crear ese archivo, una vez hecho podemos añadir el siguiente código con el que nuestro carrito quedará implementado.

<?php
session_start();
class Carrito
{
    //aquí guardamos el contenido del carrito
    private $carrito = array();
    //seteamos el carrito exista o no exista en el constructor
    public function __construct()
    {
        if(!isset($_SESSION["carrito"]))
        {
            $_SESSION["carrito"] = null;
            $this->carrito["precio_total"] = 0;
            $this->carrito["articulos_total"] = 0;
        }
        $this->carrito = $_SESSION['carrito'];
    }
    //añadimos un producto al carrito
    public function add($articulo = array())
    {
        //primero comprobamos el articulo a añadir, si está vacío o no es un 
        //array lanzamos una excepción y cortamos la ejecución
        if(!is_array($articulo) || empty($articulo))
        {
            throw new Exception("Error, el articulo no es un array!", 1);
        }
        //nuestro carro necesita siempre un id producto, cantidad y precio articulo
        if(!$articulo["id"] || !$articulo["cantidad"] || !$articulo["precio"])
        {
            throw new Exception("Error, el articulo debe tener un id, cantidad y precio!", 1);
        }
        //nuestro carro necesita siempre un id producto, cantidad y precio articulo
        if(!is_numeric($articulo["id"]) || !is_numeric($articulo["cantidad"]) || !is_numeric($articulo["precio"]))
        {
            throw new Exception("Error, el id, cantidad y precio deben ser números!", 1);
        }
        //debemos crear un identificador único para cada producto
        $unique_id = md5($articulo["id"]);
        //creamos la id única para el producto
        $articulo["unique_id"] = $unique_id;
        //si no está vacío el carrito lo recorremos 
        if(!empty($this->carrito))
        {
            foreach ($this->carrito as $row)
            {
                //comprobamos si este producto ya estaba en el 
                //carrito para actualizar el producto o insertar
                //un nuevo producto	
                if($row["unique_id"] === $unique_id)
                {
                    //si ya estaba sumamos la cantidad
                    $articulo["cantidad"] = $row["cantidad"] + $articulo["cantidad"];
                }
            }
        }
        //evitamos que nos pongan números negativos y que sólo sean números para cantidad y precio
        $articulo["cantidad"] = trim(preg_replace('/([^0-9\.])/i', '', $articulo["cantidad"]));
        $articulo["precio"] = trim(preg_replace('/([^0-9\.])/i', '', $articulo["precio"]));
        //añadimos un elemento total al array carrito para 
        //saber el precio total de la suma de este artículo
        $articulo["total"] = $articulo["cantidad"] * $articulo["precio"];
        //primero debemos eliminar el producto si es que estaba en el carrito
        $this->unset_producto($unique_id);
        ///ahora añadimos el producto al carrito
        $_SESSION["carrito"][$unique_id] = $articulo;
        //actualizamos el carrito
        $this->update_carrito();
        //actualizamos el precio total y el número de artículos del carrito
        //una vez hemos añadido el producto
        $this->update_precio_cantidad();
    }
    //método que actualiza el precio total y la cantidad
    //de productos total del carrito
    private function update_precio_cantidad()
    {
        //seteamos las variables precio y artículos a 0
        $precio = 0;
        $articulos = 0;
        //recorrecmos el contenido del carrito para actualizar
        //el precio total y el número de artículos
        foreach ($this->carrito as $row)
        {
            $precio += ($row['precio'] * $row['cantidad']);
            $articulos += $row['cantidad'];
        }
        //asignamos a articulos_total el número de artículos actual
        //y al precio el precio actual
        $_SESSION['carrito']["articulos_total"] = $articulos;
        $_SESSION['carrito']["precio_total"] = $precio;
        //refrescamos él contenido del carrito para que quedé actualizado
        $this->update_carrito();
    }
    //método que retorna el precio total del carrito
    public function precio_total()
    {
        //si no está definido el elemento precio_total o no existe el carrito
        //el precio total será 0
        if(!isset($this->carrito["precio_total"]) || $this->carrito === null)
        {
            return 0;
        }
        //si no es númerico lanzamos una excepción porque no es correcto
        if(!is_numeric($this->carrito["precio_total"]))
        {
            throw new Exception("El precio total del carrito debe ser un número", 1);
        }
        //en otro caso devolvemos el precio total del carrito
        return $this->carrito["precio_total"] ? $this->carrito["precio_total"] : 0;
    }
    //método que retorna el número de artículos del carrito
    public function articulos_total()
    {
        //si no está definido el elemento articulos_total o no existe el carrito
        //el número de artículos será de 0
        if(!isset($this->carrito["articulos_total"]) || $this->carrito === null)
        {
            return 0;
        }
        //si no es númerico lanzamos una excepción porque no es correcto
        if(!is_numeric($this->carrito["articulos_total"]))
        {
            throw new Exception("El número de artículos del carrito debe ser un número", 1);
        }
        //en otro caso devolvemos el número de artículos del carrito
        return $this->carrito["articulos_total"] ? $this->carrito["articulos_total"] : 0;
    }
    //este método retorna el contenido del carrito
    public function get_content()
    {
        //asignamos el carrito a una variable
        $carrito = $this->carrito;
        //debemos eliminar del carrito el número de artículos
        //y el precio total para poder mostrar bien los artículos
        //ya que estos datos los devuelven los métodos 
        //articulos_total y precio_total
        unset($carrito["articulos_total"]);
        unset($carrito["precio_total"]);
        return $carrito == null ? null : $carrito;
    }
    //método que llamamos al insertar un nuevo producto al 
    //carrito para eliminarlo si existia, así podemos insertarlo
    //de nuevo pero actualizado
    private function unset_producto($unique_id)
    {
        unset($_SESSION["carrito"][$unique_id]);
    }
    //para eliminar un producto debemos pasar la clave única
    //que contiene cada uno de ellos
    public function remove_producto($unique_id)
    {
        //si no existe el carrito
        if($this->carrito === null)
        {
            throw new Exception("El carrito no existe!", 1);
        }
        //si no existe la id única del producto en el carrito
        if(!isset($this->carrito[$unique_id]))
        {
            throw new Exception("La unique_id $unique_id no existe!", 1);
        }
        //en otro caso, eliminamos el producto, actualizamos el carrito y 
        //el precio y cantidad totales del carrito
        unset($_SESSION["carrito"][$unique_id]);
        $this->update_carrito();
        $this->update_precio_cantidad();
        return true;
    }
    //eliminamos el contenido del carrito por completo
    public function destroy()
    {
        unset($_SESSION["carrito"]);
        $this->carrito = null;
        return true;
    }
    //actualizamos el contenido del carrito
    public function update_carrito()
    {
        self::__construct();
    }
}

Para entender el funcionamiento del carrito es suficiente con repasar el código las veces necesarias, hasta que logremos entender el funcionamiento y la lógica ya que está explicado en cada apartado de forma muy muy clara.

Para poder hacer uso del carrito, lo primero es crear una nueva instancia, lo que nos devolverá un carrito vacío y valor 0 tanto al precio como al número de artículos.

Crear un nuevo carrito

$carrito = new Carrito();

Añadir un producto al carrito

//array que crea un producto
$articulo = array(
		"id"			=>		14,
		"cantidad"		=>		3,
		"precio"		=>		50,
		"nombre"		=>		"camisetas"
	);

//añadir el producto
//$carrito->add($articulo);

Eliminar un producto por su unique_id

$carrito->remove_producto("45c48cce2e2d7fbdea1afc51c7c6ad26");

Ese es el aspecto de un campo unique_id de cada producto.

Obtener el contenido del carrito

$carrito->get_content();

Obtener el precio total del carrito

$carrito->precio_total();

Obtener el número de artículos del carrito

$carrito->articulos_total();

Eliminar el contenido del carrito

$carrito->destroy();

Una vez creado el carrito y añadido algún producto, simplemente podemos mostrar los artículos de la siguiente forma.

//asignamos a $carro el método get_content() que contiene el contenido del carrito
$carro = $carrito->get_content();
if($carro)
{
	foreach($carro as $producto)
	{
		echo $producto["id"];
		echo "<br />";
		echo $producto["unique_id"];
		echo "<br />";
		echo $producto["cantidad"];
		echo "<br />";
		echo $producto["precio"];
		echo "<br />";
		echo $producto["nombre"];
		echo "<br />";
	}
}

Y eso es todo, no tiene más misterio un carrito de compras con php, sólo necesitamos juntar los ingredientes que necesitemos y ya está, espero que te sea de utilidad, por lo menos para seguir aprendiendo php si estás en ese camino.

function LetrasyNumeros($texto)
{
      $textoLimpio = preg_replace('([^A-Za-z0-9])', '', $texto);	     					
      return $textoLimpio;
}

Modo de uso

$texto="Este texto-Limpio"
echo LetrasyNumeros($texto)
//salida
//EstetextoLimpio

Php tiene la función mail(); la cual es muy facil de usar como se ve en el primer ejemplo

mail("contacto@dominio.com,pedro@dominio2.com","Asunto","Cuerpo del mensaje que se enviara") 

Ahora se puede hacer algo mas elaborado por si queremos que nuestro correo lleve diseño para ello necesitamos incluir html

//Declaramos las variables de la cabecera del mensaje
$destinatario = "destinatario@sitio1.com"; 
$asunto = "Titulo del mensaje"; 
//definimos el cuerpo del mensaje ya con el html.
$cuerpo = ' 
<html> 
<head> 
   <title>Titulo del correo</title> 
</head> 
<body> 
<h1>Hola amigos!</h1> 
<p> 
<b>Este es mi primer correo de prueba </b>. Estoy encantado de tener varios lectores. y agradezco a cada uno de ellos el leerme. 
</p> 
</body> 
</html> 
'; 

//para el envío en formato HTML debemos declarar las siguiente cabecera.
$headers = "MIME-Version: 1.0\r\n"; 
$headers .= "Content-type: text/html; charset=iso-8859-1\r\n"; 

//dirección del remitente 
$headers .= "From: Emanuel Paxtian <contacto@sitio.com>\r\n"; 

//dirección de respuesta, si queremos que sea distinta que la del remitente 
$headers .= "Reply-To: respuesta@sitio.com\r\n";  

//Con esto especificamos las direcciones que recibirán copia 
$headers .= "Cc: copia@sitio.com\r\n"; 

//direcciones que recibirán copia oculta 
$headers .= "Bcc: copiaoculta@dominio.com,copiaoculta@dominio2.com\r\n"; 

mail($destinatario,$asunto,$cuerpo,$headers) 

Una vez activo, podremos realizar búsquedas o reemplazos utilizando expresiones regulares.

El mundo de las expresiones regulares es muy amplio, pero es muy útil para automatizar tareas de búsqueda con patrones muy variables o desconocidos. Aquí algunos ejemplos:

Expresiones regulares atómicas

Expresiones regulares básicas

Expresiones regulares de agrupación (captura)

Lo interesante de estas últimas expresiones regulares es que los paréntesis efectúan una tarea de agrupación, capturando el contenido y guardándolo en una variable $1. En el caso de que la expresión regular contenga más paréntesis, irá capturando en variables sucesivas: $1, $2, $3, etc…

Todo esto puede ser muy útil para realizar reemplazos con fragmentos capturados en dichas variables.

// genera una cadena única
echo uniqid();
/* devuelve
4bd67c947233e
*/

Puedes enviar como primer parámetro en la función un prefijo y puede poner a true el segundo valor para aumentar la entropía, (usando el generador de congruencia lineal combinado) al final del valor de retorno, lo que aumenta la probabilidad de que el resultado será único. Por defecto devuelve una cadena de 13 caracteres, si se activa la entropía devuelve una cadena de 23 caracteres.

// con prefijo
echo uniqid('id_');
/* devuelve
id_4bd67d6cd8b8f
*/

// con más entropía
echo uniqid('',true);
/* devuelve
4bd67d6cd8b926.12135106
*/

// ambos
echo uniqid('id_',true);
/* devuelve
id_4bd67da367b650.43684647
*/

La Entropía también se puede considerar como la cantidad de información promedio que contienen los símbolos usados. Los símbolos con menor probabilidad son los que aportan mayor información; por ejemplo, si se considera como sistema de símbolos a las palabras en un texto, palabras frecuentes como “que”, “el”, “a” aportan poca información. Mientras que palabras menos frecuentes como “corren”, “niño”, “perro” aportan más información. Si de un texto dado borramos un “que”, seguramente no afectará a la comprensión y se sobreentenderá, no siendo así si borramos la palabra “niño” del mismo texto original. Cuando todos los símbolos son igualmente probables (distribución de probabilidad plana), todos aportan información relevante y la entropía es máxima.

En la función que les traigo a continuación les mostrare como generar una cadena aleatoria pasándole un parámetro en este caso la longitud de la cadena que nos va a generar y haciendo so de un arreglo y de un ciclo.

<?php
function generarCadena($longitud) {
 $cadena = '';
 $patron = '1234567890abcdefghijklmnopqrstuvwxyz';
 $max = strlen($patron)-1;
 for($i=0;$i < $longitud;$i++) 
 $cadena .= $patron{mt_rand(0,$max)};  
 return $cadena; }   
//Ejemplo de uso   
echo generarCadena(6); 
// genera una cadena aleatoria  de 6 caracteres de longitud. 
?>

Ahora les explico las variable
$longitud: Esta variable es la que nos devolverá un numero de caracteres.
$patron: Aquí definimos que caracteres usaremos
$cadena: es la variable que nos va a retornar nuestra función.

<?php   
//definimos las variables para nuestra conexión 
 $server = "localhost"; $user = "root"; $pass = ""; $bd = "psoluciones";   
//Generamos nuestra conexión  
$conexion = mysqli_connect($server, $user, $pass,$bd)  or die("Ha sucedido un error inesperado en la conexion de la base de datos");   
//generamos la consulta $sql = "SELECT * FROM clientes"; 
mysqli_set_charset($conexion, "utf8"); 
//formato de datos utf8   
if(!$result = mysqli_query($conexion, $sql)) die();   
$clientes = array(); 
//creamos un array el cual posteriormente procesaremos a JSON

while($row = mysqli_fetch_array($result))  {      
$id=$row['id'];     
$nombre=$row['nombre'];     
$edad=$row['edad'];     
$genero=$row['genero'];     
$email=$row['email'];     
$localidad=$row['localidad'];    
$telefono=$row['telefono'];            
$clientes[] = array('id'=> $id, 'nombre'=> $nombre, 'edad'=> $edad, 'genero'=> $genero,
'email'=> $email, 'localidad'=> $localidad, 'telefono'=> $telefono);
 
}
    
//desconectamos la base de datos
$close = mysqli_close($conexion) or die("Ha sucedido un error inesperado en la desconexión de la base de datos");
  
 
//Creamos el JSON
$json_string = json_encode($clientes);
// imprimimos para mostrar el contenido
echo $json_string;
 
//Si queremos crear un archivo json, sería de esta forma:
/*
$file = 'clientes.json';

file_put_contents($file, $json_string);
*/
 
?>