Arama Yap Mesaj Senden
Rückruf anfordern
+90
X
X

Wählen Sie Ihre Währung

Türkische Lira $ US Dollar Euro
X
X

Wählen Sie Ihre Währung

Türkische Lira $ US Dollar Euro

Kontaktieren Sie uns

Standort Halkali Merkez Viertel Fatih Str. Ozgur Apt. No. 46, Kucukcekmece, Istanbul, 34303, TR

PHP'de Debuggen
Techniken und Beispiele

Wie erkennen und beheben Sie Fehler in Ihrem Code? Lernen Sie Debugging-Techniken, Tools und Best Practices zur Lösung von Problemen kennen, auf die Sie in Ihren Projektktkten stoßen können.

Fehler
Typen

Erkennen verschiedener Fehlertypen in PHP

Debuggen
Werkzeuge

Die effektivsten Debugging-Tools

Fehler
Management

Fehler erkennen und behandeln

Am besten
Uygulamalar

Professionelle Debugging-Techniken

Was ist Debuggen?

Eine der wichtigsten Phasen des Softwareentwicklungsprozesses

Unter Debuggen versteht man den Prozess des Findens, Verstehens und Behebens von Fehlern in Ihrem Code während des Softwareentwicklungsprozesses.

Jeder Softwareentwickler stößt in seinen Projektktkten auf verschiedene Fehler. Bei diesen Fehlern kann es sich manchmal um einfache Tippfehler, manchmal um logische Fehler oder manchmal um komplexere Systemprobleme handeln. Debuggen ist ein systematischer Ansatz, der Sie bei der Lösung dieser Probleme unterstützt.

Informationen: Der Begriff „Debug“, II. Im Zweiten Weltkrieg gelangte es in die Computerterminologie. Grace Hopper, die an der Harvard University am Mark II-Computer arbeitete, prägte den Begriff „Debugging“, als sie einen tatsächlichen Fehler im Inneren des Computers entdeckte und ihn beseitigte.

Warum ist Debuggen wichtig?

  • Qualitätscode: Fehlerfreier Code ist zuverlässiger und wartbarer.
  • Zaman Tasarrufu: Regelmäßiges Debuggen verhindert größere Probleme in der Zukunft.
  • Fähigkeiten zur Problemlösung: Durch das Debuggen verbessern Sie Ihre Fähigkeiten zur Problemlösung.
  • Code-Verständnis: Wenn Sie Fehler beheben, erhalten Sie ein besseres Verständnis für die Funktionsweise Ihres Codes.
  • Benutzererfahrung: Fehlerfreie Anwendungen bieten Benutzern ein besseres Erlebnis.
Ohne Debuggen
  • unerwartete Abstürze
  • Datenverlustrisiken
  • Unzufriedenheit der Benutzer
  • Schwachstellen
  • Wartungsschwierigkeiten
Mit aktivem Debugging
  • Zuverlässige Anwendung
  • Schnelle Problemlösung
  • Benutzerzufriedenheit
  • Sichererer Code
  • Einfache Wartung und Entwicklung

Fehlertypen in PHP

Das Erkennen verschiedener Fehlertypen beschleunigt den Lösungsprozess

Syntaxfehler (Parse-Fehler)

Hierbei handelt es sich um Probleme, die durch Grammatikfehler in Ihrem PHP-Code verursacht werden. Solche Fehler werden von PHP erkannt, bevor Ihr Code ausgeführt wird, und der Code wird vollständig gestoppt.

Häufige Ursachen:
  • Fehlende oder zusätzliche Klammern, Semikolons
  • Falsche Syntaxstrukturen
  • Falsche Verwendung von Anführungszeichen
  • Missbrauch von PHP-Tags
Beispiel für einen fehlerhaften Code
<?php
// Noktalı Komma eksik
$name = "John"
echo "Merhaba " . $name;

// Yanlış parantez kapama
if($x > 5) {
  echo "x 5'ten groß";
?>
Richtiger Code
<?php
// Noktalı Komma eklendi
$name = "John";
echo "Merhaba " . $name;

// Parantez kapatıldı
if($x > 5) {
  echo "x 5'ten groß";
}
?>

Laufzeitfehler

Dabei handelt es sich um Fehler, die beim Ausführen des Codes auftreten. Obwohl die Syntax korrekt ist, tritt es während der Laufzeit auf und stoppt häufig die Codeausführung.

Häufige Ursachen:
  • Aufruf undefinierter Funktionen oder Klassen
  • Einschließlich nicht vorhandener Dateien
  • Aufrufen einer Funktion mit fehlenden Parametern
  • Versuche, durch Null zu dividieren
Beispiel für einen fehlerhaften Code
<?php
// Nicht definiert fonksiyon çağrısı
calculateTotal($price, $quantity);

// Olmayan bir Datei dahil etme
include 'non_existent_file.php';

// Sıfıra bölme Fehlersı
$result = 10 / 0;
?>
Richtiger Code
<?php
// Fonksiyonu tanımlama
function calculateTotal($price, $quantity) {
  return $price * $quantity;
}
$total = calculateTotal($price, $quantity);

// Dosyanın varlığını kontrol etme
if(file_exists('config.php')) {
  include 'config.php';
}

// Sıfıra bölmeyi kontrol etme
$divisor = 0;
$result = ($divisor != 0) ? (10 / $divisor) : 'Sıfıra bölünemez';
?>

Logikfehler

Hierbei handelt es sich um Fehler, die zwar syntaktisch korrekt funktionieren, aber nicht zum erwarteten Ergebnis führen. Dies sind die am schwersten zu erkennenden Fehler, da PHP sie nicht als Fehler erkennt.

Häufige Ursachen:
  • Falscher Algorithmus oder falsche Geschäftslogik
  • Falsche Bedingungen
  • Falsche Bestimmung der Zyklusgrenzen
  • Falsche Zuweisung von Variablenwerten
Beispiel für einen fehlerhaften Code
<?php
// Sonsuza giden döngü
$i = 1;
while($i > 0) {
  echo $i;
  $i++;  // i her zaman 0'dan groß olacak
}

// Yanlış karşılaştırma operatörü
$age = 20;
if($age = 18) {  // Atama yapılıyor, karşılaştırma değil!
  echo "Yaşınız 18";
}
?>
Richtiger Code
<?php
// Richtig döngü sınırı
$i = 1;
while($i <= 10) {  // 10'a kadar sayar
  echo $i;
  $i++;
}

// Doğru karşılaştırma operatörü
$age = 20;
if($age == 18) {  // Eşitlik karşılaştırması
  echo "Yaşınız 18";
}
?>

Warnungen und Benachrichtigungen (Warnings & Notices)

Diese sind Benachrichtigungen, die Ihren Code nicht stoppen, aber potenzielle Probleme oder Verbesserungsbereiche anzeigen, die für die Optimierung wichtig sind.

Typen:
  • E_WARNING: Schwere, aber nicht blockierende Fehler
  • E_NOTICE: Benachrichtigungen, die mögliche Fehler oder unerwartetes Verhalten anzeigen
  • E_DEPRECATED: Verwendung von Funktionen, die in zukünftigen PHP-Versionen nicht mehr unterstützt werden
  • E_STRICT: Empfehlungen für Best Practices
Warnungs-/Benachrichtigungsbeispiele
<?php
// E_NOTICE: Nicht definiert değişken kullanımı
echo $undefined_var;

// E_WARNING: Olmayan dosya dahil etme
include 'missing_file.php';

// E_DEPRECATED: Verwendungdan kaldırılmış fonksiyon
mysql_connect('localhost', 'user', 'pass');

// E_STRICT: Statik olmayan metodu statik als çağırma
class Test {
  function method() {}
}
Test::method();
?>
Optimierter Code
<?php
// Değişken Prüfungle
$undefined_var = '';
echo $undefined_var;

// Dosya Prüfungle
if(file_exists('config.php')) {
  include 'config.php';
}

// Güncel fonksiyon kullanımı
$conn = new mysqli('localhost', 'user', 'pass');

// Richtig sınıf metodu çağrısı
class Test {
  static function method() {}
}
Test::method();
?>

PHP-Debugging-Techniken

Methoden zur schnellen und effektiven Erkennung und Behebung von Fehlern.

Grundlegende Fehlersuchwerkzeuge

var_dump() Fonksiyonu

Zeigt den Inhalt und die Struktur der Variable im Detail an. Zeigt Informationen zum Datentyp, Länge und Wert an.

<?php
// Basit bir değişken
$name = "Ahmet";
var_dump($name);
// Çıktı: string(5) "Ahmet"

// Dizi
$user = [
  "id" => 1,
  "name" => "Ahmet",
  "age" => 30,
  "active" => true
];
var_dump($user);
// Tüm dizi yapısını ve içeriğini gösterir

// Nesne
$obj = new stdClass();
$obj->name = "Test";
$obj->value = 123;
var_dump($obj);
// Nesnenin türünü ve speziellliklerini gösterir
?>

print_r() Fonksiyonu

Zeigt den Inhalt der Variable in einem lesbaren Format an. Um die Ausgabe einer Variablen zuzuweisen, kann als zweiter Parameter true verwendet werden.

<?php
// Dizi örneği
$colors = ["red", "green", "blue"];
print_r($colors);
/* Çıktı:
Array
(
    [0] => red
    [1] => green
    [2] => blue
)
*/

// Çıktıyı değişkene atama
$output = print_r($colors, true);
echo htmlspecialchars($output); // Sicher HTML Ausgabe

// İç içe dizileri okunabilir formatta gösterir
$complex = [
  "users" => [
    ["name" => "Ali", "role" => "admin"],
    ["name" => "Ayşe", "role" => "editor"]
  ]
];
print_r($complex);
?>

debug_backtrace() Fonksiyonu

Zeigt den Aufrufstapel (call stack) an. Durch die Anzeige, welche Funktionen in welcher Reihenfolge aufgerufen werden, können Sie den Ablauf des Codes verfolgen.

<?php
function first() {
  second();
}

function second() {
  third();
}

function third() {
  // Çağrı yığınını al
  $trace = debug_backtrace();
  echo "Çağrı Yığını:\n";
  foreach ($trace as $level => $call) {
    echo "#$level: ";
    if (isset($call['class'])) {
      echo $call['class'] . '::';
    }
    echo $call['function'] . '()';
    if (isset($call['file'])) {
      echo ' çağrıldı: ' . $call['file'] . ', Zeile: ' . $call['line'];
    }
    echo "\n";
  }
}

// Çağrı zincirini başlat
first();
?>

PHP-Fehlerberichterstattungs-Einstellungen

Einstellungen, die steuern, welche PHP-Fehler angezeigt werden. Es ist in der Entwicklungsphase nützlich, alle Fehler zu sehen.

<?php
// Tüm Fehlerları göster (Entwicklung ortamı für)
error_reporting(E_ALL);
ini_set('display_errors', 1);
ini_set('display_startup_errors', 1);

// Sadece belirli Fehler türlerini göster
error_reporting(E_ERROR | E_WARNING | E_PARSE);

// Fehlerları gizle (canlı ortam für)
error_reporting(0);
ini_set('display_errors', 0);

// Fehlerları loglama
ini_set('log_errors', 1);
ini_set('error_log', '/path/to/error.log');

// PHP.ini üzerinden yapılandırma
/*
error_reporting = E_ALL
display_errors = On
log_errors = On
error_log = /path/to/error.log
*/
?>

Fehlererfassung und -behandlung

try-catch-Blöcke

Strukturen, die potenzielle Fehler abfangen und verarbeiten, damit die Anwendung nicht abstürzt. Sie ermöglichen Fehlerbehandlung über Exceptions.

<?php
// Temel try-catch kullanımı
try {
  // Potansiyel als Fehler verebilecek kod
  $file = fopen('dosya.txt', 'r');
  if (!$file) {
    throw new Exception("Dosya açılamadı!");
  }
  $content = fread($file, filesize('dosya.txt'));
  fclose($file);
} catch (Exception $e) {
  // Fehler yakalandı ve işlendi
  echo "Fehler mesajı: " . $e->getMessage();
  // Alternatif als logla
  error_log("Dosya Fehlersı: " . $e->getMessage());
} finally {
  // Her durumda çalışacak kod
  echo "Arbeitlem tamamlandı.";
}

// Çoklu catch blokları
try {
  $db = new PDO('mysql:host=localhost;dbname=test', 'user', 'pass');
  $stmt = $db->query("SELECT * FROM non_existent_table");
} catch (PDOException $e) {
  // Veritabanı Fehlerlarını yakala
  echo "Veritabanı Fehlersı: " . $e->getMessage();
} catch (Exception $e) {
  // Andere alle Fehlerları yakala
  echo "Genel Fehler: " . $e->getMessage();
}
?>

Benutzerdefinierte Fehlerhandler

Sie können das Standardfehlerverhalten von PHP ändern, indem Sie Ihre eigenen Fehlerbehandlungsfunktionen definieren.

<?php
// Speziell Fehler işleyicisi tanımlama
function customErrorHandler($errno, $errstr, $errfile, $errline) {
  $error_type = "";
  switch ($errno) {
    case E_ERROR:
      $error_type = "Fehler";
      break;
    case E_WARNING:
      $error_type = "Warnung";
      break;
    case E_NOTICE:
      $error_type = "Bildirim";
      break;
    default:
      $error_type = "Bilinmeyen";
      break;
  }

  // Fehler mesajını erstellen
  $error_message = "[$error_type] $errstr in $errfile on line $errline";

  // Fehler logla
  error_log($error_message);

  // Benutzerya daha kullanıcı dostu bir mesaj göster
  if ($errno == E_ERROR) {
    echo "
Bir Fehler oluştu. Bitte daha sonra tekrar deneyin.
"; die(); // Kritik Fehlerlarda çalışmayı durdur } else { echo "
Bir sorun oluştu, ancak işleme devam ediliyor.
"; } // true döndürerek PHP'nin kendi Fehler işleyicisini çalıştırmasını engelle return true; } // Speziell Fehler işleyicisini ayarla set_error_handler("customErrorHandler"); // Şimdi bir Fehler erstellenalım echo $undefined_variable; // E_NOTICE üretecek // Arbeitleyiciyi varsayılana sıfırla restore_error_handler(); ?>

Fortgeschrittene Fehlersuche-Techniken

Xdebug-Erweiterung

Xdebug ist eine leistungsstarke PHP-Erweiterung mit erweiterten Debugging-Funktionen wie schrittweiser Ausführung, Variableninspektion und Code-Coverage-Analyse.

Xdebug erfordert eine zusätzliche Installation in Ihren XAMPP- oder anderen PHP-Umgebungen.
Funktionen, die Xdebug bietet:
  • Schrittweise Codeausführung (Step Debugging)
  • Erweiterte var_dump()-Ausgaben
  • Detaillierte Fehlerberichte
  • Codeumfangsanalyse
  • Profiling und Leistungsanalyse
# Xdebug yapılandırma örneği (php.ini)
[xdebug]
zend_extension=xdebug
xdebug.mode=develop,debug
xdebug.start_with_request=yes
xdebug.client_host=127.0.0.1
xdebug.client_port=9003
xdebug.idekey=VSCODE
xdebug.log=/path/to/xdebug.log

Log-Nutzung

Das Protokollieren ist eine effektive Methode, das Verhalten Ihrer Anwendung zu überwachen und Probleme zu diagnostizieren. Sie können die PHP-Funktion error_log() oder benutzerdefinierte Protokollierungsbibliotheken verwenden.

<?php
// Temel error_log kullanımı
function logMessage($message, $level = 'INFO') {
  error_log("[$level] " . date('Y-m-d H:i:s') . " - $message");
}

// Örnek kullanım
logMessage("Uygulama başlatıldı");
try {
  $db = new PDO('mysql:host=localhost;dbname=test', 'user', 'pass');
  logMessage("Veritabanı bağlantısı kuruldu");
} catch (PDOException $e) {
  logMessage("Veritabanı bağlantı Fehlersı: " . $e->getMessage(), 'ERROR');
}

// Farklı log seviyelerini kullanma
function debug($message) { logMessage($message, 'DEBUG'); }
function info($message) { logMessage($message, 'INFO'); }
function warning($message) { logMessage($message, 'WARNING'); }
function error($message) { logMessage($message, 'ERROR'); }

// Değişken değerlerini loglama
$user_id = 123;
debug("Benutzer ID: $user_id");

// Arbeitlem süresini loglama
$start_time = microtime(true);
// ... işlem yapılıyor ...
$end_time = microtime(true);
$execution_time = ($end_time - $start_time) * 1000; // milisaniye
info("Arbeitlem tamamlandı. Süre: {$execution_time}ms");
?>

Best Practices und Tipps

Professionelle Tipps, die Ihren Debugging-Prozess effizienter machen.

Nehmen Sie einen systematischen Ansatz an.

Fehler isolieren Sie systematisch und nicht zufällig. Das Problem isolieren, Hypothesen entwickeln, testen und die Ergebnisse bewerten. Die wissenschaftliche Methode ist auch bei der Fehlerbehebung effektiv.

Bis zum Ursprung des Problems fragen, indem Sie immer wieder die Frage 'Warum?' stellen. Oft ist das scheinbare Problem ein Symptom für ein anderes, zugrunde liegendes Problem.

Schrittweise Änderungen vornehmen

Anstatt gleichzeitig mehrere Änderungen vorzunehmen, machen Sie eine Änderung und beobachten Sie die Ergebnisse. Diese Herangehensweise hilft Ihnen, zu bestimmen, welche Änderung das Problem löste oder neue Probleme aufwarf.

Verwenden Sie ein Versionskontrollsystem wie Git, um jede Änderung zu protokollieren. So können Sie sich auf die vorherige funktionierende Version zurückfallen, wenn erforderlich.

Erläutern Sie Ihren Code

"Rubber Duck Debugging" ist eine Technik, bei der Sie Ihre Codezeilen (auch einem Spielzeugenten gegenüber) erläutern, um Ihren Denkprozess zu klären und logische Fehler zu identifizieren.

Lassen Sie einen anderen Programmierer Ihren Code überprüfen. Eine frische Sichtweise kann Probleme schnell erkennen, die Ihnen entgangen sind.

Effektive Protokollierung durchführen

Halten Sie umfassende und bedeutungsvolle Protokolle. Nicht nur Fehler, sondern auch wichtige Durchflusspunkte, Variablenwerte und Systemstatus sollten protokolliert werden. Eine gute Protokollierungsstrategie ermöglicht es Ihnen, Probleme schnell zu diagnostizieren.

Fügen Sie in Ihren Protokollnachrichten zeitstempel, Datei/Satzinformationen und Operation-IDs hinzu. Diese Informationen können sehr wertvoll sein, wenn komplexe Probleme gelöst werden.

Schreiben Sie Ihren Code modular

Schreiben Sie kleine, unabhängige und testbare Funktionen. Modulare Code erleichtert die Isolierung von Problemen und vereinfacht den Debugging-Prozess.

Eine Funktion sollte eine einzige Verantwortung haben. Zerlegen Sie Funktionen, die mehrere Aufgaben erfüllen, in kleinere, fokussierte Funktionen.

Führen Sie Vorprüfungen durch

Überprüfen Sie die Parameter und Eingabewerte in Ihren Funktionen vor der Verarbeitung. Die frühzeitige Erkennung unerwarteter Werte vereinfacht den Debugging-Prozess erheblich.

Verwenden Sie Type Hinting (PHP 7.0 und später). Diese Funktion generiert automatisch einen Fehler, wenn falsche Wertetypen gesendet werden.

Automatisierte Tests schreiben

Schreiben Sie Einheitstests und Integrationstests, um Ihr Code regelmäßig zu testen. Automatisierte Tests stellen sicher, dass die Funktionalität durch Änderungen nicht beeinträchtigt wird.

Verwenden Sie den Ansatz der Testgetriebenen Entwicklung (TDD): Schreiben Sie zuerst Tests und dann Code. Dieser Ansatz hilft Ihnen dabei, zuverlässigere und testbare Codes zu erzeugen.

Verwenden Sie die richtigen Werkzeuge

Nutzen Sie professionelle Entwicklungswerkzeuge wie Xdebug, PHPUnit, PHP CodeSniffer und PhpStorm. Sie beschleunigen das Finden und Beheben von Fehlern erheblich.

Lernen Sie die Debugging-Funktionen Ihres IDEs kennen. Breakpoints, Schritt-für-Schritt-Ausführung und Variablen-Tracking sind sehr wertvoll.

Der wichtigste Punkt, den Sie beachten sollten.

Fehlerbehebung ist ein natürlicher Teil des Softwareentwicklungsprozesses. Fehler sind keine Misserfolge, sondern Lern- und Verbesserungsmöglichkeiten. Mit einem systematischen Ansatz, den richtigen Werkzeugen und kontinuierlichem Üben können Sie Ihre Fähigkeiten zur Fehlerbehebung im Laufe der Zeit verbessern.

Top