Special characters

It is still possible to create multiline strings with single and double quotes by using a so-called “newline character”, written as \n , which denotes a line break:

As a simpler example, these two lines are equal, just written differently:

There are other, less common special characters:

As you can see, all special characters start with a backslash character \ . It is also called an “escape character”.

Because it’s so special, if we need to show an actual backslash \ within the string, we need to double it:

So-called “escaped” quotes \' , \" , \` are used to insert a quote into the same-quoted string.

For instance:

As you can see, we have to prepend the inner quote by the backslash \' , because otherwise it would indicate the string end.

Of course, only the quotes that are the same as the enclosing ones need to be escaped. So, as a more elegant solution, we could switch to double quotes or backticks instead:

Besides these special characters, there’s also a special notation for Unicode codes \u… , it’s rarely used and is covered in the optional chapter about Unicode .

String length

The length property has the string length:

Note that \n is a single “special” character, so the length is indeed 3 .

People with a background in some other languages sometimes mistype by calling str.length() instead of just str.length . That doesn’t work.

Please note that str.length is a numeric property, not a function. There is no need to add parenthesis after it. Not .length() , but .length .

Accessing characters

To get a character at position pos , use square brackets [pos] or call the method str.at(pos) . The first character starts from the zero position:

As you can see, the .at(pos) method has a benefit of allowing negative position. If pos is negative, then it’s counted from the end of the string.

So .at(-1) means the last character, and .at(-2) is the one before it, etc.

The square brackets always return undefined for negative indexes, for instance:

We can also iterate over characters using for..of :

Strings are immutable

Strings can’t be changed in JavaScript. It is impossible to change a character.

Let’s try it to show that it doesn’t work:

The usual workaround is to create a whole new string and assign it to str instead of the old one.

In the following sections we’ll see more examples of this.

Changing the case

Methods toLowerCase() and toUpperCase() change the case:

Or, if we want a single character lowercased:

Searching for a substring

There are multiple ways to look for a substring within a string.


The first method is str.indexOf(substr, pos) .

It looks for the substr in str , starting from the given position pos , and returns the position where the match was found or -1 if nothing can be found.

The optional second parameter allows us to start searching from a given position.

For instance, the first occurrence of "id" is at position 1 . To look for the next occurrence, let’s start the search from position 2 :

If we’re interested in all occurrences, we can run indexOf in a loop. Every new call is made with the position after the previous match:

The same algorithm can be layed out shorter:

There is also a similar method str.lastIndexOf(substr, position) that searches from the end of a string to its beginning.

It would list the occurrences in the reverse order.

There is a slight inconvenience with indexOf in the if test. We can’t put it in the if like this:

The alert in the example above doesn’t show because str.indexOf("Widget") returns 0 (meaning that it found the match at the starting position). Right, but if considers 0 to be false .

So, we should actually check for -1 , like this:

includes, startsWith, endsWith

The more modern method str.includes(substr, pos) returns true/false depending on whether str contains substr within.

It’s the right choice if we need to test for the match, but don’t need its position:

The optional second argument of str.includes is the position to start searching from:

The methods str.startsWith and str.endsWith do exactly what they say:

Getting a substring

There are 3 methods in JavaScript to get a substring: substring , substr and slice .

Returns the part of the string from start to (but not including) end .

If there is no second argument, then slice goes till the end of the string:

Negative values for start/end are also possible. They mean the position is counted from the string end:

Returns the part of the string between start and end (not including end ).

This is almost the same as slice , but it allows start to be greater than end (in this case it simply swaps start and end values).

Negative arguments are (unlike slice) not supported, they are treated as 0 .

Returns the part of the string from start , with the given length .

In contrast with the previous methods, this one allows us to specify the length instead of the ending position:

The first argument may be negative, to count from the end:

This method resides in the Annex B of the language specification. It means that only browser-hosted Javascript engines should support it, and it’s not recommended to use it. In practice, it’s supported everywhere.

Let’s recap these methods to avoid any confusion:

All of them can do the job. Formally, substr has a minor drawback: it is described not in the core JavaScript specification, but in Annex B, which covers browser-only features that exist mainly for historical reasons. So, non-browser environments may fail to support it. But in practice it works everywhere.

Of the other two variants, slice is a little bit more flexible, it allows negative arguments and shorter to write.

So, for practical use it’s enough to remember only slice .

Comparing strings

As we know from the chapter Comparisons , strings are compared character-by-character in alphabetical order.

Although, there are some oddities.

A lowercase letter is always greater than the uppercase:

Letters with diacritical marks are “out of order”:

This may lead to strange results if we sort these country names. Usually people would expect Zealand to come after Österreich in the list.

To understand what happens, we should be aware that strings in Javascript are encoded using UTF-16 . That is: each character has a corresponding numeric code.

There are special methods that allow to get the character for the code and back:

Returns a decimal number representing the code for the character at position pos :

Creates a character by its numeric code

Now let’s see the characters with codes 65..220 (the latin alphabet and a little bit extra) by making a string of them:

See? Capital characters go first, then a few special ones, then lowercase characters, and Ö near the end of the output.

Now it becomes obvious why a > Z .

The characters are compared by their numeric code. The greater code means that the character is greater. The code for a (97) is greater than the code for Z (90).

  • All lowercase letters go after uppercase letters because their codes are greater.
  • Some letters like Ö stand apart from the main alphabet. Here, its code is greater than anything from a to z .

Correct comparisons

The “right” algorithm to do string comparisons is more complex than it may seem, because alphabets are different for different languages.

So, the browser needs to know the language to compare.

Luckily, modern browsers support the internationalization standard ECMA-402 .

It provides a special method to compare strings in different languages, following their rules.

The call str.localeCompare(str2) returns an integer indicating whether str is less, equal or greater than str2 according to the language rules:

  • Returns a negative number if str is less than str2 .
  • Returns a positive number if str is greater than str2 .
  • Returns 0 if they are equivalent.

This method actually has two additional arguments specified in the documentation , which allows it to specify the language (by default taken from the environment, letter order depends on the language) and setup additional rules like case sensitivity or should "a" and "á" be treated as the same etc.

  • There are 3 types of quotes. Backticks allow a string to span multiple lines and embed expressions ${…} .
  • We can use special characters, such as a line break \n .
  • To get a character, use: [] or at method.
  • To get a substring, use: slice or substring .
  • To lowercase/uppercase a string, use: toLowerCase/toUpperCase .
  • To look for a substring, use: indexOf , or includes/startsWith/endsWith for simple checks.
  • To compare strings according to the language, use: localeCompare , otherwise they are compared by character codes.

There are several other helpful methods in strings:

  • str.trim() – removes (“trims”) spaces from the beginning and end of the string.
  • str.repeat(n) – repeats the string n times.
  • …and more to be found in the manual .

Strings also have methods for doing search/replace with regular expressions. But that’s big topic, so it’s explained in a separate tutorial section Regular expressions .

Also, as of now it’s important to know that strings are based on Unicode encoding, and hence there’re issues with comparisons. There’s more about Unicode in the chapter Unicode, String internals .

Uppercase the first character

Write a function ucFirst(str) that returns the string str with the uppercased first character, for instance:

Open a sandbox with tests.

We can’t “replace” the first character, because strings in JavaScript are immutable.

But we can make a new string based on the existing one, with the uppercased first character:

There’s a small problem though. If str is empty, then str[0] is undefined , and as undefined doesn’t have the toUpperCase() method, we’ll get an error.

The easiest way out is to add a test for an empty string, like this:

Open the solution with tests in a sandbox.

Check for spam

Write a function checkSpam(str) that returns true if str contains ‘viagra’ or ‘XXX’, otherwise false .

The function must be case-insensitive:

To make the search case-insensitive, let’s bring the string to lower case and then search:

Truncate the text

Create a function truncate(str, maxlength) that checks the length of the str and, if it exceeds maxlength – replaces the end of str with the ellipsis character "…" , to make its length equal to maxlength .

The result of the function should be the truncated (if needed) string.

The maximal length must be maxlength , so we need to cut it a little shorter, to give space for the ellipsis.

Note that there is actually a single Unicode character for an ellipsis. That’s not three dots.

Extract the money

We have a cost in the form "$120" . That is: the dollar sign goes first, and then the number.

Create a function extractCurrencyValue(str) that would extract the numeric value from such string and return it.

The example:

  • If you have suggestions what to improve - please submit a GitHub issue or a pull request instead of commenting.
  • If you can't understand something in the article – please elaborate.
  • To insert few words of code, use the <code> tag, for several lines – wrap them in <pre> tag, for more than 10 lines – use a sandbox ( plnkr , jsbin , codepen …)

Lesson navigation

  • © 2007—2024  Ilya Kantor
  • about the project
  • terms of usage
  • privacy policy

JavaScript Multiline String – How to Create Multi Line Strings in JS

Dionysia Lemonaki

In this article, you will learn three different ways to create multiline strings in JavaScript.

I will first explain the basics of strings in JavaScript and go over how to use template literals. Then, you will learn how to create a string that spans multiple lines with the help of code examples along the way.

Here is what we will cover:

  • What is a template literal? Why and how to use template literals
  • How to create multiline strings with template literals
  • How to create multiline strings using the + operator
  • How to create multiline strings using the \ operator

What Is A String in JavaScript? An Intro on How to Create A String in JS

Strings are an effective way of communicating through text.

A string is an ordered sequence of character values. Specifically, a string is a sequence of one or more characters that can be either letters, numbers, or symbols (such as punctuation marks).

There are three ways you can create a string in JavaScript:

  • By using single quotes.
  • By using double quotes.
  • By using backticks.

Here is how to create a string using single quotes :

Here is how to create a string using double quotes :

Here is how to create a string using backticks :

The last way of creating strings in JavaScript is known as a template literal .

I created a variable named favePhrase .

Inside the variable, I stored the string Hello World! , which I created using three different ways.

To view the output of the string in the browser's console, pass the variable name to console.log(); .

For example, If I wanted to see the output of the string created with double quotes, I would do the following:

Creating strings using single or double quotes works the same, so there is no difference between the two.

You can choose to use either or both of them throughout a file. That said, it is a good idea to remain consistent across your file.

When creating a string, make sure that the type of quotes you use is the same on both sides.

Another thing to note is that you can use one type of quote inside another.

For example, you could use double quotes inside single quotes, like so:

Make sure that the inside quotes don't match the surrounding ones because doing so would lead to an error:

Same thing happens when you try to use an apostrophe inside single quotes:

I used double quotes inside single quotes, and that worked. However, when I introduced the apostrophe, the code broke.

The way to get this to work is to escape the single quotes by using the \ escape character:

And to make the apostrophe work, you would have to do the following:

What is A Template Literal in JavaScript? Why and How to Use Template Literals in JavaScript

Earlier, you saw that to create a template literal, you have to use backticks.

Template literals were introduced with ES6, and they allow you to perform more complex operations using strings.

One of those is the ability to embed a variable inline inside a string, like so:

In the example above, I created two variables, firstName and lastName , and stored a person's first and last name, respectively.

Then, using console.log() , I printed a string created with backticks, also known as a template literal.

Inside that string, I embedded those two variables.

To do so, I wrapped the variable names in ${} - this is also known as string interpolation which allows you to introduce any variables without having to concatenate them like so:

Another thing that template literals allow you to do is to use single quotes, double quotes, and apostrophes inside them without the need to escape them:

String literals also allow you to create multiline strings, which you will learn how to do in the following section.

How to Create Multiline Strings in JavaScript

There are three ways to create strings that span multiple lines:

  • By using template literals.
  • By using the + operator – the JavaScript concatenation operator.
  • By using the \ operator – the JavaScript backslash operator and escape character.

If you choose to use single or double quotes instead of template literals to create a string that spans multiple lines, you would have to use either the + operator or the \ operator.

How to Create Multiline Strings with Template Literals in JavaScript

Template literals allow you to create a string that spans multiple lines:

Using template literals is the most straightforward way of creating multiline strings.

How to Create Multiline Strings Using the + Operator in JavaScript

Taking the same example from the previous section, here is how you would re-write it using the + operator:

You would also need to include the \n newline character to make sentences appear on a new line:

How to Create Multiline Strings Using the \ Operator in JavaScript

If you wanted to use the \ operator, here is how you would re-write the example from the previous section:

In this example, I created a multiline string using single quotes.

I first had to use the \n newline character followed by the \ operator to make the string span multiple lines.

Make sure you place the \ operator after the \n newline character.

And there you have it! You now know how to create multiline strings in JavaScript.

To learn more about JavaScript, head to freeCodeCamp's JavaScript Algorithms and Data Structures Certification .

It's a free, well-thought-out, and structured curriculum where you will learn interactively. In the end, you will also build 5 projects to claim your certification and solidify your knowledge.

Thanks for reading!

Read more posts .

If this article was helpful, share it .

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started

How to Convert a String to an Array in JavaScript

string assign javascript

  • Introduction

Textual data is typically stored through sequences of characters - strings. These sequences, are ultimately, arrays, and converting between the two structures typically is both simple and intuitive. Whether you're breaking a word down into its characters, or a sentence into words - splitting a string into an array isn't an uncommon operation, and most languages have built-in methods for this task.

In this guide, learn how to convert a String to an Array in JavaScript, with the split() , Object.assign() , Array.from() methods and spread[...] operator, as well as when to use which.
  • Split String into Array with split()

The split() method is used to divide a string into an ordered list of two or more substrings, depending on the pattern/divider/delimiter provided, and returns it. The pattern/divider/delimiter is the first parameter in the method's call and can be a regular expression , a single character , or another string .

If you'd like to learn more about Regular Expressions - read our Guide to Regular Expressions and Matching Strings in JavaScript !

For example, suppose we have a string:

We could split it on each whitespace (breaking it down into words), or on every character, or any other arbitrary delimiter, such as 'p' :

One of the major downsides of using single characters or even entire strings is that the approach is fairly rigid. You can't match by multiple delimiters, unless you use a Regular Expression. For instance, say you'd like to break a string into sentences . A sentence can end with a period ( . ), exclamation mark ( ! ), a question mark ( ? ) or three dots ( ... ). Each of these are valid sentences, but we'd have to perform multiple splits to match all of them, if we were to use single characters or strings.

Pattern matching is where Regular Expressions excel! Let's split a string on each sentence, with any of these ending delimiters:

However, the delimiters are lost! We split on them and in the process, remove them from the output. Additionally, we have multiple whitespaces in the beginnings of the sentences, and there's an empty string in the end! This isn't to say that split() doesn't work well with Regular Expressions - but it is to say that splitting sentences out of text isn't solved well by split() . This is where we can use the match() method instead - which returns the matching patterns and their delimiters:

Again, if you're interested in learning more about Regular Expressions - read our Guide to Regular Expressions and Matching Strings in JavaScript !

Note: The split() method takes in a second parameter, which specifies the limit of splitting that can occur. It doesn't alter the number of splits and elements to fit the passed argument, but rather, performs the split n times, from the start, and stops splitting after that.

To limit the number of splits we perform, we can easily supply the second argument of the split() method:

A common use case for the split() method is when someone supplies their full name as a single string:

Here, we can split the name and save it as different fields of an object to the database, for instance:

Instead of having to call get both elements using an array index, we can use array destructuring to make the assignment cleaner:

Note: The split() method doesn't support certain UTF-8 characters, such as emojis (i.e. 😄, 😍, ⁣💗), and will replace them with a pair of �� .

  • Split String into Array with Array.from()

The from() method from the Array class is the leading contender to the split() method. It's used to create an array, given a source of data - and naturally, it can be used to create an array from an iterable string :

Check out our hands-on, practical guide to learning Git, with best-practices, industry-accepted standards, and included cheat sheet. Stop Googling Git commands and actually learn it!

The major benefit of using Array.from() instead of split() is that you don't have to bother with setting a delimiter - the constituent elements are just re-exposed and added to an array, rather than being converted explicitly. Additionally, the Array.from() method supports emoji characters:

  • Split String into Array with the Spread Operator

The Spread Operator has several uses and is a widely-applicable operator in JavaScript. In our context - we'd be most interested in expanding arrays (strings are arrays of characters).

If you'd like to learn more about the Spread Operator - read our Spread Operator in JavaScript !

The operator's syntax is simple and clean - and we can spread out the string into an array :

The operator also works with UTF-8 emojis:

  • Split String with Object.assign()

The Object.assign() method copies all values and properties of one object - and maps them to the properties of another. In a sense - it's used for cloning objects and merging those with the same properties:

In our case - we'd be copying and mapping the values within a string onto an array:

This approach is a bit more verbose, and less aesthetically pleasing than the previous two:

It's worth noting that Object.assign() doesn't support special UTF-8 characters such as emojis:

In this short guide, we've taken a look at how to convert a string into an array in JavaScript. We've explored the split() method, which has the highest level of customizability - including splitting on Regular Expressions! Then, we've explored the creation of arrays from() sources such as strings. The Spread Operator works very well in expanding strings back to arrays, and we've finally covered the Object.assign() method to assign the values of a string to an array.

You might also like...

  • JavaScript: Check if First Letter of a String is Upper Case
  • Using Mocks for Testing in JavaScript with Sinon.js
  • For-each Over an Array in JavaScript
  • Commenting Code in JavaScript - Types and Best Practices

Improve your dev skills!

Get tutorials, guides, and dev jobs in your inbox.

No spam ever. Unsubscribe at any time. Read our Privacy Policy.

Frontend Developer & Technical Writer

In this article

string assign javascript

React State Management with Redux and Redux-Toolkit

Coordinating state and keeping components in sync can be tricky. If components rely on the same data but do not communicate with each other when...

David Landup

Getting Started with AWS in Node.js

Build the foundation you'll need to provision, deploy, and run Node.js applications in the AWS cloud. Learn Lambda, EC2, S3, SQS, and more!

© 2013- 2024 Stack Abuse. All rights reserved.

How to Convert a JavaScript String to a Number

Converting a JavaScript string into a number is useful for comparing numerical data that comes in string format and completing math operations. Here are seven methods to do it.

Sanchitha Sharma

There are several situations in which you’ll need to convert a JavaScript string into a number. It’s useful for comparing numerical data that comes in a string format, completing math operations on a string and more. 

7 Methods to Convert a JavaScript String to a Number

  • Using parseInt()
  • Using number()
  • Using the unary operator (+)
  • Using parseFloat()
  • Using Math.floor()
  • Multiply with number
  • Using the double tilde (~~) operator

Below are several different methods you can use to convert a string into a number in JavaScript with example code. 

7 Ways to Convert a JavaScript String to a Number

1. using parseint().

parseInt() parses a string and returns a whole number. Spaces are allowed. Only the first number is returned.

This method has a limitation though. If you parse the decimal number, it will be rounded off to the nearest integer value and that value is converted to string. One might need to use the parseFloat() method for literal conversion.

More on JavaScript JavaScript Array Contains: 6 Methods to Find a Value

2. Using Number()

Number() can be used to convert JavaScript variables to numbers. We can also use it to convert the string into a number. If the value can’t be converted to a number, NaN is returned.

3. Using Unary Plus Operator (+)

The unary plus operator (+) precedes its operand and evaluates to its operand, but it also attempts to convert it into a number, if it isn't already.

4. Using parseFloat()

parseFloat() parses a string and returns a number. Spaces are allowed. Only the first number is returned.

5. Using Math.floor()

The Math.floor() function returns the largest integer less than or equal to a given number. This can be a little tricky with decimal numbers since it will return the value of the nearest integer as a whole number.

6. Multiply with number

Multiplying the string value with the 1 won’t change the value, and it will convert the string to a number by default.

7. Double tilde (~~) Operator

We can use the double tilde (~~) operator to convert the string to number.

More on JavaScript Top 50 JavaScript Interview Questions With Example Answers

How to Pick the Best Method to Convert a JavaScript String to a Number

Although there are many ways to convert string to number in JavaScript, one has to be careful which one they use.

1. Check for Null Explicitly 

If null represents a special case in your application, it’s important to check for it before converting. 

2. Fallback Values

Use logical OR (||) to provide a fallback value when conversions return NaN . For example: 

3. Readability

I prefer to use the Number()  method because it’s easier for developers to read the code, and it’s quite intuitive to realize that it’s converting a string to Number .

4. Performance

Chart of performance for each method to convert a javascript string to a number.

Above is the performance chart for each method. Sometimes it makes sense to select the method with the highest performance. 

Recent Expert Contributors Articles

Is Your Startup Idea Truly Innovative?

  • United States
  • United Kingdom

ECMAScript 2024 features you can use now

Ecmascript 2024 is expected to be finalized in june, but four new javascript features are already supported in browsers and node.js. here's how to start using them today..

Matthew Tyson

Contributor, InfoWorld |

ECMAScript 2024 features you can use now


Object.groupby & map.groupby, atomics.waitasync, string.iswellformed & string.towellformed .

The ECMAScript specification is like a portrait of the JavaScript language that is repainted every year. As is typical of modern JavaScript, the spec and real-world practice move in tandem. The newest version of the spec, ECMAScript 2024 , includes seven new JavaScript features and is expected to be finalized in June. This article introduces four of the new features that are already available in browsers and server-side environments, and ready for you to use today:

  • Promise.withResolvers  is a powerful mechanism for managing asynchronous operations when external control over resolution and rejection is necessary.
  • Object.groupBy and Map.groupBy  let you organize collections based on key properties.
  • Atomics.waitAsync  facilitates safe communication and synchronization between worker threads.
  • String.isWellFormed and String.toWellFormed  add valuable tools for handling user input and network data.

Let’s start with the new static method on Promise , called withResolvers() . JavaScript promises give us various ways to deal with asynchronous operations. The withResolvers() method is used to create the three parts of a Promise : the Promise itself and the resolve() and reject() functions. 

The benefit of withResolvers() is that it creates all three as externally exposed references. In cases where you want to create a promise, and also have access to the resolution and rejection of the promise from external code, this is the method to use.

The spec itself is characteristically spartan in its description . The Mozilla documentation provides more detail . The key takeaway is that withResolvers() is equivalent to:

In the above snippet, we declare the resolve and reject references in the enclosing scope, then use them inside the body of the Promise callback to refer to the resolve and reject arguments. In this way, we're getting a handle on the promise callback from outside the callback itself.

The Promise.withResolvers() syntax is more compact and we don't have to declare the resolve and reject separately. With this method, we could write the exact same functionality as above like so:

The essence of this capability is that you use it when you need outside access to resolve() and reject() . This isn’t a very common scenario but it happens. Let’s consider a simple example:

Here, we have two operations, fetchData1() and fetchData2() , that return promises. They run timeouts, and fetchData2() is always fastest at 500 milliseconds. We use withResolvers() inside the race() function to expose the resolve and reject functions. These functions are then used by a new promise, called racePromise .

We then use the resolve and reject functions to respond to the two fetchData operations. This is interesting because you can see we don’t even provide a callback to racePromise . Instead, we control the promise externally. We use that control to bind the outcome of the other two promises to racePromise .

This is a contrived example, and somewhat unrealistic because the two racing promises do not begin at the same time. The point is to show the essence of how and when to use withResolvers() .

The handy groupBy method is a quick way to organize collections based on a string value. It's a static method on Object and Map , which works on an array-like collection. The groupBy() method takes two arguments: the collection and a callback that operates on it. You get back a new object instance that has string label values as keys, and the corresponding array elements as the value.

So, when you have an array, and you need to divvy up the elements into string-labeled buckets according to some internal criteria, this is the method to use.

This is a fairly common thing that comes up in day-to-day coding. Looking at an example should make it clear. Say we have a collection of dog breeds and their size:

Now, say we want to organize this collection by size. We want to end up with a collection of objects where the keys are the breed size and the values are the dog breed. Normally, we’d write a loop to do this but it's a bit finicky; it seems like there should be a better way. Now, with groupBy() , there is:

This gives you a simple, functional way to group collections of objects based on some property of the objects themselves. 

The groupBy() method takes whatever is returned by the callback and automatically collects all the elements that are equal according to String equality . If the return value is not a string, it’ll be coerced into a string. If it can’t be coerced, it’ll error out.

The new Atomics.waitAsync() method is designed for sharing data across worker threads safely. It does not block the main thread like Atomics.wait() does. Because it is used between threads, it relies on the SharedArrayBuffer class. 

This class is disabled by default in modern browsers unless security requirements are met . In Node.js, however, the class is enabled by default. 

Here’s a simple example for usage in Node. Note that the imports are built into Node, so no NPM installs are required (but note that the import statement is):

To run this program, just enter: $ node asyncWait.js

The program declares a SharedArrayBuffer (wrapped around an int32Array ) and then checks if we are on the main thread. If it is the main thread, we spawn a worker thread. (If you are new to worker threads, here's a good intro .)

The main thread waits for an update from the worker via the Atomics.waitAsync() call. The three args to waitAsync(1, 2, 3) are:

  • Shared array ( int32Array ): The shared memory space.
  • Element to watch ( 0 ): The index of the array to wait upon.
  • Initial value ( initialValue = 0 ): Only notify the main thread if this value is different (i.e., if the worker sets the value to the initial value of 0, a notification will not occur).

User input, bad data, and network glitches are all sources of malformed strings.  String.isWellFormed is a sanity check. It determines if a string is UTF-16 valid. UTF-16 is the encoding JavaScript itself uses, so String.isWellFormed() ensures a given string is something JavaScript can handle:

You can learn more about what constitutes valid strings in JavaScript in this section of the Mozilla reference . The bad guys in UTF-16 encoding are known as “lone surrogates.”

The active partner to String.isWellFormed , String.toWellFormed transforms a given string into something valid. Any lone surrogates found will be replaced by U+FFFD, the black diamond question mark character: �.

We’ve got a nice collection of new features in ECMAScript 2024.  Promise.withResolvers() and Atomics.waitAsync() are more advanced use cases, while groupBy is a convenient addition that often comes in handy, and the new string methods are perfect for certain situations. All of these features are supported for JavaScript in browsers and server-side environments, so you can start using them today.

Next read this:

  • Why companies are leaving the cloud
  • 5 easy ways to run an LLM locally
  • Coding with AI: Tips and best practices from developers
  • Meet Zig: The modern alternative to C
  • What is generative AI? Artificial intelligence that creates
  • The best open source software of 2023
  • Programming Languages
  • Software Development

Matthew Tyson is a founder of Dark Horse Group, Inc. He believes in people-first technology. When not playing guitar, Matt explores the backcountry and the philosophical hinterlands. He has written for JavaWorld and InfoWorld since 2007.

Copyright © 2024 IDG Communications, Inc.

string assign javascript

JS Tutorial

Js versions, js functions, js html dom, js browser bom, js web apis, js vs jquery, js graphics, js examples, js references, javascript operators.

Javascript operators are used to perform different types of mathematical and logical computations.

The Assignment Operator = assigns values

The Addition Operator + adds values

The Multiplication Operator * multiplies values

The Comparison Operator > compares values

JavaScript Assignment

The Assignment Operator ( = ) assigns a value to a variable:

Assignment Examples

Javascript addition.

The Addition Operator ( + ) adds numbers:

JavaScript Multiplication

The Multiplication Operator ( * ) multiplies numbers:


Types of javascript operators.

There are different types of JavaScript operators:

  • Arithmetic Operators
  • Assignment Operators
  • Comparison Operators
  • String Operators
  • Logical Operators
  • Bitwise Operators
  • Ternary Operators
  • Type Operators

JavaScript Arithmetic Operators

Arithmetic Operators are used to perform arithmetic on numbers:

Arithmetic Operators Example

Arithmetic operators are fully described in the JS Arithmetic chapter.


JavaScript Assignment Operators

Assignment operators assign values to JavaScript variables.

The Addition Assignment Operator ( += ) adds a value to a variable.

Assignment operators are fully described in the JS Assignment chapter.

JavaScript Comparison Operators

Comparison operators are fully described in the JS Comparisons chapter.

JavaScript String Comparison

All the comparison operators above can also be used on strings:

Note that strings are compared alphabetically:

JavaScript String Addition

The + can also be used to add (concatenate) strings:

The += assignment operator can also be used to add (concatenate) strings:

The result of text1 will be:

When used on strings, the + operator is called the concatenation operator.

Adding Strings and Numbers

Adding two numbers, will return the sum, but adding a number and a string will return a string:

The result of x , y , and z will be:

If you add a number and a string, the result will be a string!

JavaScript Logical Operators

Logical operators are fully described in the JS Comparisons chapter.

JavaScript Type Operators

Type operators are fully described in the JS Type Conversion chapter.

JavaScript Bitwise Operators

Bit operators work on 32 bits numbers.

The examples above uses 4 bits unsigned examples. But JavaScript uses 32-bit signed numbers. Because of this, in JavaScript, ~ 5 will not return 10. It will return -6. ~00000000000000000000000000000101 will return 11111111111111111111111111111010

Bitwise operators are fully described in the JS Bitwise chapter.

Test Yourself With Exercises

Multiply 10 with 5 , and alert the result.

Start the Exercise

Test Yourself with Exercises!

Exercise 1 »   Exercise 2 »   Exercise 3 »   Exercise 4 »   Exercise 5 »

Get Certified



Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

Top references, top examples, get certified.

  • CSS Tutorial
  • CSS Exercises
  • CSS Interview Questions
  • CSS Selectors
  • CSS Properties
  • CSS Functions
  • CSS Examples
  • CSS Cheat Sheet
  • CSS Templates
  • CSS Frameworks
  • CSS Formatter
  • How to remove a Class name from an Element using JavaScript ?
  • How to Hide an HTML Element by Class using JavaScript ?
  • How to add a class to DOM element in JavaScript?
  • How to change style/class of an element using JavaScript ?
  • How to get the child element of a parent using JavaScript ?
  • How to Get Value by Class Name using JavaScript ?
  • How to Toggle an Element Class in JavaScript ?
  • How to Access <tr> element from Table using JavaScript ?
  • JavaScript adding a class name to the element
  • How to check two elements are same using jQuery/JavaScript ?
  • How to get all CSS styles that are applied directly to an element using JavaScript ?
  • How to get the data attributes of an element using JavaScript ?
  • How to get the class of a element which has fired an event using JavaScript/JQuery?
  • How to check if the clicked element is a div or not in JavaScript ?
  • How to add a class to the last paragraph element using jQuery ?
  • How to Check an Element with Specific ID Exists using JavaScript ?
  • How to get the type of DOM element using JavaScript ?
  • How to apply CSS in a particular div element using jQuery ?
  • How to convert Color Names to Hexcode using JavaScript ?

How to Filter a DIV Element Based on its Class Name using JavaScript?

Div Element can be filtered based on class name for displaying specific content using JavaScript . Here, we will explore two different approaches to filtering a DIV element.

Table of Content

Using querySelectorAll and classList

Using getelementsbyclassname.

In this approach, we are using querySelectorAll to select all elements with the class name ‘box’, and classList.contains to check if each box has the specified class name. If it does, we set its display style to ‘block’, otherwise to ‘none’, achieving the filtering effect based on the class name.

Example: The below example uses querySelectorAll and classList to filter a DIV element based on its class name using JavaScript.

In this approach, we are using the getElementsByClassName method in JavaScript to filter <div> elements based on their class name. When a button is clicked, the function approach2Fn(className) displays only the <div> elements with the matching class name while hiding the others.

Example: The below example uses getElementsByClassName to filter a DIV element based on its class name using JavaScript.

Please Login to comment...

Similar reads.

  • CSS-Questions
  • Web Technologies

Improve your Coding Skills with Practice


What kind of Experience do you want to share?

  • Skip to main content
  • Skip to search
  • Skip to select language
  • Sign up for free
  • Português (do Brasil)

Regular expressions

Regular expressions are patterns used to match character combinations in strings. In JavaScript, regular expressions are also objects. These patterns are used with the exec() and test() methods of RegExp , and with the match() , matchAll() , replace() , replaceAll() , search() , and split() methods of String . This chapter describes JavaScript regular expressions.

Creating a regular expression

You construct a regular expression in one of two ways:

  • Using a regular expression literal, which consists of a pattern enclosed between slashes, as follows: js const re = / ab + c / ; Regular expression literals provide compilation of the regular expression when the script is loaded. If the regular expression remains constant, using this can improve performance.
  • Or calling the constructor function of the RegExp object, as follows: js const re = new RegExp ( "ab+c" ) ; Using the constructor function provides runtime compilation of the regular expression. Use the constructor function when you know the regular expression pattern will be changing, or you don't know the pattern and are getting it from another source, such as user input.

Writing a regular expression pattern

A regular expression pattern is composed of simple characters, such as /abc/ , or a combination of simple and special characters, such as /ab*c/ or /Chapter (\d+)\.\d*/ . The last example includes parentheses, which are used as a memory device. The match made with this part of the pattern is remembered for later use, as described in Using groups .

Note: If you are already familiar with the forms of a regular expression, you may also read the cheat sheet for a quick lookup for a specific pattern/construct.

Using simple patterns

Simple patterns are constructed of characters for which you want to find a direct match. For example, the pattern /abc/ matches character combinations in strings only when the exact sequence "abc" occurs (all characters together and in that order). Such a match would succeed in the strings "Hi, do you know your abc's?" and "The latest airplane designs evolved from slabcraft." . In both cases the match is with the substring "abc" . There is no match in the string "Grab crab" because while it contains the substring "ab c" , it does not contain the exact substring "abc" .

Using special characters

When the search for a match requires something more than a direct match, such as finding one or more b's, or finding white space, you can include special characters in the pattern. For example, to match a single "a" followed by zero or more "b" s followed by "c" , you'd use the pattern /ab*c/ : the * after "b" means "0 or more occurrences of the preceding item." In the string "cbbabbbbcdebc" , this pattern will match the substring "abbbbc" .

The following pages provide lists of the different special characters that fit into each category, along with descriptions and examples.

Assertions include boundaries, which indicate the beginnings and endings of lines and words, and other patterns indicating in some way that a match is possible (including look-ahead, look-behind, and conditional expressions).

Distinguish different types of characters. For example, distinguishing between letters and digits.

Groups group multiple patterns as a whole, and capturing groups provide extra submatch information when using a regular expression pattern to match against a string. Backreferences refer to a previously captured group in the same regular expression.

Indicate numbers of characters or expressions to match.

If you want to look at all the special characters that can be used in regular expressions in a single table, see the following:

Note: A larger cheat sheet is also available (only aggregating parts of those individual articles).

If you need to use any of the special characters literally (actually searching for a "*" , for instance), you must escape it by putting a backslash in front of it. For instance, to search for "a" followed by "*" followed by "b" , you'd use /a\*b/ — the backslash "escapes" the "*" , making it literal instead of special.

Similarly, if you're writing a regular expression literal and need to match a slash ("/"), you need to escape that (otherwise, it terminates the pattern). For instance, to search for the string "/example/" followed by one or more alphabetic characters, you'd use /\/example\/[a-z]+/i —the backslashes before each slash make them literal.

To match a literal backslash, you need to escape the backslash. For instance, to match the string "C:\" where "C" can be any letter, you'd use /[A-Z]:\\/ — the first backslash escapes the one after it, so the expression searches for a single literal backslash.

If using the RegExp constructor with a string literal, remember that the backslash is an escape in string literals, so to use it in the regular expression, you need to escape it at the string literal level. /a\*b/ and new RegExp("a\\*b") create the same expression, which searches for "a" followed by a literal "*" followed by "b".

If escape strings are not already part of your pattern you can add them using String.prototype.replace() :

The "g" after the regular expression is an option or flag that performs a global search, looking in the whole string and returning all matches. It is explained in detail below in Advanced Searching With Flags .

Why isn't this built into JavaScript? There is a proposal to add such a function to RegExp.

Using parentheses

Parentheses around any part of the regular expression pattern causes that part of the matched substring to be remembered. Once remembered, the substring can be recalled for other use. See Groups and backreferences for more details.

Using regular expressions in JavaScript

Regular expressions are used with the RegExp methods test() and exec() and with the String methods match() , matchAll() , replace() , replaceAll() , search() , and split() .

When you want to know whether a pattern is found in a string, use the test() or search() methods; for more information (but slower execution) use the exec() or match() methods. If you use exec() or match() and if the match succeeds, these methods return an array and update properties of the associated regular expression object and also of the predefined regular expression object, RegExp . If the match fails, the exec() method returns null (which coerces to false ).

In the following example, the script uses the exec() method to find a match in a string.

If you do not need to access the properties of the regular expression, an alternative way of creating myArray is with this script:

(See Using the global search flag with exec() for further info about the different behaviors.)

If you want to construct the regular expression from a string, yet another alternative is this script:

With these scripts, the match succeeds and returns the array and updates the properties shown in the following table.

As shown in the second form of this example, you can use a regular expression created with an object initializer without assigning it to a variable. If you do, however, every occurrence is a new regular expression. For this reason, if you use this form without assigning it to a variable, you cannot subsequently access the properties of that regular expression. For example, assume you have this script:

However, if you have this script:

The occurrences of /d(b+)d/g in the two statements are different regular expression objects and hence have different values for their lastIndex property. If you need to access the properties of a regular expression created with an object initializer, you should first assign it to a variable.

Advanced searching with flags

Regular expressions have optional flags that allow for functionality like global searching and case-insensitive searching. These flags can be used separately or together in any order, and are included as part of the regular expression.

To include a flag with the regular expression, use this syntax:

Note that the flags are an integral part of a regular expression. They cannot be added or removed later.

For example, re = /\w+\s/g creates a regular expression that looks for one or more characters followed by a space, and it looks for this combination throughout the string.

You could replace the line:

and get the same result.

The m flag is used to specify that a multiline input string should be treated as multiple lines. If the m flag is used, ^ and $ match at the start or end of any line within the input string instead of the start or end of the entire string.

Using the global search flag with exec()

RegExp.prototype.exec() method with the g flag returns each match and its position iteratively.

In contrast, String.prototype.match() method returns all matches at once, but without their position.

Using unicode regular expressions

The u flag is used to create "unicode" regular expressions; that is, regular expressions which support matching against unicode text. An important feature that's enabled in unicode mode is Unicode property escapes . For example, the following regular expression might be used to match against an arbitrary unicode "word":

Unicode regular expressions have different execution behavior as well. RegExp.prototype.unicode contains more explanation about this.

Note: Several examples are also available in:

  • The reference pages for exec() , test() , match() , matchAll() , search() , replace() , split()
  • The guide articles: character classes , assertions , groups and backreferences , quantifiers

Using special characters to verify input

In the following example, the user is expected to enter a phone number. When the user presses the "Check" button, the script checks the validity of the number. If the number is valid (matches the character sequence specified by the regular expression), the script shows a message thanking the user and confirming the number. If the number is invalid, the script informs the user that the phone number is not valid.

The regular expression looks for:

  • the beginning of the line of data: ^
  • followed by three numeric characters \d{3} OR | a left parenthesis \( , followed by three digits \d{3} , followed by a close parenthesis \) , in a non-capturing group (?:)
  • followed by one dash, forward slash, or decimal point in a capturing group ()
  • followed by three digits \d{3}
  • followed by the match remembered in the (first) captured group \1
  • followed by four digits \d{4}
  • followed by the end of the line of data: $

An online tool to learn, build, & test Regular Expressions.

An online regex builder/debugger

An online interactive tutorials, Cheat sheet, & Playground.

An online visual regex tester.


  1. How to Use Strings in JavaScript, Basic Tutorial

    string assign javascript

  2. How to assign a string to a variable using if else in javascript?

    string assign javascript

  3. String Array in JavaScript

    string assign javascript

  4. JavaScript String Operators

    string assign javascript

  5. What is a String in JS? The JavaScript String Variable Explained

    string assign javascript

  6. Your Guide to String Concatenation in JavaScript

    string assign javascript


  1. Javascript String and Array methods

  2. String.endsWith(); Method in JavaScript..? 🤔🔥 #javascript #webdevelopment

  3. substring in javascript

  4. 50 substring String em JavaScript

  5. JavaScript Reverse String Challenge #javascript #coding #dsa

  6. String.startsWith(); Method in JavaScript..? 🤔🔥 #javascript #webdevelopment


  1. How To Work with Strings in JavaScript

    We can use the concatenation operator to show the string on multiple lines. const threeLines = "This is a string\n" + "that spans across\n" + "three lines."; Instead of concatenating multiple strings, we can use the \ escape character to escape the newline. const threeLines = "This is a string\n\.

  2. How do I put variables inside javascript strings?

    What if my string is a part of configuration file hello ${my_name}, how are you doing and I want to assign variable dynamically after reading string from config? - Amreesh Tyagi Jul 11, 2018 at 15:39

  3. JavaScript Strings

    Normally, JavaScript strings are primitive values, created from literals: let x = "John"; But strings can also be defined as objects with the keyword new: let y = new String ("John");

  4. Handling text

    console.log(typeof myString2); // string. These constructs can be really useful in some situations. For example, if a user enters a number into a form's text field, it's a string. However, if you want to add this number to something, you'll need it to be a number, so you could pass it through Number() to handle this.

  5. The JavaScript String Handbook

    Strings, in the context of JavaScript, are essential data types that represent sequences of characters. They are integral to web development, forming the foundation for handling and presenting textual information on websites. Whether it's displaying user names, handling form input, or generating dynamic content, strings are omnipresent in JavaScript programming.

  6. String

    The String object is used to represent and manipulate a sequence of characters. ... attempting to delete or assign a value to these properties will not succeed. The properties involved are neither writable nor configurable. ... Note that JavaScript distinguishes between String objects and primitive string values. (The same is true of Boolean ...

  7. Strings

    The usual workaround is to create a whole new string and assign it to str instead of the old one. For instance: let str = 'Hi'; str = 'h' + str[1]; // replace the string alert( str ); // hi. ... because strings in JavaScript are immutable. But we can make a new string based on the existing one, with the uppercased first character:

  8. Expressions and operators

    This chapter describes JavaScript's expressions and operators, including assignment, comparison, arithmetic, bitwise, logical, string, ternary and more. At a high level, an expression is a valid unit of code that resolves to a value. There are two types of expressions: those that have side effects (such as assigning values) and those that ...

  9. JavaScript Multiline String

    How to Create Multiline Strings in JavaScript. There are three ways to create strings that span multiple lines: By using template literals. By using the + operator - the JavaScript concatenation operator. By using the \ operator - the JavaScript backslash operator and escape character.

  10. JavaScript String Methods

    Note. The replace() method does not change the string it is called on.. The replace() method returns a new string.. The replace() method replaces only the first match. If you want to replace all matches, use a regular expression with the /g flag set. See examples below.

  11. How to Join/Concatenate Strings in JavaScript

    Concatenate With the + Operator. The easiest, and probably most intuitive approach to string concatenation is using the + operator: console .log( "hello " + "world" ); Running this short piece of code results in: hello world. It is possible to assign a string in memory to a reference variable, and reference the object instead of concatenating ...

  12. How to Convert a String to an Array in JavaScript

    Split String into Array with Array.from() The from() method from the Array class is the leading contender to the split() method. It's used to create an array, given a source of data - and naturally, it can be used to create an array from an iterable string:

  13. Object.assign()

    Later sources' properties overwrite earlier ones. The Object.assign() method only copies enumerable and own properties from a source object to a target object. It uses [[Get]] on the source and [[Set]] on the target, so it will invoke getters and setters. Therefore it assigns properties, versus copying or defining new properties.

  14. JavaScript Variables

    The Assignment Operator. In JavaScript, the equal sign (=) is an "assignment" operator, not an "equal to" operator. ... In programming, text values are called text strings. JavaScript can handle many types of data, but for now, just think of numbers and strings.

  15. JavaScript OR (||) variable assignment explanation

    The boolean operators in JavaScript can return an operand, and not always a boolean result as in other languages. The Logical OR operator ( ||) returns the value of its second operand, if the first one is falsy, otherwise the value of the first operand is returned. For example: "foo" || "bar"; // returns "foo".

  16. How to Convert a JavaScript String to Number

    It's useful for comparing numerical data that comes in a string format, completing math operations on a string and more. 7 Methods to Convert a JavaScript String to a Number. Using parseInt() Using number() Using the unary operator (+) Using parseFloat() Using Math.floor() Multiply with number. Using the double tilde (~~) operator.

  17. ECMAScript 2024 features you can use now

    String.isWellFormed & String.toWellFormed User input, bad data, and network glitches are all sources of malformed strings. String.isWellFormed is a sanity check. It determines if a string is UTF ...

  18. Assignment (=)

    The assignment (=) operator is used to assign a value to a variable or property. ... Because the global object has a String property (Object.hasOwn(globalThis, "String")), ... JavaScript does not have implicit or undeclared variables. It just conflates the global object with the global scope and allows omitting the global object qualifier ...

  19. JavaScript Operators

    JavaScript Assignment Operators. Assignment operators assign values to JavaScript variables. The Addition Assignment Operator (+=) adds a value to a variable. ... JavaScript String Comparison. All the comparison operators above can also be used on strings: Example. let text1 = "A";

  20. REST API for Oracle Fusion Cloud HCM

    The REST client may isolate itself from these changes or choose to interact with the latest version of the API by specifying this header. For example: Metadata-Context:sandbox="TrackEmployeeFeature". The protocol version between a REST client and service. If the client does not specify this header in the request the server will pick a default ...

  21. How to Filter a DIV Element Based on its Class Name using JavaScript

    Div Element can be filtered based on class name for displaying specific content using JavaScript. Here, we will explore two different approaches to filtering a DIV element. Table of Content. Using querySelectorAll and classList. Using getElementsByClassName.

  22. Casting to string in JavaScript

    This is not entirely true. As you can see from the results, concatenating an empty string and an object does not yield the same result as concatenating an object and an empty string. Furthermore, new String(blarg) gives you a String object you can call toString() on. In my Chrome debugger, they effectively result the same kind of object except said difference.

  23. Template literals (Template strings)

    Template literals are enclosed by backtick (`) characters instead of double or single quotes.Along with having normal strings, template literals can also contain other parts called placeholders, which are embedded expressions delimited by a dollar sign and curly braces: ${expression}.The strings and placeholders get passed to a function — either a default function, or a function you supply.

  24. Security Update Guide

    The information provided in the Microsoft Knowledge Base is provided "as is" without warranty of any kind. Microsoft disclaims all warranties, either express or implied, including the warranties of merchantability and fitness for a particular purpose.

  25. Logical OR assignment (||=)

    Description. Logical OR assignment short-circuits, meaning that x ||= y is equivalent to x || (x = y), except that the expression x is only evaluated once. No assignment is performed if the left-hand side is not falsy, due to short-circuiting of the logical OR operator. For example, the following does not throw an error, despite x being const: js.

  26. Regular expressions

    Regular expressions are patterns used to match character combinations in strings. In JavaScript, regular expressions are also objects. These patterns are used with the exec() and test() methods of RegExp, and with the match(), matchAll(), replace(), replaceAll(), search(), and split() methods of String. This chapter describes JavaScript regular expressions.