Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/javascript/what-is-type-coercion-in-javascript/ below:

What is Type Coercion in JavaScript?

Last Updated : 19 Feb, 2025

JavaScript is a loosely typed or dynamic language, which means it automatically converts types when necessary, making it easier for developers to work with different data types in expressions, comparisons, and operations. However, this flexibility can sometimes lead to unexpected results if you're not careful.

In JavaScript, Type Coercion happens when JavaScript automatically changes one type of value into another. Sometimes, this automatic conversion can cause unexpected results if you’re not aware of how it works.

• Automatic Conversion: When required, the JavaScript automatically converts required data types.
• Works with Three Types: String, Number, and Boolean coercion.
• Can Lead to Unexpected Results: If they are not handled properly, they may cause unintended bugs.
• Implicitly Occurs: Automatically converts the type of the value from one to another.

Output:

"510"

In this example

• JavaScript converts the number 5 into a string.
• Concatenates it with "10".

In JavaScript, type coercion mainly occurs in the three ways:

It occurs when the string is combined with the non-string using (+). JavaScript converts numbers and booleans into strings before concatenation.

console.log("5" + 2); 
console.log("5" + true); 

Output:

"52"
"5true"

• The number 2 is coerced to a string and then concatenated with the string "5", resulting in "52".
• The boolean true is coerced into the string "true", and the two strings are concatenated.

In the number coercion, JavaScript converts the string into a number before operating.

console.log("5" - 2); 
console.log("5" * 2); 
console.log("10" / "2"); 

The string is coerced into a number before performing the arithmetic operation.

JavaScript treats the true value as '1' and the false value as '0'.

console.log(Boolean("hello")); 
console.log(Boolean(0)); 
console.log(Boolean([])); 

Non-empty strings are coerced to true, while 0 is coerced to false.

Comparison Operator(= =), allows coercion due to which the unexpected conversions occur. To avoid this, we should use the strict equality(= = =) operator.

console.log(0 == "0"); 
console.log(0 == false); 
console.log(" " + 0 == 0);

Null and undefined behave unexpectedly.

console.log(null == undefined); 
console.log(null === undefined); 
console.log(null + 1); 

NaN is not equal to itself, so checking with isNaN() is the best way to detect it.

console.log(NaN == NaN); 
console.log(isNaN(NaN)); 

In this example, NaN is not equal to itself, so the isNaN() function is the preferred way to check for NaN.

When we use strict equality, instead of the comparison operator, it prevents unnecessary types of coercion.

=== ensures no implicit type conversion occurs and both values must be of the same type.

Explicit conversion converts the value manually due to which there are fewer chances of errors in the code.

console.log(Number("123"));

This ensures that you're working with the correct type, reducing the chance of errors during operations.

Always check for null, undefined, or empty strings explicitly.

if (value !== null && value !== undefined) {
    console.log("Value exists");
}

This ensures that only non-null and defined values are considered valid.

console.log(parseInt("42px")); 
console.log(parseFloat("3.14abc")); 

This will parse the number part of a string, ensuring a valid numeric conversion.

Use isNaN() to check if a value is NaN instead of comparing it directly.

if (isNaN(value)) {
    console.log("Invalid number");
}

This ensures you're correctly detecting NaN and handling it appropriately.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4