Running scripts, understanding the event loop, and working with asynchronous code in Node.js
What is Node.js?
Node.js is a JavaScript runtime — it lets you run JavaScript code outside of a web browser. It uses the same V8 engine that powers Google Chrome.
Your First Node.js Script
Create a file called hello.js:
// hello.js - Run with: node hello.js
const school = 'UCSD';
const course = 'CSE 135';
const year = new Date().getFullYear();
// Template strings (ES6) work naturally
console.log(`Welcome to ${course} at ${school}, ${year}!`);
// Unlike PHP, this script runs once and exits
// There's no HTTP request triggering it - we just ran a file
Run it from the terminal:
$ node hello.js
Welcome to CSE 135 at UCSD, 2026!
That's it. Node.js executed your JavaScript file, printed output, and exited.
Running Node.js Interactively
Beyond running files with node filename.js, there are other ways to execute Node.js code:
The REPL (Read-Eval-Print Loop)
Run node with no arguments to enter an interactive shell:
Here's the most important concept in Node.js: the event loop.
Node.js is single-threaded, but it handles many concurrent operations using an event loop. When you do something that takes time (reading a file, making an HTTP request), Node doesn't wait. It schedules the work and continues running other code.
// async-demo.js - Demonstrates the event loop
console.log('1. Script starts');
// setTimeout schedules work for later
setTimeout(() => {
console.log('3. This runs after 2 seconds');
}, 2000);
console.log('2. Script continues immediately');
// Output order:
// 1. Script starts
// 2. Script continues immediately
// (2 seconds pass)
// 3. This runs after 2 seconds
Run it:
$ node async-demo.js
1. Script starts
2. Script continues immediately
(2 seconds pass)
3. This runs after 2 seconds
Notice that "Script continues" prints BEFORE the setTimeout callback. Node doesn't block waiting for the timer.
Why This Matters for Web Servers
This non-blocking behavior is why Node.js handles many concurrent connections efficiently:
// Conceptual example (not runnable yet)
server.on('request', (req, res) => {
// Read from database (takes time)
database.query('SELECT * FROM users', (err, results) => {
// This callback runs when data is ready
res.json(results);
});
// Node doesn't wait here - it can handle other requests!
});
While waiting for the database, Node.js can handle other requests on the same thread. Note that PHP with Apache handles concurrency differently: Apache typically spawns multiple worker processes or threads, so while each PHP script blocks within its own process, the server as a whole still handles concurrent requests. The trade-off is in memory and resource usage per connection.
Async Patterns: Callbacks, Promises, and Async/Await
Node.js has three patterns for handling async operations. Each is syntactically different, but all fundamentally deal with the same challenge: managing chained dependencies where one operation depends on the result of another.