PHP-lessen - les 2 - Werken met bestanden: openen, schrijven, lezen.

In de vorige les hebben we het raamwerk gemaakt voor onze gastenboek-, blog- of chatsite. Nu hoeven we alleen nog functionaliteit toe te voegen. In deze les gaan we onze berichten opslaan in bestanden en ze vervolgens weer uitlezen.

PHP heeft veel functies om met bestanden te werken. We zullen er een paar bekijken — hoogstwaarschijnlijk zal je website gegevens opslaan in een database (daar ben ik zeker van) en niet in bestanden, dus behandelen we alleen de basis om het principe te begrijpen. Met databases gaan we later aan de slag.

Als je de bestanden uit de vorige les niet hebt, ga dan terug naar de vorige les en download ze opnieuw.

Laten we naar het formulier voor het toevoegen van berichten gaan:

/index.php?admin=1

Met dit formulier voegen we nieuwe berichten toe. Om de gegevens van dit formulier te verwerken, moeten we in index.php controleren of de variabele $_POST waarden bevat (de gegevens die het formulier verstuurt). Dat doen we heel eenvoudig:

if($_POST){

}

Eenvoudig, toch? Nu moeten we binnen de accolades de verwerking van de array $_POST uitvoeren. We schrijven die code niet direct in de accolades, maar plaatsen deze in onze klasse en roepen de verwerking aan via een methode van het object. In het bestand index.php roepen we de methode als volgt aan:

if($_POST){
 $obj->write($_POST);
}

En in het bestand simpleCMS.php voegen we de implementatie van de methode write() toe:

  public function write($p) { // methode om bericht op te slaan
  
  }  

Waarom doen we dat? Omdat we de code in index.php overzichtelijk willen houden. Het bestand index.php dient alleen als besturingsbestand, terwijl de verwerking van gegevens en het tonen van resultaten beter in een aparte klasse kan gebeuren, bijvoorbeeld in onze klasse simpleCMS. Deze scheiding maakt de code overzichtelijker en beter te onderhouden — en ook makkelijker te begrijpen voor anderen (of voor jezelf later).

Laten we eenvoudig beginnen: we drukken de inhoud van de array $_POST af die door het formulier wordt verzonden. Voeg deze code toe:

  public function write($p) { // methode om bericht op te slaan
     print_r($p);
  }  

Zoals je ziet gebruiken we de lokale variabele $p, hoewel de superglobale variabele $_POST wordt doorgegeven. We gebruiken geen superglobale variabelen direct, omdat we deze methode later ook kunnen gebruiken om gegevens uit andere bronnen op te slaan, bijvoorbeeld uit een XML-bestand. Door een lokale variabele te gebruiken, maken we de methode flexibeler en herbruikbaar.

Vul nu het formulier in en verstuur het. Ik kreeg als resultaat deze gegevens:

Array ( [title] => Ivan [bodytext] => Hallo, Wereld! ) 

Als je iets anders hebt ingevuld, zal jouw array uiteraard anders zijn. We hebben de array afgedrukt om te zien welke sleutels we kunnen gebruiken: in ons geval $p['title'] en $p['bodytext']. Nu we weten welke gegevens er binnenkomen, kunnen we ze opslaan in een bestand. Laten we beginnen met het schrijven naar een bestand.

Bestanden schrijven in PHP

Voordat we iets naar een bestand kunnen schrijven, moeten we het eerst “openen om te schrijven”. Dat betekent dat we het bestand koppelen aan een PHP-variabele. Het werken met bestanden in PHP draait om acties op variabelen van het type resource. Zo ziet dat eruit:

  public function write($p) { // methode om bericht op te slaan
	$message = fopen("messages/file.txt","w"); 
	print_r($message);
  }  

Hiervoor heb ik het bestand file.txt aangemaakt in de map messages. Wanneer we nu het formulier invullen en verzenden, krijgen we bijvoorbeeld:

Resource id #4

Resource is het type van de variabele $message, en het getal 4 is het interne ID van de resource. Alle handelingen met de variabele $message hebben nu effect op het gekoppelde bestand. We schrijven de inhoud regel voor regel, zodat we deze later ook regel voor regel kunnen uitlezen:

  public function write($p) { // methode om bericht op te slaan
	$message = fopen("messages/file.txt","w"); 
	fputs ($message, $p['title']. "\r\n");
	fputs ($message, $p['bodytext']);
  }  

De tekens \r\n in dubbele aanhalingstekens (in enkele werkt het niet altijd) betekenen een nieuwe regel. In het bestand file.txt staat nu bijvoorbeeld:

Ivan
Hallo, Wereld!

Na alle bewerkingen met het bestand moeten we de resource sluiten, om geheugen vrij te maken:

  public function write($p) { // methode om bericht op te slaan
	$message = fopen("messages/file.txt","w");  // open bestand
	fputs ($message, $p['title']. "\r\n");
	fputs ($message, $p['bodytext']);
	fclose ($message); // sluit bestand
  } 

Je hebt waarschijnlijk gemerkt dat het bestand telkens wordt overschreven. Dat hangt af van de parameter in de functie fopen(). Je kunt bestanden ook openen om alleen te lezen of om toe te voegen, bijvoorbeeld:

$message = fopen("messages/file.txt","r");  // open bestand alleen voor lezen

1. r – openen voor alleen lezen.
2. r+ – openen voor lezen en schrijven.
3. w – maak een nieuw leeg bestand aan (als het al bestaat, wordt het overschreven).
4. w+ – lezen en schrijven, maar bestaande inhoud wordt verwijderd.
5. a – openen voor schrijven, nieuwe inhoud wordt toegevoegd aan het einde van het bestand.
6. a+ – openen voor lezen en schrijven, bestaande inhoud blijft behouden.

Zoals hierboven vermeld, als we een bestand openen met de parameter w, wordt er een nieuw bestand gemaakt met de naam uit de eerste parameter. Laten we bestandsnamen genereren op basis van de huidige tijd met de functie time().

De functie time() retourneert het aantal seconden sinds 1 januari 1970.

Je code zou er nu zo uit moeten zien:

  public function write($p) { // methode om bericht op te slaan
	$message = fopen('messages/'.time(),"w");  // open bestand
	fputs ($message, $p['title']. "\r\n");
	fputs ($message, $p['bodytext']. "\r\n");
	fputs ($message, time());
	fclose ($message); // sluit bestand
  }  

Elke seconde geeft time() een grotere waarde terug, dus elke bestandsnaam wordt uniek. Probeer nieuwe berichten toe te voegen — nieuwe bestanden verschijnen in de map messages. Nu moeten we die bestanden alleen nog uitlezen en weergeven.

Bestanden lezen in PHP

Om een bestand te lezen, moeten we het openen met de parameter r. Alle bestanden bevinden zich in de map messages. We gebruiken een while-lus om alle bestanden in die map te verwerken.

We lezen de bestandsnamen met de functie opendir(), die een map opent om erin te lezen:

	if (is_dir('messages')) { // controleer of map bestaat
		if ($dh = opendir('messages')) { // open map
			while (($file = readdir($dh)) !== false) { // lees bestanden
				// verwerk elk bestand
			}
			closedir($dh); // sluit map
		}
	} 

De bestandsnamen worden verkregen met de functie readdir() en opgeslagen in de variabele $file. Na afloop sluiten we de map om geheugen vrij te maken.

Nu we bestanden kunnen lezen, breiden we de methode display_public() uit:

  public function display_public() { // methode om berichten weer te geven
    $content = '';
	if (is_dir('messages')) {
		if ($dh = opendir('messages')) {
			while (($file = readdir($dh)) !== false) {
			  if(substr($file, -4) == '.txt'){ // neem alleen .txt-bestanden
				$filename = 'messages/' . $file;
			    $message = fopen($filename, 'r');
				$title = fgets($message); // lees eerste regel
				$body = fgets($message);  // lees tweede regel
				$time = fgets($message);  // lees derde regel
				print '<div class="post">';
				print '<span class="time">' . date('d-m-Y', $time) . '</span><h2>' . $title . '</h2>';
			    print '<p>' . $body . '</p>';
				print '</div>';
				fclose($message);
			  }	
			}
			closedir($dh);
		}
	}   	
	$content .= '<p><a href="/index.php?admin=1">Bericht toevoegen</a></p>';
    return $content;
  }

Ik heb elke regel van commentaar voorzien. Als iets niet duidelijk is, laat het weten in de reacties, dan leg ik het verder uit.

Hoewel je in de praktijk waarschijnlijk geen bestanden regel voor regel zult lezen, zijn dit soort oefeningen erg nuttig om de werking van PHP-functies en bestandsverwerking te begrijpen.

Hieronder staat de broncode van de tussentijdse versie van de website.