Manual Imprescindible

CURSO DE PHP 8
Y MySQL 8

Luis Miguel Cabezas Granado

Francisco José González Lozano MULTIMEDIA
í ndice
de contenidos

Cómo usar este libro............................................................................. 18

Estructura de la guía.........................................................................................................19
Uso de los ejemplos..........................................................................................................21
2.3.6. Objeto..................................................................................................................59
2.3.7. Callable.................................................................................................................60
2.3.8. Iterable..................................................................................................................61
2.3.9. Valores nulos (NULL).......................................................................................62
2.3.10. Recurso..............................................................................................................63
2.3.11. Void.....................................................................................................................63
2.3.12. Unión.................................................................................................................64
2.3.13. Mixed.................................................................................................................65
2.4. Variables de variables................................................................................................66
2.5. Funciones de variables..............................................................................................67
2.5.1. isset() y unset()...................................................................................................67
2.5.2. is_integer(), is_double(), is_string(), is_array().............................................67
2.5.3. intval(), floatval(), strval()................................................................................67
2.5.4. Funciones matemáticas de precisión arbitraria.............................................68
2.6. Constantes...................................................................................................................69
2.6.1. defined()..............................................................................................................70
2.6.2. Constantes predefinidas...................................................................................70
2.7. Resumen......................................................................................................................71

1. Introducción a PHP 8 y MySQL 8...................................................... 22 3. Operadores....................................................................................... 72

3.1. Introducción................................................................................................................73
1.1. Introducción................................................................................................................23
3.2. Operadores de asignación.........................................................................................73
1.2. Instalación de PHP 8 y MySQL 8.............................................................................29
3.3. Operadores unarios...................................................................................................73
1.3. git..................................................................................................................................29
3.4. Operadores aritméticos.............................................................................................74
1.4. Docker..........................................................................................................................31
3.5. Operadores de comparación....................................................................................74
1.5. Dockerfile....................................................................................................................36
3.6. Operadores lógicos....................................................................................................75
1.6. docker-compose.........................................................................................................40
3.7. Operador ternario......................................................................................................76
1.7. Visual Studio Code....................................................................................................42
3.8. Operadores bit a bit...................................................................................................77
1.8. MySQL Workbench....................................................................................................45
3.9. Operadores de asignación combinados..................................................................78
1.9. Resumen......................................................................................................................48
3.10. Operador de ejecución.............................................................................................79
1.10. Recomendaciones.....................................................................................................49
3.11. Operador de coalescencia nulo..............................................................................79
2. Variables, tipos y constantes............................................................ 50 3.12. Operador nave espacial...........................................................................................80
3.13. Precedencia de operadores.....................................................................................81
2.1. Introducción................................................................................................................51
3.14. Resumen....................................................................................................................82
2.2. Variables......................................................................................................................51
2.3. Tipos.............................................................................................................................53 4. Estructuras de control....................................................................... 84
2.3.1. Enteros (integer)..................................................................................................54
4.1. Introducción................................................................................................................85
2.3.2. Número de coma flotante (float)......................................................................55
4.2. Estructuras de elección..............................................................................................85
2.3.3. Cadena de caracteres (string)...........................................................................56
4.2.1. if-else...................................................................................................................85
2.3.4. Valores binarios (boolean)..................................................................................57
4.2.2. Operador ternario..............................................................................................86
2.3.5. Arrays...................................................................................................................58

8 Índice de contenidos Índice de contenidos 9

 4.2.3. elseif.....................................................................................................................86
4.2.4. switch..................................................................................................................87
4.2.5. match...................................................................................................................89
4.3. Bucles...........................................................................................................................90
4.3.1. while....................................................................................................................90
4.3.2. do-while..............................................................................................................92
4.3.3. for.........................................................................................................................93
4.3.4. foreach.................................................................................................................96
4.4. break y continue.........................................................................................................97
4.5. Finalizar la ejecución de un programa....................................................................97
4.6. Sintaxis alternativa.....................................................................................................98
4.7. Resumen......................................................................................................................98
5. Funciones........................................................................................ 100
5.1. Funciones...................................................................................................................101
5.1.1. Valores de las funciones..................................................................................101
5.1.2. Función para obtener la fecha........................................................................102
5.1.3. Documentación sobre funciones...................................................................104
5.1.4. Definir funciones propias...............................................................................104
5.1.5. Ámbito de las variables..................................................................................106
5.1.6. Argumentos por defecto.................................................................................107
5.1.7. Argumentos variables.....................................................................................108
5.1.8. Argumentos con tipo definido.......................................................................109
5.1.9. Funciones con tipo definido...........................................................................110
5.1.10. Funciones anónimas......................................................................................110
5.1.11. Recursividad...................................................................................................110
5.1.12. Organizar el código....................................................................................... 111
5.2. Llamadas por valor..................................................................................................112
5.3. Llamadas por referencia..........................................................................................113
5.3.1. Referencia a variables.....................................................................................114
5.3.2. Funciones variables.........................................................................................114
5.4. Resumen....................................................................................................................115
5.5. Recomendaciones.....................................................................................................115
6. Cadenas de caracteres y expresiones regulares............................ 116
6.1. Introducción..............................................................................................................117
6.2. Propiedades de las cadenas....................................................................................118
6.2.1. Índices de string...............................................................................................118
6.2.2. Operadores.......................................................................................................119
6.2.3. Sintaxis para múltiples líneas........................................................................119
10 Índice de contenidos
6.3. Funciones de string..................................................................................................121
6.3.1. Tamaño de la cadena.......................................................................................121
6.3.2. Posición de los caracteres...............................................................................122
6.3.3. Conocer si existe el string...............................................................................123
6.3.4. Chequeo del principio y final de una cadena..............................................124
6.3.5. Comparación....................................................................................................124
6.3.6. Búsqueda de caracteres..................................................................................125
6.3.7. Selección de subcadenas.................................................................................125
6.3.8. Funciones de limpieza de cadenas................................................................127
6.3.9. Sustitución de cadenas....................................................................................127
6.3.10. Funciones de mayúsculas y minúsculas....................................................128
6.4. Expresiones regulares..............................................................................................129
6.4.1. Comprobar expresiones regulares................................................................132
6.4.2. Modificadores..................................................................................................132
6.4.3. Patrones de reemplazo....................................................................................133
6.5. Resumen....................................................................................................................134
6.6. Recomendaciones.....................................................................................................134
7. Conjunto de datos tipo array......................................................... 136
7.1. Introducción..............................................................................................................137
7.2. Creación de arrays....................................................................................................137
7.2.1. Asignación directa...........................................................................................137
7.2.2. array()................................................................................................................138
7.2.3. list()....................................................................................................................138
7.2.4. Funciones que devuelven arrays...................................................................139
7.3. Arrays multidimensionales.....................................................................................140
7.4. Propiedades de los arrays........................................................................................140
7.4.1. count()...............................................................................................................141
7.4.2. in_array()..........................................................................................................141
7.4.3. Borrar ocurrencias...........................................................................................142
7.4.4. Interactuar con arrays......................................................................................142
7.4.5. Funciones para avanzar en un array.............................................................144
7.4.6. Funciones para retroceder en un array.........................................................146
7.4.7. Intercambio de valores....................................................................................147
7.4.8. Inversión del contenido..................................................................................148
7.4.9. Mezcla de valores............................................................................................149
7.5. Pilas............................................................................................................................150
7.6. Ordenación de valores.............................................................................................151
7.7. Resumen....................................................................................................................152
Índice de contenidos 11
8. Formularios..................................................................................... 154
8.1. Introducción..............................................................................................................155
8.2. GET y POST..............................................................................................................155
8.2.1. Arrays.................................................................................................................159
8.3. Subir ficheros............................................................................................................162
8.4. Validación y saneamiento.......................................................................................167
8.4.1. Filtros de saneamiento....................................................................................167
8.4.2. Filtros de validación........................................................................................170
8.5. Resumen....................................................................................................................171
9. PHP orientado a objetos................................................................. 172
9.1. Introducción..............................................................................................................173
9.2. Definición de clase...................................................................................................173
9.3. Instancia de clase......................................................................................................175
9.3.1. Constructor.......................................................................................................176
9.3.2. Herencia ...........................................................................................................176
9.3.3. Redefinición de métodos................................................................................177
9.3.4. Valores y alcance de las variables..................................................................179
9.3.5. Miembros públicos, privados y protegidos.................................................180
9.3.6. Propiedades y métodos privados..................................................................180
9.3.7. Propiedades y métodos protegidos..............................................................181
9.3.8. Propiedades y métodos públicos..................................................................182
9.3.9. Interfaces...........................................................................................................182
9.3.10. Clases abstractas............................................................................................182
9.3.11. Final.................................................................................................................183
9.3.12. Clases con métodos estáticos.......................................................................184
9.3.13. Llamadas a funciones padre........................................................................185
9.3.14. Clases anónimas............................................................................................186
9.3.15. Rasgos.............................................................................................................186
9.3.16. Fluent Interface..............................................................................................187
9.4. Promoción de las propiedades del constructor ..................................................191
9.5. Argumentos con nombre ........................................................................................192
9.6. Espacios de nombre.................................................................................................193
9.6.1. Carga automática de clases............................................................................194
9.7. Atributos....................................................................................................................195
9.8. Métodos mágicos.....................................................................................................197
9.8.1. __toString().......................................................................................................198
9.8.2. __set()................................................................................................................198
9.8.3. __get()................................................................................................................198
9.9. Serialización..............................................................................................................198
12 Índice de contenidos
9.10. Resumen..................................................................................................................199
9.11. Recomendaciones...................................................................................................199
10. Código limpio y principios SOLID................................................ 200
10.1. Introducción............................................................................................................201
10.2. Código limpio.........................................................................................................201
10.2.1. El código malo hace demasiadas cosas,
el código limpio es enfocado.......................................................................201
10.2.2. El lenguaje con el que se escribe el código debería parecer
que fue hecho para resolver el problema...................................................201
10.2.3. El código no debe ser redundante...............................................................202
10.2.4. Debe ser placentero leer el código..............................................................202
10.2.5. Puede ser extendido fácilmente por otro desarrollador..........................202
10.2.6. Debe tener dependencias mínimas.............................................................202
10.2.7. Cuanto más pequeño, mejor........................................................................203
10.2.8. Debe tener pruebas unitarias y de aceptación..........................................203
10.2.9. Debe ser expresivo........................................................................................203
10.3. Principios SOLID....................................................................................................203
10.3.1. Principio de responsabilidad única (SRP).................................................204
10.3.2. Principio abierto/cerrado (OCP)................................................................207
10.3.3. Principio de sustitución de Liskov (LSP)...................................................212
10.3.4. Principio de segregación de interfaz (ISP).................................................213
10.3.5. Principio de inversión de dependencias (DIP)..........................................215
10.4. Resumen..................................................................................................................216
10.5. Recomendaciones...................................................................................................216
11. Patrones de diseño....................................................................... 218
11.1. Introducción............................................................................................................219
11.2. Patrones de creación..............................................................................................219
11.2.1. Patrón de creación Singleton........................................................................220
11.2.2. Patrón de creación Factory Method............................................................221
11.2.3. Patrón de comportamiento Observer.........................................................224
11.2.4. Patrón estructural Decorator........................................................................226
11.3. Resumen..................................................................................................................229
11.4. Recomendaciones...................................................................................................229
12. MySQL básico............................................................................... 230
12.1. ¿Qué es MySQL?....................................................................................................231
12.2. MySQL Workbench................................................................................................232
12.3. Manejar esquemas..................................................................................................236
Índice de contenidos 13
 12.4. Tipos de datos.........................................................................................................239
12.5. Tablas.......................................................................................................................241
12.5.1. Crear una tabla...............................................................................................241
12.5.2. Crear registros................................................................................................246
12.5.3. Actualizar y eliminar registros....................................................................247
12.6. Relaciones................................................................................................................249
12.7. Conclusión..............................................................................................................257
13. Índices y consultas........................................................................ 258
13.1. Índices......................................................................................................................259
13.1.1. Crear un índice...............................................................................................259
13.1.2. Claves primarias............................................................................................263
13.1.3. Índice FULLTEXT..........................................................................................265
13.2. Consultar una base de datos MySQL..................................................................266
13.2.1. SELECT...........................................................................................................266
13.2.2. SELECT COUNT...........................................................................................267
13.2.3. SELECT DISTINCT.......................................................................................269
13.2.4. DELETE...........................................................................................................270
13.2.5. WHERE...........................................................................................................271
13.2.6. LIMIT...............................................................................................................272
13.2.7. MATCH AGAINST.......................................................................................274
15. CRUD de PHP con MySQL............................................................ 310
13.2.8. UPDATE..........................................................................................................275
13.2.9. ORDER BY......................................................................................................276
13.2.10. GROUP BY....................................................................................................277
13.3. Cruzar tablas...........................................................................................................278
13.3.1. NATURAL JOIN............................................................................................280
13.3.2. JOIN ON.........................................................................................................281
13.3.3. Usar AS...........................................................................................................281
13.4. Operadores lógicos................................................................................................283
13.5. Funciones MySQL..................................................................................................283
13.5.1. CONCAT........................................................................................................283
13.5.2. CONCAT_WS................................................................................................284
13.5.3. LENGTH.........................................................................................................284
13.5.4. LOWER y UPPER..........................................................................................284
13.5.5. REPLACE........................................................................................................284
13.5.6. TRIM................................................................................................................285
13.5.7. CURDATE......................................................................................................285
13.5.8. DATE_FORMAT............................................................................................285
13.5.9. DAY, MONTH y YEAR.................................................................................285
13.6. Resumen..................................................................................................................286
14 Índice de contenidos
14. Normalización y transacciones..................................................... 288
14.1. Introducción............................................................................................................289
14.1.1. Claves primarias............................................................................................290
14.2. Normalización........................................................................................................291
14.2.1. Primera forma normal..................................................................................292
14.2.2. Segunda forma normal.................................................................................294
14.2.3. Tercera forma normal....................................................................................297
14.2.4. Cuándo no usar normalización...................................................................299
14.3. Relaciones................................................................................................................300
14.3.1. Uno-a-uno.......................................................................................................300
14.3.2. Uno‑a-muchos................................................................................................301
14.3.3. Muchos‑a‑muchos.........................................................................................302
14.4. Transacciones..........................................................................................................304
14.4.1. Motores de almacenamiento de transacciones..........................................304
14.4.2. Usar BEGIN....................................................................................................306
14.4.3. Usar COMMIT...............................................................................................307
14.4.4. Usar ROLLBACK...........................................................................................307
14.5. Resumen..................................................................................................................308
15.1. Introducción............................................................................................................311
15.2. Extensiones MySQL...............................................................................................311
15.3. Conexión a MySQL................................................................................................312
15.4. Consultar datos......................................................................................................315
15.4.1. Acceso a todos los registros..........................................................................315
15.4.2. Configuración................................................................................................318
15.4.3. Routing.............................................................................................................319
15.4.4. Diseño limpio.................................................................................................322
15.4.5. Mostrar el resultado de la consulta.............................................................330
15.5. Manipulación de datos..........................................................................................334
15.5.1. Insertar una fila..............................................................................................334
15.5.2. Modificar una fila..........................................................................................339
15.5.3. Borrar una fila................................................................................................345
15.6. Contar filas..............................................................................................................347
15.6.1. Usar PHP........................................................................................................348
15.6.2. Usar la extensión Mysqli..............................................................................348
15.6.3. Último número insertado.............................................................................349
15.7. Resumen..................................................................................................................350
Índice de contenidos 15
16. Testing........................................................................................... 352 18.3. Plantillas con Blade................................................................................................410
18.3.1. Componentes iniciales..................................................................................412
16.1. Introducción............................................................................................................353
18.4. Creación del modelo..............................................................................................415
16.2. Test unitarios...........................................................................................................353
18.5. Creación de las rutas..............................................................................................419
16.3. PHPUnit..................................................................................................................355
18.6. CRUD con Laravel.................................................................................................422
16.3.1. Composer........................................................................................................357
18.6.1. CREATE. Creación de registros...................................................................422
16.3.2. Primeras pruebas...........................................................................................358
18.6.2. Creación de registro en la API.....................................................................426
16.3.3. Patrón AAA....................................................................................................362
18.6.3. LIST. Listado de los registros.......................................................................426
16.3.4. Fixtures............................................................................................................363
18.6.4. DELETE. Borrar un usuario.........................................................................430
16.4. Dobles de prueba...................................................................................................364
18.6.5. Enlaces del menú...........................................................................................431
16.5. Unit Test are FIRST..................................................................................................368
18.6.6. Mensajes de alerta.........................................................................................432
16.5.1. Fast (Rápido)..................................................................................................368
18.6.7. EDIT. Editar un usuario................................................................................435
16.5.2. Isolated (Independiente)................................................................................368
18.7. Resumen..................................................................................................................440
16.5.3. Repeateable (Repetible)...................................................................................369
18.8. Recomendaciones...................................................................................................440
16.5.4. Selfverifying (Autoverificable)......................................................................369
16.5.5. Timely (Oportuno).........................................................................................369 Índice alfabético.................................................................................. 442
16.6. TDD: Test-Driven Development (Desarrollo guiado por pruebas)....................370
16.7. Cobertura.................................................................................................................381
16.8. Resumen..................................................................................................................382

17. React............................................................................................. 384

17.1. Introducción............................................................................................................385
17.2. Primeros pasos........................................................................................................385
17.3. Componentes..........................................................................................................388
17.3.1. Crear un nuevo componente.......................................................................389
17.3.2. Propiedades de los componentes................................................................390
17.4. Estado del componente.........................................................................................391
17.5. Efectos......................................................................................................................393
17.5.1. Recorrer las noticias con map......................................................................397
17.5.2. Cargando........................................................................................................400
17.6. Resumen..................................................................................................................402
17.7. Recomendaciones...................................................................................................402

18. Laravel 8........................................................................................ 404

18.1. Introducción............................................................................................................405
18.2. Primeros pasos con Laravel 8...............................................................................405
18.2.1. Integración con React....................................................................................407
18.2.2. Rutas................................................................................................................408
18.2.3. Controladores.................................................................................................409

16 Índice de contenidos Índice de contenidos 17


Figura 1.6. Descarga de Docker (fuente: https://docker.com).
Para comprobar que Docker está instalado, tendremos que utilizar un terminal,
que no es más que una aplicación del sistema operativo que permite escribir
comandos. Acostúmbrese a utilizar comandos desde el principio, va a ser muy
necesario el día que quiera desplegar aplicaciones en la nube.
En Windows 10 se puede abrir el terminal desde la caja inferior de búsqueda
escribiendo terminal o cmd. En macOS se puede buscar en Spotlight la palabra
terminal.
Para comprobar que todo está correcto, debemos escribir el comando docker
version y obtendremos algo parecido a la figura 1.7.
Evidentemente, no debe tener en cuenta las versiones que le aparezcan, Docker
se actualiza muy a menudo y seguramente no sean iguales a las de la figura 1.6.
Conceptualmente, un contenedor es un entorno aislado donde se pueden
ejecutar aplicaciones. Se les suele comparar con máquinas virtuales (VirtualBox,
WMWare), pero las máquinas virtuales necesitan un sistema operativo completo
para funcionar. Un contenedor tan solo necesita un pequeño núcleo (kernel) y
una capa de aislamiento, el resto de recursos los obtiene del sistema operativo
anfitrión; por lo tanto, los contenedores suelen ser muy livianos y ligeros.
32 Capítulo 1
Figura 1.7. docker version.
Podemos pensar que un contenedor es una especie de caja donde guardar y
ejecutar aplicaciones, pero esas aplicaciones debemos sacarlas antes de algún
sitio. El otro concepto básico en Docker son las imágenes. Una imagen es un
paquete de software que sirve como base para un contenedor. Hay imágenes de
todo tipo: PHP, MySQL, Apache, WordPress, etc. Como ejemplo puede probar a
instalar una imagen creada para este libro con el siguiente comando:
docker run -d hazardco/anaya-php8:v1.0.1
Docker intenta localizar esa imagen dentro de su disco duro. Si no la encuentra,
la busca en una base de datos de imágenes llamada dockerhub (https://hub.
docker.com) y la descarga. Cuando ya está la imagen en el disco, procede a
ejecutarla en segundo plano gracias al parámetro -d. Puede ver el resultado en
la figura 1.8.
Después de ejecutar la imagen de PHP 8, lo que obtenemos es un contenedor
que está iniciado, pero que no es visible a priori. Además del contenedor que está
ejecutándose, Docker guarda de forma local una copia de la imagen descargada.
Se puede obtener un listado de imágenes con el comando:
docker image list
Introducción a PHP 8 y MySQL 8 33
 ADVERTENCIA: Ejemplo Nombre Resultado
No hay que confundir el operador de asignación (=) con el operador de comparación, $a < $b Menor que true si $a es menor que $b
doble igual (==), sobre todo en bucles de control, donde sería algo complicado encontrar $a > $b Mayor que true si $a es mayor que $b
el error. $a <= $b Menor o igual true si $a es menor o igual a $b
$a >= $b Mayor o igual true si $a es mayor o igual a $b

3.4. Operadores aritméticos El código siguiente es un típico ejemplo de utilización de operadores de compa-
ración. En la figura 3.1, puede ver el resultado.
Este tipo de operador forma parte de la aritmética básica. Le resultará familiar
<?php
porque son símbolos muy utilizados en el aprendizaje de las matemáticas. $a = 23; // Asignación de los valores
$b = 75;
Tabla 3.1. Operadores aritméticos. if ( $a >= $b ) { // La condición no se cumple. El resultado es false
echo "Esta parte no se ejecuta";
Ejemplo Nombre Resultado } else {
echo "La comparación es FALSE porque $a es menor que $b";
$a + $b Suma Suma dos valores }
$a - $b Resta Resta dos números
$a * $b Multiplicación Producto de variables
$a / $b División Cociente entre dos variables
$a % $b Módulo Resto de la división de $a entre $b

NOTA:
Figura 3.1. Operador de comparación.
PHP ignora los espacios en blanco entre las variables y los operadores. Aunque $a + $b
es equivalente a $a+$b, es preferible utilizar la primera forma, porque es más legible.

3.6. Operadores lógicos

3.5. Operadores de comparación Durante el desarrollo de su proyecto, puede encontrarse con situaciones en las
que necesite hacer varias comparaciones seguidas para que se cumpla una deter-
En algunos ejemplos del capítulo anterior puede ver que se utiliza la estructura minada condición. PHP permite unir todas las comparaciones en una mediante
de control if ... else. Como verá más adelante, esta estructura compara dos el uso de operadores lógicos. Es posible encadenar varias comparaciones juntas
valores y elige el camino a seguir dentro del código. El resultado siempre es mediante este tipo de operadores.
true o false.
Tabla 3.3. Operadores lógicos.
Tabla 3.2. Operadores de comparación.
Ejemplo Nombre Resultado
Ejemplo Nombre Resultado
expresión1 and expresión2 Y true si las dos expresiones son verdaderas
$a == $b Igual Verdadero si los dos son iguales
expresión1 && expresión2 Y true si las dos expresiones son verdaderas
$a === $b Identidad Verdadero si son iguales y del mismo tipo
expresión1 or expresión2 O true si una de las expresiones es verdadera
$a != $b Distinto Verdadero si las dos variables son distintas

74 Capítulo 3 Operadores 75
5
5.1. Funciones
Las funciones son grupos de instrucciones independientes que tienen un propó-
sito determinado. De esta manera, tenemos funciones que calculan la raíz
cuadrada de un número, nos dan un número aleatorio o permiten contar los
caracteres de una palabra.

Funciones La sintaxis básica de una función es la que se describe a continuación:

function nombre_función(parámetro1, parámetro2, parámetro3...parámetro_n)

Las funciones pueden ser llamadas con varios parámetros o con ninguno, depen-
diendo de su definición. Cuando PHP encuentra en el código la llamada a una
función, primero evalúa cada argumento y los utiliza como parámetro de entrada.
Después, ejecuta la función y devuelve el valor solicitado o realiza alguna acción
sin enviar ningún valor de salida.
El siguiente ejemplo contiene un conjunto de llamadas a funciones con 0, 1 o 2 pará-
metros de entrada:
<?php
echo "Marca de tiempo: ".time() . "<br/>";
echo "Raíz cuadrada de 9: ".sqrt(9) . "<br/>";
echo "Número aleatorio entre 10 y 20: ".rand(10, 20) . "<br/>";
echo "Número pi: ".pi();

5.1.1. Valores de las funciones

En este capítulo aprenderás:
• Qué es y para qué sirve una función
• Funciones de fecha
• Definir funciones
• Ámbito de variables
• Cómo se pueden definir argumentos de función
• Qué son las funciones anónimas
• Recursividad
Cada función en PHP se considera como una expresión. Se pueden utilizar las
funciones para lo mismo que se utilizan las expresiones, como por ejemplo alma-
cenar su resultado en una variable o formar parte de una expresión más compleja.
El ejemplo siguiente llama a la función rand(), que devuelve un número alea-
torio que esté entre los dos números que se pasan como parámetro.
<?php
$numero_aleatorio = rand(1, 100);
echo $numero_aleatorio;
Si crea un fichero con este código y lo ejecuta, obtendrá un valor entero
entre 1 y 100. Cada vez que actualice el navegador, obtendrá un número distinto.
No todas las funciones devuelven un valor numérico. También pueden devolver
caracteres, arrays o TRUE/FALSE si la función ha tenido éxito o no. Este tipo de
funciones se utiliza para conectar a bases de datos, escribir en ficheros de texto,
manipular imágenes, etcétera.
Una base de datos MySQL contiene una o más tablas, cada una de las cuales
contiene registros o filas. Dentro de estas filas, hay varias columnas o campos que
contienen los datos en sí. Como ejemplo, la siguiente tabla muestra el contenido
de una base de datos de ejemplo de cinco publicaciones que detallan el autor, el
título y el año de la publicación.
Tabla 12.1. Ejemplo de una base de datos.
En este capítulo utilizaremos esa aplicación para conocer las principales carac-
terísticas de MySQL. En la figura  12.1 puede observar la pantalla inicial de
MySQL Workbench, que incluye la conexión al servidor MySQL que configuró
en el capítulo 1.

Autor Título Año

Robert C. Martin Código limpio 2012
Steve Krug No me hagas pensar 2015
Aurélien Géron Aprende Machine Learning 2020

Cada fila de la tabla es igual a una fila de una tabla MySQL, cada columna corres-
ponde a una columna en MySQL y cada elemento dentro de una fila es igual a
un campo MySQL.
En este capítulo utilizará un tipo de base de datos relacional. Este tipo de base
de datos es gestionado por un software que se conoce como Sistema gestor de
base de datos relacional (SGBDR), que es el responsable de controlar las bases
de datos, sus componentes, mantener la integridad de los datos, los usuarios
que acceden, de recibir las consultas de petición, creación y actualización de la
información y muchas otras funcionalidades.
El SGBDR que utilizaremos se llama MySQL, que está disponible como código
abierto bajo licencia GPL. MySQL es un sistema de administración de bases
de datos relacionales cliente/servidor, es decir, existe como una aplicación de
Figura 12.1. Vista inicial de MySQL Workbench.
software instalada y funcionando en una o múltiples máquinas en una red, que
sirve información a través de esa red a aplicaciones de software instaladas en otras
máquinas que solicitan datos o los envían para ser almacenados. Por lo tanto, lo En la vista de esta figura puede observar la distribución de los diferentes
más habitual es tener la versión servidor (MySQL Server) en una máquina en la elementos que componen el entorno de trabajo de MySQL Workbench. En la
red, que será donde almacenamos nuestros datos. zona de la izquierda, hay una columna con varios iconos con los que interac-
tuar para acceder rápidamente a algunas funcionalidades. El que muestra una
Es necesario tener una versión cliente que acceda al servidor para enviar y recibir
casa nos lleva a la pantalla inicial. Justo debajo, el icono del delfín nos permite
datos. Como verá más adelante, con PHP ya viene incluida una extensión para
acceder a las diferentes conexiones. A continuación, el icono de diagrama
trabajar como cliente de MySQL.
muestra una zona donde crear modelos, es decir, modelar gráficamente la
base de datos utilizando diagramas. Y, por último, la flecha encerrada en un
12.2. MySQL Workbench círculo nos lleva a un apartado para poder realizar migraciones utilizando un
asistente. Una migración nos permite transformar una base de datos de otro
En el capítulo  1 aprendimos a instalar PHP y MySQL; por lo tanto, ya tiene gestor de bases de datos relacionales como PostgreSQL hacia MySQL y vice-
disponible el servidor de MySQL en su sistema. También vimos cómo instalar versa. En el apartado de conexiones aparece la conexión que creamos en el
una aplicación cliente de escritorio que nos servirá para gestionar las bases de capítulo 1, Curso PHP8. Haga clic en ella para abrir el editor de MySQL que
datos de nuestros proyectos: MySQL Workbench. tiene el aspecto mostrado en la figura 12.2.

232 Capítulo 12 MySQL básico 233

Se comprobará de nuevo el acceso al esquema seleccionado, haga clic en Continue
y finalmente le mostrará la vista para confirmar la importación de las tablas de
ese esquema. También ofrece la posibilidad de escoger qué tablas desea que sean
importadas al modelo utilizando la opción Show Filter. Haga clic en el botón
Execute para realizar la importación. A continuación, se le mostrará el resultado
de ese proceso, haga clic en Continue para llegar a la vista de resumen completo
del proceso y cierre la ventana haciendo clic en Close. Puede ver el resultado
en la figura 12.17. Tiene la tabla Contactos dibujada como un rectángulo con el
nombre de la tabla y la lista de campos con su tipo.
Figura 12.18. Añadir una tabla al diagrama.

Figura 12.17. Importación de nuestro esquema a un modelo.

Para añadir la tabla Reuniones, haga clic en el icono de tabla del menú que se
encuentra junto al borde del diagrama y después haga clic en cualquier zona del
diagrama, como se ve en la figura 12.18.
Se creará una nueva tabla con el nombre table 1. Haga doble clic en ella para ver
sus propiedades y así poder cambiarlas. El proceso de modificar el nombre y los
campos de la tabla es el mismo que vimos cuando creamos la tabla Contactos. En
la figura 12.19 puede ver el resultado. Observe que no hemos creado el campo
contactos_id, lo creará a continuación utilizando el diagrama.
Figura 12.19. Configuración de la tabla Reuniones.
Ha llegado al paso más importante, el de la creación de la relación entre ambas
tablas. Para ello, tiene que decidir en primer lugar qué tipo de relación va a
establecer. Las tablas se pueden relacionar de muchas maneras. De una forma
general, sin entrar en detalles de registros que no se relacionan con ninguno de
otras tablas, una clasificación resumida de las relaciones puede ser:

252 Capítulo 12 MySQL básico 253

 Tabla 14.8. Tabla Clientes en tercera forma normal. Aunque usar la tercera forma normal de esta manera puede parecer demasiado
Id Nombre Dirección Código Postal exhaustivo, puede aprovecharse de ciertas ventajas. Por ejemplo, eche un vistazo
a la tabla 14.11, donde se ha podido incluir tanto el nombre de una provincia
1 Javier Arroyo Arias C\Felipe Sanz, 34 28001
como su abreviatura de dos letras. También podría contener detalles de pobla-
2 Francisco Martínez Av. Alan Turing, 67 10600
ción y otros datos demográficos, si lo desea.
3 Guillermo Ródena C\Robert C. Martin, 25 46700
En ocasiones, puede ser difícil decidir si usar la tercera forma normal. Para ello,
4 Gabriel Villena Díaz C\Marquesa Pinares, 4 06800 debe tener claro si va a necesitar añadir datos en el futuro. Si es seguro que, en
el caso de los clientes, todo lo que va a necesitar son su nombre y su dirección,
Tabla 14.9. Tabla Códigos Postales en tercera forma normal. probablemente querrá dejar fuera esta etapa final de normalización.
Código Postal Localidad Id Por otra parte, supongamos que está escribiendo una base de datos para una
28001 1234
gran organización como el servicio de Correos. ¿Qué pasaría si se cambiara el
nombre de una localidad? Con una tabla como la tabla 14.6, habría que realizar
10600 5678
una búsqueda global y reemplazar cada instancia de esa localidad. Pero, si tiene
46700 4321
su base de datos diseñada para cumplir con la tercera forma normal, tendría que
06800 8765 cambiar solo una entrada en la tabla 14.10 para que el cambio se reflejara en toda
la base de datos.
Tabla 14.10. Tabla Localidades en tercera forma normal. Por lo tanto, le sugerimos que se haga dos preguntas que le ayudarán a decidir
Localidad Id Nombre Provincia Id si debe llegar a normalizar hasta la tercera forma normal en cualquier tabla:
1234 Madrid 28 • ¿Es probable que en el futuro haya que añadir muchas columnas nuevas a
5678 Plasencia 10 esta tabla?
4321 Gandía 43
• ¿Podría cualquiera de los campos de esta tabla requerir una actualización
8765 Mérida 06 global en cualquier momento?
Si alguna de las respuestas es afirmativa, probablemente debería considerar la
Tabla 14.11. Tabla Provincias en tercera forma normal.
posibilidad de realizar esta etapa final de normalización.
Provincia Id Nombre Abreviatura
28 Madrid MA
10 Cáceres CC
14.2.4. Cuándo no usar normalización
43 Valencia VA Ahora que ya conoce qué es la normalización y las formas normales, a continua-
06 Badajoz BA ción, le contamos por qué debería tirar estas reglas a la basura cuando se trate de
sitios con tráfico alto. Así es, nunca debe normalizar completamente sus tablas
Bueno, hemos pasado de tratar una sola tabla, la 14.6, a disponer de un total de en sitios donde esta normalización exhaustiva pueda provocar que MySQL se
cuatro. Aunque parece que esto complica la búsqueda, no se abrume. Primero, caiga, es decir, se bloquee y deje de dar servicio.
usaría el código postal en la tabla 14.8 (Clientes) para encontrar el identificador Como ha podido comprobar, la normalización requiere diseminar los datos
de la localidad en la tabla 14.9 (Códigos Postales). Con esta información, podría a través de múltiples tablas. Esto implica que es necesario hacer múltiples
buscar el nombre de la localidad en la tabla 14.10 (Localidades) y, finalmente, el llamadas a MySQL por cada consulta. En un sitio muy popular, si tiene tablas
código de la provincia, que podría usar en la tabla 14.11 (Provincias) para obtener de tamaño normal, el acceso a su base de datos se ralentizará considerable-
el nombre de la provincia. mente una vez que supere unas pocas docenas de usuarios simultáneos, porque

298 Capítulo 14 Normalización y transacciones 299

17
React
En este capítulo aprenderás:
• Qué es React
• Crear y utilizar componentes React
• Algunos efectos interesantes
• Practicar React con algunos ejemplos básicos
17.1. Introducción
Durante mucho tiempo, las aplicaciones escritas en PHP siempre han ido acom-
pañadas de alguna biblioteca JavaScript para ayudar a la parte visual a ser más
atractiva y aportar una funcionalidad extra. En nuestro libro anterior, Desarrollo
web con PHP y MySQL. Edición 2018, describimos cómo utilizar jQuery, una de
las bibliotecas más utilizadas en el desarrollo web. A partir de 2018 comenzaron
a despuntar una serie de utilidades que planteaban la interacción con el usuario
de una forma distinta a como lo venía haciendo JavaScript de forma clásica.
También conocimos que uno de los frameworks más utilizados de CSS, Bootstrap,
abandonaba el uso de jQuery a favor de otra biblioteca más purista. Todo esto nos
ha hecho decantarnos por React, una biblioteca JavaScript moderna que potencia
la experiencia de uso de la web y que se acopla perfectamente en los frameworks
modernos de PHP como Laravel.
React está desarrollado por Facebook y es tan extenso como el propio PHP;
podríamos escribir un libro entero sobre su funcionamiento. En este capítulo,
veremos la parte esencial para que pueda utilizarlo junto a sus proyectos PHP
y, sobre todo, para que tenga una base para el siguiente capítulo sobre Laravel.
17.2. Primeros pasos
Al igual que PHP utiliza composer como sistema de paquetes, el ecosistema de
JavaScript utiliza npm para gestionar la descarga de nuevas características y utili-
dades. En la imagen Docker de PHP, ya está todo listo para crear aplicaciones
escritas con React. Entre en esta imagen a través de Visual Studio Code haciendo
clic con el botón derecho sobre la imagen y eligiendo la opción Attach Shell.
Figura 17.1. Conexión con la imagen Docker de PHP.
CURSO DE PHP 8 Y MySQL 8

Manual Imprescindible

PHP es uno de los lenguajes más utilizados en Internet y está presente en aplicaciones muy
conocidas como WordPress, Joomla, Moodle o el propio Facebook. Desde sus inicios fue creado
pensando en la sencillez de uso y en facilitar una curva de aprendizaje gradual al programador.
MySQL es el sistema de gestión de bases de datos más popular y extendido en la actualidad.
Este libro es ideal para aprender de forma gradual a dominar las nuevas versiones de PHP y MySQL.
Cubre todos los aspectos necesarios para aprender PHP 8, una evolución del lenguaje original en
la que se han invertido numerosos años en mejorar todos los aspectos tecnológicos del lenguaje,
modernizándolo constantemente. También MySQL 8 incorpora muchas novedades como el
soporte para UTF8, el formato JSON, funcionalidades GIS y mucho más.
El libro puede dividirse en varios apartados lógicos: una primera parte como introducción a lo que
se puede hacer con PHP seguida de una descripción de MySQL como motor principal de bases de
datos. Una tercera parte que añade capítulos donde se mezclan PHP y MySQL y una última sobre
aspectos avanzados. Además, cuenta con un capítulo introductorio a Laravel 8 para elevar tus
conocimientos de PHP a la máxima potencia con este framework.

2311362

MULTIMEDIA www.anayamultimedia.es