OS moduli

OS moduli nima?

Node.js-dagi OS moduli asosiy operatsion tizim bilan o‘zaro ishlash uchun kuchli yordamchi dasturlar to‘plamini taqdim etadi.

It offers a cross-platform way to access system-related information and perform common operating system tasks.

Asosiy xususiyatlar:

Retrieve system information (CPU, memory, platform, etc.)
Foydalanuvchi va tarmoq ma’lumotlariga kirish
O‘zaro platforma usulida fayl yo‘llari va kataloglari bilan ishlash
Tizim resurslari va ishlashini kuzatib boring
Operatsion tizim signallari va xatolarini boshqarish

OS moduli bilan ishlashni boshlash

Modulni import qilish

OS moduli asosiy Node.js modulidir, shuning uchun uni o‘rnatish shart emas.

Siz uni CommonJS yoki ES modullari sintaksisi yordamida import qilishingiz mumkin:

CommonJS (Node.js’da standart)

const os = require('os');

ES modullari (Node.js 14+ yoki "turi" bilan: package.json ichidagi "modul")

import os from 'os';
// or
import { arch, platform, cpus } from 'os';

Asosiy foydalanish misoli

Quyida ba’zi umumiy OS modul usullarini ko‘rsatadigan tezkor misol keltirilgan:

const os = require('os');

// Basic system information
console.log(`OS Platform: ${os.platform()}`);
console.log(`OS Type: ${os.type()}`);
console.log(`OS Release: ${os.release()}`);
console.log(`CPU Architecture: ${os.arch()}`);
console.log(`Hostname: ${os.hostname()}`);

// Memory information
const totalMemGB = (os.totalmem() / (1024 * 1024 * 1024)).toFixed(2);
const freeMemGB = (os.freemem() / (1024 * 1024 * 1024)).toFixed(2);
console.log(`Memory: ${freeMemGB}GB free of ${totalMemGB}GB`);

// User information
const userInfo = os.userInfo();
console.log(`Current User: ${userInfo.username}`);
console.log(`Home Directory: ${os.homedir()}`);

O‘zingiz sinab ko‘ring »

OS moduli ma’lumotnomasi

Eslatma: Barcha OS modul usullari sinxron va natijalarni darhol qaytaradi.

Ishlash uchun muhim ilovalar uchun os.cpus() yoki os.networkInterfaces() kabi tez-tez chaqirilishi mumkin bo‘lgan usullarning natijalarini keshlashni ko‘rib chiqing.

Tizim ma’lumotlari

os.arch()

Node.js ikkilik fayli kompilyatsiya qilingan operatsion tizim protsessor arxitekturasini qaytaradi.

const os = require('os');

// Get CPU architecture
console.log(`CPU Architecture: ${os.arch()}`);

// Common values:
// - 'x64' for 64-bit systems
// - 'arm' for ARM processors
// - 'arm64' for 64-bit ARM
// - 'ia32' for 32-bit x86
// - 'mips' for MIPS processors

Try it Yourlself »

os.platform()

Operatsion tizim platformasini aniqlovchi stringni qaytaradi.

const os = require('os');

// Get platform information
const platform = os.platform();
console.log(`Platform: ${platform}`);

// Common values:
// - 'darwin' for macOS
// - 'win32' for Windows (both 32-bit and 64-bit)
// - 'linux' for Linux
// - 'freebsd' for FreeBSD
// - 'openbsd' for OpenBSD

O‘zingiz sinab ko‘ring »

os.type()

POSIX tizimlarida uname yoki Windowsda ver buyrug‘idan qaytarilgan operatsion tizim nomini qaytaradi.

const os = require('os');

// Get OS type
console.log(`OS Type: ${os.type()}`);

// Examples:
// - 'Linux' on Linux
// - 'Darwin' on macOS
// - 'Windows_NT' on Windows

O‘zingiz sinab ko‘ring »

os.release()

Operatsion tizimning reliz raqamini qaytaradi.

const os = require('os');

// Get OS release information
console.log(`OS Release: ${os.release()}`);

// Examples:
// - '10.0.19044' on Windows 10
// - '21.6.0' on macOS Monterey
// - '5.15.0-46-generic' on Ubuntu

O‘zingiz sinab ko‘ring »

os.version()

Yadro versiyasini aniqlovchi stringni qaytaradi. Windows-da bu qurilish ma’lumotlarini o‘z ichiga oladi.

const os = require('os');

// Get kernel version
console.log(`Kernel Version: ${os.version()}`);

// Example output:
// - Windows: 'Windows 10 Enterprise 10.0.19044'
// - Linux: '#49-Ubuntu SMP Tue Aug 2 08:49:28 UTC 2022'
// - macOS: 'Darwin Kernel Version 21.6.0: ...'

Foydalanuvchi va muhit

os.userInfo()

Hozirgi faol foydalanuvchi haqidagi ma’lumotlarni qaytaradi.

const os = require('os');

// Get current user information
const user = os.userInfo();
console.log('User Information:');
console.log(`- Username: ${user.username}`);
console.log(`- User ID: ${user.uid}`);
console.log(`- Group ID: ${user.gid}`);
console.log(`- Home Directory: ${user.homedir}`);

// On Windows, you can also get the user's domain
if (os.platform() === 'win32') {
console.log(`- Domain: ${user.domain || 'N/A'}`);
}

// Note: user.shell is only available on POSIX platforms
if (user.shell) {
console.log(`- Default Shell: ${user.shell}`);
}

Misolni ishga tushirish »

os.homedir()

Joriy foydalanuvchining uy katalogini qaytaradi.

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

// Get the home directory
const homeDir = os.homedir();
console.log(`Home Directory: ${homeDir}`);

// Example: Create a path to a config file in the user's home directory
const configPath = path.join(homeDir, '.myapp', 'config.json');
console.log(`Config file will be saved to: ${configPath}`);

O‘zingiz sinab ko‘ring »

os.hostname()

Operatsion tizimning xost nomini qaytaradi.

const os = require('os');

// Get the system hostname
const hostname = os.hostname();
console.log(`Hostname: ${hostname}`);

// Example: Use hostname in logging or configuration
console.log(`Server started on ${hostname} at ${new Date().toISOString()}`);

O‘zingiz sinab ko‘ring »

os.tmpdir()

Vaqtinchalik fayllar uchun operatsion tizimning standart katalogini qaytaradi.

const os = require('os');

// Get the system default temp dir
console.log(`Temporary Directory: ${os.tmpdir()}`);

O‘zingiz sinab ko‘ring »

Tizim resurslari

os.cpus()

Har bir mantiqiy protsessor yadrosi haqidagi ma’lumotlarni o‘z ichiga olgan obyektlar massivini qaytaradi.

const os = require('os');

// Get CPU information
const cpus = os.cpus();
console.log(`Number of CPU Cores: ${cpus.length}`);

// Display information about each CPU core
cpus.forEach((cpu, index) => {
  console.log(`\nCPU Core ${index + 1}:`);
  console.log(`- Model: ${cpu.model}`);
  console.log(`- Speed: ${cpu.speed} MHz`);
  console.log('- Times (ms):', {     user: cpu.times.user,
    nice: cpu.times.nice,
    sys: cpu.times.sys,
    idle: cpu.times.idle,
    irq: cpu.times.irq
  });
});
// Calculate total CPU usage (example, requires two measurements)
function calculateCpuUsage(prevCpus) {
  const currentCpus = os.cpus();
  const usage = [];

  for (let i = 0; i < currentCpus.length; i++) {
    const current = currentCpus[i];
    const prev = prevCpus ? prevCpus[i] : { times: { user: 0, nice: 0, sys: 0, idle: 0, irq: 0 } };

    const prevIdle = prev.times.idle;
    const idle = current.times.idle - prevIdle;

    let total = 0;
    for (const type in current.times) {
      total += current.times[type] - (prev.times[type] || 0);
    }

    const usagePercent = ((1 - idle / total) * 100).toFixed(1);
    usage.push(parseFloat(usagePercent));
  }

  return {
    perCore: usage,
    average: (usage.reduce((a, b) => a + b, 0) / usage.length).toFixed(1),
    cpus: currentCpus
  };
}

// Example usage of CPU usage calculation
console.log('\nCPU Usage (requires two measurements):');
const firstMeasure = os.cpus();

// Simulate some CPU work
for (let i = 0; i < 1000000000; i++) {}
const usage = calculateCpuUsage(firstMeasure);
console.log(`Average CPU Usage: ${usage.average}%`);

O‘zingiz sinab ko‘ring »

os.totalmem() va os.freemem()

Umumiy va bo‘sh tizim xotirasini mos ravishda baytlarda qaytaring.

const os = require('os');

// Format bytes to human-readable format
function formatBytes(bytes, decimals = 2) {
  if (bytes === 0) return '0 Bytes';
  const k = 1024;
  const dm = decimals < 0 ? 0 : decimals;
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
  const i = Math.floor(Math.log(bytes) / Math.log(k));
  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
}

// Get memory information
const totalMem = os.totalmem();
const freeMem = os.freemem();
const usedMem = totalMem - freeMem;
const usagePercent = ((usedMem / totalMem) * 100).toFixed(2);

console.log('Memory Information:');
console.log(`- Total Memory: ${formatBytes(totalMem)}`);
console.log(`- Free Memory: ${formatBytes(freeMem)} (${((freeMem / totalMem) * 100).toFixed(2)}%)`);
console.log(`- Used Memory: ${formatBytes(usedMem)} (${usagePercent}%)`);

// Example: Check if there's enough free memory
const MIN_FREE_MEMORY = 200 * 1024 * 1024; // 200MB
if (freeMem < MIN_FREE_MEMORY) {
  console.warn('Warning: Low on memory!');
} else {
  console.log('System has sufficient memory available');
}

O‘zingiz sinab ko‘ring »

os.loadavg()

1, 5 va 15 daqiqalik yuklanishning o‘rtacha ko‘rsatkichlarini o‘z ichiga olgan massivni qaytaradi.

const os = require('os');

// Get load averages
const loadAverages = os.loadavg();
console.log('System Load Averages (1, 5, 15 min):', loadAverages);

// On Linux/Unix, load average represents the average system load over the last 1, 5, and 15 minutes
// The values represent the number of processes in the system run queue
const [oneMin, fiveMin, fifteenMin] = loadAverages;
const cpuCount = os.cpus().length;

console.log(`1-minute load average: ${oneMin.toFixed(2)} (${(oneMin / cpuCount * 100).toFixed(1)}% of ${cpuCount} cores)`);
console.log(`5-minute load average: ${fiveMin.toFixed(2)}`);
console.log(`15-minute load average: ${fifteenMin.toFixed(2)}`);

// Example: Check if system is under heavy load
const isSystemOverloaded = oneMin > cpuCount * 1.5;
if (isSystemOverloaded) {
console.warn('Warning: System is under heavy load!');
} else {
console.log('System load is normal');
}

O‘zingiz sinab ko‘ring »

Tarmoq ma’lumotlari

os.networkInterfaces()

Tarmoq manzili tayinlangan tarmoq interfeyslarini o‘z ichiga olgan obyektni qaytaradi.

const os = require('os');

// Get network interfaces information
const networkInterfaces = os.networkInterfaces();

console.log('Network Interfaces:');

// Iterate over each network interface
Object.entries(networkInterfaces).forEach(([name, addresses]) => {
  console.log(`\nInterface: ${name}`);
  addresses.forEach((address) => {
    console.log(`- Family: ${address.family}`);
    console.log(` Address: ${address.address}`);
    console.log(` Netmask: ${address.netmask}`);
    console.log(` MAC: ${address.mac || 'N/A'}`);
    console.log(` Internal: ${address.internal}`);
  });
});

// Example: Find the first non-internal IPv4 address
function getLocalIpAddress() {
  const interfaces = os.networkInterfaces();
  for (const name of Object.keys(interfaces)) {
    for (const iface of interfaces[name]) {
      if (iface.family === 'IPv4' && !iface.internal) {
        return iface.address;
      }
    }
  }
  return '127.0.0.1'; // Fallback to localhost
}

const localIp = getLocalIpAddress();
console.log(`\nLocal IP Address: ${localIp}`);

O‘zingiz sinab ko‘ring »

os.uptime()

Tizimning ishlash vaqtini soniyalarda qaytaradi.

const os = require('os');

// Get system uptime in seconds
const uptime = os.uptime();
console.log(`System Uptime: ${uptime} seconds`);

// Format uptime in a more readable way
const uptimeDays = Math.floor(uptime / (60 * 60 * 24));
const uptimeHours = Math.floor((uptime % (60 * 60 * 24)) / (60 * 60));
const uptimeMinutes = Math.floor((uptime % (60 * 60)) / 60);
const uptimeSeconds = Math.floor(uptime % 60);

console.log(`System has been running for: ${uptimeDays} days, ${uptimeHours} hours, ${uptimeMinutes} minutes, ${uptimeSeconds} seconds`);

O‘zingiz sinab ko‘ring »

os.networkInterfaces()

Tarmoq interfeyslari haqidagi ma’lumotlarni o‘z ichiga olgan obyektni qaytaradi.

const os = require('os');

// Get network interfaces
const networkInterfaces = os.networkInterfaces();
console.log('Network Interfaces:');
console.log(JSON.stringify(networkInterfaces, null, 2));

// Iterate through network interfaces
Object.keys(networkInterfaces).forEach((interfaceName) => {
  console.log(`\nInterface: ${interfaceName}`);

  networkInterfaces[interfaceName].forEach((interface) => {
    console.log(` Address Family: ${interface.family}`);
    console.log(` IP Address: ${interface.address}`);
    console.log(` Netmask: ${interface.netmask}`);
    if (interface.mac) {
      console.log(` MAC Address: ${interface.mac}`);
    }
    console.log(` Internal: ${interface.internal ? 'Yes' : 'No'}`);
  });
});

// Function to get primary IPv4 address (non-internal)
function getPrimaryIPv4Address() {
  const interfaces = os.networkInterfaces();
  for (const name of Object.keys(interfaces)) {
    for (const interface of interfaces[name]) {
      // Skip internal and non-IPv4 addresses
      if (!interface.internal && interface.family === 'IPv4') {
        return interface.address;
      }
    }
  }
  return 'No IPv4 address found';
}

console.log(`\nPrimary IPv4 Address: ${getPrimaryIPv4Address()}`);

O‘zingiz sinab ko‘ring »

OT konstantalari va yordamchi dasturlari

os.constants

Xato kodlari, jarayon signallari va boshqalar uchun tez-tez ishlatiladigan operatsion tizimga xos konstantalarni o‘z ichiga olgan obyektni qaytaradi.

const os = require('os');

// Get all signal constants
console.log('Signal Constants:', os.constants.signals);

// Example: Handle common signals
process.on('SIGINT', () => {
  console.log('Received SIGINT. Performing cleanup...');
  process.exit(0);
});

process.on('SIGTERM', () => {
  console.log('Received SIGTERM. Shutting down gracefully...');
  process.exit(0);
});

console.log('Process is running. Press Ctrl+C to exit.');

O‘zingiz sinab ko‘ring »

os.EOL

Joriy operatsion tizim uchun string oxiri belgisini qaytaradi.

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

// Get the end-of-line marker for the current OS
console.log('End of Line character:', JSON.stringify(os.EOL));

// Example: Write a file with platform-specific line endings
const lines = [
  'First line',
  'Second line',
  'Third line'
];

// Join lines with the correct EOL character
const content = lines.join(os.EOL);
fs.writeFileSync('output.txt', content);
console.log('File written with platform-appropriate line endings');

O‘zingiz sinab ko‘ring »

Eng yaxshi amaliyotlar

1. Yo‘llarni to‘g‘ri boshqaring

O‘zaro platformalar mosligini ta’minlash uchun fayl yo‘llari uchun stringlarni birlashtirish o‘rniga har doim path.join() dan foydalaning.

// Good
const filePath = path.join(os.homedir(), 'app', 'config.json');

// Bad (won't work on Windows)
const badPath = `${os.homedir()}/app/config.json`;

2. os.EOL bilan ehtiyot bo‘ling

Fayllarni yozishda qator oxirlariga e’tibor bering. O‘zaro platformalar mosligi uchun os.EOL dan foydalaning.

const content = `First Line${os.EOL}Second Line${os.EOL}Third Line`;
fs.writeFileSync('output.txt', content, 'utf8');

3. Xotira cheklovlarini boshqarish

Ko‘p xotira talab qiladigan operatsiyalarni bajarishdan oldin mavjud xotirani tekshiring.

const MIN_FREE_MEMORY_MB = 500; // 500MB minimum free memory

function canPerformMemoryIntensiveOperation() {
  const freeMemMB = os.freemem() / (1024 * 1024);
  return freeMemMB > MIN_FREE_MEMORY_MB;
}

if (!canPerformMemoryIntensiveOperation()) {
  console.warn('Not enough free memory to perform this operation');
  // Handle the error appropriately
}

Amaliy misollar

Tizim ma’lumotlari boshqaruv paneli

Ushbu misol tizim haqida to‘liq ma’lumot hisobotini yaratadi:

const os = require('os');

function getSystemInfo() {
  const info = {
    os: {
      type: os.type(),
      platform: os.platform(),
      architecture: os.arch(),
      release: os.release(),
      hostname: os.hostname(),
      uptime: formatUptime(os.uptime())
    },
    user: {
      username: os.userInfo().username,
      homedir: os.homedir(),
      tempdir: os.tmpdir()
    },
    memory: {
      total: formatBytes(os.totalmem()),
      free: formatBytes(os.freemem()),
      usage: `${((1 - os.freemem() / os.totalmem()) * 100).toFixed(2)}%`
    },
    cpu: {
      model: os.cpus()[0].model,
      cores: os.cpus().length,
      speed: `${os.cpus()[0].speed} MHz`
    }
  };

  return info;
}

function formatUptime(seconds) {
  const days = Math.floor(seconds / (60 * 60 * 24));
  const hours = Math.floor((seconds % (60 * 60 * 24)) / (60 * 60));
  const minutes = Math.floor((seconds % (60 * 60)) / 60);
  const secs = Math.floor(seconds % 60);

  return `${days}d ${hours}h ${minutes}m ${secs}s`;
}

function formatBytes(bytes) {
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
  if (bytes === 0) return '0 Bytes';
  const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)));
  return `${(bytes / Math.pow(1024, i)).toFixed(2)} ${sizes[i]}`;
}

// Display the system information dashboard
const systemInfo = getSystemInfo();
console.log('======= SYSTEM INFORMATION DASHBOARD =======');
console.log(JSON.stringify(systemInfo, null, 2));

// Display in a more formatted way
console.log('\n======= FORMATTED SYSTEM INFORMATION =======');
console.log(`OS: ${systemInfo.os.type} (${systemInfo.os.platform} ${systemInfo.os.architecture})`);
console.log(`Version: ${systemInfo.os.release}`);
console.log(`Hostname: ${systemInfo.os.hostname}`);
console.log(`Uptime: ${systemInfo.os.uptime}`);
console.log(`User: ${systemInfo.user.username}`);
console.log(`Home Directory: ${systemInfo.user.homedir}`);
console.log(`CPU: ${systemInfo.cpu.model}`);
console.log(`Cores: ${systemInfo.cpu.cores}`);
console.log(`Speed: ${systemInfo.cpu.speed}`);
console.log(`Memory Total: ${systemInfo.memory.total}`);
console.log(`Memory Free: ${systemInfo.memory.free}`);
console.log(`Memory Usage: ${systemInfo.memory.usage}`);

Misolni ishga tushirish »

Resurs monitori

Ushbu misol har soniyada yangilanadigan asosiy resurs monitorini yaratadi:

const os = require('os');

function monitorResources() {
  console.clear(); // Clear console for a cleaner display

  const now = new Date().toLocaleTimeString();
  console.log(`======= RESOURCE MONITOR (${now}) =======`);

  // CPU Usage
  const cpus = os.cpus();
  console.log(`\nCPU Cores: ${cpus.length}`);

  // Calculate CPU usage (this is approximate since we need two measurements)
  const cpuUsage = cpus.map((cpu, index) => {
    const total = Object.values(cpu.times).reduce((acc, tv) => acc + tv, 0);
    const idle = cpu.times.idle;
    const usage = ((total - idle) / total * 100).toFixed(1);
    return `Core ${index}: ${usage}% used`;
  });

  console.log(cpuUsage.join('\n'));

  // Memory Usage
  const totalMem = os.totalmem();
  const freeMem = os.freemem();
  const usedMem = totalMem - freeMem;

  console.log('\nMemory Usage:');
  console.log(`Total: ${formatBytes(totalMem)}`);
  console.log(`Used: ${formatBytes(usedMem)} (${(usedMem / totalMem * 100).toFixed(1)}%)`);
  console.log(`Free: ${formatBytes(freeMem)} (${(freeMem / totalMem * 100).toFixed(1)}%)`);

  // System Uptime
  console.log(`\nSystem Uptime: ${formatUptime(os.uptime())}`);

  // Process Info
  console.log('\nProcess Information:');
  console.log(`PID: ${process.pid}`);
  console.log(`Memory Usage: ${formatBytes(process.memoryUsage().rss)}`);
  console.log(`User: ${os.userInfo().username}`);
}

function formatBytes(bytes) {
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
  if (bytes === 0) return '0 Bytes';
  const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)));
  return `${(bytes / Math.pow(1024, i)).toFixed(2)} ${sizes[i]}`;
}

function formatUptime(seconds) {
  const days = Math.floor(seconds / (60 * 60 * 24));
  const hours = Math.floor((seconds % (60 * 60 * 24)) / (60 * 60));
  const minutes = Math.floor((seconds % (60 * 60)) / 60);
  const secs = Math.floor(seconds % 60);

  return `${days}d ${hours}h ${minutes}m ${secs}s`;
}

// Initial display
monitorResources();

// Update every second (note: in a real application, you might not want
// to update this frequently as it uses CPU resources)
const intervalId = setInterval(monitorResources, 1000);

// In a real application, you would need to handle cleanup:
// clearInterval(intervalId);

// For this example, we'll run for 10 seconds then stop
console.log('Monitor will run for 10 seconds...');
setTimeout(() => {
  clearInterval(intervalId);
  console.log('\nResource monitoring stopped.');
}, 10000);

Misolni ishga tushirish »

Platformaga xos xulq-atvor

Ushbu misol ilovangizning xatti-harakatlarini operatsion tizim asosida qanday moslashtirishni ko‘rsatadi:

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

// Function to determine a good location for app data based on the OS
function getAppDataPath(appName) {
  const platform = os.platform();

  let appDataPath;

  switch (platform) {
    case 'win32': // Windows
      appDataPath = path.join(process.env.APPDATA || '', appName);
      break;
    case 'darwin': // macOS
      appDataPath = path.join(os.homedir(), 'Library', 'Application Support', appName);
      break;
    case 'linux': // Linux
      appDataPath = path.join(os.homedir(), '.config', appName);
      break;
    default: // Fallback for other platforms
      appDataPath = path.join(os.homedir(), `.${appName}`);
  }

  return appDataPath;
}

// Function to get appropriate command based on OS
function getOpenCommand() {
  const platform = os.platform();

  switch (platform) {
    case 'win32': // Windows
      return 'start';
    case 'darwin': // macOS
      return 'open';
    default: // Linux and others
      return 'xdg-open';
  }
}

// Example usage
const appName = 'myapp';
const appDataPath = getAppDataPath(appName);
const openCommand = getOpenCommand();

console.log(`OS Platform: ${os.platform()}`);
console.log(`OS Type: ${os.type()}`);
console.log(`Recommended App Data Path: ${appDataPath}`);
console.log(`Open Command: ${openCommand}`);

// Example of platform-specific behavior
console.log('\nPlatform-Specific Actions:');

if (os.platform() === 'win32') {
  console.log('- Using Windows-specific registry functions');
  console.log('- Setting up Windows service');
} else if (os.platform() === 'darwin') {
  console.log('- Using macOS keychain for secure storage');
  console.log('- Setting up launchd agent');
} else if (os.platform() === 'linux') {
  console.log('- Using Linux systemd for service management');
  console.log('- Setting up dbus integration');
}

// Example of checking for available memory and adjusting behavior
const availableMemGB = os.freemem() / (1024 * 1024 * 1024);
console.log(`\nAvailable Memory: ${availableMemGB.toFixed(2)} GB`);

if (availableMemGB < 0.5) {
  console.log('Low memory mode activated: reducing cache size and disabling features');
} else if (availableMemGB > 4) {
  console.log('High memory mode activated: increasing cache size and enabling all features');
} else {
  console.log('Standard memory mode activated: using default settings');
}

// Example of CPU core detection for parallel processing
const cpuCount = os.cpus().length;
console.log(`\nCPU Cores: ${cpuCount}`);

const recommendedWorkers = Math.max(1, cpuCount - 1); // Leave one core for the system
console.log(`Recommended worker processes: ${recommendedWorkers}`);

O‘zingiz sinab ko‘ring »

Xulosa

Node.js OS moduli operatsion tizim bilan ishlash uchun kuchli vositalar to‘plamini taqdim etadi.

U bilan siz:

CPU arxitekturasi, platformasi va versiya versiyasi kabi tizim ma’lumotlarini oling
Xotiradan foydalanish va protsessor ishlashini kuzatib boring
Uy katalogi va foydalanuvchi nomi kabi foydalanuvchi ma’lumotlariga kirish
Tarmoq interfeysi ma’lumotlarini oling
Tizimning ishlash vaqtini aniqlang
Operatsion tizimga xos konstantalar va qator oxiri belgilaridan foydalaning

Bu qobiliyatlar, ayniqsa, quyidagilar uchun foydalidir:

Xost muhitiga moslashuvchi o‘zaro platforma ilovalarini yaratish
Tizim resurslarini monitoring qilish
Diagnostika vositalarini yaratish
Turli xil operatsion tizimlarda to‘g‘ri ishlaydigan yo‘l va fayl bilan bog‘liq operatsiyalarni bajarish
Mavjud tizim resurslari asosida dastur unumdorlikni optimallashtirish

OS modulidan foydalanib, siz Node.js ilovalaringizni yanada mustahkam, samarali va turli ish muhitlariga moslasha oladigan qilishingiz mumkin.

W3Schools Pathfinder

Yutuqlaringizni kuzating – bu bepul!

Ro'yxatdan o'tish Kirish