Um einen Sauberen Code zu schreiben, reicht es nicht, nur die Syntax zu verstehen. Wichtig ist auch, dass man den Code so schreibt, dass eine anderer Programmierer ihn auch lesen und verstehen kann. Dazu kann ich folgende Tipps geben:

Wichtig sind auch folgende Sachen:

 
 Code > Comments
 
 Code = how
 Tests = what
 Comment = why
 

Es ist wichtig, zum Verständnis im Code gewisse Kommentare anzulegen. In PHP gibt es die Möglichkeit DocBlocks zu schreiben. Diese Möglichkeit sollte man nutzen.

Mit DRY ist gemeint, dass man Redundanzen vermeiden soll. Also ein mehrfach vorkommendes Codesegement in eine Funktion schreiben. Ebenso sollte man auf „Copy & Paste“ verzichten.
(Wikipedia: DRY)

In seiner Grundaussage ähnelt das KISS-Prinzip stark der Aussage von Ockhams Rasiermesser: wenn es mehrere Erklärungen für einen bestimmten Sachverhalt gibt, dann ist diejenige Erklärung zu bevorzugen, die am einfachsten ist, also mit den wenigsten Annahmen und Variablen auskommt.
(Quelle: Wikipedia)

Dieses Prinzip ist für Funktionen. Wichtig ist hier, dass man so früh wie möglich einen return macht. Wenn also eine Funktion prüft, ob eine Telefonnummer mehr als 3 und weniger als 50 Zeichen het und der geprüfte Wert 2 Zeichen lang ist, muss man nicht noch prüfen, ob die Telefonnummer kürzer als 50 Zeichen ist. Also kann man nach der (negativ) erfolgten Prüfung bereits Falsch zurückmelden. Ein Beispiel für eine solche Funktion(PHP):

 // richtig:
 function validate_phonenumber($phonenumber)
 {
    $lenght = count($phonenumber);
    if ($lenght < 3) {
       return false;
    }
    if ($lenght > 50) {
       return false
    }
    return true;
 }                                                   
 ________________________________________________________
 
 // falsch (bad practice)
 function validate_phonenumber($phonenumber)
 {
   $lenght = count($phonenumber);
   if ($lenght > 3) {
     if ($lenght < 50) {
       $result = true;
     } else {
       $result = false;
     }
   } else {
     $result = false;
   }
   return $result;
  }

Die Zyklomatische Komplexität ist ein Wert, welcher beschreibt, wie viele Pfade (verschiedene Durchläufe) möglich sind bei einem Programm. Je höher dieser Wert ist, desto fehleranfälliger ist das Programm. Laut dem Johner Institut / Prof. Dr. Christian Johner kann man die Skala wie folgt definieren:

1-10: Nicht komplex, geringes Fehlerrisiko
11-20: Mittlere Komplexität, moderates Fehlerrisiko
21-50: Hohe Komplexität, hone Wahrscheinlichkeit eines Fehlers
> 50: Untestbares System, sehr hohe Wahrscheinlichkeit eines Fehlers

Bei einem Programm, welches 7 Prüfungen hat (und einen Endpunkt), das wie folgt konstruiert ist, kann man 5 unabhängige Pfade Zählen:

1. 2, 7
2. 1, 4, 6, 9, 10
3. 1, 4, 6, 9, 8, 9, 10
4. 1, 3, 5, 9, 8, 9, 10
5. 1, 3, 5, 9, 10

Diese Pfade muss man dann auf Fehler testen, um die Fehleranfälligkeit so niedrig (oder am besten keine) zu halten.
Um seien PHP-Code auf die Zyklomatische Komplexität zu testen, kann man Scrudinizer CI anwenden. Dazu stellt man sein Projekt OpenSource auf GitHub und folgt den Anweisungen auf der Webseite von Scrudinizer CI.

Viele Projekte werden meistens nicht nur von einer Person betreut. Deshalb ist es wichtig, dass der programmierte Code auch für andere Personen lesbar ist. Ein schlechtes Beispiel (Java):

import java.util.Scanner;class test{public static void main(String [] args){Scanner s=new
Scanner(System.in);int input, output;System.out.print("please enter a number");input=s.nextInt();
output=input+2;System.out.print("your number + 2 is: "+output);}}

Das obenstehende Beispiel fordert einem auf eine Zahl einzugeben und gibt danach die eingegebene Zahl + 2 aus. Für den Programmierer dieses Programmes ist der Code sicher leicht zu verstehen, jedoch für andere nicht. Der gleiche Code, jedoch sauber formatiert, sieh dann so aus:

 import java.util.Scanner;\\
 class test {
         public static void main(String [] args){
              Scanner s = new Scanner(System.in);
              int input, output;
              System.out.print("please enter a number");
              input = s.nextInt();
              output = input+2;System.out.print("your number + 2 is: "+output);
        }
  }

Beide Programme machen genau das Gleiche (ohne Fehler). Jedoch ist die Weiterentwicklung des ersten Programmes einiges schwieriger als die des Zweiten.
Ein schlechtes Beispiel (PHP):

if($_POST){$default=[];$default['username']='';$default['password']='';$data=[];$data=array_replace_recursive
($default,$_POST);$user='root';$pass='';$dbh=new PDO('mysql:host=localhost,
dbname=test',$user,$pass);$stmt=$pdo->prepare("SELECT * FROM users WHERE user =
$data['username]");$rows=$stmt->execute;foreach($rows as $row){$data['table']=$row}if($data['table']
['username']==$data['username']&&$data['table']['password']==$data['password']){header("Location:
loggedin.php");}else{echo "invalid user credentials"};}

Der gleiche Code, jedoch sauber formatiert (PSR 2):

if($_POST){
    $default = [];
    $default['username'] = '';
    $default['password'] = '';
    $data = [];
    $data = array_replace_recursive($default,$_POST);
    $user = 'root';
    $pass = '';
    $dbh = new PDO('mysql:host=localhost, dbname=test',$user,$pass);
    $stmt=$pdo->prepare("SELECT * FROM users WHERE user = $data['username]");
    $rows=$stmt->execute;
    foreach($rows as $row){
        $data['table'] = $row
    }
    if($data['table']['username'] == $data['username'] && $data['table']['password'] == $data['password']){
        header("Location: loggedin.php");
    } else {
        echo "invalid user credentials"
    }
}

Dieser Code ist genau richtig formatiert nach dem PSR-2 Standard. Jedoch ist es empfehlenswert auch ab und zu mal einen Zeilenumbruch einzubauen („Das Auge programmiert mit“):

if($_POST){
    $default = [];
    $default['username'] = '';
    $default['password'] = '';
    
    $data = [];
    $data = array_replace_recursive($default,$_POST);
    
    $user = 'root';
    $pass = '';
    $dbh = new PDO('mysql:host=localhost, dbname=test',$user,$pass);
    $stmt=$pdo->prepare("SELECT * FROM users WHERE user = $data['username]");
    $rows=$stmt->execute;
    
    foreach($rows as $row){
        $data['table'] = $row
    }
    
    if($data['table']['username'] == $data['username'] && $data['table']['password'] == $data['password']){
        header("Location: loggedin.php");
    } else {
        echo "invalid user credentials"
    }
}

Dieses Beispiel ist perfekt. Man hat sauberen Code (wie sinnvoll dieser ist, sei mal so dahingestellt). Wenn man sich nicht die Mühe machen will, jedes Mal vor einem Push auf GitHub den ganzen Code durchzulesen, dann kann ich StyleCI empfehlen. Diese Webseite prüft (bei korrekter konfiguration), ob der Code dem gewünschten Standard enspricht (PSR 1, 2, etc).

Cloaking wird das Spammen von Suchmaschinen genannt. Man platziert unsichtbare Tags innerhalb seiner Webseite und hofft so auf ein besseres Ranking durch Suchmaschinen. Das wird heutzutage sehr hart bestraft (die Webseite landet auf der letzten Seite von Google).