PHP – Łańcuchy znaków i wyrażenia regularne.


Spis zagadnień:

  1. Łańcuchy znaków
    1. echo/print
    2. addslashes/stripslashes
    3. explode/implode
    4. str_split
    5. htmlspecialchars/strip_tags
    6. nl2br
    7. password_hash
    8. strlen
    9. strpos
    10. wielkość liter
    11. str_replace
    12. substr
    13. substr_replace
    14. strstr
    15. strtr
    16. trim
    17. przykłady
    18. zadania do wykonania
  2. Wyrażenia regularne


Łańcuchy znaków

Łańcuchy znaków (ciągi), to zmienne typu string, które możemy formatować za pomocą wielu funkcji wbudowanych języka PHP.

Pełną listę funkcji znajdziecie w dokumentacji PHP,  poniżej najczęściej wykorzystywane.

echo/print

Drukowanie treści na ekranie. Różnice pomiędzy nimi są znikome, jeżeli chodzi o szczegóły (ilość argumentów, które zachowuje się jak funkcja, a które nie) – odsyłam do dokumentacji. Jedno jest pewne – echo jest szybsze!

<?php 
echo "Hello World!"; // wyświetli napis: Hello World! 
print "Hello World!"; // alternatywne wyświetlanie: Hello World! 
echo "<br>"; //w ten sposób dodajemy wyświetlanie nowej linii

//wyświetlanie wielu linii
echo "Ten zapis obejmuje wiele linii.
Będą one wyświetlane, ale w jednej linii.
Nie zostanie automatycznie dodany znacznik nowego wiersza."; 

echo "<br>Ten zapis również obejmuje wiele linii.<br>
Będą one wyświetlane, w wielu liniach,<br>
przez dodanie znacznika nowego wiersza."; 

echo "<br>"; 

//wyświetlanie znaków specjalnych tj. "" musimy poprzedzić backslash'em
echo "Jeżeli chcemy wyświetlić cudzysłów \"Przykład\"."; 

echo "<br>"; 

// Wyświetlanie zawartości zmiennych 
$zmienna1 = "wartość zmiennej 1"; 
$zmienna2 = "wartość zmiennej 2"; 
echo "zmienna1 = $zmienna1, a zmienna2 = $zmienna2"; // foo is foobar 

echo "<br>"; 

// używając apostrofu wyświetlamy dokładnie to co znajduje się pomiędzy apostrofami (nie pobiera zawartości zmiennej)
echo 'wartość zmiennej 1 znajduje się w $zmienna1'; // wartość zmiennej 1 znajduje się w $zmienna1 

echo "<br>"; 

// jeżeli wyświetlamy samą zmienną nie musimy używać cudzysłowów, ani apostrofów 
echo $zmienna1; // wartość zmiennej 1 

echo "<br>"; 

//łączenie wielu elementów do wyświetlenia
echo $zmienna1.$zmienna2."<br>"; // za pomocą kropki dołączamy kolejne zmienne 
echo $zmienna1,$zmienna2."<br>"; // przecinek działa podobnie, nie jest używany - stosujemy kropkę


// Some people prefer passing multiple parameters to echo over concatenation. 
echo 'Można ', 'łączyć ', 'wiele ', 'elementów ', ' oraz dodawać zmienne ', $zmienna1, '<br>'; 
echo 'Można '. 'łączyć '. 'wiele '. 'elementów '. ' oraz dodawać zmienne '. $zmienna1. '<br>'; 

//alternatywna metoda wyświetlania. Działa pod warunkiem, iż łańcuch rozpocznie się i zakończy tym samym słowem, w tym wypadku END. Nie jest to jednak metoda często spotykana.
echo <<<END
Ten tekst może być wielolinijkowy w wedytorze.
Niestety w przeglądarce zostanie wyświetlony w jednej linii.
END;

echo "<br>";

// wyświetlanie tablicowe
$tablica = array("indeks" => "wartość"); 
echo "wartość dla indeksu = {$tablica['indeks']} !"; // wyświetli: wartość dla indeksu = wartość ! 

echo "<br>";

// wyświetlanie z warunkiem jeżeli (warunek) ? 'wartość gdy prawda' : 'wartość gdy fałsz'
echo ($zmienna1) ? 'true' : 'false';
  
?>
<p>użycie PHP w HTML <?php echo $zmienna1; ?></p>
<p>użycie PHP w HTML w skróconej formie <?=$zmienna1;?></p>


addslashes()/stripslashes()

Funkcje te są stosowane przy operacjach na bazie danych.

Przed zapisem jakiegokolwiek łańcucha znaków do bazy danych należy go sformatować przy użyciu funkcji addslashes().

Funkcja addslashes() dodaje backslash \ do ciągu znaków zawsze wtedy, gdy natrafi na tzw. „znak ucieczki”, czyli taki znak który najczęściej pozawala na dokonanie ataku SQL Injection – pojedynczy cudzysłów ( ‚), podwójny cudzysłów ( „), backslash (\) i NULL.

<?php
$text = "Muszę zapisać znak ', czyli apostrof.";
echo addslashes($text); 
//zostanie wyświetlone: Muszę zapisać znak \', czyli apostrof. 
?>

Po odczytaniu łańcucha znaków z bazy danych, należy przywrócić oryginalną składnię znaków specjalnych, czyli usunąć poprzedzające je znaki backslash. Do tego celu służy funkcja stripslashes().

<?php 
$text = "Muszę odczytać z bazy znak \', czyli usunąć backslash."; 
echo stripslashes($text); 
//zostanie wyświetlone: Muszę zapisać znak ', czyli usunąć backslash. 
?>

W pliku php.ini istnieje opcja magic_quotes_gpc, która może przyjmować wartość On lub Off. Gdy jest włączona, będzie wykonywała za nas opcje funkcji addslashes().

explode/implode()

PHP umożliwia zamianę ciągów tekstowych na tablice i odwrotnie. Zamiana ciągu na tablicę jest bardzo przydatna jeśli zachodzi potrzeba „wyciągnięcia” jakiegoś fragmentu danych z ciągu. Załóżmy że w odczytaliśmy z pliku z danymi (o odczycie z plików w jednym z kolejnych rozdziałów) linię z logu zapisanego przez licznik WWW: „12/11/2000;19:23:33;Netscape Navigator;192.168.1.1”. Jak widać dane rozdzielone są średnikami. Do rozdzielania ciągów na tablicę służy funkcja explode(). Jako pierwszy parametr trzeba do niej podać znak lub dłuższy ciąg który oddziela kolejne pola, jako drugi ciąg do rozdzielenia. Opcjonalnie można podać trzeci argument, który oznacza maksymalną liczbę pól – jeśli jest ich więcej niż ta liczba, to ostatnie pole będzie zawierało wszystkie pozostałe pola. Funkcja zwraca tablicę zawierającą kolejne pola.
Przykładowo:

<?php 
$dane="alfa;beta;gamma;delta";
$tablica = explode(";", $dane); 
?>

Czasem potrzebne jest działanie pozwalające na złącznie pól tablicy w jeden ciąg, w którym pola oddzielone są jakimś znakiem (lub kilkoma). Do tego służy funkcja implode(). Jako pierwszy parametr podawany jest ciąg za pomocą którego „sklejane” są elementy tablicy, a jako drugi właśnie tablica do posklejania. Zwracany jest ciąg zawierający „posklejane” elementy. Przykład zastosowania:

<?php $dane = implode(";", $tablica); ?>

str_split()

Funkcja rozdziela ciąg na tablicę. Budowa:

str_split(tekst[,długość_podziału]

<?php
$str = "Hello Friend";

$arr1 = str_split($str);
$arr2 = str_split($str, 3);
echo '<pre>';
print_r($arr1);
print_r($arr2);
echo '</pre>';

/* zostanie wyświetlone
Array
(
    [0] => H
    [1] => e
    [2] => l
    [3] => l
    [4] => o
    [5] =>  
    [6] => F
    [7] => r
    [8] => i
    [9] => e
    [10] => n
    [11] => d
)
Array
(
    [0] => Hel
    [1] => lo 
    [2] => Fri
    [3] => end
)
*/
?>

 htmlspecialchars()/strip_tags()

Pozwala zapewnić bezpieczeństwo strony www przed niechcianym kodem. Obie funkcje filtrują znaki specjalne pod kontem znaczników HTML i PHP.

<?php

// niebezpieczny tekst zawierający link do strony konkurencji
$string = '<a href="adres">Niebiezpieczny link</a> do <b>strony konkurencji</b>.';

$string_html = htmlspecialchars($string); // wyświetli: <a href="adres">Niebiezpieczny link</a> do <b>strony konkurencji</b>.

$string_strip = strip_tags($string); // wyświetli: Niebiezpieczny link do strony konkurencji.

echo $string_html .'<br/>'.$string_strip ;

?>

Funkcja htmlspecialchars() zamienia znaki specjalne na ich „bezpieczne” odpowiedniki wg wzoru:

& (ampersand) zmieniany jest na &amp;

” (cudzysłów) zmieniany jest na &quot;

‚ (apostrof) zmieniany jest na &#039; (lub &apos;)

< (mniejsze) zmieniany jest na &lt;

> (większe) zmieniany jest na &gt;

Funkcja strip_tags() usuwa znaczniki HTML-a pozostawiając sam tekst.

nl2br()

Funkcja zamienia wszystkie znaki \n na znacznik HTML <br />

<?php
echo nl2br("Zamieniamy znak nowej linii\n na znacznik HTML");
?>

password_hash()

Jest to funkcja hashująca dany ciąg znaków. Używana jest najczęściej do szyfrowania haseł.

<?php
echo password_hash("rasmuslerdorf", PASSWORD_DEFAULT); 
?>

password_verify()

Jest to funkcja sprawdzająca czy zahashowane hasła zgadzają się z podanymi.

<?php
if (password_verify('rasmuslerdorf', $hash)) {
    echo 'Password is valid!';
} else {
    echo 'Invalid password.';
} 
?>

strlen()

Wyświetla długość ciągu.

<?php
$str = 'abcdef';
echo strlen($str); // 6

$str = ' ab cd ';
echo strlen($str); // 7
?>

strpos()

Zwraca numeryczną pozycję pierwszego wystąpienia szukanego znaku w ciągu. Jako trzeci parametr, można ustawić numer znaku, od którego funkcja ma zacząć przeszukiwać.

strpos(string,find[,start])

<?php
echo strpos("I love php, I love php too!", "php")."<br>"; //7
echo strpos("I love php, I love php too!", "php", 8); //19
?>

strtolower()/strtoupper()/ucfirst()/ucwords()

Funkcje odpowiedzialne za zmianę wielkości liter.

<?php
$str = "Marysia Ma Małego Baranka, Którego Bardzo KOCHA.";

//zmiana na wielkie litery
$str = strtoupper($str); 
echo $str.'<br>'; // Wyświetli: MARYSIA MA MAłEGO BARANKA, KTóREGO BARDZO KOCHA

//zmiana na małe litery
$str = strtolower($str); 
echo $str.'<br>'; // Wyświetli: marysia ma małego baranka, ktorego bardzo kocha

//jak w zdaniu
$str = ucfirst($str); 
echo $str.'<br>'; // Wyświetli: Marysia ma małego baranka, którego bardzo kocha

//wielka każda pierwsza litera wyrazu
$str = ucwords($str); 
echo $str.'<br>'; // Wyświetli: Marysia Ma Małego Baranka, Którego Bardzo Kocha
?>

str_replace()

Funkcja zastępuje podany tekst innym. Budowa:

str_replace(znajdź, zastąp, string[, $jakaś_nazwa]), gdzie do opcjonalnej zmiennej $jakaś_nazwa zostanie wpisana ilość zmian jakich dokona funkcja

<?php

$tekst = "Jeśli jesteś za podnieś rękę";
$wynik = str_replace("za", "przeciw", $tekst, $count); //ostatni 
parametr $count jest opcjonalny i pozwala wyświetlić liczbę dokonanych 
zmian
echo $tekst."<br>";//Jeśli jesteś za podnieś rękę
echo $wynik."<br>";//Jeśli jesteś przeciw podnieś rękę 
echo "Zmieniono: $count<br>";


//przykład z tablicami
$arr = array("blue","red","blue","yellow");
echo '<pre>';
print_r(str_replace("blue","pink",$arr,$count));//ostatni
 parametr $count jest opcjonalny i pozwala wyświetlić liczbę dokonanych 
zmian
echo '</pre>';
echo "Zmieniono: $count";

?>

substr()

Funkcja substr() wycina fragment ciągu wg podanych parametrów. Budowa:

substr(string, początek[, długość])

jeżeli:

początek>0 – wycinanie zacznie się od znaku o podanym numerze

początek<0 – wycinanie zacznie się od miejsca = długość-początek

długość>0 – wycinanie zacznie się od podanej cyfry określającej początek do początek+długość

długość<0 – wycinanie zakończy się o podaną liczbę znaków przed końcem

<?php
echo substr("abcdef", -1); // zwraca "f" 
echo substr("abcdef", -2); // zwraca "ef" 
echo substr("abcdef", -3, 1); // zwraca "d" 
echo substr("abcdef", 0, -1); // zwraca "abcde" 
echo substr("abcdef", 2, -1); // zwraca "cde" 
echo substr("abcdef", 4, -4); // zwraca false 
echo substr("abcdef", -3, -1); // zwraca "de"
echo substr('abcdef', 1); // bcdef 
echo substr('abcdef', 1, 3); // bcd 
echo substr('abcdef', 0, 4); // abcd 
echo substr('abcdef', 0, 8); // abcdef 
echo substr('abcdef', -1, 1); // f

//metoda zapisu dla tablic
$string = 'abcdef'; 
echo $string[0]; // a 
echo $string[3]; // d 
echo $string[strlen($string)-1]; // f
?>

substr_replace()

Funkcja substr_replace() zastępuje fragment łańcucha innym, określonym przez użytkownika. Budowa: substr_replace(string,zamiennik,początek[,długość])

jeżeli:

początek>0 – zastępowanie zacznie się od znaku o podanym numerze

początek<0 – zastępowanie zacznie się od miejsca = długość-początek

długość>0 – tyle znaków ciągu zostanie zmienione od początku

długość<0 – zastępowanie zakończy się o podaną liczbę znaków przed końcem

<?php
$var = 'ABCDEFGH:/MNRPQR/'; 
echo "Orginalny tekst: $var<hr />\n"; 

/* poniższe przykłady zamieniają całe $var na 'bob'. */ 
echo substr_replace($var, 'bob', 0) . "<br />\n"; 
echo substr_replace($var, 'bob', 0, strlen($var)) . "<br />\n"; 

/* Dołącza napis 'bob' przed zmienną $var. */ 
echo substr_replace($var, 'bob', 0, 0) . "<br />\n"; 

/* Zastępuje napis 'MNRPQR' w zmiennej $var napisem 'bob'. */ 
echo substr_replace($var, 'bob', 10, -1) . "<br />\n"; 
echo substr_replace($var, 'bob', -7, -1) . "<br />\n"; 

/* usuwa 'MNRPQR' z $var. */ 
echo substr_replace($var, '', 10, -1) . "<br />\n"; 

//operacje na tablicach
$input = array('A: XXX', 'B: XXX', 'C: XXX'); 
//zamienia XXX w każdym elemencie tablicy na YYY. 
echo implode('; ', substr_replace($input, 'YYY', 3, 3))."\n"; 

// sytuacja kiedy każdy element tablicy jest inny 
$replace = array('AAA', 'BBB', 'CCC'); 
echo implode('; ', substr_replace($input, $replace, 3, 3))."\n"; 

// sytuacja kiedy długości sa pobierane z tablicy. 
$length = array(1, 2, 3); 
echo implode('; ', substr_replace($input, $replace, 3, $length))."\n"; 
?>

strstr()

strstr(string,find[,przed_czy_po])

Wyszukuje podane znaki w ciągu, po czym wyświetla to co jest za znakiem (trzeci argument domyślnie ustawiony jest na false). Jeżeli użyjemy trzeciego argumentu z wartością true to wyświetli ciąg znaków poprzedzający szukany element. Funkcja rozróżnia wielkość znaków.

<?php
$email  = 'name@example.com';
$domain = strstr($email, '@');
echo $domain.'<br>';
// wyświetli: '@example.com'

$user = strstr($email, '@', true); // PHP 5.3.0
echo $user;
// wyświetli: 'name'
?>

strtr()

Zamienia podany ciąg znaków na inny. Budowa: strtr(string,from,to) lub strtr(string,array)

<?php
echo strtr("Hilla Warld","ia","eo");//wyświetli: Hello World 

$arr = array("Hello" => "Hi", "world" => "earth");
echo strtr("Hello world",$arr); //wyświetli: Hi earth 
?>

trim()

Funkcja trim() usuwa następujące znaki z początku i końca ciągu: odstępy, tabulacje poziome (\t) i pionowe (\x0b), nowy wiersz (\n), NULL (\0), powrót karetki (\r). Budowa:

trim(string[, lista_znaków])

parametr lista_znaków pozwala na określenie niestandardowych znaków do usunięcia.

<?php

$text   = "\t\tTutaj jest kilka słów 🙂 ...  ";
$binary = "\x09Przykładowy napis\x0A";
$hello  = "Hello World";
var_dump($text, $binary, $hello);

print "\n";

$trimmed = trim($text);
var_dump($trimmed);

$trimmed = trim($text, " \t.");
var_dump($trimmed);

$trimmed = trim($hello, "Hdle");
var_dump($trimmed);

$trimmed = trim($hello, 'HdWr');
var_dump($trimmed);

// trim the ASCII control characters at the beginning and end of $binary
// (from 0 to 31 inclusive)
$clean = trim($binary, "\x00..\x1F");
var_dump($clean);

?>

Przykład:

Funkcja PHP tworząca przyjazne linki

function clearDiacritics($sText)
{
$aReplacePL = array(
'ą' => 'a', 'ę' => 'e', 'ś' => 's', 'ć' => 'c',
'ó' => 'o', 'ń' => 'n', 'ż' => 'z', 'ź' => 'z', 'ł' => 'l',
'Ą' => 'A', 'Ę' => 'E', 'Ś' => 'S', 'Ć' => 'C',
'Ó' => 'O', 'Ń' => 'N', 'Ż' => 'Z', 'Ź' => 'Z', 'Ł' => 'L'
);

return str_replace(array_keys($aReplacePL), array_values($aReplacePL), $sText);
}

function prepareURL($sText)
{
// pozbywamy się polskich znaków diakrytycznych
$sText = clearDiacritics($sText);

// dla przejrzystości wszystko z małych liter
$sText = strtolower($sText);

// wszystkie spacje zamieniamy na myślniki
$sText = str_replace(' ', '-', $sText);

// usuń wszytko co jest niedozwolonym znakiem
$sText = preg_replace('/[^0-9a-z\-]+/', '', $sText);

// zredukuj liczbę myślników do jednego obok siebie
$sText = preg_replace('/[\-]+/', '_', $sText);

// usuwamy możliwe myślniki na początku i końcu
$sText = trim($sText, '-');

return $sText;
}

Przykład:

Kwota, liczba słownie PHP

<?php

if(!function_exists('str_split')){
function str_split($string,$len = 1) {
if ($len < 1) return false;
for($i=0, $rt = Array();$i<ceil(strlen($string)/$len);$i++)
$rt[$i] = substr($string, $len*$i, $len);
return($rt);
}
}

$slowa = 
Array('minus',
 Array('zero','jeden','dwa','trzy','cztery','pięć','sześć','siedem','osiem','dziewięć'),
    Array('dziesięć','jedenaście','dwanaście','trzynaście','czternaście','piętnaście','szesnaście','siedemnaście','osiemnaście','dziewiętnaście'),
      Array('dziesięć','dwadzieścia','trzydzieści','czterdzieści','pięćdziesiąt','sześćdziesiąt','siedemdziesiąt','osiemdziesiąt','dziewięćdziesiąt'),
        Array('sto','dwieście','trzysta','czterysta','pięćset','sześćset','siedemset','osiemset','dziewięćset'),
          Array('tysiąc','tysiące','tysięcy'),
            Array('milion','miliony','milionów'),
              Array('miliard','miliardy','miliardów'),
                Array('bilion','biliony','bilionów'),
                  Array('biliard','biliardy','biliardów'),
                    Array('trylion','tryliony','trylionów'),
                     Array('tryliard','tryliardy','tryliardów'),
                       Array('kwadrylion','kwadryliony','kwadrylionów'),
                         Array('kwintylion','kwintyliony','kwintylionów'),
                           Array('sekstylion','sekstyliony','sekstylionów'),
                             Array('septylion','septyliony','septylionów'),
                               Array('oktylion','oktyliony','oktylionów'),
                                 Array('nonylion','nonyliony','nonylionów'),
                                   Array('decylion','decyliony','decylionów')
);

function odmiana($odmiany, $int){ // $odmiany = Array('jeden','dwa','pięć')
$txt = $odmiany[2];
if ($int == 1) $txt = $odmiany[0];
$jednosci = (int) substr($int,-1);
$reszta = $int % 100;
if (($jednosci > 1 && $jednosci < 5) &! ($reszta > 10 && $reszta < 20))
$txt = $odmiany[1];
return $txt;
}

function liczba($int){ // odmiana dla liczb < 1000
global $slowa;
$wynik = '';
$j = abs((int) $int);

if ($j == 0) return $slowa[1][0];
$jednosci = $j % 10;
$dziesiatki = ($j % 100 - $jednosci) / 10;
$setki = ($j - $dziesiatki*10 - $jednosci) / 100;

if ($setki > 0) $wynik .= $slowa[4][$setki-1].' ';

if ($dziesiatki > 0)
if ($dziesiatki == 1) $wynik .= $slowa[2][$jednosci].' ';
else
$wynik .= $slowa[3][$dziesiatki-1].' ';

if ($jednosci > 0 && $dziesiatki != 1) $wynik .= $slowa[1][$jednosci].' ';
return $wynik;
}

function slownie($int){

global $slowa;

$in = preg_replace('/[^-\d]+/','',$int);
$out = '';

if ($in{0} == '-'){
$in = substr($in, 1);
$out = $slowa[0].' ';
}

$txt = str_split(strrev($in), 3);

if ($in == 0) $out = $slowa[1][0].' ';

for ($i = count($txt) - 1; $i >= 0; $i--){
$liczba = (int) strrev($txt[$i]);
if ($liczba > 0)
if ($i == 0)
$out .= liczba($liczba).' ';
else
$out .= ($liczba > 1 ? liczba($liczba).' ' : '')
.odmiana( $slowa[4 + $i], $liczba).' ';
}
return trim($out);
}
function kwotaslownie($kwota){
$kwota = explode('.', $kwota);

$zl = preg_replace('/[^-\d]+/','', $kwota[0]);
$gr = preg_replace('/[^\d]+/','', substr(isset($kwota[1]) ? $kwota[1] : 0, 0, 2));
while(strlen($gr) < 2) $gr .= '0';

echo slownie($zl) . ' ' . odmiana(Array('złoty', 'złote', 'złotych'), $zl) .
(intval($gr) == 0 ? '' :
' ' . slownie($gr) . ' ' . odmiana(Array('grosz', 'grosze', 'groszy'), $gr));
}

?>

ZADANIA:

  1. Napisz funkcję zmieniającą wielkość liter, w przesłanym formularzem lub podanym tekście, na:
    1. wielkie litery
    2. małe litery
    3. każdy wyraz pisany wielką literą
    4. jak w zdaniu

    wyświetl otrzymane wyniki.

  2. Napisz funkcję, która sprawdza domenę podanego adresu e-mail. Zastosuj funkcję explode, by rozdzielić adres względem znaku @.
  3. Stwórz funkcję, która będzie zamieniała podany wyraz występujący w podanym tekście na inny podany wyraz
  4. Napisz skrypt szyfrujący hasło podane przez użytkownika. Użyj funkcji md5.
  5. W zdaniu: „Jestem mistrzem” dokonaj następujących zmian przy pomocy funkcji substr i substr_replace:
    1. zamień wyraz „Jestem” na swoje imię i wyświetl wynik
    2. dodaj na końcu zdania wyraz „PHP” i wyświetl wynik
    3. wyświetl jedynie wyraz „mistrzem”


Wyrażenia regularne i funkcja preg_match()

preg_match()

funkcja, która sprawdza występowanie podanego wzorca w danym ciągu. Jest przydatna w przypadku walidacji formularzy np. gdy chcemy sprawdzić czy została podana cyfra i znak specjalny w haśle, albo czy mail został podany poprawnie. Jeżeli wyrażenie zostanie znalezione w ciągu, funkcja zwraca 1, w przeciwnym wypadku zwraca 0.

preg_match(wyrazenie_regularne, badany_ciag);

Ale jak się tworzy wyrażenia regularne…

/…/

Wyrażenie, którego szukamy musi znajdować się pomiędzy dwoma slash’ami.

preg_match('/kot/', 'Ala ma kota.');

wyrażenie /kot/ będzie pasowało do każdego ciągu, w którym znajda sie obok siebie litery k o t. Nie ma znaczenia, czy są wewnątrz ciągu, na początku, czy na końcu. Znaczenie ma wielkość liter!

Przyklad:

preg_match('/kot/', 'Ala ma kota.');                  
preg_match('/kot/', 'Ala ma kota na punkcie kotów.'); 
preg_match('/kot/', 'Kotka i małe koty.');          

^ i $

Jeżeli chcemy określić, czy dane wyrażenie ma znajdować się na początku ciągu używamy ^, jeżeli ma byc na końcy – używamy $.

Przyklad:

preg_match('/^Kot/', 'Kot należy do Ali.');           
preg_match('/^kot/', 'Ten kot jest czarny.');         
preg_match('/kot$/', 'Oto kot');                      
preg_match('/kot$/', 'Oto kot.');                    
preg_match('/^kot$/', 'kot');                        

. (kropka)

Kropka służy do znalezienia dowolnego znaku w ciągu. Jedna kropka to jeden znak.

Przyklad:

preg_match('/k.t/', 'Ala ma kota.');                
preg_match('/k.t/', 'Ten kotek ma czarną kitę.');   
preg_match('/k.t/', 'Wypłynął kutrem.');             
preg_match('/k..t/', 'karta');                       

Kropka jest znakiem specjalnym, więc jeżeli chcielibyśmy sprawdzić czy w ciągu występuje kropka to musimy poprzedzić ją \ (backslashem)

Przyklad:

preg_match('/\./', 'Ala ma kota.');                

Znaki specjalne

Poza kropką istnieją inne znaki specjalne, które należy poprzedzić znakiem \ (backslash).

. \ / * + ? [ ^ $ | { ( )

Przyklad:

preg_match('/\?/', 'Ala ma kota?');                

[…]

W nawiasach kwadratowych określamy zbiory znaków jakie chcemy wyszukać. Musi wystąpić dokładnie jeden znak, obojętnie który oraz obojętnie w jakiej kolejności.

Przyklad:

preg_match('/[jest]/', 'se');                 
preg_match('/[Ala]/', 'Ala ma kota');       

Możemy zbiory znaków łączyć swobodnie ze zwykłymi znakami:

Przyklad:

preg_match('/ol[wer]/', 'wyrewolwerowane pole');       

Zbiory znaków mają swoje zakresy:

  • [a-z] – oznacza dowolną małą literę od a do z
  • [^a-z] – negacja [a-z], nie może wystąpić żadna mała litera od a do z
  • [A-Z] – oznacza dowolną wielką literę od A do Z
  • [^A-Z] – negacja [A-Z], nie może wystąpić żadna duża litera od A do Z
  • [0-9] lub \d– oznacza dowolną cyfrę
  • [^0-9] lub \D– negacja [0-9], nie może wystąpić żadna cyfra
  • \w – oznacza wszystkie litery, cyfry i podkreślnik – [a-zA-Z0-9_]
  • \W – stanowi negację \w – [^a-zA-Z0-9_]
  • \s – oznacza znaki specjalne – spację, \n, \r\ i \t
  • \S – stanowi negację \s

zakresy możemy łączyć ze sobą

Przyklad:

Jedna z liter od a do z mała lub duża lub dowolna cyfra
preg_match('/[a-zA-Z0-9]/', 'Jakiś ciąg znaków: liter aąbcć, cyfr 123456 oraz znaków !@#$%');       

aby zanegowac dany zbiór umieszczamy na jego początku ^

Przyklad:

Nie może wystąpić żadna mała litera
preg_match('/abc[^a-z]/', 'abcdef');  //nie będzie dopasowania, bo po abc nie może wystąpić żadna mała litera

preg_match('/abc[^a-z]/', 'abc123');  // poprawne dopasowanie, po abc nie wystepuje żadna mała litera

|, czyli OR

jeżeli chcemy sprawdzić, czy któryś z ciągów istnieje, używamy |. Oznacza on to samo co logiczne OR. Sprawdzana jest całość członu po lewej lub prawej stronie |.

Przyklad:

preg_match('/abc|123/', 'abc');  
preg_match('/abc|123/', '123');  

(), czyli grupowanie

działa tak jak w matematyce, gdy musimy pogrupować elementy do dopasowania. Wyrażenie wewnątrz nawiasów traktujemy jako całość.

Przyklad:

preg_match('/^Oh(Karol|Karolina)$)/', 'OhKarol');  

*, +, ?, {}, czyli kwantyfikatory

jeżeli chcemy określić ile dopasowań w ciągu ma wystąpić, to używamy kwantyfikatorów.

  • * (gwiazdka) oznacza zero lub więcej wystąpień
  • + (plus) oznacza jedno lub więcej wystąpień
  • ? (znak zapytania) oznacza zero lub jedno wystąpienie
  • {n} oznacza dokładnie n wystąpień znaku lub zakresu przed nawiasem
  • {n,} oznacza co najmniej n wystąpień znaku lub zakresu przed nawiasem
  • {m, n} oznacza od m do n wystąpień znaku lub zakresu przed nawiasem

Przyklady:

//wyrażenie pasuje do wszystkich ciągów

//* zero lub więcej wystąpień
preg_match('/abc[A-Z]*/', 'abc');  
preg_match('/abc[A-Z]*/', 'abcC'); 
preg_match('/abc[A-Z]*/', 'abcXY'); 
preg_match('/abc[A-Z]*/', 'abcABCDE'); 

//+ jedno lub więcej wystąpień
preg_match('/abc[A-Z]+/', 'abcB'); 
preg_match('/abc[A-Z]+/', 'abcC'); 
preg_match('/abc[A-Z]+/', 'abcXY'); 
preg_match('/abc[A-Z]+/', 'abcABCDE'); 

//? zero lub jedno wystąpienie
preg_match('/abc[A-Z]?/', 'abc'); 
preg_match('/abc[A-Z]?/', 'abcC'); 
preg_match('/abc[A-Z]?/', 'abcX'); 
preg_match('/abc[A-Z]?/', 'abcZ'); 

//od 1 do 3 wystąpień znaków z zakresu [A-Z]
preg_match('/abc[A-Z]{1,3}/', 'abcA'); 
preg_match('/abc[A-Z]{1,3}/', 'abcAC'); 
preg_match('/abc[A-Z]{1,3}/', 'abcAHX'); 

//od 1 do 3 wystąpień znaku c 
preg_match('/abc{1,3}/', 'abcc'); 
preg_match('/abc{1,3}/', 'abccc'); 
preg_match('/abc{1,3}/', 'abcccc'); 
//co najmniej 3 wystąpienia znaków z zakresu [A-Z]
preg_match('/abc[A-Z]{3,}/', 'abcABC'); 
preg_match('/abc[A-Z]{3,}/', 'abcACGH'); 
preg_match('/abc[A-Z]{3,}/', 'abcAHTUX'); 
//co najmniej 3 wystąpienia znaków z zakresu (abc) 
preg_match('/(abc){3,}/', 'abcabcabc'); 

Przechwytywanie

Wynik działania funkcji preg_match() możemy umieścić w tablicy, aby tego dokonać musimy dołożyć naszej funkcji dodatkowe parametry mianowicie: $matches i PREG_OFFSET_CAPTURE

preg_match(wyrazenie_regularne, badany_ciag, $matches, PREG_OFFSET_CAPTURE);  

Wyniki zostają wrzucone do tablicy, gdzie w indeksie zerowym znajduje się część ciągu od, której zaczęło się dopasowanie, a w indeksie od 1 do n znajdują się dopasowania.

preg_match('/(\d+)\D+(\d+)/', 'Mam 70zł, wystarczy mi to na zakup 2 książek.', $matches, PREG_OFFSET_CAPTURE);  

wykonanie tego kodu spowoduje otrzymanie tablicy:

Array
(
    [0] => Array
        (
            [0] => 70zł, wystarczy mi to na zakup 2
            [1] => 4
        )

    [1] => Array
        (
            [0] => 70
            [1] => 4
        )

    [2] => Array
        (
            [0] => 2
            [1] => 36
        )

)

pogrupowanie elementów za pomocą (), powoduje że przechwytywanie zaczyna się od nawiasów zewnętrznych

preg_match('/((\d+)\D+)(\d+)/', 'Mam 70zł, wystarczy mi to na zakup 2 książek.', $matches, PREG_OFFSET_CAPTURE); 

wykonanie tego kodu spowoduje otrzymanie tablicy:

Array
(
    [0] => Array
        (
            [0] => 70zł, wystarczy mi to na zakup 2
            [1] => 4
        )

    [1] => Array
        (
            [0] => 70zł, wystarczy mi to na zakup 
            [1] => 4
        )

    [2] => Array
        (
            [0] => 70
            [1] => 4
        )

    [3] => Array
        (
            [0] => 2
            [1] => 36
        )

)

Narzędzie do testowania wyrażeń regularnych

Więcej informacji na temat wyrażeń regularnych znajdziecie na tej stronie

Zadania:

Zadanie 1. Napisz skrypt, który sprawdzi, czy podana zmienna zawiera dokładnie 1 cyfrę.

Zadanie 2. Napisz skrypt, który sprawdzi, czy nazwa pliku zawiera polskie znaki.