Buffer moduli

Buffer moduli nima?

Node.js-dagi Buffer moduli ikkilik ma’lumotlarni qayta ishlash uchun ishlatiladi.

Bufferlar butun sonlar massivlariga o‘xshaydi, lekin belgilangan uzunliklarga ega va V8 JavaScript dvigatelidan tashqaridagi xom xotira taqsimotlariga mos keladi.

Node.js Buffer sinfini global obyekt sifatida taqdim etadi, shuning uchun uni aniq talab qilish yoki import qilish shart emas.

Eslatma: Node.js v6.0.0 dan beri Buffer konstruktori yangi Buffer usullari foydasiga eskirgan.

Konstruktordan foydalanish ishga tushirilmagan xotira tufayli xavfsizlik zaifliklariga olib kelishi mumkin.

Buferlardan foydalanishni boshlash

Node.js-dagi bufferlar ikkilik ma’lumotlarni to‘g‘ridan-to‘g‘ri ishlash uchun ishlatiladi.

Ular butun sonlar massivlariga o‘xshaydi, lekin o‘lchamlari o‘zgarmas va V8 to‘plamidan tashqarida xom xotira taqsimotlarini ifodalaydi.

Asosiy buffer misoli

// Create a buffer from a string
const buf = Buffer.from('Hello, Node.js!');

// Buffers can be converted to strings
console.log(buf.toString()); // 'Hello, Node.js!'

// Access individual bytes
console.log(buf[0]); // 72 (ASCII for 'H')

// Buffers have a fixed length
console.log(buf.length); // 15

O‘zingiz sinab ko‘ring »

Buferlarni yaratish

Node.js da buferlarni yaratishning bir necha usullari mavjud, ularning har biri turli xil ishlash va xavfsizlik xususiyatlariga ega:

Node.js da buferlarni yaratishning bir necha yo‘li mavjud:

1. Buffer.alloc()

Nol bilan ishga tushirilgan belgilangan o‘lchamdagi yangi Buferni yaratadi.

Bu yangi buffer yaratishning eng xavfsiz usuli, chunki u eski ma’lumotlar yo‘qligini ta’minlaydi.

// Create a buffer of 10 bytes filled with zeros
const buffer1 = Buffer.alloc(10);
console.log(buffer1);

Misolni ishga tushirish »

2. Buffer.allocUnsafe()

Belgilangan o‘lchamdagi yangi buffer yaratadi, lekin xotirani ishga tushirmaydi.

Bu Buffer.alloc() dan tezroq, lekin eski yoki maxfiy ma’lumotlarni o‘z ichiga olishi mumkin.

Xavfsizlik muammosi bo‘lsa, ishlatishdan oldin har doim buferni to‘ldiring.

// Create an uninitialized buffer of 10 bytes
const buffer2 = Buffer.allocUnsafe(10);
console.log(buffer2);

// Fill the buffer with zeros for security
buffer2.fill(0);
console.log(buffer2);

Misolni ishga tushirish »

Ogohlantirish: Buffer.allocUnsafe() Buffer.alloc() dan tezroq, lekin maxfiy ma’lumotlarni oshkor qilishi mumkin.

Uni faqat xavfsizlik oqibatlarini tushunganingizda va darhol butun buferni to‘ldirishni rejalashtirganingizda foydalaning.

3. Buffer.from()

Stringlar, massivlar yoki ArrayBuffer kabi turli manbalardan yangi Buffer yaratadi. Bu mavjud ma’lumotlardan bufferlar yaratishning eng moslashuvchan usuli.

// Create a buffer from a string
const buffer3 = Buffer.from('Hello, World!');
console.log(buffer3);

console.log(buffer3.toString());

// Create a buffer from an array of integers
const buffer4 = Buffer.from([65, 66, 67, 68, 69]);
console.log(buffer4);

console.log(buffer4.toString());

// Create a buffer from another buffer
const buffer5 = Buffer.from(buffer4);
console.log(buffer5);

Misolni ishga tushirish »

Buferlardan foydalanish

Buferlarga yozish

Turli usullar yordamida buferga ma’lumotlarni yozishingiz mumkin:

// Create an empty buffer
const buffer = Buffer.alloc(10);

// Write a string to the buffer
buffer.write('Hello');
console.log(buffer);

console.log(buffer.toString());

// Write bytes at specific positions
buffer[5] = 44; // ASCII for ','
buffer[6] = 32; // ASCII for space
buffer.write('Node', 7);
console.log(buffer.toString());

Misolni ishga tushirish »

Buferlardan o‘qish

Turli usullar yordamida buferdan ma’lumotlarni o‘qishingiz mumkin:

// Create a buffer from a string
const buffer = Buffer.from('Hello, Node.js!');

// Read the entire buffer as a string
console.log(buffer.toString());

// Read a portion of the buffer (start at position 7, end before position 11)
console.log(buffer.toString('utf8', 7, 11));

// Read a single byte
console.log(buffer[0]);

// Convert the ASCII code to a character
console.log(String.fromCharCode(buffer[0]));

Misolni ishga tushirish »

Bufferlar orqali takrorlash

Buferlarni massivlar kabi takrorlash mumkin:

// Create a buffer from a string
const buffer = Buffer.from('Hello');

// Iterate using for...of loop
for (const byte of buffer) {
console.log(byte);
}

// Iterate using forEach
buffer.forEach((byte, index) => {
console.log(`Byte at position ${index}: ${byte}`);
});

Misolni ishga tushirish »

Buffer usullari

Buffer.compare()

Ikki buferni taqqoslaydi va birinchisi ikkinchisidan oldin, keyin yoki tartiblash tartibida bir xil ekanligini ko‘rsatadigan raqamni qaytaradi:

const buffer1 = Buffer.from('ABC');
const buffer2 = Buffer.from('BCD');
const buffer3 = Buffer.from('ABC');

console.log(Buffer.compare(buffer1, buffer2));
console.log(Buffer.compare(buffer2, buffer1));
console.log(Buffer.compare(buffer1, buffer3));

Misolni ishga tushirish »

buffer.copy()

Ma’lumotlarni bir buferdan boshqasiga ko‘chiradi:

// Create source and target buffers
const source = Buffer.from('Hello, World!');
const target = Buffer.alloc(source.length);

// Copy from source to target
source.copy(target);

console.log(target.toString());

// Create a target buffer for partial copy
const partialTarget = Buffer.alloc(5);

// Copy only part of the source (starting at index 7)
source.copy(partialTarget, 0, 7);

console.log(partialTarget.toString());

Misolni ishga tushirish »

buffer.slice()

Asl xotira bilan bir xil xotiraga havola qiladigan, lekin ofset va berilgan oxirigacha kesilgan yangi buffer yaratadi:

const buffer = Buffer.from('Hello, World!');

// Create a slice from position 7 to the end
const slice = buffer.slice(7);
console.log(slice.toString());

// Create a slice from position 0 to 5
const slice2 = buffer.slice(0, 5);
console.log(slice2.toString());

// Important: slices share memory with original buffer
slice[0] = 119; // ASCII for 'w' (lowercase)
console.log(slice.toString());
console.log(buffer.toString());

Misolni ishga tushirish »

Eslatma: buffer.slice() bir xil xotira ko‘rinishini yaratganligi sababli, asl buffer yoki bo‘lakni o‘zgartirish boshqasiga ta’sir qiladi.

buffer.toString()

Buferni belgilangan kodlash yordamida stringga dekodlaydi:

const buffer = Buffer.from('Hello, World!');

// Default encoding is UTF-8
console.log(buffer.toString());

// Specify encoding
console.log(buffer.toString('utf8'));

// Decode only a portion of the buffer
console.log(buffer.toString('utf8', 0, 5));

// Using different encodings
const hexBuffer = Buffer.from('48656c6c6f', 'hex');
console.log(hexBuffer.toString());

const base64Buffer = Buffer.from('SGVsbG8=', 'base64');
console.log(base64Buffer.toString());

Misolni ishga tushirish »

buffer.equals()

Kontent tengligi uchun ikkita buferni solishtiradi:

const buffer1 = Buffer.from('Hello');
const buffer2 = Buffer.from('Hello');
const buffer3 = Buffer.from('World');

console.log(buffer1.equals(buffer2));

console.log(buffer1.equals(buffer3));

console.log(buffer1 === buffer2);

Misolni ishga tushirish »

Kodlashlar bilan ishlash

Stringlar va ikkilik ma’lumotlar o‘rtasida konvertatsiya qilishda bufferlar turli kodlashlar bilan ishlaydi:

// Create a string
const str = 'Hello, World!';

// Convert to different encodings
const utf8Buffer = Buffer.from(str, 'utf8');
console.log('UTF-8:', utf8Buffer);

const base64Str = utf8Buffer.toString('base64');
console.log('Base64 string:', base64Str);

const hexStr = utf8Buffer.toString('hex');
console.log('Hex string:', hexStr);

// Convert back to original
const fromBase64 = Buffer.from(base64Str, 'base64').toString('utf8');
console.log('From Base64:', fromBase64);

const fromHex = Buffer.from(hexStr, 'hex').toString('utf8');
console.log('From Hex:', fromHex);

Misolni ishga tushirish »

Node.js da qo‘llab-quvvatlanadigan kodlashlar quyidagilarni o‘z ichiga oladi:

utf8: Ko‘p baytli kodlangan Unicode belgilar (standart)
ascii: faqat ASCII belgilar (7-bit)
latin1: Lotin-1 kodlash (ISO 8859-1)
base64: Base64 kodlash
hex: o‘n oltilik kodlash
ikkilik: ikkilik kodlash (eskirgan)
ucs2/utf16le: 2 yoki 4 bayt, kichik endian kodlangan Unicode belgilar

Kengaytirilgan buffer operatsiyalari

Buferlarni birlashtirish

Buffer.concat() yordamida bir nechta buferlarni bittaga birlashtirishingiz mumkin:

Misol

const buf1 = Buffer.from('Hello, ');
const buf2 = Buffer.from('Node.js!');

// Concatenate buffers
const combined = Buffer.concat([buf1, buf2]);
console.log(combined.toString()); // 'Hello, Node.js!'

// With a maximum length parameter
const partial = Buffer.concat([buf1, buf2], 5);
console.log(partial.toString()); // 'Hello'

Misolni ishga tushirish »

Buferlarda qidirish

Bufferlar qiymatlar yoki ketma-ketlikni qidirish usullarini taqdim etadi:

Misol

const buf = Buffer.from('Hello, Node.js is awesome!');

// Find the first occurrence of a value
console.log(buf.indexOf('Node')); // 7

// Check if buffer contains a value
console.log(buf.includes('awesome')); // true

// Find the last occurrence of a value
console.log(buf.lastIndexOf('e')); // 24

Misolni ishga tushirish »

Buffer va streamlar

Bufferlar odatda samarali ma’lumotlarni qayta ishlash uchun streamlar bilan qo‘llaniladi:

Misol

const fs = require('fs');
const { Transform } = require('stream');

// Create a transform stream that processes data in chunks
const transformStream = new Transform({
transform(chunk, encoding, callback) {
   // Process each chunk (which is a Buffer)
   const processed = chunk.toString().toUpperCase();
   this.push(Buffer.from(processed));
   callback();
}
});
// Create a read stream from a file
const readStream = fs.createReadStream('input.txt');
// Create a write stream to a file
const writeStream = fs.createWriteStream('output.txt');
// Process the file in chunks
readStream.pipe(transformStream).pipe(writeStream);

Buffer va fayl tizimi (fs)

Bufferlar odatda fayl tizimi (fs) operatsiyalari uchun ishlatiladi:

const fs = require('fs');

// Write buffer to file
const writeBuffer = Buffer.from('Hello, Node.js!');
fs.writeFile('buffer.txt', writeBuffer, (err) => {
  if (err) throw err;
  console.log('File written successfully');

  // Read file into buffer
  fs.readFile('buffer.txt', (err, data) => {
    if (err) throw err;

    // 'data' is a buffer
    console.log('Read buffer:', data);
    console.log('Buffer content:', data.toString());

    // Read only part of the file into a buffer
    const smallBuffer = Buffer.alloc(5);
    fs.open('buffer.txt', 'r', (err, fd) => {
      if (err) throw err;

      // Read 5 bytes starting at position 7
      fs.read(fd, smallBuffer, 0, 5, 7, (err, bytesRead, buffer) => {
        if (err) throw err;

        console.log('Partial read:', buffer.toString());
        // Output: Node.

        fs.close(fd, (err) => {
          if (err) throw err;
        });
      });
    });
  });
});

Misolni ishga tushirish »

Buferning ishlashini hisobga olish

Xotiradan foydalanish: Bufferlar xotirani JavaScript to‘plamidan tashqarida iste’mol qiladi, bu ham afzallik (kamroq axlat yig‘ish bosimi) va kamchilik (ehtiyotkorlik bilan boshqarilishi kerak) bo‘lishi mumkin.
Ajratish: Buffer.allocUnsafe() Buffer.alloc() dan tezroq, lekin xavfsizlik masalalari bilan birga keladi
String konvertatsiyasi: Katta buferlarni stringlarga yoki aksincha aylantirish ko‘p resurs talab qilishi mumkin.
Pooling: Tez-tez kichik buferlarni yaratadigan ilovalar uchun ajratilgan qo‘shimcha xarajatlarni kamaytirish uchun buffer pulini qo‘llashni ko‘rib chiqing.

// Simple buffer pool implementation
class BufferPool {
  constructor(bufferSize = 1024, poolSize = 10) {
    this.bufferSize = bufferSize;
    this.pool = Array(poolSize).fill().map(() => Buffer.alloc(bufferSize));

    this.used = Array(poolSize).fill(false);
  }

  // Get a buffer from the pool
  get() {
    const index = this.used.indexOf(false);
    if (index === -1) {
       // Pool is full, create a new buffer
       console.log('Pool full, allocating new buffer');
       return Buffer.alloc(this.bufferSize);
    }
    this.used[index] = true;
    return this.pool[index];
  }

  // Return a buffer to the pool
  release(buffer) {
    const index = this.pool.indexOf(buffer);
    if (index !== -1) {
       // Zero the buffer for security
       buffer.fill(0);
       this.used[index] = false;
    }
  }
}

// Usage example
const pool = new BufferPool(10, 3); // 3 buffers of 10 bytes each

const buf1 = pool.get();
const buf2 = pool.get();
const buf3 = pool.get();
const buf4 = pool.get(); // This will allocate a new buffer

buf1.write('Hello');
console.log(buf1.toString()); // Hello

// Return buf1 to the pool
pool.release(buf1);

// Get another buffer (should reuse buf1)
const buf5 = pool.get();
console.log(buf5.toString()); // Should be empty (zeros)

Misolni ishga tushirish »

Buffer xavfsizligini hisobga olish

Xavfsizlik bo‘yicha ogohlantirish: Bufferlar xotiradan maxfiy ma’lumotlarni o‘z ichiga olishi mumkin.

Bufferlar bilan ishlashda doimo ehtiyot bo‘ling, ayniqsa ular foydalanuvchilarga ta’sir qilishi yoki tizimga kirishi mumkin.

Eng yaxshi amaliyotlar:

Agar unumdorlik muhim bo‘lmasa va siz darhol buferni to‘ldirmasangiz, Buffer.allocUnsafe() dan foydalanmang
Foydalanishdan keyin nol to‘ldirish buferlari, agar ularda maxfiy ma’lumotlar bo‘lsa
Buffer nusxalari yoki bo‘laklarini almashishda ehtiyot bo‘ling, chunki o‘zgarishlar barcha havolalarda aks etadi
Tashqi manbalardan ikkilik ma’lumotlarni qabul qilishda buffer kirishlarini tasdiqlang

// Example: Safely handling sensitive data
function processPassword(password) {
  // Create a buffer to hold the password
  const passwordBuffer = Buffer.from(password);

  // Process the password (e.g., hashing)
  const hashedPassword = hashPassword(passwordBuffer);

  // Zero out the original password buffer for security
  passwordBuffer.fill(0);

  return hashedPassword;
}

// Simple hashing function for demonstration
function hashPassword(buffer) {
  // In a real application, you would use a cryptographic hash function
  // This is a simplified example
  let hash = 0;
  for (let i = 0; i < buffer.length; i++) {
    hash = ((hash < 5) - hash) + buffer[i];
    hash |= 0; // Convert to 32-bit integer
  }
  return hash.toString(16);
}

// Usage
const password = 'secret123';
const hashedPassword = processPassword(password);
console.log('Hashed password:', hashedPassword);

Misolni ishga tushirish »

Xulosa

Node.js Buffer klassi ikkilik ma’lumotlar bilan ishlash uchun muhim vositadir. Eslash kerak bo‘lgan asosiy fikrlar:

Bufferlar JavaScript-da ikkilik ma’lumotlarni qayta ishlash usulini ta’minlaydi
Buferlarni yaratish uchun Buffer.alloc() , Buffer.from() va Buffer.allocUnsafe() dan foydalaning
Buferlarni write() , toString() , slice() va copy() kabi usullar bilan boshqarish mumkin
Bufferlar UTF-8, Base64 va Hex kabi turli xil kodlashni qo‘llab-quvvatlaydi
Bufferlar odatda fayl kiritish-chiqarish, tarmoq operatsiyalari va ikkilik ma’lumotlarni qayta ishlashda qo‘llaniladi
Bufferlar bilan ishlashda samaradorlik va xavfsizlik oqibatlarini ko‘rib chiqing

W3Schools Pathfinder

Yutuqlaringizni kuzating – bu bepul!

Ro'yxatdan o'tish Kirish