String.prototype

W tym rozdziale dowiesz się...

constructor

String.prototype.constructor
Wartość:
Function - konstruktor obiektu

Zawiera konstruktor wbudowanego obiektu tekstowego String.

Przykład:

String.prototype.constructor === String; // true
new String().constructor === String;     // true
String.prototype.constructor === Object; // false

toString

String.prototype.toString()

Działa identycznie jak funkcja String.prototype.valueOf.

valueOf

String.prototype.valueOf()
Wartość:
prosta wartość tekstowa
Wyjątki:
TypeError - obiekt nie jest tekstem

Przekształca obiekt tekstowy na prostą wartość tekstową (już nie obiekt). Działa identycznie jak funkcja String.prototype.toString.

Przykład:

new String("test").valueOf();             // "test"
String.prototype.valueOf.call("test");    // "test"
 
String.prototype.valueOf.call(null);      // TypeError
String.prototype.valueOf.call(undefined); // TypeError
String.prototype.valueOf.call({});        // TypeError

charAt

String.prototype.charAt()
String.prototype.charAt(pos)
Parametry:
Number pos - pozycja w tekście (liczba naturalna licząc od 0)
Wartość:
String - znak o podanej pozycji

Zwraca znak o podanej pozycji w tekście. Pierwszy znak ma pozycję 0. Jeżeli podano pozycję poza ograniczonym zakresem (mniejszą od zera albo większą lub równą długości tekstu), zwracany jest pusty tekst.

Przykład:

"abc".charAt();          // "a"
"abc".charAt(0);         // "a"
"abc".charAt(" +0.9 ");  // "a"
"abc".charAt(null);      // "a"
"abc".charAt(undefined); // "a"
"abc".charAt(NaN);       // "a"
"abc".charAt("test");    // "a"
"abc".charAt(false);     // "a"
"abc".charAt(true);      // "b"
 
"abc".charAt(-1);        // ""
"abc".charAt(3);         // ""
"abc".charAt(Infinity);  // ""
"".charAt(0);            // ""

charCodeAt

String.prototype.charCodeAt()
String.prototype.charCodeAt(pos)
Parametry:
Number pos - pozycja w tekście (liczba naturalna licząc od 0)
Wartość:
Number - kod liczbowy znaku o podanej pozycji w postaci 16-bitowej liczby naturalnej (0 - 65535)

Każdy pojedynczy znak tekstu jest zapisany wewnętrznie w postaci odpowiadającego mu kodu liczbowego. System przechowuje pełną mapę tych kodów, dzięki czemu wiadomo, że np. literze 'a' odpowiada kod 97, 'b' - 98, 'c' - 99 itd. W naszym programie możemy mieć potrzebę jawnie przekształcić znak w postaci tekstu, na odpowiadający mu taki kod liczbowy. Możemy to zrobić właśnie za pomocą funkcji String.prototype.charCodeAt.

Pierwszy znak w tekście ma pozycję 0. Jeżeli podano pozycję poza ograniczonym zakresem (mniejszą od zera albo większą lub równą długości tekstu), zwracana jest wartość NaN.

Funkcja działa odwrotnie do String.fromCharCode.

Aby sprawdzić, czy funkcja nie zwróciła przypadkiem niepoprawnego wyniku, użyj funkcji isNaN.

Przykład:

"abc".charCodeAt();          // 97
"abc".charCodeAt(0);         // 97
"abc".charCodeAt(" +0.9 ");  // 97
"abc".charCodeAt(null);      // 97
"abc".charCodeAt(undefined); // 97
"abc".charCodeAt(NaN);       // 97
"abc".charCodeAt("test");    // 97
"abc".charCodeAt(false);     // 97
"abc".charCodeAt(true);      // 98
 
"abc".charCodeAt(-1);        // NaN
"abc".charCodeAt(3);         // NaN
"abc".charCodeAt(Infinity);  // NaN
"".charCodeAt(0);            // NaN

concat

String.prototype.concat()
String.prototype.concat(string1)
String.prototype.concat(string1, string2...)
Parametry:
String string1, String string2... - lista kolejnych wartości tekstowych
Wartość:
String - połączona wartość tekstowa

Łączy kilka wartości - niekoniecznie tekstowych - w jeden tekst. Zatem działa identycznie jak operator +, w przypadku gdy przynajmniej jeden z jego argumentów jest tekstem.

Przykład:

"abc".concat();             // "abc"
"abc".concat("def", "ghi"); // "abcdefghi"
"test ".concat(null);       // "test null"
"test ".concat(false);      // "test false"
"test ".concat(undefined);  // "test undefined"
"test ".concat(+1.2);       // "test 1.2"
"test ".concat(NaN);        // "test NaN"
"test ".concat(Infinity);   // "test Infinity"

indexOf

String.prototype.indexOf(searchString)
String.prototype.indexOf(searchString, position)
Parametry:
searchString - poszukiwany tekst
Number position - początkowa pozycja poszukiwań (domyślnie: 0)
Wartość:
Number - pozycja pierwszego znalezionego tekstu

Przeszukuje tekst w kierunku jego końca pod kątem występowania w nim innego podanego tekst. Jeżeli tekst nie zostanie znaleziony, funkcja zwraca liczbę -1. Możliwe jest również ograniczenie zakresu poszukiwań do pozycji nie mniejszych niż podana (wartości ujemne są traktowane jak 0).

Przypominam, że pierwszy znak tekstu ma pozycję 0, a więc taka wartość zwrócona przez funkcję oznacza, że poszukiwany tekst został znaleziony (na samym początku).

Przykład:

"abc def abc".indexOf("a");       // 0
"abc def abc".indexOf("abc");     // 0
"abc def abc".indexOf("abc", 1);  // 8
"abc def abc".indexOf("abc", -8); // 0  == "abc def abc".indexOf("abc", 0)
"abc def abc".indexOf("abc", 30); // -1 == "abc def abc".indexOf("abc", 11)
"abc def abc".indexOf("ghi");     // -1
"abc def abc".indexOf("ABC");     // -1

lastIndexOf

String.prototype.lastIndexOf(searchString)
String.prototype.lastIndexOf(searchString, position)
Parametry:
searchString - poszukiwany tekst
Number position - początkowa pozycja poszukiwań (domyślnie: długość tekstu - 1)
Wartość:
Number - pozycja ostatniego znalezionego tekstu

Przeszukuje tekst w kierunku jego początku pod kątem występowania w nim innego podanego tekst. Jeżeli tekst nie zostanie znaleziony, funkcja zwraca liczbę -1. Możliwe jest również ograniczenie zakresu poszukiwań do pozycji nie większych niż podana (wartości ujemne są traktowane jak 0).

Przypominam, że pierwszy znak tekstu ma pozycję 0, a więc taka wartość zwrócona przez funkcję oznacza, że poszukiwany tekst został znaleziony (na samym początku).

Przykład:

"abc def abc".lastIndexOf("a");       // 8
"abc def abc".lastIndexOf("abc");     // 8
"abc def abc".lastIndexOf("abc", 1);  // 0
"abc def abc".lastIndexOf("abc", -8); // 0 == "abc def abc".lastIndexOf("abc", 0)
"abc def abc".lastIndexOf("abc", 30); // 8 == "abc def abc".lastIndexOf("abc", 11)
"abc def abc".lastIndexOf("ghi");     // -1
"abc def abc".lastIndexOf("ABC");     // -1

localeCompare

String.prototype.localeCompare(that)
Parametry:
String that - drugi tekst do porównania
Wartość:
Number - wartość porównania:
  • liczba mniejsza od zera - gdy bieżący tekst jest mniejszy niż that
  • zero - gdy oba teksty są równe
  • liczba większa od zera - gdy bieżący tekst jest większy niż that

Dwa teksty możemy porównać ze sobą za pomocą operatora < oraz >, ale wtedy porównywane są tak naprawdę ich kody liczbowe. W przypadku alfabetu łacińskiego wszystko jest w porządku. Jednak gdy będziemy próbowali porównać teksty zawierające znaki diakrytyczne, takie porównanie nie odzwierciedli prawidłowej kolejności występowania liter w narodowym alfabecie. Wady tej nie posiada funkcja String.prototype.localeCompare, która powinna uwzględnić domyślny język ustawiony w systemie operacyjnym użytkownika.

Przykład:

"abc".localeCompare("def") < 0; // true
"def" > "abc";                  // true
"def".localeCompare("abc") > 0; // true
 
"ą" < "b";                      // false
"ą".localeCompare("b"); < 0;    // true
"b" > "ą";                      // false
"b".localeCompare("ą") > 0;     // true
 
var chars = [
    " ", "`", "-", "=", "[", "]", "|", ";", "'", ",", ".", "/",
    "~", "!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "{", "}", "\\", ":", "\"", "<", ">", "?",
    "1", "0", "2", "3", "5", "7", "4", "6", "8", "9",
    "n", "c", "a", "o", "b", "p", "d", "g", "q", "e", "m", "r", "h", "f", "s", "i", "l", "v", "w", "x", "j", "y", "u", "k", "z", "t",
    "N", "C", "A", "O", "B", "P", "D", "G", "Q", "E", "M", "R", "H", "F", "S", "I", "L", "V", "W", "X", "J", "Y", "U", "K", "Z", "T",
    "ż", "ó", "ł", "ć", "ę", "ś", "ą", "ź", "ń",
    "Ż", "Ó", "Ł", "Ć", "Ę", "Ś", "Ą", "Ź", "Ń"
];
var f = function (x, y) {
    return String.prototype.localeCompare.call(x, y);
};
chars.sort(f);
// np.: ["'", "-", " ", "!", "\"", "#", "$", "%", "&", "(", ")", "*", ",", ".",
//       "/", ":", ";", "?", "@", "[", "\\", "]", "^", "`", "{", "|", "}", "~",
//       "<", "=", ">", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
//       "a", "A", "ą", "Ą", "b", "B", "c", "C", "ć", "Ć", "d", "D", "e", "E",
//       "ę", "Ę", "f", "F", "g", "G", "h", "H", "i", "I", "j", "J", "k", "K",
//       "l", "L", "ł", "Ł", "m", "M", "n", "N", "ń", "Ń", "o", "O", "ó", "Ó",
//       "p", "P", "q", "Q", "r", "R", "s", "S", "ś", "Ś", "t", "T", "u", "U",
//       "v", "V", "w", "W", "x", "X", "y", "Y", "z", "Z", "ź", "Ź", "ż", "Ż"]

match

String.prototype.match(regexp)
Parametry:
RegExp regexp - wyrażenie regularne
Wartość:
Array - tablica dopasowań
Null - tekst nie został dopasowany do wyrażenia regularnego

Próbuje dopasować tekst do podanego wzorca - wyrażenia regularnego. Jeżeli się to uda, zwraca pierwszy dopasowany fragment tekstu oraz każdą jego część, która w wyrażeniu była zapisana w nawiasie (to działanie jest identyczne jak w przypadku funkcji RegExp.prototype.exec). Natomiast w przypadku dopasowania globalnego - kiedy wyrażenie regularne posiada flagę g - zwracane są wszystkie dopasowane fragmenty tekstu, ale już bez dodatkowych ich części, które w wyrażaniu były zapisane w nawiasach.

Jeżeli chcesz tylko sprawdzić, czy określony tekst pasuje do wzorca - wyrażenia regularnego - użyj funkcji RegExp.prototype.test.

Przykład:

"abcd efg abc".match(/abc/);    // ["abc"]
"abcd efg abc".match(/(ab)c/);  // ["abc", "ab"]
 
"ABCd efg abc".match(/abc/i);   // ["ABC"]
"ABCd efg abc".match(/(ab)c/i); // ["ABC", "AB"]
 
"abcd efg abc".match(/abc/g);   // ["abc", "abc"]
"abcd efg abc".match(/(ab)c/g); // ["abc", "abc"]
 
"ABCd efg abc".match(/abc/ig);   // ["ABC", "abc"]
"ABCd efg abc".match(/(ab)c/ig); // ["ABC", "abc"]
 
"abcd efg abc".match(/hij/);     // null
"abcd efg abc".match(/ABC/);     // null
"abcd efg abc".match(/(AB)C/);   // null
"abcd efg abc".match(/hij/g);    // null
"abcd efg abc".match(/ABC/g);    // null
"abcd efg abc".match(/(AB)C/g);  // null

replace

String.prototype.replace(searchValue, replaceValue)
Parametry:
String|RegExp searchValue - szukana wartość w postaci prostego tekstu albo wyrażenia regularnego
String|Function replaceValue - tekst na który mają zostać zamienione dopasowania albo funkcja zwracająca tekst na podmianę i przyjmująca argumenty:
  • String substring - dopasowany fragment oryginalnego tekstu
  • String capture1, String capture2... - lista części dopasowania, które w wyrażeniu były umieszczone w nawiasach (opcjonalne)
  • Number offset - pozycja w oryginalnym teście (liczba naturalna licząc od 0), na której znaleziono dopasowany fragment
  • String string - oryginalny tekst
Wartość:
String - zmieniony tekst

Przeszukuje tekst pod kątem występowania w nim podanego tekstu i zamienia go na inny.

Jeżeli argument searchValue jest wyrażeniem regularnym o dopasowaniu globalnym - z ustawioną flagą g - zamieniane są wszystkie znalezione wystąpienia tekstu. W przeciwnym razie zamieniane jest tylko pierwsze wystąpienie dopasowania.

Jeżeli argument replaceValue jest funkcją, znalezione wystapienia tekstu są zamieniane na wartość, którą ona zwróci. W przeciwnym razie znalezione dopasowania są zamieniane na podany tekst. W takim przypadku niektóre znaki w tym teście mają specjalne znaczenie:

  • $$ - znak dolara $
  • $& - dopasowany fragment oryginalnego tekstu
  • $` - fragment tekstu znajdujący się przed dopasowaniem
  • $' - fragment tekstu znajdujący się po dopasowaniu
  • $n (n = 1...9), $nn (nn = 01...99) - odpowiednia część dopasowania, która w wyrażeniu była umieszczona w nawiasie o podanym numerze

Dość częstym błędem jest podanie pierwszego argumentu w postaci prostego tekstu albo wyrażenia regularnego bez flagi g i oczekiwanie, że w oryginalnym tekście zostaną zamienione wszystkie wystąpienia poszukiwanej frazy. Przypominam, że jedynym sposobem na wykonanie tego jest użycie wyrażenia regularnego o dopasowaniu globalnym (z ustawioną flagą g).

Przykład:

"abcd efg abc".replace("abc", "123");      // "123d efg abc"
"abcd efg abc".replace(/abc/, "123");      // "123d efg abc"
"abcd efg abc".replace(/abc/g, "123");     // "123d efg 123"
 
"ABCd efg abc".replace(/abc/i, "123");     // "123d efg abc"
"ABCd efg abc".replace(/abc/ig, "123");    // "123d efg 123"
 
var search = /((a)b)(c)/;
var replace = "$$[$`,$&,$',$1-$01,$2-$02,$3-$03]$$";
"123 abc 456".replace(search, replace);    // "123 $[123 ,abc, 456,ab-ab,a-a,c-c]$ 456"
 
replace = "[$&,$1,$2,$3]";
"ABC abc".replace(/((a)b)(c)/ig, replace); // "[ABC,AB,A,C] [abc,ab,a,c]"
 
replace = function (substring, capture1, capture2, capture3, offset, string) {
    return "[" + substring + "," + capture1 + "," + capture2 + "," + capture3 + "," + offset + "," + string + "]";
};
"123 abc 456".replace(search, replace);    // "123 [abc,ab,a,c,4,123abc456] 456"
String.prototype.search(regexp)
Parametry:
RegExp regexp - wyrażenie regularne
Wartość:
Number - pozycja pierwszego znalezionego dopasowania

Przeszukuje tekst pod kątem występowania w nim podanego wzorca - wyrażenia regularnego. Jeżeli tekst nie zostanie dopasowany, funkcja zwraca liczbę -1.

Przypominam, że pierwszy znak tekstu ma pozycję 0, a więc taka wartość zwrócona przez funkcję oznacza, że poszukiwany tekst został znaleziony (na samym początku).
Jeżeli chcesz znaleźć pozycję z góry znanej frazy w określony tekście, użyj funkcji String.prototype.indexOf.
Jeżeli chcesz tylko sprawdzić, czy określony tekst pasuje do wzorca - wyrażenia regularnego - użyj funkcji RegExp.prototype.test.

Przykład:

"abc def abc".search(/a[a-z]/); // 0
"abc def abc".search(/abc?/);  // 0
"abc def abc".search(/ABC?/i); // 0
 
"abc def abc".search(/ghi?/); // -1
"abc def abc".search(/ABC?/); // -1

slice

String.prototype.slice()
String.prototype.slice(start)
String.prototype.slice(start, end)
Parametry:
Number start - pozycja znaku początkowego (domyślnie: 0)
Number end - pozycja znaku po końcowym (domyślnie: długość tekstu)
Wartość:
String - wycięty tekst

Tworzy wycinek tekstu, składający się z kolejnych znaków poczynając od początkowego (na który wskazuje pozycja start) aż do końcowego (przed pozycją end).

  • Jeżeli do funkcji nie zostaną przekazane żadne argumenty, będzie zwrócony oryginalny tekst.
  • Jeżeli argument end nie zostanie podany, wycinek będzie zawierał wszystkie znaki od start do końca tekstu.
  • Jeżeli wartość argumentu będzie mniejsza od zera, odliczanie pozycji rozpocznie się od końca tekstu.

Ostatni sposób zachowania odróżnia tę funkcję od String.prototype.substring.

Przykład:

"abcd".slice();       // "abcd"
"abcd".slice(1);      // "bcd"
"abcd".slice(-2);     // "cd" == "abcd".slice(2)
"abcd".slice(1, 3);   // "bc"
"abcd".slice(1, -1);  // "bc" == "abcd".slice(1, 3)
"abcd".slice(-3, -1); // "bc" == "abcd".slice(1, 3)
 
"abcd".slice(0, 0);   // ""
"abcd".slice(1, 1);   // ""
"abcd".slice(3, 1);   // ""
"abcd".slice(-1, -2); // ""   == "abcd".slice(3, 2)

split

String.prototype.split()
String.prototype.split(separator)
String.prototype.split(separator, limit)
Parametry:
String|RegExp separator - znaki rozdzielające (domyślnie: undefined)
Number limit - maksymalna liczba elementów w tablicy wynikowej (domyślnie: 232 – 1)
Wartość:
Array - tablica zawierająca kawałki rozbitego tekstu

Rozbija podany tekst na tablicę mniejszych kawałków, z których każdy w oryginalnym tekście był rozdzielony od pozostałych określonym separatorem. Sam separator nie jest dołączany do wynikowej tablicy. Podanie separatora w postaci wyrażenia regularnego pozwala określić znaki rozdzielające kolejne kawałki tekstu w postaci ogólnego wzorca. Możemy np. pokawałkować tekst w miejscach wystąpienia w nim dowolnej cyfry. Działanie funkcji jest takie samo bez względu, czy wyrażenie regularne zawiera flagę g.

  • Jeżeli separator nie został podany albo ma wartość undefined, funkcja zwraca jednoelementową tablicę zawierającą pełny tekst oryginalny.
  • Jeżeli oryginalny tekst jest pusty, a separatorem jest również pusty tekst lub wyrażenie regularne dopasowujące pusty tekst, funkcja zwraca pustą tablicę.
  • Jeżeli oryginalny tekst jest pusty, ale separatorem nie jest pusty tekst ani wyrażenie regularne dopasowujące pusty tekst, funkcja zwraca jednoelementową tablicę zawierającą pusty tekst.
  • Jeżeli oryginalny tekst nie jest pusty, ale separatorem jest pusty tekst lub wyrażenie regularne dopasowujące pusty tekst, funkcja zwraca tablicę złożoną z kolejnych znaków oryginalnego tekstu.
  • Jeżeli oryginalny tekst rozpoczyna lub kończy się separatorem, funkcja zwraca tablicę, której odpowiednio pierwszym lub ostatnim elementem będzie pusty tekst.
  • Jeżeli separatorem jest wyrażenie regularne zawierające nawiasy, funkcja zwraca tablicę, która zawiera również części dopasowań, które w wyrażeniu znajdowały się w nawiasie. Jeżeli części w nawiasach nie zostaną dopasowane, w ich miejsce podstawiana jest wartość undefined.

Podanie argumentu limit pozwala ustalić, maksymalnie ile elementów będzie zawierać tablica wynikowa. Ewentualne dalsze kawałki tekstu już się w niej nie znajdą.

Przykład:

"abc".split();           // ["abc"]
"".split();              // [""]
"".split("");            // []
"".split(/a?/);          // []
"".split("a");           // [""]
"".split(/a/);           // [""]
"abc".split("");         // ["a", "b", "c"]
"abc".split(/a?/);       // ["a", "b", "c"]
"abc".split("a");        // ["", "bc"]
"abcba".split("b");      // ["a", "c", "a"]
"abc".split("c");        // ["ab", ""]
"abcba".split(/b/);      // ["a", "c", "a"]
"abcdba".split(/b(c)?/); // ["a", "c", "d", undefined, "a"]

substring

String.prototype.substring()
String.prototype.substring(start)
String.prototype.substring(start, end)
Parametry:
Number start - pozycja znaku początkowego (domyślnie: 0)
Number end - pozycja znaku po końcowym (domyślnie: długość tekstu)
Wartość:
String - wycięty tekst

Tworzy wycinek tekstu, składający się z kolejnych znaków poczynając od początkowego (na który wskazuje pozycja start) aż do końcowego (przed pozycją end).

  • Jeżeli do funkcji nie zostaną przekazane żadne argumenty, będzie zwrócony oryginalny tekst.
  • Jeżeli argument end nie zostanie podany, wycinek będzie zawierał wszystkie znaki od start do końca tekstu.
  • Jeżeli wartość argumentu będzie mniejsza od zera, przyjmowana jest pozycja 0.
  • Jeżeli wartość start jest większa niż end, argumenty są zamieniane miejscami i następuje wycięcie tekstu od pozycji end do znaku przed pozycją start.

Dwa ostatnie sposoby zachowania odróżniają tę funkcję od String.prototype.slice.

Przykład:

"abcd".substring();       // "abcd"
"abcd".substring(1);      // "bcd"
"abcd".substring(-2);     // "abcd"
"abcd".substring(1, 3);   // "bc"
"abcd".substring(3, 1);   // "bc" == "abcd".substring(1, 3)
"abcd".substring(1, -1);  // "a"  == "abcd".substring(0, 1)
 
"abcd".substring(0, 0);   // ""
"abcd".substring(1, 1);   // ""
"abcd".substring(-3, -1); // ""   == "abcd".substring(0, 0)
"abcd".substring(-1, -2); // ""   == "abcd".substring(0, 0)

toLowerCase

String.prototype.toLowerCase()
Wartość:
String - tekst zapisany małymi literami

Zamienia w teście wszystkie wielkie litery na ich małe odpowiedniki.

Ta funkcja może nie działać prawidłowo dla alfabetu domyślnego języka systemu operacyjnego użytkownika (dla języka polskiego działa poprawnie). W takim przypadku użyj String.prototype.toLocaleLowerCase.

Przykład:

var str = "AĄBCĆDEĘFGHIJKLŁMNŃOÓPQRSŚTUVWXYZŹŻ";
str.toLowerCase();         // "aąbcćdeęfghijklłmnńoópqrsśtuvwxyzźż"
"AbcQX 123".toLowerCase(); // "abcqx 123"

toLocaleLowerCase

String.prototype.toLocaleLowerCase()
Wartość:
String - tekst zapisany małymi literami

Działa tak samo jak String.prototype.toLowerCase, ale uwzględnia alfabet domyślnego języka systemu operacyjnego użytkownika.

Przykład:

var str = "AĄBCĆDEĘFGHIJKLŁMNŃOÓPQRSŚTUVWXYZŹŻ";
str.toLocaleLowerCase();         // np.: "aąbcćdeęfghijklłmnńoópqrsśtuvwxyzźż"
"AbcQX 123".toLocaleLowerCase(); // np.: "abcqx 123"

toUpperCase

String.prototype.toUpperCase()
Wartość:
String - tekst zapisany wielkimi literami

Zamienia w teście wszystkie małe litery na ich wielkie odpowiedniki.

Ta funkcja może nie działać prawidłowo dla alfabetu domyślnego języka systemu operacyjnego użytkownika (dla języka polskiego działa poprawnie). W takim przypadku użyj String.prototype.toLocaleUpperCase.

Przykład:

var str = "aąbcćdeęfghijklłmnńoópqrsśtuvwxyzźż";
str.toUpperCase();         // "AĄBCĆDEĘFGHIJKLŁMNŃOÓPQRSŚTUVWXYZŹŻ"
"Abcqx 123".toUpperCase(); // "ABCQX 123"

toLocaleUpperCase

String.prototype.toLocaleUpperCase()
Wartość:
String - tekst zapisany małymi literami

Działa tak samo jak String.prototype.toUpperCase, ale uwzględnia alfabet domyślnego języka systemu operacyjnego użytkownika.

Przykład:

var str = "aąbcćdeęfghijklłmnńoópqrsśtuvwxyzźż";
str.toLocaleUpperCase();         // np.: "AĄBCĆDEĘFGHIJKLŁMNŃOÓPQRSŚTUVWXYZŹŻ"
"Abcqx 123".toLocaleUpperCase(); // np.: "ABCQX 123"

trim

(interpretuje: Internet Explorer 9, Firefox 3.5, Opera 10.50, Chrome)

String.prototype.trim()
Wartość:
String - nowy tekst

Usuwa wszystkie ewentualne białe znaki oraz znaki końca linii, znajdujące się na początku i na końcu tekstu.

Białymi znakami są:

  • tabulacja ("\u0009" lub "\t")
  • pionowa tabulacja ("\u000B" lub "\v")
  • nowa strona ("\u000C" lub "\f")
  • spacja ("\u0020" lub " ")
  • niełamliwa spacja ("\u00A0")
  • BOM ("\uFEFF")
  • wszystkie inne znaki spacji w systemie Unicode

Znakami końca linii są:

  • następna linia ("\u000A" lub "\n")
  • powrót karetki ("\u000D" lub "\r")
  • separator linii ("\u2028")
  • separator akapitów ("\u2029")

Przykład:

"\t A B C\r\n".trim(); // "A B C"