• Das Erstellen neuer Accounts wurde ausgesetzt. Bei berechtigtem Interesse bitte Kontaktaufnahme über die üblichen Wege. Beste Grüße der Admin

OOP mit PHP ->

dogsnhumans.de

New member
OOP mit PHP -> Fragen...

Hallo :)

bevor ich jetzt weitermache, möchte ich gern wissen ob ich die OOP in PHP weit verfehlt, bzw. verstanden habe. :rolleyes:

PHP:
/* Die JSON Klasse lädt und speichert JSON Dateien */
class json_basic {
	
	protected $file;	        // Datei inkl. Pfad
	protected $str;		// JSON String
	protected $arr;		// Dekodiertes JSON Array
	protected $error;	        // Fehlerspeicher
	
	// Benötigt Datei inkl. Pfad
	// Für JSON Kodierung kann ein Array übergeben werden
	function __construct($json_file, $json_array = false) {
		$this->file = $json_file;
		if ($json_array) {
			$this->arr = $json_array;
		}
	}
	
	// Lädt JSON Datei in einen String
	protected function load() {
		$this->str = file_get_contents($this->file);
		if (!$this->str) {
			$this->error = $this->str;
		}
	}
	
	// Dekodiert die JSON Datei zu einem Array
	protected function decode() {
		$this->arr = json_decode($this->str, true);
		$this->error = json_last_error();
	}
	
	// Kodiert übergebenes Array in einen JSON String
	protected function encode() {
		$this->str = json_encode($this->arr);
		$this->error = json_last_error();
	}
	
	// Speichert den JSON String als Datei
	protected function save() {
		$this->error = file_put_contents($this->file, $this->str);
	}
	
}

// Erweitert die Klasse "json_basic" und gibt eventuelle Fehler zurück
class json_extend extends json_basic {

	public function get_json() {
		
	}
	
	public function put_json() {
	
	}
}

Die Erweiterungsklasse ist noch leer. Brauche ersteinmal ein Feedback ob man die Sache so angehen kann, da ich mit PHP noch nicht soviel zu tun hatte.

Fragen:
Alles in die Hauptklasse integrieren?
Den Konstruktor lieber in die Erweiterungsklasse integrieren?
 
Zuletzt bearbeitet:
Sorry, aber anhand des von dir geposteten Codes, wird dir niemand sagen können ob verstanden oder nicht...

Dafür müsste man viel mehr über deine Motivation und Gedankengänge wissen, die dem Code zugrunde liegen.

mfg
 
Man kann die Sache schon so angehen... ist alles eine Frage des persönlichen Geschmackst (ich würde z.B. nicht zwei verschiedene Klassen machen und auch nicht die Objekt- UND Stringrepräsentation der Daten im Objekt speichern, sondern nur eine von beiden).

Zu deinen beiden Fragen ein klares "das kommt darauf an" ;)
 
Ich möchte Informationen im JSON Format in verschiedenen Dateien abspeichern und bei Bedarf wieder auslesen. Mehr soll die Klasse nicht können *g*:

  • PHP Array in JSON umwandeln und als Datei abspeichern
  • JSON Datei auslesen und den String in ein PHP Array umwandeln
  • Fehler die dabei entstehen können abfangen

Hab schonmal weitergemacht:

PHP:
/* Die JSON Klasse lädt und speichert JSON Dateien */
class json_basic {
	
	protected $file;	// Datei inkl. Pfad
	protected $str;		// JSON String
	protected $arr;		// Dekodiertes JSON Array
	
	// Lädt JSON Datei in einen String
	protected function load() {
		$this->str = file_get_contents($this->file);
	}
	
	// Dekodiert die JSON Datei zu einem Array
	protected function decode() {
		$this->arr = json_decode($this->str, true);
	}
	
	// Kodiert übergebenes Array in einen JSON String
	protected function encode() {
		$this->str = json_encode($this->arr);
	}
	
	// Speichert den JSON String als Datei
	protected function save() {
		return file_put_contents($this->file, $this->str);
	}
	
}

// Erweitert die Klasse "json_extend" und gibt eventuelle Fehler zurück
class json_extend extends json_basic {
	
	public $check;	// Fehlerspeicher
	
	// Benötigt Datei inkl. Pfad
	// Für JSON Kodierung kann ein Array übergeben werden
	function __construct($json_file, $json_array = false) {
		$this->file 								= $json_file;
		$this->arr 									= $json_array;
		$this->check['json_extend']['is_array'] 		= is_array($json_array);
		$this->check['json_extend']['basename']		= basename($this->file);
		$this->check['json_extend']['file_exists'] 	= file_exists($this->file);
		$this->check['json_extend']['is_file'] 		= is_file($this->file);
		$this->check['json_extend']['is_readable'] 	= is_readable($this->file);
		$this->check['json_extend']['is_writable'] 	= is_writable($this->file);
		$this->check['json_extend']['decode']		= 4;
		$this->check['json_extend']['encode']		= 4;
	}

	public function get_json() {
		if($this->check['json_extend']['file_exists'] && $this->check['json_extend']['is_readable'] && $this->check['json_extend']['is_readable']) {
			$this->load();
			$this->decode();
			$this->check['json_extend']['decode'] = json_last_error();
		} else {
			return false;
		}
		if($this->check['json_extend']['decode'] == 0) {
			// Testzone
			var_dump($this->check['json_extend']['decode']);
			print '<br />';
			var_dump($this->arr);
			return $this->arr;
		} else {
			return false;
		}
	}
	
	public function put_json() {
		$this->encode();
		$this->check['json_extend']['encode'] = json_last_error();
		$this->save();
	}
	
}
// Testzone
$data = array("test1"=>1);
$test = new json_extend('data/home/content.json', $data);
$out = $test->get_json();
//var_dump($out);

Vll. wird es nun verständlicher was ich vorhabe!? :rolleyes: Für Tipps, Infos, etc. wäre ich dankbar.
 
Zuletzt bearbeitet:
Sodele,

nun hatte ich mal wieder etwas Zeit. Könnt ja mal drüber schauen, für Tipps wäre ich dankbar.

PHP:
class json {
	
	public $json_file;		// JSON Datei inkl. Pfadangabe
	public $json_str;		// JSON String
	public $json_arr;		// PHP Array aus JSON Daten
	public $json_check;		// Fehlerspeicher
	
	/* Konstruktor füllt die Eigenschaften.
	// Wenn ein Array als 2. Parameter übergeben wird,
	// kann eine JSON Datei abgespeichert werden. */
	function __construct($file, $arr = FALSE) {
		$this->json_file = $file;
		$this->json_arr = $arr;
		$this->json_check['json']['is_array'] 		= is_array($this->json_arr);
		$this->json_check['json']['basename']		= basename($this->json_file);
		$this->json_check['json']['file_exists'] 	= file_exists($this->json_file);
		$this->json_check['json']['is_file'] 		= is_file($this->json_file);
		$this->json_check['json']['is_readable'] 	= is_readable($this->json_file);
		$this->json_check['json']['is_writable'] 	= is_writable($this->json_file);
		$this->json_check['json']['decode']			= FALSE;
		$this->json_check['json']['encode']			= FALSE;
	}
	
	/* Lädt eine JSON Datei und gibt ein Array zurück.
	// Bei einem Fehler wird das Array $json_check zurückgegeben. */
	public function load() {
		if ($this->json_check['json']['file_exists'] && $this->json_check['json']['is_file'] && $this->json_check['json']['is_readable']) {
			$this->json_str = file_get_contents($this->json_file);
			$this->json_arr = json_decode($this->json_str, TRUE);
			$this->json_check['json']['decode'] = json_last_error();
		} else {
			return $this->json_check;
		}
		if ($this->json_check['json']['decode'] == 0) {
			return $this->arr;
		} else {
			return $this->json_check;
		}
	}
	
	/* Speichert ein Array als JSON Datei.
	// Bei einem Fehler wird das Array $json_check zurückgegeben. */
	public function save() {
		if ($this->json_check['json']['is_array'] && $this->json_check['json']['is_writable']) {
			$this->json_str = json_encode($this->json_arr);
			$this->json_check['json']['encode'] = json_last_error();
		} else {
			return $this->json_check;
		}
		if ($this->json_check['json']['encode'] == 0) {
			file_put_contents($this->json_file, $this->json_str);
		} else {
			return $this->json_check;
		}
	}
		
}

Habe mich nun doch entschlossen alles in einer Klasse zu schreiben, ohne Erweiterung.

Gruß
 
Zuletzt bearbeitet:
Was machst du, wenn zwischen dem Aufruf des Konstruktors und dem Aufruf der load- oder save-Funktion sich die Schreib-/Leserechte ändern?

Die ganzen Informationen im json_check sind auch nicht garantiert, dass sie immer korrekt sind, da ja alle Attribute public sind (und json_arr ändert sich ja auch mit jedem Aufruf von load).
 
Anstatt die Eigenschaften als Public zu deklarieren solltest du lieber Getter und Setter verwenden.

Lg Kasalop
 
Schreib und Leserechte werden sich nicht ändern, hoffe ich ^^. Getter und Setter, was ist das? Evlt. alle Eigenschaften auf private setzten?
 
Naja - "var" sollte man nicht mehr verwenden und Eigenschaten mit "var" sind "public"...

Ich finde da die magic methods __set und __get ja viel eleganter.
 
Ich finde da die magic methods __set und __get ja viel eleganter.

und langsamer... und unsauberer, da du ja die ganze logik des setztens in __set hauen musst oder du musst dann wieder in der klasse sauber implementierte private methoden für jedes property haben, dann kannste die aber auch einfach public setzten und dir __set sparen.
Dann musste beim ableiten aufpassen, weil die methode zwar übernommen wird, aber evtl auf nicht mehr vorhandene Propertys zugegriffen wird (weil private anstatt protected), etc etc etc

Auch die Unterstützung in der Entwicklungsumgebung ist in der Regel nicht möglich.

Ich würde zu typischen setter und gettern raten, sparst du dir (gerade wenn du dich nicht so gut auskennst) viel Ärger.

Lg Kasalop
 
Zuletzt bearbeitet:
Danke für die Hilfe und für die Links.

Die magischen Methoden __get(), __set() versteh ich ehrlich gesagt noch nicht.

Mit klassischem getter, setter ist das hier gemeint?
PHP:
class Kunde
{
	// Attribute
 
	private $kontostand;
	private $geheimzahl;
 
	// Methoden
	// Getter: Kontostand
	//...
 
	// Setter: Kontostand
	// ...
 
	// Getter: Geheimzahl
	// ...
 
	// Setter: Geheimzahl
	// ...
}
 
$schmitt = new Kunde;
 
// Kontostand verändern
$schmitt->setKontostand(1000);
 
// Kontostand ausgeben
$schmitt->getKontostand();
 
// Geheimzahl verändern
$schmitt->setGeheimzahl(1321);
 
// Geheimzahl überprüfen
$eingabeausBankingFormular = 1324; // auf 1321 ändern,
							// um funktionalität zu überprüfen
if ($schmitt->getGeheimzahl() == $eingabeausBankingFormular)
{
	echo "zugang gewährt!";
}
else
{
	echo "zugang verweigert";
}

Quelle: [informatikunterricht] - Getter und Setter (auf informatikZentrale.de)

Weil dann hätte ich schonmal das Prinzip verstanden :)
 
ja das sieht gut aus. Aber die Getter und Setter hast du ja nicht implementiert, aber kann man eigentlich nciht viel falsch machen ^^

Lg Kasalop
 
__get und __set sind für den Anfang auch nicht so wichtig - ich wollte sie nur erwähnt haben, weil man damit schöne Sachen machen kann (aber Kasalop hat Recht, dass sie nicht besonders schnell sind und gerne etwas unübersichtlich werden).
 
Okay nun habe ich es mit klassischen Gettern / Settern umgesetzt:

PHP:
class json {
	
	private $str;
	private $arr;
	private $check;
	
	public function setStr($str) {
		$this->str = $str;
	}
	
	public function getStr() {
		return $this->str;
	}
	
	public function setArr($arr) {
		$this->arr = $arr;
	}

	public function getArr() {
		return $this->arr;
	}
	
	public function setCheck() {
        $this->check['json']['decode'] = NULL;
        $this->check['json']['encode'] = NULL;
	}
	
	public function getCheck() {
		return $this->check;
	}
	
	public function decodeJSON() {
		$this->arr = json_decode($this->str);
		$this->check['json']['decode'] = json_last_error();
	}
	
	public function encodeJSON() {
		$this->str = json_encode($this->arr);
		$this->check['json']['encode'] = json_last_error();
	}
	
}

//JSON gültiger String
$json_string = '{"GetJSON Test 1":1,"GetJSON Test 2":2}';

//Array das in JSON String konvertiert wird
$arr_for_json = array('SetJSON Test 1' => 1, 'SetJSON Test 2' => 2);

//Klasse laden
$json_mgm = new json();
$json_mgm->setCheck();

//JSON String in Array umwandeln
$json_mgm->setStr($json_string);
$json_mgm->decodeJSON();
$check = $json_mgm->getCheck();
$data = $json_mgm->getArr();
echo '<p>JSON Check:</p>';
var_dump($check);
echo '<br /><p>get JSON Data:</p>';
var_dump($data);
echo '<br /><br />';

//Array in JSON String umwandeln
$json_mgm->setArr($arr_for_json);
$json_mgm->encodeJSON();
$check = $json_mgm->getCheck();
$string = $json_mgm->getStr();
echo '<p>JSON Check:</p>';
var_dump($check);
echo '<br /><p>set JSON String:</p>';
var_dump($string);

Die Methode "setCheck" könnte ich eigentlich weglassen oder? Bzw. das check Array vorab im __construct() mit NULL deklarieren?

Macht es Sinn für Dateien zu lesen und schreiben eine seperate Klasse zu machen? Deshalb habe ich das ersteinmal weggelassen.

Und kann man auch Kontrollstrukturen (if, elseif, case und so weiter) in den Methoden verwenden oder sollte man das lieber außerhalb der Klasse machen?

Besten Dank schonmal für die bisherige gute Hilfe.
 
Zuletzt bearbeitet:
das solltest du unbedingt nutzen ;)

1) setCheck() ist für mich kein aussagekräftiger name, daher weiß ich nicht ob du sie weglassen kannst :D
2) du kannst bei den Settern noch checks für die nicht typisierbaren Datentypen durchführen (zeig ich dir gleich noch)
3) wenn du mit der struktur klar kommst würde ich immer ein Objekt zurückgeben, wenn du sonst keine rückegabetyp hast. das verkürzt die codes meistens enorm (zeig ich auch gleich noch)

Hier mal die klasse von dir mit ein paar Änderungen (die sind kein muss, nicht falsch verstehen! du kannst das so machen, wie du es gemacht hast. nur ein paar hinweise wie ich es abgeändert hätte):
PHP:
<?php
    class json {
        private $_str;
        private $_arr;
        private $_check = array(); // Meiner Meinung nach sind das zwar errors und keine checks... aber ich lass mal deine var namen!
        
        public function __construct($argument=null) {
            // preset:
            $this->_check = array(
                'json' => array(
                    'decode' => null,
                    'encode' => null
                )
            );
            // $argument auswerten:
            if(isset($argument) && !is_null($argument)) {
                if(is_string($argument)) {
                    $this->_str = $argument;
                    $this->decodeJSON();
                }
                if(is_array($argument) || is_object($argument)) {
                    $this->_arr = $argument;
                    $this->encodeJSON();
                }
            }
        }
        
        public function setStr($str) {
            if(!is_string($str))
                throw new Exception('String Required.');
            $this->_str = $str;
            return $this;
        }
        
        public function getStr() {
            return $this->_str;
        }
        
        public function setArr($arr) {
            if(!is_array($arr))
                throw new Exception('Array Required.');
            $this->_arr = $arr;
            return $this;
        }
    
        public function getArr() {
            return $this->_arr;
        }
        
        public function getCheck() {
            return $this->_check;
        }
        
        public function decodeJSON() {
            $this->_arr = json_decode($this->_str);
            $this->_check['json']['decode'] = json_last_error();
            return $this;
        }
        
        public function encodeJSON() {
            $this->_str = json_encode($this->_arr);
            $this->_check['json']['encode'] = json_last_error();
            return $this;
        }
    }
    
    //JSON gültiger String
    $json_string = '{"GetJSON Test 1":1,"GetJSON Test 2":2}';
    
    //Array das in JSON String konvertiert wird
    $arr_for_json = array('SetJSON Test 1' => 1, 'SetJSON Test 2' => 2);
    
    //Klasse laden
    $json_mgm = new json();
    // $json_mgm->setCheck(); <<< braucht man nicht mehr. hast du ja schon festgestellt.
    
    //JSON String in Array umwandeln
    $json_mgm->setStr($json_string);
    $json_mgm->decodeJSON();
    // Alternativ würde nun auch das gehen:
    $json_mgm->setStr($json_string)->decodeJSON();
    // ---
    $check = $json_mgm->getCheck();
    $data = $json_mgm->getArr();
    echo '<p>JSON Check:</p>';
    var_dump($check);
    echo '<br /><p>get JSON Data:</p>';
    var_dump($data);
    echo '<br /><br />';
    
    //Array in JSON String umwandeln
    $json_mgm->setArr($arr_for_json);
    $json_mgm->encodeJSON();
    $check = $json_mgm->getCheck();
    $string = $json_mgm->getStr();
    echo '<p>JSON Check:</p>';
    var_dump($check);
    echo '<br /><p>set JSON String:</p>';
    var_dump($string); 
?>
Aber wofür überhaupt erst setzten und dann nochmal ne methode aufrufen? wieso nicht einfach so:
PHP:
<?php
    class json {
        private $_check = array(); // Meiner Meinung nach sind das zwar errors und keine checks... aber ich lass mal deine var namen!
        
        public function __construct() {
            // preset:
            $this->_check = array(
                'json' => array(
                    'decode' => null,
                    'encode' => null
                )
            );
        }
        
        public function getCheck() {
            return $this->_check;
        }
        
        public function decodeJSON($string) {
            $arr = json_decode($string);
            $this->_check['json']['decode'] = json_last_error();
            return $arr;
        }
        
        public function encodeJSON($objectOrArray) {
            $str = json_encode($objectOrArray);
            $this->_check['json']['encode'] = json_last_error();
            return $str;
        }
    }
    
    //JSON gültiger String
    $json_string = '{"GetJSON Test 1":1,"GetJSON Test 2":2}';
    
    //Array das in JSON String konvertiert wird
    $arr_for_json = array('SetJSON Test 1' => 1, 'SetJSON Test 2' => 2);
    
    //Klasse laden
    $json_mgm = new json();
    
    //JSON String in Array umwandeln
    echo "<p>Data:</p>".print_r($json_mgm->decodeJSON($json_string), true);
    // ---
    $check = $json_mgm->getCheck();
    echo '<p>JSON Check:</p>';
    var_dump($check);
    echo '<br /><br />';
    
    //Array in JSON String umwandeln
    echo "<p>Data: </p>".$json_mgm->encodeJSON($arr_for_json);
    $check = $json_mgm->getCheck();
    echo '<p>JSON Check:</p>';
    var_dump($check);
?>

Lg Kasalop
 
Ja vielen Dank, das Ihr mir einen Einblick in OOP mit PHP verschafft habt. :)

Die JSON Klasse sieht nun so aus:

PHP:
// Konvertiert Array zu JSON und umgekehrt
class json {
	
	private $_error;			// Speichert auftretene Fehler
	
	private function setError() {
		switch(json_last_error()) {
			case 0: $this->_error = FALSE;										break;
			case 1: $this->_error = 'Maximale Stacktiefe überschritten';		break;
			case 2: $this->_error = 'Ungültiges JSON-Dokument';					break;
			case 3: $this->_error = 'Unerwartetes Steuerzeichen gefunden';		break;
			case 4: $this->_error = 'Syntaxfehler, ungültiges JSON';			break;
			case 5: $this->_error = 'UTF-8 Fehler';								break;
		}
	}
	
	public function getError() {
		return $this->_error;
	}
	
	public function decodeJSON($str) {
		if(!is_string($str))
			throw new Exception('String Required.');
		$arr = json_decode($str, TRUE);
		$this->setError();
		return (!$this->_error) ? $arr : FALSE;
	}
	
	public function encodeJSON($objOrArr) {
		if(!is_array($objOrArr))
			throw new Exception('Array Required.');
		$str= json_encode($objOrArr);
		$this->setError();
		return (!$this->_error) ? $str : FALSE;
	}
	
}

//JSON String
$json_string = '{"decodeJSON Test 1":1,"decodeJSON Test 2":2}';
$json_string_err = '{"encodeJSON Test 1":1,"encodeJSON Test 2":2,}';

//Array das in JSON String konvertiert werden soll
$arr_for_json = array('SetJSON Test 1' => 1, 'SetJSON Test 2' => 2);
$iso_8859_1 = utf8_decode('Bla Bla Blä');
$arr_for_json_err = array('SetJSON Test 1' => $iso_8859_1, 'SetJSON Test 2' => 2);

//Klasse anwenden
$json_mgm = new json();
echo '<h3>Ohne Fehler</h3><b>Decode</b><br />';
$ergebnis = $json_mgm->decodeJSON($json_string);
echo '<b>Ergebnis: </b>';
echo var_dump($ergebnis).'<br />';
echo '<b>Fehler: </b>';
echo var_dump($json_mgm->getError()).'<br /><br />';

echo '<b>Encode</b><br />';
$ergebnis = $json_mgm->encodeJSON($arr_for_json);
echo '<b>Ergebnis: </b>';
echo var_dump($ergebnis).'<br />';
echo '<b>Fehler: </b>';
echo var_dump($json_mgm->getError());

echo '<h3>Mit Fehler</h3><b>Decode</b><br />';
$ergebnis = $json_mgm->decodeJSON($json_string_err);
echo '<b>Ergebnis: </b>';
echo var_dump($ergebnis).'<br />';
echo '<b>Fehler: </b>';
echo var_dump($json_mgm->getError()).'<br /><br />';

echo '<b>Encode</b><br />';
$ergebnis = $json_mgm->encodeJSON($arr_for_json_err);
echo '<b>Ergebnis: </b>';
echo var_dump($ergebnis).'<br />';
echo '<b>Fehler: </b>';
echo var_dump($json_mgm->getError());

"throw" und new Exception habe ich noch nie angewandt. Es stoppt aber in diesem Fall die Ausführung des Skriptes und gibt ausführliche Details aus. Find ich zur Fehlersuche super. :)

Grüße
 
So noch eine Klasse geschrieben *g*:

PHP:
// Lädt, speichert und löscht Dateien
class file {
	
	private $_file;		// Datei inkl. Verzeichniss
	private $_dir;		// Verzeichniss
	private $_error;	// Fehlerspeicher
	
	// Füllt die Eigenschaften
	private function setProperties($file) {
		$this->_file = $file;
		$this->_dir = dirname($file);
	}
	
	// Findet evtl. Fehler und setzt die Eigenschaft $_error
	private function setError($type) {
		$err = FALSE;
		switch ($type) {
			case 'readFile':
				if (!is_dir($this->_dir)) {
					$err = 'Verzeichnis existiert nicht.';
				} elseif (!file_exists($this->_file)) {
					$err = 'Datei existiert nicht.';
				} elseif (!is_file($this->_file)) {
					$err = 'Datei ist beschädigt.';
				} elseif (!is_readable($this->_file)) {
					$err = 'Datei ist nicht lesbar.';
				}
				break;
			case 'writeFile':
				if (!is_dir($this->_dir)) {
					$err = 'Verzeichnis existiert nicht.';
				}
				break;
			case 'deleteFile':
				if (!is_dir($this->_dir)) {
					$err = 'Verzeichnis existiert nicht.';
				} elseif (!file_exists($this->_file)) {
					$err = 'Datei existiert nicht.';
				} elseif (!is_file($this->_file)) {
					$err = 'Datei ist beschädigt.';
				} elseif (!is_writable($this->_file)) {
					$err = 'Datei ist nicht löschbar.';
				}
				break;
			default:
				$err = 'Variable $type wurde nicht ordnungsgemäß an die Funktion setError() übertragen.';
		}
		$this->_error = $err;
	}
	
	// Gibt evtl. gefundene Fehler aus
	public function getError() {
		return $this->_error;
	}
	
	// Liest eine Datei
	public function readFile($file) {
		$this->setProperties($file);
		$this->setError('readFile');
		return (!$this->_error) ? file_get_contents($file) : FALSE;
	}
	
	// Schreibt eine Datei
	public function writeFile($file, $data) {
		$this->setProperties($file);
		$this->setError('writeFile');
		return (!$this->_error) ? file_put_contents($file, $data) : FALSE;
	}
	
	// Löscht eine Datei
	public function deleteFile($file) {
		$this->setProperties($file);
		$this->setError('deleteFile');
		return (!$this->_error) ? unlink($file) : FALSE;
	}
	
}

Wenn ich es recht verstehe, werden unter PHP mit Standardeinstellungen, Dateien mit CHMOD 0666 und Verzeichnisse mit CHMOD 0777 angelegt. Das würde mir auch erstmal völlig ausreichen. Bzw. welche Aspekte sollte ich noch berücksichtigen?

Könnt Ihr nocheinmal einen Blick drüber werfen? Evtl. habe ich etwas wichtiges nicht berücksichtigt oder irgendwas grob falsch gemacht.
 
Zurück
Oben