PHP-Tricks

Textdateien in PHP auslesen

- und darin enthaltene URLs:

"http://..."

zu anklickbaren Verweisen in HTML machen:

Man muß sich entscheiden: Array oder Zeichenfolge?

$Zeilen = file($Datei);

// Liest die Datei ($Datei) zeilenweise (!) in ein Array.

$JZeilen = join(" ",$Zeilen);

// Macht aus dem Array eine Zeichenfolge

// Achtung:
// Die (neue) Funktion 'file_get_contents()' arbeitet ähnlich wie 'file()', nur mit dem Unterschied,
// dass der Inhalt einer Datei komplett(!) als Zeichenfolge (String) ausgegeben wird

// Weiter:
// [wird der Parameter 'regs' angegeben, werden alle Treffer weiter in einem Array gespeichert]

for($x=0;$x<count($Zeilen);$x++)
{
if ($Suchstring != "" && eregi ($Suchstring, $Zeilen[$x], $regs))
{

// Das folgende trennt eventuelle im Text aufeinanderfolgende URLs:

$ZZeilen = eregi_replace ("http", "|http", $Zeilen[$x]);

// Das nächste wirft die URLs (meistens) als anklickbare Verweise aus.
// Vorher! Alle HTML-Tags in der Textdatei maskieren,
// damit diese in HTML als Text dargestellt werden und kein Unheil anrichten:

$ZZeilen = htmlentities($ZZeilen);

// Von http://www.php-faq.de/q-regexp-uri-klickbar.html / übernommen und abgeändert:
// [Es gibt im Netz noch umfassendere Suchmuster zu finden:
// http://mathiasbynens.be/demo/url-regex]

$suchmuster = '#(^|[^\"=]{1})(http://|ftp://|mailto:|news:)([^\s<>]+)([\s\n<>]|$)#sm';
$ersetzung = "\\1<a href=\"\\2\\3\"><u>\\2\\3</u></a>\\4";

$ZZeilen = preg_replace($suchmuster, $ersetzung, $ZZeilen);

echo $ZZeilen;

}
}

--------------

Will man nur die URLs in Verweise umwandeln, die im Text alleine stehen,
also vorne und hinten durch Leerzeichen oder Zeilenumbrüche abgegrenzt sind,
kann man diesen regulären Ausdruck nehmen:

$suchmuster = "#[ | // Leerzeichen oder Zeilenumbruch vor der URL
]((http|https|ftp)://[^\s$]+)#";

$ZZeilen = preg_replace($suchmuster, ' <A HREF="$1">$1</A> ', $ZZeilen);

Arrays oder Strings kombinieren

Arrays bzw. Strings kombinieren und wechseln:

<?PHP

$Wert1 = "eins";
$Wert2 = "zwei|drei|vier|fünf";
$Wert3 = "vier";

$Wertesammlung = array($Wert1,$Wert2,$Wert3);

$Kombination = implode('|', $Wertesammlung);

// Macht daraus:

// eins|zwei|drei|vier|fünf|vier

echo $Kombination;

// Man kann es auch als Array belassen bzw. ausgeben:

$Array_Kombination = explode("|", $Kombination);

print_r ($Array_Kombination);

// Oder, wenn jeder Wert nur einmal vorkommen soll:

$Array_Kombination = array_unique(explode("|", $Kombination));

// Der Witz liegt darin, für Haupt- und Unterstrings bzw. Haupt- und Unterarrays
// jeweils das selbe Trennzeichen zu benutzen;
// dann zerfällt der String anschließend in ein Array aus kombinierten Einzelwerten.

print_r ($Array_Kombination);

// Allerdings sind nach 'array_unique' die Schlüssel nicht mehr durchgängig vorhanden,
// denn sie werden ggf. mit entfernt.

// Aus:

Array ( [0] => x [1] => x [2] => y )

// wird so:

Array ( [0] => x [2] => y )

// Das führt zu interessanten Verarbeitungsfehlern.
// Lösung: Das Array neu durch nummerieren.

$Array_Kombination = array_merge_recursive($Array_Kombination);

// Ergibt:

Array ( [0] => x [1] => y )

?>

Arrays oder Strings addieren

In PHP Werte laufend rekursiv addieren:

$AddiertesArray = array(); // Für ein Array

for($a=0; $a<$AnzahlDerWerte; $a++)
{

// Addiert die einzelnen Werte zu einem

// Im Array:

$AddiertesArray[$a]=$NeuerWert[$a];

// Im String:

$AddierterWert = $AddierterWert.$NeuerWert[$a];

// Mit Trennzeichen X:

$AddierterWert = $AddierterWert. "X" .$NeuerWert[$a];

}

Bei jedem Durchlauf wird die neue Zeichenkette an die alte angehängt,
optional getrennt durch ein Trennzeichen.

[Im ersten Durchlauf ist der addierte Wert noch nicht vorhanden]

Array auf Wert setzen & prüfen

Leervorgaben

Häufig muß man in PHP (und JavaScript) Variablen oder einen Verarbeitungswert (wieder) auf null setzen bzw. diese definieren, damit das Script im ersten Durchgang keinen Fehler auswirft in der Art "existiert nicht" (im Gegensatz zu set/isset/unset, womit man sie löscht).

In PHP:

$EineVariable = 0;
$EineVariable = "";
...

$EinArray = array();
...

ganz an den Anfang des Skriptes setzen

-----------

Umgekehrt: Die Fehlerabfrage

Prüfen, ob ein Array nicht leer ist, d.h. prüfen, ob ein Array existiert und ob es einen Wert enthält (nicht einen bestimmten, sondern überhaupt irgend einen Wert)

if (is_array($Fragliches_Array) && ((bool)$Fragliches_Array[0]))

liefert FALSE

bei

$Fragliches_Array = "";

$Fragliches_Array = array();

$Fragliches_Array = array("");

- letzterer Fehler ist sonst kaum abzufangen, da PHP in dem Fall automatisch einen Schlüssel generiert

Text-Zeilentrenner

Zeilentrenner

Problem: Eine Textdatei soll zeilenweise eingelesen und zeilenweise getrennt ausgegeben werden

Kein Problem:

// Datei als Array einlesen:
$Zeilen = file($Datei);

print_r($Zeilen);

Soll aber die Datei als Ganzes gelesen und danach in Absätze unterteilt ausgegeben werden,
muß nach (mindestens) doppelten Zeilenumbrüchen gefahndet werden - und das ist nicht ganz so einfach.

So geht es:

// Datei als String einlesen:
$ZeilenString = file_get_contents($Datei);

Anschließend doppelte Zeilenumbrüche suchen;

// Entweder den doppelten Zeilenumbruch direkt in den Code eingeben:
// Den doppelten Zeilenumbruch so lassen!
$Zeilen = explode("

",$ZeilenString);
// Den doppelten Zeilenumbruch so lassen!
// Ohne Einzug!

// oder diese Variante wählen:
$Zeilen = explode("\r\n\r\n",$ZeilenString);

- Was immer auf dem Server geht.

- Wer außerdem die Zeilenumbrüche erhalten will, setzt später davor noch ein

nl2br(...

Ausgabe:

for($x=0;$x<count($Zeilen);$x++)

{

// Ohne Zeilenumbrüche:

echo $Zeilen[$x];

// Mit Zeilenumbrüchen:

echo nl2br($Zeilen[$x]);

}

Mehrere Worte ersetzen

Mehrere Ausdrücke in einem String ersetzen:

$str = 'gehabt haben worden sein.';

$search = array('worden','sein','gehabt','haben');
$replace = array('alles','gut','Morgen','wird');

$Ausgabe = (str_replace($search, $replace, $str));

Ergebnis: Morgen wird alles gut

['str_replace' beachtet dabei Groß- und Kleinschreibung, 'str_ireplace' nicht]

Alternativ (unterscheidet zwischen Groß- und Kleinschreibung):

$Tauschen = array(
"eins" => "zwei",
"sechs" => "sieben",
"zehn" => "dreiundzwanzig",
"und so" => "weiter"
);

$String = strtr($String, $Tauschen);

- So können mit 'strtr' auch unterschiedlich große Ausdrücke ersetz bzw. ausgetauscht werden.

-----

Bestimmte Worte hervorheben, ohne sie zu verändern:

$String = "Zwei mal zweiundzwanzig Zwei";

$Wort = "zwei";

$String = preg_replace('/('.$Wort.')/i', '<B>$1</B>', $String);

Ergibt:

<B>Zwei</B> mal <B>zwei</B>undzwanzig <B>Zwei</B>

- Die Groß- und Kleinschreibung bleibt wie im Original erhalten!

ACHTUNG:

- ('.$Wort.') muß hier in Klammern gesetzt werden, damit PHP es als Variable erkennt, und mit $1 genau den gefundenen Suchausdruck wieder darstellen kann - die zweite Variable (in Klammern) wäre dann $2, und so weiter - aber immer nur innerhalb EIN UND DERSELBEN Ersetzungsfunktion!

- Einzubinden ohne Punkt '.'
- Außer zwischen zwei anderen Variablen - dann ja, aber mit Anführungszeichen: $xy.'$1'.$z
- Den Suchausdruck bei Fehlern versuchsweise doppelt in Anführungszeichen setzen: '/('.$Wort.')/i'
- Bei weiterer Fehlfunktion doppelte Anführungszeichen versuchen: "/<('.$Wort.')/i"
- Mehrere Variable in regulären Suchausdrücken ohne Punkt verbinden: "/<('.$Wort$NochEinWort.')/i"

- Eine solche Such-&-Ersetze- Variable läßt sich durch (einklammern) überall in jedem regulären Ausdruck definieren

HTML- Code validieren

HTML-Code in PHP validieren

- gefunden auf:

http://stackoverflow.com/questions/3059398/how-to-close-unclosed-html-tags

Machmal ist es notwendig, HTML-Code in PHP zu verarbeiten, und nicht immer ist der resultierende HTML- Code korrekt.

Um wenigstens die gröbsten HTML-Fehler, wie nicht geschlossene HTML-Tags, zu beseitigen und einen gültigen HTML-Code zu erzeugen, kann man ab PHP 5 die interne Funktion "DOMDocument" benutzen:

// Parse HTML

$internal_errors = libxml_use_internal_errors(true);

$doc = new DOMDocument();
$doc->loadHTML("$MeinHtmlCode");
$MeinHtmlCode = $doc->saveHTML();

libxml_use_internal_errors($internal_errors);
libxml_clear_errors();

Der HTML-String wird damit völlig neu aufgebaut.

Die 'error'- Zeilen davor und danach unterdrücken die dabei entstehenden Fehlermeldungen.

HTML- Code zu Text

HTML-Text komplett zu reinem Text entformatieren:

$Bereinigt = strip_tags($HTMLDatei);

echo html_entity_decode($Bereinigt);

-> Allerdings auch ohne Absätze, jedenfalls in der HTML-Ausgabe.
-> Die originalen Zeilenumbrüche (\r\n) des Quellcode blieben jedoch erhalten;
-> Man kann diese Datei also als Text ausgeben lassen.

print "\n<PRE>\n";
echo html_entity_decode($Bereinigt);
print "\n</PRE>\n";

Wer will, kann andererseits vorher etwa mit

$search = array('<TD>','<LI>','etc.');
$replace = array(';',' - ','etc.');

$HTMLDatei = (str_ireplace($search, $replace, $HTMLDatei));

bestimmte HTML-Tags für die HTML-Ausgabe in eine ansprechende Text-Formatierung umwandeln lassen.

Dagegen die Ausgabe mit Absätzen in HTML:

$Bereinigt = strip_tags($HTMLDatei, '<p><br>');

// Beläßt diese Tags als Ausnahmen bestehen
// Diese und weitereTags können nach Bedarf eingefügt werden, z.B. auch <TD> oder <LI>

echo html_entity_decode($Bereinigt);

[Das Ganze geht natürlich nur, wenn der HTML-Code auch korrekt geschrieben wurde]

HTML-Tags ausschließen

Manchmal möchte man im sichtbaren Text einer HTML-Datei nach einem Begriff suchen,
aber nicht in den HTML-Tags.

Das ist einfacher als man glaubt:

// Holt den Inhalt einer Datei als Zeichenfolge:
$HTMLDatei = file_get_contents("HTML-Datei.htm");

// Entfernt die HTML-Tags
// Auch einfache Kommentare - jedoch nicht HTML-Tags plus Text in Kommentaren!

$Bereinigt = strip_tags($HTMLDatei);

if ($Suche != "" && eregi ($Suche, $Bereinigt, $regs))
{
usw...
}

---

Allerdings ist mit dieser Methode keine Ersetzung im HTML-Code möglich, da dieser durch STRIP_TAGS für die Suche ja beseitigt wurde.

Das ist etwas komplizierter: Suche und Ersetze Text, der nicht in HTML-Tags steht

(geholt von http://stackoverflow.com/ - - negative lookahead, negative Vorausschau)

[~i = ignoriere Großschreibung]

Methode 1:

// - Suche NICHT in Verweisen (A -Tags) - auch nicht im Veweistext zwischen den <A...> </A> - Tags:

$Suche_Das = '~$SuchWort(?![^<]*</a>)~i';

Methode 2:

// - Suche NICHT in Verweisen (A -Tags) - auch nicht im Veweistext zwischen den <A...> </A> - Tags:

$Suche_Das = '~<a.*?</a>(*SKIP)(*F)|$SuchWort~i';

// - Suche NICHT in irgend einem HTML-Tag:

$Suche_Das = '~<.*?>(*SKIP)(*F)|$SuchWort~i';

[*? = Suche so kurz wie möglich - d. h. jeden Tag einzeln nehmen,
und nicht den ersten bis zum letzten Tag im Text als einen einzigen sehen]

// Dann:

$Ergebnis = preg_replace($Suche_Das, $Ersetze_Durch, $HTMLDatei);

Echo $Ergebnis;

Anmerkung:

- Es macht manchmal eine Unterschied, ob man einen komplexen regulären Ausdruck in doppelte "~~" oder einfache '~~' Anführungszeichen setzt.

- Hat man vorher den String auf HTMLEntities gesetzt, muß auch der Ausdruck "<.*?>" in "<.*?>" umgewandelt werden.
- Aber nur dann.

----------------

Ähnlich:

$Suche_Nach = "~<A HREF((?:(?!</A>).)+)$DasHier~i";

Suche nach "<A HREF" gefolgt von etwas, was nicht "</A>" ist (= ersetzbar durch $1), gefolgt von $DasHier;

$Suche_Nach = "~<A HREF((?:(?!</A>).)*)$DasHier~i"; // Sternchen '*' statt Plus '+'

Suche nach "<A HREF" gefolgt von nichts oder etwas, was nicht "</A>" ist (= ersetzbar durch $1), gefolgt von $DasHier;

Seitenbereiche ausblenden

<?PHP if (!($Einblenden)) echo "

Arrays auflösen und Elemente zählen

Arrays auflösen und die Elemente verkoppeln:

if (Irgendwas)

{

// WICHTIG! Parameter-Zähler:
$pz = $pz+1;

if (count($Array) == 2 )

{
// Werte-Zuordnung Einzeln

list($Parameter,$Wert) = $Array;

$Parameter = trim($Parameter);
$Wert = trim($Wert);

echo "\n<BR>\n";

echo "Parameter $pz: $Parameter";
echo "\n<BR> \n";
echo "Wert $pz: $Wert";

echo "\n<P>\n";

$ParameterWert = "$$Parameter = \"$Wert\"";

eval ("\$ParameterWert = $ParameterWert;");

echo "\n<BR> \n";

echo "<U>Wertepaar $pz</U>: $Parameter: $ParameterWert ";

}

Ergibt:

Wertepaar 1: Etwas = soviel

Wertepaar 2: EtwasAnderes = soviel mehr

etc.