Home
Scripts
Games
Referenz
     Basics:
   · Variablen
   · Datentypen
   · Operatoren
   · Funktionen
   · Pragmas
   · if else
   · while
   · for
     Libraries:
   · Lang
   · Float
   · String
   · URL
   · WMLBrowser
   · Dialogs
   · Crypto
   · WTAPublic
     Extras:
   · Arrays
   · Sortieren
   · Mathematik
Links
Gäste
Kontakt

< String-Library >


Die String-Library beinhaltet diverse Funktionen zur Verwendung und Verarbeitung von Zeichenketten.

WAP-Standard: 1.1+


length
Gibt die Länge des Strings zurück.
Syntax => String.lenght(string)

var a;
a = String.lenght("laenge"); // a == 6
a = String.lenght("");       // a == 0
a = String.lenght(" ");      // a == 1
a = String.lenght(3213);     // a == 4
a = String.lenght(3.2);      // a == 3
a = String.lenght(-1);       // a == 2

isEmpty
Prüft, ob die Länge des Strings gleich 0 ist.
Syntax => String.isEmpty(string)

var s;
s = String.isEmpty("");       // s == true
s = String.isEmpty(" ");      // s == false
s = String.isEmpty("pipapo"); // s == false
s = String.isEmpty(0);        // s == false

charAt
Liest aus einem String ein Element heraus.
Syntax => String.charAt(string, index)

var c;
s = String.charAt("Hello World", 0);  // s == "H"
s = String.charAt("Hello World", 5);  // s == "o"
s = String.charAt("Hello World", 6);  // s == " "
s = String.charAt("Hello World", 22); // s == ""
s = String.charAt(534, 2);            // s == "4"

subString
Liest aus einem String einen Teil-String heraus.
Syntax => String.subString(string, startIndex, length)

var c;
c = String.subString("Hello Moon", 0, 2 ); // c == "He"
c = String.subString("Hello Moon", 5, 3);  // c == "o M"
c = String.subString("Hello Moon", 22, 7); // c == ""
c = String.subString(52.447, 3, 3);        // c == "447"

find
Findet in einem String einen Teil-String.
Syntax => String.find(string, subString)

var f;
f = String.find("Der große Käse", "Käs" ); // f == 10
f = String.find("Der große Käse", "e" );   // f == 1
f = String.find("Großer Käse", "qxy" );    // f == -1
f = String.find(69887, "9 " );             // f == -1

replace
Ersetzt in einem String einen alten Teil-String durch einen neuen Teil-String.
Syntax => String.replace(string, oldSubString, newSubString)

var r;
r = String.replace("Der Ball ist rot", "rot", "blau" );
// r == "Der Ball ist blau"
r = String.replace("H a l l o", " ", "" );  // r == "Hallo"
r = String.replace("Hallo", "", " " );      // r == invalid
r = String.replace(123456, "3", "9" );      // r == "129456"

elements
Zählt die Anzahl der Elemente in einem String, die durch Separatoren getrennt sind.
Syntax => String.elements(string, separator)

var e;
e = String.elements("Es ist alles aus", " " );   // e == 4
e = String.elements("Es ist - alles aus", "-" ); // e == 2
e = String.elements("Es-ist alles-aus", "-" );   // e == 3
e = String.elements("Esxistxallesxaus", "x" );   // e == 4
e = String.elements(1234567, "4" );              // e == 2
e = String.elements("yyyyy", "y" );              // e == 6
e = String.elements("x", "y" );                  // e == 1
e = String.elements("", "y" );                   // e == 1
e = String.elements("yyy", "" );                 // e == invalid
e = String.elements("x!?x?x", "?!" ); // e == 3, Seperator ?
e = String.elements("x!?x?x", "!?" ); // e == 2, Seperator !

elementAt
Liest einzelne Elemente aus einem String heraus.
Syntax => String.elementAt(string, index, separator)

var a;
a = String.elementAt("Es ist alles aus", 0, " " ); // a == "Es"
a = String.elementAt("Es ist alles aus", 1, " " ); // a == "ist"
a = String.elementAt("Es ist alles aus", 5, " " ); // a == ""
a = String.elementAt("Es-ist alles-aus", 2, "-" ); // a == "aus"
a = String.elementAt("0-1-2-3-4-5", 5, "-" );      // a == "5"
a = String.elementAt(22.03, 0, "." );              // a == "22"

removeAt
Löscht ein Element.
Syntax => String.removeAt(string, index, separator)

var r;
r = String.removeAt("e,z,d,v", 1, "," );  // r == "e,d,v"
r = String.removeAt("e,z,d,v", 0, "," );  // r == "z,d,v"
r = String.removeAt("e z d v", 9, " " );  // r == "e z d"
r = String.removeAt("e z d v", -2, " " ); // r == "z d v"

replaceAt
Ersetzt ein Element.
Syntax => String.replaceAt(string, element, index, separator)

var r;
r = String.replaceAt("1,2,3,4", "x", 1, "," );  // r == "1,x,3,4"
r = String.replaceAt("1,2,3,4", "x", -2, "," ); // r == "x,2,3,4"
r = String.replaceAt("1,2,3,4", "x", 8, "," );  // r == "1,2,3,x"
r = String.replaceAt("dein", "m", 0, "" );      // r == "mein"

insertAt
Fügt ein neues Element ein.
Syntax => String.insertAt(string, element, index, separator)

var i = String.insertAt("1,2,3,4", "2b", 1, "," );
// i == "1,2,2b,3,4"

squeeze
Reduziert mehrere Leerzeichen auf eines.
Syntax => String.squeeze(string)

var s = String.squeeze("Sehr      viel   Platz  hier" );
// s == "Sehr viel Platz hier"

trim
Löscht alle Leerzeichen am Anfang und am Ende.
Syntax => String.trim(string)

var t;
t = String.trim(" Anfang und    Ende   " );
// t == "Anfang und    Ende"

compare
Bestimmt die lexikalische Reihenfolge zweier Strings. Steht der 'führende' String an erster Stelle, wird eine -1 zurückgegeben, steht er an zweiter Stelle eine 1. Bei Gleichheit eine 0.
Syntax => String.compare(string1, string2)

var c;
c = String.compare("blau", "rot");    // c == -1
c = String.compare("rot", "blau");    // c == 1
c = String.compare("blau", "blau");   // c == 0
c = String.compare("blau", "blauer"); // c == -1
c = String.compare(3, 7);             // c == -1
c = String.compare(3, 17);            // c == 1
c = String.compare(13, 17);           // c == -1
c = String.compare(3, "blau");        // c == -1

Lexikalische Reihenfolge heißt:
a vor b, aa vor ab, aa vor aaa und 1 vor 2, 12 vor 22, 14 vor 4 (!) usw.


toString
Wandelt einen Wert in einen String um.
Syntax => String.toString(value)

var s;
s = String.toString(23);   // s == "23"
s = String.toString(true); // s == "true"
s = String.toString(text); // error

format
Zum Formatieren von Strings.
Syntax => String.format(format, value)

Syntax des format-Arguments: %[width][.precision]type
Zwingend erforderlich ist nur %type.

'width' ist die Anzahl der anzuzeigenden Zeichen.'
Eine Ergänzung erfolgt gegebenenfalls durch vorangestellte Leerzeichen.

'type' kann 'd' für Ganzzahlen, 'f ' für Fließkommazahlen oder 's' für beliebige Zeichenketten sein:

'.precision' hängt von 'type' ab:
Wenn type d ist, bestimmt precision die minimale Anzahl der Zeichen.
Eine Ergänzung erfolgt gegebenenfalls durch Nullen.
Default: 1.
Wenn type f ist, bestimmt precision die Anzahl der Nachkommastellen.
Ergänzung gegebenenfalls durch Nullen. Bei einer Kürzung wird gerundet.
Default: 6
Wenn type s ist, bestimmt precision die maximale Anzahl der Zeichen.
'width' hat hier keine Bedeutung.
Default: alle

var m;

m = String.format("%d", 12345);          // m == "12345"
m = String.format("%3d", 12345);         // m == "12345"
m = String.format("%7d", 12345);         // m == "  12345"
m = String.format("%.8d", 12345);        // m == "00012345"
m = String.format("%9.8d", 12345);       // m == " 00012345"
m = String.format("Erg.: %.5d", 12);     // m == "Erg.: 00012"

m = String.format("%f", 123.45);         // m == "123.450000"
m = String.format("%12f", 123.45);       // m == "  123.450000"
m = String.format("%.3f", 123.45);       // m == "123.450"
m = String.format("%.1f", 123.45);       // m == "123.5" (Rundung)
m = String.format("%.f", 123.45);        // m == "123" (Rundung)
m = String.format("E = %.f", 123.45);    // m == "E = 123"

m = String.format("%s", "abcdef");       // m == "abcdef"
m = String.format("%6s", "abcdef");      // m == " abcdef"
m = String.format("%.5s", "abcdef");     // m == "abcde"
m = String.format("%12.5s", "abcdef");   // m == "abcde"
m = String.format("%2.5s", "abcdef");    // m == "abcde"
m = String.format("Für %.5s", "abcdef"); // m == "Für abcde"




Copyright © 2002-2003 by wmlscript.de - Alle Rechte vorbehalten
Impressum | Datenschutz | eMail