• 
  Konstruktor obiektu tekstowego - constructor

  Gdzie jest zapisany konstruktor obiekt tekstowego?

• 
  Konwersja obiektu tekstowego - toString

  Jak zamienić obiekt tekstowy na prosty tekst, który można wyświetlić użytkownikowi?

• 
  Prosta wartość tekstowa - valueOf

  Jak zamienić obiekt tekstowy na prostą wartość tekstową?

• 
  Pobieranie znaku - charAt

  Jak pobrać określony znak tekstu?

• 
  Kod liczbowy znaku - charCodeAt

  Jak pobrać kod liczbowy określonego znaku w tekście?

• 
  Łączenie tekstów - concat

  Jak połączyć dwa teksty w jeden?

• 
  Wyszukiwanie frazy - indexOf

  W jaki sposób wyszukać określoną frazę w tekście?

• 
  Ostatnie wystąpienie frazy - lastIndexOf

  W jaki sposób znaleźć ostatnie wystąpienie podanej frazy w tekście?

• 
  Porównanie lokalne - localeCompare

  W jaki sposób ułożyć tekst w porządku alfabetycznym uwzględniając polskie znaki diakrytyczne?

• 
  Dopasowanie wzorca - match

  Jak sprawdzić, czy tekst pasuje do złożonego wzorca (wyrażenia regularnego)?

• 
  Zamiana fraz - replace

  Co zrobić, aby zamienić w tekście wszystkie wystąpienia podanej frazy na inną?

• 
  Wyszukiwanie wzorca - search

  Jak wyszukać w tekście złożonego wzorca (wyrażenia regularnego)?

• 
  Wycinanie tekstu - slice

  W jaki sposób wyciąć z tekstu jego część?

• 
  Rozbijanie tekstu - split

  Jak rozbić tekst na tablicę elementów?

• 
  Fragment tekstu - substring

  Jak wyciąć z tekstu krótki fragment?

• 
  Zmiana na małe litery - toLowerCase

  Jak zamienić tekst na małe litery?

• 
  Lokalna zmiana na małe litery - toLocaleLowerCase

  Jak zamienić tekst na małe litery uwzględniając język polski?

• 
  Zmiana na wielkie litery - toUpperCase

  Jak zamienić tekst na wielkie litery?

• 
  Lokalna zmiana na wielkie litery - toLocaleUpperCase

  Jak zamienić tekst na wielkie litery uwzględniając język polski?

• 
  Usuwanie białych znaków - trim

  Jak usunąć niepotrzebne białe znaki na początku i na końcu tekstu?

String.prototype.constructor

Wartość:

Function - konstruktor obiektu

Zawiera konstruktor wbudowanego obiektu tekstowego String.

Przykład String.prototype.constructor

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

String.prototype.toString()

Działa identycznie jak funkcja String.prototype.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 String.prototype.valueOf

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

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 String.prototype.charAt

"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);            // ""

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 String.prototype.charCodeAt

"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

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 String.prototype.concat

"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"

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 String.prototype.indexOf

"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

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 String.prototype.lastIndexOf

"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

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 String.prototype.localeCompare

"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", "ź", "Ź", "ż", "Ż"]

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 String.prototype.match

"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

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 String.prototype.replace

"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 String.prototype.search

"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

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 String.prototype.slice

"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)

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: 2³² – 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 String.prototype.split

"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"]

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 String.prototype.substring

"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)

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 String.prototype.toLowerCase

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"

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 String.prototype.toLocaleLowerCase

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"

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 String.prototype.toUpperCase

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"

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 String.prototype.toLocaleUpperCase

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"

(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 String.prototype.trim

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