<!DOCTYPE html>

Day 2: Deep Dive into JavaScript Data Types, Strict Mode, and Basic Operations

<br> body {<br> font-family: sans-serif;<br> line-height: 1.6;<br> }</p> <div class="highlight"><pre class="highlight plaintext"><code> h1, h2, h3 { color: #333; } code { background-color: #f0f0f0; padding: 2px 5px; font-family: monospace; } pre { background-color: #f0f0f0; padding: 10px; overflow-x: auto; } img { max-width: 100%; height: auto; } </code></pre></div> <p>

Day 2: Deep Dive into JavaScript Data Types, Strict Mode, and Basic Operations

Welcome back to our journey into the fascinating world of JavaScript! On Day 1, we laid the foundation by setting up our development environment and understanding the basics of JavaScript. Today, we'll dive deeper into some core concepts: data types, strict mode, and fundamental operations. Mastering these will empower you to write more robust and predictable code.

JavaScript Data Types

Data types are the building blocks of any programming language. They define the kind of values a variable can hold. JavaScript has several fundamental data types:

1.1 Primitive Data Types

Number : Represents numerical values, both integers and decimals.

    
    let age = 25;
    let price = 19.99;

String : Represents sequences of characters enclosed in single or double quotes.

    
    let name = "Alice";
    let message = 'Hello, world!';

Boolean : Represents truth values, either true or false.

    
    let isLoggedIn = true;
    let isCompleted = false;

Null : Represents the intentional absence of a value.
```
    
    let user = null;
    
    
```
Undefined : Represents a variable that has been declared but not assigned a value.
```
    
    let city; // city is undefined
    
    
```

Symbol : Represents a unique and immutable value.

    
    let uniqueSymbol = Symbol("mySymbol");

1.2 Object Data Type

Objects are complex data structures that allow us to store collections of key-value pairs. Keys are strings, and values can be of any data type, including other objects.

    
    let user = {
        name: "Bob",
        age: 30,
        occupation: "Software Engineer"
    };

You can access the properties of an object using dot notation ( user.name ) or bracket notation ( user["name"] ).

1.3 Data Type Conversion

Sometimes, you might need to convert one data type to another. JavaScript provides built-in functions for this:

Number() : Converts a value to a number.
String() : Converts a value to a string.
Boolean() : Converts a value to a boolean.


let age = "35"; // String
let numericAge = Number(age); // Now a Number
console.log(typeof numericAge); // Output: "number"

JavaScript Strict Mode

Strict mode is a powerful mechanism in JavaScript that helps you write more secure and reliable code. It introduces stricter parsing and error handling rules, catching potential issues early on.

2.1 Enabling Strict Mode

You can enable strict mode by placing the directive "use strict" at the top of your script or function:

    
    "use strict"; // For the entire script

    function myFunction() {
        "use strict"; // For the function only
    }

2.2 Benefits of Strict Mode

Catch errors early : Strict mode throws errors for syntax or behavior that might be problematic. For instance, it prevents you from using undeclared variables.
Prevent silent failures : In non-strict mode, some errors might go unnoticed, leading to unexpected behavior. Strict mode helps you identify and address these issues.
Improved code readability : Strict mode discourages certain practices that can make code harder to understand.
Enhanced performance : Strict mode can potentially improve performance in some cases by eliminating certain optimizations.

Basic JavaScript Operations

Now that we understand data types and strict mode, let's dive into performing operations on data.

3.1 Arithmetic Operations

JavaScript provides standard arithmetic operators for calculations:

Operator	Description	Example
`+`	Addition	`5 + 3` = 8
`-`	Subtraction	`10 - 4` = 6
`*`	Multiplication	`2 * 7` = 14
`/`	Division	`15 / 3` = 5
`%`	Modulo (remainder)	`10 % 3` = 1
`**`	Exponentiation	`2 ** 3` = 8

3.2 String Operations

Strings can be manipulated using various operations:

Concatenation : Combining strings using the

operator:

    
    let firstName = "John";
    let lastName = "Doe";
    let fullName = firstName + " " + lastName; // "John Doe"

Template Literals : A more readable way to include variables and expressions within strings using backticks (`) :

    
    let age = 30;
    let message = `Hello, I'm ${age} years old.`; // "Hello, I'm 30 years old."

String Methods : JavaScript provides many built-in methods to work with strings, such as:
- toUpperCase()
- toLowerCase()
- trim()
- length
- indexOf()
- slice()

3.3 Comparison Operations

Comparison operators allow us to compare values and determine their relationships:

Operator	Description	Example
`==`	Equal to (loose comparison)	`5 == "5"` is true
`===`	Strictly equal to (strict comparison)	`5 === "5"` is false
`!=`	Not equal to (loose comparison)	`5 != "5"` is false
`!==`	Strictly not equal to (strict comparison)	`5 !== "5"` is true
`>`	Greater than	`10 > 5` is true
`<`	Less than	`5 < 10` is true
`>=`	Greater than or equal to	`10 >= 10` is true
`<=`	Less than or equal to	`5 <= 10` is true

It's important to understand the difference between loose and strict comparisons. Loose comparisons perform type coercion, which can sometimes lead to unexpected results. For instance, 5 == "5" is true because the string "5" is coerced to the number 5 before comparison. Strict comparisons, on the other hand, do not perform type coercion and only consider values that are the same type.

3.4 Logical Operators

Logical operators combine boolean expressions to produce new boolean values:

Operator	Description	Example
`&&`	Logical AND	`true && true` is true
`\|\|`	Logical OR	`false \|\| true` is true
`!`	Logical NOT	`!true` is false

For example, you can use logical operators to check multiple conditions:





let age = 25;

let hasLicense = true;

if (age >= 18 && hasLicense) {
console.log("You are eligible to drive.");
} else {
console.log("You are not eligible to drive.");
}

Conclusion

Congratulations! You've covered crucial JavaScript concepts, including data types, strict mode, and basic operations. This knowledge will serve as a solid foundation for building more complex applications. Remember to practice consistently, experiment with different data types and operations, and refer to the documentation for deeper insights. In the next day, we'll explore control flow statements, which will allow you to execute code based on specific conditions and create dynamic and interactive programs. Stay tuned!