Sertifikat olingYANGIW3Schools ilovasiiOS va AndroidSarguzashtni boshlang

Readline moduli

ULASHISH

Readline moduliga kirish

Readline moduli Readable oqimdan (masalan, process.stdin) ma’lumotlarni qatorma-qator o‘qish uchun interfeys taqdim etadigan asosiy Node.js modulidir.

Bu, ayniqsa, quyidagilar uchun foydalidir:

Umumiy foydalanish holatlari

  • Interaktiv buyruq qatori ilovalari
  • Konfiguratsiya ustalari va sozlash vositalari
  • Buyruqlar qatori o‘yinlari
  • REPL (Read-Eval-Print Loop) environments
  • Katta matnli fayllarni string bo‘yicha qayta ishlash
  • Maxsus qobiqlar va CLI’larni yaratish

Asosiy xususiyatlar

  • Satr bo‘yicha kirishni qayta ishlash
  • Moslashtirilgan takliflar va formatlash
  • Jadvalni to‘ldirishni qo‘llab-quvvatlash
  • Tarixni boshqarish
  • Voqealarga asoslangan interfeys
  • Promise-ga asoslangan API qo‘llab-quvvatlash

Eslatma: Readline moduli Node.js ichiga o‘rnatilgan, shuning uchun qo‘shimcha o‘rnatish talab qilinmaydi.

Bu buyruq satri orqali foydalanuvchilar bilan muloqot qilishi yoki matn kiritishni satrga yo‘naltirilgan tarzda qayta ishlashi kerak bo‘lgan har qanday ilova uchun juda mos keladi.

Readline bilan ishlashni boshlash

Oddiy interaktiv buyruq qatori ilovasini yaratish uchun Readline modulidan foydalanishning qisqacha misoli:

Asosiy interaktiv taklif

const readline = require('readline');

// Create interface for input/output
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

// Ask a question and handle the response
rl.question('What is your name? ', (name) => {
  console.log(`Hello, ${name}!`);

  // Ask follow-up question
  rl.question('How old are you? ', (age) => {
    console.log(`In 5 years, you'll be ${parseInt(age) + 5} years old.`);

    // Close the interface when done
    rl.close();
  });
});

// Handle application exit
rl.on('close', () => {
  console.log('Goodbye!');
  process.exit(0);
});
Misolni ishga tushirish »

Import va sozlash

Readline moduli modul tizimi va ehtiyojlariga qarab bir necha usul bilan import qilinishi mumkin:

CommonJS (Node.js’da standart)

// Basic require
const readline = require('readline');

// Import specific methods using destructuring
const { createInterface } = require('readline');

// Create interface with default settings
const rl = createInterface({
  input: process.stdin,
  output: process.stdout
});

ES modullari (Node.js 12+)

// Using default import
import readline from 'readline';

// Using named imports
import { createInterface } from 'readline';

// Dynamic import (Node.js 14+)
const { createInterface } = await import('readline');

// Create interface
const rl = createInterface({
  input: process.stdin,
  output: process.stdout
});

Eng yaxshi amaliyot: Tizim resurslarini bo‘shatish va dasturingizdan toza chiqishga ruxsat berish uchun uni bajarib bo‘lgach, har doim rl.close() yordamida o‘qish interfeysini yoping.

Readline interfeysini yaratish

createInterface usuli - o‘qish interfeysini yaratishning asosiy usuli. U bir nechta konfiguratsiya xususiyatlariga ega variantlar obyektini oladi:

Asosiy interfeys yaratish

const readline = require('readline');

// Create a basic interface
const rl = readline.createInterface({
  input: process.stdin, // Readable stream to listen to
  output: process.stdout, // Writable stream to write to
  prompt: '> ', // Prompt to display (default: '> ')
});

Umumiy variantlar:

  • input : Tinglash uchun o‘qiladigan stream (standart: process.stdin )
  • output : Yoziladigan stream (standart: process.stdout )
  • prompt : Foydalanish uchun taklif stringi (standart: '> ')
  • terminal : Agar rost bo‘lsa, chiqishni TTY deb hisoblaydi (standart: output.isTTY )
  • historySize : Tarix yozuvlarining maksimal soni (standart: 30)
  • removeHistoryDuplicates : Agar rost bo‘lsa, takroriy tarix yozuvlarini o‘chirib tashlaydi (standart: noto‘g‘ri)
  • completer : Yorliqlarni avtomatik to‘ldirish uchun ixtiyoriy funksiya
  • crlfDelay : CR va LF o‘rtasidagi kechikish (standart: 100ms)
  • escapeCodeTimeout : Belgilardan qochish ketma-ketligini kutish vaqti (standart: 500ms)

Kengaytirilgan interfeysga misol

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

// Create an interface with advanced options
const rl = readline.createInterface({
  input: fs.createReadStream('input.txt'), // Read from file
  output: process.stdout, // Write to console
  terminal: false, // Input is not a terminal
  historySize: 100, // Larger history
  removeHistoryDuplicates: true, // Don't store duplicate commands
  prompt: 'CLI> ', // Custom prompt
  crlfDelay: Infinity, // Handle all CR/LF as single line break
  escapeCodeTimeout: 200 // Faster escape code detection
});

// Handle each line from the file
rl.on('line', (line) => {
  console.log(`Processing: ${line}`);
});

// Handle end of file
rl.on('close', () => {
  console.log('Finished processing file');
});

Eslatma: Fayllarni qayta ishlash uchun interfeyslarni yaratishda TTY-ga xos xususiyatlarni o‘chirish va unumdorlikni oshirish uchun terminal: false ni o‘rnating.

O‘qishning asosiy usullari

Readline moduli foydalanuvchi bilan muloqot qilishning bir necha usullarini taqdim etadi. Bu yerda eng ko‘p ishlatiladiganlar:

1. rl.question(query, callback)

Foydalanuvchiga so‘rovni ko‘rsatadi va foydalanuvchining javobi bilan callback funksiyasini chaqiradi. Bu oddiy foydalanuvchi shovqinlari uchun eng ko‘p qo‘llaniladigan usullardan biridir.

Asosiy misol

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

rl.question('What is your name? ', (name) => {
  console.log(`Hello, ${name}!`);
  rl.close();
});

O‘rnatilgan savollarga misol

function askQuestion(query) {
  return new Promise(resolve => {
    rl.question(query, resolve);
  });
}

async function userSurvey() {
  try {
    const name = await askQuestion('What is your name? ');
    const age = await askQuestion('How old are you? ');
    const email = await askQuestion('What is your email? ');

    console.log('\n=== User Information ===');
    console.log(`Name: ${name}`);
    console.log(`Age: ${age}`);
    console.log(`Email: ${email}`);

  } catch (error) {
    console.error('An error occurred:', error);
  } finally {
    rl.close();
  }
}

userSurvey();

rl.question() uchun eng yaxshi amaliyotlar:

  • callback qilish funksiyasidagi xatolarni har doim boshqaring
  • Bir nechta savollar bilan oqimni yaxshiroq boshqarish uchun Promiselar yoki asinx/kutishdan foydalanishni o‘ylab ko‘ring
  • Ishlov berishdan oldin foydalanuvchi ma’lumotlarini tasdiqlang
  • Resurslarni bo‘shatish uchun har doim interfeysni yoping

2. rl.prompt([preserveCursor])

Joriy taklif satrini (prompt) chiqishga yozadi va foydalanuvchi kiritishini kutadi. Ixtiyoriy preserveCursor parametri (boolean) kursor pozitsiyasi saqlanishi kerakligini belgilaydi.

Asosiy taklif namunasi

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  prompt: 'CLI> '
});
// Display initial prompt
rl.prompt();

// Handle each line of input
rl.on('line', (line) => {
  const input = line.trim();

  switch (input) {
    case 'hello':
      console.log('Hello there!');
      break;
    case 'time':
      console.log(`Current time: ${new Date().toLocaleTimeString()}`);
      break;
    case 'exit':
      rl.close();
      return;
    default:
      console.log(`You entered: ${input}`);
  }

  // Show the prompt again
  rl.prompt();
});

// Handle application exit
rl.on('close', () => {
  console.log('Goodbye!');
  process.exit(0);
});

Ko‘rsatmalardan foydalanish bo‘yicha maslahatlar:

  • So‘rov stringini dinamik ravishda o‘zgartirish uchun rl.setPrompt() dan foydalaning
  • Ko‘p qatorli takliflar uchun so‘rov stringiga qatorlarni qo‘shing
  • Ko‘rsatmalarga ranglar qo‘shish uchun chalk kabi kutubxonadan foydalanishni o‘ylab ko‘ring
  • So‘rovni qayta ko‘rsatish uchun har bir kiritilgan ma’lumotlarni ko‘rib chiqqandan so‘ng rl.prompt() metodini chaqirishni unutmang

3. rl.write(data[, key])

Chiqish oqimiga ma’lumotlarni yozadi. Ixtiyoriy key parametri tugmachalarni bosishni taqlid qilish uchun ishlatilishi mumkin.

Misol yozing

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

// Display a welcome message
rl.write('Welcome to the CLI Application!\n');
rl.write('='.repeat(30) + '\n\n');

// Pre-fill a default value
rl.question('Enter your username: ', (username) => {
  console.log(`Hello, ${username}!`);

  // Simulate typing a default value
  rl.write('default@example.com');

  // Move cursor to the beginning of the line
  rl.write(null, { ctrl: true, name: 'a' });

  rl.question('Enter your email: ', (email) => {
    console.log(`Your email is: ${email}`);
    rl.close();
  });
});

rl.write() uchun umumiy foydalanish holatlari:

  • Sarlavhalar yoki bo‘lim sarlavhalarini ko‘rsatish
  • Ko‘rsatmalarda standart qiymatlarni taqdim etish
  • Sinov uchun foydalanuvchi kiritishini simulyatsiya qilish
  • Maxsus kiritish formatini yaratish

4. rl.close()

Readline interfeysini yopadi va kirish va chiqish oqimlarini boshqarishni bo‘shatadi. Bu tizim resurslarini bo‘shatish va dasturingizdan toza chiqish imkonini berish uchun muhimdir.

To‘g‘ri tozalash misoli

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

// Handle application exit
function exitApp() {
  console.log('\nCleaning up resources...');

  // Perform any necessary cleanup
  // (e.g., close database connections, write logs, etc.)

  // Close the readline interface
  rl.close();
}

// Handle Ctrl+C
rl.on('SIGINT', () => {
  console.log('\nReceived SIGINT. Exiting...');
  exitApp();
});

// Handle normal exit
rl.on('close', () => {
  console.log('Goodbye!');
  process.exit(0);
});

// Start the application
console.log('Application started. Press Ctrl+C to exit.');
rl.prompt();

5. rl.pause() va rl.resume()

Ushbu usullar kirish oqimini vaqtincha to‘xtatib turish va davom ettirish imkonini beradi, bu esa foydalanuvchi kiritish oqimini boshqarish uchun foydali bo‘lishi mumkin.

To‘xtatib turish/davom etish misoli

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

let isPaused = false;

console.log('Type "pause" to pause input, "resume" to continue, or "exit" to quit');

rl.on('line', (input) => {
  const command = input.trim().toLowerCase();

  switch (command) {
    case 'pause':
      if (!isPaused) {
        console.log('Input paused. Type "resume" to continue...');
        rl.pause();
        isPaused = true;
      }
      break;

    case 'resume':
      if (isPaused) {
        console.log('Resuming input...');
        rl.resume();
        rl.prompt();
        isPaused = false;
      }
      break;

    case 'exit':
      console.log('Goodbye!');
      rl.close();
      return;

    default:
      if (!isPaused) {
        console.log(`You entered: ${input}`);
        rl.prompt();
      }
  }
});

rl.prompt();

To‘xtatib turish/davom etishdan qachon foydalanish kerak:

  • Foydalanuvchi kiritishi bilan to‘xtatilmasligi kerak bo‘lgan uzoq muddatli operatsiyalarni bajarishda
  • Muayyan operatsiyalar paytida foydalanuvchi kiritishni vaqtincha o‘chirib qo‘yganda
  • Uzoq chiqishlar uchun peyjing mexanizmini amalga oshirishda
  • Qachon siz kiritishni qayta ishlashni bosishingiz kerak
Metod Tavsif
rl.question(query, callback) So‘rovni ko‘rsatadi va foydalanuvchi kiritishini kutadi, so‘ngra foydalanuvchi javobi bilan callback funksiyasini chaqiradi
rl.prompt([preserveCursor]) Foydalanuvchi kiritish uchun sozlangan so‘rovni ko‘rsatadi
rl.write(data[, key]) Chiqish oqimiga ma’lumotlarni yozadi, shuningdek, tugmachalarni bosish hodisalarini simulyatsiya qilishi mumkin
rl.close() Readline interfeysini yopadi va kirish va chiqish oqimlarini boshqarishdan voz kechadi
rl.pause() O‘qishga kirish oqimini to‘xtatib turadi
rl.resume() Readline kiritish oqimini davom ettiradi

Readline bilan Promiselardan foydalanish

Readline modulining callback funksiyasiqa asoslangan API-ni yanada zamonaviy, asenk/kutish uchun qulay kod Promiselari bilan o‘rash mumkin:

const readline = require('readline');

// Create interface
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

// Promise-based question function
function askQuestion(query) {
  return new Promise(resolve => {
    rl.question(query, resolve);
  });
}

// Using async/await with readline
async function main() {
  try {
    const name = await askQuestion('What is your name? ');
    console.log(`Hello, ${name}!`);

    const age = await askQuestion('How old are you? ');
    console.log(`In 5 years, you'll be ${parseInt(age) + 5} years old.`);

    const location = await askQuestion('Where do you live? ');
    console.log(`${location} is a great place!`);

    console.log('Thank you for your answers!');
  } catch (error) {
    console.error('Error:', error);
  } finally {
    rl.close();
   }
}

// Run the main function
main();

Interaktiv CLI menyusini yaratish

Buyruqlar qatori ilovalari uchun interaktiv menyular yaratish uchun Readline modulidan foydalanishingiz mumkin:

const readline = require('readline');

// Create interface
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

// Menu options
const menu = {
  1: 'Show current time',
  2: 'Show system info',
  3: 'Show memory usage',
  4: 'Exit'
};

// Function to display menu
function displayMenu() {
  console.log('\n===== MAIN MENU =====');
  for (const [key, value] of Object.entries(menu)) {
    console.log(`${key}: ${value}`);
  }
  console.log('====================\n');
}

// Function to handle menu selection
async function handleMenu() {
  let running = true;

  while (running) {
    displayMenu();

    const answer = await askQuestion('Select an option: ');

    switch (answer) {
      case '1':
        console.log(`Current time: ${new Date().toLocaleTimeString()}`);
        break;

      case '2':
        console.log('System info:');
        console.log(`Platform: ${process.platform}`);
        console.log(`Node.js version: ${process.version}`);
        console.log(`Process ID: ${process.pid}`);
        break;

      case '3':
        const memory = process.memoryUsage();
        console.log('Memory usage:');
        for (const [key, value] of Object.entries(memory)) {
          console.log(`${key}: ${Math.round(value / 1024 / 1024 * 100) / 100} MB`);
        }
        break;

      case '4':
        console.log('Exiting program. Goodbye!');
        running = false;
        break;

      default:
        console.log('Invalid option. Please try again.');
      }

      if (running) {
        await askQuestion('\nPress Enter to continue...');
        console.clear(); // Clear console for better UX
      }
  }
}

// Promise-based question function
function askQuestion(query) {
  return new Promise(resolve => {
    rl.question(query, resolve);
  });
}

// Start the interactive menu
handleMenu()
  .finally(() => {
    rl.close();
  });

Faylni string bo‘yicha o‘qish

Interaktiv kiritishdan tashqari, Readline moduli fayllarni string bo‘yicha ham o‘qiy oladi, bu esa katta matnli fayllarni samarali qayta ishlash uchun foydalidir:

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

// Create a readable stream for the file
const fileStream = fs.createReadStream('example.txt');

// Create the readline interface
const rl = readline.createInterface({
  input: fileStream,
  crlfDelay: Infinity // Recognize all instances of CR LF as a single line break
});

// Counter for line numbers
let lineNumber = 0;

// Process file line by line
rl.on('line', (line) => {
  lineNumber++;
  console.log(`Line ${lineNumber}: ${line}`);
});

// Handle end of file
rl.on('close', () => {
  console.log(`Finished reading file with ${lineNumber} lines.`);
});

Eslatma: Ushbu yondashuv katta fayllar uchun xotiradan tejamkor, chunki u butun faylni xotiraga yuklashdan ko‘ra bir vaqtning o‘zida bir qatorni qayta ishlaydi.

Jadvalni yakunlash

Jadvalni yakunlash buyruq va fayl yo‘li takliflarini taqdim etish orqali foydalanuvchi tajribasini yaxshilaydi. Readline moduli sizga maxsus yakunlash mantiqini amalga oshirish imkonini beradi:

Varaqlarni yakunlash qanday ishlaydi:

  • Foydalanuvchi Tab tugmasini bosadi
  • Readline joriy string va kursor joylashuvi bilan yakunlovchi funksiyangizni chaqiradi
  • Funksiyangiz yakuniy takliflarni qaytaradi
  • Readline faqat bitta moslik bo‘lsa, yakunlash yoki avtomatik to‘ldirishlarni ko‘rsatadi
const readline = require('readline');
const fs = require('fs');
const path = require('path');

// Available commands for autocompletion
const commands = ['help', 'exit', 'list', 'clear', 'info', 'version', 'history'];

// Create the readline interface with a completer function
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  prompt: 'myapp> ',
  completer: function(line) {
    // Command completion
    if (!line.includes(' ')) {
      const hits = commands.filter(c => c.startsWith(line));

      // Show all completions if none matches
      return [hits.length ? hits : commands, line];
    }

    // File path completion (for commands like "list ")
    if (line.startsWith('list ')) {
      const dir = line.split(' ')[1] || '.';
      try {
        let completions = fs.readdirSync(dir);

        // Add trailing slash to directories
        completions = completions.map(file => {
          const fullPath = path.join(dir, file);
          return fs.statSync(fullPath).isDirectory() ? file + '/' : file;
        });

        const hits = completions.filter(c => c.startsWith(line.split(' ')[1] || ''));
        return [hits.length ? hits : completions, line.split(' ')[1] || ''];
      } catch (err) {
        return [[], line];
      }
    }

    return [[], line];
  }
});

// Set the prompt
rl.prompt();

// Handle commands
rl.on('line', (line) => {
  line = line.trim();

  switch (true) {
    case line === 'help':
      console.log('Available commands:');
      commands.forEach(cmd => console.log(` ${cmd}`));
      break;

    case line === 'exit':
      console.log('Goodbye!');
      rl.close();
      return;

    case line.startsWith('list'):
      const dir = line.split(' ')[1] || '.';
      try {
        const files = fs.readdirSync(dir);
        console.log(`Contents of ${dir}:`);
        files.forEach(file => {
          const stats = fs.statSync(path.join(dir, file));
          console.log(` ${file}${stats.isDirectory() ? '/' : ''}`);
        });
      } catch (err) {
        console.error(`Error listing directory: ${err.message}`);
      }
      break;

    case line === 'clear':
      console.clear();
      break;

    case line === 'info':
      console.log('Node.js CLI Example');
      console.log(`Version: 1.0.0`);
      break;

    case line === 'version':
      console.log(`Node.js version: ${process.version}`);
      break;

    case line === 'history':
      // Note: This requires storing history manually
      console.log('History feature not fully implemented.');
      break;

    case line === '':
      // Do nothing for empty lines
      break;

    default:
      console.log(`Unknown command: ${line}`);
      console.log('Type "help" for available commands');
    }

    rl.prompt();
}).on('close', () => {
    console.log('CLI terminated.');
    process.exit(0);
});

// Handle Ctrl+C
rl.on('SIGINT', () => {
    rl.question('Are you sure you want to exit? (y/n) ', (answer) => {
      if (answer.toLowerCase() === 'y') {
        rl.close();
      } else {
        rl.prompt();
      }
  });
});

Ko‘p qatorli kiritish

Readline moduli ko‘p satrli kiritish bilan ishlashda juda qulay, bu uni matn muharrirlari, kod muharrirlari yoki foydalanuvchilardan bir necha satr matn to‘plashi kerak bo‘lgan har qanday dastur uchun mukammal qiladi. Buni samarali amalga oshirish usuli:

Ko‘p qatorli kiritish strategiyalari:

  • End Marker: Kirish oxiri haqida signal berish uchun maxsus ketma-ketlikdan foydalaning (masalan, .end )
  • Qavslarni moslashtirish: Barcha ochilgan qavslar/qavslar yopilganda avtomatik aniqlash
  • Maxsus buyruq: Ko‘p qatorli kiritishni yuborish uchun maxsus buyruqni taqdim eting
  • Vaqt tugashiga asoslangan: Foydalanuvchi yozishni tugatganini aniqlash uchun taymerdan foydalaning
const readline = require('readline');

// Create interface
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  prompt: '> '
});

console.log('Enter your multi-line input. Type ".end" on a new line to finish:');
rl.prompt();

// Store lines
const lines = [];

// Handle input
rl.on('line', (line) => {
   // Check for end command
   if (line.trim() === '.end') {
     console.log('\nYour complete input:');
     console.log('-'.repeat(30));
     console.log(lines.join('\n'));
     console.log('-'.repeat(30));

     // Process the input (example: count words)
     const text = lines.join(' ');
     const wordCount = text.split(/\s+/).filter(Boolean).length;
     const charCount = text.length;

     console.log(`\nStatistics:`);
     console.log(`Lines: ${lines.length}`);
     console.log(`Words: ${wordCount}`);
     console.log(`Characters: ${charCount}`);

     rl.close();
     return;
  }

  // Add line to collection
  lines.push(line);
  rl.prompt();
});

Oddiy REPL yaratish

Read-Eval-Print Loop (REPL) foydalanuvchi kiritgan ma’lumotni o‘qiydigan, uni hisoblaydigan va natijani chiqaradigan interaktiv dasturlash muhitidir.

Readline moduli maxsus REPLlarni yaratish uchun juda mos keladi. O‘zingizni yaratish bo‘yicha keng qamrovli qo‘llanma:

REPLning asosiy komponentlari:

  • O‘qing: Foydalanuvchi kiritishni string string qabul qiling
  • Baholash: Kiritilgan ma’lumotlarni tahlil qiling va baholang
  • Chop etish: Natijani yoki istalgan natijani ko‘rsatish
  • Loop: Keyingi buyruq uchun kiritish taklifiga qayting
  • Maxsus buyruqlar: .help , .exit kabi buyruqlarni boshqaring
  • Xatolarni qayta ishlash: Sintaksis xatolari va istisnolarni ehtiyotkorlik bilan hal qiling
const readline = require('readline');
const vm = require('vm');

// Create interface
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  prompt: 'js> '
});

// Create context for evaluating code
const context = vm.createContext({
  console,
  Number,
  String,
  Array,
  Object,
  // Add any other global variables you want to make available
  // You can also add your own functions
  add: (a, b) => a + b,
  multiply: (a, b) => a * b
});

console.log('Simple JavaScript REPL (Press Ctrl+C to exit)');
console.log('Type JavaScript code and press Enter to evaluate');

// Show the prompt
rl.prompt();

// Track multi-line input
let buffer = '';

// Handle input
rl.on('line', (line) => {
  // Add the line to our buffer
  buffer += line;

  try {
    // Try to evaluate the code
    const result = vm.runInContext(buffer, context);

    // Display the result
    console.log('\x1b[33m%s\x1b[0m', '=> ' + result);

    // Reset the buffer after successful evaluation
    buffer = '';
  } catch (error) {
    // If it's a syntax error and might be due to incomplete input,
    // continue collecting input
    if (error instanceof SyntaxError &&
      error.message.includes('Unexpected end of input')) {
      // Continue in multi-line mode
      rl.setPrompt('... ');
    } else {
      // It's a real error, show it and reset buffer
      console.error('\x1b[31m%s\x1b[0m', 'Error: ' + error.message);
      buffer = '';
      rl.setPrompt('js> ');
    }
  }

  rl.prompt();
});

// Handle Ctrl+C
rl.on('SIGINT', () => {
  if (buffer.length > 0) {
    // If there's pending input, clear it
    console.log('\nInput cleared');
    buffer = '';
    rl.setPrompt('js> ');
    rl.prompt();
  } else {
    // Otherwise exit
    rl.question('\nAre you sure you want to exit? (y/n) ', (answer) => {
      if (answer.toLowerCase() === 'y') {
        console.log('Goodbye!');
        rl.close();
      } else {
        rl.prompt();
      }
    });
  }
});

rl.on('close', () => {
  console.log('REPL closed');
  process.exit(0);
});

Eng yaxshi amaliyotlar

  1. Har doim interfeysni yoping: Resurslarni tozalashni tugatgandan so‘ng rl.close() metodini chaqiring.
  2. Xatolarni qayta ishlash: Barcha o‘qish operatsiyalari uchun xatolarni qayta ishlashni amalga oshiring.
  3. Promiselardan foydalaning: Callback-ga asoslangan usullarni tozaroq asinxron kod uchun Promiselarga kiriting.
  4. UXni ko‘rib chiqing: Foydalanuvchilarga aniq maslahatlar va fikr-mulohazalarni taqdim eting.
  5. Hodisalarni qayta ishlash vositalaridan foydalaning: Murakkab o‘zaro ta’sirlar uchun o‘qish liniyasining voqealarga asoslangan xususiyatidan foydalaning.
  6. Xotirani boshqarish: Katta fayllar bilan ehtiyot bo‘ling; ularni string bo‘yicha qayta ishlang.
  7. Klaviatura yorliqlarini qo‘shish: Umumiy klaviatura yorliqlari uchun ishlov beruvchilarni qo‘llang (Ctrl+C, Ctrl+D).

Readline va boshqa kiritish usullari

Metod Pros Kamchiliklari Eng yaxshisi
o‘qish liniyasi Satr bo‘yicha ishlov berish, interaktiv kiritish, tarix, yakunlash Murakkab interfeyslar uchun ko‘proq kod CLI, interaktiv takliflar, REPLlar
process.stdin Past darajadagi nazorat, xom ma’lumotlar Foydalanish qiyinroq, qo‘lda buferlash Ikkilik kiritish, maxsus protokollar
Inquirer.js (3rd party) Rich UI, ko‘p kiritish turlari, tekshirish Tashqi qaramlik Murakkab shakllar, so‘rovlar, konfiguratsiya ustalari
Commander.js (3rd party) Buyruq ta’rifi, variantni tahlil qilish Kamroq interaktiv Argumentlar bilan buyruq qatori vositalari

Xulosa

Node.js Readline moduli interaktiv buyruq qatori interfeyslarini yaratish, matn kiritishni qatorma-qator qayta ishlash va foydalanuvchi bilan o‘zaro ta’sirni talab qiluvchi vositalarni yaratishning oddiy, ammo kuchli usulini taqdim etadi.

Bu, ayniqsa, quyidagilar uchun foydalidir:

  • Interaktiv buyruq satrlarini yaratish
  • Foydalanuvchi kiritishi bilan CLI ilovalarini yaratish
  • Fayllarni string bo‘yicha qayta ishlash
  • Maxsus REPL muhitlarini joriy qilish
  • Matnga asoslangan interfeyslar va o‘yinlarni ishlab chiqish

Yuzaki ko‘rinishda oddiy bo‘lsa-da, Readline-ni Promiselar, voqealarni boshqarish va to‘g‘ri UX mulohazalari bilan birlashtirish sizga ajoyib foydalanuvchi tajribasini ta’minlaydigan murakkab buyruq qatori ilovalarini yaratishga imkon beradi.


‹ OrqagaKeyingisi

W3Schools Pathfinder

Yutuqlaringizni kuzating – bu bepul!

Ro'yxatdan o'tishKirish