JavaScript Fundamentals (Variables, Data Types, Operators) • Variables store data; they are containers for information in your code. • Data types define the kind of values variables can hold, like numbers or text. • Operators perform operations on values, such as arithmetic or comparisons. • Understanding these basics is crucial for writing any JavaScript code. • Use const for values that won't change, let for values that will. • Common types include strings, numbers, booleans, and objects. • Arithmetic operators (+, -, *, /) are fundamental for calculations. • Comparison operators (>, <, ==, ===) are vital for decision-making. • Practical reminder: Always declare variables before using them.

Key points: - Variables hold data. - Data types define value types. - Operators perform actions. - Choose const or let wisely. - Fundamental for all JS programming.

Example: const greeting = 'Hello, world!'; let count = 10; const isAwesome = true;

console.log(greeting); console.log(count * 2); console.log(isAwesome ? 'Yes!' : 'No.');

Control Flow and Functions • Control flow directs the execution path of your program based on conditions. • Functions are reusable blocks of code that perform specific tasks. • Conditional statements (if, else, switch) make decisions in your code. • Loops (for, while) repeat code blocks multiple times. • Functions help organize code and avoid repetition, making it cleaner. • Return values from functions to use their results elsewhere. • Use if/else for binary decisions, switch for multiple options. • Loops are great for processing arrays or repeating actions. • Practical reminder: Keep functions small and focused on one job.

Key points: - Control flow guides execution. - Functions group code for reuse. - Conditionals make decisions. - Loops repeat actions. - Functions improve readability and maintainability.

Example: function greetUser(name) { if (name) { console.log(Hello, ${name}!); } else { console.log('Hello, guest!'); } }

greetUser('Alice'); greetUser();

Asynchronous JavaScript (Callbacks, Promises, Async/Await) • Asynchronous operations allow code to run without blocking the main thread. • Callbacks are functions passed as arguments to be executed later. • Promises represent the eventual result of an asynchronous operation (success or failure). • Async/await is syntactic sugar for Promises, making async code look synchronous. • This is vital for tasks like network requests or file I/O. • Callbacks can lead to 'callback hell' if nested too deeply. • Promises provide cleaner chaining and error handling for async tasks. • Async/await simplifies Promise-based code, improving readability significantly. • Practical reminder: Always handle potential errors in async operations.

Key points: - Non-blocking operations are key. - Callbacks are simple but can be complex. - Promises manage async states (pending, fulfilled, rejected). - Async/await simplifies Promise usage. - Crucial for web performance and responsiveness.

Example: async function fetchData() { try { const response = await fetch('https://api.example.com/data'); const data = await response.json(); console.log(data); } catch (error) { console.error('Error fetching data:', error); } } fetchData();

Introduction to Node.js and NPM • Node.js is a JavaScript runtime environment that executes JavaScript code outside the browser. • It allows you to build server-side applications and command-line tools. • NPM (Node Package Manager) is the default package manager for Node.js. • NPM helps you install, manage, and share reusable code modules (packages). • Node.js enables full-stack JavaScript development, from frontend to backend. • It's built on Chrome's V8 JavaScript engine for high performance. • Use npm init to create a package.json file for your project. • Install packages with npm install <package-name>. • Practical reminder: Always check package licenses before using them in commercial projects.

Key points: - Node.js runs JS server-side. - NPM manages project dependencies. - Enables full-stack JS. - High performance via V8 engine. - Use npm init for projects.

Example: Node.js allows you to run JavaScript on your server.

Example scenario: Building a simple web server using Express.js, a popular Node.js framework.

npm install express

Then create server.js:

const express = require('express'); const app = express(); app.get('/', (req, res) => res.send('Hello from Node.js!')); app.listen(3000, () => console.log('Server running on port 3000'));

Core Node.js Modules (fs, http, path) • Core modules are built-in functionalities provided by Node.js. • The fs module handles file system operations like reading and writing files. • The http module allows you to create web servers and make HTTP requests. • The path module helps in working with file and directory paths robustly. • These modules are essential for common server-side tasks and utility operations. • You don't need to install them; they are globally available. • Use require('fs') to access the file system module. • Use require('http') for server creation and client requests. • Practical reminder: Always use path.join for cross-platform path construction.

Key points: - Built-in Node.js functionalities. - fs for file operations. - http for servers and requests. - path for path manipulation. - Essential for common tasks.

Example: const fs = require('fs'); const path = require('path');

const filePath = path.join(__dirname, 'my_file.txt');

fs.writeFile(filePath, 'Hello Node.js!', (err) => { if (err) throw err; console.log('File created successfully!'); });

fs.readFile(filePath, 'utf8', (err, data) => { if (err) throw err; console.log('File content:', data); });

Event Loop and Non-Blocking I/O • The Event Loop is Node.js's mechanism for handling asynchronous operations efficiently. • Non-blocking I/O means operations (like reading files) don't halt program execution. • It allows Node.js to handle many concurrent connections with a single thread. • When an I/O operation starts, Node.js delegates it and continues other tasks. • This makes Node.js highly scalable and performant for I/O-bound applications. • The loop constantly checks for completed asynchronous operations. • Callback functions are executed when their associated operations finish. • This architecture is fundamental to Node.js's speed and efficiency. • Practical reminder: Understand that async operations are not instantaneous.

Key points: - Manages asynchronous tasks. - Non-blocking for efficiency. - Single-threaded, high concurrency. - Scalable for I/O-bound apps. - Core to Node.js performance.

Example: console.log('Start');

setTimeout(() => { console.log('Timeout callback executed'); }, 0); // This runs *after* the next console.log

console.log('End');

// Expected Output: // Start // End // Timeout callback executed

Basic Module System (CommonJS and ES Modules) • Modules help organize JavaScript code into reusable, separate files. • CommonJS is the traditional module system used in Node.js (using require and module.exports). • ES Modules (ECMAScript Modules) are the standard JavaScript module system (using import and export). • Both systems aim to manage dependencies and encapsulate code effectively. • Node.js now supports both, with ES Modules gaining broader adoption. • CommonJS is synchronous; ES Modules are asynchronous by design. • Use module.exports = { ... } to export in CommonJS. • Use export const or export default for ES Modules. • Practical reminder: Be consistent with module system usage within a project.

Key points: - Organize code into files. - CommonJS: require, module.exports. - ES Modules: import, export. - Standard JS vs. Node.js tradition. - Node.js supports both.

Example: // myModule.js (CommonJS) const greeting = 'Hello'; module.exports = { greeting };

// app.js (CommonJS) const myModule = require('./myModule'); console.log(myModule.greeting); // Output: Hello

Debugging Node.js Applications • Debugging is the process of finding and fixing errors (bugs) in your code. • Node.js has a built-in debugger accessible via the command line. • You can also use browser developer tools (like Chrome DevTools) for debugging. • Setting breakpoints allows you to pause execution at specific lines. • Stepping through code helps you understand its flow and variable states. • Console logging (console.log) is a simple but effective debugging technique. • Use node inspect to start the built-in debugger. • Learn to inspect variables and evaluate expressions during debugging. • Practical reminder: Don't leave excessive console.log statements in production code.

Key points: - Find and fix errors. - Built-in Node.js debugger. - Browser DevTools integration. - Breakpoints and stepping are powerful. - Console logging is a basic tool.

Example: To debug: 1. Save your Node.js code in a file (e.g., app.js). 2. Open your terminal and run: node inspect app.js 3. Type c to continue execution until a breakpoint. 4. Use repl to enter interactive mode and inspect variables.

Quick quiz: 1. In JavaScript, which of the following keywords is used to declare a variable whose value cannot be reassigned after initialization? 2. Consider the following Node.js code snippet: fs.readFile('data.txt', 'utf8', (err, data) => { if (err) throw err; console.log(data); });. What is the primary benefit of this asynchronous approach compared to a synchronous fs.readFileSync? 3. What is the main purpose of npm init in a Node.js project? 4. Which of the following is a common pitfall when using Promises in JavaScript, potentially leading to unhandled rejections? 5. In Node.js, the http module is used to create HTTP servers and clients. If you need to access the file path of the current executing script, which core module would you use?