Our volunteers haven't translated this article into Bamanankan yet. Join us and help get the job done!
You can also read the article in English (US).

The String global object is a constructor for strings or a sequence of characters.

Syntax

String literals take the forms:

'string text'
"string text"
"中文 español deutsch English देवनागरी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어 தமிழ் עברית"

Strings can also be created using the String global object directly:

String(thing)

Parameters

thing
Anything to be converted to a string.

Template literals

Starting with ECMAScript 2015, string literals can also be so-called Template literals:

`hello world`
`hello!
 world!`
`hello ${who}`
escape `<a>${who}</a>`

Escape notation

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

Code Output
\0 the NULL 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
\u{X} ... \u{XXXXXX} unicode codepoint
\xXX the Latin-1 character

Unlike some other languages, JavaScript makes no distinction between single-quoted strings and double-quoted strings; therefore, the escape sequences above work in strings created with either single or double quotes.

Long literal strings

Sometimes, your code will include strings which are very long. Rather than having lines that go on endlessly, or wrap at the whim of your editor, you may wish to specifically break the string into multiple lines in the source code without affecting the actual string contents. There are two ways you can do this.

You can use the + operator to append multiple strings together, like this:

let longString = "This is a very long string which needs " +
                 "to wrap across multiple lines because " +
                 "otherwise my code is unreadable.";

Or you can use the backslash character ("\") at the end of each line to indicate that the string will continue on the next line. Make sure there is no space or any other character after the backslash (except for a line break), or as an indent; otherwise it will not work. That form looks like this:

let longString = "This is a very long string which needs \
to wrap across multiple lines because \
otherwise my code is unreadable.";

Both of these result in identical strings being created.

Description

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

Character access

There are two ways to access an individual character in a string. The first is the 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 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
  console.log(a + ' is less than ' + b);
} else if (a > b) {
  console.log(a + ' is greater than ' + b);
} else {
  console.log(a + ' and ' + b + ' are equal.');
}

A similar result can be achieved using the 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 Boolean and 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 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 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, the 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 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.

Properties

String.prototype
Allows the addition of properties to a String object.

Methods

String.fromCharCode()
Returns a string created by using the specified sequence of Unicode values.
String.fromCodePoint()
Returns a string created by using the specified sequence of code points.
String.raw()
Returns a string created from a raw template string.

String generic methods

String generics are non-standard, deprecated and will get removed near future.

The String instance methods are also available in Firefox as of JavaScript 1.6 (not part of the ECMAScript standard) on the String object for applying String methods to any object:

var num = "15";
console.log(num.replace("5", "2"));

For migrating away from String generics, see also Warning: String.x is deprecated; use String.prototype.x instead.

Generics are also available on Array methods.

String instances

Properties

String.prototype.constructor
Specifies the function that creates an object's prototype.
String.prototype.length
Reflects the length of the string.
N
Used to access the character in the Nth position where N is a positive integer between 0 and one less than the value of length. These properties are read-only.

Methods

Methods unrelated to HTML

String.prototype.charAt()
Returns the character (exactly one UTF-16 code unit) at the specified index.
String.prototype.charCodeAt()
Returns a number that is the UTF-16 code unit value at the given index.
String.prototype.codePointAt()
Returns a nonnegative integer Number that is the code point value of the UTF-16 encoded code point starting at the specified index.
String.prototype.concat()
Combines the text of two strings and returns a new string.
String.prototype.includes()
Determines whether one string may be found within another string.
String.prototype.endsWith()
Determines whether a string ends with the characters of another string.
String.prototype.indexOf()
Returns the index within the calling String object of the first occurrence of the specified value, or -1 if not found.
String.prototype.lastIndexOf()
Returns the index within the calling String object of the last occurrence of the specified value, or -1 if not found.
String.prototype.localeCompare()
Returns a number indicating whether a reference string comes before or after or is the same as the given string in sort order.
String.prototype.match()
Used to match a regular expression against a string.
String.prototype.normalize()
Returns the Unicode Normalization Form of the calling string value.
String.prototype.padEnd()
Pads the current string from the end with a given string to create a new string from a given length.
String.prototype.padStart()
Pads the current string from the start with a given string to create a new string from a given length.
String.prototype.quote()
Wraps the string in double quotes (""").
String.prototype.repeat()
Returns a string consisting of the elements of the object repeated the given times.
String.prototype.replace()
Used to find a match between a regular expression and a string, and to replace the matched substring with a new substring.
String.prototype.search()
Executes the search for a match between a regular expression and a specified string.
String.prototype.slice()
Extracts a section of a string and returns a new string.
String.prototype.split()
Splits a String object into an array of strings by separating the string into substrings.
String.prototype.startsWith()
Determines whether a string begins with the characters of another string.
String.prototype.substr()
Returns the characters in a string beginning at the specified location through the specified number of characters.
String.prototype.substring()
Returns the characters in a string between two indexes into the string.
String.prototype.toLocaleLowerCase()
The characters within a string are converted to lower case while respecting the current locale. For most languages, this will return the same as toLowerCase().
String.prototype.toLocaleUpperCase()
The characters within a string are converted to upper case while respecting the current locale. For most languages, this will return the same as toUpperCase().
String.prototype.toLowerCase()
Returns the calling string value converted to lower case.
String.prototype.toSource()
Returns an object literal representing the specified object; you can use this value to create a new object. Overrides the Object.prototype.toSource() method.
String.prototype.toString()
Returns a string representing the specified object. Overrides the Object.prototype.toString() method.
String.prototype.toUpperCase()
Returns the calling string value converted to uppercase.
String.prototype.trim()
Trims whitespace from the beginning and end of the string. Part of the ECMAScript 5 standard.
String.prototype.trimStart()
String.prototype.trimLeft()
Trims whitespace from the beginning of the string.
String.prototype.trimEnd()
String.prototype.trimRight()
Trims whitespace from the end of the string.
String.prototype.valueOf()
Returns the primitive value of the specified object. Overrides the Object.prototype.valueOf() method.
String.prototype[@@iterator]()
Returns a new Iterator object that iterates over the code points of a String value, returning each code point as a String value.

HTML wrapper methods

Examples

String conversion

It's possible to use String as a more reliable toString() alternative, as it works when used on null, undefined, and on symbols. For example:

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

Specifications

Specification Status Comment
ECMAScript 1st Edition (ECMA-262) Standard Initial definition.
ECMAScript 5.1 (ECMA-262)
The definition of 'String' in that specification.
Standard  
ECMAScript 2015 (6th Edition, ECMA-262)
The definition of 'String' in that specification.
Standard  
ECMAScript Latest Draft (ECMA-262)
The definition of 'String' in that specification.
Draft  

Browser compatibility

FeatureChromeEdgeFirefoxInternet ExplorerOperaSafari
@@iterator Yes Yes

36

27 — 361 2

17 — 273 4

No No No
String Yes Yes1 Yes Yes Yes
String: Unicode code point escapes \u{xxxxxx} Yes ?40 ? Yes Yes
anchor Yes Yes15 No Yes Yes
big Yes Yes1 Yes Yes Yes
blink Yes Yes1 Yes Yes Yes
bold Yes Yes1 Yes Yes Yes
charAt Yes Yes1 Yes Yes Yes
charCodeAt Yes Yes1 Yes Yes Yes
codePointAt41 Yes29 No2810
concat Yes Yes1 Yes Yes Yes
endsWith41 Yes17 No289
fixed Yes Yes1 Yes Yes Yes
fontcolor Yes Yes1 Yes Yes Yes
fontsize Yes Yes1 Yes Yes Yes
fromCharCode Yes Yes1 Yes Yes Yes
fromCodePoint41 Yes29 No2810
includes41 Yes

40

18 — 486

No Yes9
indexOf Yes Yes1 Yes Yes Yes
italics Yes Yes1 Yes Yes Yes
lastIndexOf Yes Yes16 Yes Yes
length Yes Yes1 Yes Yes Yes
link Yes Yes1 Yes Yes Yes
localeCompare Yes Yes1 Yes Yes Yes
localeCompare.locales24 Yes29111510
localeCompare.options24 Yes29111510
match Yes Yes1 Yes Yes Yes
match.flags No No1 — 49 No No No
normalize34 Yes31 No Yes10
padEnd571548 No4410
padStart571548 No4410
prototype Yes Yes1 Yes Yes Yes
quote No No1 — 37 No No No
raw41 Yes34 No No10
repeat41 Yes24 No Yes9
replace Yes Yes1 Yes Yes Yes
replace.flags No No1 — 49 No No No
search Yes Yes1 Yes Yes Yes
search.flags No No1 — 49 No No No
slice Yes Yes1 Yes Yes Yes
small Yes Yes1 Yes Yes Yes
split Yes Yes1 Yes Yes Yes
startsWith41 Yes17 No289
strike Yes Yes1 Yes Yes Yes
sub Yes Yes1 Yes Yes Yes
substr Yes Yes1 Yes Yes Yes
substring Yes Yes1 Yes Yes Yes
sup Yes Yes1 Yes Yes Yes
toLocaleLowerCase Yes Yes1 Yes Yes Yes
toLocaleLowerCase.locale ? ?55 ? ? ?
toLocaleUpperCase Yes Yes1 Yes Yes Yes
toLocaleUpperCase.locale ? ?55 ? ? ?
toLowerCase Yes Yes1 Yes Yes Yes
toSource No No1 No No No
toString Yes Yes1 Yes Yes Yes
toUpperCase Yes Yes1 Yes Yes Yes
trim Yes Yes3.5910.55
trimEnd

66

Yes7

?

61

3.57

No53 ?
trimStart

66

Yes8

?

61

3.58

No53 ?
valueOf Yes Yes1 Yes Yes Yes
FeatureAndroid webviewChrome for AndroidEdge mobileFirefox for AndroidOpera AndroidiOS SafariSamsung Internet
@@iterator No No ?

36

27 — 361 2

17 — 273 4

No No No
String Yes Yes Yes4 Yes Yes Yes
String: Unicode code point escapes \u{xxxxxx} Yes Yes ?40 Yes Yes Yes
anchor Yes Yes Yes4 Yes Yes Yes
big Yes Yes Yes4 Yes Yes Yes
blink Yes Yes Yes4 Yes Yes Yes
bold Yes Yes Yes4 Yes Yes Yes
charAt Yes Yes Yes4 Yes Yes Yes
charCodeAt Yes Yes Yes4 Yes Yes Yes
codePointAt Yes Yes Yes29 Yes10 Yes
concat Yes Yes Yes4 Yes Yes Yes
endsWith Yes36 Yes17 Yes9 Yes
fixed Yes Yes Yes4 Yes Yes Yes
fontcolor Yes Yes Yes4 Yes Yes Yes
fontsize Yes Yes Yes4 Yes Yes Yes
fromCharCode Yes Yes Yes4 Yes Yes Yes
fromCodePoint Yes Yes Yes29 Yes10 Yes
includes Yes Yes Yes

40

18 — 486

Yes9 Yes
indexOf Yes Yes Yes4 Yes Yes Yes
italics Yes Yes Yes4 Yes Yes Yes
lastIndexOf Yes Yes Yes4 Yes Yes Yes
length Yes Yes Yes4 Yes Yes Yes
link Yes Yes Yes4 Yes Yes Yes
localeCompare Yes Yes Yes4 Yes Yes Yes
localeCompare.locales No26 ? No No10 Yes
localeCompare.options No26 ? No No10 Yes
match Yes Yes Yes4 Yes Yes Yes
match.flags No No No4 — 49 No No No
normalize No34 Yes31 Yes10 Yes
padEnd5757 Yes4844107.0
padStart5757 Yes4844107.0
prototype Yes Yes Yes4 Yes Yes Yes
quote No No No4 — 37 No No No
raw No41 Yes34 No104.0
repeat No36 Yes24 Yes9 Yes
replace Yes Yes Yes4 Yes Yes Yes
replace.flags No No No4 — 49 No No No
search Yes Yes Yes4 Yes Yes Yes
search.flags No No No4 — 49 No No No
slice Yes Yes Yes4 Yes Yes Yes
small Yes Yes Yes4 Yes Yes Yes
split Yes Yes Yes4 Yes Yes Yes
startsWith Yes36 Yes17 Yes9 Yes
strike Yes Yes Yes4 Yes Yes Yes
sub Yes Yes Yes4 Yes Yes Yes
substr Yes Yes Yes4 Yes Yes Yes
substring Yes Yes Yes4 Yes Yes Yes
sup Yes Yes Yes4 Yes Yes Yes
toLocaleLowerCase Yes Yes Yes4 Yes Yes Yes
toLocaleLowerCase.locale ? ? ?55 ? ? ?
toLocaleUpperCase Yes Yes Yes4 Yes Yes Yes
toLocaleUpperCase.locale ? ? ?55 ? ? ?
toLowerCase Yes Yes Yes4 Yes Yes Yes
toSource No No No4 No No No
toString Yes Yes Yes4 Yes Yes Yes
toUpperCase Yes Yes Yes4 Yes Yes Yes
trim Yes Yes Yes4 Yes Yes Yes
trimEnd

66

Yes7

66

Yes7

?

61

47

53 ? ?
trimStart

66

Yes8

66

Yes8

?

61

48

53 ? ?
valueOf Yes Yes Yes4 Yes Yes Yes

1. A placeholder property named @@iterator is used.

2. Supported as @@iterator.

3. A placeholder property named iterator is used.

4. Supported as iterator.

5. Starting with version 17, the quotation mark (") is replaced by its HTML reference character (") in strings supplied for the name parameter.

6. Supported as contains.

7. Supported as trimRight.

8. Supported as trimLeft.

See also