Added foundational JavaScript concepts including code structure, strict mode, and script tag usage

Author: avinashyadav16

01.01_Code_Structure.md

@@ -0,0 +1,153 @@
+# 🧱 JavaScript Code Structure
+
+The building blocks of code.
+
+## 📌 Statements
+
+Statements are syntax constructs and commands that perform actions.
+
+For example We’ve already seen a statement, `alert('Hello, world!')`, which shows the message “Hello, world!”.:
+
+```js
+alert("Hello, world!");
+```
+
+We can have as many statements in our code as we want. They can be separated with a semicolon (`;`):
+
+```js
+alert("Hello"); alert("World");
+```
+
+But usually, for readability, we write them on separate lines:
+
+```js
+alert("Hello");
+alert("World");
+```
+
+---
+
+## 🟡 Semicolons
+
+Semicolons can be **omitted** in many cases where a line break exists:
+
+This would also work:
+
+```js
+alert("Hello")
+alert("World")
+```
+
+Here, JavaScript interprets the line break as an **implicit** semicolon. This is called **automatic semicolon insertion**. But be careful—**not all cases** are safe.
+
+**In most cases, a newline implies a semicolon. But “in most cases” does not mean “always”!** There are cases when a newline does not mean a semicolon. For example:
+
+Example:
+
+```js
+alert(3 + 
+1 
++ 2);
+```
+
+✅ This works as expected and shows `6` because JavaScript does not insert semicolons here. JavaScript knows the line ends in `+`, so it continues.
+
+However, **there are situations where JavaScript “fails” to assume a semicolon where it is really needed**:
+
+```js
+alert("Hello");
+
+[1, 2].forEach(alert);
+```
+
+This shows:
+
+```
+Hello
+1
+2
+```
+
+But if you remove the semicolon after the `alert`:
+
+```js
+alert("Hello")
+
+[(1, 2)].forEach(alert);
+```
+
+It fails! 
+The difference compared to the code above is only one character: the semicolon at the end of the first line is gone.
+
+If we run this code, only the first Hello shows (and there’s an error, you may need to open the console to see it). There are no numbers any more.
+
+That’s because JavaScript does not assume a semicolon before square brackets [...]. So, the code in the last example is treated as a single statement.
+
+Here’s how the engine sees it:
+
+```js
+alert("Hello")[(1, 2)].forEach(alert);
+```
+
+Which is incorrect. So, always using semicolons is a **safe practice**, especially for beginners.
+
+---
+
+## 💬 Comments
+
+As code grows and becomes more and more complex, **comments** help explain what’s going on.
+
+Comments can be put into any place of a script. They don’t affect its execution because the engine simply ignores them.
+
+### ✅ Single-line comments
+
+One-line comments start with two forward slash characters `//`:
+
+The rest of the line is a comment. It may occupy a full line of its own or follow a statement.
+
+```js
+// This comment is on its own line
+alert("Hello");
+
+alert("World"); // This one follows a statement
+```
+
+### ✅ Multiline comments
+
+Multiline comments start with a forward slash and an asterisk `/* `and end with an asterisk and a forward slash `*/`.
+
+```js
+/* This is a
+multiline comment */
+alert("Hello");
+alert("World");
+```
+
+You can also temporarily disable code:
+
+```js
+/*
+alert('Hello');
+*/
+alert("World");
+```
+
+### ⚠️ No Nested Comments!
+
+There may not be `/*...*/` inside another `/*...*/`.
+
+Such code will die with an error:
+
+```js
+/*
+  /* Nested comment? */
+*/
+alert('World');
+```
+
+---
+
+## ⚡ Editor Tip: Use Hotkeys!
+
+- Single-line comment: `Ctrl + /` (or `Cmd + /` on Mac)
+- Multiline comment: `Ctrl + Shift + /` (or `Cmd + Option + /` on Mac)

01.02_The_Modern_Mode_use_strict.md

@@ -0,0 +1,105 @@
+# 🛡️ JavaScript Strict Mode – `"use strict"`
+
+## 📜 What is `"use strict"`?
+
+JavaScript has evolved over time while keeping old code working. This meant that early mistakes in the language couldn’t be fixed without breaking existing programs.
+
+That changed in **2009**, with the release of **ECMAScript 5 (ES5)**. It introduced `"use strict"` – a way to opt in to a safer, modern version of JavaScript.
+
+---
+
+## 🧪 Enabling Strict Mode
+
+Strict mode is enabled by placing `"use strict"` at the **very top** of your script or function:
+
+```js
+"use strict";
+
+// Your modern JavaScript code here
+```
+
+You can also enable it inside a function:
+
+```js
+function example() {
+  "use strict";
+  // strict mode only applies inside this function
+}
+```
+
+---
+
+## 🚨 Strict Mode Must Be at the Top
+
+Strict mode won’t work if it’s **not at the top**:
+
+```js
+alert("Some code");
+("use strict"); // ❌ Ignored!
+```
+
+✅ Only comments may appear before `"use strict"`.
+
+---
+
+## ❌ No Way to Cancel
+
+Once strict mode is enabled, you **cannot disable it**. There’s no `"no strict"` or similar directive.
+
+---
+
+## 🧪 Using Strict in the Browser Console
+
+Browser consoles don’t run in strict mode by default.
+
+### ✅ To enable it manually:
+
+```js
+"use strict";
+// your code here
+```
+
+Use **Shift + Enter** to input multiline code before running it.
+
+### 💡 Compatibility Wrapper:
+
+If your console doesn’t behave well, wrap your code in an **IIFE** (Immediately Invoked Function Expression):
+
+```js
+(function () {
+  "use strict";
+  // your code here
+})();
+```
+
+---
+
+## 🤔 Should You Use Strict Mode?
+
+Yes – at least **for now**.
+
+Strict mode helps catch bugs, improves performance in some cases, and prevents certain bad practices.
+
+```js
+"use strict";
+// safer and cleaner code
+```
+
+But… when you start using **classes** or **modules**, strict mode is enabled automatically. So:
+
+✅ Use `"use strict"` now.
+
+💡 Later, with **modern features**, you won’t need it!
+
+---
+
+### 🔐 Benefits of `"use strict"`:
+
+- Makes it easier to write secure JavaScript.
+- Prevents the use of undeclared variables.
+- Eliminates silent errors.
+- Fixes mistakes in the language.
+
+---
+
+Stay strict, code safe! 💻🔒

01_JavaScript_Fundamentals.md

@@ -0,0 +1,126 @@
+# 👋 Hello, World!
+
+## 🧩 The `<script>` Tag
+
+JavaScript can be embedded almost anywhere in an HTML document using the `<script>` tag.
+
+Here’s a basic example:
+
+```html
+<!DOCTYPE html>
+<html>
+  <body>
+    <p>Before the script...</p>
+
+    <script>
+      alert("Hello, world!");
+    </script>
+
+    <p>...After the script.</p>
+  </body>
+</html>
+```
+
+📌 The code inside the `<script>` tag is automatically executed when the browser processes it.
+
+---
+
+## 📜 A Bit of Script History
+
+The `<script>` tag has a few attributes that are rarely used nowadays but can still be found in old code:
+
+### 🔹 `type` Attribute
+
+```html
+<script type="text/javascript">
+```
+
+- In **HTML4**, the `type` attribute was required.
+- Typically set as `type="text/javascript"`.
+- In **modern HTML**, it’s **optional**.
+- Today, it’s used for JavaScript **modules**, like `type="module"`, but we’ll cover that later.
+
+### 🔹 `language` Attribute
+
+```html
+<script language="JavaScript">
+```
+
+- This was meant to specify the script’s language.
+- It's now **deprecated**—JavaScript is the **default**.
+- You **don’t need to use it** anymore.
+
+### 🔹 Old-Style Comments
+
+In really old tutorials, you might see something like:
+
+```html
+<script type="text/javascript">
+  <!--
+  alert("Hello, old world!");
+  //-->
+</script>
+```
+
+- These were used to **hide JS from old browsers**.
+- Totally unnecessary today.
+- Can be a sign of **very old code**.
+
+---
+
+## 📁 External Scripts
+
+If your JS code is large or reused, it’s best to keep it in a separate file.
+
+### ✅ Basic Usage
+
+```html
+<script src="/path/to/script.js"></script>
+```
+
+- The path can be **absolute** (`/path/to/`) or **relative** (`./script.js`).
+- You can also use a full URL:
+
+```html
+<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>
+```
+
+### 🔗 Multiple Scripts
+
+To include several external scripts, use multiple `<script>` tags:
+
+```html
+<script src="/js/script1.js"></script>
+<script src="/js/script2.js"></script>
+```
+
+---
+
+## ⚠️ Important Notes
+
+- Only **simple scripts** are written directly in HTML.
+- More complex or reusable code goes in **external files**.
+- Browsers **cache external files**, which improves performance and reduces bandwidth usage.
+
+---
+
+## ❌ Don’t Mix `src` with Inline Code
+
+This **won’t work**:
+
+```html
+<script src="file.js">
+  alert(1); // ❌ ignored!
+</script>
+```
+
+Use separate `<script>` tags instead:
+
+```html
+<script src="file.js"></script>
+<script>
+  alert(1); // ✅ works
+</script>
+```
+
+---