Jassif Team Institution

node --inspect app.js

node --inspect-brk app.js

node --inspect=127.0.0.1:9222 app.js

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "launch",
      "name": "Launch Program",
      "program": "${workspaceFolder}/app.js",
      "skipFiles": ["<node_internals>/**"]
    },
    {
      "type": "node",
      "request": "attach",
      "name": "Attach to Process",
      "port": 9229
    }
  ]
}

npm install debug

// உங்கள் பயன்பாட்டின் வெவ்வேறு பகுதிகளுக்கு பெயர்வெளி debuggers உருவாக்கவும்
const debug = require('debug');

const debugServer = debug('app:server');
const debugDatabase = debug('app:database');
const debugAuth = debug('app:auth');

// உங்கள் குறியீட்டில் debuggers பயன்படுத்தவும்
debugServer('Server starting on port %d', 8080);
debugDatabase('Connected to database: %s', 'mongodb://localhost');
debugAuth('User %s authenticated', 'john@example.com');

// இயல்புநிலையாக, இந்த debug செய்திகள் வெளியீட்டில் தோன்றாது

DEBUG=app:* node app.js

DEBUG=app:server,app:auth node app.js

DEBUG=app:*,-app:database node app.js

// நினைவக பயன்பாட்டைக் கண்காணிக்கவும்
function logMemoryUsage() {
  const memoryUsage = process.memoryUsage();
  console.log('Memory usage:');
  console.log(`RSS: ${Math.round(memoryUsage.rss / 1024 / 1024)} MB`);
  console.log(`Heap Total: ${Math.round(memoryUsage.heapTotal / 1024 / 1024)} MB`);
  console.log(`Heap Used: ${Math.round(memoryUsage.heapUsed / 1024 / 1024)} MB`);
}

// ஒவ்வொரு 30 வினாடிகளுக்கும் நினைவக பயன்பாட்டை பதிவு செய்யவும்
setInterval(logMemoryUsage, 30000);

const http = require('http');

// இந்த பொருள் ஒவ்வொரு கோரிக்கைக்கும் தரவை சேமிக்கும் (நினைவக கசிவு!)
const requestData = {};

const server = http.createServer((req, res) => {
  // ஒரு தனித்துவமான கோரிக்கை ID ஐ உருவாக்கவும்
  const requestId = Date.now() + Math.random().toString(36).substring(2, 15);

  // உலகளாவிய பொருளில் தரவை சேமிக்கவும் (இது நினைவக கசிவு!)
  requestData[requestId] = {
    url: req.url,
    method: req.method,
    headers: req.headers,
    timestamp: Date.now(),
    // கசிவை மிகவும் வெளிப்படையாக்க ஒரு பெரிய பொருளை உருவாக்கவும்
    payload: Buffer.alloc(1024 * 1024) // கோரிக்கைக்கு 1MB ஒதுக்கவும்
  };

  // ஒவ்வொரு கோரிக்கைக்கும் பிறகு நினைவக பயன்பாட்டை பதிவு செய்யவும்
  const memoryUsage = process.memoryUsage();
  console.log(`Memory usage after request ${requestId}:`);
  console.log(`- Heap Used: ${Math.round(memoryUsage.heapUsed / 1024 / 1024)} MB`);
  console.log(`- Request count: ${Object.keys(requestData).length}`);

  res.end('Request processed');
});

server.listen(8080);

const http = require('http');

// இந்த பொருள் ஒவ்வொரு கோரிக்கைக்கும் தரவை சேமிக்கும்
const requestData = {};

const server = http.createServer((req, res) => {
  const requestId = Date.now() + Math.random().toString(36).substring(2, 15);

  // உலகளாவிய பொருளில் தரவை சேமிக்கவும்
  requestData[requestId] = {
    url: req.url,
    method: req.method,
    timestamp: Date.now()
  };

  // பதில் அனுப்பப்பட்ட பிறகு சுத்தம் செய்யவும் (நினைவக கசிவுக்கான தீர்வு)
  res.on('finish', () => {
    delete requestData[requestId];
    console.log(`Cleaned up request ${requestId}`);
  });

  res.end('Request processed');
});

server.listen(8080);

# CPU சுயவிவரத்தை உருவாக்கவும்
node --prof app.js

# உருவாக்கப்பட்ட பதிவு கோப்பை ஒரு வாசிக்கக்கூடிய வடிவமைப்பிற்கு மாற்றவும்
node --prof-process isolate-0xnnnnnnnnnnnn-v8.log > processed.txt

// திறனற்ற சுழல்நிலை Fibonacci செயல்பாடு
function inefficientFibonacci(n) {
  if (n <= 1) return n;
  return inefficientFibonacci(n - 1) + inefficientFibonacci(n - 2);
}

// மிகவும் திறன்மிக்க மீள் செயல்பாட்டு Fibonacci செயல்பாடு
function efficientFibonacci(n) {
  if (n <= 1) return n;

  let a = 0, b = 1, temp;
  for (let i = 2; i <= n; i++) {
    temp = a + b;
    a = b;
    b = temp;
  }

  return b;
}

// செயல்திறனை ஒப்பிடுக
function comparePerformance(n) {
  console.log(`Calculating Fibonacci(${n})`);

  // திறனற்ற பதிப்பை நேரம் கணக்கிடவும்
  const inefficientStart = process.hrtime.bigint();
  const inefficientResult = inefficientFibonacci(n);
  const inefficientEnd = process.hrtime.bigint();
  const inefficientTime = Number(inefficientEnd - inefficientStart) / 1_000_000; // in ms

  // திறன்மிக்க பதிப்பை நேரம் கணக்கிடவும்
  const efficientStart = process.hrtime.bigint();
  const efficientResult = efficientFibonacci(n);
  const efficientEnd = process.hrtime.bigint();
  const efficientTime = Number(efficientEnd - efficientStart) / 1_000_000; // in ms

  console.log(`Inefficient: ${inefficientResult} (${inefficientTime.toFixed(2)} ms)`);
  console.log(`Efficient: ${efficientResult} (${efficientTime.toFixed(2)} ms)`);
  console.log(`Speedup: ${Math.round(inefficientTime / efficientTime)}x`);
}

// ஒப்பீட்டை இயக்கவும்
comparePerformance(30);

// பிழைத்திருத்த கடினம்
fetch('https://api.example.com/data')
  .then(response => response.json())
  .then(data => processData(data))
  .catch(error => console.error('Error:', error));

// பிழைத்திருத்த எளிதானது
async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    return processData(data);
  } catch (error) {
    console.error('Error:', error);
    throw error; // கையாள மேல் அடுக்குகளுக்கு மீண்டும் வீசவும்
  }
}

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

// கால்பேக்குகளை வாக்குறுதிகளாக மாற்றவும்
const readFile = util.promisify(fs.readFile);

// உள்ளமைக்கப்பட்ட async செயல்பாடுகளின் சங்கிலியுடன் செயல்பாடு
async function processUserData(userId) {
  try {
    console.log(`Processing data for user ${userId}...`);
    
    // பயனர் தரவைப் பெறவும்
    const userData = await fetchUserData(userId);
    console.log(`User data retrieved: ${userData.name}`);

    // பயனர் இடுகைகளைப் பெறவும்
    const posts = await getUserPosts(userId);
    console.log(`Retrieved ${posts.length} posts for user`);

    // இடுகைகளை செயலாக்கவும் (இது userId = 3 க்கு ஒரு பிழையை ஏற்படுத்தும்)
    const processedPosts = posts.map(post => {
      return {
        id: post.id,
        title: post.title.toUpperCase(),
        contentLength: post.content.length, // content வரையறுக்கப்படவில்லை என்றால் தோல்வியடையும்
      };
    });
    return { user: userData, posts: processedPosts };
   } catch (error) {
    console.error('Error processing user data:', error);
    throw error;
  }
}

// உருவகப்படுத்தப்பட்ட API அழைப்பு
function fetchUserData(userId) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (userId <= 0) {
        reject(new Error('Invalid user ID'));
      } else {
        resolve({ id: userId, name: `User ${userId}` });
      }
    }, 500);
  });
}

// உருவகப்படுத்தப்பட்ட தரவுத்தள வினா
function getUserPosts(userId) {
  return new Promise((resolve) => {
    setTimeout(() => {
      // பிழை: userId 3 க்கு வரையறுக்கப்படாத உள்ளடக்கத்துடன் இடுகை
      if (userId === 3) {
        resolve([
          { id: 1, title: 'First Post', content: 'Content' },
          { id: 2, title: 'Second Post', content: undefined }
        ]);
      } else {
        resolve([
          { id: 1, title: 'First Post', content: 'Content' },
          { id: 2, title: 'Second Post', content: 'More content' }
        ]);
      }
    }, 300);
  });
}

// பயன்பாடு
processUserData(3).catch(err => console.log('Caught at top level:', err.message));