Scribd
Upload
2 views

NodeJS Notes

NodeJS is a JavaScript runtime that enables server-side execution of JavaScript, featuring an event-driven architecture and non-blocking I/O operations. The document covers setting up a NodeJS project, building web servers, handling files, asynchronous programming, and creating REST APIs using ExpressJS. It also includes instructions for integrating MySQL with NodeJS applications.

Uploaded by

abrahamsamuel898
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
2 views

NodeJS Notes

NodeJS is a JavaScript runtime that enables server-side execution of JavaScript, featuring an event-driven architecture and non-blocking I/O operations. The document covers setting up a NodeJS project, building web servers, handling files, asynchronous programming, and creating REST APIs using ExpressJS. It also includes instructions for integrating MySQL with NodeJS applications.

Uploaded by

abrahamsamuel898
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 8

NODE JS NOTES

NodeJS
1. Introduction to NodeJS
Overview: NodeJS is a JavaScript runtime built on Chrome's V8 JavaScript engine,
allowing developers to run JavaScript on the server side.

Key Features:
1.​ Event-driven architecture
2.​ Non-blocking I/O operations
3.​ Single-threaded but highly scalable due to the event loop

Example: Basic server setup

const http = require('http');

http.createServer((req, res) => {


res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('Hello World\n');
}).listen(1337, '127.0.0.1');
console.log('Server running at http://127.0.0.1:1337/');

2. Setting Up a NodeJS Project.


Project Initialization: Use npm init to create package.json.

npm init -y
npm install express --save

3. Understanding Modules and npm


Modules: Encapsulated code that can be reused across different parts of an application
or by other applications.
npm: Package manager for JavaScript.

// Importing a module
const fs = require('fs');

// Using a module
fs.readFile('example.txt', 'utf8', (err, data) => {
if (err) throw err;
console.log(data);
});
4. Building a Web Server with NodeJS
HTTP Module: Fundamental for creating HTTP servers.

const http = require('http');

http.createServer((req, res) => {


res.writeHead(200, {'Content-Type': 'text/html'});
res.end('<h1>Hello World</h1>');
}).listen(3000, () => {
console.log('Server running on port 3000');
});

5. Serving Static Files


File Serving: Using fs module to read and serve files.

const http = require('http');


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

http.createServer((req, res) => {

let filePath = '.' + req.url;


if (filePath == './') filePath = './index.html';

const extname = path.extname(filePath);


let contentType = 'text/html';

switch (extname) {
case '.js': contentType = 'text/javascript'; break;
case '.css': contentType = 'text/css'; break;
// Add more types as needed
}

fs.readFile(filePath, (err, content) => {


if (err) {
if(err.code == 'ENOENT') {
fs.readFile('./404.html', (err, content) => {
res.writeHead(404, { 'Content-Type': contentType });
res.end(content, 'utf-8');
});
} else {
res.writeHead(500);
res.end('Sorry, check with the site admin for error: '+err.code+' ..\n');
res.end();
}
} else {
res.writeHead(200, { 'Content-Type': contentType });
res.end(content, 'utf-8');
}
});
}).listen(8080);

6. Working with Filesystems

Reading Files:

fs.readFile('example.txt', 'utf8', (err, data) => {


if (err) throw err;
console.log(data);
});

Writing Files:

fs.writeFile('example.txt', 'Hello, World!', (err) => {


if (err) throw err;
console.log('File written successfully');
});

Streams: Efficient for handling large files or data streams.

const readStream = fs.createReadStream('example.txt');


readStream.on('data', (chunk) => {
console.log(chunk.toString());
});

7. Asynchronous Programming in NodeJS

Callbacks: Traditional method in NodeJS.

fs.readFile('file.txt', (err, data) => {


if (err) throw err;
console.log(data.toString());
});

Promises: More modern approach.

const util = require('util');


const readFile = util.promisify(fs.readFile);

readFile('file.txt', 'utf8')
.then(data => console.log(data))
.catch(err => console.error(err));

async/await: Simplifies promise handling.

async function readFileAsync() {


try {
const data = await readFile('file.txt', 'utf8');
console.log(data);
} catch (err) {
console.error(err);
}
}
readFileAsync();

8. Introduction to APIs
A REST API (Representational State Transfer Application Programming Interface) is a
set of rules and conventions for building and interacting with web services. It is based
on the principles of REST, an architectural style for designing networked applications.
REST APIs are widely used for enabling communication between clients (e.g., web
browsers, mobile apps) and servers over the internet.

Basic REST API: Using HTTP methods for CRUD operations.

const http = require('http');


const url = require('url');

const server = http.createServer((req, res) => {


const q = url.parse(req.url, true).query;
const txt = q.year + " " + q.month;
res.end(txt);
});

server.listen(8080, () => {
console.log('Server running on port 8080');
});
Module 7: ExpressJS (NodeJS Framework)

1. Introduction to Express

Express: A Nodejs framework that simplifies server creation, routing, and middleware
handling.

2. Setting Up an Express Project

npm install express

const express = require('express');


const app = express();

app.get('/', (req, res) => {


res.send('Hello World!');
});

app.listen(3000, () => {
console.log('Server is running on port 3000');
});

3. Routing in Express

app.get('/api', (req, res) => {


res.json({ message: 'Hello from API!' });
});

app.post('/api', (req, res) => {


res.json({ message: 'Data received!' });
});

4. Middleware Functions in Express


In Node.js Express, middleware refers to functions that have access to the request
object (req), the response object (res), and the next function in the application's
request-response cycle. Middleware functions can perform tasks such as modifying
request/response objects, executing code, ending the request-response cycle, or calling
the next middleware in the stack

Types of Middleware
1.​ Application level middleware
2.​ Router-Level Middleware
3.​ Route-Specific Middleware
4.​ Error-Handling Middleware:
5.​ Third-Party Middleware:

Built-in Middleware in Express


Express provides some built-in middleware functions:

express.json(): Parses incoming requests with JSON payloads.

express.urlencoded(): Parses incoming requests with URL-encoded payloads.

express.static(): Serves static files (e.g., images, CSS, JavaScript).

app.use((req, res, next) => {


console.log('Time:', Date.now());
next();
});

app.use(express.static('public')); // Serve static files from 'public' directory

5. Handling Forms and Data

app.use(express.json()); // for parsing application/json


app.use(express.urlencoded({ extended: true })); // for parsing
application/x-www-form-urlencoded

app.post('/form', (req, res) => {


const name = req.body.name;
res.send(`Hello, ${name}!`);
});
6. Building RESTful APIs with Express

const users = [];

// GET all users


app.get('/users', (req, res) => {
res.json(users);
});

// POST a new user


app.post('/users', (req, res) => {
users.push(req.body);
res.status(201).send('User added to the database');
});

// GET a specific user


app.get('/users/:id', (req, res) => {
const id = req.params.id;
const user = users.find(u => u.id === id);
if (user) {
res.json(user);
} else {
res.status(404).send('User not found');
}
});

SETTING UP MYSQL WITH NODEJS EXPRESS


Install Express and MySQL:
Install the necessary packages:
npm install express mysql

Create a db.js file to handle the database connection:

const mysql = require('mysql');


// Create a connection pool
const pool = mysql.createPool({
host: 'localhost',
user: 'root',
password: 'yourpassword',
database: 'mydatabase',
​ port: “databse port”
});

// Export the pool for use in other files


module.exports = pool

You might also like