JavaScript Server-Side Programming: JavaScript, traditionally known for its client-side capabilities, has expanded into server-side programming with the advent of environments like Node.js. This allows developers to write code that runs on a server, handling tasks such as database operations, authentication, file handling, and more. This approach enables developers to use a single language across both the client and server sides of an application, streamlining development and fostering better integration.
Non-blocking I/O: JavaScript, especially with Node.js, utilizes an event-driven, non-blocking I/O model, which makes it efficient for real-time applications.Scalability: JavaScript's asynchronous nature and event loop make it capable of handling multiple concurrent operations, which is crucial for scalable applications.Unified Language Stack: Developers can use JavaScript both on the client (in browsers) and server sides, which simplifies development and maintenance.Overview: Node.js is a runtime environment that allows JavaScript to be used for server-side scripting. It's built on Chrome's V8 JavaScript engine2.Features: Event-driven, non-blocking I/O, robust package ecosystem (npm).const http = require('http');
const server = http.createServer((req, res) => {
res.statusCode = 200;
res.setHeader('Content-Type', 'text/plain');
res.end('Hello, World!\n');
});
server.listen(3000, '127.0.0.1', () => {
console.log('Server running at http://127.0.0.1:3000/');
});
import { serve } from "https://deno.land/std@0.100.0/http/server.ts";
const server = serve({ port: 8000 });
console.log("http://localhost:8000/");
for await (const req of server) {
req.respond({ body: "Hello, World!\n" });
}
Benefits of Server-Side JavaScript Server-Side Programming with Node.js Node.js has fundamentally changed the landscape of server-side programming by allowing developers to write server-side scripts in JavaScript. Built on the V8 JavaScript engine, Node.js is efficient, lightweight, and highly performant, making it ideal for building scalable network applications.
Event-Driven Architecture: Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient. It can handle multiple connections concurrently without creating new threads for each connection.Single Language Stack: Developers can use JavaScript on both the client and server sides, simplifying the development process and fostering better code reusability.NPM (Node Package Manager): NPM provides access to thousands of reusable packages, which can significantly speed up development.Popular Node.js Frameworks To make building server-side applications even more efficient, several frameworks have been developed for Node.js. Here are some of the most popular ones:
Overview: Express is a minimalistic and flexible Node.js web application framework that provides a robust set of features to develop web and mobile applications.Features: Middleware system, routing, integration with various view engines, and a large ecosystem of plugins.const express = require('express');
const app = express();
app.get('/', (req, res) => {
res.send('Hello, World!');
});
app.listen(3000, () => {
console.log('Server running on port 3000');
});
const Koa = require('koa');
const app = new Koa();
app.use(async ctx => {
ctx.body = 'Hello, World!';
});
app.listen(3000, () => {
console.log('Server running on port 3000');
});
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
@Module({
imports: [],
controllers: [AppController],
providers: [AppService],
})
export class AppModule {}
const Hapi = require('@hapi/hapi');
const init = async () => {
const server = Hapi.server({
port: 3000,
host: 'localhost'
});
server.route({
method: 'GET',
path: '/',
handler: (request, h) => {
return 'Hello, World!';
}
});
await server.start();
console.log('Server running on %s', server.info.uri);
};
init();
Server-Side Programming with Deno Deno is a modern JavaScript and TypeScript runtime built on the V8 engine, the same engine that powers Node.js, but it offers several unique features and improvements over Node.js. It was created by Ryan Dahl, the original developer of Node.js, to address some of the limitations and shortcomings he identified in Node.js.
Built-in TypeScript Support: Deno has first-class TypeScript support out of the box, without the need for additional configurations or compilers.Security: Deno is secure by default. It runs in a sandboxed environment, and requires explicit permission to access files, networks, and environment variables.Standard Library: Deno includes a built-in standard library, which eliminates the need for a separate package manager.Simplified Module Management: Deno uses ES module syntax and supports URLs for importing modules, eliminating the need for a centralized package manager like npm.Deno Modules and Third-Party Libraries: Deno supports importing modules directly from URLs, and has a decentralized repository system. The Deno community has created a wide range of modules and libraries, similar to npm packages in Node.js.
Oak is a popular middleware framework for Deno, similar to Koa for Node.js. It provides robust routing and middleware capabilitie
import { Application, Router } from "https://deno.land/x/oak@v10.5.1/mod.ts";
const router = new Router();
router.get("/", (context) => {
context.response.body = "Hello from Oak!";
});
const app = new Application();
app.use(router.routes());
app.use(router.allowedMethods());
console.log("Server running at http://localhost:8000/");
await app.listen({ port: 8000 });
Application programming Interface Its a way for two or more softwares to communicate
Develop and consume RESTFUL APISs or GraphQL APIs
Libraries:
REST: axios, fetch.
GRAPHQL: apollo-server, graphql-tools.
Use socket.io or ws for webSockets to enable real time communication.
Common methods:
Session-based: express-session.Token-based: JSON Web Tokens(JWT) with jsonwebtoken.OAuth integration using libraries like passport.js.