Navigation
 Startseite
 Fachbücher
 Anzeigenmarkt
 Forum
 Webmaster News
 Script Newsletter
 Push Meldungen
 Kontakt
 Script Installation
 Php
 Php Tutorials
 Lernpfade
 Webhoster Vergleich
 Impressum

Community-Bereich
 kostenlos Registrieren
 Anmelden
 Benutzerliste

Script Datenbank
 Script Archiv
 Script Top 20
 Screenshots
 Testberichte

Suche
 

Unsere Php Scripts
 Counter Script
 Umfrage Script
 Bilder Upload Script
 Terminverwaltung
 Simple PHP Forum
 RSS Grabber

Tools und Generatoren
 .htpasswd Generator
 md5 Generator
 base64 Generator
 Markdown to HTML
 Colorpicker
 Unix timestamp Tool
 Unit Test Generator
 TLD Liste
 Webkatalog‑Verzeichnis

Hosterplus.de
Bekommen Sie Speicherplatz (Webspace), Domains...
https://www.Hosterplus.de
Artfiles.de
Bietet Serviceorientierte...
https://www.Artfiles.de
 
 
 

PHP mb_ucfirst() Function: ucfirst für Multibyte ab PHP 8.4

Sie befinden sich: Home > Php Tutorial > PHP mb_ucfirst() Function: ...

PHP mb_ucfirst() Function: ucfirst für Multibyte ab PHP 8.4
Veröffentlicht am:
16.11.2026
Hits / Besucher:
10
Sprache:
  Deutsch
Tutorial Art:
eigenes
Eingetragen von:
Merkliste:
 
Beschreibung

Im Shop eines Hofladens stehen die Produktnamen klein in der Datenbank und werden mit ucfirst() ausgegeben. Aus „birnen vom Bodensee“ wird sauber „Birnen vom Bodensee“, nur „äpfel aus dem Alten Land“ bleibt klein. Warum ucfirst() an Umlauten scheitert, erklärt das Tutorial zu ucfirst(), welche mb-Funktionen PHP insgesamt mitbringt, das Tutorial zu Multibyte-Strings. Hier geht es um PHP mb_ucfirst() und das Gegenstück mb_lcfirst(), die seit PHP 8.4 eingebaut sind: was sie wirklich ändern, warum sie Titlecase statt Großbuchstaben liefern und welche Fehler beim Nachrüsten und beim Update auf PHP 8.4 auftreten.

Illustration zum Tutorial: PHP mb_ucfirst() Function: ucfirst für Multibyte ab PHP 8.4

Gemessen wurde unter Windows und Linux mit PHP 8.4. Die Polyfills liefen zusätzlich unter PHP 8.1 bis 8.3, die Fehlerfälle, die Titlecase-Proben und das Praxisbeispiel auch unter PHP 8.5.

Was PHP mb_ucfirst() und mb_lcfirst() bei Multibyte-Zeichen wirklich ändern

PHP mb_ucfirst() nimmt das erste Zeichen eines Strings, schreibt es groß und hängt den Rest unverändert wieder an. mb_lcfirst() macht dasselbe in die andere Richtung. Beide zählen Zeichen statt Bytes und erkennen deshalb Umlaute, die in UTF-8 aus zwei Bytes bestehen:

<?php

echo ucfirst('über'), PHP_EOL; /* über */
echo mb_ucfirst('über'), PHP_EOL; /* Über */
echo mb_lcfirst('Äpfel'), PHP_EOL; /* äpfel */
echo mb_ucfirst('äPFEL'); /* ÄPFEL */

Der Rest bleibt, wie er ist: Aus äPFEL wird ÄPFEL und nicht Äpfel. Und gemeint ist wirklich das erste Zeichen, nicht der erste Buchstabe. Steht davor ein Leerzeichen oder ein Anführungszeichen, passiert gar nichts. Für beides gibt es unten einen eigenen Abschnitt. mb_lcfirst() arbeitet spiegelbildlich, aus ÜBER wird üBER und aus dem großen Eszett ẞ am Anfang ein kleines ß.

Welcher Weg zum großen Anfangsbuchstaben passt, hängt von der PHP-Version und vom Rest des Strings ab:

flowchart TD
    A[Anfang groß] --> B{PHP 8.4 oder neuer?}
    B -->|ja| C[mb_ucfirst eingebaut]
    B -->|nein| D[Polyfill mit Prüfung]
    D --> E[MB_CASE_TITLE auf Zeichen 1]
    C --> F{Was passiert mit dem Rest?}
    E --> F
    F -->|bleibt| G[fertig]
    F -->|Name in Versalien| H[erst mb_strtolower]
    F -->|jedes Wort| I[mb_convert_case TITLE]

Die Signatur im Original

PHP mb_ucfirst() und mb_lcfirst() haben dieselbe Form:

mb_ucfirst(

string $string,
?string $encoding = null
): string
mb_lcfirst(
string $string,
?string $encoding = null
): string

/* string - the input string
encoding - the character encoding; null
means mb_internal_encoding(),
usually utf-8
return - the resulting string. The
mb_ucfirst function converts the
first character to title case,
which is the upper case for most
letters; mb_lcfirst converts it
to lowercase. All other
characters stay unchanged.
New in php 8.4. The php rfc starts with:
"PHP does not have a multibyte equivalent
of ucfirst, lcfirst functions". Case
mapping uses unicode properties, not
locale settings. Rules of single
languages like Turkish or Dutch are not
applied. A userland function with the
same name breaks (backward incompatible
change). */

Ohne zweiten Parameter gilt die interne Kodierung aus mb_internal_encoding(), in allen getesteten Installationen UTF-8. Ein unbekannter Name wirft ValueError: mb_ucfirst(): Argument #2 ($encoding) must be a valid encoding, "UTF8X" given. Einen Fehlerwert wie false kennt PHP mb_ucfirst() nicht. Wer null als String übergibt, bekommt unter PHP 8.4 die Meldung Passing null to parameter #1 ($string) of type string is deprecated und einen leeren String zurück.

Call to undefined function: PHP mb_ucfirst() vor 8.4 nachrüsten

Ein Rezeptblog läuft auf einem Hosting mit PHP 8.3. Der Betreiber übernimmt ein Snippet aus einem englischen Blog, und die Seite bricht ab:

<?php

echo mb_ucfirst('über');
/* PHP 8.3: Fatal error: Uncaught Error:
Call to undefined function mb_ucfirst() */

Unter PHP 8.1, 8.2 und 8.3 kam genau diese Meldung, unter 8.4 erscheint Über. PHP mb_ucfirst() gibt es erst seit Version 8.4, eingeführt über einen RFC, der mit 15 zu 0 Stimmen angenommen wurde. Wer noch nicht umstellen kann, rüstet sie mit einem Polyfill nach. Entscheidend ist die Prüfung mit function_exists(), die den Ersatz nur dort definiert, wo die Funktion fehlt:

<?php

if (!function_exists('mb_ucfirst')) {
function mb_ucfirst(
?string $string,
?string $encoding = null
): string {
$string ??= '';
$encoding ??= mb_internal_encoding();
$erstes = mb_substr($string, 0, 1, $encoding);
$rest = mb_substr($string, 1, null, $encoding);
return mb_convert_case(
$erstes,
MB_CASE_TITLE,
$encoding
) . $rest;
}
}
if (!function_exists('mb_lcfirst')) {
function mb_lcfirst(
?string $string,
?string $encoding = null
): string {
$string ??= '';
$encoding ??= mb_internal_encoding();
$erstes = mb_substr($string, 0, 1, $encoding);
$rest = mb_substr($string, 1, null, $encoding);
return mb_strtolower($erstes, $encoding)
. $rest;
}
}
echo mb_ucfirst('über'), ' ', mb_lcfirst('Äpfel');
/* Über äpfel */

Unter PHP 8.1, 8.2 und 8.3 greift der Ersatz, unter 8.4 tritt er von selbst zurück. Reflection zeigt, welche Fassung gerade läuft:

<?php

$r = new ReflectionFunction('mb_ucfirst');
var_dump($r->isInternal());
/* PHP 8.3 mit Polyfill: bool(false)
PHP 8.4: bool(true) */

Die Parameter heißen bewusst $string und $encoding wie im Original. Ein Polyfill mit $str funktioniert, bis jemand benannte Argumente benutzt: mb_ucfirst(string: 'über') endete unter PHP 8.3 mit Uncaught Error: Unknown named parameter $string, unter 8.4 lief derselbe Aufruf. Auch das ?string beim ersten Parameter ist Absicht. Mit string $string endete ein null aus einer leeren Datenbankspalte unter PHP 8.1 bis 8.3 mit TypeError: mb_ucfirst(): Argument #1 ($string) must be of type string, null given, während die eingebaute Funktion ab 8.4 nur eine Deprecation meldet und einen leeren String liefert. Mit $string ??= '' gibt der Polyfill ebenfalls einen leeren String zurück. Wer Composer verwendet, bekommt einen fertigen Ersatz mit dem Paket symfony/polyfill-php84, das ebenfalls über MB_CASE_TITLE arbeitet. Sobald alle Server mit PHP 8.4 laufen, kann der Polyfill weg, und ein Eintrag "php": ">=8.4" in der composer.json hält fest, dass ältere Versionen nicht mehr unterstützt werden.

Langsamer als das eingebaute PHP mb_ucfirst() ist der Polyfill auch, aber nicht spürbar. Eine Million Aufrufe dauerten in mehreren Läufen unter Linux mit PHP 8.4 eingebaut rund 100 bis 180 Millisekunden, mit dem Code des Polyfills rund 170 bis 290, also etwa anderthalbmal so lange. Bei ein paar tausend Seitentiteln spielt das keine Rolle.

Weiße Seite nach dem Update: Cannot redeclare function

Eine Agentur betreut Kundenseiten, in deren functions.php seit Jahren eine selbst geschriebene Hilfsfunktion namens mb_ucfirst() steht. Solche Hilfsfunktionen stehen bis heute in Anleitungen und Forenbeiträgen, oft ohne Prüfung, ob es die Funktion schon gibt. Der Hoster stellt auf PHP 8.4 um, und die Startseite bleibt weiß:

<?php

echo 'Start';

function mb_ucfirst($string) {
$first = mb_strtoupper(mb_substr($string, 0, 1));
return $first . mb_substr($string, 1);
}
/* PHP 8.4: Fatal error: Cannot redeclare
function mb_ucfirst() ... on line 4
"Start" erscheint nicht */

Nicht einmal das Start aus der ersten Anweisung kommt an. PHP bricht schon beim Übersetzen der Datei ab, bevor irgendetwas ausgeführt wird. Unter PHP 8.5 folgt zusätzlich ein Stack trace, unter 8.3 läuft derselbe Code ohne Fehler. Der RFC zur Funktion hat diesen Fall vorhergesagt. Unter der Überschrift „Backward Incompatible Changes“, also Änderungen, die bestehenden Code brechen können, steht: „This could break a function existing in userland with the same name.“ Gemeint ist jede selbst geschriebene Funktion gleichen Namens im globalen Namensraum.

Die schnellste Reparatur ist die Prüfung mit function_exists() aus dem vorigen Abschnitt oder das Löschen der Altfunktion. Wer eine eigene Variante behalten will, etwa mit eingebautem trim(), legt sie in einen eigenen Namensraum. Dort darf sie sogar gleich heißen:

<?php

namespace App\Text;

function mb_ucfirst(string $s): string
{
return \mb_ucfirst(\trim($s));
}

echo mb_ucfirst(' über'); /* Über */

Der Aufruf ohne Backslash findet im Namensraum App\Text zuerst die eigene Funktion, die mit vorangestelltem Backslash die eingebaute. Vorbeugen lässt sich vor jedem Versionssprung mit einem Syntaxtest der neuen Version. php -l unter PHP 8.4 meldete für die Datei oben Cannot redeclare function mb_ucfirst() und Errors parsing, unter 8.3 dagegen No syntax errors detected. Wer alle Projektdateien so prüft, findet die Altlast, bevor der Hoster umstellt.

Titlecase statt Großbuchstabe: warum der alte Polyfill falsch liegt

Eine Bibliothek für Seitentitel läuft auf dem Entwicklungsrechner mit PHP 8.3 und einem Polyfill, der das erste Zeichen mit mb_strtoupper() großschreibt, genau wie die Hilfsfunktion im vorigen Abschnitt. In Produktion läuft PHP 8.4 mit der eingebauten Funktion PHP mb_ucfirst(). Die Tests mit deutschen Wörtern sind grün, und trotzdem liefern beide Umgebungen nicht dasselbe:

<?php

$wort = 'džungla';
echo mb_ucfirst($wort), PHP_EOL;
/* Džungla: Titlecase, U+01C5 */
$erstes = mb_substr($wort, 0, 1);
echo mb_strtoupper($erstes);
/* DŽ: Großbuchstabe, U+01C4 */

PHP mb_ucfirst() setzt das erste Zeichen nicht in den Großbuchstaben, sondern in die Titelform, die der Unicode-Standard Titlecase nennt. Für fast alle Buchstaben ist beides dasselbe. Unterschiede gibt es bei Zeichen, die zwei Buchstaben in sich tragen, wie den kroatischen Digraph dž, den Digraph dz oder die Ligatur fi, dazu beim Eszett und bei Schriften wie Georgisch. Gemessen an sechzehn Proben wich der Polyfill mit mb_strtoupper() fünfmal ab. Die Tabelle zeigt die fünf Abweichungen und drei unauffällige Proben:

Eingabe PHP mb_ucfirst() mb_strtoupper() aufs erste Zeichen
über Über Über
ßa Ssa SSa
džungla Džungla DŽungla
dzemlja Dzemlja DZemlja
fish mit Ligatur Fish FIsh
აბგ (Georgisch) აბგ Აბგ
ijsselmeer mit Ligatur IJsselmeer IJsselmeer
istanbul Istanbul Istanbul

Bei Georgisch ist die Titelform eines Kleinbuchstabens der Kleinbuchstabe selbst. mb_strtoupper() macht daraus die Großbuchstaben-Schrift Mtavruli, PHP mb_ucfirst() lässt das Wort stehen. Das Handbuch ist an dieser Stelle doppeldeutig: Die Überschrift der Seite spricht von „uppercase“, die Beschreibung von „title-cased“. Der RFC legt es eindeutig fest, das erste Zeichen bekommt die Unicode-Titelform.

Der Polyfill aus dem Abschnitt zum Nachrüsten nutzt deshalb MB_CASE_TITLE. Gemessen an denselben sechzehn Proben lieferte er unter PHP 8.1, 8.2 und 8.3 exakt dieselben Ergebnisse wie das eingebaute PHP mb_ucfirst() unter 8.4 und 8.5. Vorbeugen lässt sich mit einem Test, der genau diese Zeichen enthält und in der CI unter allen unterstützten PHP-Versionen läuft. Mit Wörtern wie „über“ allein fällt der Unterschied nie auf.

Über alle 1.112.064 Unicode-Zeichen gemessen lieferten das eingebaute PHP mb_ucfirst() und der Polyfill innerhalb derselben PHP-Version immer dasselbe. Zwischen den Versionen wächst dagegen die Unicode-Tabelle: Die Titelform änderte unter PHP 8.1 bis 8.3 genau 1452 Zeichen, unter 8.4 1479 und unter 8.5 1507. Ein Zeichen wie ƛ bekommt erst ab PHP 8.4 eine eigene Titelform. Ein CI-Test mit solchen Zeichen schlägt deshalb auch ohne Polyfill zwischen zwei Versionen an, für deutsche Texte spielt das keine Rolle.

Aus ß wird Ss: Eszett und Strings, die länger werden

Ein Glossar führt Einträge wie „ß (Eszett)“, die Notizen eines CRM werden nach der Aufbereitung auf 30 Zeichen gekürzt. Beides geht mit PHP mb_ucfirst() schief:

<?php

echo mb_ucfirst('ß (Eszett)'), PHP_EOL;
/* Ss (Eszett) */
echo mb_strlen(mb_ucfirst('ßa'));
/* 3 statt 2 */

Die Titelform des Eszett besteht aus zwei Zeichen, S und s. Der String wird dadurch länger. Eine Notiz, die vorher genau 30 Zeichen hatte, ist danach 31 Zeichen lang, und ein anschließendes mb_substr($text, 0, 30) schneidet den letzten Buchstaben ab. Genau das passiert im Praxisbeispiel am Ende, solange es keine Ausnahme für das Eszett gibt. Ähnlich wächst die armenische Ligatur և zu Եւ. Zum Vergleich: mb_strtoupper('ß') ergibt sogar SS, wie das Tutorial zu strtoupper() zeigt.

Soll das Eszett stehen bleiben, hilft die einfache Titelform MB_CASE_TITLE_SIMPLE. Sie ersetzt jedes Zeichen durch genau ein Zeichen:

<?php

function titel_simple(string $s): string
{
$e = mb_substr($s, 0, 1);
return mb_convert_case($e, MB_CASE_TITLE_SIMPLE)
. mb_substr($s, 1);
}
echo titel_simple('ß (Eszett)'), PHP_EOL;
/* ß (Eszett) */
echo titel_simple('über');
/* Über */

Der Preis: Auch die Ligatur fi bleibt dann unverändert, während der Digraph dž weiterhin zu Dž wird. Die Reihenfolge gilt in jedem Fall: erst umwandeln, dann kürzen. Feldlängen in der Datenbank gehören nach der Umwandlung geprüft, nicht davor.

Wenn das erste Zeichen kein Buchstabe ist

Notizen aus einem Formular beginnen gern mit einem deutschen Anführungszeichen, einer Aufzählungsnummer oder einem Leerzeichen, das beim Kopieren mitkam. PHP mb_ucfirst() lässt all diese Werte unverändert: „über, 1. über, - ärger und über kommen gemessen so zurück, wie sie hineingingen. Satzzeichen, Ziffern und Leerraum haben keine Titelform, und die Funktion sucht nicht weiter.

Wer den ersten Buchstaben meint, muss ihn suchen. Ein regulärer Ausdruck mit der Unicode-Klasse \p{L} findet ihn, die Begrenzung auf einen Treffer verhindert, dass weitere Buchstaben angefasst werden:

<?php

function anfang_gross(string $text): string
{
return preg_replace_callback(
'/\p{L}/u',
fn(array $m): string => mb_ucfirst($m[0]),
$text,
1
) ?? $text;
}
echo anfang_gross('„über'), PHP_EOL; /* „Über */
echo anfang_gross('1. über'), PHP_EOL; /* 1. Über */
echo anfang_gross('...und'); /* ...Und */

Gemessen kamen außerdem - Ärger und Über heraus, eine reine Zahl wie 42 blieb unverändert. Bei ungültigem UTF-8 liefert preg_replace_callback() den Wert null. Der Rückfall mit ?? gibt dann den Originaltext zurück, statt einen leeren String zu speichern. Für Leerzeichen am Rand reicht vorher ein trim().

Rest klein, Namen, Bindestriche: mb_convert_case() und ucwords() im Vergleich

Ein Kundenportal übernimmt Namen aus einem Anmeldeformular. Die einen tippen alles groß, die anderen alles klein. Ein älteres Snippet schreibt deshalb jeden Wert vorher klein und dann den Anfang groß. Für einen Namen klappt das, für einen Satz nicht:

<?php

$t = 'äpfel und BIRNEN';
echo ucwords($t), PHP_EOL;
/* äpfel Und BIRNEN */
echo mb_convert_case($t, MB_CASE_TITLE), PHP_EOL;
/* Äpfel Und Birnen */
echo mb_ucfirst($t), PHP_EOL;
/* Äpfel und BIRNEN */
echo mb_ucfirst(mb_strtolower('über die BRÜCKE'));
/* Über die brücke */

Die letzte Zeile zeigt das Problem. PHP mb_ucfirst() fasst den Rest nicht an. Wer ihn vorher kleinschreibt, verliert jedes großgeschriebene Substantiv. ucwords() kennt keine Umlaute und trennt standardmäßig nur an Leerraum, aus anna-maria wird Anna-maria. mb_convert_case() mit MB_CASE_TITLE erkennt Wortgrenzen selbst und schreibt den Rest jedes Wortes klein, gemessen Anna-Maria und Jean-Luc Picard.

Für Namen ist das die richtige Wahl, aber nur, wenn der Name komplett groß oder komplett klein eingegeben wurde. Wer McDonald richtig tippt, soll nicht Mcdonald zurückbekommen:

<?php

function name_aufbereiten(string $roh): string
{
$name = trim($roh);
$klein = mb_strtolower($name);
if ($name === $klein
|| $name === mb_strtoupper($name)) {
return mb_convert_case($klein, MB_CASE_TITLE);
}
return $name;
}
echo name_aufbereiten(' ÖZTÜRK-MÜLLER '), PHP_EOL;
/* Öztürk-Müller */
echo name_aufbereiten('McDonald');
/* McDonald */

Eine Grenze bleibt: Aus O'NEIL wird O'neil, denn der Apostroph gilt nicht als Wortgrenze. Für Satzanfänge in deutschem Fließtext ist PHP mb_ucfirst() allein richtig, ohne vorheriges Kleinschreiben.

ISO-8859-1 und Windows-1252: der Parameter encoding

Ein Großhändler importiert Artikeldaten aus einer alten Warenwirtschaft, die ihre CSV-Dateien in Windows-1252 schreibt. Das ü ist dort ein einzelnes Byte. Ohne Angabe der Kodierung passiert damit nichts, mit einer falschen Angabe geht gültiges UTF-8 kaputt:

<?php

$latin = "\xFCber"; /* über in ISO-8859-1 */
$neu = mb_ucfirst($latin, 'ISO-8859-1');
echo bin2hex($neu), PHP_EOL;
/* dc626572 */
echo bin2hex(mb_ucfirst($latin)), PHP_EOL;
/* fc626572 */

$kaputt = mb_lcfirst('Äpfel', 'ISO-8859-1');
var_dump(mb_check_encoding($kaputt, 'UTF-8'));
/* bool(false) */

Mit der richtigen Angabe wird aus dem Byte fc das große dc, also Über in Latin-1. Mit Windows-1252 oder dem Kurznamen latin1 kam dasselbe heraus. Ohne Angabe nimmt PHP mb_ucfirst() UTF-8 an, findet am Anfang kein gültiges Zeichen und lässt die Bytes stehen, ohne Warnung. Umgekehrt hält mb_lcfirst() mit der Angabe ISO-8859-1 das erste Byte des UTF-8-Umlauts für ein Ã, schreibt es klein und zerstört damit das Zeichen.

Sicherer als jede Encoding-Angabe ist eine einzige Kodierung im ganzen Programm. Eingaben aus fremden Quellen werden an der Grenze mit mb_convert_encoding() nach UTF-8 gewandelt und mit mb_check_encoding() geprüft. Danach kommt PHP mb_ucfirst() ohne zweiten Parameter aus, so wie im Praxisbeispiel.

Türkisch und Niederländisch: wo PHP mb_ucfirst() keine Sprachregeln kennt

Ein Reiseportal pflegt Ortsnamen in mehreren Sprachen. Aus istanbul macht PHP mb_ucfirst() Istanbul, auf Türkisch wäre İstanbul mit Punkt richtig. Aus dem niederländischen ijsselmeer wird Ijsselmeer, korrekt ist IJsselmeer. Nur die Ligatur ij, die als ein einziges Zeichen gespeichert ist, wird richtig zu IJ.

PHP mb_ucfirst() arbeitet mit den Unicode-Eigenschaften der Zeichen und kennt keine Sprachregeln. Eine gesetzte Locale ändert daran nichts. Unter Windows meldete setlocale(LC_ALL, 'tr-TR') Erfolg, die Ausgabe blieb Istanbul. Was die Locale in PHP 8 überhaupt noch steuert, zeigt das Tutorial zu setlocale(). Der RFC nennt solche Fälle ausdrücklich und verweist sie in den eigenen Code. Mit der Erweiterung intl gibt es Transliteratoren, die Sprachregeln kennen:

<?php

$tr = Transliterator::create('tr-Title');
echo $tr->transliterate('istanbul izmir'), PHP_EOL;
/* İstanbul İzmir */
$nl = Transliterator::create('nl-Title');
echo $nl->transliterate('ijsselmeer'), PHP_EOL;
/* IJsselmeer */
echo mb_ucfirst('istanbul'); /* Istanbul */

Die Transliteratoren setzen jedes Wort in die Titelform, nicht nur das erste. Im Linux-Container standen neben tr-Title und nl-Title auch az-Title, el-Title und lt-Title zur Verfügung. In der getesteten Windows-Installation fehlte intl, dort braucht der Code vorher eine Prüfung mit class_exists('Transliterator').

Praxis: Kundendaten aus einer Windows-CSV mit PHP mb_ucfirst() aufbereiten

Zum Schluss ein Import, der fast alle Fälle auf einmal hat. Eine Warenwirtschaft exportiert Kunden als kunden.csv in Windows-1252, mit Semikolon und Windows-Zeilenenden. Die Namen stehen mal in Versalien, mal klein, mal richtig. Die Notizen beginnen mit Anführungszeichen, Nummern oder einem Eszett. Zum Nachstellen erzeugt dieses Skript die Datei:

<?php

$zeilen = [
'ÖZTÜRK-MÜLLER;über Empfehlung gekommen',
'jean-luc picard;„dringend: rückruf erbeten“',
'McDonald;1. mahnung offen',
'ÄNNE SCHÄFER;ölwechsel am 3.11. bestätigt',
"O'NEIL;ß-Schreibweise im Namen prüfen",
];
$csv = implode("\r\n", $zeilen) . "\r\n";
file_put_contents(
__DIR__ . '/kunden.csv',
mb_convert_encoding($csv, 'Windows-1252', 'UTF-8')
);

Das Importskript bindet den Polyfill ein, damit es auch unter PHP 8.3 läuft, wandelt jede Zeile nach UTF-8, bereitet Namen nur bei durchgehender Groß- oder Kleinschreibung auf und schreibt den ersten Buchstaben der Notiz mit PHP mb_ucfirst() groß. Das Eszett bleibt dabei stehen, und gekürzt wird erst nach der Umwandlung:

<?php

require __DIR__ . '/mb-polyfill.php';

function anfang_gross(string $text): string
{
return preg_replace_callback(
'/\p{L}/u',
fn(array $m): string => $m[0] === 'ß'
? $m[0]
: mb_ucfirst($m[0]),
$text,
1
) ?? $text;
}

/* name_aufbereiten() aus dem Abschnitt zu Namen */

$datei = __DIR__ . '/kunden.csv';
$von = 'Windows-1252';
foreach (file($datei, FILE_IGNORE_NEW_LINES) as $roh) {
$utf8 = mb_convert_encoding($roh, 'UTF-8', $von);
[$name, $notiz] = str_getcsv($utf8, ';', '"', '');
$notiz = mb_substr(anfang_gross($notiz), 0, 30);
echo name_aufbereiten($name), ' | ', $notiz;
echo PHP_EOL;
}
/* Öztürk-Müller | Über Empfehlung gekommen
Jean-Luc Picard | „Dringend: rückruf erbeten“
McDonald | 1. Mahnung offen
Änne Schäfer | Ölwechsel am 3.11. bestätigt
O'neil | ß-Schreibweise im Namen prüfen */

In mb-polyfill.php stehen die beiden function_exists()-Blöcke aus dem Abschnitt zum Nachrüsten, ohne die echo-Zeile am Ende. Die Ausgabe war unter PHP 8.1 und 8.3 mit Polyfill, unter 8.4 und unter 8.5 dieselbe, unter Windows nur mit anderen Zeilenenden. Die erste Fassung des Skripts hatte noch keine Ausnahme für das Eszett. Ihre letzte Zeile lautete O'neil | Ss-Schreibweise im Namen prüfe: Aus dem Eszett war Ss geworden, die Notiz dadurch 31 Zeichen lang, und die Kürzung auf 30 Zeichen hatte das n abgeschnitten. str_getcsv() bekommt ein leeres Escape-Zeichen, damit keine PHP-Version eine Warnung zum Standardwert ausgibt. McDonald bleibt, wie er eingegeben wurde, O'neil ist die bekannte Grenze aus dem Namensabschnitt.

Fazit

PHP mb_ucfirst() und mb_lcfirst() lösen das Umlautproblem von ucfirst() mit einem Aufruf, aber sie tun weniger und anderes, als der Name verspricht. Sie ändern nur das erste Zeichen und lassen den Rest stehen. Sie setzen dieses Zeichen in die Titelform, weshalb aus ß ein Ss wird und der String wachsen kann. Und sie kennen keine Sprachregeln, Türkisch und Niederländisch brauchen intl.

Vor PHP 8.4 hilft ein Polyfill mit function_exists() und MB_CASE_TITLE, der gemessen dieselben Ergebnisse liefert wie das Original und mit ?string auch null verträgt. Eine alte Hilfsfunktion ohne diese Prüfung legt nach dem Update die ganze Seite lahm, ein php -l mit PHP 8.4 findet sie vorher. Für Namen ist mb_convert_case() mit MB_CASE_TITLE das bessere Werkzeug, für Satzanfänge PHP mb_ucfirst(), und Daten in fremder Kodierung werden zuerst nach UTF-8 gewandelt.

 

Tags:

 

 

Kommentare (0)

Noch keine Kommentare. Sei der Erste!

Melde dich an, um einen Kommentar zu schreiben.
Bücherregal mit drei Büchern: 'PHP 4 - Grundlagen und Profiwissen' von Hanser Verlag, 'Webdesign in a Nutshell' von O'Reilly Verlag, und 'Webgestaltung' von Galileo Computing.