JavaScript Type Conversion

JavaScript Type Conversion

Learn about automatic type conversion and string conversion in JavaScript. Explore how JavaScript handles data types, automatic conversions, and common scenarios.

JavaScript is a dynamically typed language, which means that variables can change their data types during runtime. Type conversion in JavaScript refers to the process of converting a value from one data type to another. This can happen implicitly or explicitly.

There are two main types of type conversion in JavaScript:

Implicit Type Conversion (Coercion):

Implicit type conversion, also known as type coercion, occurs when JavaScript automatically converts one data type to another behind the scenes. This often happens in operations involving different data types.

For example:

var num = 5;
var str = "10";
var result = num + str; // JavaScript implicitly converts num to a string and performs concatenation.
document.write(result);    // Outputs "510" (a string)

In this example, the number 5 is implicitly converted to a string and concatenated with the string “10”.

Explicit Type Conversion:

Explicit type conversion, also known as type casting, is when you manually convert a value from one data type to another using built-in functions or operators.

JavaScript provides several methods for explicit type conversion:

parseInt() and parseFloat():

These functions are used to convert a string to an integer or a floating-point number, respectively.

var str = "123";
var num = parseInt(str); // Converts the string "123" to the integer 123

String():

The String() function converts a value to a string explicitly.

var num = 456;
var str = String(num); // Converts the number 456 to the string "456"

Number():

The Number() function converts a value to a number explicitly.

var str = "789";
var num = Number(str); // Converts the string "789" to the number 789

Boolean():

The Boolean() function converts a value to a Boolean (true or false).

var val = "Hello";
var boolValue = Boolean(val); // Converts the string "Hello" to true (non-empty strings are truthy)

It’s essential to be aware of type conversion in JavaScript, as it can lead to unexpected behavior in your code if you’re not careful. Understanding How JavaScript handles different data types and when type conversion occurs is crucial for writing robust and predictable code.

Converting Strings to Numbers

You can convert strings to numbers in JavaScript using various methods, such as parseInt(), parseFloat(), or unary plus (+).

Here’s a complete code example demonstrating each of these methods:

// Method 1: Using parseInt()
var str1 = "123";
var num1 = parseInt(str1); // Converts the string "123" to the integer 123
// Method 2: Using parseFloat()
var str2 = "456.78";
var num2 = parseFloat(str2); // Converts the string "456.78" to the floating-point number 456.78
// Method 3: Using unary plus (+)
var str3 = "789";
var num3 = +str3; // Converts the string "789" to the number 789 using the unary plus operator
// Display the results
document.write("Method 1 (parseInt):", num1); // Output: 123
document.write("Method 2 (parseFloat):", num2); // Output: 456.78
document.write("Method 3 (unary plus):", num3); // Output: 789

In this example:

1. We use parseInt() to convert the string “123” to the integer 123.
2. We use parseFloat() to convert the string “456.78” to the floating-point number 456.78.
3. We use the unary plus operator (+) to convert the string “789” to the number 789.

You can choose the method that best suits your needs based on whether you want an integer or a floating-point number. Additionally, it’s important to handle cases where the string cannot be parsed as a valid number, as these methods may return NaN (Not-a-Number) for invalid input.

Converting Numbers to Strings:

complete code example in html

To convert numbers to strings in an HTML environment using JavaScript, you can use various methods like toString(), concatenation with an empty string, or the String() function. Here’s a complete HTML example demonstrating these methods:

<!DOCTYPE html>
<html>
<head>
    <title>Number to String Conversion</title>
</head>
<body>

<h1>Number to String Conversion Example</h1>

<script>
    // Method 1: Using toString()
    var num1 = 123;
    var str1 = num1.toString(); // Converts the number 123 to the string "123"
    // Method 2: Concatenation with an empty string
    var num2 = 456.78;
    var str2 = num2 + ""; // Converts the number 456.78 to the string "456.78"
    // Method 3: Using the String() function
    var num3 = 789;
    var str3 = String(num3); // Converts the number 789 to the string "789"
    // Display the results
    document.write("Method 1 (toString()): " + str1 + "<br>"); // Output: 123
    document.write("Method 2 (concatenation): " + str2 + "<br>"); // Output: 456.78
    document.write("Method 3 (String()): " + str3 + "<br>"); // Output: 789
</script>
</body>
</html>

In this HTML example:

1. We use the toString() method to convert the number 123 to the string “123”.
2. We use concatenation with an empty string (“”) to convert the number 456.78 to the string “456.78”.
3. We use the String() function to convert the number 789 to the string “789”.
4. The results are displayed within the HTML document using the document.write() method.

You can choose the method that best fits your requirements based on your specific use case.

Converting Dates to Numbers:

complete code example in html

• Converting dates to numbers in an HTML environment using JavaScript typically involves obtaining a numeric representation of a date, such as a timestamp.
• You can achieve this by using the Date object’s getTime() method or by converting the date to the number of milliseconds since the epoch.

Here’s a complete HTML example:

<!DOCTYPE html>
<html>
<head>
    <title>Date to Number Conversion</title>
</head>
<body>
<h1>Date to Number Conversion Example</h1>
<script>
    // Create a Date object representing a specific date and time
    var date = new Date("2023-10-02T12:34:56");
    // Method 1: Using the getTime() method
    var timestamp1 = date.getTime(); // Converts the date to a timestamp (milliseconds since epoch)
    // Method 2: Converting to milliseconds since epoch manually
    var timestamp2 = date.valueOf(); // Converts the date to a timestamp (milliseconds since epoch)
    // Display the results
    document.write("Method 1 (getTime()): " + timestamp1 + "<br>"); // Output: A timestamp in milliseconds
    document.write("Method 2 (valueOf()): " + timestamp2 + "<br>"); // Output: Same timestamp as Method 1
</script>
</body>
</html>

In this HTML example:

1. We create a Date object representing a specific date and time, in this case, “2023-10-02T12:34:56.”
2. Method 1: We use the getTime() method of the Date object to convert the date to a timestamp, which represents the number of milliseconds since the epoch (January 1, 1970, 00:00:00 UTC).
3. Method 2: We use the valueOf() method of the Date object to achieve the same result, converting the date to a timestamp in milliseconds since the epoch.
4. Both methods result in the same timestamp, which is displayed in the HTML document using the document.write() method.
5. These timestamps can be useful for performing date calculations or comparisons, as they provide a numeric representation of dates and times.

Converting Numbers to Dates:

complete code example in html

Converting numbers to dates in an HTML environment using JavaScript involves creating a Date object based on a numeric representation of a date, such as a timestamp.

Here’s a complete HTML example that demonstrates this conversion:

<!DOCTYPE html>
<html>
<head>
    <title>Number to Date Conversion</title>
</head>
<body>
<h1>Number to Date Conversion Example</h1>
<script>
    // Method 1: Using a timestamp (milliseconds since epoch)
    var timestamp = 1633130096000; // Example timestamp (for October 2, 2021, 12:34:56 UTC)
    // Create a Date object using the timestamp
    var date1 = new Date(timestamp);
    // Method 2: Using the setMilliseconds() method
    var milliseconds = 96000; // Example milliseconds (for 12:34:56)
    var date2 = new Date(0);  // Create a Date object at the epoch (January 1, 1970, 00:00:00 UTC)
    date2.setMilliseconds(milliseconds);
    // Display the results
    document.write("Method 1 (using timestamp): " + date1 + "<br>"); // Output: Date based on the timestamp
    document.write("Method 2 (using setMilliseconds()): " + date2 + "<br>"); // Output: Date based on milliseconds
</script>
</body>
</html>

In this HTML example:

1. Method 1: We use a timestamp (timestamp variable) representing the number of milliseconds since the epoch (January 1, 1970, 00:00:00 UTC). We then create a Date object (date1) using this timestamp.
2. Method 2: We use a number of milliseconds (milliseconds variable) representing the time of day (12:34:56). We create a Date object (date2) at the epoch (January 1, 1970, 00:00:00 UTC) and set the milliseconds to the desired value using the setMilliseconds() method.
3. Both methods result in a Date object representing a specific date and time based on the numeric input. The results are displayed in the HTML document using the document.write() method.

These conversions can be useful when you have timestamps or other numeric representations of dates and need to work with them as Date objects in JavaScript.

Converting Booleans to Numbers:

complete code example in html

Converting booleans to numbers in an HTML environment using JavaScript is straightforward because JavaScript treats true as 1 and false as 0 when you convert them to numbers.

Here’s a complete HTML example demonstrating this:

<!DOCTYPE html>
<html>
<head>
    <title>Boolean to Number Conversion</title>
</head>
<body>

<h1>Boolean to Number Conversion Example</h1>
<script>
    // Example boolean values
    var bool1 = true;
    var bool2 = false;
    // Convert booleans to numbers
    var num1 = Number(bool1); // Converts true to 1
    var num2 = Number(bool2); // Converts false to 0
    // Display the results
    document.write("Boolean 1 (true) as Number: " + num1 + "<br>"); // Output: 1
    document.write("Boolean 2 (false) as Number: " + num2 + "<br>"); // Output: 0
</script>
</body>
</html>

In this HTML example:

1. We have two example boolean values, bool1 set to true and bool2 set to false.
2. We convert these boolean values to numbers using the Number() function. JavaScript automatically converts true to 1 and false to 0.
3. The results are displayed in the HTML document using the document.write() method.

As demonstrated in the code, converting booleans to numbers is as simple as calling the Number() function with the boolean value as an argument, and JavaScript handles the conversion automatically.

Converting Numbers to Booleans:

Converting numbers to booleans in an HTML environment using JavaScript typically involves checking if a number is nonzero or zero, where nonzero values are considered true, and zero is considered false.

Here’s a complete HTML example demonstrating this conversion:

<!DOCTYPE html>
<html>
<head>
    <title>Number to Boolean Conversion</title>
</head>
<body>
<h1>Number to Boolean Conversion Example</h1>
<script>
    // Example numbers
    var num1 = 42;     // A nonzero number
    var num2 = 0;      // Zero

    // Convert numbers to booleans
    var bool1 = Boolean(num1); // Converts nonzero number to true
    var bool2 = Boolean(num2); // Converts zero to false
    // Display the results
    document.write("Number 1 (42) as Boolean: " + bool1 + "<br>"); // Output: true
    document.write("Number 2 (0) as Boolean: " + bool2 + "<br>");  // Output: false
</script>
</body>
</html>

In this HTML example:

1. We have two example numbers, num1 set to 42 (a nonzero number) and num2 set to 0 (zero).
2. We convert these numbers to booleans using the Boolean() function. JavaScript automatically converts nonzero numbers to true, and zero to false.
3. The results are displayed in the HTML document using the document.write() method.

As shown in the code, converting numbers to booleans is as simple as calling the Boolean() function with the number as an argument, and JavaScript handles the conversion according to its truthy (nonzero) and falsy (zero) rules.

Converting Dates to Numbers: 

Converting dates to numbers typically involves obtaining a numeric representation of a date, such as a timestamp.

Here’s a complete JavaScript example of how to convert a date to a timestamp:

<!DOCTYPE html>
<html>
<head>
    <title>Date to Number Conversion</title>
</head>
<body>
<h1>Date to Number Conversion Example</h1>
<script>
    // Create a Date object representing a specific date and time
    var date = new Date("2023-10-02T12:34:56");
    // Method 1: Using getTime() method
    var timestamp1 = date.getTime(); // Converts the date to a timestamp (milliseconds since epoch)
    // Method 2: Using valueOf() method
    var timestamp2 = date.valueOf(); // Converts the date to a timestamp (milliseconds since epoch)
    // Display the results
    document.write("Date: " + date + "<br>");
    document.write("Method 1 (getTime()): " + timestamp1 + "<br>");
    document.write("Method 2 (valueOf()): " + timestamp2 + "<br>");
</script>
</body>
</html>

In this HTML example:

1. We create a Date object representing a specific date and time, in this case, “2023-10-02T12:34:56.”
2. Method 1: We use the getTime() method of the Date object to convert the date to a timestamp, which represents the number of milliseconds since the epoch (January 1, 1970, 00:00:00 UTC).
3. Method 2: We use the valueOf() method of the Date object to achieve the same result, converting the date to a timestamp in milliseconds since the epoch.
4. The results are displayed in the HTML document using the document.write() method. These timestamps can be useful for performing date calculations or comparisons, as they provide a numeric representation of dates and times.

Converting Dates to Strings:

Converting dates to strings in JavaScript is typically done using the toString(), toDateString(), or other methods provided by the Date object.

Here’s a complete JavaScript example of how to convert a date to a string:

<!DOCTYPE html>
<html>
<head>
    <title>Date to String Conversion</title>
</head>
<body>
<h1>Date to String Conversion Example</h1>
<script>
    // Create a Date object representing a specific date and time
    var date = new Date("2023-10-02T12:34:56");
    // Method 1: Using toString() method
    var dateString1 = date.toString(); // Converts the date to a full string representation
    // Method 2: Using toDateString() method
    var dateString2 = date.toDateString(); // Converts the date to a string with the date portion
    // Display the results
    document.write("Date: " + date + "<br>");
    document.write("Method 1 (toString()): " + dateString1 + "<br>");
    document.write("Method 2 (toDateString()): " + dateString2 + "<br>");
</script>
</body>
</html>

In this HTML example:

1. We create a Date object representing a specific date and time, in this case, “2023-10-02T12:34:56.”
2. Method 1: We use the toString() method of the Date object to convert the date to a full string representation, including date and time information.
3. Method 2: We use the toDateString() method of the Date object to convert the date to a string that only contains the date portion without the time information.
4. The results are displayed in the HTML document using the document.write() method. These string representations of dates can be useful for displaying dates in a human-readable format in your web applications.

Converting Booleans to Strings: 

Converting booleans to strings in JavaScript is straightforward. You can simply concatenate an empty string to a boolean value, or you can use the toString() method.

Here’s a complete HTML example demonstrating both methods:

<!DOCTYPE html>
<html>
<head>
    <title>Boolean to String Conversion</title>
</head>
<body>
<h1>Boolean to String Conversion Example</h1>

<script>
    // Example boolean values
    var bool1 = true;
    var bool2 = false;
    // Method 1: Concatenation with an empty string
    var str1 = bool1 + ""; // Converts true to "true"
    var str2 = bool2 + ""; // Converts false to "false"
    // Method 2: Using the toString() method
    var str3 = bool1.toString(); // Converts true to "true"
    var str4 = bool2.toString(); // Converts false to "false"
    // Display the results
    document.write("Boolean 1 (true) as String (Method 1): " + str1 + "<br>");
    document.write("Boolean 2 (false) as String (Method 1): " + str2 + "<br>");
    document.write("Boolean 1 (true) as String (Method 2): " + str3 + "<br>");
    document.write("Boolean 2 (false) as String (Method 2): " + str4 + "<br>");
</script>
</body>
</html>

In this HTML example:

1. We have two example boolean values, bool1 set to true and bool2 set to false.
2. Method 1: We convert these boolean values to strings by concatenating them with an empty string (“”). This is a common way to convert booleans to strings because JavaScript automatically performs type coercion.
3. Method 2: We use the toString() method on boolean values to explicitly convert them to strings.
4. The results are displayed in the HTML document using the document.write() method. Both methods yield the same results, converting true to the string “true” and false to the string “false”.

Automatic Type Conversion

Automatic type conversion, also known as type coercion, is a feature of JavaScript where the language automatically converts values from one data type to another when needed. This can happen implicitly in various situations, such as during arithmetic operations, comparisons, or when using certain operators or functions.

Here are some common scenarios where automatic type conversion occurs in JavaScript:

String Concatenation:

When you use the + operator with strings and other data types, JavaScript converts non-string values to strings and performs concatenation.

var num = 42;
var str = "The answer is " + num; // Implicitly converts num to a string and concatenates

Arithmetic Operations:

JavaScript may automatically convert between number and string types in arithmetic operations.

var result = "10" - 5; // Implicitly converts "10" to a number for subtraction

Comparison Operators:

In comparisons, JavaScript can convert values to a common data type before making the comparison.

var isEqual = "5" == 5; // Implicitly converts "5" to a number for comparison

Truthy and Falsy Values:

In conditional statements, values are automatically coerced to Boolean values (true or false).

if ("hello") {
    // "hello" is truthy
}

Type Conversion Functions:

JavaScript provides functions like parseInt(), parseFloat(), and String() that explicitly convert values between data types.

var str = "123";
var num = parseInt(str); // Explicit conversion from string to number

Automatic type conversion can be convenient, but it can also lead to unexpected behavior if you’re not aware of how JavaScript handles different data types.

It’s essential to understand the rules of type coercion to write reliable and predictable code. Additionally, you can use explicit type conversion functions when needed to ensure that the conversion happens as intended.

complete code example in html

Here’s a complete HTML example demonstrating automatic type conversion in JavaScript:

<!DOCTYPE html>
<html>
<head>
    <title>Automatic Type Conversion Example</title>
</head>
<body>
<h1>Automatic Type Conversion in JavaScript</h1>
<script>
    // Example of automatic type conversion
    // String concatenation
    var num = 42;
    var str = "The answer is " + num; // Implicitly converts num to a string and concatenates
    // Arithmetic operations
    var result = "10" - 5; // Implicitly converts "10" to a number for subtraction
    // Comparison operators
    var isEqual = "5" == 5; // Implicitly converts "5" to a number for comparison

    // Truthy and falsy values
    var isTruthy = "hello"; // "hello" is truthy
    var isFalsy = "";      // An empty string is falsy
    // Display the results
    document.write("String Concatenation: " + str + "<br>");
    document.write("Arithmetic Operation: " + result + "<br>");
    document.write("Comparison Operator: " + isEqual + "<br>");
    document.write("Truthy Value: " + isTruthy + "<br>");
    document.write("Falsy Value: " + isFalsy + "<br>");
</script>
</body>
</html>

In this HTML example:

1. We demonstrate automatic type conversion in various scenarios, including string concatenation, arithmetic operations, comparison operators, and truthy/falsy values.
2. The results of each scenario are displayed in the HTML document using the document.write() method.

JavaScript automatically converts data types as needed to perform the specified operations or comparisons. For example, in the string concatenation scenario, the numeric variable num is automatically converted to a string before concatenation.

The output in the HTML document shows the results of these automatic type conversions in different situations.

Automatic String Conversion

Automatic string conversion, also known as type coercion, is a feature of JavaScript where the language automatically converts values to strings when needed.

This typically occurs in situations where JavaScript expects or concatenates strings, but the value is not a string.

JavaScript will implicitly convert the value to a string data type.

Here are some common scenarios where automatic string conversion occurs in JavaScript:

String Concatenation:

When you use the + operator to concatenate a string with another data type, JavaScript converts the non-string value to a string and performs the concatenation.

var num = 42;
var str = "The answer is " + num; // Implicitly converts num to a string and concatenates

Template Literals:

In modern JavaScript, template literals (using backticks) allow you to embed expressions inside strings. JavaScript automatically converts expressions to strings within template literals.

var num = 42;
var str = `The answer is ${num}`; // Implicitly converts num to a string within the template literal

Value Assignment:

When assigning a non-string value to a variable or property that expects a string, JavaScript will perform automatic string conversion.

var num = 42;

var strVar = num; // Implicitly converts num to a string for strVar

Automatic string conversion

can be convenient, but it’s important to be aware of how JavaScript handles this process.

While JavaScript will automatically convert values to strings in many cases, it doesn’t always result in the desired behavior.

To ensure precise string conversion, you can use the String() function or toString() method explicitly:

var num = 42;
var str = String(num); // Explicitly converts num to a string

Explicit conversions can make your code more readable and avoid unexpected results in situations where automatic type conversion might behave differently than expected.

complete code example in html

Here’s a complete HTML example demonstrating automatic string conversion in JavaScript:

<!DOCTYPE html>
<html>
<head>
    <title>Automatic String Conversion Example</title>
</head>
<body>
<h1>Automatic String Conversion in JavaScript</h1>
<script>
    // Example of automatic string conversion
    // String Concatenation
    var num = 42;
    var str1 = "The answer is " + num; // Implicitly converts num to a string and concatenates
    // Template Literals
    var str2 = `The answer is ${num}`; // Implicitly converts num to a string within the template literal

    // Value Assignment
    var num2 = 123;
    var str3 = num2; // Implicitly converts num2 to a string for str3
    // Display the results
    document.write("String Concatenation: " + str1 + "<br>");
    document.write("Template Literals: " + str2 + "<br>");
    document.write("Value Assignment: " + str3 + "<br>");
</script>
</body>
</html>

In this HTML example:

1. We demonstrate automatic string conversion in various scenarios, including string concatenation, template literals, and value assignment.
2. The results of each scenario are displayed in the HTML document using the document.write() method.
3. JavaScript automatically converts data types to strings when necessary for the specified operations or assignments.

For example, in the string concatenation scenario, the numeric variable num is automatically converted to a string before concatenation.

The output in the HTML document shows the results of these automatic string conversions in different situations.

Applications by this lesson

The concept of automatic type conversion and string conversion in JavaScript is fundamental for understanding how JavaScript handles data types and can be applied in a wide range of web development scenarios. Here are a few examples of how this knowledge can be applied in web applications:

Form Input Handling: When working with  input from forms,

JavaScript often needs to convert  input, which is typically in string format, to other data types for calculations or validations.

var Input = document.getElementById("Input").value;
var numericValue = parseInt(Input); // Convert  input to a numeric value

API Requests: When making API requests, the response data is often in string format. Automatic string conversion allows you to work with this data more effectively.

fetch('https://api.example.com/data')
  .then(response => response.json())
  .then(data => {
    var strValue = data.someValue; // Automatically converted to a string
    // Work with the string data
  });

 Interface Updates: In web applications, you may need to update the  interface dynamically with data. Automatic string conversion simplifies this process when inserting data into HTML elements.

var resultValue = 42;
var resultElement = document.getElementById("result");
resultElement.textContent = "The result is " + resultValue; // Converts resultValue to a string

Data Validation: When validating data or input fields, you may want to ensure that a string can be converted to a specific data type before further processing.

var Input = document.getElementById("Input").value;
if (!isNaN(Input)) {
  var numericValue = parseFloat(Input); // Convert to a numeric value if it's a valid number
  // Perform further validation or calculations
} else {
  alert("Please enter a valid number.");
}

Template Rendering: When rendering dynamic content using templates or front-end frameworks, automatic string conversion simplifies the process of inserting values into the template.

var Name = "John";
var template = `<p>Hello, ${Name}!</p>`; // Name is automatically converted to a string
// Insert the template into the document

Understanding how JavaScript handles type conversions, both automatically and explicitly, is crucial for writing robust and efficient web applications that handle various data types gracefully.

complete code

Here’s a complete HTML example that demonstrates the application of automatic type conversion and string conversion in a simple web application:

<!DOCTYPE html>
<html>
<head>
    <title>Automatic Type Conversion Example</title>
</head>
<body>

<h1>Automatic Type Conversion and String Conversion Example</h1>

<!-- Input field for  to enter a number -->
<label for="Input">Enter a Number:</label>
<input type="text" id="Input">
<button onclick="convertAndDisplay()">Convert</button>

<!-- Result will be displayed here -->
<p id="result"></p>

<script>
    function convertAndDisplay() {
        // Get  input as a string
        var Input = document.getElementById("Input").value;

        // Automatically convert the string to a number
        var numericValue = parseFloat(Input);

        // Check if the conversion is successful
        if (!isNaN(numericValue)) {
            // Display the result as a string
            var resultElement = document.getElementById("result");
            resultElement.textContent = "The numeric value is: " + numericValue;
        } else {
            alert("Please enter a valid number.");
        }
    }
</script>

</body>
</html>

In this example:

1. The is prompted to enter a number in the input field.
2. When the “Convert” button is clicked, the convertAndDisplay() JavaScript function is called.
3. Inside the function:

-The  input is retrieved as a string.

Automatic type conversion is applied by using parseFloat() to convert the  input to a numeric value.

4. The code checks if the conversion was successful using isNaN().
5. If the conversion is successful, the numeric value is displayed as a string in the result paragraph.
6. If the input is not a valid number, an alert is shown.
7. This example demonstrates how JavaScript’s automatic type conversion and string conversion can be used to handle input and display results in a web application.

Quiz with answers 

Here’s a multiple-choice quiz with answers related to the topic of automatic type conversion and string conversion in JavaScript:

1-What is automatic type conversion in JavaScript?

1. A feature that converts data types without any developer intervention.
2. A process that requires explicit casting of data types.
3. A type of conversion only used for numbers.

Answer: a. A feature that converts data types without any developer intervention.

2-When does automatic string conversion occur in JavaScript?

a-Only in arithmetic operations.

b-When converting numbers to strings.

c-When JavaScript expects or concatenates strings, but the value is not a string.

Answer: c. When JavaScript expects or concatenates strings, but the value is not a string.

3-What happens when you use the + operator to concatenate a string with a non-string value in JavaScript?

a-An error is thrown.

b-The non-string value is automatically converted to a string and then concatenated.

c-The non-string value is ignored.

Answer: b. The non-string value is automatically converted to a string and then concatenated.

4-Which method can be used for explicit string conversion in JavaScript?

a-convertToString()

b-stringify()

c-String()

Answer: c. String()

5-In JavaScript, what does the Boolean() function do when applied to a value?

a-Converts the value to a boolean (true or false).

b-Converts the value to a string.

c-Converts the value to a number.

Answer: a. Converts the value to a boolean (true or false).

6-What is the result of the following operation: “5” + 3?

a-“8”

b-8

c-“53”

Answer: c. “53”

7-When using template literals in JavaScript, which syntax is used to embed expressions inside strings?

a-Single quotes (‘)

b-Double quotes (“)

c-Backticks (“)

Answer: c. Backticks (“)

8-Which function can be used to explicitly convert a string to a number in JavaScript

a-parseFloat()

b-parseInt()

c-toNumber()

Answer: a. parseFloat() or b. parseInt()

9-What does the isNaN() function in JavaScript do?

a-Checks if a value is not a string.

b-Checks if a value is not a number.

c-Converts a value to a number.

Answer: b. Checks if a value is not a number.

10-In JavaScript, what does the expression “5” == 5 evaluate to?

a-true

b-false

c-It causes an error.

Answer: a. true

11-In JavaScript, which of the following is considered a falsy value?

a-0

b-“false”

c-null

**Answer: a. `0`, c. `null`**

12-What is the result of the expression “5” – 3 in JavaScript?

a-8

b-“2”

c-2

**Answer: c. `2`**

13-Which method can be used to explicitly convert a number to a string in JavaScript?

a-String()

b-toStr()

c-numberToString()

**Answer: a. `String()`**

14-When using template literals in JavaScript, what symbol is used to enclose expressions?

a-{ }

b-[ ]

c-${ }

**Answer: c. `${ }`**

15-What is the result of the expression Boolean(“”) in JavaScript?

a-true

b-false

**Answer: b. `false`**

16-In JavaScript, which value is considered truthy?

a-null

b-0

c-true

**Answer: c. `true`**

17-What does the toString() method do when applied to a number in JavaScript?

a-Converts the number to a string.

b-Converts the number to a boolean.

c-Converts the number to an array.

**Answer: a. Converts the number to a string.**