Ik probeer HTML5-code te ontleden zodat ik attributen/waarden in de code kan instellen, maar het lijkt erop dat DOMDocument (PHP5.3) geen tags ondersteunt zoals
Is er een manier om dit als HTML in PHP te ontleden en de code te manipuleren?
Code om te spelen:
laadHTML("
");
Waarschuwing: DOMDocument::loadHTML(): tag is ongeldig in Entiteit, regel: 4 in /home/wbkrnl/public_html/new-mvc/1.php op regel 17
Waarschuwing: DOMDocument::loadHTML(): Tagsectie is ongeldig in Entiteit, regel: 10 in /home/wbkrnl/public_html/new-mvc/1.php op regel 17
Nee, er is geen manier om een specifiek doctype te specificeren om de vereisten van een bestaand document te gebruiken of te wijzigen.
De best werkende oplossing zou zijn om foutrapportage uit te schakelen met libxml_use_internal_errors:
$dom = nieuw DOMDocument; libxml_use_internal_errors(waar); $dom->loadHTML("..."); libxml_clear_errors();
Je kunt het ook doen
@$dom->loadHTML($htmlString);
U kunt de fouten filteren die u van de analyser ontvangt. Schakel, volgens andere antwoorden hier, de foutrapportage op het scherm uit en speel vervolgens de fouten opnieuw af en toon alleen de fouten die u wilt:
Libxml_use_internal_errors(TRUE); // Laad hier $errors = libxml_get_errors(); foreach ($fouten als $error) ( /* @var $error LibXMLError */ )
Hier is print_r() van één fout:
LibXMLError Object ( => 2 => 801 => 17 => Tagsectie ongeldig => => 39)
Bijpassende boodschap en/of code kunnen eenvoudig worden gefilterd.
Dit werkte voor mij:
Als je een title-tag nodig hebt, verander dan de titel met een div-tag en gebruik een id. Bijvoorbeeld:
$zoeken = array("
Dit is niet de beste oplossing, maar afhankelijk van de situatie kan het nuttig zijn.
Er lijkt geen manier te zijn om waarschuwingen te elimineren, maar geen fouten. PHP heeft constanten die dit zouden moeten doen, maar deze lijken niet te werken. Dit is wat MOET werken, maar niet omdat (een bug?)….
$doc=nieuw DOMDocument(); $doc->loadHTML(" Hoi
HTML5-tags gebruiken bijna altijd attributen zoals id, class, etc. De te vervangen code zou dus zijn:
$html = file_get_contents($url); $zoeken = array("
Ik heb vaak over dit probleem gehoord van andere gebruikers. Sommigen moeten vanwege de hoster de fouten die verschijnen verbergen, anderen moeten juist begrijpen wat er met hun code gebeurt, omdat er geen enkele fout wordt weergegeven. In dit artikel zal ik proberen de belangrijkste manieren te tonen om fouten weer te geven/te verbergen.
In een PHP-script
1) Er is slechts één verklaring in PHP die het foutbeheersysteem ondersteunt: dit is teken @. Hiermee kunt u elke foutmelding negeren. Het moet vóór een expressie worden geplaatst die het kan bevatten.Er zit een opzettelijke fout in het voorbeeld, maar deze wordt NIET weergegeven
$waarde = @$var[$sleutel];
2)
U kunt ook een parameterinstelling voor de foutweergave invoegen vóór het PHP-script dat u controleert ( display_fouten). Het kan de waarde Aan (toon) of Uit (verbergen) aannemen.
Ini_set("display_errors", "Aan");
error_reporting("E_ALL");
En dienovereenkomstig, na de code die op fouten is gecontroleerd, stelt u de parameter terug.
Ini_set("display_errors","Uit");
U wilt bijvoorbeeld fouten in het script zien
Ini_set("display_errors", "Aan"); // foutmeldingen worden getoond
error_reporting(E_ALL); // E_ALL - toon ALLE fouten
$waarde = $var[$sleutel]; // foutvoorbeeld
ini_set("display_errors", "Uit"); // nu zullen er GEEN berichten zijn
Je kunt het andersom instellen (bovenaan uit en onderaan aan), zodat fouten NIET in een specifiek gedeelte van de code worden weergegeven.
In het .htaccess-bestand
Meestal wordt het probleem opgelost door de instellingen in het bestand op te geven .htaccess, die zich in de hoofdmap van de site bevindt. In de regel php_flag display_errors moet je ook Aan of Uit zettenPhp_flag display_errors Aan
#toon alle fouten behalve waarschuwingen (Opmerking)
php_value error_reporting "E_ALL & ~E_NOTICE"
In het php.ini-bestand
Zoals u kunt zien, kan de parameter op verschillende plaatsen worden opgegeven. Als u echter wilt dat deze parameter een bepaalde waarde heeft op de hele site, dan is het eenvoudiger om deze in het bestand php.ini in te stellen (deze is mogelijk niet altijd toegankelijk op de hosting), maar in dit geval kunt u zelfs de instellingen van de gehele hostingIN php.ini:
Error_reporting = E_ALL
display_errors Aan
In de bovenste regel selecteren we alle soorten fouten, in de onderste regel geven we groen licht voor de weergave ervan.
Na de bewerkingen moet u Apache opnieuw opstarten om de instellingen te wijzigen en van kracht te laten worden (sierlijk of opnieuw opstarten):
Sudo apachectl -k sierlijk
In welke volgorde wordt de foutparameter verwerkt?
Helemaal aan het begin wordt rekening gehouden met de parameter php.ini, vervolgens met .htaccess en vervolgens met wat rechtstreeks in het PHP-script is opgegeven. Dus als iets niet werkt, zoek dan de keten op, misschien is daar een andere setting.Zoals altijd bedankt voor uw aandacht en veel succes! Ik hoop dat het artikel nuttig was!
PHP ondersteunt één foutcontroleoperator: het @-teken.
Als het voorafgaat aan een expressie in PHP-code, worden eventuele foutmeldingen die door die expressie worden gegenereerd, genegeerd. Als u uw eigen foutafhandelingsfunctie hebt geïnstalleerd met behulp van set_error_handler() , dan wordt deze echter nog steeds aangeroepen als binnen deze functie de functie wordt aangeroepen error_reporting()
, dan zal het 0 retourneren als de functie die de gegeven fout veroorzaakte, onderdrukt werd met @. Als de optie is geïnstalleerd track_fouten
, worden alle gegenereerde foutmeldingen opgeslagen in de $php_errormsg variabele.
Deze variabele wordt bij elke nieuwe fout overschreven, dus controleer deze indien nodig onmiddellijk.
// Opzettelijke fout bij het werken met bestanden $my_file = @file("non_existent_file") of sterven(
"Fout bij openen bestand: De foutmelding was: "
$php_errormsg "" );
// werkt voor alle expressies, niet alleen voor functies
?>
$waarde = @ $cache [$sleutel];: // Als er geen $key is, wordt de foutmelding (opmerking) niet weergegeven Opmerking De operator @ werkt alleen met expressies. Er is een eenvoudige regel: als iets een waarde retourneert, kunt u de operator @ ervoor gebruiken. U kunt bijvoorbeeld @ gebruiken vóór de naam van een variabele, willekeurige functie of aanroep erbij betrekken
, constant enzovoort. Tegelijkertijd kunt u deze operator niet gebruiken vóór een functie- of klassedefinitie, voorwaardelijke constructies zoals , dan wordt deze echter nog steeds aangeroepen als binnen deze functie de functie wordt aangeroepen als
, foreach, enz.
Bekijk ook de functiebeschrijving
en het handmatige gedeelte Foutafhandeling en registratiefuncties.
Aandacht
Tegenwoordig onderdrukt de operator "@" de uitvoer van berichten, zelfs over kritieke fouten die het script onderbreken. Dit betekent onder andere dat als u "@" gebruikt om fouten te onderdrukken die optreden bij het uitvoeren van een functie, als deze niet beschikbaar is of verkeerd is geschreven, de verdere uitvoering van het script zonder enige kennisgeving wordt gestopt.
12 jaar geleden
Om fouten voor een nieuwe klasse/object te onderdrukken:
// Getest: PHP 5.1.2 ~ 13-10-2006
// Typisch voorbeeld
// Werkt NIET!
//$var = nieuw @some_class(); // syntaxisfout
?>
Ik vond dit het handigst bij het verbinden met een
database, waar ik de fouten wilde controleren
en waarschuwingen die aan de klant worden weergegeven, terwijl hij stilstaat
met behulp van de klassenstijl van toegang.
14 jaar geleden
Gebruik beter de functie trigger_error() ()
om gedefinieerde mededelingen, waarschuwingen en fouten weer te geven, controleer dan zelf het foutniveau. Hiermee kunt u berichten naar logbestanden schrijven, indien gedefinieerd in de uitvoer van php.ini
berichten die afhankelijk zijn van het error_reporting()-niveau en onderdruk de uitvoer met het @-teken.
8 jaar geleden
Als u de ErrorException-uitzondering gebruikt voor uniform foutenbeheer, raad ik u aan om te testen met error_reporting in de fouthandler, en niet in de uitzonderingshandler, omdat u mogelijk problemen tegenkomt, zoals blanco pagina's, omdat error_reporting mogelijk niet wordt verzonden naar de uitzonderingshandler. .
{
}
functie catchException ($e)
{
{
opbrengst;
}
//Doe wat dingen
}
?>
Het zou beter zijn om te doen:
Functie exception_error_handler ($errno , $errstr , $errfile , $errline )
{
als (error_reporting() === 0 )
{
opbrengst;
}
Nieuwe ErrorException genereren ($errstr, 0, $errno, $errfile, $errline);
}
Set_error_handler("exception_error_handler");
functie catchException ($e)
{
//Doe wat dingen
}
Set_exception_handler("catchException");
?>
4 jaar geleden
Hoewel je zeker niet te liberaal moet zijn met de @-operator, ben ik het ook niet eens met mensen die beweren dat dit de ultieme zonde is.
Een zeer redelijk gebruik is bijvoorbeeld het onderdrukken van de meldingsfout die wordt gegenereerd door parse_ini_file() als u weet dat het .ini-bestand mogelijk ontbreekt.
In mijn geval was het verkrijgen van de FALSE-retourwaarde voldoende om die situatie aan te pakken, maar ik wilde niet dat er fouten door mijn API werden uitgevoerd.
TL;DR: Gebruik het, maar alleen als je weet wat je onderdrukt en waarom.
2 jaar geleden
Wat is het gedrag van PHP voor een variabele waaraan de retourwaarde is toegewezen van een expressie die wordt beschermd door de Error Control Operator wanneer de expressie een fout tegenkomt?
Op basis van de volgende code is het resultaat NULL (maar het zou mooi zijn als dit in alle gevallen bevestigd zou worden).
$var = 3;
$arr = array();
$var = @ $arr [ "x" ]; // wat is de waarde van $var na deze opdracht?
// is het de vorige waarde (3) alsof de toewijzing nooit heeft plaatsgevonden?
// is het FALSE of NULL?
// is het een uitzondering, foutmelding of foutnummer?
Var_dump($var); // drukt "NULL" af
?>
5 jaar geleden
Ik vroeg me af of iemand (anders) zou kunnen vinden dat een richtlijn voor het uitschakelen/inschakelen van de foutoperator een nuttige toevoeging zou zijn. Dat wil zeggen, in plaats van zoiets als (wat ik op een paar plaatsen in een bepaalde code heb gezien):
Als(gedefinieerd(PRODUCTIE )) {
@functie();
}
anders(
functie();
}
?>
Er zou zoiets als dit kunnen zijn:
Als (gedefinieerd (PRODUCTIE)) (
ini_set ("error.silent", TRUE);
}
anders(
ini_set ("error.silent", FALSE);
}
?>
en het handmatige gedeelte Foutafhandeling en registratiefuncties.
Als je alle foutmeldingen voor een php-script uit een sessie wilt loggen, kun je zoiets als dit gebruiken:
sessie_start();
functiefout ($error, $return = FALSE) (
globaal $php_errormsg;
if(isset($_SESSION [ "php_errors" ])) (
$_SESSION [ "php_errors" ] = array();
}
$_SESSION [ "php_errors" ] = $fout; // Gebruik misschien $php_errormsg
if($return == WAAR ) (
$bericht = "" ;
foreach($_SESSION [ "php_errors" ] als $php_error ) (
$berichten .= $php_error . "\N" ;
}
retourneer $ berichten; // Of u kunt $_SESSION["php_errors"] gebruiken
}
}
?>
Ik hoop dat dit iemand helpt...
PHP biedt een geweldige manier om eventuele fouten te beheersen. Hier zullen we praten over hoe om te gaan met een fout - rapporteer (of rapporteer) het incident aan de gebruiker, indien nodig - informeer de beheerder via e-mail, schrijf informatie over het incident naar een logbestand.
Laten we dus eerst definiëren welke fouten er in PHP zijn.
PHP ondersteunt de volgende foutniveaus:
E_ERROR
E_WAARSCHUWING
E_PARSE
E_NOTICE
E_CORE_ERROR
E_CORE_WARNING
E_COMPILE_ERROR
E_COMPILE_WARNING
E_USER_ERROR
E_USER_WARNING
E_USER_NOTICE
E_ALL
E_STRICT
In feite zijn dit slechts constanten die worden gebruikt om het niveau van foutafhandeling te bepalen en een bitmasker te construeren. Constanten hebben betekenisvolle namen. Als we naar de constante kijken, kunnen we zeggen dat de E_PARSE-niveaufout optreedt in het geval van een syntaxisfout, E_NOTICE is een herinnering aan de programmeur over de schending van de "goede stijl" van PHP-programmeren.
Enkele voorbeelden:
Wanneer een verbinding met een MySQL (of andere) database mislukt, rapporteert de PHP-interpreter een E_WARNING-fout
Waarschuwing: mysql_connect(): Toegang geweigerd voor gebruiker: "VVingless@localhost" (met wachtwoord: YES) In /home/mysite/index.php (regel 83)
Opmerking: Om ervoor te zorgen dat de PHP-interpreter fouten rapporteert, moet PHP dienovereenkomstig worden geconfigureerd: de display_errors-vlag moet zijn ingeschakeld - 1, de error_reporting-richtlijn moet aangeven dat het nodig is om fouten van het E_WARNING-niveau weer te geven (bij voorkeur natuurlijk andere ). Als de waarden van deze richtlijnen niet aan uw eisen voldoen, kunt u proberen ze zelf te installeren door een .htaccess-bestand in de map met het script te plaatsen (de punt aan het begin van de naam is vereist) met ongeveer de volgende inhoud:
Php_flag display_errors aan
php_value error_reporting "E_ALL & ~E_NOTICE"
Dit betekent dat foutmeldingen op alle niveaus worden weergegeven, behalve op E_NOTICE
Wanneer een programmeur een syntaxisfout maakt, rapporteert de PHP-interpreter een E_PARSE-niveaufout
Parseerfout: parseerfout, onverwacht ‘(‘, verwacht T_STRING in /home/mysite/index.php op regel 150
Maar de foutniveaus die voor ons het meest interessant zijn, zijn E_USER_ERROR en E_USER_WARNING. Zoals de naam al aangeeft, zijn dit foutniveaus die door de gebruiker kunnen worden ingesteld. Er is hiervoor een trigger_error() functie - met zijn hulp kun je de gebruiker op dezelfde manier op de hoogte stellen van een incident als PHP.
Zoals je uit de PHP-handleiding weet, heeft de functie trigger_error() twee parameters nodig.
void trigger_error (string error_msg [, int error_type])
De eerste parameter is een tekstfoutbericht, zoals 'bestand niet gevonden'. De tweede parameter bepaalt het foutniveau. De functie trigger_error() werkt alleen met de E_USER-foutenfamilie - dit betekent dat u foutniveaus E_USER_ERROR, E_USER_WARNING, E_USER_NOTICE kunt instellen en geen foutniveau E_WARNING kunt instellen. De tweede parameter is optioneel en is standaard E_USER_NOTICE.
Laten we proberen:
Laten we zeggen dat onze gegevens voor de nieuwsfeed zijn opgeslagen in het bestand news.txt, en als het bestand niet wordt gevonden, moeten we een fout melden. De programmatekst zal er ongeveer zo uitzien:
if (!file_exists(‘/home/mijnsite/nieuws.txt’)) (
trigger_error(‘Nieuwsbestand niet gevonden’);
}
Als gevolg hiervan rapporteert de PHP-interpreter een fout op niveau E_USER_NOTICE
Opmerking: Nieuwsbestand niet gevonden in /home/mijnsite/index.php op regel 47
Maar wat levert dit ons op? Om te beginnen, als richtlijnen zijn ingesteld in php.ini of het .htaccess-bestand
php_value log_errors "1"
php_value log_errors_max_len "1024"
php_value error_log "/home/mijnsite/mijn.log"
Vervolgens wordt er automatisch een record van het incident toegevoegd aan het bestand /home/mysite/my.log.
PHP-opmerking: Nieuwsbestand niet gevonden in /home/mijnsite/index.php op regel 47
Vervolgens kunnen we met behulp van de functie set_error_handler() onze eigen fouthandler instellen die optreedt tijdens de uitvoering van een PHP-script.
Zoals je uit de handleiding weet, heeft de functie in PHP 4 één enkele stringparameter nodig: de naam van de functie die wordt uitgevoerd telkens wanneer er een fout optreedt. PHP 5 maakt het mogelijk om nog een parameter in te stellen: het type fouten dat wordt verwerkt met onze handler. De functie retourneert een string: de naam van de handlerfunctie die tot nu toe is geïnstalleerd.
string set_error_handler (callback error_handler [, int error_types])
stel het zo in
set_error_handler("mijn_fout_handler");
Een aangepaste functie die fouten afhandelt, kan de volgende invoerparameters accepteren:
— foutniveaucode
— stringinterpretatie van de fout
— naam van het bestand waarin de fout is opgetreden
— de regel waar de fout is opgetreden
Er moet ook worden opgemerkt dat deze functie geen fouten kan verwerken op de niveaus E_ERROR, E_PARSE, E_CORE_ERROR, E_CORE_WARNING, E_COMPILE_ERROR, E_COMPILE_WARNING
Dit komt door het feit dat fouten op de vermelde niveaus optreden voordat de tolk informatie ontvangt over de aangepaste foutafhandelaar.
Laten we dus onze functie declareren
function mijn_error_handler($code, $msg, $file, $line) (
}
Opmerking: elk min of meer volumineus script is gewoonlijk verdeeld in verschillende bestanden om het werken ermee te vergemakkelijken. Hoe je de modulariteit van een programma kunt organiseren is een onderwerp voor een apart gesprek. Nu wil ik alleen maar adviseren om de algemene instellingen in een apart bestand te scheiden, dat aan het begin van het programma zal worden opgenomen met behulp van de include-instructie, of met behulp van de auto_prepend_file-instructie. Ook onze behandelaar kan in dit bestand geplaatst worden. De foutafhandelaar moet zo dicht mogelijk bij het begin van het programma worden geïnstalleerd, bij voorkeur helemaal aan het begin.
Om er zeker van te zijn dat dit echt werkt, gaan we een nieuw PHP-bestand maken en proberen het uit te voeren
Inhoud van het bestand myerrortest.php
n"; echo "$file ($line)"; ) set_error_handler("my_error_handler"); if (!file_exists("/home/mijnsite/news.txt")) ( trigger_error("Nieuwsbestand niet gevonden"); ) ?>
Het resultaat van de verwerking van dit bestand zal er als volgt uitzien:
Er is een fout opgetreden: Nieuwsbestand niet gevonden (1024)
/home/mijnsite/mijnfouttest.php (12)
Nu hebben we een functie die gegevens ontvangt over alle fouten die optreden. Laten we erover nadenken hoe we dit kunnen gebruiken.
Niveaufouten behandelen wij
E_ERROR
E_WAARSCHUWING
E_NOTICE
E_USER_ERROR
E_USER_NOTICE
De eerste drie fouten zouden in een goed compleet programma helemaal niet mogen voorkomen, daarom zullen wij de gebruiker er alleen over informeren door de fouttekst op het scherm weer te geven. Op deze manier kunt u werken terwijl het script in ontwikkeling is. Berichten daarover kunnen worden uitgeschakeld of in een logbestand worden vastgelegd.
Wat de andere twee betreft, zoals je al geraden had, kunnen ze daar nuttig zijn. Indien nodig zullen wij zelf op deze niveaus fouten veroorzaken. Laten we zeggen dat fouten van het E_USER_ERROR-niveau worden opgeroepen in het geval dat een foutmelding in het logbestand terechtkomt en naar een e-mail naar de beheerder wordt verzonden (er is bijvoorbeeld een fout opgetreden bij het uitvoeren van een SQL-query, of er was geen toegangswachtwoord voor een vereist bestand). Fouten op het E_USER_NOTICE-niveau worden veroorzaakt wanneer er “lichte” fouten optreden (de gebruiker heeft bijvoorbeeld het formulier onjuist ingevuld of een niet-bestaand record uit de database opgevraagd).
Nu zal onze foutafhandelingsfunctie er ongeveer zo uitzien:
// Enkele voorlopige instellingen // stel de foutweergavemodus in // toon alle fouten behalve E_NOTICE error_reporting (E_ALL & ~E_NOTICE); // deze constante is verantwoordelijk voor // het in-/uitschakelen van de foutopsporingsmodus // tijdens het debuggen - berichten worden niet verzonden // per e-mail, maar eenvoudigweg afgedrukt op het scherm definition("DEBUG", 0); // dit is een globale variabele die // het bericht opslaat dat // de gebruiker $MSG = "" moet zien; // e-mailadres van de ontwikkelaar waar fouten naartoe moeten worden gestuurd definiëren("ADM_EMAIL"," [e-mailadres beveiligd]"); // logbestand definiëren("LOGFILE","/home/mysite/mylog.log"); // tijdsverschil met de server (in seconden) definiëren("TIMEOFFSET", 0); // de functie zelf function my_error_handler($code, $msg, $file, $line) ( // globale variabele waarin de foutmelding zal worden geschreven // global $MSG; // sla fouten over op het E_NOTICE-niveau // en negeer fouten als de foutrapportage in de berichtmodus is uitgeschakeld als (($code == E_NOTICE) of (error_reporting() == 0)) ( return; ) // als we een E_USER_NOTICE-niveaufout hebben gegenereerd - // schrijf de fouttekst naar de globale variabele $MSG // en stop de uitvoering van de functie if ($code == E_USER_NOTICE) ( $MSG = $msg; Return; ) // als het foutniveau E_ERROR is - druk de fouttekst af // en voltooi de uitvoering van het script if ($code == E_ERROR) ( die ("
FOUT:".$msg."
In ".$bestand." (regel ".$regel.")
"); ) // als de fout zich op niveau E_WARNING bevindt, drukt u de fouttekst af // en stopt u met het uitvoeren van de functie als ($code == E_WARNING) ( echo "
WAARSCHUWING:".$msg."
In ".$bestand." (regel ".$regel.")
"; Return; ) // als het foutniveau E_USER_ERROR is if ($code == E_USER_ERROR) ( // schrijf de tekst in de $MSG variabele dat er een fout is opgetreden, // we zullen de redenen niet rapporteren, we zullen alleen rapporteren dat de details // naar een e-mail zijn verzonden naar wie dan ook $MSG = "Kritische fout: actie is niet voltooid.
Er is een foutmelding verzonden naar de ontwikkelaar."; // details worden geschreven naar de $text variabele $text = $msg."
"."Bestand: ".$bestand." (".$line.")"; // Als de DEBUG-constante is ingesteld op 1, drukken we informatie over // de fout af op het scherm, zo niet, dan sturen we de fouttekst per post // functie error_mail() en schrijf naar de log - functie error_writelog() if (DEBUG == 1) ( error_print($text); ) else ( error_mail($text); error_writelog($text); ) Return; "my_error_handler"); Nu beschrijven we de servicefuncties // function print een fout naar de schermfunctie error_print($text) ( echo $text."
"; ) // functie verzendt een fout per e-mail function error_mail($text) ( $text = str_replace("
", "n", $text); $info = "Tijd: ".get_datetime().."nRemote IP:".get_ip().."n"; mail(ADM_EMAIL, "Foutrapportage", $info.$text ); ) // f schrijft een fout naar de logfunctie error_writelog($text) ( $text = str_replace("
", "t", $text); if (@$fh = fopen(LOGFILE, "a+")) ( fputs($fh, get_datetime()."t".get_ip().."t".$text. "n"); fclose($fh); ) // haal de tijd op, rekening houdend met de tijdsverschilfunctie get_time() ( return(date("H:i", time () + TIMEOFFSET)); ) / / haal de datum op, rekening houdend met de tijdsverschilfunctie get_date() ( return(date("Y-m-d", time () + TIMEOFFSET)); ) // haal de datum en tijd op, rekening houdend met de tijdsverschilfunctie get_datetime() ( return get_date() ." ".get_time(); ) // haal de IP-functie get_ip() op ( return($_SERVER["REMOTE_ADDR"]); ) En tot slot een voorbeeld van gebruik // de functie schrijft nieuws naar een bestandsfunctie write_news($title, $ text) ( $news_file = "/home/mysite/news.txt"; // controleer op de aanwezigheid van een titel - de fout is niet kritisch als (!trim($title)) ( // om vast te stellen dat de functie is geëindigd // mislukt - het is noodzakelijk false terug te geven. Functie // trigger_error() - retourneert true, we zullen // het omgekeerde resultaat retourneren return !trigger_error("Nieuwstitel moet worden opgegeven "); ) // controleer op de aanwezigheid van de nieuwstekst - de fout is niet kritisch if (!trim($text)) ( return !trigger_error("U moet de nieuwstekst specificeren"); ) // controleer op de aanwezigheid van de nieuwstekst bestand waarnaar we zullen schrijven // als het bestand niet wordt gevonden - er treedt een kritieke fout op als (!file_exists($news_file)) ( return !trigger_error("Nieuwsdatabasebestand niet gevonden!", E_USER_ERROR); ) // .. .voorlopige gegevensverwerking hier... // schrijf het nieuws $fh = fopen ($news_file, "a+"); fputs($fh, $titel."t".$text."n"); fsluiten($fh); // als alles in orde is, retourneert de functie true return true; ) // probeert nieuws te schrijven // deze gegevens kunnen afkomstig zijn van een webformulier $res = write_news("Mijn nieuws", "Tekst van mijn nieuws"); if ($res === false) ( // als false wordt geretourneerd, drukt u de fout af echo $MSG; ) else ( // als alles in orde is, kunt u dit melden // of beter nog, stuur de gebruiker ergens heen. echo "Het nieuws is toegevoegd";
Om het voorbeeld te laten werken, kopieert u eenvoudigweg de drie voorgaande codeblokken naar een PHP-bestand. Vergeet niet de toegangsrechten tot het logbestand op 777 te zetten zodat het script ermee kan werken, de juiste paden in te voeren en je e-mailadres aan te geven. U kunt de foutopsporingsmodus inschakelen door de DEBUG-variabele in te stellen op 1.
