Mime-Typ - (mime.class.php)

new mime() - Object

$string code = null Dateierweiterung bzw. Kurzcode in Kleinbuchstaben (z. B. 'jpg', 'html', 'json')
$string media = null Medien-Hauptgruppe (z. B. 'image', 'text', 'video', 'audio')
$string contentType = null offizieller Content-Type aus der XML-Definition (z. B. 'image/jpeg')
$string contentTypeApache = null Apache-spezifischer Content-Type aus /etc/mime.types
$string class = null zugeordnete Handler-Klasse zur Verarbeitung (z. B. '\mime\lib\html'); ansonsten null
$object charset = null verknüpftes Zeichensatz-Objekt als new charset(); über __set modifizierbar
$bool parse = true gibt an, ob Dateien dieses MIME-Typs durch den Template-Parser interpretiert werden sollen
$bool isDefault = false gibt an, ob auf den konfigurierten Standard-MIME-Typ (mime.default) zurückgegriffen wurde
$bool isMime = false gibt an, ob der MIME-Typ erfolgreich und gültig aufgelöst wurde
$float weight = 1.0 Qualitätsfaktor (q-Wert zwischen 0.0 und 1.0) für HTTP Content-Negotiation; über __set modifizierbar
__construct ([$mixed $context = null[, $bool $search = false]])
$context optional; Dateiendung (z. B. 'jpg'), MIME-Typ (z. B. 'image/jpeg'), HTTP-Accept-Header (z. B. 'text/html; charset=UTF-8', 'application/xml;q=0.9'), bestehende mime-Instanz oder null; default ist null
$search optional; aktiviert bei ungenauer Eingabe eine unscharfe Fuzzy-Suche; default ist false
erstellt eine neue mime-Instanz und löst Dateiendung, Content-Type, Zeichensatz und Qualitätsfaktor dynamisch auf
$mime = new mime('jpg');
$mime = new mime('image/jpeg');
$mime = new mime('application/xml;q=0.9');
$mime = new mime('text/html; charset=UTF-8');
$fuzzy = new mime('imagebmp', true); // Fuzzy-Suche
$clone = new mime($mime); // Kopiert bestehende Instanz
__get ($string $name)
$name Name der abzufragenden Eigenschaft (code, media, contentType, contentTypeApache, class, charset, parse, isDefault, isMime, weight); Pflicht
schreibgeschützter Zugriff auf die internen Eigenschaften; bei ungültiger Eigenschaft wird ein Fehler protokolliert und null zurückgegeben
$mime = new mime('jpg');
echo $mime->code; // 'jpg'
echo $mime->contentType; // 'image/jpeg'
echo $mime->media; // 'image'
__set ($string $name, $mixed $val)
$name Name der zu modifizierenden Eigenschaft (nur charset und weight sind schreibbar); Pflicht
$val neuer Wert (für charset: Name oder new charset(); für weight: Zahl zwischen 0.0 und 1.0); Pflicht
erlaubt das kontrollierte Ändern von charset und weight; alle anderen Eigenschaften sind schreibgeschützt und geben false zurück
$mime = new mime('html');
$mime->charset = 'UTF-8';
$mime->weight = 0.8;
$mime->code = 'png'; // Schreibgeschützt! Wird ignoriert (Rückgabe: false)
__toString ()
gibt den vollständigen HTTP Content-Type-String inklusive Qualitätsfaktor (;q=... bei Werten unter 1.0) und Zeichensatz (;charset=...) zurück
$mime = new mime('jpg');
echo $mime; // 'image/jpeg'

$custom = new mime('text/html;q=0.8;charset=UTF-8');
echo $custom; // 'text/html;q=0.8;charset=UTF-8'
__invoke ()
ermöglicht den direkten Aufruf des Objekts als Funktion ($mime()); gibt den formatierten Content-Type-String direkt per echo aus und liefert true zurück
$mime = new mime('json');
$mime(); // Direkte Ausgabe: application/json
__debugInfo ()
liefert ein assoziatives array aller relevanten Objekteigenschaften zur sauberen Debug-Darstellung in var_dump() oder print_r()
$mime = new mime('png');
var_dump($mime);

Überprüfung

static mime::isMime ([$mixed $item = null])
$item optional; zu prüfende Variable oder Objekt; default ist null
prüft, ob das übergebene Element eine gültige Instanz von new mime() ist und erfolgreich aufgelöst wurde ($item->isMime === true); gibt true zurück, andernfalls false
$obj = new mime('jpg');
mime::isMime($obj); // true
mime::isMime('jpg'); // false (reiner String, keine Instanz)
static mime::isMimeCode ([$mixed $code = null[, $bool $caseSensitive = false]])
$code optional; Dateiendung bzw. MIME-Code (z. B. 'html', 'jpg'); default ist null
$caseSensitive optional; bei true wird Groß- und Kleinschreibung beachtet; default ist false
prüft, ob die Dateiendung in der zentralen XML-MIME-Definitionsliste existiert; gibt true zurück, andernfalls false
mime::isMimeCode('html'); // true
mime::isMimeCode('HTML'); // true (case-insensitive)
mime::isMimeCode('HTML', true); // false (in der Liste kleingeschrieben)
mime::isMimeCode('xyz'); // false
static mime::isMimeCodeArray ([$array $codeArray = null[, $bool $caseSensitive = false]])
$codeArray optional; numerisch indiziertes array mit Dateiendungen; default ist null
$caseSensitive optional; bei true wird Groß- und Kleinschreibung beachtet; default ist false
prüft, ob alle Elemente des übergebenen Arrays gültige MIME-Codes sind; gibt true zurück wenn alle gültig sind, andernfalls false
mime::isMimeCodeArray(['jpg', 'png', 'gif']); // true
mime::isMimeCodeArray(['jpg', 'unbekannt']); // false
static mime::compare ($object $first, $object $second[, $bool $checkWeight = false])
$first erste new mime()-Instanz; Pflicht
$second zweite new mime()-Instanz; Pflicht
$checkWeight optional; bei true muss auch der Qualitätsfaktor (weight) übereinstimmen; default ist false
vergleicht zwei new mime()-Objekte auf Übereinstimmung ihres MIME-Codes (und optional des Qualitätsfaktors); gibt true zurück wenn gleich, andernfalls false
$a = new mime('jpg');
$b = new mime('image/jpeg');
mime::compare($a, $b); // true (beide lösen zu 'jpg' auf)

Header & Parsing

static mime::parseString ([$string $header = null])
$header optional; zu parsender MIME-String oder HTTP-Header-Wert (z. B. 'text/html; charset=UTF-8; q=0.7'); default ist null
parst einen Header- oder MIME-String und extrahiert den bereinigten MIME-Code, den Zeichensatz und den Qualitätsfaktor; gibt ein assoziatives array im Format ['mime' => ?string, 'charset' => ?string, 'weight' => ?float] zurück
mime::parseString('text/html; charset=UTF-8; q=0.8');
// Rückgabe: ['mime' => 'html', 'charset' => 'UTF-8', 'weight' => 0.8]

Informationsausgabe

static mime::getDefault ()
liefert den konfigurierten Standard-MIME-Code (Fallback) aus config::get('mime.default') oder 'txt' als string zurück
mime::getDefault(); // 'txt'
static mime::detect ([$string $content = null])
$content optional; Text- oder Binärinhalt der Datei; default ist null
erkennt den MIME-Typ anhand des Inhalts über finfo (Erweiterungs- und MIME-Type-Prüfung mit manuellem Fallback-Mapping und Fuzzy-Suche); gibt eine neue new mime()-Instanz zurück
$mime = mime::detect('<html><body>Hallo Welt</body></html>');
echo $mime->code; // 'html'
static mime::getParse ([$mixed $context = null])
$context optional; Dateiendung oder new mime()-Objekt; default ist null
prüft, ob Dateien dieses Typs durch den Template-Parser interpretiert werden müssen (z. B. false bei Bildern, true bei HTML/PHP/Text); gibt true oder false zurück
mime::getParse('jpg'); // false (Binärdaten werden nicht geparst)
mime::getParse('html'); // true
static mime::getContentType ([$mixed $context = null])
$context optional; Dateiendung oder new mime()-Objekt; default ist null
liefert den offiziellen Content-Type aus der XML-Definitionsdatei für den angegebenen Typ als string zurück; im Fehlerfall null
mime::getContentType('jpg'); // 'image/jpeg'
mime::getContentType('json'); // 'application/json'
static mime::getContentTypeApache ([$mixed $context = null])
$context optional; Dateiendung oder new mime()-Objekt; default ist null
liefert den Apache-spezifischen Content-Type aus /etc/mime.types als string zurück; im Fehlerfall null
mime::getContentTypeApache('jpg'); // 'image/jpeg'
static mime::getClass ([$mixed $context = null])
$context optional; Dateiendung oder new mime()-Objekt; default ist null
ermittelt die zuständige Handler-Klasse aus \mime\lib\{code} anhand der Klassenkonstante MIME_CONTAINER; speichert das Ergebnis für 15 Tage im Konfigurations-Cache und gibt den vollqualifizierten Klassennamen als string zurück; ansonsten null
mime::getClass('html'); // '\mime\lib\html'
mime::getClass('php'); // '\mime\lib\html'

Suche

static mime::searchContentType ([$string $media = null[, $string $subType = null]])
$media optional; Hauptgruppe als Suchbegriff (z. B. 'image', 'application'); default ist null
$subType optional; Subtyp als Suchbegriff (z. B. 'jpeg', 'json'); default ist null
sucht hierarchisch nach dem passenden MIME-Code anhand von Hauptgruppe und Subtyp unter Verwendung einer unscharfen Suche; gibt die gefundene Dateiendung als string zurück; im Fehlerfall null
mime::searchContentType('application', 'json'); // 'json'
mime::searchContentType('aplication', 'jsn'); // 'json' (Toleranz bei Tippfehlern)

Listen & Definitionen

static mime::getMimeList ()
lädt und validiert die zentrale XML-MIME-Definitionsdatei, sortiert nach Priorität (order) und Dateiendung und gibt ein assoziatives array aller MIME-Definitionen zurück; im Fehlerfall null
$list = mime::getMimeList();
// [
// 'jpg' => ['mime' => 'image/jpeg', 'parse' => false, 'media' => 'image', 'order' => 10],
// 'html' => ['mime' => 'text/html', 'parse' => true, 'media' => 'text', 'order' => null],
// ...
// ]
static mime::getMimeListApache ()
liest die Apache-MIME-Konfigurationsdatei (/etc/mime.types) ein und gibt die Zuordnungen als assoziatives array mit Dateiendungen und Content-Typen zurück; im Fehlerfall null
$apache = mime::getMimeListApache();
// ['jpg' => ['image/jpeg'], 'iso' => ['application/octet-stream', 'application/x-iso9660-image'], ...]
static mime::getContentTypeList ()
erstellt eine zweistufige Zuordnungsmatrix im Format [media => [subtyp => code]] für strukturierte Suchen; im Fehlerfall null
$matrix = mime::getContentTypeList();
// ['image' => ['jpeg' => 'jpg', 'png' => 'png'], 'application' => ['json' => 'json'], ...]