--- title: String slug: Web/JavaScript/Reference/Global_Objects/String tags: - JavaScript - String translation_of: Web/JavaScript/Reference/Global_Objects/String original_slug: Web/JavaScript/Referencje/Obiekty/String ---

Podsumowanie

Tworzy obiekt pozwalający działać na ciągach znaków.

Składnia

Literały znakowe są postaci:

'string text'
"string text"
"中文 español English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어 தமிழ்"

Beside regular, printable characters, special characters can be encoded using escape notation:

Code	Output
`\0`	the NUL character
`\'`	single quote
`\"`	double quote
`\\`	backslash
`\n`	new line
`\r`	carriage return
`\v`	vertical tab
`\t`	tab
`\b`	backspace
`\f`	form feed
`\uXXXX`	unicode codepoint
`\xXX`	the Latin-1 character

Or, using the String global object directly:

String(thing)
new String(thing)

Parametry

thing: Dowolny łańcuch znaków.

Opis

trings are useful for holding data that can be represented in text form. Some of the most-used operations on strings are to check their {{jsxref("String.length", "length")}}, to build and concatenate them using the + and += string operators, checking for the existence or location of substrings with the {{jsxref("String.prototype.indexOf()", "indexOf()")}} method, or extracting substrings with the {{jsxref("String.prototype.substring()", "substring()")}} method.

Character access

There are two ways to access an individual character in a string. The first is the {{jsxref("String.prototype.charAt()", "charAt()")}} method:

return 'cat'.charAt(1); // returns "a"

The other way (introduced in ECMAScript 5) is to treat the string as an array-like object, where individual characters correspond to a numerical index:

return 'cat'[1]; // returns "a"

For character access using bracket notation, attempting to delete or assign a value to these properties will not succeed. The properties involved are neither writable nor configurable. (See {{jsxref("Object.defineProperty()")}} for more information.)

Comparing strings

C developers have the strcmp() function for comparing strings. In JavaScript, you just use the less-than and greater-than operators:

var a = 'a';
var b = 'b';
if (a < b) { // true
  print(a + ' is less than ' + b);
} else if (a > b) {
  print(a + ' is greater than ' + b);
} else {
  print(a + ' and ' + b + ' are equal.');
}

A similar result can be achieved using the {{jsxref("String.prototype.localeCompare()", "localeCompare()")}} method inherited by String instances.

Distinction between string primitives and `String` objects

Note that JavaScript distinguishes between String objects and primitive string values. (The same is true of {{jsxref("Global_Objects/Boolean", "Boolean")}} and {{jsxref("Global_Objects/Number", "Numbers")}}.)

String literals (denoted by double or single quotes) and strings returned from String calls in a non-constructor context (i.e., without using the {{jsxref("Operators/new", "new")}} keyword) are primitive strings. JavaScript automatically converts primitives to String objects, so that it's possible to use String object methods for primitive strings. In contexts where a method is to be invoked on a primitive string or a property lookup occurs, JavaScript will automatically wrap the string primitive and call the method or perform the property lookup.

var s_prim = 'foo';
var s_obj = new String(s_prim);

console.log(typeof s_prim); // Logs "string"
console.log(typeof s_obj);  // Logs "object"

String primitives and String objects also give different results when using {{jsxref("Global_Objects/eval", "eval()")}}. Primitives passed to eval are treated as source code; String objects are treated as all other objects are, by returning the object. For example:

var s1 = '2 + 2';             // creates a string primitive
var s2 = new String('2 + 2'); // creates a String object
console.log(eval(s1));        // returns the number 4
console.log(eval(s2));        // returns the string "2 + 2"

For these reasons, code may break when it encounters String objects when it expects a primitive string instead, although generally authors need not worry about the distinction.

A String object can always be converted to its primitive counterpart with the {{jsxref("String.prototype.valueOf()", "valueOf()")}} method.

console.log(eval(s2.valueOf())); // returns the number 4

Note: For another possible approach to strings in JavaScript, please read the article about StringView — a C-like representation of strings based on typed arrays.

Własności

{{jsxref("String.prototype")}}: Pozwala na dodawanie własności do obiektu String.

Metody

{{jsxref("String.fromCharCode()")}}: Zwraca łańcuch znaków stworzony przez podaną sekwencję kodów Unicode.
{{jsxref("String.fromCodePoint()")}} {{experimental_inline}}: Returns a string created by using the specified sequence of code points.
{{jsxref("String.raw()")}} {{experimental_inline}}: Returns a string created from a raw template string.

{{jsOverrides("Function", "Methods", "fromCharCode", "fromCodePoint", "raw")}}

Przykłady

Example: String conversion

It's possible to use String as a "safer" {{jsxref("String.prototype.toString()", "toString()")}} alternative, as although it still normally calls the underlying toString(), it also works for {{jsxref("null")}} and {{jsxref("undefined")}}. For example:

var outputStrings = [];
for (var i = 0, n = inputValues.length; i < n; ++i) {
  outputStrings.push(String(inputValues[i]));
}