10 Ways to Convert a Value to String in JavaScript

Converting values to strings is a common task in JavaScript, especially when working with dynamic data. JavaScript provides several techniques to perform this conversion, each with its own use case. Let’s explore 10 different ways to convert a value to a string, with explanations and examples for each.

1.Using the String() Constructor

The String() constructor is a straightforward and versatile method to convert values to strings. It works on numbers, booleans, arrays, and more.

const num = 123;
const str = String(num);
console.log(str); // "123"
console.log(typeof str); // "string"

This method is clean and widely used because it works with all data types.

2.Using the .toString() Method

Most data types in JavaScript (like numbers and arrays) have a .toString() method that converts them to strings. However, it can throw an error if called on null or undefined.

const num = 123;
const str = num.toString();
console.log(str); // "123"
console.log(typeof str); // "string"

⚠️ Note: Be cautious when using .toString() on variables that could be null or undefined.

3.Using Template Literals

Template literals are an elegant way to convert values to strings, especially when embedding them in larger strings.

const num = 123;
const str = `${num}`;
console.log(str); // "123"
console.log(typeof str); // "string"

This approach is concise and useful when you need to include other text or variables in the string.

4.Concatenating with an Empty String

Adding an empty string ("") to a value forces JavaScript to coerce it into a string.

const num = 123;
const str = num + "";
console.log(str); // "123"
console.log(typeof str); // "string"

This method is popular for its brevity, but it might reduce code readability in some cases.

5.Using JSON.stringify()

JSON.stringify() is a powerful method that converts objects, arrays, and primitive types into strings.

const num = 123;
const str = JSON.stringify(num);
console.log(str); // "123"
console.log(typeof str); // "string"

It is particularly useful when working with complex data structures like objects or arrays.

6.Using the new String() Constructor

The new String() constructor creates a String object. However, it's not commonly recommended for converting primitives because it creates an object, not a primitive string.

const num = 123;
const strObj = new String(num);
console.log(strObj); // [String: '123']
console.log(typeof strObj); // "object"
console.log(strObj.toString()); // "123"

Use this method only when you specifically need a String object.

7.Using Object.prototype.toString.call()

This method is more technical and used for debugging or determining data types, but it can also convert values to strings.

const num = 123;
const str = Object.prototype.toString.call(num).slice(8, -1);
console.log(str); // "Number"

⚠️ This is not ideal for simple value-to-string conversions but is worth knowing for advanced use cases.

8.Using Array.prototype.join()

Converting a value to an array and then joining it is another way to achieve string conversion.

const num = 123;
const str = [num].join("");
console.log(str); // "123"
console.log(typeof str); // "string"

This is an unconventional method but works well for converting arrays of numbers to strings.

9.Using Unary Plus with .toString()

Using a unary + converts strings to numbers, but combined with .toString(), it can convert them back to strings.

const str = (+"123").toString();
console.log(str); // "123"
console.log(typeof str); // "string"

This method is not common but demonstrates how type coercion can be used creatively.

10.Using parseInt() and .toString()

If your input is a string containing a number, you can parse it to a number first and then convert it back to a string.

const str = parseInt("123", 10).toString();
console.log(str); // "123"
console.log(typeof str); // "string"

This method ensures that the input is a valid number before converting it to a string.

Summary Table

Method	Description
`String()`	Simple, works for all data types
`.toString()`	Direct method, avoid with `null` or `undefined`
Template Literals	Concise and integrates with other text
Concatenation with `""`	Quick but might affect readability
`JSON.stringify()`	Ideal for objects and arrays
`new String()`	Creates String object, not recommended for primitives
`Object.prototype.toString`	Advanced, useful for debugging
`Array.prototype.join()`	Converts arrays to strings
Unary `+` and `.toString()`	Creative use of type coercion
`parseInt()` and `.toString`	Ensures valid number before conversion