# Mòdul 0376 - Implantació d'aplicacions web
**Cicle formatiu:** Administració de Sistemes Informàtics en Xarxa (ASIX)
**Durada:** 99 h (66 h centre + 33 h empresa)
**Entorn:** Ubuntu Server 26.04
# RA5 - Genera documents web utilitzant llenguatges de guions de servidor.
## 1. Llenguatges de guions de servidor
### Concepte
Un **llenguatge de guions de servidor** (*server-side scripting language*) és un llenguatge de programació que s'executa al servidor web, no al navegador del client. Quan un usuari sol·licita una pàgina, el servidor executa el codi, genera HTML dinàmic i l'envia al client. El client **mai no veu el codi font** del servidor, només el resultat HTML.
### Principals llenguatges de servidor
| Llenguatge | Característiques principals | Usos habituals |
|---|---------|------|
| **PHP** | Codi obert, molt estès, integrat en Apache/Nginx, orientat al web | WordPress, Drupal, Laravel |
| **Python** | Llegible, gran ecosistema (Django, Flask, FastAPI) | Aplicacions web, data science |
| **Node.js** | JavaScript al servidor, arquitectura basada en esdeveniments, no bloquejant | APIs REST, aplicacions en temps real |
| **Java** | Robust, tipat, gran rendiment (Spring Boot, Jakarta EE) | Aplicacions empresarials |
| **Ruby** | Expressiu, convencions sobre configuració (Ruby on Rails) | Prototips, startups |
| **ASP.NET** | Ecosistema Microsoft, C# o VB.NET | Entorns corporatius Windows |
| **Go** | Compilat, molt ràpid, concurrent | Microserveis, APIs d'alt rendiment |
### Per què PHP?
PHP (*Hypertext Preprocessor*) és el llenguatge de servidor més usat al web per diverses raons:
- Present en el **73% dels llocs web** que usen un llenguatge de servidor conegut (dades de desembre de 2025) [benjamincrozat.com
](https://benjamincrozat.com/php-is-dead-2025).
- Gratuït, de codi obert i amb una comunitat enorme.
- Instal·lat per defecte en la majoria de serveis d'allotjament.
- Integrat nativament amb els servidors Apache i Nginx.
- Base de WordPress, que alimenta el **43% de tots els llocs web**.
- La versió 8.x aporta millores significatives de rendiment i noves funcionalitats.
## 2. Integració amb els llenguatges de marques
### PHP i HTML
PHP es pot barrejar directament amb HTML. El servidor processa el codi PHP i retorna HTML pur al client:
```php
<?php echo htmlspecialchars($titol); ?>
```
> El client (navegador) rep únicament el resultat HTML generat, mai el codi PHP.
### PHP i CSS
PHP pot generar CSS dinàmic o injectar classes i estils condicionals:
```php
```
### PHP i JavaScript
PHP pot generar codi JavaScript o passar dades a JS via JSON:
```php
'Joan',
'rol' => 'admin',
'permisos' => ['llegir', 'escriure']
];
?>
```
### PHP i formularis HTML
PHP processa les dades enviades pels formularis HTML (vegeu la [secció 9](#formularis-introducció-dinformació)).
### Model de separació de capes (MVC bàsic)
En projectes més grans, és recomanable separar:
```ini
index.php ← Controlador: rep la petició, crida la lògica, decideix la vista
models/usuari.php ← Model: lògica de negoci, accés a BD
views/inici.php ← Vista: HTML amb mínim PHP (sols echo i if)
config/bd.php ← Configuració: credencials, constants
```
## 3. Sintaxi bàsica
### Etiquetes PHP
```php
```
> Usa sempre ` Si un fitxer és 100% PHP (sense HTML), **omet l'etiqueta de tancament** `?>` per evitar espais en blanc involuntaris que podrien causar errors amb les capçaleres HTTP.
### Regles bàsiques
- Instruccions acaben amb **punt i coma** (`;`).
- Paraules clau i funcions: **no** distingeixen majúscules (`echo`, `ECHO`, `Echo` → equivalent).
- Variables: **sí** que distingeixen majúscules (`$nom` ≠ `$Nom`).
### Variables
```php
```
### Scope de les variables
```php
```
> [!CAUTION]
> Usar `global` dins funcions és una mala pràctica. Millor passar-la com a paràmetre.
### Tipus de dades
| Tipus | Exemple | Notes |
|---|---|---|
| `string` | `"Hola"` | Mutable, implementada com array de bytes |
| `int` | `42`, `0xFF`, `0b1010` | 32 o 64 bits, amb signe |
| `float` | `3.14`, `1.5e3` | Igual que `double` |
| `bool` | `true`, `false` | |
| `array` | `[1, 2, 3]` | Array associativa generalment |
| `object` | `new Classe()` | |
| `null` | `null` | Variable no assignada |
| `resource` | `fopen(...)` | Referència a recurs extern |
**Truthiness** — avaluació com a booleà:
| Valor | Avalua com |
|---|---|
| `''`, `'0'`, `0`, `0.0`, `null`, `[]` | `false` |
| Qualsevol altre valor | `true` |
### Constants
```php
```
## 4. Eines d'edició de codi
### Editors i IDEs recomanats
| Eina | Tipus | Característiques |
|---|---|---------|
| **Visual Studio Code** | Editor lleuger | Extensió PHP Intelephense, debugging integrat, Git, terminal |
| **PhpStorm** | IDE complet | Autocompleció avançada, refactoring, debugging natiu, BD integrada |
| **Sublime Text** | Editor lleuger | Ràpid, connectors PHP disponibles |
| **NetBeans** | IDE | Suport PHP integrat, gratuït |
| **Vim / Neovim** | Editor terminal | Alta productivitat un cop après, ideal per a servidors remots |
### Configuració recomanada per a VS Code
Extensions útils:
- **PHP Intelephense** — autocompleció, navegació, detecció d'errors.
- **PHP Debug** (Xdebug) — debugging pas a pas.
- **PHP CS Fixer** — formatació automàtica de codi (PSR-12).
- **GitLens** — integració Git avançada.
- **Thunder Client** — provar APIs REST sense sortir de l'editor.
Fitxer `.vscode/settings.json` recomanat:
```json
{
"php.validate.executablePath": "/usr/bin/php",
"editor.formatOnSave": true,
"[php]": {
"editor.defaultFormatter": "bmewburn.vscode-intelephense-client"
},
"intelephense.environment.phpVersion": "8.2.0"
}
```
### Entorn de les pràctiques: Ubuntu 26.04 + Apache + MariaDB
Les pràctiques d'aquest mòdul es faran sobre una màquina virtual amb **Ubuntu 26.04 LTS** i un servidor **LAMP** (Linux + Apache + MariaDB + PHP). Aquesta és la configuració de referència per a totes les activitats.
**Instal·lació de l'entorn LAMP a Ubuntu 26.04:**
```bash
# Actualitzar el sistema
sudo apt update && sudo apt upgrade -y
# Instal·lar Apache
sudo apt install apache2 -y
sudo systemctl enable apache2
sudo systemctl start apache2
# Instal·lar MariaDB
sudo apt install mariadb-server -y
sudo systemctl enable mariadb
sudo systemctl start mariadb
sudo mysql_secure_installation # configuració inicial de seguretat
# Instal·lar PHP i els mòduls necessaris per a WordPress i projectes propis
sudo apt install php libapache2-mod-php php-mysql php-mbstring \
php-xml php-curl php-zip php-gd php-intl php-bcmath php-imagick -y
# Reiniciar Apache per carregar el mòdul PHP
sudo systemctl restart apache2
```
**Directori arrel del servidor web:**
```bash
/var/www/html/ ← aquí es posen els fitxers PHP dels projectes
```
**Comprovar les versions instal·lades:**
```bash
apache2 -v # versió d'Apache
php -v # versió de PHP
mariadb --version # versió de MariaDB
```
**Gestió dels serveis:**
```bash
sudo systemctl start|stop|restart|status apache2
sudo systemctl start|stop|restart|status mariadb
```
**Verificar la instal·lació de PHP al navegador:**
Crea el fitxer `/var/www/html/info.php` amb:
```php
```
Accedeix a `http://localhost/info.php`. Esborra'l un cop verificat per seguretat.
Per veure les extensions carregades:
```php
```
**Servidor integrat de PHP (per a proves ràpides puntuals):**
```bash
php -S localhost:8080
```
## 5. Elements del llenguatge
### Operadors
**Aritmètics:**
```php
$a = 10; $b = 3;
echo $a + $b; // 13
echo $a - $b; // 7
echo $a * $b; // 30
echo $a / $b; // 3.333... (NOTA: no és divisió entera com a Java o Python)
echo $a % $b; // 1 (mòdul)
echo $a ** $b; // 1000 (exponent)
```
**Assignació:**
```php
$x = 10;
$x += 5; // 15
$x -= 3; // 12
$x *= 2; // 24
$x /= 4; // 6
$x %= 4; // 2
$x **= 3; // 8
$text .= "!"; // concatenació i assignació
```
**Comparació:**
```php
var_dump(10 == "10"); // true (igual valor; converteix tipus)
var_dump(10 === "10"); // false (idèntic: valor I tipus)
var_dump(10 != "10"); // false
var_dump(10 !== "10"); // true
// Spaceship (PHP 7+): retorna -1, 0 o 1
echo 1 <=> 2; // -1
echo 2 <=> 2; // 0
echo 3 <=> 2; // 1
```
> [!NOTE]
> Preferiu sempre `===` sobre `==`.
**Lògics:**
```php
// && i || tenen més precedència que =
// and i or en tenen menys (pot causar confusió)
var_dump(true && false); // false
var_dump(true || false); // true
var_dump(!true); // false
var_dump(true xor false); // true
```
**Assignació condicional:**
```php
// Ternari
$r = ($condicio) ? 'Sí' : 'No';
// Elvis (PHP 5.3+): retorna esquerra si és truthy
$nom = $valor ?: 'Anònim';
// Null coalescing (PHP 7+): retorna esquerra si no és null
$nom = $_GET['nom'] ?? 'Anònim';
// Null coalescing assignment (PHP 7.4+)
$array['clau'] ??= 'valor per defecte';
```
### Estructures de control
**Condicionals:**
```php
if ($nota >= 90) {
echo "Excel·lent";
} elseif ($nota >= 70) {
echo "Notable";
} elseif ($nota >= 50) {
echo "Aprovat";
} else {
echo "Suspès";
}
// switch
switch ($color) {
case "red": echo "Vermell"; break;
case "blue": echo "Blau"; break;
default: echo "Altre";
}
// match (PHP 8+): comparació estricta (===), retorna valor
$missatge = match($codi_http) {
200, 201 => "Èxit",
404 => "No trobat",
500 => "Error del servidor",
default => "Codi desconegut"
};
```
**Sintaxi alternativa (per barrejar amb HTML):**
```php
HTML si cert
HTML si altra condició
HTML altrament
```
**Bucles:**
```php
// while
while ($i <= 5) { echo $i++; }
// do...while (sempre executa almenys una vegada)
do { echo $i++; } while ($i < 5);
// for (treure count() fora per eficiència)
for ($i = 0, $n = count($arr); $i < $n; $i++) {
echo $arr[$i];
}
// foreach (la forma més habitual per arrays)
foreach ($colors as $color) { echo $color; }
foreach ($edat as $nom => $anys) { echo "$nom: $anys"; }
// Modificar valors per referència
foreach ($arr as &$valor) { $valor *= 2; }
unset($valor); // IMPORTANT: trencar la referència
// break i continue
for ($i = 0; $i < 10; $i++) {
if ($i == 5) break; // surt del bucle
if ($i % 2 == 0) continue; // salta iteració
echo $i;
}
```
### Arrays
```php
"Joan", "edat" => 30, "ciutat" => "BCN"];
echo $persona["nom"]; // Joan
// Multidimensionals
$alumnes = [
["nom" => "Joan", "nota" => 8.5],
["nom" => "Maria", "nota" => 9.0],
];
echo $alumnes[0]["nom"]; // Joan
// Unpacking (PHP 7.4+)
$arr1 = [1, 2, 3];
$arr2 = [0, ...$arr1, 4]; // [0, 1, 2, 3, 4]
// Destructuring (PHP 7.1+)
[$a, $b, $c] = [10, 20, 30];
echo $a; // 10
?>
```
**Funcions d'array principals:**
```php
sort($arr); // ordena ascendent (reindexa)
rsort($arr); // ordena descendent
asort($arr); // ordena per valor (conserva claus)
ksort($arr); // ordena per clau
usort($arr, fn($a,$b) => $a - $b); // ordenació personalitzada
array_push($arr, $val); // afegeix al final
array_pop($arr); // elimina i retorna l'últim
array_shift($arr); // elimina i retorna el primer
array_unshift($arr, $v); // afegeix al principi
in_array($val, $arr); // comprova si existeix el valor
array_key_exists($k,$a); // comprova si existeix la clau
array_search($val, $arr);// retorna la clau del valor trobat
array_merge($a, $b); // combina dues arrays
array_unique($arr); // elimina duplicats
array_slice($arr, 1, 3); // subconjunt
array_filter($arr, fn($v) => $v > 0); // filtra per condició
array_map(fn($v) => $v*2, $arr); // transforma cada element
array_reduce($arr, fn($acc,$v) => $acc+$v, 0); // redueix a un valor
```
## 6. Comentaris
```php
```
## 7. Funcions integrades i d'usuari
### Funcions predefinides destacades
**Strings:**
```php
strlen($s) // longitud en bytes
mb_strlen($s, 'UTF-8') // longitud en caràcters (recomanat per UTF-8)
strtolower($s) / strtoupper($s)
trim($s) / ltrim($s) / rtrim($s)
str_replace($cerca, $sub, $s)
strpos($s, $needle) // posició primera ocurrència (o false)
substr($s, $inici, $longitud)
explode($sep, $s) // string → array
implode($sep, $arr) // array → string
sprintf("%.2f €", 9.9) // formata: "9.90 €"
htmlspecialchars($s) // escapa caràcters HTML (seguretat XSS)
nl2br($s) // \n →
strip_tags($s) // elimina etiquetes HTML
```
**Nombres:**
```php
abs($n) / ceil($n) / floor($n) / round($n, $decimals)
sqrt($n) / pow($base, $exp)
min(...$nums) / max(...$nums)
rand($min, $max) // pseudoaleatori
random_int($min, $max) // criptogràficament segur
number_format($n, 2, ',', '.') // "1.234,56"
```
**Arrays:** (vegeu secció anterior)
**Data i hora:**
```php
date('Y-m-d H:i:s') // data/hora actual formatada
time() // timestamp Unix actual
strtotime('+1 month') // timestamp relatiu
$d = new DateTime();
$d->format('d/m/Y');
$d->add(new DateInterval('P1M')); // +1 mes
```
**Altres útils:**
```php
phpinfo() // informació de l'entorn PHP
var_dump($var) // tipus i valor (debug)
print_r($var) // valor llegible (debug)
isset($var) // comprova si la variable existeix i no és null
empty($var) // comprova si és buida/falsy
unset($var) // elimina la variable
is_int($v) / is_string($v) / is_array($v) / is_null($v)
intval($v) / floatval($v) / strval($v)
filter_var($v, FILTER_VALIDATE_EMAIL) // validació i sanejament
json_encode($arr) // array → JSON string
json_decode($json, true) // JSON string → array associativa
```
### Funcions definides per l'usuari
```php
```
**Paràmetres variables:**
```php
```
**Tipació estricta (recomanada):**
```php
```
**Named arguments (PHP 8+):**
```php
```
**Passar per referència:**
```php
```
**Funcions anònimes i funcions fletxa:**
```php
$n * $factor;
// Ús habitual en array_map, array_filter
$quadrats = array_map(fn($n) => $n ** 2, [1, 2, 3, 4]);
$parells = array_filter([1,2,3,4,5,6], fn($n) => $n % 2 === 0);
?>
```
**Variables variables:**
```php
```
## 8. Gestió d'errors
### Nivells d'error
| Constant | Descripció |
|---|---|
| `E_ERROR` | Errors fatals que aturen l'execució |
| `E_WARNING` | Avisos que no aturen l'execució |
| `E_NOTICE` | Avisos lleugers (ús de variables no definides, etc.) |
| `E_PARSE` | Errors de sintaxi |
| `E_ALL` | Tots els errors i avisos |
### Configuració de la gestió d'errors
```php
```
> [!CAUTION]
> **Mai** activis `display_errors` en un servidor de producció: podria revelar rutes, usuaris i contrasenyes.
### Gestor d'errors personalitzat
```php
S'ha produït un error. Si us plau, contacteu l'administrador.";
exit(1);
}
return true; // no executar el gestor intern de PHP
}
set_error_handler("gestorErrors");
// Generar errors personalitzats
trigger_error("Valor invàlid", E_USER_WARNING);
trigger_error("Error crític", E_USER_ERROR);
?>
```
### Excepcions
```php
errors = $errors;
}
public function getErrors(): array { return $this->errors; }
}
// Ús
function validaNom(string $nom): string {
if (empty($nom)) throw new ValidacióException(["El nom és obligatori"]);
if (strlen($nom) < 2) throw new ValidacióException(["El nom és massa curt"]);
return trim($nom);
}
try {
$nom = validaNom("");
echo "Nom vàlid: $nom";
} catch (ValidacióException $e) {
foreach ($e->getErrors() as $error) {
echo "- $error\n";
}
} catch (Exception $e) {
echo "Error inesperat: " . $e->getMessage();
} finally {
echo "Sempre s'executa";
}
?>
```
### Gestor global d'excepcions
```php
getMessage() . " a " . $e->getFile() . ":" . $e->getLine());
http_response_code(500);
echo "
Error intern del servidor
";
// En desenvolupament podries mostrar $e->getMessage()
});
?>
```
## 9. Formularis: introducció d'informació
### Formulari HTML i processament PHP
```html
```
```php
120) {
$errors[] = "L'edat ha de ser entre 0 i 120";
}
if (!$accepta) {
$errors[] = "Cal acceptar les condicions";
}
// 3. Mostrar resultat
if (empty($errors)) {
echo "
Dades rebudes correctament: $nom, $email, $edat anys
";
// Aquí vindria la lògica: desar a BD, enviar email, etc.
} else {
echo "
";
foreach ($errors as $error) {
echo "
" . htmlspecialchars($error) . "
";
}
echo "
";
}
?>
```
### Funcions de filtre i validació
```php
['min_range' => 0, 'max_range' => 120]]);
filter_var($n, FILTER_VALIDATE_FLOAT);
filter_var($b, FILTER_VALIDATE_BOOLEAN);
// Sanejament (elimina caràcters no desitjats)
filter_var($input, FILTER_SANITIZE_NUMBER_INT);
filter_var($input, FILTER_SANITIZE_EMAIL);
filter_var($input, FILTER_SANITIZE_URL);
// Equivalent manual per a HTML
htmlspecialchars($input, ENT_QUOTES, 'UTF-8');
strip_tags($input);
trim($input);
?>
```
### Pujada de fitxers
```html
```
```php
file($fitxer['tmp_name']);
if (!in_array($tipus_real, $tipus_permesos)) {
die("Tipus de fitxer no permès: $tipus_real");
}
if ($fitxer['size'] > $mida_maxima) {
die("El fitxer és massa gran");
}
// Generar nom únic per evitar sobrescriure fitxers existents
$extensio = pathinfo($fitxer['name'], PATHINFO_EXTENSION);
$nom_segur = uniqid('img_', true) . '.' . strtolower($extensio);
$ruta_dest = $directori_dest . $nom_segur;
if (move_uploaded_file($fitxer['tmp_name'], $ruta_dest)) {
echo "Fitxer pujat correctament: $nom_segur";
} else {
die("No s'ha pogut moure el fitxer");
}
?>
```
## 10. Autenticació d'usuaris
### Emmagatzematge segur de contrasenyes
```php
```
> `PASSWORD_DEFAULT` usa bcrypt. PHP fa evolucionar l'algoritme amb el temps.
> No usar SHA1, MD5 ni SHA256 directament: són massa ràpids i vulnerables a atacs de força bruta.
### Procés de login complet
```php
PDO::ERRMODE_EXCEPTION]);
$stmt = $pdo->prepare("SELECT id, nom, clau_hash FROM usuaris WHERE email = ? LIMIT 1");
$stmt->execute([$usuari]);
$user = $stmt->fetch(PDO::FETCH_ASSOC);
if ($user && password_verify($clau, $user['clau_hash'])) {
// Login correcte
session_regenerate_id(true); // evita fixació de sessió
$_SESSION['user_id'] = $user['id'];
$_SESSION['nom'] = $user['nom'];
$_SESSION['rol'] = $user['rol'] ?? 'usuari';
$dest = $_GET['backto'] ?? 'dashboard.php';
header('Location: ' . $dest);
exit;
} else {
$error = "Credencials incorrectes";
// Registrar intent fallat (per a fail2ban o similar)
error_log("Login fallat per a l'usuari: $usuari des de " . $_SERVER['REMOTE_ADDR']);
}
} catch (PDOException $e) {
error_log("Error BD en login: " . $e->getMessage());
$error = "Error intern. Torna-ho a provar.";
}
}
}
?>
```
## 11. Control d'accessos
### Verificació de sessió (protecció de pàgines)
```php
403 — Accés denegat";
echo "
No tens permís per accedir a aquesta pàgina.
";
exit;
}
}
?>
```
### Ús del control d'accés
```php
```
### Sistema de rols
```php
['llegir'],
'editor' => ['llegir', 'escriure', 'editar'],
'admin' => ['llegir', 'escriure', 'editar', 'esborrar', 'gestionar_usuaris'],
'superadmin'=> ['*'], // tots els permisos
];
function tePermis(string $permis): bool {
$rol = $_SESSION['rol'] ?? 'usuari';
$permisos_rol = PERMISOS[$rol] ?? [];
return in_array('*', $permisos_rol) || in_array($permis, $permisos_rol);
}
// Ús a les vistes
if (tePermis('esborrar')): ?>
```
### Protecció CSRF (Cross-Site Request Forgery)
```php
```
## 12. Sessions
### Cicle de vida d'una sessió
```php
```
### Configuració de sessions
```php
3600, // la cookie expira en 1 hora
'cookie_secure' => true, // HTTPS obligatori
'cookie_httponly' => true, // inaccessible per JavaScript
'cookie_samesite' => 'Strict', // prevenció CSRF
'gc_maxlifetime' => 3600, // dades de sessió al servidor: 1 hora
]);
// Regenerar ID per evitar fixació de sessió (fer-ho en el login)
session_regenerate_id(true);
?>
```
### Exemple d'ús per verificar aïllament entre usuaris
```php
prepare("SELECT * FROM comandes WHERE usuari_id = ?");
$stmt->execute([$user_id]);
$comandes = $stmt->fetchAll();
// Cada usuari veu sols les seves comandes
// L'aïllament el garanteix la sessió + la consulta SQL amb WHERE usuari_id = ?
?>
```
## 13. Configuració de l'intèrpret
### Fitxer `php.ini`
El fitxer principal de configuració de PHP. A Ubuntu 26.04 amb Apache, la ubicació és:
| Sistema | Ubicació |
|---|---|
| **Ubuntu 26.04 + Apache** | `/etc/php/8.x/apache2/php.ini` |
| Ubuntu 26.04 (CLI) | `/etc/php/8.x/cli/php.ini` |
Per saber la versió exacta de PHP i el fitxer que s'usa:
```bash
php -v # mostra la versió (ex. 8.3.x)
php --ini # mostra el php.ini que usa la CLI
apache2ctl -t -D DUMP_MODULES # comprova que el mòdul PHP és actiu
```
Opcions clau:
```ini
; ===== ERRORS (DEV) =====
display_errors = On
error_reporting = E_ALL
log_errors = On
error_log = /var/log/php_errors.log
; ===== ERRORS (PRODUCCIÓ) =====
display_errors = Off
display_startup_errors = Off
error_reporting = E_ALL & ~E_DEPRECATED & ~E_STRICT
log_errors = On
error_log = /var/log/php_errors.log
; ===== FITXERS PUJATS (recomanat per a WordPress) =====
file_uploads = On
upload_max_filesize = 64M
post_max_size = 68M ; ha de ser > upload_max_filesize
max_file_uploads = 20
; ===== RENDIMENT =====
memory_limit = 256M ; WordPress recomana 256M
max_execution_time = 60
max_input_time = 60
max_input_vars = 3000 ; necessari per a temes/plugins complexos
; ===== EXTENSIONS (ja actives si s'ha seguit la instal·lació) =====
; Les extensions s'activen com a paquets APT a Ubuntu,
; no editant php.ini directament. Comprova-les amb phpinfo().
; ===== SESSIONS =====
session.cookie_httponly = 1
session.cookie_secure = 1 ; requereix HTTPS
session.gc_maxlifetime = 1440
session.use_strict_mode = 1
; ===== OPCACHE (rendiment) =====
opcache.enable = 1
opcache.memory_consumption = 128
opcache.max_accelerated_files = 4000
```
> Després de modificar `php.ini`, cal reiniciar Apache:
> ```bash
> sudo systemctl restart apache2
> ```
### Modificar configuració temporalment des de PHP
```php
```
# RA6 - Genera documents web amb accés a bases de dades utilitzant llenguatges de guions de servidors.
## 14. Integració PHP i MySQL
### Sistemes gestors de bases de dades en entorns web
| SGBD | Característiques | Usos habituals |
|---|-----|-----|
| **MySQL / MariaDB** | El més usat en web, ràpid, codi obert | WordPress, LAMP |
| **PostgreSQL** | Funcionalitats avançades, ACID complet | Aplicacions empresarials, geolocalització |
| **SQLite** | Fitxer únic, sense servidor | Apps mòbils, prototips, tests |
| **MongoDB** | NoSQL orientat a documents | APIs, big data, dades no estructurades |
| **Redis** | Clau-valor en memòria | Caching, sessions, cues de missatges |
### API PHP per a MySQL: PDO vs. MySQLi
PHP ofereix dues API per connectar-se a MySQL:
| | PDO | MySQLi |
|---|---|-----|
| **Portabilitat** | Suporta 12 SGBD | Només MySQL/MariaDB |
| **Prepared statements** | Sí (nomenats i posicionals) | Sí (només posicionals) |
| **Estil** | OO | OO i procedural |
| **Recomanació** | Preferida | Per a funcionalitats MySQL específiques |
En aquest document usem **PDO** per portabilitat.
### Activar les extensions necessàries
A Ubuntu 26.04, les extensions de PHP s'instal·len com a paquets APT, no editant `php.ini` directament:
```bash
# Ubuntu 26.04 — instal·lar extensions per a MariaDB/MySQL
sudo apt install php-mysql php-mbstring php-xml php-curl \
php-zip php-gd php-intl php-bcmath -y
sudo systemctl restart apache2
```
Per verificar que les extensions estan actives:
```bash
php -m | grep -E "pdo_mysql|mysqli|mbstring|gd|curl"
```
O bé consultant `phpinfo()` al navegador.
## 15. Connexió a bases de dades
### Connexió bàsica amb PDO
```php
PDO::ERRMODE_EXCEPTION, // llença excepcions
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, // arrays associatives
PDO::ATTR_EMULATE_PREPARES => false, // prepared statements reals
];
try {
return new PDO($dsn, $usuari, $clau, $opcions);
} catch (PDOException $e) {
// No mostrar detalls de connexió per pantalla en producció
error_log("Error de connexió BD: " . $e->getMessage());
throw new RuntimeException("No s'ha pogut connectar a la base de dades");
}
}
// Ús
$pdo = connexioBD();
```
### Fitxer de configuració separat
```php
'localhost',
'dbname' => 'la_meva_bd',
'charset' => 'utf8mb4',
'username' => 'nom_usuari',
'password' => 'contrasenya',
];
```
```php
```
## 16. Creació de bases de dades i taules
### Crear una base de dades
```php
PDO::ERRMODE_EXCEPTION]);
$pdo->exec("CREATE DATABASE IF NOT EXISTS botiga
CHARACTER SET utf8mb4
COLLATE utf8mb4_unicode_ci");
echo "Base de dades creada";
// Seleccionar-la
$pdo->exec("USE botiga");
?>
```
### Crear taules
```php
exec("
CREATE TABLE IF NOT EXISTS usuaris (
id INT AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(100) NOT NULL,
email VARCHAR(255) NOT NULL UNIQUE,
clau_hash VARCHAR(255) NOT NULL,
rol ENUM('usuari','editor','admin') DEFAULT 'usuari',
actiu TINYINT(1) DEFAULT 1,
creat_el TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
modificat_el TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
");
// Taula de productes
$pdo->exec("
CREATE TABLE IF NOT EXISTS productes (
id INT AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(200) NOT NULL,
descripcio TEXT,
preu DECIMAL(10,2) NOT NULL,
estoc INT DEFAULT 0,
actiu TINYINT(1) DEFAULT 1,
creat_el TIMESTAMP DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
");
// Taula de comandes (clau forana)
$pdo->exec("
CREATE TABLE IF NOT EXISTS comandes (
id INT AUTO_INCREMENT PRIMARY KEY,
usuari_id INT NOT NULL,
total DECIMAL(10,2) NOT NULL,
estat ENUM('pendent','pagada','enviada','cancel·lada') DEFAULT 'pendent',
creat_el TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (usuari_id) REFERENCES usuaris(id) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
");
echo "Taules creades correctament";
?>
```
## 17. Consulta de dades (SELECT)
### Consulta simple
```php
query("SELECT * FROM productes WHERE actiu = 1 ORDER BY nom");
$productes = $stmt->fetchAll(); // array de tots els registres
foreach ($productes as $p) {
echo "{$p['nom']}: {$p['preu']} € ";
}
// Nombre de files
echo "Total: " . $stmt->rowCount();
?>
```
### Consulta amb paràmetres (SEMPRE per a dades externes)
```php
prepare($sql);
$stmt->bindValue(':preu_max', 50.0, PDO::PARAM_STR); // float usa PARAM_STR
$stmt->bindValue(':limit', 10, PDO::PARAM_INT);
$stmt->execute();
$productes = $stmt->fetchAll();
// O amb execute() directament:
$stmt = $pdo->prepare("SELECT * FROM productes WHERE preu < ? AND actiu = 1");
$stmt->execute([50.0]);
$productes = $stmt->fetchAll();
?>
```
### Obtenir un sol registre
```php
prepare("SELECT * FROM usuaris WHERE id = ?");
$stmt->execute([$id]);
$usuari = $stmt->fetch(); // un sol registre o false si no existeix
if ($usuari) {
echo "Nom: {$usuari['nom']}";
} else {
echo "Usuari no trobat";
}
// Obtenir un sol valor escalar
$stmt = $pdo->prepare("SELECT COUNT(*) FROM productes WHERE actiu = 1");
$stmt->execute();
$total = $stmt->fetchColumn();
echo "Total actius: $total";
?>
```
### Consulta amb JOIN
```php
prepare($sql);
$stmt->execute(['pendent']);
$comandes = $stmt->fetchAll();
?>
```
## 18. Modificació de dades (INSERT, UPDATE, DELETE)
### INSERT
```php
prepare("
INSERT INTO productes (nom, descripcio, preu, estoc)
VALUES (:nom, :descripcio, :preu, :estoc)
");
$stmt->execute([
':nom' => 'Teclat mecànic',
':descripcio' => 'Teclat mecànic retroil·luminat',
':preu' => 79.99,
':estoc' => 50,
]);
$id_nou = (int) $pdo->lastInsertId();
echo "Producte inserit amb ID: $id_nou";
// Inserció múltiple (transacció per eficiència)
$productes = [
['Ratolí ergonòmic', 29.99, 100],
['Monitor 24"', 199.00, 20],
['Auriculars BT', 49.99, 75],
];
$stmt = $pdo->prepare("INSERT INTO productes (nom, preu, estoc) VALUES (?, ?, ?)");
$pdo->beginTransaction();
try {
foreach ($productes as $p) {
$stmt->execute($p);
}
$pdo->commit();
echo "Inserció múltiple completada";
} catch (PDOException $e) {
$pdo->rollBack();
error_log("Error en inserció múltiple: " . $e->getMessage());
throw $e;
}
?>
```
### UPDATE
```php
prepare("
UPDATE productes
SET preu = :preu, estoc = :estoc, modificat_el = NOW()
WHERE id = :id AND actiu = 1
");
$stmt->execute([
':preu' => 89.99,
':estoc' => 45,
':id' => 1,
]);
echo "Files actualitzades: " . $stmt->rowCount();
// Actualitzar múltiples registres
$stmt = $pdo->prepare("UPDATE productes SET actiu = 0 WHERE estoc = 0");
$stmt->execute();
echo "Productes desactivats: " . $stmt->rowCount();
?>
```
### DELETE
```php
prepare("UPDATE productes SET actiu = 0 WHERE id = ?");
$stmt->execute([$id_producte]);
// Esborrat físic
$stmt = $pdo->prepare("DELETE FROM productes WHERE id = ?");
$stmt->execute([$id_producte]);
echo "Files esborrades: " . $stmt->rowCount();
?>
```
### Transaccions
```php
beginTransaction();
// Operació 1: crear comanda
$stmt = $pdo->prepare("INSERT INTO comandes (usuari_id, total) VALUES (?, ?)");
$stmt->execute([$usuari_id, $total]);
$comanda_id = (int) $pdo->lastInsertId();
// Operació 2: reduir estoc
$stmt = $pdo->prepare("UPDATE productes SET estoc = estoc - ? WHERE id = ? AND estoc >= ?");
$stmt->execute([$quantitat, $producte_id, $quantitat]);
if ($stmt->rowCount() === 0) {
throw new RuntimeException("Estoc insuficient");
}
$pdo->commit();
echo "Comanda $comanda_id creada correctament";
} catch (Exception $e) {
$pdo->rollBack();
error_log("Error en transacció: " . $e->getMessage());
echo "Error: " . $e->getMessage();
}
?>
```
## 19. Verificació i validació de la informació
### Validació de dades d'entrada
```php
200) {
$errors[] = "El nom no pot superar 200 caràcters";
}
$preu = filter_var($dades['preu'] ?? '', FILTER_VALIDATE_FLOAT);
if ($preu === false || $preu < 0) {
$errors[] = "El preu ha de ser un número positiu";
}
$estoc = filter_var($dades['estoc'] ?? '', FILTER_VALIDATE_INT,
['options' => ['min_range' => 0]]);
if ($estoc === false) {
$errors[] = "L'estoc ha de ser un enter no negatiu";
}
if (!empty($errors)) {
throw new InvalidArgumentException(implode('; ', $errors));
}
return [
'nom' => htmlspecialchars($nom, ENT_QUOTES, 'UTF-8'),
'preu' => (float) $preu,
'estoc' => (int) $estoc,
];
}
// Ús
try {
$dades_validades = validaProducte($_POST);
// Inserir a la BD...
} catch (InvalidArgumentException $e) {
echo "Error de validació: " . $e->getMessage();
}
?>
```
### Verificació de l'existència de registres
```php
prepare($sql);
$stmt->execute($params);
return (int) $stmt->fetchColumn() > 0;
}
if (existeixEmail($pdo, $_POST['email'])) {
$errors[] = "Ja existeix un compte amb aquest email";
}
?>
```
## 20. Gestió d'errors de BD
### Modes d'error de PDO
```php
PDO::ERRMODE_SILENT,
// ERRMODE_WARNING: genera un E_WARNING (no atura l'execució)
PDO::ATTR_ERRMODE => PDO::ERRMODE_WARNING,
// ERRMODE_EXCEPTION (recomanat): llença PDOException
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
];
?>
```
### Gestió d'errors en operacions de BD
```php
prepare("
INSERT INTO productes (nom, preu, estoc)
VALUES (:nom, :preu, :estoc)
");
$stmt->execute($dades);
return (int) $pdo->lastInsertId();
} catch (PDOException $e) {
$codi = (int) $e->getCode();
// Error de clau duplicada (SQLSTATE 23000)
if ($codi === 23000) {
throw new RuntimeException("Ja existeix un producte amb aquest nom");
}
// Altres errors: registrar i relllençar
error_log("Error BD insereixProducte: [{$e->getCode()}] {$e->getMessage()}");
throw new RuntimeException("Error en desar el producte. Torna-ho a provar.");
}
}
?>
```
## 21. Seguretat i control d'accés a la BD
### Prevenció d'injeccions SQL
```php
prepare("SELECT * FROM usuaris WHERE id = ?");
$stmt->execute([(int) $_GET['id']]);
$usuari = $stmt->fetch();
?>
```
### Principi de mínim privilegi
```sql
-- Crear un usuari de BD amb NOMÉS els permisos necessaris
CREATE USER 'app_user'@'localhost' IDENTIFIED BY 'contrasenya_segura';
-- Permisos mínims per a l'aplicació web (no DROP, no CREATE, no GRANT)
GRANT SELECT, INSERT, UPDATE, DELETE ON botiga.* TO 'app_user'@'localhost';
FLUSH PRIVILEGES;
```
### Protecció de les credencials
```php
getenv('DB_HOST') ?: 'localhost',
'name' => getenv('DB_NAME') ?: 'botiga',
'user' => getenv('DB_USER') ?: 'app_user',
'pass' => getenv('DB_PASS') ?: '',
];
?>
```
```apache
# .htaccess per protegir el directori config/
Require all denied
```
## 22. Verificació del funcionament i proves de rendiment
### Comprovació bàsica de la BD
```php
query("SELECT 1");
echo "Connexió a la BD: OK";
} catch (Exception $e) {
echo "Connexió a la BD: FALLIDA — " . $e->getMessage();
}
// Informació del servidor MySQL
$stmt = $pdo->query("SELECT VERSION() AS versio, NOW() AS ara");
$info = $stmt->fetch();
echo "MySQL versió: {$info['versio']}, Hora servidor: {$info['ara']}";
?>
```
### Mesura del temps d'execució
```php
query("SELECT * FROM productes WHERE actiu = 1");
$productes = $stmt->fetchAll();
$temps = (microtime(true) - $inici) * 1000;
echo sprintf("Consulta: %.2f ms, %d registres", $temps, count($productes));
?>
```
### Activar EXPLAIN per analitzar consultes lentes
```php
query("EXPLAIN $sql");
$pla = $stmt->fetchAll();
print_r($pla);
// Mostra si s'usen índexs i el cost estimat de la consulta
?>
```
### Paginació de resultats
```php
query("SELECT COUNT(*) FROM productes WHERE actiu = 1");
$total = (int) $stmt->fetchColumn();
$total_pagines = (int) ceil($total / $resultats_pagina);
// Obtenir la pàgina actual
$stmt = $pdo->prepare("SELECT * FROM productes WHERE actiu = 1 LIMIT ? OFFSET ?");
$stmt->bindValue(1, $resultats_pagina, PDO::PARAM_INT);
$stmt->bindValue(2, $offset, PDO::PARAM_INT);
$stmt->execute();
$productes = $stmt->fetchAll();
?>
Pàgina de ( resultats)
```
### Bones pràctiques de rendiment
```php
query("SELECT id, nom, preu FROM productes"); // no SELECT *
// 3. Reutilitzar prepared statements en bucles
$stmt = $pdo->prepare("INSERT INTO log (event, dades) VALUES (?, ?)");
foreach ($events as $e) {
$stmt->execute([$e['tipus'], json_encode($e['dades'])]);
}
// 4. Usar transaccions per a insercions múltiples (molt més ràpid)
$pdo->beginTransaction();
// ... múltiples inserts ...
$pdo->commit();
// 5. Limitar sempre els resultats
$stmt = $pdo->prepare("SELECT * FROM logs ORDER BY creat_el DESC LIMIT 100");
?>
```
# RA7 - Realitza modificacions en gestors de continguts adaptant-ne l’aparença i les funcionalitats.
## 23. Introducció als gestors de continguts (CMS)
### Què és un CMS?
Un **gestor de continguts** (*Content Management System*, CMS) és una aplicació web que permet crear, gestionar i publicar contingut digital sense necessitat de programar cada vegada. Separa el contingut de la presentació i ofereix una interfície d'administració gràfica.
### Principals CMS
| CMS | Quota mercat | Tecnologia | Usos típics |
|----|----|---|-------|
| **WordPress** | ~43% web mundial | PHP + MySQL | Blogs, webs corporatives, e-commerce |
| **Drupal** | ~2% | PHP + MySQL | Portals complexos, grans institucions |
| **Joomla** | ~2% | PHP + MySQL | Webs de tot mena |
| **Magento/Adobe Commerce** | — | PHP + MySQL | E-commerce |
| **Shopify** | — | Ruby | E-commerce (SaaS) |
| **Ghost** | — | Node.js | Blogs professionals |
Dades de desembre de 2025 [Sketchweb Microblog](https://micro.sketchweb.net/2026/05/30/wordpress-market-share-decline-what.html)
WordPress és el CMS dominant i el que estudiem en detall per la seva penetració i arquitectura representativa.
## 24. Estructura de WordPress
### Estructura de directoris
```ini
/var/www/html/wordpress/
├── wp-admin/ ← Panell d'administació (no modificar)
├── wp-includes/ ← Nucli de WordPress (no modificar)
└── wp-content/ ← Tot el contingut personalitzable
├── themes/ ← Temes (aparença)
│ ├── twentytwentyseven/ ← Tema per defecte de WordPress 7
│ └── el-meu-tema/ ← Tema personalitzat
├── plugins/ ← Plugins (funcionalitats)
│ ├── woocommerce/
│ └── el-meu-plugin/ ← Plugin personalitzat
├── uploads/ ← Fitxers pujats pels usuaris
└── languages/ ← Traduccions
```
### Fitxers de configuració clau
```php
// wp-config.php — configuració principal (a l'arrel)
define('DB_NAME', 'nom_base_dades');
define('DB_USER', 'usuari_bd');
define('DB_PASSWORD', 'contrasenya_bd');
define('DB_HOST', 'localhost');
define('DB_CHARSET', 'utf8mb4');
// Claus de seguretat (generar a https://api.wordpress.org/secret-key/1.1/salt/)
define('AUTH_KEY', 'posar clau única aquí');
// ...
// Mode de debug (activar en desenvolupament)
define('WP_DEBUG', true);
define('WP_DEBUG_LOG', true); // desa errors a wp-content/debug.log
define('WP_DEBUG_DISPLAY', false); // no mostrar per pantalla en producció
```
### Tipus de contingut (Post Types)
WordPress gestiona el contingut com a **posts** de diferent tipus:
| Post Type | Descripció |
|---|---|
| `post` | Entrades del blog |
| `page` | Pàgines estàtiques |
| `attachment` | Fitxers multimèdia |
| `custom` | Qualsevol tipus personalitzat |
### Jerarquia de plantilles
WordPress segueix una jerarquia per escollir quina plantilla renderitza cada URL:
```ini
Pàgina concreta → page-{slug}.php → page-{id}.php → page.php
Entrada blog → single-{type}.php → single.php → singular.php
Arxiu → archive-{type}.php → archive.php
Cerca → search.php
Error 404 → 404.php
Cap dels anteriors → index.php (obligatori)
```
## 25. Modificació de l'aparença: temes
### Estructura mínima d'un tema
```ini
wp-content/themes/el-meu-tema/
├── style.css ← obligatori (capçalera amb metadades)
├── index.php ← obligatori (plantilla principal)
├── functions.php ← funcions del tema i hooks
├── header.php ← capçalera reutilitzable
├── footer.php ← peu reutilitzable
├── sidebar.php ← barra lateral reutilitzable
├── single.php ← plantilla per a entrades
├── page.php ← plantilla per a pàgines
├── archive.php ← plantilla per a arxius
├── 404.php ← pàgina d'error
└── screenshot.png ← previsualització al panell (1200×900 px)
```
### `style.css` — capçalera obligatòria
```css
/*
Theme Name: El Meu Tema
Theme URI: https://exemple.cat/el-meu-tema
Description: Tema personalitzat per al mòdul 0376.
Author: Ramon López
Author URI: https://proferamon.com
Version: 1.0.0
License: GNU General Public License v2 or later
License URI: https://www.gnu.org/licenses/gpl-2.0.html
Text Domain: el-meu-tema
*/
/* Aquí els estils CSS del tema */
body {
font-family: 'Segoe UI', sans-serif;
line-height: 1.6;
color: #333;
}
```
### `functions.php` — registrar funcionalitats
```php
add_theme_support('title-tag');
// Suport per a HTML5
add_theme_support('html5', ['search-form', 'comment-form', 'gallery']);
// Registrar menús de navegació
register_nav_menus([
'primary' => __('Menú principal', 'el-meu-tema'),
'footer' => __('Menú del peu', 'el-meu-tema'),
]);
}
add_action('after_setup_theme', 'el_meu_tema_setup');
// Encolar CSS i JS (mai incloure'ls directament amb o