Frontend Integration உடன் Node.js க்கு அறிமுகம்
Node.js நவீன JavaScript முன்-முனை கட்டமைப்புகளுடன் ஒருங்கிணைக்கும் ஒரு பின்-முனை அடித்தளத்தை வழங்குகிறது, இது டெவலப்பர்களை JavaScript சூழலுக்குள் முழுமையான பயன்பாடுகளை உருவாக்க அனுமதிக்கிறது.
இந்த அணுகுமுறை பல நன்மைகளை வழங்குகிறது:
ஒருங்கிணைந்த மொழி
முழு ஸ்டாக்கிலும் JavaScript/TypeScript ஐப் பயன்படுத்தவும்
குறியீடு பகிர்வு
முன்-முனை மற்றும் பின்-முனை இடையே சரிபார்ப்பு, வகைகள் மற்றும் பயன்பாடுகளைப் பகிரவும்
டெவலப்பர் அனுபவம்
npm/yarn உடன் சீரான கருவிகள் மற்றும் தொகுப்பு மேலாண்மை
செயல்திறன்
JSON மற்றும் நவீன நெறிமுறைகளுடன் திறமையான தரவு பரிமாற்றம்
சூழல்
முன்-முனை மற்றும் பின்-முனை இரண்டிற்கும் தொகுப்புகளின் விரிவான சேகரிப்புக்கான அணுகல்
பொதுவான ஒருங்கிணைப்பு வடிவங்கள்
1. API-First கட்டமைப்பு
Node.js பின்-முனை RESTful அல்லது GraphQL APIகளை வெளிப்படுத்துகிறது, அவை தனி முன்-முனை பயன்பாட்டால் நுகரப்படுகின்றன.
// Example API endpoint
app.get('/api/products', (req, res) => {
res.json([{ id: 1, name: 'Product' }]);
});
2. சேவையக-பக்க ரெண்டரிங் (SSR)
Node.js சிறந்த SEO மற்றும் செயல்திறனுக்காக சேவையகத்தில் ஆரம்ப பக்கத்தை ரெண்டர் செய்கிறது.
// Next.js page
export async function getServerSideProps() {
const res = await fetch('https://api.example.com/data');
return { props: { data: await res.json() } };
}
3. மைக்ரோ-முன்-முனைகள்
பல முன்-முனை பயன்பாடுகள் ஒருங்கிணைக்கப்பட்ட அனுபவத்தில் ஒருங்கிணைக்கப்படுகின்றன.
// Module Federation in webpack.config.js
new ModuleFederationPlugin({
name: 'app1',
filename: 'remoteEntry.js',
exposes: { './Component': './src/Component' }
})
Node.js உடன் React
React என்பது பயனர் இடைமுகங்களை உருவாக்குவதற்கான ஒரு விளக்கமான, திறமையான மற்றும் நெகிழ்வான JavaScript நூலகமாகும்.
இது டெவலப்பர்களை மீண்டும் பயன்படுத்தக்கூடிய UI கூறுகளை உருவாக்கவும், தரவு மாறும்போது அவற்றை திறம்பட புதுப்பிக்கவும் ரெண்டர் செய்யவும் இயக்குகிறது.
Node.js உடன் React ஏன் பயன்படுத்த வேண்டும்?
Node.js பின்-முனையுடன் React பயன்பாட்டை அமைத்தல்
// Node.js backend (Express)
const express = require('express');
const cors = require('cors');
const app = express();
// Enable CORS for React frontend
app.use(cors());
app.get('/api/data', (req, res) => {
res.json({ message: 'Hello from Node!' });
});
app.listen(8080, () => {
console.log('Server running on port 8080');
});
// React frontend component
import { useState, useEffect } from 'react';
function App() {
const [data, setData] = useState(null);
const [loading, setLoading] = useState(true);
useEffect(() => {
fetch('http://localhost:8080/api/data')
.then(res => res.json())
.then(data => {
setData(data);
setLoading(false);
});
}, []);
return (
{loading ? 'Loading...' : data.message}
);
}
Node.js உடன் Angular
Angular என்பது TypeScript ஐப் பயன்படுத்தி அளவிடக்கூடிய ஒற்றை-பக்கம் பயன்பாடுகளை உருவாக்குவதற்கான ஒரு விரிவான தளம் மற்றும் கட்டமைப்பாகும்.
இது ரூட்டிங், படிவங்கள், HTTP வாடிக்கையாளர் மற்றும் பலவற்றுக்கான உள்ளமைக்கப்பட்ட அம்சங்களைக் கொண்ட ஒரு முழுமையான தீர்வை வழங்குகிறது, இது நிறுவன பயன்பாடுகளுக்கு ஒரு வலுவான தேர்வாக அமைகிறது.
Node.js உடன் Angular இன் முக்கிய அம்சங்கள்
Node.js பின்-முனையுடன் Angular ஐ அமைத்தல்
// Node.js backend (Express)
const express = require('express');
const cors = require('cors');
const app = express();
app.use(cors());
app.get('/api/users', (req, res) => {
res.json([
{ id: 1, name: 'John Doe' },
{ id: 2, name: 'Jane Smith' }
]);
});
app.listen(8080, () => {
console.log('Server running on port 8080');
});
// Angular service (user.service.ts)
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';
interface User {
id: number;
name: string;
}
@Injectable({
providedIn: 'root'
})
export class UserService {
private apiUrl = 'http://localhost:8080/api/users';
constructor(private http: HttpClient) { }
getUsers(): Observable {
return this.http.get(this.apiUrl);
}
}
Node.js உடன் Vue.js
Vue.js என்பது பயனர் இடைமுகங்களை உருவாக்குவதற்கான ஒரு முற்போக்கான, அணுகக்கூடிய மற்றும் செயல்திறன் மிக்க JavaScript கட்டமைப்பாகும்.
இது ஒரு மென்மையான கற்றல் வளைவு மற்றும் நெகிழ்வான கட்டமைப்பை வழங்குகிறது, இது சிறிய திட்டங்கள் மற்றும் பெரிய அளவிலான பயன்பாடுகள் இரண்டிற்கும் Node.js பின்-முனைகளுடன் சேரும்போது ஒரு சிறந்த தேர்வாக அமைகிறது.
Node.js உடன் Vue.js ஏன் தேர்வு செய்ய வேண்டும்?
Node.js பின்-முனையுடன் Vue.js ஐ அமைத்தல்
// Node.js backend (Express)
const express = require('express');
const cors = require('cors');
const app = express();
app.use(cors());
app.get('/api/products', (req, res) => {
res.json([
{ id: 1, name: 'Product A', price: 29.99 },
{ id: 2, name: 'Product B', price: 49.99 }
]);
});
app.listen(8080, () => {
console.log('Server running on port 8080');
});
// Vue.js component
Products
Loading...
-
{{ product.name }} - ${{ product.price }}
Node.js உடன் Svelte
Svelte என்பது பயனர் இடைமுகங்களை உருவாக்குவதற்கான ஒரு புரட்சிகர அணுகுமுறையாகும், இது இயக்க நேரத்தில் உங்கள் பயன்பாட்டு குறியீட்டை விளக்குவதற்குப் பதிலாக கட்டுமான நேரத்தில் உங்கள் குறியீட்டை அதிக திறன் கொண்ட வெனில்லா JavaScript க்கு தொகுக்கிறது.
இது சிறிய தொகுப்பு அளவுகள் மற்றும் பாரம்பரிய கட்டமைப்புகளுடன் ஒப்பிடும்போது சிறந்த செயல்திறனுக்கு வழிவகுக்கிறது.
Node.js உடன் Svelte ஏன் தேர்வு செய்ய வேண்டும்?
Node.js பின்-முனையுடன் Svelte ஐ அமைத்தல்
// Node.js backend (Express)
const express = require('express');
const cors = require('cors');
const app = express();
app.use(cors());
app.get('/api/todos', (req, res) => {
res.json([
{ id: 1, text: 'Learn Node.js', done: true },
{ id: 2, text: 'Learn Svelte', done: false },
{ id: 3, text: 'Build an app', done: false }
]);
});
app.listen(8080, () => {
console.log('Server running on port 8080');
});
Todo List
{#if loading}
Loading...
{:else}
{#each todos as todo (todo.id)}
-
toggleTodo(todo.id)}
/>
{todo.text}
{/each}
{/if}
Node.js உடன் முன்-முனை கட்டமைப்புகளுக்கான சிறந்த நடைமுறைகள்
1. திட்ட கட்டமைப்பு & ஒழுங்கமைப்பு
Monorepo vs Polyrepo
Monorepo: முன்-முனை மற்றும் பின்-முனை இரண்டிற்கும் ஒற்றை களஞ்சியம்
Polyrepo: தெளிவான API ஒப்பந்தங்களுடன் தனி களஞ்சியங்கள்
பரிந்துரைக்கப்பட்ட கட்டமைப்பு
project/
├── backend/ # Node.js backend
│ ├── src/
│ ├── package.json
│ └── ...
└── frontend/ # Frontend framework
├── src/
├── package.json
└── ...
2. API வடிவமைப்பு & தகவல்தொடர்பு
RESTful API சிறந்த நடைமுறைகள்
- சரியான HTTP முறைகளைப் பயன்படுத்தவும் (GET, POST, PUT, DELETE)
- பொருத்தமான நிலை குறியீடுகளைத் திருப்பி அனுப்பவும்
- சீரான பதில் வடிவங்களை செயல்படுத்தவும்
- உங்கள் API ஐ பதிப்பு செய்யவும் (எ.கா., /api/v1/...)
நிகழ்நேர தகவல்தொடர்பு
// Server-side with Socket.io
io.on('connection', (socket) => {
socket.emit('message', 'Welcome!');
socket.on('chatMessage', (msg) => {
io.emit('message', msg);
});
});
3. பாதுகாப்பு சிறந்த நடைமுறைகள்
அத்தியாவசிய பாதுகாப்பு மிடில்வேர்
// Install required packages
npm install helmet cors express-rate-limit
express-mongo-sanitize xss-clean hpp
// Basic security setup
app.use(helmet());
app.use(cors({ origin: process.env.FRONTEND_URL }));
app.use(express.json({ limit: '10kb' }));
app.use(mongoSanitize());
app.use(xss());
4. செயல்திறன் மேம்பாடு
முன்-முனை
- குறியீடு பிரித்தல் மற்றும் சோம்பேறி ஏற்றுதல்
- படம் மேம்பாடு
- தொகுப்பு பகுப்பாய்வு (webpack-bundle-analyzer)
- ஆஃப்லைன் ஆதரவுக்கான சேவை தொழிலாளர்கள்
பின்-முனை
- கேசிங் செயல்படுத்தவும் (Redis, Memcached)
- தரவுத்தள அட்டவணைப்படுத்தல் மற்றும் வினா மேம்பாடு
- இணைப்பு குளம்
- சுருக்க மிடில்வேர்
5. வளர்ச்சி & விநியோகம்
சூழல் கட்டமைப்பு
// .env.example
NODE_ENV=development
PORT=3000
MONGODB_URI=your_mongodb_uri
JWT_SECRET=your_jwt_secret
FRONTEND_URL=http://localhost:3000
CI/CD பைப்லைன்
- தானியங்கி சோதனை (Jest, Cypress)
- கொள்கலனாக்கத்திற்கான Docker
- நீல-பச்சை விநியோகங்கள்
- கண்காணிப்பு மற்றும் பதிவு செய்தல்
பயிற்சி
சரியான சொல்லை இழுத்து விடவும்.
Node.js பின்-முனையுடன் கூடிய React பயன்பாட்டில், முன்-முனை பின்-முனைக்கு API கோரிக்கைகளைச் செய்யும் ______ கட்டமைப்பு வடிவம் பொதுவாகப் பயன்படுத்தப்படுகிறது.