Ge­ter Text

Ja, Blocksatz und automatische Silbentrennung können die Browser nicht. Aber es wäre schön, wenn sie es könnten. In der Diskussion hierüber gibt es zwei Lager: die einen wollen etwas haben, was die Lesbarkeit eines Webtextes in die Nähe eines Drucktextes bringt; die anderen lehnen halbherzige Versuche ab und argumentieren technisch, dass es eben nicht vernünftig geht: Browserschriften können vom Anwender verändert werden, es würde den Browser zusätzlich belasten, die Kontrolle über das Ergebnis geht verloren, usw. Ein wenig erinnert mich das an eine Diskussion von vor 25 Jahren: Da wurde der Einsatz einer Maus bei der Textverarbeitung abgelehnt – mit Tasten sei man schließlich schneller ...

Also gäbe es eine auf allen Browser zum gleichen Ergebnis kommende schnelle hundertprozentige automatische Silbentrennung, wer würde sie nicht haben wollen?

Zur Zeit gibt es das aber nicht. Was komischerweise vorhanden ist, ist ein veraltertes HTML-Tag für die Markierung einer möglichen Trennstelle: <wbr> und ein Character-Code für eine 'weiche Trennung': &shy; alias &#173; alias &#xAD; (shy = soft hyphen = bedingter Trennstrich). Leider macht wieder jeder Browser was er will: Firefox bis Version 2 ignoriert, IE trennt wie wild, Safari macht sich nen eigenen Trennzeichenrand beim Blocksatz. Je nach Verfahren und Browser wird bei einer weichen Trennung auch gerne mal das Trennzeichen geschlabbert. Also nicht wirklich viel Freude, es bleibt der ganz normale Sumpf.

Wenn man sich nun die Mühe machen würde, eine halbwegs auf allen Browsern auch laufende Lösung mittels JavaScript zu schreiben, dann würde man zunächst voraussetzen, dass die Trennungen irgendwie im Text vorhanden sind. Also zum Beispiel: BeiIIspiel. Nun könnten man verfolgen, ob eine Trennung auch realisiert werden muss, indem man den Text kleinhackt, d. h. die Trennstriche, Leer- und Sonderzeichen in Tags kleidet und in einer Ver|arbeitungsschleife den Abstand der Tags zueinander prüft. Wenn zwischen zwei Tags der Abstand unterschiedlich wird, und der erstere Tag ein Trennzeichen-Tag ist, dann liegt eine Trennung vor. Alle anderen potentiellen Trennzeichen kann man nun getrost entfernen. Übrig bleiben so nur die weichen Trennzeichen, die man braucht. Klar ist auch, dass man fürs Kleinhacken notwendige Tag-Gerümpel wieder entfernt.

o = true // wenn Blocksatz
e.innerHTML=e.innerHTML.replace(/([,.;:?!'"\])-])/g,'<s>$1</s>');
e.innerHTML=e.innerHTML.replace(/ /g,'<s>&nbsp;</s> ');
e.innerHTML=e.innerHTML.replace(/\|/g,'<s>- </s>');
z=document.getElementsByTagName('s');
for(i=0;i<z.length;++i) {
if (z[i].innerHTML == '&nbsp;') z[i].innerHTML = '';
if (i<z.length-1 && z[i].offsetTop == z[i+1].offsetTop && z[i].innerHTML == '- ') z[i].innerHTML = '';
if (o && i>0 && z[i-1].innerHTML == '- ') {
if (z[i-1].offsetLeft < e.offsetWidth-10 || z[i].innerHTML.match(/[,.;:?!'"\])-]/))
  z[i-1].innerHTML = '';
}
}
e.innerHTML=e.innerHTML.replace(/<s>-<\/s><s>- <\/s>/ig,'- ');
e.innerHTML=e.innerHTML.replace(/<s>(.{0,2})<\/s>/ig,'$1');

Das Ergebnis ist insbesondere beim Blocksatz im FF, IE und Safari recht ordentlich. Und im DOM des Browsers sind auch keine überflüssigen 'weichen Trennzeichen' mehr, die eine Suche nach Textstellen (ich denke an Seiten-Durchsuchen per JavaScript mit Highlighting) behindern würden.

Die offene Frage ist noch, wie erhält man so einen Silben-ausgezeichneten-Text, der hier Voraussetzung für die Verarbeitung ist. Erste Antwort: manuell. Zweite Antwort: per JavaScript-Trennprogramm. Nun gibt es mehr oder weniger ausgetüfftelte Algorithmen, die zur automatischen Silbentrennung verwendet werden. Trotz der neuen Regeln in der deutschen Rechtschreibung, ist das Finden der Silben nicht einfach. Entweder man analysiert Wortstamm usw. oder liest direkt in einem Wörterbuch oder hat eine Ausnahmenbehandlungstabelle.

Und dann gibt es ja auch noch die sinnentstellenden Zweifelsfälle: Wach-stube vs. Wachs-tube und ihre die Lösung: Wachstu-be gemäß SiSiSi (Sichere sinnentsprechende Silbentrennung). Zu erwähnen bliebe noch Fran­kling Mark Liangs Algorithmus, der so manches offene Softwareprojekt ziert und auch in die wohl für Webseiten zur Zeit perfekteste Lösung von Mathias Nater eingeflossen ist. Nun ich suchte nach einer kleinen, nicht unbedingt perfekten Lösung und fand eine kleine Code-Strecke von Danial Kirch, die ich nach JavaScript portiert und erweitert habe:

function hyp_in(w) {
t              = new Array();
l              = w.length;
vokale         = "aeiouäöüAEIOUÄÖÜy";
verbindungen   = "sch ch ph ck pf br pl tr st gr sp kl gl ng";
trennungen     = "-/\*#;,.+=)(&!?<>: _~|";
if (l > 4) {
ok = false;
for (i=1; i<l; ++i) {
z0 = w.charAt(i-1);
if (ok == false && vokale.indexOf(z0) != -1) { ok = true; }
if (ok == true) {
 z  = w.charAt(i);
 z1 = w.charAt(i+1);
 v  = z0+z;
 if (v == "ch" && i > 2 && w.charAt(i-2) == "s") { v = "sch"; }
 if (vokale.indexOf(z1) != -1 && vokale.indexOf(z) == -1
   && trennungen.indexOf(z) == -1 && trennungen.indexOf(z0) == -1)
   if (verbindungen.indexOf(v) != -1)     
      { if (i<l-1) t.push(i-v.length+1); }
   else
      if (w.charAt(i-2)!= '|') t.push(i);
}
}
}
r = (trennungen.indexOf(w[l-1]) != -1)?2:1;
if (l-t[t.length-1] == r) t.pop();
out='';y=0;
for(i=0;i<l;++i) { if (i == t[y]) { out+='|'; y+=1; } out+=w.charAt(i);}
return out;
}

Die Funktion will am liebsten einzelne Worte überreicht bekommen, so dass man seinen Text noch in Worte aufbrechen muss:

textin=document.getElementById('irgendwas');
text=textin.innerHTML.split(/\s/);
newtext='';
for (word=0; word<text.length; ++word)
  newtext+=hyp_in(text[word])+' ';
textin.innerHTML=newtext;

Das Schöne an dem obigen Algorithmus ist, dass man auch eine manuelle Vortrennung vornehmen kann, die ein wenig das Trennverhalten steuert (kleine Ergänzung von mir) und das Ergebnis ist recht passabel für so ein kleines Ding. Die Trennungsvorschlagsqua- lität liegt bei etwas über 90% - das kommt nun ja auch ganz auf den Text an. Fest vorgegeben Bindestriche werden zwar berücksichtigt, sind aber noch ein Problemkind: auf sehr kurzen Zeilen (Wort ist 60% der Zeilenlänge oder sogar über eine Zeile lang), geht es meist nicht richtig. Entfernt man die 'harten Bindestriche', ist es kein Problem mehr. Was auch sehr schön ist, ist die Tatsache, dass man keine mit Trennvorschlägen vorbereiteten Webseiten-Texte braucht; das wäre für manche Suchmaschine (ach sind sie alle doch schlecht) nicht verdaubarer Inhalt: sucht mal nach &shy; ...