Oto przykładowy kurs programowania w PHP dla początkujących:
Kurs programowania w PHP dla początkujących
Moduł 1: Wprowadzenie do PHP
Moduł 2: Funkcje i Tablice
Moduł 3: Praca z formularzami i bazami danych
Moduł 4: Obsługa sesji i ciasteczek
Moduł 5: Wprowadzenie do obiektowości w PHP
Moduł 6: Praca z plikami i manipulacja danymi
Moduł 7: Zabezpieczenia i optymalizacja
Podsumowanie kursu
Ten kurs zawiera podstawowe zagadnienia oraz praktyczne ćwiczenia, które pomogą Ci zrozumieć i zacząć tworzyć aplikacje w PHP. Powodzenia!
Co to jest PHP?
PHP (Hypertext Preprocessor) to język skryptowy ogólnego przeznaczenia, który jest powszechnie stosowany do tworzenia stron internetowych. PHP jest interpretowany na serwerze, co oznacza, że kod PHP jest wykonywany na serwerze, a jego wynik jest przesyłany do przeglądarki internetowej użytkownika. Jest to język programowania open-source, co oznacza, że jego kod jest dostępny publicznie do modyfikacji i dostosowywania przez społeczność programistyczną.
Dlaczego PHP jest popularne?
Istnieje wiele powodów, dla których PHP jest popularnym wyborem dla tworzenia stron internetowych:
W rezultacie PHP pozostaje jednym z najbardziej popularnych języków programowania do tworzenia stron internetowych i aplikacji internetowych, przyciągając zarówno początkujących, jak i doświadczonych programistów z całego świata.
Przed rozpoczęciem pracy z PHP, musisz mieć skonfigurowane środowisko programistyczne. Środowisko to składa się z interpretera PHP oraz serwera WWW. W tej lekcji dowiesz się, jak zainstalować i skonfigurować PHP na swoim komputerze.
1. Wybór środowiska:
Istnieje wiele różnych pakietów, które zawierają prekonfigurowane środowiska PHP, takie jak:
Możesz również zainstalować PHP, Apache i MySQL oddzielnie, ale dla początkujących zalecamy skorzystanie z gotowego pakietu, który upraszcza proces konfiguracji.
2. Instalacja XAMPP (dla systemu Windows):
XAMPP jest popularnym pakietem, który zawiera Apache, MySQL, PHP oraz Perl.
3. Konfiguracja środowiska:
Po zainstalowaniu XAMPP możesz skonfigurować środowisko PHP poprzez:
4. Testowanie instalacji:
Aby sprawdzić, czy PHP zostało poprawnie zainstalowane i skonfigurowane:
http://localhost/.test.php w katalogu htdocs (lub www w zależności od konfiguracji), a następnie otwórz go w edytorze tekstu i dodaj kod:<?php
phpinfo();
?>http://localhost/test.php.Po ukończeniu tych kroków, masz skonfigurowane środowisko PHP i możesz zacząć pisać i testować swoje skrypty PHP na swoim komputerze lokalnym.
W tej lekcji nauczysz się pisać prosty skrypt PHP, który wyświetli napis "Hello World!" na stronie internetowej. To klasyczne zadanie wprowadzające pozwoli Ci zapoznać się z podstawami składni PHP i uruchomić swój pierwszy program.
1. Tworzenie pliku PHP:
.php. Na przykład hello.php.2. Pisanie kodu PHP:
Wpisz następujący kod PHP w utworzonym pliku:
<?php
// To jest komentarz w PHP. Wszystko, co jest pomiędzy // a końcem linii, jest ignorowane przez interpreter.
echo "Hello World!"; // Ta linijka wyświetla napis "Hello World!" na stronie internetowej.
?>3. Uruchomienie skryptu:
hello.php w katalogu, który jest dostępny dla serwera WWW (np. katalog htdocs w przypadku XAMPP).http://localhost/hello.php.4. Wyjaśnienie kodu:
<?php i ?>: Oznaczają początek i koniec bloku kodu PHP.echo "Hello World!";: Instrukcja echo jest używana do wyświetlania tekstu lub wartości na stronie internetowej. W tym przypadku wyświetlamy napis "Hello World!".5. Zadanie dodatkowe:
Spróbuj zmodyfikować skrypt PHP, aby wyświetlał więcej niż tylko "Hello World!". Na przykład, dodaj komunikat powitalny dla użytkownika lub wyświetlaj datę i godzinę.
Po ukończeniu tej lekcji, będziesz mógł napisać i uruchamiać proste skrypty PHP, co będzie podstawą dla bardziej zaawansowanych zadań i projektów.
W tej lekcji zapoznamy się z podstawowymi elementami składni PHP, w tym zmiennymi, typami danych i operatorami. Zrozumienie tych koncepcji jest kluczowe dla efektywnego programowania w PHP.
1. Zmienne w PHP:
Zmienna w PHP jest miejscem przechowywania danych. Nazwa zmiennej musi zaczynać się od znaku dolara ($) i może zawierać litery, cyfry i znak podkreślenia (_), ale nie może zaczynać się od cyfry.
$zmienna = wartość;2. Typy danych w PHP:
3. Operatory w PHP:
+, -, *, /, % (dodawanie, odejmowanie, mnożenie, dzielenie, reszta z dzielenia).=, +=, -= (przypisanie wartości do zmiennej).==, !=, ===, !==, <, >, <=, >= (równość, nierówność, identyczność, nieidentyczność, mniejsze niż, większe niż, mniejsze niż lub równe, większe niż lub równe).&&, ||, ! (i, lub, negacja).. (łączenie ciągów znaków).++, -- (zwiększenie o 1, zmniejszenie o 1).Przykład:
$liczba1 = 10;
$liczba2 = 5;
$suma = $liczba1 + $liczba2; // Dodawanie
$roznica = $liczba1 - $liczba2; // Odejmowanie
$iloczyn = $liczba1 * $liczba2; // Mnożenie
$iloraz = $liczba1 / $liczba2; // Dzielenie
$reszta = $liczba1 % $liczba2; // Reszta z dzielenia
echo "Suma: " . $suma . "<br>";
echo "Różnica: " . $roznica . "<br>";
echo "Iloczyn: " . $iloczyn . "<br>";
echo "Iloraz: " . $iloraz . "<br>";
echo "Reszta: " . $reszta . "<br>";W tej lekcji nauczyliśmy się podstaw składni PHP, w tym jak definiować zmienne, jakie są typy danych oraz jak używać operatorów arytmetycznych, przypisania, porównania i logicznych. Te podstawy są niezbędne do tworzenia bardziej zaawansowanych programów w PHP.
W tej lekcji zapoznamy się z podstawowymi elementami składni PHP, w tym zmiennymi, typami danych i operatorami. Zrozumienie tych koncepcji jest kluczowe dla efektywnego programowania w PHP.
1. Zmienne w PHP:
Zmienna w PHP jest miejscem przechowywania danych. Nazwa zmiennej musi zaczynać się od znaku dolara ($) i może zawierać litery, cyfry i znak podkreślenia (_), ale nie może zaczynać się od cyfry.
$zmienna = wartość;2. Typy danych w PHP:
3. Operatory w PHP:
+, -, *, /, % (dodawanie, odejmowanie, mnożenie, dzielenie, reszta z dzielenia).=, +=, -= (przypisanie wartości do zmiennej).==, !=, ===, !==, <, >, <=, >= (równość, nierówność, identyczność, nieidentyczność, mniejsze niż, większe niż, mniejsze niż lub równe, większe niż lub równe).&&, ||, ! (i, lub, negacja).. (łączenie ciągów znaków).++, -- (zwiększenie o 1, zmniejszenie o 1).Przykład:
$liczba1 = 10;
$liczba2 = 5;
$suma = $liczba1 + $liczba2; // Dodawanie
$roznica = $liczba1 - $liczba2; // Odejmowanie
$iloczyn = $liczba1 * $liczba2; // Mnożenie
$iloraz = $liczba1 / $liczba2; // Dzielenie
$reszta = $liczba1 % $liczba2; // Reszta z dzielenia
echo "Suma: " . $suma . "<br>";
echo "Różnica: " . $roznica . "<br>";
echo "Iloczyn: " . $iloczyn . "<br>";
echo "Iloraz: " . $iloraz . "<br>";
echo "Reszta: " . $reszta . "<br>";W tej lekcji nauczyliśmy się podstaw składni PHP, w tym jak definiować zmienne, jakie są typy danych oraz jak używać operatorów arytmetycznych, przypisania, porównania i logicznych. Te podstawy są niezbędne do tworzenia bardziej zaawansowanych programów w PHP.
W tej lekcji zapoznamy się z instrukcjami warunkowymi w PHP, które pozwalają nam kontrolować przepływ programu w zależności od warunków logicznych.
1. Instrukcja warunkowa if:
Instrukcja warunkowa if pozwala nam wykonać określony blok kodu, jeśli podany warunek jest spełniony.
if (warunek) {
// Wykonaj ten kod, jeśli warunek jest spełniony
}2. Instrukcja warunkowa else:
Instrukcja else pozwala nam wykonać inny blok kodu, jeśli warunek w instrukcji if nie jest spełniony.
if (warunek) {
// Wykonaj ten kod, jeśli warunek jest spełniony
} else {
// Wykonaj ten kod, jeśli warunek nie jest spełniony
}3. Instrukcja warunkowa elseif:
Instrukcja elseif pozwala nam sprawdzić kolejne warunki, jeśli poprzednie nie zostały spełnione.
if (warunek1) {
// Wykonaj ten kod, jeśli warunek1 jest spełniony
} elseif (warunek2) {
// Wykonaj ten kod, jeśli warunek1 nie jest spełniony, ale warunek2 jest spełniony
} else {
// Wykonaj ten kod, jeśli żaden z powyższych warunków nie jest spełniony
}Przykład:
$ocena = 75;
if ($ocena >= 60) {
echo "Zaliczone!";
} else {
echo "Niezaliczone!";
}W tym przykładzie, jeśli wartość zmiennej $ocena wynosi co najmniej 60, zostanie wyświetlony komunikat "Zaliczone!", w przeciwnym razie zostanie wyświetlony komunikat "Niezaliczone!".
Instrukcje warunkowe są ważnym elementem każdego języka programowania, pozwalając na dynamiczne sterowanie przepływem programu w zależności od warunków logicznych. Praktyka w tworzeniu instrukcji warunkowych jest kluczowa dla zrozumienia i skutecznego stosowania PHP.
W tej lekcji omówimy trzy podstawowe rodzaje pętli w PHP: pętlę for, while i do-while. Pętle są używane do powtarzania określonych fragmentów kodu przez określoną liczbę razy lub do momentu spełnienia określonego warunku.
1. Pętla for:
Pętla for jest używana, gdy znasz dokładną liczbę iteracji.
for ($i = 0; $i < 5; $i++) {
// Kod, który ma być powtarzany
}2. Pętla while:
Pętla while wykonuje blok kodu, dopóki podany warunek jest prawdziwy.
$licznik = 0;
while ($licznik < 5) {
// Kod, który ma być powtarzany
$licznik++;
}3. Pętla do-while:
Pętla do-while najpierw wykonuje blok kodu, a następnie sprawdza warunek, czy ma być kontynuowana.
$licznik = 0;
do {
// Kod, który ma być powtarzany
$licznik++;
} while ($licznik < 5);Przykład:
// Pętla for
echo "Pętla for: ";
for ($i = 0; $i < 5; $i++) {
echo $i . " ";
}
echo "<br>";
// Pętla while
echo "Pętla while: ";
$licznik = 0;
while ($licznik < 5) {
echo $licznik . " ";
$licznik++;
}
echo "<br>";
// Pętla do-while
echo "Pętla do-while: ";
$licznik = 0;
do {
echo $licznik . " ";
$licznik++;
} while ($licznik < 5);W tym przykładzie użyliśmy każdego rodzaju pętli do wyświetlenia liczb od 0 do 4. W przypadku pętli for użyliśmy trzech wyrażeń: inicjalizacji, warunku i inkrementacji, aby kontrolować iteracje. W przypadku pętli while i do-while użyliśmy tylko warunku, a inkrementację zrobiliśmy wewnątrz pętli. Pętle są użytecznym narzędziem do automatyzacji powtarzalnych zadań i pozwalają na bardziej dynamiczne tworzenie aplikacji.
Proste ćwiczenie praktyczne na temat stworzenia prostego kalkulatora w PHP:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Prosty kalkulator PHP</title>
</head>
<body>
<h2>Prosty kalkulator PHP</h2>
<form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
<input type="text" name="num1" placeholder="Wprowadź liczbę 1" required>
<select name="operator" required>
<option value="add">Dodawanie</option>
<option value="subtract">Odejmowanie</option>
<option value="multiply">Mnożenie</option>
<option value="divide">Dzielenie</option>
</select>
<input type="text" name="num2" placeholder="Wprowadź liczbę 2" required>
<button type="submit" name="submit">Oblicz</button>
</form>
<?php
if (isset($_POST['submit'])) {
$num1 = $_POST['num1'];
$num2 = $_POST['num2'];
$operator = $_POST['operator'];
$result = '';
switch ($operator) {
case 'add':
$result = $num1 + $num2;
break;
case 'subtract':
$result = $num1 - $num2;
break;
case 'multiply':
$result = $num1 * $num2;
break;
case 'divide':
if ($num2 == 0) {
echo "Nie można dzielić przez zero!";
} else {
$result = $num1 / $num2;
}
break;
default:
echo "Nieprawidłowy operator";
break;
}
echo "<h3>Wynik: $result</h3>";
}
?>
</body>
</html>W tym przykładzie stworzyliśmy prosty kalkulator, który pobiera dwie liczby od użytkownika oraz operację matematyczną, którą chce wykonać. Po kliknięciu przycisku "Oblicz", kalkulator wyświetla wynik na ekranie.
switch w PHP sprawdzamy, jaką operację matematyczną użytkownik wybrał, a następnie wykonujemy odpowiednią operację.To proste ćwiczenie praktyczne pozwala na zastosowanie podstawowych umiejętności PHP w praktyce i zrozumienie, jak działa prosty kalkulator internetowy.
Funkcje w PHP pozwalają na zorganizowanie kodu w bardziej czytelny i modułowy sposób. W tej lekcji omówimy, jak deklarować funkcje, przekazywać im argumenty oraz zwracać wartości.
1. Deklaracja funkcji:
Aby zadeklarować funkcję w PHP, używamy słowa kluczowego function, po którym podajemy nazwę funkcji i jej ciało.
function nazwa_funkcji() {
// Kod funkcji
}2. Przekazywanie argumentów:
Możemy przekazywać argumenty do funkcji, które są wartościami, które funkcja będzie przetwarzać.
function dodaj($liczba1, $liczba2) {
$wynik = $liczba1 + $liczba2;
echo "Wynik dodawania: $wynik";
}3. Zwracanie wartości:
Funkcja może również zwracać wartość za pomocą słowa kluczowego return.
function dodaj($liczba1, $liczba2) {
$wynik = $liczba1 + $liczba2;
return $wynik;
}Przykład:
function dodaj($liczba1, $liczba2) {
$wynik = $liczba1 + $liczba2;
return $wynik;
}
$wynik = dodaj(5, 3);
echo "Wynik dodawania: $wynik";W tym przykładzie zdefiniowaliśmy funkcję dodaj, która przyjmuje dwie liczby jako argumenty, dodaje je i zwraca wynik. Następnie wywołaliśmy tę funkcję z argumentami 5 i 3, a wynik dodawania został wyświetlony na ekranie.
Korzystanie z funkcji pozwala na unikanie powtarzania kodu, co prowadzi do bardziej czytelnego i łatwiejszego do zarządzania kodu.
Tablice w PHP są bardzo wszechstronnym narzędziem, które pozwalają na przechowywanie i manipulację danymi. W tej lekcji omówimy trzy podstawowe rodzaje tablic: indeksowane, asocjacyjne i wielowymiarowe.
1. Tablice indeksowane:
Tablice indeksowane są tablicami, w których klucze są automatycznie przypisywane przez PHP w postaci kolejnych liczb całkowitych (indeksów).
$tablica = array("jabłko", "banan", "śliwka");2. Tablice asocjacyjne:
Tablice asocjacyjne są tablicami, w których klucze są zdefiniowane przez użytkownika.
$oceny = array("Matematyka" => 5, "Fizyka" => 4, "Chemia" => 3);3. Tablice wielowymiarowe:
Tablice wielowymiarowe są tablicami, które zawierają inne tablice jako swoje elementy.
$uczniowie = array(
array("Anna", "Kowalska", 15),
array("Jan", "Nowak", 16),
array("Ewa", "Wiśniewska", 14)
);Przykład:
// Tablica indeksowana
$owoce = array("jabłko", "banan", "śliwka");
echo $owoce[0]; // Wyświetli "jabłko"
// Tablica asocjacyjna
$oceny = array("Matematyka" => 5, "Fizyka" => 4, "Chemia" => 3);
echo $oceny["Matematyka"]; // Wyświetli 5
// Tablica wielowymiarowa
$uczniowie = array(
array("Anna", "Kowalska", 15),
array("Jan", "Nowak", 16),
array("Ewa", "Wiśniewska", 14)
);
echo $uczniowie[0][0]; // Wyświetli "Anna"Tablice są jednymi z najważniejszych struktur danych w PHP i są szeroko wykorzystywane w programowaniu. Zrozumienie różnych rodzajów tablic oraz sposobów ich używania jest kluczowe dla efektywnego tworzenia aplikacji.
W tej lekcji omówimy operacje dodawania, usuwania i sortowania tablic w PHP, co jest kluczowym elementem przy manipulowaniu danymi w aplikacjach.
1. Dodawanie elementów do tablicy:
Aby dodać nowy element do tablicy w PHP, możemy użyć kilku metod. Jedną z nich jest używanie operatora [] lub funkcji array_push().
$owoce = array("jabłko", "banan", "śliwka");
$owoce[] = "gruszka"; // Dodanie "gruszka" na koniec tablicy
array_push($owoce, "pomarańcza"); // Inna metoda dodawania elementu na koniec tablicy2. Usuwanie elementów z tablicy:
Aby usunąć element z tablicy w PHP, możemy użyć funkcji unset() lub funkcji array_pop().
$owoce = array("jabłko", "banan", "śliwka");
unset($owoce[1]); // Usunięcie elementu o indeksie 1 (banan)
array_pop($owoce); // Usunięcie ostatniego elementu z tablicy (śliwka)3. Sortowanie tablicy:
PHP oferuje kilka funkcji do sortowania tablic. Jedną z nich jest funkcja sort(), która sortuje tablicę indeksowaną w miejscu.
$liczby = array(4, 2, 8, 5, 1);
sort($liczby); // Sortowanie tablicy w kolejności rosnącejMożemy również posortować tablicę asocjacyjną za pomocą funkcji asort(), która zachowuje klucze powiązane z ich wartościami.
$oceny = array("Matematyka" => 5, "Fizyka" => 4, "Chemia" => 3);
asort($oceny); // Sortowanie tablicy asocjacyjnej w kolejności rosnącej wartościPrzykład:
$owoce = array("jabłko", "banan", "śliwka");
$owoce[] = "gruszka";
array_push($owoce, "pomarańcza");
unset($owoce[1]);
array_pop($owoce);
sort($owoce);
foreach ($owoce as $owoc) {
echo $owoc . "<br>";
}W tym przykładzie dodaliśmy i usunęliśmy elementy z tablicy $owoce, a następnie posortowaliśmy ją i wyświetliliśmy zawartość za pomocą pętli foreach. To podstawowe operacje na tablicach są bardzo przydatne w codziennej pracy z PHP i pozwalają na elastyczne manipulowanie danymi.
Oto proste ćwiczenie praktyczne polegające na stworzeniu aplikacji do zarządzania listą zadań w PHP:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Aplikacja do zarządzania listą zadań</title>
</head>
<body>
<h2>Aplikacja do zarządzania listą zadań</h2>
<form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
<input type="text" name="task" placeholder="Dodaj nowe zadanie" required>
<button type="submit" name="submit">Dodaj</button>
</form>
<?php
session_start();
if (!isset($_SESSION['tasks'])) {
$_SESSION['tasks'] = array();
}
if (isset($_POST['submit'])) {
$task = $_POST['task'];
array_push($_SESSION['tasks'], $task);
}
if (!empty($_SESSION['tasks'])) {
echo "<h3>Lista zadań:</h3>";
echo "<ul>";
foreach ($_SESSION['tasks'] as $task) {
echo "<li>$task</li>";
}
echo "</ul>";
} else {
echo "<p>Brak zadań do wyświetlenia.</p>";
}
?>
<form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
<button type="submit" name="clear">Wyczyść listę</button>
</form>
<?php
if (isset($_POST['clear'])) {
$_SESSION['tasks'] = array();
}
?>
</body>
</html>W tym przykładzie stworzyliśmy prostą aplikację do zarządzania listą zadań. Użytkownik może dodawać nowe zadania za pomocą formularza, a dodane zadania są przechowywane w tablicy sesji. Po dodaniu zadań, lista zadań jest wyświetlana na stronie. Dodaliśmy także przycisk do wyczyszczenia listy zadań.
$_SESSION['tasks'] do przechowywania listy zadań.array_push() do dodania nowego zadania do tablicy sesji.foreach do wyświetlenia listy zadań na stronie.To proste ćwiczenie praktyczne pokazuje, jak zbudować podstawową aplikację internetową do zarządzania listą zadań w PHP.
W tej lekcji omówimy, jak tworzyć formularze HTML i obsługiwać je za pomocą PHP. Formularze są kluczowym elementem interakcji użytkownika z aplikacją internetową, pozwalając użytkownikom przesyłać dane do serwera.
1. Tworzenie formularza HTML:
Formularz HTML definiujemy za pomocą znacznika <form>. Wewnątrz formularza umieszczamy pola do wprowadzania danych, takie jak pola tekstowe, pola wyboru, przyciski itp.
<form method="post" action="obsługa_formularza.php">
<input type="text" name="username" placeholder="Wprowadź nazwę użytkownika">
<input type="password" name="password" placeholder="Wprowadź hasło">
<button type="submit" name="submit">Zaloguj się</button>
</form>2. Obsługa formularza w PHP:
Aby obsłużyć dane przesłane przez formularz, musimy utworzyć plik PHP, który będzie przetwarzał te dane. W pliku PHP możemy korzystać z tablicy $_POST do odczytania danych przesłanych przez formularz.
<?php
if ($_SERVER["REQUEST_METHOD"] == "POST") {
$username = $_POST["username"];
$password = $_POST["password"];
// Tutaj możemy wykonywać operacje na przesłanych danych, np. logowanie użytkownika
}
?>3. Zabezpieczenie formularza:
Podstawowym zabezpieczeniem formularza jest walidacja danych po stronie klienta i serwera. Możemy sprawdzać, czy pola są wypełnione, czy dane są poprawnego formatu, czy pola nie zawierają złośliwych danych itp.
<?php
$username = $password = "";
if ($_SERVER["REQUEST_METHOD"] == "POST") {
if (empty($_POST["username"])) {
$usernameErr = "Nazwa użytkownika jest wymagana";
} else {
$username = test_input($_POST["username"]);
}
if (empty($_POST["password"])) {
$passwordErr = "Hasło jest wymagane";
} else {
$password = test_input($_POST["password"]);
}
}
function test_input($data) {
$data = trim($data);
$data = stripslashes($data);
$data = htmlspecialchars($data);
return $data;
}
?>4. Przekierowanie użytkownika:
Po przetworzeniu danych formularza, możemy przekierować użytkownika na inną stronę za pomocą funkcji header().
<?php
// Po poprawnym zalogowaniu
header("Location: witamy.php");
exit();
?>Tworzenie i obsługa formularzy HTML w PHP jest kluczowym elementem tworzenia interaktywnych aplikacji internetowych. Poprzez umiejętne korzystanie z formularzy i odpowiednią obsługę przesłanych danych możemy tworzyć funkcjonalne i bezpieczne aplikacje internetowe.
Funkcja test_input($data) jest używana do przetwarzania danych przesłanych przez formularz przed ich dalszym wykorzystaniem. Poniżej znajdują się wyjaśnienia każdej linii w tej funkcji:
trim($data): Funkcja trim() usuwa białe znaki (spacje, tabulatory, nowe linie) z początku i końca ciągu znaków. Jest to przydatne, ponieważ użytkownik może przypadkowo wprowadzić dodatkowe białe znaki przy wpisywaniu danych do formularza.stripslashes($data): Funkcja stripslashes() usuwa znaki ukośnika odwrotnego (\) z ciągu znaków. Jest to użyteczne, ponieważ znaki ukośnika odwrotnego są czasami automatycznie dodawane do danych przesyłanych przez formularze, na przykład w przypadku formularzy HTML z atrybutem magic_quotes_gpc włączonym w starszych wersjach PHP.htmlspecialchars($data): Funkcja htmlspecialchars() konwertuje znaki specjalne na encje HTML. Zapobiega to atakom XSS (Cross-Site Scripting), które mogą być wywołane przez wstrzykiwanie kodu JavaScript lub HTML do formularzy i pól tekstowych na stronie internetowej.return $data: Zwraca przetworzone dane z powrotem do miejsca, z którego została wywołana funkcja. Ostatecznie przetworzone dane są zwracane i mogą być wykorzystane dalej w kodzie, na przykład do przypisania ich do zmiennej lub zapisania w bazie danych.W tej lekcji omówimy, jak przekazywać dane z formularza HTML do skryptu PHP w celu ich przetworzenia.
1. Metoda GET:
Metoda GET przesyła dane jako parametry dodane do adresu URL. Dane są widoczne w adresie URL i mają ograniczoną długość.
<form method="get" action="skrypt.php">
<input type="text" name="username">
<button type="submit" name="submit">Wyślij</button>
</form>W pliku skrypt.php możemy odczytać dane za pomocą tablicy $_GET.
$username = $_GET["username"];
echo "Witaj, $username!";2. Metoda POST:
Metoda POST przesyła dane jako część żądania HTTP, co oznacza, że dane są przesyłane w ciele żądania i nie są widoczne w adresie URL. Metoda POST jest zwykle używana do przesyłania większych ilości danych.
<form method="post" action="skrypt.php">
<input type="text" name="username">
<button type="submit" name="submit">Wyślij</button>
</form>W pliku skrypt.php możemy odczytać dane za pomocą tablicy $_POST.
$username = $_POST["username"];
echo "Witaj, $username!";3. Bezpośrednie przekazywanie:
Możemy również przekazywać dane bezpośrednio poprzez zagnieżdżanie danych w adresie URL.
<a href="skrypt.php?username=John">Przekazanie danych</a>W pliku skrypt.php możemy odczytać dane tak samo jak w przypadku metody GET.
$username = $_GET["username"];
echo "Witaj, $username!";Podczas przekazywania danych z formularza do skryptu PHP musimy uwzględnić odpowiednią metodę (GET lub POST) oraz odpowiednio przetworzyć przekazane dane w skrypcie PHP, aby uniknąć zagrożeń związanych z bezpieczeństwem, takich jak ataki XSS i SQL Injection.
W tej lekcji omówimy podstawy pracy z bazami danych MySQL w PHP, włączając w to nawiązywanie połączenia z bazą danych.
1. Tworzenie połączenia z bazą danych:
Najpierw musimy nawiązać połączenie z bazą danych MySQL. Do tego celu możemy użyć funkcji mysqli_connect() lub obiektu mysqli.
$servername = "localhost";
$username = "nazwa_uzytkownika";
$password = "haslo";
$database = "nazwa_bazy_danych";
// Tworzenie połączenia
$conn = mysqli_connect($servername, $username, $password, $database);
// Sprawdzenie połączenia
if (!$conn) {
die("Błąd połączenia: " . mysqli_connect_error());
} else {
echo "Połączenie z bazą danych udane";
}2. Zamknięcie połączenia z bazą danych:
Po zakończeniu pracy z bazą danych, ważne jest zamknięcie połączenia za pomocą funkcji mysqli_close().
mysqli_close($conn);3. Wykonywanie zapytań SQL:
Po nawiązaniu połączenia z bazą danych, możemy wykonywać zapytania SQL za pomocą funkcji mysqli_query().
$sql = "SELECT * FROM tabela";
$result = mysqli_query($conn, $sql);
if (mysqli_num_rows($result) > 0) {
while($row = mysqli_fetch_assoc($result)) {
echo "ID: " . $row["id"]. " - Nazwa: " . $row["nazwa"]. "<br>";
}
} else {
echo "Brak danych";
}W powyższym przykładzie wykonujemy zapytanie SELECT do tabeli tabela i wyświetlamy wyniki.
4. Zabezpieczenie przed atakami SQL Injection:
Aby zapobiec atakom SQL Injection, zawsze należy korzystać z zapytań parametryzowanych lub stosować funkcję mysqli_real_escape_string().
$user_input = "wartość_do_wstawienia";
$user_input_safe = mysqli_real_escape_string($conn, $user_input);
$sql = "INSERT INTO tabela (kolumna) VALUES ('$user_input_safe')";Nawiązywanie połączenia z bazą danych jest niezbędnym krokiem podczas pracy z bazami danych w PHP. Zapewnienie bezpieczeństwa danych poprzez stosowanie zabezpieczeń przed atakami SQL Injection jest równie ważne jak sam proces komunikacji z bazą danych.
Kod, który podałeś, jest przykładem zabezpieczenia przed atakami SQL Injection poprzez użycie funkcji mysqli_real_escape_string() w PHP. Poniżej wyjaśniam każdą linię tego kodu:
$user_input = "wartość_do_wstawienia";: Ta linia definiuje zmienną $user_input i przypisuje jej wartość "wartość_do_wstawienia". Jest to przykładowa wartość, którą użytkownik chce wstawić do bazy danych. W rzeczywistości ta wartość może pochodzić z formularza lub innego źródła danych przesłanych przez użytkownika.$user_input_safe = mysqli_real_escape_string($conn, $user_input);: Ta linia używa funkcji mysqli_real_escape_string() do zabezpieczenia wartości $user_input przed atakami SQL Injection. Funkcja ta przyjmuje dwa argumenty: pierwszy to aktywne połączenie z bazą danych ($conn), a drugi to wartość, która ma być zabezpieczona ($user_input). Funkcja ta wykonuje odpowiednie escapowanie znaków specjalnych w łańcuchu, aby zapobiec wstrzykiwaniu kodu SQL. Wynik jest przypisywany do zmiennej $user_input_safe.$sql = "INSERT INTO tabela (kolumna) VALUES ('$user_input_safe')";: Ta linia definiuje zapytanie SQL, które wstawia zabezpieczoną wartość $user_input_safe do kolumny kolumna w tabeli tabela. Używając tej metody, wstrzykiwanie kodu SQL jest niemożliwe, ponieważ wartość została odpowiednio zabezpieczona za pomocą funkcji mysqli_real_escape_string().W tej lekcji omówimy, jak wykonywać podstawowe operacje na bazie danych w PHP, takie jak SELECT, INSERT, UPDATE i DELETE, za pomocą funkcji PHP MySQLi.
1. Wykonywanie zapytań SELECT:
Zapytania SELECT służą do pobierania danych z bazy danych. Możemy użyć funkcji mysqli_query() do wykonania zapytania SELECT i funkcji mysqli_fetch_assoc() do pobrania wyników.
$sql = "SELECT * FROM tabela";
$result = mysqli_query($conn, $sql);
if (mysqli_num_rows($result) > 0) {
while($row = mysqli_fetch_assoc($result)) {
echo "ID: " . $row["id"]. " - Nazwa: " . $row["nazwa"]. "<br>";
}
} else {
echo "Brak danych";
}2. Wykonywanie zapytań INSERT:
Zapytania INSERT służą do dodawania nowych rekordów do bazy danych. Możemy użyć funkcji mysqli_query() do wykonania zapytania INSERT.
$sql = "INSERT INTO tabela (kolumna1, kolumna2) VALUES ('wartosc1', 'wartosc2')";
if (mysqli_query($conn, $sql)) {
echo "Nowy rekord został dodany";
} else {
echo "Błąd: " . mysqli_error($conn);
}3. Wykonywanie zapytań UPDATE:
Zapytania UPDATE służą do aktualizowania istniejących rekordów w bazie danych. Możemy użyć funkcji mysqli_query() do wykonania zapytania UPDATE.
$sql = "UPDATE tabela SET kolumna='nowa_wartosc' WHERE warunek";
if (mysqli_query($conn, $sql)) {
echo "Rekord został zaktualizowany";
} else {
echo "Błąd: " . mysqli_error($conn);
}4. Wykonywanie zapytań DELETE:
Zapytania DELETE służą do usuwania rekordów z bazy danych. Możemy użyć funkcji mysqli_query() do wykonania zapytania DELETE.
$sql = "DELETE FROM tabela WHERE warunek";
if (mysqli_query($conn, $sql)) {
echo "Rekord został usunięty";
} else {
echo "Błąd: " . mysqli_error($conn);
}Podczas wykonywania zapytań INSERT, UPDATE i DELETE, ważne jest, aby uwzględnić zabezpieczenie przed atakami SQL Injection, korzystając z odpowiednich metod, takich jak parametryzacja zapytań lub funkcja mysqli_real_escape_string(). Dodatkowo, zawsze warto sprawdzać, czy zapytanie zostało wykonane poprawnie i obsłużyć ewentualne błędy.
Parametryzacja zapytań to technika używana do bezpiecznego przekazywania danych do zapytań SQL, aby zapobiec atakom SQL Injection. Zamiast osadzać dane bezpośrednio w treści zapytania, parametryzacja polega na definiowaniu zapytania SQL z miejscami zastępczymi dla danych, a następnie przekazywaniu tych danych jako oddzielnych parametrów do funkcji wywołującej zapytanie.
W PHP, do parametryzacji zapytań można użyć metody przygotowywania i wykonywania zapytań w oparciu o obiekty mysqli lub procedury proceduralnej. Poniżej przedstawiamy przykład zastosowania parametryzacji zapytań w PHP z wykorzystaniem proceduralnego interfejsu MySQLi:
// Zapytanie SQL z miejscem zastępczym (?)
$sql = "SELECT * FROM users WHERE username = ?";
// Przygotowanie zapytania
$stmt = mysqli_prepare($conn, $sql);
// Przypisanie wartości do miejsca zastępczego
mysqli_stmt_bind_param($stmt, "s", $username);
// Ustawienie wartości zmiennej $username
$username = "example_username";
// Wykonanie zapytania
mysqli_stmt_execute($stmt);
// Pobranie wyników
$result = mysqli_stmt_get_result($stmt);
// Przetwarzanie wyników...W tym przykładzie, zamiast osadzać nazwę użytkownika bezpośrednio w zapytaniu, używamy miejsca zastępczego ?. Następnie, przed wykonaniem zapytania, przypisujemy wartość zmiennej $username do tego miejsca zastępczego za pomocą funkcji mysqli_stmt_bind_param(). Jest to bezpieczne, ponieważ parametry są automatycznie escapowane, co zapobiega wstrzykiwaniu kodu SQL.
Parametryzacja zapytań zapewnia skuteczną ochronę przed atakami SQL Injection i jest zalecana jako standardowa praktyka przy pracy z bazami danych w PHP.
Oto krok po kroku wyjaśnienie każdej linii kodu:
// Zapytanie SQL z miejscem zastępczym (?) $sql = "SELECT * FROM users WHERE username = ?";
$sql, która zawiera zapytanie SQL do pobrania wszystkich danych z tabeli users, gdzie nazwa użytkownika (username) jest równa podanej wartości.? wskazuje, że będziemy przypisywać wartość do tego miejsca w późniejszym etapie, zapobiegając w ten sposób atakom SQL Injection.// Przygotowanie zapytania $stmt = mysqli_prepare($conn, $sql);
mysqli_prepare(). Przekazujemy do niej połączenie z bazą danych ($conn) oraz zapytanie SQL ($sql).// Przypisanie wartości do miejsca zastępczego mysqli_stmt_bind_param($stmt, "s", $username);
mysqli_stmt_bind_param().$stmt), drugi argument to typ danych przekazywanych (w tym przypadku s oznacza string), a trzeci argument to właściwa wartość, którą chcemy przypisać miejscu zastępczemu.// Ustawienie wartości zmiennej $username $username = "example_username";
$username i przypisujemy do niej wartość, która będzie użyta do wyszukania użytkownika w bazie danych.// Wykonanie zapytania mysqli_stmt_execute($stmt);
mysqli_stmt_execute().$username, którą przypisaliśmy wcześniej, zostanie użyta w zapytaniu, gdyż została przypisana do odpowiedniego miejsca zastępczego.// Pobranie wyników $result = mysqli_stmt_get_result($stmt);
mysqli_stmt_get_result().$result i mogą być dalej przetwarzane.// Przetwarzanie wyników... // Tutaj możemy przetwarzać wyniki zapytania, na przykład za pomocą pętli while lub foreach, aby wyświetlić wyniki na stronie.
while lub foreach, aby iterować przez wyniki i wykonywać na nich odpowiednie operacje. Na przykład, możemy wyświetlić dane na stronie internetowej lub przekazać je dalej w kodzie aplikacji.Oto proste ćwiczenie praktyczne, w którym stworzymy prostą aplikację do zarządzania kontaktami w PHP i bazie danych MySQL:
CREATE TABLE contacts (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(50) NOT NULL,
email VARCHAR(50) NOT NULL,
phone VARCHAR(20) NOT NULL
); <!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Dodaj kontakt</title>
</head>
<body>
<h2>Dodaj nowy kontakt</h2>
<form action="add_contact.php" method="POST">
<label for="name">Imię i nazwisko:</label>
<input type="text" id="name" name="name" required><br><br>
<label for="email">Email:</label>
<input type="email" id="email" name="email" required><br><br>
<label for="phone">Telefon:</label>
<input type="text" id="phone" name="phone" required><br><br>
<button type="submit">Dodaj kontakt</button>
</form>
</body>
</html>add_contact.php), który będzie obsługiwał dodawanie nowego kontaktu do bazy danych. <?php
// Połączenie z bazą danych
$conn = mysqli_connect("localhost", "nazwa_uzytkownika", "haslo", "nazwa_bazy_danych");
// Sprawdzenie połączenia
if (!$conn) {
die("Błąd połączenia: " . mysqli_connect_error());
}
// Pobranie danych z formularza
$name = $_POST['name'];
$email = $_POST['email'];
$phone = $_POST['phone'];
// Dodanie kontaktu do bazy danych
$sql = "INSERT INTO contacts (name, email, phone) VALUES ('$name', '$email', '$phone')";
if (mysqli_query($conn, $sql)) {
echo "Kontakt został dodany pomyślnie";
} else {
echo "Błąd podczas dodawania kontaktu: " . mysqli_error($conn);
}
// Zamknięcie połączenia
mysqli_close($conn);
?> <?php
// Połączenie z bazą danych
$conn = mysqli_connect("localhost", "nazwa_uzytkownika", "haslo", "nazwa_bazy_danych");
// Sprawdzenie połączenia
if (!$conn) {
die("Błąd połączenia: " . mysqli_connect_error());
}
// Zapytanie SQL
$sql = "SELECT * FROM contacts";
$result = mysqli_query($conn, $sql);
// Wyświetlenie listy kontaktów
if (mysqli_num_rows($result) > 0) {
while($row = mysqli_fetch_assoc($result)) {
echo "ID: " . $row["id"]. " - Nazwa: " . $row["name"]. " | Email: " . $row["email"]. " | Telefon: " . $row["phone"]. "<br>";
}
} else {
echo "Brak kontaktów";
}
// Zamknięcie połączenia
mysqli_close($conn);
?>To proste ćwiczenie praktyczne pokazuje, jak stworzyć prostą aplikację do zarządzania kontaktami w PHP z wykorzystaniem bazy danych MySQL
W tej lekcji omówimy podstawy pracy z sesjami w PHP, włączając w to rozpoczęcie sesji, zapisywanie danych w sesji oraz odczytywanie danych sesji.
1. Rozpoczęcie sesji:
Sesje w PHP pozwalają nam przechowywać dane użytkownika między różnymi stronami lub odświeżeniami strony. Pierwszym krokiem jest rozpoczęcie sesji za pomocą funkcji session_start().
<?php
session_start();
?>2. Zapisywanie danych w sesji:
Możemy zapisywać dane w sesji, przypisując wartości do zmiennych sesji.
<?php
// Rozpoczęcie sesji
session_start();
// Przypisanie wartości do zmiennej sesji
$_SESSION['username'] = 'example_user';
$_SESSION['email'] = 'example@example.com';
?>3. Odczytywanie danych sesji:
Aby odczytać dane sesji, możemy po prostu odwołać się do zmiennych sesji.
<?php
// Rozpoczęcie sesji
session_start();
// Odczytanie danych sesji
$username = $_SESSION['username'];
$email = $_SESSION['email'];
// Wyświetlenie danych sesji
echo "Username: " . $username . "<br>";
echo "Email: " . $email . "<br>";
?>4. Usuwanie danych sesji:
Możemy usunąć pojedynczą zmienną sesji lub całą sesję.
<?php
// Rozpoczęcie sesji
session_start();
// Usunięcie pojedynczej zmiennej sesji
unset($_SESSION['username']);
// Usunięcie całej sesji
session_destroy();
?>Sesje są przydatnym narzędziem do przechowywania danych użytkownika w trakcie trwania sesji przeglądarki. Umożliwiają one przechowywanie informacji, takich jak dane logowania, preferencje użytkownika czy stan koszyka w sklepie internetowym, pomiędzy różnymi żądaniami HTTP. Jednak warto pamiętać, że przechowywanie zbyt wielu danych w sesji może negatywnie wpłynąć na wydajność aplikacji.
W tej lekcji omówimy podstawy pracy z ciasteczkami w PHP, włączając w to tworzenie, odczytywanie i usuwanie ciasteczek.
1. Tworzenie ciasteczek:
Ciasteczka są przechowywane po stronie klienta i mogą być używane do przechowywania małych ilości danych, takich jak preferencje użytkownika czy identyfikatory sesji.
<?php
// Ustawienie ciasteczka na 1 godzinę
setcookie("username", "example_user", time() + 3600, "/");
?>W powyższym przykładzie tworzymy ciasteczko o nazwie "username" i wartości "example_user". Wartość time() + 3600 określa czas wygaśnięcia ciasteczka (tu: po 1 godzinie od aktualnego czasu).
2. Odczytywanie ciasteczek:
Możemy odczytać wartość ciasteczka za pomocą tablicy superglobalnej $_COOKIE.
<?php
// Odczytanie wartości ciasteczka
$username = $_COOKIE['username'];
echo "Username: " . $username;
?>3. Usuwanie ciasteczek:
Aby usunąć ciasteczko, można ustawić je ponownie z czasem wygaśnięcia przeszłym.
<?php
// Usunięcie ciasteczka
setcookie("username", "", time() - 3600, "/");
?>W tym przykładzie ustawiamy ciasteczko o nazwie "username" z pustą wartością i czasem wygaśnięcia przeszłym, co skutkuje usunięciem ciasteczka.
Ciasteczka są przydatnym narzędziem do przechowywania informacji po stronie klienta, co pozwala na dostosowywanie zawartości strony internetowej do preferencji użytkownika. Jednak należy pamiętać, że ciasteczka mogą być ograniczone ze względu na prywatność użytkownika i ich wielkość, dlatego należy stosować je z rozwagą.
Oto proste ćwiczenie praktyczne, w którym stworzymy prosty system logowania i rejestracji użytkowników w PHP z wykorzystaniem sesji i bazy danych MySQL:
CREATE TABLE users (
id INT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(50) NOT NULL,
email VARCHAR(50) NOT NULL,
password VARCHAR(255) NOT NULL
); <!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Rejestracja</title>
</head>
<body>
<h2>Rejestracja</h2>
<form action="register.php" method="POST">
<label for="username">Nazwa użytkownika:</label>
<input type="text" id="username" name="username" required><br><br>
<label for="email">Email:</label>
<input type="email" id="email" name="email" required><br><br>
<label for="password">Hasło:</label>
<input type="password" id="password" name="password" required><br><br>
<button type="submit">Zarejestruj się</button>
</form>
</body>
</html>register.php), który będzie obsługiwał proces rejestracji użytkownika. <?php
// Połączenie z bazą danych
$conn = mysqli_connect("localhost", "nazwa_uzytkownika", "haslo", "nazwa_bazy_danych");
// Sprawdzenie połączenia
if (!$conn) {
die("Błąd połączenia: " . mysqli_connect_error());
}
// Pobranie danych z formularza
$username = $_POST['username'];
$email = $_POST['email'];
$password = password_hash($_POST['password'], PASSWORD_DEFAULT); // Hashowanie hasła
// Dodanie użytkownika do bazy danych
$sql = "INSERT INTO users (username, email, password) VALUES ('$username', '$email', '$password')";
if (mysqli_query($conn, $sql)) {
echo "Rejestracja zakończona sukcesem";
} else {
echo "Błąd podczas rejestracji: " . mysqli_error($conn);
}
// Zamknięcie połączenia
mysqli_close($conn);
?> <!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Logowanie</title>
</head>
<body>
<h2>Logowanie</h2>
<form action="login.php" method="POST">
<label for="username">Nazwa użytkownika:</label>
<input type="text" id="username" name="username" required><br><br>
<label for="password">Hasło:</label>
<input type="password" id="password" name="password" required><br><br>
<button type="submit">Zaloguj się</button>
</form>
</body>
</html>login.php), który będzie obsługiwał proces logowania użytkownika. <?php
// Rozpoczęcie sesji
session_start();
// Połączenie z bazą danych
$conn = mysqli_connect("localhost", "nazwa_uzytkownika", "haslo", "nazwa_bazy_danych");
// Sprawdzenie połączenia
if (!$conn) {
die("Błąd połąc
zenia: " . mysqli_connect_error());
}
// Pobranie danych z formularza
$username = $_POST['username'];
$password = $_POST['password'];
// Zapytanie SQL
$sql = "SELECT * FROM users WHERE username='$username'";
$result = mysqli_query($conn, $sql);
if (mysqli_num_rows($result) == 1) {
$row = mysqli_fetch_assoc($result);
if (password_verify($password, $row['password'])) {
$_SESSION['username'] = $username;
echo "Zalogowano pomyślnie";
} else {
echo "Nieprawidłowe hasło";
}
} else {
echo "Użytkownik nie istnieje";
}
// Zamknięcie połączenia
mysqli_close($conn);
?>To proste ćwiczenie praktyczne pokazuje, jak stworzyć prosty system logowania i rejestracji użytkowników w PHP z wykorzystaniem sesji i bazy danych MySQL.
Oto sposób, w jaki możemy zabezpieczyć ten kod przed atakami hakerskimi, linijka po linijce:
<?php
// Połączenie z bazą danych
$conn = mysqli_connect("localhost", "nazwa_uzytkownika", "haslo", "nazwa_bazy_danych");
// Sprawdzenie połączenia
if (!$conn) {
die("Błąd połączenia: " . mysqli_connect_error());
}
// Pobranie danych z formularza
$username = mysqli_real_escape_string($conn, $_POST['username']);
$email = mysqli_real_escape_string($conn, $_POST['email']);
$password = password_hash(mysqli_real_escape_string($conn, $_POST['password']), PASSWORD_DEFAULT); // Hashowanie hasła
// Sprawdzenie poprawności adresu email
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
die("Nieprawidłowy adres email");
}
// Sprawdzenie długości hasła
if (strlen($_POST['password']) < 8) {
die("Hasło musi zawierać co najmniej 8 znaków");
}
// Dodanie użytkownika do bazy danych
$stmt = mysqli_prepare($conn, "INSERT INTO users (username, email, password) VALUES (?, ?, ?)");
mysqli_stmt_bind_param($stmt, "sss", $username, $email, $password);
if (mysqli_stmt_execute($stmt)) {
echo "Rejestracja zakończona sukcesem";
} else {
echo "Błąd podczas rejestracji: " . mysqli_error($conn);
}
// Zamknięcie połączenia
mysqli_close($conn);
?>Wyjaśnienie zmian:
mysqli_real_escape_string(): Funkcja ta zabezpiecza dane wejściowe przed wstrzykiwaniem SQL poprzez escapowanie specjalnych znaków, co zapobiega atakom typu SQL Injection.filter_var(): Funkcja ta sprawdza, czy podany adres email jest poprawny. Zapewnia to, że adres email jest w prawidłowym formacie przed zapisaniem go do bazy danych.mysqli_prepare() i mysqli_stmt_bind_param(): Te funkcje umożliwiają przygotowanie zapytania SQL z parametrami, co zapobiega wstrzykiwaniu SQL. Parametry są bezpiecznie wprowadzane do zapytania SQL bez konieczności escapowania danych.Zastosowanie tych metod zwiększa bezpieczeństwo aplikacji poprzez zabezpieczenie jej przed atakami SQL Injection oraz sprawdzenie poprawności danych wejściowych.
Oto sposób, w jaki możemy zabezpieczyć ten kod przed atakami hakerskimi, linijka po linijce:
<?php
// Rozpoczęcie sesji
session_start();
// Połączenie z bazą danych
$conn = mysqli_connect("localhost", "nazwa_uzytkownika", "haslo", "nazwa_bazy_danych");
// Sprawdzenie połączenia
if (!$conn) {
die("Błąd połączenia: " . mysqli_connect_error());
}
// Pobranie danych z formularza i zabezpieczenie przed atakami SQL Injection
$username = mysqli_real_escape_string($conn, $_POST['username']);
$password = mysqli_real_escape_string($conn, $_POST['password']);
// Zapytanie SQL z parametrami
$stmt = mysqli_prepare($conn, "SELECT * FROM users WHERE username=?");
mysqli_stmt_bind_param($stmt, "s", $username);
mysqli_stmt_execute($stmt);
$result = mysqli_stmt_get_result($stmt);
// Sprawdzenie, czy użytkownik istnieje
if (mysqli_num_rows($result) == 1) {
$row = mysqli_fetch_assoc($result);
// Weryfikacja hasła
if (password_verify($password, $row['password'])) {
$_SESSION['username'] = $username;
echo "Zalogowano pomyślnie";
} else {
echo "Nieprawidłowe hasło";
}
} else {
echo "Użytkownik nie istnieje";
}
// Zamknięcie połączenia
mysqli_close($conn);
?>Wyjaśnienie zmian:
mysqli_real_escape_string(): Funkcja ta zabezpiecza dane wejściowe przed wstrzykiwaniem SQL poprzez escapowanie specjalnych znaków, co zapobiega atakom typu SQL Injection.?). Następnie, używając funkcji mysqli_stmt_bind_param(), przypisujemy wartości do tych parametrów. Jest to bardziej bezpieczny sposób wykonywania zapytań SQL, ponieważ dane są bezpiecznie wprowadzane do zapytania bez konieczności escapowania.mysqli_stmt_execute() i mysqli_stmt_get_result(): Po wykonaniu przygotowanego zapytania za pomocą mysqli_stmt_execute(), możemy uzyskać wyniki zapytania za pomocą mysqli_stmt_get_result().Te zmiany zabezpieczają kod przed atakami typu SQL Injection oraz zwiększają ogólne bezpieczeństwo aplikacji poprzez prawidłowe przetwarzanie danych wejściowych.
W tej lekcji omówimy podstawy programowania obiektowego w PHP, włączając w to klasy i obiekty.
1. Klasy w PHP:
Klasy są szablonami do tworzenia obiektów. Zawierają one właściwości (zmienne) i metody (funkcje).
class Car {
// Właściwości (zmienne)
public $brand;
public $model;
// Metody
public function drive() {
return "Jadę samochodem {$this->brand} {$this->model}";
}
}W powyższym przykładzie definiujemy klasę Car z dwiema właściwościami ($brand i $model) oraz jedną metodą (drive()).
2. Obiekty w PHP:
Obiekty są instancjami klas. Możemy tworzyć obiekty na podstawie klasy za pomocą operatora new.
$car1 = new Car();
$car1->brand = "Toyota";
$car1->model = "Corolla";
echo $car1->drive(); // Output: Jadę samochodem Toyota CorollaW powyższym przykładzie tworzymy obiekt $car1 na podstawie klasy Car i ustawiamy jego właściwości. Następnie wywołujemy metodę drive() dla tego obiektu.
3. Konstruktory i destruktory:
Konstruktor jest specjalną metodą, która jest wywoływana podczas tworzenia nowego obiektu. Możemy użyć go do inicjalizacji właściwości obiektu.
class Person {
public $name;
// Konstruktor
public function __construct($name) {
$this->name = $name;
echo "Nowa osoba została stworzona: {$this->name}";
}
}Dekonstruktor jest specjalną metodą, która jest wywoływana podczas usuwania obiektu.
class Person {
public function __destruct() {
echo "Osoba została usunięta";
}
}4. Dziedziczenie:
Dziedziczenie pozwala na tworzenie nowych klas na podstawie istniejących klas.
class Animal {
public function makeSound() {
return "Zwierzę wydaje dźwięk";
}
}
class Dog extends Animal {
public function makeSound() {
return "Pies szczeka";
}
}W tym przykładzie klasa Dog dziedziczy metodę makeSound() po klasie Animal, ale nadpisuje ją, aby zwracała specyficzny dla psa dźwięk.
Programowanie obiektowe pozwala na lepszą organizację kodu poprzez enkapsulację danych i zachowań. Umożliwia to również tworzenie bardziej elastycznych i rozszerzalnych aplikacji. W dalszych lekcjach będziemy zgłębiać bardziej zaawansowane zagadnienia związane z programowaniem obiektowym w PHP.
Przyjrzyjmy się innemu przykładowi klasy i obiektu w PHP, który będzie reprezentował prosty system bankowy z klientami i ich kontami.
<?php
// Definicja klasy Client
class Client {
public $name;
public $email;
public $balance;
// Konstruktor
public function __construct($name, $email, $balance) {
$this->name = $name;
$this->email = $email;
$this->balance = $balance;
}
// Metoda do wyświetlania informacji o kliencie
public function displayInfo() {
return "Klient: {$this->name}, Email: {$this->email}, Saldo: {$this->balance}";
}
// Metoda do wpłacania środków na konto
public function deposit($amount) {
$this->balance += $amount;
return "Wpłacono $amount zł. Aktualne saldo: {$this->balance} zł";
}
// Metoda do wypłacania środków z konta
public function withdraw($amount) {
if ($amount <= $this->balance) {
$this->balance -= $amount;
return "Wypłacono $amount zł. Aktualne saldo: {$this->balance} zł";
} else {
return "Brak wystarczających środków na koncie";
}
}
}
// Utworzenie obiektu klienta
$client1 = new Client("Jan Kowalski", "jan@example.com", 1000);
// Wyświetlenie informacji o kliencie
echo $client1->displayInfo() . "<br>";
// Wpłata na konto
echo $client1->deposit(500) . "<br>";
// Wypłata z konta
echo $client1->withdraw(2000) . "<br>";
// Wyświetlenie informacji o kliencie po operacjach
echo $client1->displayInfo();
?>W powyższym przykładzie definiujemy klasę Client, która reprezentuje klienta banku. Klasa ta zawiera właściwości klienta (imię, email, saldo) oraz metody do wyświetlania informacji o kliencie, wpłacania i wypłacania środków z konta.
Tworzymy obiekt klienta o nazwie $client1 za pomocą konstruktora __construct(), a następnie wykonujemy na nim różne operacje, takie jak wpłata i wypłata środków, korzystając z metod deposit() i withdraw().
Programowanie obiektowe pozwala na tworzenie bardziej czytelnego, elastycznego i łatwiejszego w zarządzaniu kodu. W tym przykładzie wykorzystujemy klasę i obiekt do symulowania prostego systemu bankowego.
W tej lekcji omówimy bardziej zaawansowane zagadnienia dotyczące metod i właściwości obiektów w PHP.
1. Dostępność właściwości:
Właściwości obiektów mogą mieć różne poziomy dostępności: publiczne, chronione i prywatne.
class Car {
public $brand; // Właściwość publiczna
protected $model; // Właściwość chroniona
private $color; // Właściwość prywatna
}Właściwość publiczna jest dostępna zarówno wewnątrz klasy, jak i na zewnątrz, chroniona jest dostępna tylko wewnątrz klasy i klas dziedziczących, a prywatna jest dostępna tylko wewnątrz klasy.
2. Metody dostępowe:
Metody dostępowe pozwalają na kontrolę dostępu do właściwości obiektów.
class Car {
private $model;
// Metoda dostępowa (getter)
public function getModel() {
return $this->model;
}
// Metoda dostępowe (setter)
public function setModel($model) {
$this->model = $model;
}
}W powyższym przykładzie getModel() to metoda dostępu (getter), która zwraca wartość właściwości $model, a setModel() to metoda dostępu (setter), która ustawia wartość właściwości $model.
3. Metody magiczne:
PHP dostarcza kilka specjalnych metod zwanych metodami magicznymi, które są wywoływane automatycznie w określonych sytuacjach.
class Car {
private $model;
// Konstruktor
public function __construct($model) {
$this->model = $model;
}
// Metoda wywoływana przy próbie wyświetlenia obiektu
public function __toString() {
return "Model: " . $this->model;
}
}W powyższym przykładzie __construct() jest konstruktorem, który jest wywoływany automatycznie podczas tworzenia nowego obiektu, a __toString() jest metodą magiczną, która jest wywoływana automatycznie, gdy obiekt jest próbowany być użyty jako string.
Metody i właściwości obiektów są kluczowymi elementami programowania obiektowego w PHP. Właściwa kontrola dostępu i wykorzystanie metod dostępowych pozwala na bezpieczne i skuteczne zarządzanie obiektami. Metody magiczne mogą być używane do dostosowywania zachowania obiektów w różnych sytuacjach.
W tej lekcji omówimy zaawansowane koncepcje programowania obiektowego w PHP, takie jak dziedziczenie i polimorfizm.
1. Dziedziczenie:
Dziedziczenie pozwala na tworzenie nowych klas na podstawie istniejących klas, które dziedziczą ich właściwości i metody.
// Klasa bazowa
class Animal {
public function makeSound() {
return "Zwierzę wydaje dźwięk";
}
}
// Klasa dziedzicząca
class Dog extends Animal {
public function makeSound() {
return "Pies szczeka";
}
}W tym przykładzie klasa Dog dziedziczy metodę makeSound() po klasie Animal, ale nadpisuje ją, aby zwracała specyficzny dla psa dźwięk.
2. Polimorfizm:
Polimorfizm to zdolność różnych klas do posiadania tych samych nazw metod, które zachowują się w różny sposób.
class Animal {
public function makeSound() {
return "Zwierzę wydaje dźwięk";
}
}
class Dog extends Animal {
public function makeSound() {
return "Pies szczeka";
}
}
class Cat extends Animal {
public function makeSound() {
return "Kot miauczy";
}
}W tym przykładzie zarówno klasy Dog jak i Cat posiadają metodę makeSound(), ale każda z nich ma inną implementację, co pozwala na polimorficzne użycie metod w zależności od typu obiektu.
Polimorfizm pozwala na elastyczne i modularne projektowanie aplikacji, ponieważ pozwala na używanie tych samych interfejsów dla różnych typów obiektów.
Dziedziczenie i polimorfizm są kluczowymi koncepcjami programowania obiektowego w PHP. Poprawne ich wykorzystanie pozwala na tworzenie bardziej elastycznych i łatwych w utrzymaniu aplikacji.
Oto przykład wykorzystania dziedziczenia i polimorfizmu w prostym systemie bankowym:
<?php
// Klasa bazowa reprezentująca konto bankowe
class Account {
protected $balance;
public function __construct($balance) {
$this->balance = $balance;
}
public function deposit($amount) {
$this->balance += $amount;
return "Wpłacono $amount zł. Aktualne saldo: {$this->balance} zł";
}
public function withdraw($amount) {
if ($amount <= $this->balance) {
$this->balance -= $amount;
return "Wypłacono $amount zł. Aktualne saldo: {$this->balance} zł";
} else {
return "Brak wystarczających środków na koncie";
}
}
}
// Klasa dziedzicząca reprezentująca konto oszczędnościowe
class SavingsAccount extends Account {
private $interestRate;
public function __construct($balance, $interestRate) {
parent::__construct($balance);
$this->interestRate = $interestRate;
}
public function addInterest() {
$interest = $this->balance * ($this->interestRate / 100);
$this->balance += $interest;
return "Odsetki dodane. Aktualne saldo: {$this->balance} zł";
}
}
// Klasa dziedzicząca reprezentująca konto oszczędnościowe
class CheckingAccount extends Account {
private $monthlyFee;
public function __construct($balance, $monthlyFee) {
parent::__construct($balance);
$this->monthlyFee = $monthlyFee;
}
public function deductMonthlyFee() {
$this->balance -= $this->monthlyFee;
return "Opłata miesięczna odjęta. Aktualne saldo: {$this->balance} zł";
}
}
// Utworzenie konta oszczędnościowego
$savingsAccount = new SavingsAccount(1000, 2);
echo $savingsAccount->deposit(500) . "<br>";
echo $savingsAccount->addInterest() . "<br>";
// Utworzenie konta osobistego
$checkingAccount = new CheckingAccount(2000, 10);
echo $checkingAccount->withdraw(300) . "<br>";
echo $checkingAccount->deductMonthlyFee() . "<br>";
?>W tym przykładzie mamy klasę bazową Account, która reprezentuje ogólne konto bankowe z metodami deposit() i withdraw(). Następnie mamy dwie klasy dziedziczące: SavingsAccount (konto oszczędnościowe) i CheckingAccount (konto osobiste). Każda z tych klas dziedziczy metodę deposit() i withdraw() z klasy bazowej, ale dodatkowo ma swoje unikalne metody, takie jak addInterest() dla konta oszczędnościowego i deductMonthlyFee() dla konta osobistego.
Dzięki dziedziczeniu i polimorfizmowi możemy tworzyć różne rodzaje kont bankowych, które mają wspólne zachowanie (np. wpłacanie i wypłacanie środków), ale także unikalne zachowanie (np. obliczanie odsetek dla konta oszczędnościowego)
Ćwiczenie Praktyczne:
Oczywiście! Tutaj jest przykładowa prosta aplikacja do zarządzania produktami w PHP:
<?php
// Klasa reprezentująca produkt
class Product {
private $name;
private $price;
public function __construct($name, $price) {
$this->name = $name;
$this->price = $price;
}
public function getName() {
return $this->name;
}
public function getPrice() {
return $this->price;
}
}
// Klasa reprezentująca magazyn produktów
class ProductInventory {
private $products = [];
public function addProduct($product) {
$this->products[] = $product;
}
public function listProducts() {
foreach ($this->products as $product) {
echo "Produkt: " . $product->getName() . ", Cena: " . $product->getPrice() . " zł<br>";
}
}
}
// Utworzenie kilku produktów
$product1 = new Product("Laptop", 2500);
$product2 = new Product("Smartfon", 1500);
$product3 = new Product("Tablet", 800);
// Utworzenie magazynu i dodanie produktów
$inventory = new ProductInventory();
$inventory->addProduct($product1);
$inventory->addProduct($product2);
$inventory->addProduct($product3);
// Wyświetlenie listy produktów
echo "Lista produktów w magazynie:<br>";
$inventory->listProducts();
?>W tym przykładzie mamy klasę Product, która reprezentuje pojedynczy produkt z właściwościami name (nazwa) i price (cena). Następnie mamy klasę ProductInventory, która reprezentuje magazyn produktów. Pozwala ona na dodawanie produktów do magazynu za pomocą metody addProduct() i wyświetlanie listy produktów za pomocą metody listProducts().
Tworzymy kilka produktów, dodajemy je do magazynu, a następnie wyświetlamy listę produktów znajdujących się w magazynie.
To proste ćwiczenie pokazuje, jak można użyć klas i obiektów w PHP do zarządzania produktami w aplikacji. Można rozbudować tę aplikację, dodając więcej funkcji, takich jak usuwanie produktów, aktualizowanie cen, itp.
W tej lekcji omówimy operacje na plikach w PHP, takie jak odczyt, zapis i modyfikacja.
1. Otwieranie i odczyt pliku:
$file = fopen("plik.txt", "r");
if ($file) {
while (($line = fgets($file)) !== false) {
echo $line;
}
fclose($file);
} else {
echo "Nie można otworzyć pliku.";
}W powyższym przykładzie otwieramy plik o nazwie "plik.txt" do odczytu ("r") i następnie używamy funkcji fgets() do odczytania kolejnych linii pliku.
2. Zapis do pliku:
$data = "Zapis do pliku.";
$file = fopen("plik.txt", "w");
if ($file) {
fwrite($file, $data);
fclose($file);
echo "Zapisano do pliku.";
} else {
echo "Nie można otworzyć pliku.";
}W tym przykładzie otwieramy plik do zapisu ("w") i korzystamy z funkcji fwrite() do zapisania danych do pliku.
3. Modyfikacja pliku:
$file = "plik.txt";
if (file_exists($file)) {
$content = file_get_contents($file);
$content .= "\nNowa zawartość";
file_put_contents($file, $content);
echo "Plik zaktualizowany.";
} else {
echo "Plik nie istnieje.";
}W tym przykładzie pobieramy zawartość pliku za pomocą funkcji file_get_contents(), dodajemy nową zawartość, a następnie zapisujemy zmienioną zawartość za pomocą funkcji file_put_contents().
Operacje na plikach są powszechnie używane w PHP do manipulacji danymi tekstowymi, takimi jak konfiguracje, dzienniki, pliki źródłowe itp. Warto pamiętać o bezpieczeństwie i sprawdzaniu uprawnień do plików podczas operacji na plikach.
W tej lekcji omówimy, jak w PHP wysyłać pliki na serwer i pobierać je z serwera.
1. Wysyłanie plików na serwer:
Aby umożliwić użytkownikom wysyłanie plików na serwer, możemy wykorzystać formularz HTML z polem typu file. Następnie w PHP możemy skorzystać z tablicy $_FILES, aby uzyskać dostęp do przesłanych plików.
Formularz HTML:
<form action="upload.php" method="post" enctype="multipart/form-data">
Wybierz plik: <input type="file" name="fileToUpload" id="fileToUpload">
<input type="submit" value="Wyślij plik" name="submit">
</form>Skrypt PHP do przetwarzania przesłanego pliku (upload.php):
$targetDir = "uploads/";
$targetFile = $targetDir . basename($_FILES["fileToUpload"]["name"]);
if (move_uploaded_file($_FILES["fileToUpload"]["tmp_name"], $targetFile)) {
echo "Plik został wysłany na serwer.";
} else {
echo "Wystąpił problem podczas wysyłania pliku.";
}W tym skrypcie PHP używamy funkcji move_uploaded_file() do przeniesienia pliku z jego tymczasowego katalogu docelowego na serwer.
2. Pobieranie plików z serwera:
Aby umożliwić użytkownikom pobieranie plików z serwera, możemy utworzyć linki do plików lub przekazać je poprzez formularz.
Przykład linku do pobrania pliku:
<a href="download.php?file=plik.txt">Pobierz plik</a>Skrypt PHP do obsługi pobierania plików (download.php):
$file = $_GET['file'];
$filePath = 'uploads/' . $file;
if (file_exists($filePath)) {
header('Content-Disposition: attachment; filename=' . basename($filePath));
readfile($filePath);
} else {
echo "Plik nie istnieje.";
}W tym skrypcie PHP używamy nagłówka Content-Disposition w połączeniu z funkcją readfile() do przekazywania pliku do użytkownika do pobrania.
Wysyłanie i pobieranie plików z serwera jest ważnym aspektem wielu aplikacji internetowych. W PHP istnieją wbudowane funkcje do obsługi tych operacji, co ułatwia pracę z plikami na serwerze. Jednak warto pamiętać o zabezpieczeniach, takich jak sprawdzanie typu plików i uprawnień dostępu do katalogów, aby uniknąć potencjalnych zagrożeń.
W tej lekcji omówimy manipulację danymi w formacie JSON oraz serializację i deserializację danych w PHP.
1. JSON (JavaScript Object Notation):
JSON jest lekkim formatem wymiany danych, który jest powszechnie używany do przesyłania danych między klientem a serwerem w aplikacjach internetowych.
Serializacja do formatu JSON:
$data = array("name" => "John", "age" => 30, "city" => "New York");
$jsonData = json_encode($data);
echo $jsonData;W tym przykładzie tablica danych jest serializowana do formatu JSON za pomocą funkcji json_encode().
Deserializacja z formatu JSON:
$jsonData = '{"name":"John","age":30,"city":"New York"}';
$data = json_decode($jsonData, true);
echo $data["name"]; // John
echo $data["age"]; // 30
echo $data["city"]; // New YorkW tym przykładzie dane w formacie JSON są deserializowane za pomocą funkcji json_decode().
2. Serializacja i deserializacja w PHP:
Serializacja w PHP polega na konwersji danych do ciągu znaków, który może być łatwo zapisany do pliku lub przechowywany w bazie danych. Deserializacja jest procesem odwrotnym, polegającym na przywróceniu danych z ciągu znaków do ich pierwotnej postaci.
Serializacja:
$data = array("name" => "John", "age" => 30, "city" => "New York");
$serializedData = serialize($data);
echo $serializedData;W tym przykładzie tablica danych jest serializowana za pomocą funkcji serialize().
Deserializacja:
$serializedData = 'a:3:{s:4:"name";s:4:"John";s:3:"age";i:30;s:4:"city";s:8:"New York";}';
$data = unserialize($serializedData);
print_r($data);W tym przykładzie dane są deserializowane za pomocą funkcji unserialize().
Manipulacja danymi w formacie JSON oraz serializacja i deserializacja danych w PHP są przydatne w wielu sytuacjach, takich jak przesyłanie danych między klientem a serwerem, przechowywanie danych w plikach lub bazach danych, a także przechowywanie stanu sesji. Warto być świadomym różnic między tymi metodami oraz wiedzieć, kiedy zastosować jedną zamiast drugiej w zależności od potrzeb i wymagań aplikacji.
<strong>Ćwiczenie praktyczne: Aplikacja do importu i eksportu danych w formacie CSV</strong>
Prosta aplikacja w PHP do importu i eksportu danych w formacie CSV:
```php
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Aplikacja CSV</title>
</head>
<body>
<h2>Import danych z pliku CSV</h2>
<form action="" method="post" enctype="multipart/form-data">
Wybierz plik CSV: <input type="file" name="fileToImport" required><br>
<button type="submit" name="import">Importuj dane</button>
</form>
<?php
// Obsługa importu danych
if (isset($_POST['import'])) {
$file = $_FILES['fileToImport']['tmp_name'];
$data = [];
if (($handle = fopen($file, "r")) !== FALSE) {
while (($row = fgetcsv($handle, 1000, ",")) !== FALSE) {
$data[] = $row;
}
fclose($handle);
}
// Wyświetlenie danych
echo "<h2>Zaimportowane dane:</h2>";
echo "<table border='1'>";
foreach ($data as $row) {
echo "<tr>";
foreach ($row as $cell) {
echo "<td>" . htmlspecialchars($cell) . "</td>";
}
echo "</tr>";
}
echo "</table>";
}
// Obsługa eksportu danych
$data = array(
array('Imię', 'Nazwisko', 'Wiek'),
array('John', 'Doe', 30),
array('Jane', 'Smith', 25),
array('Tom', 'Jones', 40)
);
$csvFileName = 'export.csv';
$csvFile = fopen($csvFileName, 'w');
foreach ($data as $row) {
fputcsv($csvFile, $row);
}
fclose($csvFile);
?>
<h2>Eksport danych do pliku CSV</h2>
<p><a href="<?php echo $csvFileName; ?>" download>Pobierz plik CSV</a></p>
</body>
</html>
```
Powyższy kod zawiera prostą aplikację PHP, która umożliwia użytkownikowi importowanie danych z pliku CSV oraz eksportowanie danych do pliku CSV.
- Sekcja "Import danych z pliku CSV" zawiera formularz umożliwiający wybór pliku CSV do importu. Po zatwierdzeniu formularza, dane są odczytywane z pliku CSV i wyświetlane w formie tabeli HTML.
- Sekcja "Eksport danych do pliku CSV" generuje plik CSV z danymi i udostępnia link do pobrania tego pliku.
Ta aplikacja jest przykładem prostego narzędzia do manipulacji danymi w formacie CSV za pomocą PHP. Można ją rozbudować o dodatkowe funkcje, takie jak obsługa błędów, walidacja danych lub filtrowanie danych przed importem i eksportem.W tej lekcji omówimy podstawowe zabezpieczenia w PHP, takie jak filtracja danych i walidacja formularzy, które pomagają zapobiegać atakom hakerskim i zapewniają poprawność danych.
1. Filtracja danych:
Filtracja danych to proces usuwania lub modyfikowania danych wejściowych w celu zapobieżenia atakom typu SQL Injection, Cross-Site Scripting (XSS) oraz innych zagrożeń związanych z manipulacją danymi.
Przykład filtracji danych za pomocą funkcji mysqli_real_escape_string():
$username = mysqli_real_escape_string($conn, $_POST['username']);
$password = mysqli_real_escape_string($conn, $_POST['password']);Funkcja mysqli_real_escape_string() usuwa lub unieszkodliwia znaki specjalne, które mogłyby być wykorzystane do ataków SQL Injection.
Oto 10 przykładów filtracji danych w PHP:
$input = "Hello <script>alert('XSS');</script> World!";
$filteredInput = filter_var($input, FILTER_SANITIZE_STRING);
echo $filteredInput; // Wyświetli: Hello alert('XSS'); World!$input = "123abc";
$filteredInput = filter_var($input, FILTER_SANITIZE_NUMBER_INT);
echo $filteredInput; // Wyświetli: 123$email = "invalid_email@example";
$filteredEmail = filter_var($email, FILTER_VALIDATE_EMAIL);
if ($filteredEmail === false) {
echo "Nieprawidłowy adres email";
}$ip = "192.168.1.300";
$filteredIp = filter_var($ip, FILTER_VALIDATE_IP);
if ($filteredIp === false) {
echo "Nieprawidłowy adres IP";
}$url = "example.com";
$filteredUrl = filter_var($url, FILTER_VALIDATE_URL);
if ($filteredUrl === false) {
echo "Nieprawidłowy adres URL";
}$input = "3.14abc";
$filteredInput = filter_var($input, FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION);
echo $filteredInput; // Wyświetli: 3.14$input = "true";
$filteredInput = filter_var($input, FILTER_VALIDATE_BOOLEAN);
if ($filteredInput === false) {
echo "Nieprawidłowa wartość logiczna";
}$input = "hello";
$filteredInput = filter_var($input, FILTER_CALLBACK, array("options" => "strtoupper"));
echo $filteredInput; // Wyświetli: HELLOfunction customFilter($value) {
return str_replace('a', 'x', $value);
}
$input = "banana";
$filteredInput = filter_var($input, FILTER_CALLBACK, array("options" => "customFilter"));
echo $filteredInput; // Wyświetli: bxnxnxs$array = array("Hello", "<script>alert('XSS');</script>", "World!");
$filteredArray = filter_var_array($array, FILTER_SANITIZE_STRING);
print_r($filteredArray); // Wyświetli: Array ( [0] => Hello [1] => alert('XSS'); [2] => World! )Te przykłady pokazują różne sposoby filtracji danych w PHP, co jest istotnym aspektem w zapewnianiu bezpieczeństwa aplikacji internetowych i poprawności danych.
2. Walidacja formularzy:
Walidacja formularzy polega na sprawdzaniu poprawności danych wprowadzonych przez użytkownika przed ich przetworzeniem lub zapisaniem w bazie danych.
Przykład walidacji adresu e-mail:
$email = $_POST['email'];
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
echo "Nieprawidłowy adres e-mail";
}Funkcja filter_var() z parametrem FILTER_VALIDATE_EMAIL sprawdza, czy podany adres e-mail jest poprawny.
Oto 10 przykładów walidacji formularzy w PHP:
if (empty($_POST['username'])) {
echo "Nazwa użytkownika jest wymagana";
}if (!is_numeric($_POST['age'])) {
echo "Wiek musi być liczbą";
}if (!filter_var($_POST['email'], FILTER_VALIDATE_EMAIL)) {
echo "Nieprawidłowy adres email";
}if (!filter_var($_POST['ip'], FILTER_VALIDATE_IP)) {
echo "Nieprawidłowy adres IP";
}if (!filter_var($_POST['url'], FILTER_VALIDATE_URL)) {
echo "Nieprawidłowy adres URL";
}if (strlen($_POST['message']) < 5) {
echo "Wiadomość musi mieć co najmniej 5 znaków";
}$date = $_POST['date'];
$format = 'Y-m-d';
$dateObj = DateTime::createFromFormat($format, $date);
if (!$dateObj || $dateObj->format($format) != $date) {
echo "Nieprawidłowy format daty";
}$password = $_POST['password'];
if (!preg_match('/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$/', $password)) {
echo "Hasło musi zawierać co najmniej jedną dużą literę, jedną małą literę i jedną cyfrę";
}if (strlen($_POST['comment']) > 1000) {
echo "Komentarz może mieć maksymalnie 1000 znaków";
}if ($_POST['password'] != $_POST['confirm_password']) {
echo "Hasła nie pasują do siebie";
}Te przykłady pokazują różne metody walidacji danych wprowadzonych przez użytkownika w formularzach w PHP. Poprawna walidacja formularzy pomaga zapobiec błędom i atakom hakerskim oraz zapewnia integralność i poprawność danych przetwarzanych przez aplikację.
3. Używanie zabezpieczeń sesji:
Zabezpieczenia sesji są istotne dla aplikacji internetowych. Należy zapewnić unikalny identyfikator sesji dla każdego użytkownika, a także przechowywać poufne dane sesji po stronie serwera.
Przykład rozpoczęcia sesji w PHP:
session_start();Zabezpieczenia sesji w PHP automatycznie generują unikalny identyfikator sesji dla każdego użytkownika i przechowują dane sesji po stronie serwera.
Oto 10 przykładów zabezpieczania sesji w PHP:
session_start();session_regenerate_id(true);ini_set('session.cookie_lifetime', 3600); // Sesja wygaśnie po 1 godzinie nieaktywnościsession_save_path('/custom/session/path');ini_set('session.cookie_httponly', 1);ini_set('session.cookie_secure', 1);ini_set('session.cookie_samesite', 'Strict');session_start(['read_and_close' => true]);$_SESSION['csrf_token'] = bin2hex(random_bytes(32));if (isset($_SESSION['last_activity']) && (time() - $_SESSION['last_activity'] > 3600)) {
session_unset();
session_destroy();
}Zabezpieczanie sesji w PHP jest kluczowym elementem tworzenia bezpiecznych aplikacji internetowych. Warto stosować odpowiednie praktyki zabezpieczeń sesji, aby zapewnić poufność i integralność danych przesyłanych między klientem a serwerem oraz uniknąć ataków hakerskich, takich jak kradzież sesji.
Poprawne stosowanie filtracji danych, walidacji formularzy i zabezpieczeń sesji jest kluczowe dla bezpieczeństwa aplikacji internetowych. Te podstawowe zabezpieczenia mogą pomóc w zapobieganiu wielu popularnym atakom hakerskim i zapewnić integralność i poprawność danych przetwarzanych przez aplikację.
W tej lekcji omówimy, jak zabezpieczyć aplikację przed dwoma częstymi rodzajami ataków: atakiem XSS (Cross-Site Scripting) oraz atakiem SQL Injection.
1. Zabezpieczenie przed atakami XSS:
Ataki XSS polegają na wstrzykiwaniu złośliwego kodu JavaScript do aplikacji internetowej, który może być wykonany przez przeglądarkę użytkownika, narażając ją na różne zagrożenia, takie jak kradzież ciasteczek sesji, przekierowanie na złośliwe strony itp.
htmlspecialchars()) przed wyświetleniem ich na stronie pomaga uniknąć wstrzykiwania kodu JavaScript.Przykład:
$username = "<script>alert('XSS')</script>";
echo htmlspecialchars($username);Przykład:
header("Content-Security-Policy: default-src 'self'");2. Zabezpieczenie przed atakami SQL Injection:
Ataki SQL Injection polegają na wstrzykiwaniu złośliwego kodu SQL do zapytań SQL wykonywanych przez aplikację internetową, co może prowadzić do kradzieży, modyfikacji lub usunięcia danych w bazie danych.
Przykład z użyciem MySQLi:
$stmt = $conn->prepare("SELECT * FROM users WHERE username=? AND password=?");
$stmt->bind_param("ss", $username, $password);
$stmt->execute();mysqli_real_escape_string() może pomóc w uniknięciu wstrzykiwania kodu SQL.Przykład:
$username = mysqli_real_escape_string($conn, $_POST['username']);
$password = mysqli_real_escape_string($conn, $_POST['password']);Zabezpieczanie aplikacji przed atakami XSS i SQL Injection jest kluczowym elementem tworzenia bezpiecznych aplikacji internetowych. Warto stosować odpowiednie praktyki zabezpieczeń, takie jak filtrowanie danych wejściowych, używanie przygotowanych instrukcji SQL oraz ustawianie nagłówków bezpieczeństwa, aby chronić aplikację i dane użytkowników.
W tej lekcji omówimy strategie optymalizacji kodu PHP, które pomagają zwiększyć wydajność aplikacji poprzez cachowanie danych oraz unikanie nadmiernego obciążenia serwera.
1. Cachowanie danych:
Cachowanie danych polega na przechowywaniu wyników operacji, aby uniknąć ponownego obliczania tych samych danych w przyszłości. Może to znacznie przyspieszyć działanie aplikacji, szczególnie jeśli operacje są kosztowne czasowo.
2. Unikanie nadmiernego obciążenia serwera:
Nadmierna ilość zapytań do serwera może prowadzić do obciążenia i spowolnienia aplikacji. Istnieje kilka sposobów unikania nadmiernego obciążenia serwera:
ob_start() i ob_end_flush() pozwala na jednorazowe wysłanie wyniku do przeglądarki klienta, co zmniejsza obciążenie serwera.Optymalizacja kodu PHP poprzez cachowanie danych i unikanie nadmiernego obciążenia serwera jest kluczowym elementem tworzenia wydajnych i responsywnych aplikacji internetowych. Warto stosować odpowiednie strategie optymalizacji, aby zapewnić szybką i płynną działalność aplikacji nawet przy dużej ilości użytkowników i obciążeniu serwera.
Oczywiście! Oto przykłady kodu PHP dla każdego punktu omawianego w lekcji:
1. Cachowanie danych:
a. Cachowanie wyników zapytań bazodanowych:
// Przykład cachowania wyników zapytania do bazy danych
// Sprawdź, czy wynik jest już w cache'u
$cacheKey = 'users_data';
$cache = new Memcached();
$cache->addServer('localhost', 11211);
$result = $cache->get($cacheKey);
if (!$result) {
// Wynik nie jest w cache'u, wykonaj zapytanie do bazy danych
$conn = new mysqli("localhost", "username", "password", "database");
$query = "SELECT * FROM users";
$result = $conn->query($query);
// Zapisz wynik do cache'u na 5 minut
$cache->set($cacheKey, $result->fetch_all(MYSQLI_ASSOC), 300);
}
// Wyświetl wyniki
foreach ($result as $row) {
echo $row['username'] . "<br>";
}b. Cachowanie fragmentów strony:
// Przykład cachowania fragmentów strony za pomocą Memcached
// Sprawdź, czy fragment strony jest już w cache'u
$cacheKey = 'homepage_fragment';
$cache = new Memcached();
$cache->addServer('localhost', 11211);
$htmlFragment = $cache->get($cacheKey);
if (!$htmlFragment) {
// Fragment strony nie jest w cache'u, generuj go
ob_start();
include('homepage_content.php'); // Załadowanie pliku z treścią strony
$htmlFragment = ob_get_clean();
// Zapisz fragment strony do cache'u na 1 godzinę
$cache->set($cacheKey, $htmlFragment, 3600);
}
// Wyświetl fragment strony
echo $htmlFragment;2. Unikanie nadmiernego obciążenia serwera:
a. Ustawianie odpowiednich nagłówków cache-control:
// Ustawienie nagłówków cache-control dla zasobów statycznych
header("Cache-Control: max-age=3600, public");b. Minimalizacja i kompresja zasobów:
// Minimalizacja i kompresja plików CSS
ob_start("ob_gzhandler");
header("Content-type: text/css; charset: UTF-8");
header("Cache-Control: max-age=604800");
header("Expires: " . gmdate("D, d M Y H:i:s", time() + 604800) . " GMT");c. Używanie buforowania wyjścia:
// Użycie buforowania wyjścia
ob_start();
// Generowanie zawartości strony
echo "<html><body>";
echo "<h1>Witaj, świecie!</h1>";
echo "</body></html>";
// Zakończenie buforowania i wysłanie zawartości do przeglądarki klienta
ob_end_flush();Te przykłady pokazują różne sposoby optymalizacji kodu PHP poprzez cachowanie danych oraz unikanie nadmiernego obciążenia serwera. Stosując te techniki, można zwiększyć wydajność aplikacji i zapewnić szybkie ładowanie stron nawet przy dużym obciążeniu serwera.
W ćwiczeniu praktycznym dotyczącym optymalizacji wydajności aplikacji możemy skupić się na kilku kluczowych obszarach, takich jak cachowanie danych, minimalizacja zapytań do bazy danych, optymalizacja zasobów statycznych i buforowanie wyjścia. Oto przykładowy plan działania dla tego ćwiczenia:
1. Cachowanie danych:
2. Minimalizacja zapytań do bazy danych:
3. Optymalizacja zasobów statycznych:
4. Buforowanie wyjścia:
ob_start() i ob_end_flush()) w odpowiednich miejscach kodu, aby uniknąć wielokrotnego generowania i wysyłania zawartości strony do klienta.Praktyczne zastosowanie tych technik wymaga analizy i dostosowania do konkretnych potrzeb i charakterystyki aplikacji. Po wdrożeniu tych optymalizacji warto monitorować wydajność aplikacji i dostosowywać strategię optymalizacji w miarę potrzeb, aby zapewnić płynne działanie nawet przy wzroście obciążenia.
Oczywiście, oto przykłady kodu PHP dla każdego z obszarów optymalizacji wydajności aplikacji:
1. Cachowanie danych:
// Przykład cachowania wyników zapytania do bazy danych
// Sprawdź, czy wynik jest już w cache'u
$cacheKey = 'users_data';
$cache = new Memcached();
$cache->addServer('localhost', 11211);
$result = $cache->get($cacheKey);
if (!$result) {
// Wynik nie jest w cache'u, wykonaj zapytanie do bazy danych
$conn = new mysqli("localhost", "username", "password", "database");
$query = "SELECT * FROM users";
$result = $conn->query($query);
// Zapisz wynik do cache'u na 5 minut
$cache->set($cacheKey, $result->fetch_all(MYSQLI_ASSOC), 300);
}
// Wyświetl wyniki
foreach ($result as $row) {
echo $row['username'] . "<br>";
}2. Minimalizacja zapytań do bazy danych:
// Przykład minimalizacji zapytań do bazy danych poprzez pobranie wielu danych jednym zapytaniem
// Zapytanie do bazy danych pobierające wszystkich użytkowników i ich role
$query = "SELECT u.*, r.role_name FROM users u JOIN roles r ON u.role_id = r.role_id";
$result = $conn->query($query);
// Wyświetlenie wyników
while ($row = $result->fetch_assoc()) {
echo "Username: " . $row['username'] . ", Role: " . $row['role_name'] . "<br>";
}3. Optymalizacja zasobów statycznych:
// Przykład optymalizacji plików CSS poprzez minimalizację i kompresję
// Ustawienie nagłówków cache-control
header("Cache-Control: max-age=3600, public");
// Wczytanie pliku CSS
ob_start();
include('style.css');
$cssContent = ob_get_clean();
// Minimalizacja i kompresja pliku CSS
$minifiedCss = preg_replace('/\s+/', ' ', $cssContent);
$compressedCss = gzencode($minifiedCss);
// Wyświetlenie pliku CSS
header("Content-type: text/css");
echo $compressedCss;4. Buforowanie wyjścia:
// Przykład buforowania wyjścia dla dynamicznie generowanych fragmentów strony
// Włączenie buforowania wyjścia
ob_start();
// Generowanie dynamicznego fragmentu strony
echo "<div>";
echo "<h1>Witaj, świecie!</h1>";
echo "<p>Aktualna data: " . date("Y-m-d H:i:s") . "</p>";
echo "</div>";
// Zakończenie buforowania i wyświetlenie fragmentu strony
ob_end_flush();Te przykłady przedstawiają podstawowe techniki optymalizacji wydajności aplikacji w PHP. Ważne jest dostosowanie tych technik do konkretnych potrzeb i charakterystyki aplikacji oraz regularne monitorowanie wydajności w celu identyfikacji obszarów wymagających dalszej optymalizacji.