Manipulación de Datos en PHP: Arrays y Funciones

Clase 17 de 17 • Curso de Manejo de Datos en PHP

Contenido del curso

Datos

Funciones

Arrays

Resumen

Dominar el manejo de datos en PHP es una habilidad fundamental para cualquier persona que quiera avanzar en el desarrollo web. A lo largo de este recorrido se cubrieron desde los fundamentos más sencillos hasta la manipulación de estructuras de datos complejas, construyendo una base sólida para dar el salto hacia la programación orientada a objetos.

¿Cómo se trabajan las cadenas de texto en PHP?

El punto de partida fue comprender la diferencia entre comillas simples y comillas dobles [0:12]. En PHP, las comillas dobles permiten el análisis de variables (variable parsing), es decir, interpretar el valor de una variable directamente dentro de una cadena. Las comillas simples, en cambio, tratan todo como texto literal. Esta distinción, aunque parece menor, impacta directamente en la legibilidad y eficiencia del código.

A partir de ahí se profundizó en técnicas de extracción, manipulación y alteración de datos [0:22]. Estas operaciones incluyen recortar cadenas, buscar coincidencias, reemplazar fragmentos y transformar formatos, habilidades que se utilizan constantemente en cualquier aplicación real.

¿Por qué las funciones son clave para la programación orientada a objetos?

Uno de los bloques más importantes fue el estudio de las funciones [0:30]. Entender cómo crear, parametrizar y reutilizar funciones no solo mejora la organización del código, sino que prepara el camino hacia conceptos más avanzados como la creación de clases y la definición de su estructura dentro de la programación orientada a objetos [0:35].

Las funciones permiten encapsular lógica y evitar repetición.
Facilitan el mantenimiento y la escalabilidad de proyectos.
Son la base sobre la que se construyen los métodos de una clase.

¿Qué papel juegan los arrays en la manipulación de datos complejos?

Para cerrar la parte técnica se trabajó con arrays [0:48], que son estructuras de datos capaces de almacenar múltiples valores bajo una sola variable. La manipulación de arrays —agregar, eliminar, ordenar y filtrar elementos— es indispensable cuando se manejan conjuntos de información más grandes, como registros de bases de datos o respuestas de APIs.

Todo este conocimiento se integró en un proyecto práctico [0:44] que permitió aplicar cada concepto en un contexto real, reforzando la comprensión y mostrando cómo las piezas encajan entre sí.

Si ya completaste el examen, comparte en los comentarios tu experiencia y qué tema te resultó más útil.

Matias Acosta

student•

Pd: dejo mis apunte de todo el curso

Comillas

Comillas simples
- Puedo escribir texto de una o varias lineas
- Los caracteres que puedo escapar son ' y \
- Si quiero utilizar el valor de una variable, como ejemplo $variable, lo imprime exactamente igual, no toma el valor que esta dentro de la variable
- Para utilizar el valor de una variable es necesario utilizar la concatenacion
Comillas dobles
- Aqui si podemos tomar el valor de una variable
Si la estructura a imprimir es compleja

Para estos casos utilizamos las llaves para escapar, asi le indicamos a php que esa es una estructura compleja y que la analice detenidamente

Necesitamos utilizar llaves tanto al inicio como al final de la impresion

  $courses = [
      'backend' => [
          'PHP',
          'Laravel'
      ]
  ]

  echo "{$courses['backend'][0]}"

Si queremos escribir algo contenido en una clase

Utilizamos una especie de flechita

  class User{
      public $name = "Matias";
  }

  //creamos la instancia
  user = New User;

  //imprimimos
  echo "user->name"

Utilizando variables variables

    $teacher = 'italo';
    $italo = 'Profesor de PHP';

    echo "$teacher es ${$teacher}";

Esto tambien podemos hacerlo con funciones

    function getTeacher(){
        return 'teacher';
    }
    echo "${getTeacher}"

Extraccion de datos

Una string es un objeto iterable

podemos indicar el indice que queremos seleccionar entre llaves o entre corchetes, es decir:

data[0];
data{0};
funcion substr

significa substraer string. La sintaxis es la siguiente

    substr($valor, 0, 20);

Asi indicamos, de donde tiene que substraer, desde donde tiene que empezar y hasta que indice tiene que llegar

function explode

pasar de texto a un array separando los elementos mediante un valor. Por ejemplo

    $data = 'javascript, php, laravel';
    $tags = explode(', ', $data);

    //utilizamos var_dump() para imprimir un array
    echo "<pre>";
    var_dump($tags);

Etiqueta <pre>

Es una etiqueta propia de PHP, lo que nos permite es extructurar mejor la informacion a imprimir

Funcion implode

Es el contrario de la funcion explode, lo que hace es pasar de un array a un string. La sintaxis es la misma.

Funcion trim

Lo que hace es eliminar los espacios restantes tanto al final como al inicio. Tiene otras dos variantes:

ltrim($string)
rtrim($string)

Formatear datos

Alterar texto

strtoupper(str): texto a mayusculas
strtolower(str): texto a minusculas
ucfirst(str): upper case primera letra
lcfirst(str): lower case primera letra

Reemplazar

str_replace('reemplazar', 'por', en $variable)

Modificar

str_pad(): Por ejemplo, para imprimir el numero de una factura, necesitamos que tenga 8 digitos. Asi que queremos imprimir el numero de factura actual y el espacio restante rellenarlo con #

    $code = 39;
    echo str_pad($code, 8, '#');

    //salida: 39######

Si agregamos el parametro STR_PAD_BOTH lo que hara sera centrar el numero actual de nuestra factura y rellenar con # a los lados

    $code = 39;
    echo str_pad($code, 8, '#', STR_PAD_BOTH);

    //salida: ###39###

Tambien podemos utilizar STR_PAD_LEFT y STR_PAD_LEFT

strip_tags(): Lo que hace es, si tenemos etiquetas HTML dentro de una string en PHP, nos devuelve el texto sin esas etiquetas

    $text = '<h2>Hola mundo</h2>';
    echo strip_tags($text);

Elementos Monobyte y Multibyte

Cuando trabajamos caracteres especiales, como por ejemplo la ñ o la ó, no son interpretados correctamente en las funciones strtoupper entre otras, es decir que no convierte el caracter a mayuscula

Cuando nos topamos con un elemento como este decimos que estamos trabajando con un elemento multibyte

Solucionarlo es muy sencillo

    $text = 'Hola ña ñeca';

    echo strtoupper($text);
    //salida: HOLA ñA ñECA

    echo mb_strtoupper($text);
    //salida: HOLA ÑA ÑECA

asi le indicamos a PHP que estamos trabajando con un elemento Multibyte

Expresiones regulares

Simbolos

/: CONTENEDOR
^: INICIO
$: FINAL
-: RANGO
[]: PATRÓN
{}: CONDICIÓN PHP tiene una funcion para utilizar expresiones regulares, la cual es preg_match

    preg_match("/^[0-9]{6,9}$/");

Iniciando nuestro proyecto

Utilizaremos composer y phpunit

Lo primero que hacemos es requerir phpunit para el desarrollo

composer require --dev phpunit/phpunit

Luego de eso, modificamos el archivo composer.json y le agregamos un nombre, despcripcion y configuramos el autoload

{
    "name": "matias-ed/validate",
    "description": "proyecto de validacion",
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    },
    "require-dev": {
        "phpunit/phpunit": "^9.5"
    }
}

Creamos el archivo phpunit.xml donde especificamos en que carpeta se encuentran nuestros tests

<?xml version="1.0" encoding="UTF-8"?>
<phpunit bootstrap="vendor/autoload.php" colors="true">
    <testsuite name="Test directory">
        <directory>tests</directory> 
    </testsuite>
</phpunit>

Creamos la carpeta tests y dentro de ella creamos el archivo ValidateTest.php obs: Es buena practica que los archivos de testing terminen en Test

    <?php

    use PHPUnit\Framework\TestCase;
    use App\Validate;

    class ValidateTest extends TestCase
    //TestCase es una clase de PHPUnit
    {
        public function test_email()
        {
            $email = Validate::email("matdj31@gmail.com");
            //aqui llamamos al metodo email de la clase Validate que aun no hemos creado

            $this->assertTrue($email);
            //Es un metodo de TestCase
        }
    }

Por ultimo creamos nuestra carpeta src/ y adentro creamos nuestra clase Validate

    namespace App;

    class Validate
    {
        public static function email($value)
        {
            return (bool) filter_var($value, FILTER_VALIDATE_EMAIL);
        }
    }
    //filter_var es una funcion propia de php que me permite filtrar a mis variables
    //FILTER_VALIDATE_EMAIL es una constante propia de PHP

Revision del proyecto

Los archivos que utilizamos para testing siempre deben acabar con Test. Por ejemplo Validate_Test o ValidateTest
Los metodos dentro de nuestras clases de testing tambien deben empezar por test. Por ejemplo test_email o testEmail

Funciones

Argumentos Son los valores que colocamos dentro de los parentesis
Referencia Que observa directamente el comportamiento de otro elemento

    $course = 'PHP';
    function path($course)
    {
        $course = 'Laravel';
        echo $course;
    }

    path($course);
    echo $course;

Esta function solo modifica el valor internamente en la funcion, quiere decir que fuera de la function $course sigue teniendo el valor 'PHP'

Si queremos que tambien se modifique el valor global agregamos un &

    $course = 'PHP';
    function path(&$course)
    {
        $course = 'Laravel';
        echo $course;
    }

    path($course);
    echo $course;

Parametro o argumento predeterminado Es el valor por defecto que tiene un argumento
Return Lo que hace es devolver un resultado
Exit() Es una funcion que detiene el sistema

Funciones anonimas

Una funcion anonima se usa en una variable que requiere logica Nos referimos a ella a traves de una variable

    $greet = function($name){
    return "Hola $name";
    };
    $greet("Matias");

Closure Sirve para especificar que esperamos una funcion anonima como parametro

Arrays

Array simple

Son aquellos a los cuales no hemos definido ningun key

Array complejo

Son aquellos que ya cuentan con clave => valor

Formas de recorrer un array complejo

Utilizando foreach

    $courses = [
        'frontend' => 'JavaScript',
        'framework' => 'React',
        'backend' => 'PHP'
    ];

    foreach ($courses  as $key=>$value)
    {
        echo "$key: $value<br>";
    }

Utilizando array_walk

    $courses = [
        'frontend' => 'JavaScript',
        'framework' => 'React',
        'backend' => 'PHP'
    ];

    function upper($course)
    {
        echo strtoupper($course). "<br>";
    }

    array_walk($courses, 'upper');

Otras funciones para manipular arrays

array_key_exists('frontend', $variable) pregunta si la clave 'frontend' existe
in_array('javascript', $variable) pregunta si el elemento existe dentro del array
array_keys($variable) devuelve todas las claves del array
array_values($variable) devuelve todos los valores del array
sort($array) ordena los valores de manera ascendente
rsort($array) ordena los valores de manera descendente
ksort($array) ordena los valores de manera ascendente segun los keys
krsort($array) ordena los valores de manera descendente segun los keys
array_slice($array, index) devuelve los valores del array desde el indice indicado
array_chunk($array, size) divide el array indicado en varios arrays del tamaño indicado
array_shift($array) elimina el primer elemento del array
array_pop($array) elimina el ultimo elemento del urray
array_unshift($array, element) agregamos un elemento en el indice 0
array_push($array, element) agregamos un elemento en la ultima posicion del array
array_flip($array) hace un intercambio entre valores y llaves. El valor pasa a ser un key y el key pasa a ser el valor

Comparacion entre arrays

array_diff($array_1, $array_2) nos devuelve los elementos que estan en el $array_1 que no estan en el array_2
array_diff_assoc($array_1, $array_2) compara arrays complejos

Union de arrays

sumando las variables podemos simplemente hacer lo siguiente

    $array_1 + $array_2

sin embargo aqui se sobreescriben los indices. Si tenemos dos arrays con indice 0, el elemento que esta en el indice 0 del array 1 sobreescribe a el elemento del indice 0 del array 2. Tenemos dos formas de solucionar esto

Agregando keys diferentes a cada elemento
funcion array_merge(array_1, array_2) esto une los arrays, pero solo funciona cuando los indices numeros. Si indicamos claves a cada elemento, y algun de las claves se repite en los arrays, tambien se sobreescribira el valor. Esto podemos solucionarlo con:

array_merge_recursive: la solucion que nos da php es crear un array con la clave que se repite y ahi guarda los dos valores
array_combine(key_array, value_array) lo que hace es, tomar cada elemento del key_array como una clave, y va guardando un elemento del value_array como valor de esa clave.

Italo Morales Fantone

teacher•

María Sierra

Cristian Camilo Echeverri

Alejandro González Ortega

Carlos Eduardo Gomez García

Usuario anónimo

user•

Mauricio Galvez

Brayan Olarte

Jorge Luis Lopez Santiz

Juan Sebastian Calderon

José Darío Bedoya Ortiz

Jonas Morales

Juan David Pérez Numa

Eduar Ivan Bernal Benavides

Diego Iván Cundapí León

Arlen Elian Ruiz Pedraza

Cesar Pesantez Carrión

Kenneth Angulo L

Guillermo Baldán López

Blad Zipt

AXEL MANUEL MOSQUEDA DE LA CRUZ

Jorge Enríquez

Manipulación de Datos en PHP: Arrays y Funciones

Datos

Curso actualizado

Manejo Avanzado de Datos y Funciones en PHP

Uso avanzado de comillas y variables en PHP

Extracción y Manipulación de Datos en PHP

Formato y Manipulación de Textos en PHP

Bases de Expresiones Regulares en PHP

Creación de Proyectos PHP con Composer y PHPUnit

Pruebas Automatizadas con PHP Unit y Composer

Funciones

Argumentos y Parámetros en Funciones PHP

Uso de "return" en Funciones PHP para Retornar Valores

Funciones Anónimas en Programación: Uso y Ejemplos Prácticos

Arrays

Manipulación de Arrays Simples en PHP

Arrays complejos en PHP: creación e iteración eficiente

Manipulación de Arrays en PHP: Funciones Clave y Ejemplos Prácticos

Comparación de Arrays en PHP: Uso de array_diff y Funciones Relacionadas

Unión y Manipulación de Arrays en JavaScript y PHP

Manipulación de Datos en PHP: Arrays y Funciones