Node.js with Frontend Frameworks

நவீன முன்-முனை கட்டமைப்புகளுடன் Node.js ஐ ஒருங்கிணைத்து முழுமையான வலைப் பயன்பாடுகளை உருவாக்க கற்றுக்கொள்ளுங்கள்

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 ஏன் பயன்படுத்த வேண்டும்?

கூறு-அடிப்படையிலான கட்டமைப்பு: தங்கள் சொந்த நிலையை நிர்வகிக்கும் இன்காப்சுலேடட் கூறுகளை உருவாக்கவும்
மெய்நிகர் DOM: திறமையான புதுப்பிப்புகள் மற்றும் ரெண்டரிங்
பணக்கார சூழல்: பெரிய சமூகம் மற்றும் விரிவான தொகுப்பு சூழல்
டெவலப்பர் கருவிகள்: சிறந்த டிபக்கிங் மற்றும் வளர்ச்சி கருவிகள்

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 இன் முக்கிய அம்சங்கள்

TypeScript ஆதரவு: சிறந்த கருவிகள் மற்றும் வகை பாதுகாப்புக்காக TypeScript உடன் கட்டப்பட்டது
சார்பு உட்செலுத்துதல்: சிறந்த கூறு ஒழுங்கமைப்புக்கான உள்ளமைக்கப்பட்ட DI அமைப்பு
மாடுலர் கட்டமைப்பு: தொகுதிகள், கூறுகள் மற்றும் சேவைகளாக ஒழுங்கமைக்கப்பட்டது
RxJS ஒருங்கிணைப்பு: Observables உடன் சக்திவாய்ந்த ரியாக்டிவ் புரோகிராமிங்
Angular CLI: திட்ட உருவாக்கம் மற்றும் கட்டுமான கருவிகளுக்கான கட்டளை வரி இடைமுகம்

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 ஏன் தேர்வு செய்ய வேண்டும்?

முற்போக்கான கட்டமைப்பு: ஒரு நூலகத்திலிருந்து முழு அம்சங்களுடன் கூடிய கட்டமைப்புக்கு அளவிடுகிறது
ரியாக்டிவ் தரவு பைண்டிங்: எளிமையான மற்றும் உள்ளுணர்வான இரண்டு-வழி தரவு பைண்டிங்
கூறு-அடிப்படையிலான: இன்காப்சுலேடட், மீண்டும் பயன்படுத்தக்கூடிய கூறுகளை உருவாக்கவும்
Vue CLI: திட்ட ஸ்கேஃபோல்டிங்கிற்கான சக்திவாய்ந்த கட்டளை வரி இடைமுகம்
Vuex: சிக்கலான பயன்பாடுகளுக்கான மையப்படுத்தப்பட்ட நிலை மேலாண்மை

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


Node.js உடன் Svelte

Svelte என்பது பயனர் இடைமுகங்களை உருவாக்குவதற்கான ஒரு புரட்சிகர அணுகுமுறையாகும், இது இயக்க நேரத்தில் உங்கள் பயன்பாட்டு குறியீட்டை விளக்குவதற்குப் பதிலாக கட்டுமான நேரத்தில் உங்கள் குறியீட்டை அதிக திறன் கொண்ட வெனில்லா JavaScript க்கு தொகுக்கிறது.

இது சிறிய தொகுப்பு அளவுகள் மற்றும் பாரம்பரிய கட்டமைப்புகளுடன் ஒப்பிடும்போது சிறந்த செயல்திறனுக்கு வழிவகுக்கிறது.

Node.js உடன் Svelte ஏன் தேர்வு செய்ய வேண்டும்?

மெய்நிகர் DOM இல்லை: சிறந்த செயல்திறனுக்காக வெனில்லா JavaScript க்கு தொகுக்கிறது
சிறிய தொகுப்பு அளவு: உலாவிக்கு அனுப்ப கட்டமைப்பு இயக்க நேரம் இல்லை
எளிமையான குறியீடு: பாரம்பரிய கட்டமைப்புகளை விட குறைவான போய்லர்ப்ளேட்
இயல்பாகவே ரியாக்டிவ்: சிக்கலான நிலை மேலாண்மை இல்லாமல் தானாக புதுப்பிப்புகள்
நோக்கப்பட்ட CSS: CSS-in-JS இல்லாமல் கூறு-நோக்கப்பட்ட பாணிகள்

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 சிறந்த நடைமுறைகள்

நிகழ்நேர தகவல்தொடர்பு

// 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 பைப்லைன்

பயிற்சி

சரியான சொல்லை இழுத்து விடவும்.

Node.js பின்-முனையுடன் கூடிய React பயன்பாட்டில், முன்-முனை பின்-முனைக்கு API கோரிக்கைகளைச் செய்யும் ______ கட்டமைப்பு வடிவம் பொதுவாகப் பயன்படுத்தப்படுகிறது.

MVC
✗ தவறு! MVC (Model-View-Controller) என்பது ஒரு வெவ்வேறு கட்டமைப்பு வடிவமாகும், இது React உடன் பொதுவாகப் பயன்படுத்தப்படுவதில்லை
MVVM
✗ தவறு! MVVM (Model-View-ViewModel) என்பது Angular போன்ற கட்டமைப்புகளில் பயன்படுத்தப்படும் ஒரு வடிவமாகும், React உடன் அல்ல
API-First
✓ சரி! API-First கட்டமைப்பு வடிவம் Node.js பின்-முனையுடன் கூடிய React பயன்பாடுகளில் பொதுவாகப் பயன்படுத்தப்படுகிறது, இதில் முன்-முனை பின்-முனையின் RESTful அல்லது GraphQL APIகளுக்கு கோரிக்கைகளைச் செய்கிறது
Microservices
✗ தவறு! Microservices என்பது பின்-முனை கட்டமைப்புக்கான ஒரு வடிவமாகும், முன்-முனை மற்றும் பின்-முனை இடையேயான தகவல்தொடர்புக்கு அல்ல