Type coercion and type checking
Type coercion and type checking are basic fundamental programming concepts in JavaScript programming. Type coercion and type checking are mainly used in JavaScript programming to deal with multiple programming data and information so that you can convert and control multiple data type program variables by declaring them in JavaScript program. Applying type coercion and type checking concept in JavaScript helps programmers to avoid program errors or bugs and create a better cleaner program code.
Type Coercion in JavaScript.
Type coercion concept in JavaScript program is generally used for automatic or implicit conversion of one data type to another data type program variable type value. This concept is applied in JavaScript when programmers apply operations related to multiple data type values.
JavaScript forcibly applies implicit data types in many cases in programming, but there are times when explicit coercion or manual conversion is necessary.
Example of implicit coercion in a JavaScript program.
When you try to combine a string and a numeric using the + operator, JavaScript will convert the numeric to a string format.
let test = “Vanhelpsu ” + “7 “;
console.log(test); // Result is – vcanhelpsu 7 here Number 7 is coerced into a string
It also coerces values when performing other program operations in a JavaScript program.
console.log(“9” – 3); // result is – 6 hare String “9” is coerced into a number
console.log(“10” * 3); // result is – 30 here String “10” is coerced into a number
console.log(9 + true); // result is – 10 here Boolean true is coerced into 1
console.log(7 + false); // result is – 7 here Boolean false is coerced into 0
JavaScript programming will not always force you to bind data types to variables in an intuitive way. For example, when using the + operator with two non-numeric strings, JavaScript concatenates the strings instead of adding them.
console.log(“9” + “7”); // result is – “97” it Concatenation instead of addition tow string
Example of explicit coercion in a JavaScript program.
You can coerce data values to explicit formats in a JavaScript program by using built-in functions like String(), Number(), or Boolean().
let num = “789”;
let coercedNumber = Number(num); // it used to Converts string to number format
console.log(coercedNumber); // result is – 789
let bool = 1;
let coercedBoolean = Boolean(bool); // it used to Converts 1 to true
console.log(coercedBoolean); // result is – false
You can also use template literals to convert numeric or other data types variables to strings in a JavaScript program.
let p = 7;
let str = `${p}`; // here it Coerces number to string using template literals
console.log(str); // result is – “7”
Type checking in JavaScript.
Type checking in JavaScript programming is used to define the data type nature of a data type value to determine how it will behave during the current program execution. JavaScript programs provide you with several methods to check the data type of a program variable or value.
Using typeof in JavaScript.
The typeof operator is commonly used in JavaScript programming to test the data type of a data type value. It returns a string value indicating the type of the operand of the data type.
console.log(typeof “Vcanhelpsu”); // result is – “string”
console.log(typeof 11); // result is – “number”
console.log(typeof false); // result is – “boolean”
console.log(typeof null); // result is – “object” here it is a known JavaScript
console.log(typeof undefined); // result is – “undefined”
console.log(typeof Symbol()); // result is – “symbol”
console.log(typeof BigInt(9987)); // result is – “bigint”
console.log(typeof {}); // result is – “object”
console.log(typeof []); // result is – “object” here it use as Arrays are technically objects
Checking array with Array.isArray() in JavaScript.
Here in JavaScript programming the typeof operator returns the “object” data type string value for both object and array data types, here you can specifically check if a value in the current data type is an array or not by using the Array.isArray() method.
let array = [7, 9, 8, 3];
console.log(Array.isArray(array)); // result is – true
let obj = {};
console.log(Array.isArray(obj)); // result is – false
Checking for null in JavaScript programs.
In JavaScript programs the typeof null returns the “object” value, which is like a bug in JavaScript programming, where JavaScript programmers can explicitly test for null data types if they need.
let container = null;
if (container === null) {
console.log(“It’ detect null”); // result is – It’ detect null
}
Using instanceof in JavaScript.
In JavaScript programs the instanceof operator checks if a program object is an instance of a particular class or constructor function. It is helpful for advanced data type checking in JavaScript programs, especially when dealing with objects created from class constructor functions or classes in JavaScript.
let date = new Date();
console.log(date instanceof Date); // result is – true
let arr = [7, 8, 9, 1];
console.log(arr instanceof Array); // result is – true
console.log(arr instanceof Object); // result is – true since arrays are objects
False and Truthy Values in JavaScript Programs.
In JavaScript programs, some data types are considered false where as Boolean operators evaluate to false in a Boolean context and other true values evolve to true values and display the same value.
Falsy values.
false
0
“”empty string
Null value
Undefined data type
NaN data type
False value in JavaScript programs.
if (“”) {
console.log(“This nt print here the empty string is falsy nature”);
}
if (1) {
console.log(“This is dont print because 0 is falsy value”);
}
if (“Hello”) {
console.log(“This is print value because a non-empty string is truthy value”);
}
In JavaScript programs, any other value is treated as true. Here is an example of this.
Type coercion in conditionals in JavaScript programs.
When you use variables in conditional statements like if, the JavaScript program will automatically coerce these values into Boolean values in order to obtain the same values. This is why you can directly apply true and falsy values with if statements in JavaScript.
let testVar = 0;
if (testVar) {
console.log(“This is not print value, because 0 is falsy boolean value”);
} else {
console.log(“This will print value, because 0 is falsy boolean number”);
}
let testString = “vcanhelpsu”;
if (testString) {
console.log(“This will print test string value, because it is a non-empty strings are truthy value”);
}
Examples of type coercion in JavaScript.
JavaScript often automatically performs type coercion in a program, especially when performing comparison and arithmetic operations in a program.
Coercion examples in JavaScript Equality comparison 1.
== (Loose Equal) – This JavaScript program performs coercion to compare two variable values.
console.log(7 == “7”); // result is – true here string “7” is coerced into number 7
console.log(0 == false); // result is – true here false is coerced into 0
console.log(null == undefined); // result is – true here null and undefined are equal in loose equal
=== (Strict Equal) – This JavaScript program does not perform data type coercion. It tests both the data type value and the data type.
console.log(8 === “8”); // result is – false here number 8 is not the same as string “8”
console.log(0 === false); // result is – false here different types: number vs. Boolean operator
Coercion examples in JavaScript arithmetic operations 2.
When performing arithmetic data type operations in this program, the JavaScript program will convert the values to numeric.
console.log(“20” – 7); // result is – 13 here string “20” is coerced into a number
console.log(“7” * 4); // result is – 28 here string “7” is coerced into a number
console.log(“24” / 3); // result is – 8 here string “24” is coerced into a number
Conclusion of Type Coercion and Type Checking in JavaScript.
Data type coercion in JavaScript programming is the automatic conversion of values from one data type to another, and JavaScript programs do this in many cases when performing operations involving multiple data types. This can sometimes display unexpected output as a result, so it is important for you to understand how it works.
Data type checking is very useful for verifying the data type of a program variable, ensuring that your existing JavaScript program code behaves optimally, and it protects JavaScript programmers from runtime errors in the program. You can use typeof, Array.isArray(), instanceof, and === operator to explicitly check multiple data types.
