2.11 Type Conversion and Coercion in JavaScript

13 min read

The tutorial covers type conversion and coercion in JavaScript – crucial aspects of data manipulation.

JavaScript has 7 data types, divided into primitive and complex. Type conversion is manual data type transformation, while coercion is automatic type conversion. Understanding these concepts is fundamental, as they enable concise and readable codes in scenarios where computations involve differing data types.

The tutorial provides examples of scenarios, highlighting both predictable and surprising outcomes, to foster better awareness and proficiency in coding.

JavaScript Data Types

We’ve covered decision-making with if and else statements, and now, here, we’ll delve into the topic of “type conversion and coercion in JavaScript,” requiring a revisit to value types.

JavaScript encompasses 7 data types: null, undefined, boolean, number, string, object, and symbol (introduced in ES6). The two primary categories of data in JavaScript are Primitive Data Types (String, Number, Boolean) and Complex Data Types (Object).

Types are fundamental in programming, and the conversion between them is a common task across programming languages. For instance, transforming a string into a number or converting a number to a Boolean is a routine practice.

It’s crucial to grasp these concepts before progressing further in the tutorials, especially in a language like JavaScript, known for its occasional peculiar behavior, as demonstrated in this tutorial.

Type Conversion and Coercion

JavaScript features both type conversion and type coercion, terms that may sound similar but carry distinct meanings.

Type conversion occurs when we manually convert from one type to another.

Conversely, type coercion is when JavaScript automatically performs type conversions behind the scenes. This is necessary in certain situations, but it occurs implicitly, hidden from our direct view.

Type Conversion

Let’s delve into type conversion, a process where we explicitly transform data from one type to another.

Consider a scenario where a web page features an input field prompting users to enter their birth year. Typically, inputs from such fields arrive as strings. For instance, let’s assume the variable “inputYear” received from the user interface is a string with the value “1989”. However, if we intend to perform calculations with this value, the following code won’t suffice:

const inputYear = "1989";

To illustrate, imagine adding 18 to this string to calculate the year when the person turns of legal age. When dealing with strings, adding a number concatenates the strings rather than performing numerical addition. This is demonstrated below:

let fullAgeYear = inputYear + 18; // Output will be a string: "198918"
console.log(fullAgeYear); // 198918

As expected, the result is a string combining “1989” and “18”. To address this, we need to convert the string “1989” into a numerical format. To achieve this, we utilize the built-in Number function. The conversion is accomplished by invoking the Number function with parentheses, as shown here:

let numericInputYear = Number(inputYear);
console.log(numericInputYear); // 1989

In the next section, we will delve into the concept of functions and why they function in this manner. For now, understand that the built-in Number function enables us to convert strings to numbers, executed by placing the string within parentheses.

ALSO READ:  1.3 Understanding the role of JavaScript in web development

Within the console.log parentheses, there’s a Number function applied to inputYear. Despite this nested structure, it’s important not to be confused. Executing this operation converts the string into a number.

Let’s examine the process:

console.log(Number(inputYear)); // Output: 1989

Indeed, the result is now 1989, presented as a number. To make this distinction clearer, let’s print both the numeric and string representations:

console.log(Number(inputYear), inputYear); // Output: 1989 '1989'

The first entry, 1989, is a number, while the second, ‘1989’, remains a string. It’s crucial to note that the original value is not altered; the inputYear variable remains a string holding the value ‘1989’. Consequently, the log of fullAgeYear, calculated as (inputYear + 18), still yields ‘198918’ because the original inputYear variable is still a string. The Number() function facilitates conversion.

To perform the calculation inputYear + 18, the Number() function is essential:

fullAgeYear = Number(inputYear) + 18;

This sequence first converts inputYear to a number and then adds 18. The expected result is approximately 2007:

console.log(fullAgeYear); // Output: 2007

Indeed, the output is as anticipated.

Now, consider attempting to convert an impossible-to-convert string into a number:

console.log(Number("Amit")); // Output: NaN

In this scenario, JavaScript attempts conversion but fails, resulting in ‘NaN,’ denoting “not a number.” When a numeric operation fails, JavaScript returns “NaN” to signify an invalid number. This is confirmed by checking the type using the typeof operator:

console.log(typeof NaN); // Output: number

Surprisingly, the type of “not a number” (NaN) is categorized as a number. Essentially, “not a number” refers to an invalid numeric value—still recognized as a number in a technical sense, albeit an invalid one. Therefore, encountering “NaN” indicates that an operation involving numbers failed to produce a valid numeric result.

Alright, so we’ve covered the process of converting strings to numbers. Now, let’s discuss the reverse operation, which is a bit less crucial but still worth demonstrating.

To convert from a number to a string, we utilize the String function. It’s fairly straightforward—just use String(), but remember to start it with a capital ‘S’, similar to how the Number function requires a capital ‘N’ to work correctly:

console.log(String(27)); // '27'

When the value in the console appears in white, it signifies a string type. Let’s log both to highlight the distinction:

console.log(String(27), 27); // '27' 27

In the console, the white value represents the one with a string type, while the non-white value has a number type.

This conversion isn’t as crucial, but it’s still good to be aware of.

Now, in JavaScript, conversion is limited to three types: number, string, and boolean. It’s not possible to convert something to undefined or null as that wouldn’t be meaningful.

JavaScript can convert to numbers and strings but not directly to booleans. This is because booleans behave differently, and a separate tutorial on truthy and falsy values is forthcoming.

ALSO READ:  1.4 Inline JavaScript

So, that covers manual type conversion. However, in real-world scenarios, manual conversion is rarely necessary because JavaScript automatically performs type coercion in many situations. Let’s delve into that now.

Type Coercion

Type coercion occurs when an operator interacts with two values of differing types in JavaScript. In such instances, JavaScript automatically converts one of the values behind the scenes to ensure compatibility, allowing the operation to proceed. We’ve already witnessed this phenomenon in action, as exemplified by the following:

Consider the expression:

console.log("I am " + 27 + " years old!");

This concatenation of a string and a number results in the output “I am 27 years old!” due to type coercion. The plus operator in JavaScript triggers coercion to strings. When performing an operation between a string and a number, the number is converted to a string. Therefore, the expression is equivalent to:

console.log("I am " + "27" + " years old!"); // I am 27 years old!

The plus operator seamlessly converts numbers to strings through type coercion. This behavior extends to template literals as well:

console.log(`I am ${27} years old!`); // I am 27 years old!

If JavaScript lacked automatic type coercion, as some other languages do, manual conversion would be necessary. In the absence of automatic coercion, the expression would need to be written as:

console.log("I am " + String(27) + " years old!"); // I am 27 years old!

Fortunately, JavaScript streamlines this process by handling type coercion automatically, sparing developers from the need for manual conversions.

Not all operators perform type coercion to strings. Let me demonstrate another example. If we subtract ‘9’ (a string) from ’27’ (a string) and then subtract 3 (a number), what do you expect? Let’s examine it:

console.log("27" - "9" - 3); // 15

Surprisingly, the result is 15. JavaScript, in this case, converts the strings to numbers. This occurs because the minus operator triggers the conversion of strings to numbers. So, 27 minus 9 equals 18, and 18 minus 3 equals 15.

Now, consider using the plus operator:

console.log("27" + "9" + 3); // '2793'

Here, the number 3 is converted to a string, and the three strings are concatenated. Understanding this distinction is crucial, as it often confuses JavaScript beginners.

Let’s try another example where we multiply a string by another string:

console.log("27" * "2"); // 54

The result is 54 because both values are converted to numbers for the multiplication to work. The same applies to division:

console.log("27" / "3"); // 9

Now, to reinforce the distinction between type conversion and type coercion, let’s play a game called “guess the output.” Consider the following code:

let n = "1" + 1;
n = n - 1;
console.log(n); // 10

Surprisingly, the output is 10. The first operation, '1' + 1, results in ’11’ (a string). Then, the minus operator coerces the string ’11’ to the number 11, and subtracting 1 gives the final result of 10.

Let’s explore a couple more examples. Consider the expression 2 plus 3 plus 4 plus 5, all as a string. Now, take a guess at the output:

console.log(2 + 3 + 4 + "5"); // "95"

The result is the string “95.” To break it down, we add 2 and 3 to get 5, then add 4 to get 9. Finally, when we add ‘5’ (a string) to 9, the plus operator converts 9 to a string, resulting in “95.”

ALSO READ:  JavaScript Tutorial

Now, let’s delve into another example: subtracting string 9, string 3, and string 2, followed by subtracting the real number 1, and appending the string ‘4’:

console.log("9" - "3" - "2" - 1 + "4"); // '34'

Although it may seem peculiar, the logic is similar. Subtracting “9” from “3” yields 6, then subtracting “2” gives 4. Subtracting 1 from 4 results in 3. The final step involves converting 3 to a string, resulting in ’34.’

Pitfalls and Challenges

Understanding type conversion and coercion is not without its challenges. Developers may face the following pitfalls:

  • Implicit Behavior: JavaScript’s automatic type coercion can lead to implicit behavior, where conversions happen behind the scenes. This may result in unexpected outcomes if developers are not aware of how JavaScript handles these situations.
  • Unintended Conversions: In some cases, automatic conversions may not align with the developer’s intentions. For instance, when concatenating strings and numbers, automatic conversion to strings might occur, leading to unexpected results.
  • Debugging Complexity: Identifying issues related to type conversion and coercion can be challenging during debugging. The implicit nature of these operations makes it harder to pinpoint the source of unexpected behavior.
  • Lack of Clarity: In complex codebases, understanding where and how type conversion/coercion occurs may not be evident. This lack of clarity can lead to confusion and make the codebase more error-prone.
  • Inconsistent Cross-Browser Behavior: Different JavaScript engines may handle type conversion and coercion slightly differently. Developers need to be mindful of potential inconsistencies when writing code that targets multiple browsers.


Understanding these scenarios is crucial from the outset to write code with awareness. While some may dislike type coercion due to potential unexpected bugs, it becomes a problem mainly when unfamiliar with these concepts. Type coercion can be a powerful mechanism, enabling concise and readable code. Take the time to comprehend how it operates, and incorporate it wisely into your coding practices.

Frequently Asked Questions (FAQs) – Understanding Type Conversion and Coercion in JavaScript

Engaging in the process of learning is a continuous and evolving experience, often accompanied by questions and uncertainties. Embracing this natural aspect of the learning journey, we’ve curated a comprehensive set of Frequently Asked Questions (FAQs) centered around the intricate concepts of “Type Conversion and Coercion in JavaScript.” Whether you seek clarification on the nuances of precedence usage or wish to resolve lingering doubts, our collection of FAQs is tailored to address a spectrum of queries. Seize the opportunity to immerse yourself in this resource, refining and deepening your understanding of Type Conversion and Coercion in the context of JavaScript.

Avatar for Amit

Amit (16)

Hello! I'm Amit Kumar, a passionate teacher specializing in web development and digital marketing. With several years of experience in the industry, I am dedicated to sharing my knowledge and expertise to empower aspiring learners like you.

Teaching Philosophy:

I believe in creating a dynamic and engaging learning environment where students can thrive. My teaching approach focuses on hands-on experience, practical applications, and real-world examples. I strive to make complex concepts understandable and enjoyable, ensuring that you not only grasp the fundamentals but also develop the skills necessary to excel in web development and digital marketing.

Web Development Expertise:

As a web development instructor, I am well-versed in HTML, CSS, JavaScript, and various frameworks such as React and Angular. I will guide you through the process of building responsive and user-friendly websites, exploring topics like front-end development, back-end integration, database management, and more. Together, we will delve into the latest trends and best practices in web development, equipping you with the tools to create stunning online experiences.

Digital Marketing Mastery:

In the rapidly evolving digital landscape, digital marketing is crucial for businesses to thrive. Through my digital marketing courses, I will help you navigate the intricacies of search engine optimization (SEO), social media marketing, content strategy, email marketing, and analytics. Gain insights into effective marketing techniques, harness the power of data-driven decision-making, and learn how to craft compelling campaigns that drive results.

Passion for Teaching:

Teaching is not just a profession for me; it's my passion. I find great joy in witnessing my students grow and succeed. I am committed to fostering a supportive learning community where questions are encouraged, ideas are shared, and challenges are overcome together. I am here to guide you every step of the way and provide the necessary resources for your personal and professional development.

Join me on this exciting journey of learning and discovery. Let's unlock your potential in web development and digital marketing together. Enroll in my courses today and embark on a transformative educational experience that will propel your career forward.
Start Learning Today!

5 1 vote
Article Rating
Notify of


Inline Feedbacks
View all comments
Would love your thoughts, please comment.x
Scroll to Top