End of line javascript character. Standard Methods of the String Object

This article will discuss what is strings in javascript and how to work with them.

Strings are just groups of characters like "JavaScript", "Hello world!" ', 'http://www.quirksmode.org' or even '14'. To program in JavaScript, you need to know what strings are and how to work with them, because you will use them very often. Many things like URL pages, values CSS options and form input elements are all strings.

I'll try to explain first working with strings, then the difference between in JavaScript. Even if you have programming experience in another language, read this part carefully. At the end I will talk about the most important strings in JavaScript.

String Basics

Let's look at the basics of working with strings in JavaScript.

Using quotes

When you announce strings in javascript or work with them, always enclose them in single or double quotes. This tells the browser that it is dealing with a string. Don't mix quotes in your code, if you start a string with a single quote and end with a double quote, JavaScript won't understand what you mean. As a rule, I use single quotes for strings, because I chose to use double quotes for HTML and single quotes for JavaScript. Of course, you can do everything differently, but I advise you to come up with a similar rule for yourself.

Let's imagine two lines that we will use throughout the article:

Var a = "Hello world!"; var b = "I am a student.";

We have now declared two variables, "a" and "b", and assigned string values ​​to them. After that, we can work with them, but first we solve one problem: let's say I wrote:

Varb = "I"m a student.";

The string contains an extra single quote, and JavaScript thinks the string has ended and prints an error message without knowing what's next. Therefore you need escape quote, telling the browser to treat it as a character and not as a line ending. This is done by using a "backslash" before the quote:

Varb = "I\"m a student.";

Note that you can insert double quotes into a string without escaping them. Since you are using single quotes as the beginning and end of the string,

Varb = "I\"m a "student.";

accepted without problems. Double quotes are automatically treated as part of a string, not a command.

Built-in Functions

Once the strings are defined, you can start using them. For example, you can connect one line to another, or take a substring from the string "b", consisting of the second-fourth characters and insert them in the middle of the string "a", or determine which character is the twelfth in "a", how many characters are in "b", whether they contain the letter " q", etc.

To do this, you can use the built-in functions that JavaScript predefines for each line. One of them - "length" - returns the length of the string. That is, if you want to calculate the length of "Hello world!", write:

Var c = "Hello world!".length;

Earlier we assigned this string to the variable "a". So you have made the variable "a" a string, so the "length" function applies to it too, and the following operation will give the same result:

varc = a.length;

Remember that you can use "length" on any string - this is a built-in function. You can calculate the length of any string, for example: " location.href " or " document. title " or declared by you.

Below I will provide a list of common built-in methods and properties.

Strings and numbers

Some programming languages ​​require you to specify whether a variable is a number or a string before doing anything else with it. JavaScript is easier refers to the difference between strings and numbers. In fact, you can even add numbers to strings:

Var c = a + 12;

In some programming languages, processing such a string will result in an error. Still, "a" is a string, and "12" is a number. However, JavaScript tries to solve the problem by assuming that "12" is also a string. Thus "c" takes on the value "Hello world!12". So if you use "+" with a string and a number, JavaScript tries to make a string out of the number. If you apply mathematical operations to a string, JavaScript tries to turn it into a number. In the absence of the possibility of translating a string into a number (for example, due to the presence of letters in it), JavaScript returns NaN - "Not a Number - is not a number."

Finally, in JavaScript there is no difference between integers and floating point numbers.

Number → string

For number to string conversion enter:

Var c = (16 * 24) / 49 + 12; d = c.toString();

After that, you can apply all string methods to " d ", and " c " still contains a number.

string → number

If you want to convert a string to a number, first make sure it only consists of the characters 0-9 . To do this, I simply multiply the string by 1 .

Var c = "1234"; d = c * 1;

Since multiplication is only done with numbers, JavaScript turns the string into a number if possible. Otherwise, the result is NaN .

Notice if we write:

Var c = "1234"; d = c + 0;

The result will be " 12340 " because JavaScript uses "+" to concatenate strings, not add strings.

String properties and methods

So what can we do with strings? Association is a special case, but all other commands (methods) can be used with any string using the construction:

string_name.method();

List of built-in JavaScript methods for manipulating strings

Concatenation - concatenation of strings

First, you can concatenate strings by adding them together, like so:

Document.write(a+b);

the result will be: “ Hello world! I am a student. ". But of course you want a space between sentences. To do this, write the code as follows:

Document.write(a + " " + b);

This will concatenate three strings: "a", "" "" (one space) and "b", resulting in: "Hello world! I am a student. »

You can even use numbers or calculations, for example:

Document.write(a+3*3+b);

Now we concatenate the string "a", then the result of the expression "3 * 3", treated as a string, and "b", getting: "Hello world!9 I am a student. »

You need to be careful when using addition. Team

Document.write(a + 3 + 3 + b);

connects 4 strings: "a", "3", "3" and "b", because "+" in this case means "join strings", not "add" and the result is: "Hello world!33 I am a student. ". If you want to add 3 and 3 before creating a string, use parentheses.

Document.write(a+(3+3)+b);

This expression connects the string "a", the result of the expression "3 + 3" and "b", resulting in: "Hello world!6 I am a student. ".

indexOf

One of the most widely used built-in methods is "indexOf". Each character has its own index containing the number of its position in the string. Note that the index of the first character is 0, the second is 1, and so on. Thus, the index of the character "w" in the term "a" is 6.

Using "indexOf" we can output the character index. Write " .indexOf(" ") " after the line name and insert the character you are looking for between the quotes. For instance:

Var a = "Hello world!"; document.write(a.indexOf("w"));

will return 6 . If the character occurs multiple times, this method returns the first occurrence. That is

Document.write(a.indexOf("o"));

will return 4 because that is the index of the first "o" in the string.

You can also search for a combination of characters. (Of course, this is also a string, but to avoid confusion, I will not call it that). "indexOf" returns the position of the first character of the combination. For instance:

Document.write(a.indexOf("o w"));

will also return 4 because that's the index "o".

Moreover, it is possible to search for a character after a certain index. If you enter

Document.write(a.indexOf("o", 5));

then get the index of the first "o" following the character at index 5 (that's a space), i.e. the result will be - 7 .

If the character or combination does not occur in the string, "indexOf" will return "-1". This is, in fact, the most popular use of "indexOf": checking for the existence certain combination characters. It is the core of the script that defines the browser. To define IE you take the line:

Navigator.userAgent;

and check if it contains "MSIE":

If(navigator.userAgent.indexOf("MSIE") != -1) ( //Do something with Internet Explorer }

If the index " MSIE " is not " -1 " (if " MSIE " occurs anywhere in the string), then current browser— IE.

lastIndexOf

There is also a "lastIndexOf" method that returns the last occurrence of a character or combination. It acts opposite of "indexOf". Team

Var b = "I am a student."; document.write(b.lastIndexOf("t"));

will return 13 because that is the index of the last "t" in the string.

charAt

The "charAt" method returns the character at the specified position. For example, when you enter

Var b = "I am a student."; document.write(b.charAt(5));

the result is "a" since that's the character in the sixth position (remember that the index of the first character starts at 0).

length

The "length" method returns the length of the string.

Var b = "I am a student."; document.write(b.length);

will return "15". The length of the string is 1 more than the index of the last character.

split

"split" is special method A that allows you to split a string on specific characters. Used when the result needs to be stored in an array rather than a simple variable. Let's split " b " by spaces:

Var b = "I am a student." var temp = new Array(); temp = b.split(" ");

The string is now split into 4 substrings, which are placed in the "temp" array. The gaps have disappeared.

Temp="I"; temp="am"; temp="a"; temp="student";

The "substring" method is used to extract part of a string. Method syntax: " .substring(first_index, last_index) ". For instance:

Var a = "Hello world!"; document.write(a.substring(4, 8));

will return "o wo", from the first "o" (index 4) to the second (index 7). Note that "r" (index 8) is not part of the substring.

You can also write:

Var a = "Hello world!"; document.write(a.substring(4));

This will give the whole substring "o world! ” starting from the character at index 4 to the end of the string.

substr

There is also a "substr" method that works a little differently. It does not use the index number as the second argument, but the number of characters. That is

Document.write(a.substr(4, 8));

returns 8 characters starting from the character with index 4 ("o"), that is, the result is: "o world! »

toLowerCase and toUpperCase

Finally, 2 methods that may come in handy sometimes: "toLowerCase" converts the entire string to lowercase, and "toUpperCase" to uppercase.

Var b = "I am a student."; document.write(b.toUpperCase());

The result is “I AM A STUDENT. ".

As semantic "frameworks" for the use of functions and constructions for processing strings, they are of particular interest for programming information processing processes according to its semantic content. On the tongue JavaScript functions operations with strings can be combined into their own semantic constructions, simplifying the code and formalizing the subject area of ​​the problem.

In the classical version, information processing is, first of all, string functions. Each feature and construct of the language has its own characteristics in the syntax and semantics of JavaScript. The string methods here have their own style, but in common use it's just syntax within simple semantics: search, replace, insert, extract, content, change case...

Description of string variables

The construction is used to declare a string var. You can immediately set its value or form it during the execution of the algorithm. You can use single or double quotes for a string. If it should contain a quote, it must be escaped with the "\" character.

The string denoted requires escaping the inner double quotes. Similarly, the one indicated by single quotes is critical to the presence of single quotes inside.

V this example the string "str_dbl" lists useful special characters that can be used in the string. In this case, the "\" character itself is escaped.

A string is always an array

JavaScript's work with strings can be done in many ways. The syntax of the language provides many options. First of all, one should never forget that (in the context of the descriptions made):

• str_isV => "V";
• str_chr => """;
• str_dbl => "a".

That is, the characters of the string are available as array elements, with each special character is one character. Escaping is an element of syntax. No "screen" is placed in a real line.

Using the charAt() function has a similar effect:

• str_isV.charAt(3) => "V";
• str_chr.charAt(1) => """;
• str_dbl.charAt(5) => "a".

The programmer can use either option.

Basic string functions

JavaScript is done a little differently than other languages. The name of the function is written to the name of the variable (or directly to the string) separated by a dot. Usually inline functions are named methods in the style of the syntax of the language, but the first word is more familiar.

The most important method of a string (more correctly, a property) is its length.

• var xStr = str_isV.length + "/" + str_chr.length + "/" + str_dbl.length.

Result: 11/12/175 on the lines of the above description.

The most important inline pair of functions is splitting a string into an array of elements and merging the array into a string:

• split(s[,l]);
• join(s).

In the first case, the string is divided by the delimiter character "s" into an array of elements, in which the number of elements does not exceed the value "l". If the number is not specified, then the entire line is split.

In the second case, the array of elements is merged into one line through the specified delimiter.

A notable feature of this pair is that splitting can be done using one delimiter, and merging - using another. In this context, in JavaScript, working with strings can be "brought out" of the syntax of the language.

Classic string functions

Regular string processing functions:

• Search;
• sample;
• replacement;
• transformation.

Represented by methods: indexOf(), lastIndexOf(), toLowerCase(), toUpperCase(), concan(), charCodeAt() and others.

In JavaScript, working with strings is represented by a large number of functions, but they either duplicate each other or are left for old algorithms and compatibility.

For example, using the concat() method is legal, but it's easier to write:

• str = str1 + str2 + str3;

The use of the charAt() function also makes sense, but the use of charCodeAt() has a real practical value. Similarly, for JavaScript, a line break has a special meaning: in the context of screen output, for example, in an alert() message, it is "\n", in a page content construct it is "
". In the first case, it's just a character, and in the second, it's a string of characters.

Strings and regular expressions

In JavaScript, working with strings involves the regular expression mechanism. This allows complex searches, selections, and string transformations to be performed inside the browser without having to go to the server.

Method match finds and replace replaces found match desired value. Regular expressions are implemented in JavaScript at high level, inherently complex, and due to the specifics of the application, they transfer the center of gravity from the server to the client browser.

When applying methods match, search and replace should not only give due attention to testing across the spectrum allowed values initial parameters and search strings, but also to estimate the load on the browser.

Regular expression examples

The scope of regular expressions for processing strings is extensive, but requires great care and attention from the developer. First of all, regular expressions are used when testing user input in form fields.

Here are functions that check if the input contains an integer (schInt) or a real number (schReal). The following example shows how efficient it is to process strings by checking them for only valid characters: schText - text only, schMail - correct address Email.

It is very important to keep in mind that in JavaScript symbols and strings require increased attention to the locale, especially when dealing with Cyrillic. In many cases, it is more appropriate to specify the actual character codes rather than their values. This concerns Russian letters in the first place.

It should be especially noted that it is far from always necessary to carry out the task as it is set. In particular, with regard to checking integers and real numbers: you can get by not with the classic string methods, but with the usual syntax constructs.

Object Oriented Strings

In JavaScript, working with strings is represented by a wide range of functions. But this is not a good reason to use them in their original form. The syntax and quality of the functions are impeccable, but this is a one-size-fits-all solution.

Any application of string functions involves processing real meaning, which is determined by the data, scope, specific purpose algorithm.

The ideal solution is always to interpret the data for its meaning.

By representing each parameter as an object, you can formulate functions to work with it. Is always we are talking about character processing: numbers or strings are specifically organized sequences of characters.

There are general algorithms, and there are private ones. For example, the surname or house number are strings, but if in the first case only Russian letters are allowed, then in the second case numbers, Russian letters are allowed, and hyphens or indices through a slash can occur. Indexes can be alphabetic or numeric. The house may have buildings.

Not all situations can always be foreseen. This important point in programming. A rare algorithm does not require refinement, and in most cases it is necessary to systematically adjust the functionality.

Formalization of the processed string information in the form of an object improves the readability of the code, allows you to bring it to the level of semantic processing. This is a different degree of functionality and significantly the best quality code with greater reliability of the developed algorithm.

From the author: hello friends. In several previous articles, we got acquainted with the numeric data type in JavaScript and worked with numbers. Now it's time to work with strings in JavaScript. Let's take a closer look at the string data type in JavaScript.

In we already briefly got acquainted with the string type and, in fact, we only learned what a string is and how it is written. Let's now take a closer look at strings and how to work with them.

As you remember, any text in JavaScript is a string. The string must be enclosed in quotes, single or double, it doesn't matter:

var hi = "hello", name = "John";

varhi = "hello" , name = "John" ;

Now we have written only one word to the variables. But what if we want to record a large amount of text? Yes, no problem, let's write some fishy text to the variable and output it to the console:

var text = "Lorem ipsum dolor sit amet, consectetur adipisicing elit. Nobis dignissimos maxime et tempore omnis, ab fugit. Quos nisi, culpa exercitationem!"; console log(text);

var text = "Lorem ipsum dolor sit amet, consectetur adipisicing elit. Nobis dignissimos maxime et tempore omnis, ab fugit. Quos nisi, culpa exercitationem!"; console. log(text);

Working. But if there is a lot of text, we will probably have line breaks to start new paragraph a new line. Let's try adding a line break like this to our text:

As you can see my text editor already highlighted in red possible problem. Let's see how the browser reacts to a line feed in this interpretation:

Syntax error, as expected. How to be? There are several ways to write multiline text to a variable. One of them you could already guess, we are talking about string concatenation:

As you can see, the editor already responds normally to this option of writing a string to a variable. Another option is to use the backslash (\), which in JavaScript and many other programming languages ​​is an escape character that allows you to safely work with special characters. What are special characters, we will learn further. So, let's try to escape the invisible newline character:

Shielding also solved our problem. However, if we look at the console, both string concatenation and linefeed escaping, while solving the problem of writing to the program, did not solve the problem with the output multiline string to the screen. Instead of a multi-line string, we will see text in one line in the console. How to be?

And here the special newline character \n will help us. By adding this special character to the string at the right place, we tell the interpreter that we need to terminate at this place current line and make a new line.

var text = "Lorem ipsum dolor sit amet, consectetur adipisicing elit. Nobis dignissimos maxime et tempore omnis, ab fugit.\ \nQuos nisi, culpa exercitationem!"; console log(text);

var text = "Lorem ipsum dolor sit amet, consectetur adipisicing elit. Nobis dignissimos maxime et tempore omnis, ab fugit.\ \nQuos nisi, culpa exercitationem!"; console. log(text);

Actually, if you are not embarrassed by writing text in the code in one line, then we can do this:

var text = "Lorem ipsum dolor sit amet, consectetur adipisicing elit. Nobis dignissimos maxime et tempore omnis, ab fugit.\nQuos nisi, culpa exercitationem!"; console log(text);

var text = "Lorem ipsum dolor sit amet, consectetur adipisicing elit. Nobis dignissimos maxime et tempore omnis, ab fugit.\nQuos nisi, culpa exercitationem!"; console. log(text);

The result on the screen will not change from this, we will see multiline text in the browser console:

We really do not really need the backslash escape character in the code in this situation. But it is actually needed, as noted above, for escaping special characters. For example, inside the string that we enclosed in single quotes, there is an apostrophe, i.e. single quote:

var text = "Lorem ipsum d"olor sit amet";

There are several ways to select substrings in JavaScript, including substring(), substr(), slice() and features regexp.

In JavaScript 1.0 and 1.1, substring() exists as the only easy way to select part of a larger string. For example, to select the line press from expression, use "Expression".substring(2,7). The first argument to the function is the character index at which the selection begins, while the second argument is the character index at which the selection ends (not including): substring(2,7) includes indices 2, 3, 4, 5, and 6.

In JavaScript 1.2, functions substr(), slice() and regexp can also be used to break lines.

Substr() behaves in the same way as substr Perl, where the first parameter specifies the character index at which the selection begins, while the second parameter specifies the length of the substring. To perform the same task as in the previous example, you need to use "Expression".substr(2,5). Remember, 2 is the start point and 5 is the length of the resulting substring.

When used on strings, slice() behaves similarly to the function substring(). This, however, is much more powerful tool, which can function with any type of array, and not just with strings. slice() also uses negative offsets to refer to desired position, starting from the end of the string. "Expression".slice(2,-3) will return the substring found between the second character and the third character from the end, again returning press.

Last and most generic method to work with substrings is work through regular expression functions in JavaScript 1.2. Once again, referring to the same example, the substring "press" obtained from the string "Expression":

Write("Expression".match(/press/));

Embedded object String

An object String is an object implementation of a primitive string value. Its constructor looks like:

New String( meaning?)

Here meaning— any string expression that specifies the primitive value of an object. If it is not specified, then the primitive value of the object is "" .

String object properties:

constructor The constructor that created the object. The number of characters in the string. prototype Reference to the object class prototype.

Standard Methods of the String Object

Returns the character at the given position in the string. Returns the code of the character at the given position in the string. Returns the string concatenation. Creates a string from the characters given by the Unicode codes. Returns the position of the first occurrence of the given substring. Returns the position of the last occurrence of the given substring. Compares two strings given the locale operating system. Matches a string against a regular expression. Matches a string against a regular expression and replaces the found substring with a new substring. Looks for a string match against a regular expression. Extracts part of a string and returns a new string. Splits a string into an array of substrings. Returns a substring given by position and length. Returns the substring given by the start and end positions. Converts all letters in a string to lowercase, taking into account the locale of the operating system. Converts all letters in a string to uppercase, based on the locale of the operating system. Converts all letters in a string to lowercase. Converts an object to a string. Converts all letters in a string to uppercase. Returns the primitive value of the object.

Non-Standard Methods of the String Object

Creates an HTML bookmark ( …). Wraps a string in tags …. Wraps a string in tags …. Wraps a string in tags …. Wraps a string in tags …. Wraps a string in tags …. Wraps a string in tags …. Wraps a string in tags …. Creates HTML hyperlink(...). Wraps a string in tags …. Wraps a string in tags …. Wraps a string in tags . Wraps a string in tags .

length property

Syntax : an object.length Attributes: ( DontEnum, DontDelete, ReadOnly )

Property value length is the number of characters in the string. For an empty string, this value is zero.

anchor method

Syntax : an object.anchor( name) Arguments: name Result: string value

Method anchor object, enclosed in tags …. No check is made to see if the source string was already enclosed in these tags. This method is used in conjunction with the document.write and document.writeln methods to create a bookmark in an HTML document with the given name. For example, document.write("My text".anchor("Bookmark")) is equivalent to document.write(" My text") .

big method

Syntax : an object.big() Result: string value

Method big returns a string consisting of object, enclosed in tags …. No check is made to see if the source string was already enclosed in these tags. This method is used in conjunction with the document.write and document.writeln methods to display text in large font. For example, the statement document.write("My text".big()) will display the string My text on the browser screen.

blink method

Syntax : an object.blink() Result: string value

Method blink returns a string consisting of a primitive string value object, enclosed in tags …. No check is made to see if the source string was already enclosed in these tags. This method is used in conjunction with the document.write and document.writeln methods to display text in a flashing font. The specified tags are not included in HTML standard and are only supported by Netscape and WebTV browsers. For example, the statement document.write("My Text".blink()) will display the string My Text on the browser screen.

bold method

Syntax : an object.bold() Result: string value

Method bold returns a string consisting of a primitive string value object, enclosed in tags …. No check is made to see if the source string was already enclosed in these tags. This method is used in conjunction with the document.write and document.writeln methods to display text in bold. For example, the statement document.write("My text".bold()) will display the string My text .

charAt method

Syntax : an object.charAt( position) Arguments: position- any numeric expression Result: string value

Method charAt returns a string consisting of the character located in the given positions primitive string value object. The character positions of a string are numbered from zero to an object. -one. If the position is outside this range, then an empty string is returned. For example, the statement document.write("String".charAt(0)) will display the character C on the browser screen.

charCodeAt method

Syntax : an object.charCodeAt( position) Arguments: position- any numeric expression Result: numeric value

Method charAt returns a number equal to the Unicode code of the character located in the given positions primitive string value object. The character positions of a string are numbered from zero to an object. -one. If the position is outside this range, then returns NaN. For example, the statement document.write("String".charCodeAt(0).toString(16)) will display the hexadecimal code of the Russian letter "C" on the browser screen: 421 .

concate method

Syntax : an object.concat( string0, line1, …, stringN) Arguments: string0, line1, …, stringN- any string expressions Result: string value

Method concat returns a new string that is the concatenation of the original string and the method arguments. This method is equivalent to the operation

an object + string0 + line1 + … + stringN

For example, the statement document.write("Frost and sun. ".concat("A wonderful day.")) will display the string Frost and sun on the browser screen. The day is wonderful.

fixed method

Syntax : an object.fixed() Result: string value

Method fixed returns a string consisting of a primitive string value object, enclosed in tags …. No check is made to see if the source string was already enclosed in these tags. This method is used in conjunction with the document.write and document.writeln methods to display text in teletype font. For example, the statement document.write("My text".fixed()) will display the string My text on the browser screen.

fontcolor method

Syntax : an object.fontcolor(color) Arguments: color- string expression Result: string value

Method font color returns a string consisting of a primitive string value object, enclosed in tags color>…. No check is made to see if the source string was already enclosed in these tags. This method is used in conjunction with the document.write and document.writeln methods to display text given color. For example, the statement document.write("My text".fontcolor("red")) will display the string My text on the browser screen.

fontsize method

Syntax : an object.fontsize( the size) Arguments: the size- numeric expression Result: string value

Method fontsize returns a string consisting of a primitive string value object, enclosed in tags …. No check is made to see if the source string was already enclosed in these tags. This method is used in conjunction with the document.write and document.writeln methods to display text in a given font size. For example, the statement document.write("My text".fontsize(5)) will display the string My text on the browser screen.

fromCharCode method

Syntax : String.fromCharCode( code1, code2, …, codeN) Arguments: code1, code2, …, codeN- numeric expressions Result: string value

Method fromCharCode creates a new string (but not a string object) which is a concatenation Unicode characters with codes code1, code2, …, codeN.

This is a static method on an object. String, so you don't need to specifically create a string object to access it. Example:

Vars = String.fromCharCode(65, 66, 67); // s is "ABC"

indexOf Method

Syntax : an object.indexOf( substring[,Start]?) Arguments: substring- any string expression Start- any numeric expression Result: numeric value

Method indexOf returns the first position substrings in primitive string value object. an object Start Start Start Start more than an object an object

The search is conducted from left to right. Otherwise, the method is identical to the . The following example counts the number of occurrences of the substring pattern in the string str .

Function occur(str, pattern) ( var pos = str.indexOf(pattern); for (var count = 0; pos != -1; count++) pos = str.indexOf(pattern, pos + pattern.length); return count ; )

italics method

Syntax : an object.italics() Result: string value

Method italics returns a string consisting of a primitive string value object, enclosed in tags …. No check is made to see if the source string was already enclosed in these tags. This method is used in conjunction with the document.write and document.writeln methods to display text in italics. For example, the statement document.write("My text".italics()) will display the string My text .

lastIndexOf method

Syntax : an object.lastIndexOf( substring[,Start]?) Arguments: substring- any string expression Start- any numeric expression Result: numeric value

Method lastIndexOf returns the last position substrings in primitive string value object an object. -one. If an optional argument is given Start, then the search is carried out starting from the position Start; if not, then from position 0, i.e. from the first character of the string. If Start is negative, then it is taken equal to zero; if Start more than an object. -1, then it is taken equal to an object. -one. If the object does not contain the given substring, then -1 is returned.

The search is conducted from right to left. Otherwise, the method is identical to the . Example:

Var n = "White whale".lastIndexOf("whale"); // n is 6

link method

Syntax : an object.link( uri) Arguments: uri- any string expression Result: string value

Method link returns a string consisting of a primitive string value object, wrapped in uri tags">… . There is no check to see if the source string was already enclosed in these tags. This method is used in conjunction with the document.write and document.writeln methods to create a hyperlink in an HTML document with the given uri. For example, document.write("My text".link("#Bookmark")) is equivalent to document.write("My text") .

localeCompare method

Syntax : an object.localeCompare( line1) Arguments: line1- any string expression Result: number

Support

Method localeCompare compares two strings based on the locale of the operating system. It returns -1 if primitive value object less lines1, +1 if it is greater lines1, and 0 if these values ​​match.

match method

Syntax : an object.match( regvar) Arguments: regvar Result: array of strings

Method match regvar object. The result of the match is an array of found substrings, or null if there are no matches. Wherein:

• If regvar does not contain an option global search, then the method is executed regvar.exec(an object) and returns its result. The resulting array contains the found substring in the element with index 0, and the substrings corresponding to the subexpressions in the remaining elements regvar enclosed in parentheses.
• If regvar contains a global search option, then the method regvar.exec(an object) is executed as long as there are matches. If n is the number of matches found, then the result is an array of n elements that contain the found substrings. property regvar.lastIndex is assigned the position number in the source string, pointing to the first character after the last match found, or 0 if no match is found.

It should be remembered that the method regvar.exec changes the properties of an object regvar. Examples:

replace method

Syntax : an object.replace( regvar,line) an object.replace( regvar,function) Arguments: regvar— regular expression string — string expression function- function name or function declaration Result: new line

Method replace matches a regular expression regvar with primitive string value object and replaces found substrings with other substrings. The result is a new string, which is a copy of the original string with the changes made. The replacement method is determined by the global search option in regvar and the type of the second argument.

If regvar does not contain a global search option, then the search is performed for the first substring that matches regvar and it is being replaced. If regvar contains the global search option, then all substrings matching regvar and they are replaced.

line, then each found substring is replaced by it. In this case, the string may contain such properties of the object RegExp, like $1 , ..., $9 , lastMatch , lastParen , leftContext and rightContext . For example, the statement document.write("Delicious apples, juicy apples.".replace(/apples/g, "pears")) will display the string Delicious pears, juicy pears on the browser screen.

If the second argument is function, then the replacement of each found substring is performed by calling this function. The function has the following arguments. The first argument is the found substring, followed by the arguments that match all subexpressions regvar, enclosed in parentheses, the penultimate argument is the position of the found substring in the source string, counting from zero, and the last argument is the source string itself. The following example shows how to use the method replace you can write a function to convert degrees Fahrenheit to degrees Celsius. Script given

Function myfunc($0,$1) ( return (($1-32) * 5 / 9) + "C"; ) function f2c(x) ( var s = String(x); return s.replace(/(\d+( \.\d*)?)F\b/, myfunc); ) document.write(f2c("212F"));

will display the string 100C on the browser screen.

Keep in mind that this method changes the properties of the object regvar.

Replace example

Replacing all occurrences of a substring in a string

It often happens that you need to replace all occurrences of one string with another string:

var str = "foobarfoobar"; str=str.replace(/foo/g,"xxx"); // eventually get str = "xxxbarxxxbar";

search method

Syntax : an object.search( regvar) Arguments: regvar- any regular expression Result: numeric expression

Method search matches a regular expression regvar with primitive string value object. The result of the match is the position of the first substring found, counting from zero, or -1 if there is no match. However, the global search option in regvar is ignored and the properties regvar do not change. Examples:

slice method

Syntax : an object.slice( Start [,the end]?) Arguments: Start and the end- any numeric expressions Result: new line

Method slice object, from position Start to position the end without including it. If the end Start and to the end of the original line.

The character positions of a string are numbered from zero to an object. -one. If the value Start an object. +Start. If the value the end negative, then it is replaced by an object. +the end. In other words, negative arguments are treated as offsets from the end of the string.

The result is a string value, not a string object. For example, the statement document.write("ABCDEF".slice(2,-1)) will print the string CDE to the browser screen.

small method

Syntax : an object.small() Result: string value

Method small returns a string consisting of a primitive string value object, enclosed in tags …. No check is made to see if the source string was already enclosed in these tags. This method is used in conjunction with the document.write and document.writeln methods to display text small print. For example, the statement document.write("My text". small()) will display the string My text on the browser screen.

split method

Syntax : an object.split( delimiter [,number]?) Arguments: delimiter- string or regular expression number- numeric expression Result: array of strings (object array)

Method split breaks primitive value object to an array of substrings and returns it. Splitting into substrings is done as follows. The source string is scanned from left to right looking for separator. As soon as it is found, the substring from the end of the previous delimiter (or from the beginning of the string, if this is the first occurrence of the delimiter) to the beginning of the one found is added to the substrings array. Thus, the separator itself does not get into the text of the substring.

Optional argument number sets the maximum possible size of the resulting array. If it is given, then after selection numbers the substring method exits even if the scan of the source string has not finished.

Delimiter can be specified either as a string or as a regular expression. There are several cases requiring special consideration:

V following example regular expression is used to set HTML tags as a separator. Operator

will display the string Text, bold, and italic on the browser screen.

strike method

Syntax : an object.strike() Result: string value

Method strike returns a string consisting of a primitive string value object, enclosed in tags …. No check is made to see if the source string was already enclosed in these tags. This method is used in conjunction with the document.write and document.writeln methods to display text in a strikethrough font. For example, the statement document.write("My text".strike()) will display the string My text on the browser screen.

sub method

Syntax : an object.sub() Result: string value

Method sub returns a string consisting of a primitive string value object, enclosed in tags . No check is made to see if the source string was already enclosed in these tags. This method is used in conjunction with the document.write and document.writeln methods to display text as a subscript. For example, the statement document.write("My text".sub()) will display the string My text on the browser screen.

substr method

Syntax : an object.substr( position [,length]?) Arguments: position and length- numeric expressions Result: string value

Method substr returns a substring of the primitive string value object starting with this positions and containing length characters. If length is not set, then a substring is returned, starting from the given positions and to the end of the original line. If length is negative or zero, the empty string is returned.

The character positions of a string are numbered from zero to an object. -one. If position greater than or equal an object., then an empty string is returned. If position is negative, then it is treated as an offset from the end of the string, i.e., it is replaced by an object.+position.

Note. If position is negative, Internet Explorer erroneously sets it to 0, so for compatibility reasons, this should not be used.

Var src="abcdef"; var s1 = src.substr(1, 3); // "bcd" var s2 = src.substr(1); // "bcdef" var s3 = src.substr(-1); // "f", but in MSIE: "abcdef"

substring method

Syntax : an object.substring( Start [,the end]) Arguments: Start and the end- numeric expressions Result: string value

Method substring returns a substring of the primitive string value object, from position Start to position the end without including it. If the end is not set, then a substring is returned, starting from the position Start and to the end of the original line.

The character positions of a string are numbered from zero to an object. -one. Negative arguments or equal NaN are replaced by zero; if the argument is greater than the length of the original string, then it is replaced by it. If Start more end, then they are interchanged. If Start equals end, then an empty string is returned.

The result is a string value, not a string object. Examples:

Var src="abcdef"; var s1 = src.substring(1, 3); // "bc" var s2 = src.substring(1, -1); // "a" var s3 = src.substring(-1, 1); // "a"

sup method

Syntax : an object.sup() Result: string value

Method sup returns a string consisting of a primitive string value object, enclosed in tags . No check is made to see if the source string was already enclosed in these tags. This method is used in conjunction with the document.write and document.writeln methods to display text as superscript. For example, the statement document.write("My text". sup()) will display the string My text on the browser screen.

toLocaleLowerCase Method

Syntax : an object.toLocaleLowerCase() Result: new line

Support: Internet Explorer Supported since version 5.5. Netscape Navigator Not supported.

Method toLocaleLowerCase returns a new string in which all letters of the original string have been changed to lowercase, taking into account the national settings of the operating system. The remaining characters of the original string are not changed. The original string remains the same. Usually this method returns the same result as ; the difference is only possible if the language encoding conflicts with Unicode's rules for converting uppercase letters to lowercase.

toLocaleUpperCase method

Syntax : an object.toLocaleUpperCase() Result: new line

Support: Internet Explorer Supported since version 5.5. Netscape Navigator Not supported.

Method toLocaleUpperCase returns a new string with all letters of the original string changed to uppercase, taking into account the national settings of the operating system. The remaining characters of the original string are not changed. The original string remains the same. Usually this method returns the same result as ; the difference is only possible if the language encoding conflicts with Unicode's rules for converting lowercase letters to uppercase.

toLowerCase method

Syntax : an object.toLowerCase() Result: new line

Method toLowerCase returns a new string with all letters of the original string changed to lowercase. The remaining characters of the original string are not changed. The original string remains the same. For example, the statement document.write("String object".toLowerCase()) will display the string object string object on the browser screen.

A string is a sequence of one or more characters that can contain letters, numbers, and other characters. In JavaScript, this is the simplest immutable data type.

Lines allow you to display and work with text, and text is the main way to communicate and transfer information on the network. Because strings are one of the main concepts of programming.

This tutorial will teach you how to create and view string output, concatenate strings, and store them in variables. You will also learn about the rules for using quotation marks, apostrophes, and new line in JavaScript.

Create and View a Row

There are three ways to create strings in JavaScript: they can be written within single quotes ('), double quotes ("), or backticks (`). Although scripts sometimes use all three types of strings, you should only use one type of quotation mark within a single string.

Strings in single and double quotes are essentially the same thing. There are no conventions regarding the use of one or another type of quotation marks, but it is generally recommended that one type be used consistently in program scripts.

"This string uses single quotes.";
"This string uses double quotes.";

Third and latest way creating a string is called a template literal. Template literals are written in backticks (also known as blunt accents) and work just like normal strings with a few additional features that we'll cover in this article.

`This string uses backticks.`;

The easiest way to view the output of a string is to type it into the console using console.log().

console.log("This is a string in the console.");
This is a string in the console.

Other in a simple way request string value is a browser popup that can be triggered with alert():

alert("This is a string in an alert.");

This line will open a notification window in the browser with the following text:

This is a string in an alert.

The alert() method is less frequently used because alerts need to be closed all the time.

Storing strings in variables

Variables in JavaScript are named containers that store values ​​using keywords var, const or let. Strings can be assigned to variables.

const newString = "This is a string assigned to a variable.";

The newString variable now contains a string and can be referenced and printed to the console.

console log(newString);
This is a string assigned to a variable.

By assigning strings to variables, you don't have to re-enter the string each time it needs to be output, making it easier to work with strings within programs.

String concatenation

String concatenation is the process of concatenating two or more strings into one new string. Concatenation is done using the + operator. The + symbol is also the addition operator in mathematical operations.

For example, try concatenating two short strings:

"Sea" + "horse";
sea ​​horse

Concatenation joins the end of one string with the beginning of another string without inserting spaces. To add a space between lines, add it to the end of the first line.

"Sea" + "horse";
sea ​​horse

Concatenation allows you to concatenate strings and variables with string values.

const favePoem = "My favorite poem is " + poem + " by " + author ".";

The new strings resulting from the concatenation can be used in the program.

Variables with template literals

One of the features of template literals is the ability to include expressions and variables in a string. Instead of concatenation, you can use the $() syntax to insert a variable.

const poem = "The Wide Ocean";
const author = "Pablo Neruda";
const favePoem = `My favorite poem is $(poem) by $(author).`;
My favorite poem is The Wide Ocean by Pablo Neruda.

This syntax allows you to get the same result. Template literals make it easy to concatenate strings.

String literals and string values

As you may have noticed by now, all strings are written in quotes or back quotes, but the output string does not contain quotes.

"Beyond the Sea";
Beyond the Sea

A string literal is a string as it appears in source code, including quotes. The string value is the string that appears in the output (without quotes).

In this example, "Beyond the Sea" is a string literal and Beyond the Sea is a string value.

Traversing quotes and apostrophes in strings

Because quotation marks are used to denote strings, there are special rules for using apostrophes and quotation marks in strings. For example, an apostrophe in the middle of a single-quoted string will be interpreted by JavaScript as a closing single quote, and the rest of the intended string will attempt to be read as code.

Consider this example:

const brokenString = "I"m a broken string";
console.log(brokenString);
unknown: Unexpected token (1:24)

The same thing happens if you try to use double quotes inside a double-quoted string. The interpreter won't notice the difference.

To avoid such errors, you can use:

• Different string syntax.
• Escape characters.
• template literal.

Alternate String Syntax

The easiest way to work around this problem is to use the reverse syntax to the one you use in the script. For example, strings with apostrophes should be enclosed in double quotes:

"We"re safely using an apostrophe in double quotes."

Quote strings can be enclosed in single quotes:

"Then he said, "Hello, World!"";

By combining single and double quotes, you can control the display of quotes and apostrophes within strings. However, this will affect the consistency of the syntax in the project files and will be difficult to maintain.

escape character \

With a backslash, JavaScript will not interpret quotes as closing quotes.

The combination \' will always be treated as an apostrophe, and \" as double quotes, with no exceptions.

This allows apostrophes to be used in single-quoted strings, and quotes to be used in double-quoted strings.

"We\"re safely using an apostrophe in single quotes."
"Then he said, \"Hello, World!\"";

This method looks a bit messy. But it is required if the same string contains both an apostrophe and double quotes.

Template literals

Template literals are defined with back quotes, so both double quotes and apostrophes can be safely used without any additional manipulation.

`We're safely using apostrophes and "quotes" in a template literal.`;

Template literals not only avoid errors in displaying quotation marks and apostrophes, but also provide support for inline expressions and multiline blocks, as discussed in the next section.

Multiline strings and newline

In some situations, it is necessary to insert a newline character or a line break. The escape characters \n or \r will help you insert a new line into the code output.

const threeLines = "This is a string\nthat spans across\nthree lines.";
This is a string
spans across
three lines.

This will split the output into multiple lines. However, if the code has long lines, they will be difficult to work with and read. To display one string on multiple lines, use the concatenation operator.

const threeLines = "This is a string\n" +
"that spans across\n" +
"three lines.";

You can also escape the newline using the \ escape character.

const threeLines = "This is a string\n\
spans across\n\
three lines.";

Note: This method is not recommended as it may cause problems in some browsers.

To make your code readable, use template literals. This avoids concatenation and escape characters.

const threeLines = `This is a string
spans across
three lines.`;
This is a string
spans across
three lines.

Because different codebases may use different standards, it's important to know all the ways to break newlines and create multiline strings.

Conclusion

Now you know the basics of working with strings in JavaScript, you can create strings and template literals, perform concatenation and traversal, and assign strings to variables.

Tags: