Node.js의 스트림 이해 — 효율적인 데이터 처리

스트림은 한꺼번에 모든 것을 메모리에 로드하는 대신 대량의 데이터를 하나씩 처리하여 효율적으로 처리할 수 있게 해주는 Node.js의 강력한 기능입니다. 대용량 파일, 실시간 데이터 또는 네트워크 연결을 처리하는 데 특히 유용합니다. 이 기사에서는 Node.js 스트림에 대해 자세히 알아보고 스트림 유형, 코드 예제와 함께 사용하는 방법, 실제 사용 사례를 다루면서 이해를 강화할 것입니다.

스트림이란 무엇입니까?

스트림은 시간이 지남에 따라 처리되는 데이터의 시퀀스입니다. Node.js에서 스트림은 EventEmitter의 인스턴스입니다. 즉, 이벤트를 내보내고 응답할 수 있습니다. 스트림을 사용하면 모든 데이터를 한 번에 로드하는 대신 데이터를 청크(작은 조각)로 읽고 쓸 수 있으므로 메모리가 효율적이고 빠릅니다.

스트림을 사용하는 이유는 무엇입니까?

• 효율적인 메모리 사용: 전체 데이터 세트를 메모리에 로드할 필요 없이 프로세스 데이터를 청크 단위로 스트리밍합니다.
• 빠른 처리: 모든 것이 로드될 때까지 기다리지 않고 데이터가 제공되는 즉시 처리를 시작합니다.
• 비차단 I/O: 스트림은 비동기식으로 작동하므로 다른 작업을 차단하지 않으므로 실시간 애플리케이션에 이상적입니다.

스트림 유형

Node.js는 네 가지 유형의 스트림을 제공합니다.

1. 읽기 가능한 스트림: 데이터를 순차적으로 읽는 데 사용됩니다.
2. 쓰기 가능한 스트림: 데이터를 순차적으로 쓰는 데 사용됩니다.
3. 이중 스트림: 읽기 및 쓰기가 모두 가능합니다.
4. 변환 스트림: 출력이 입력의 변환인 이중 스트림입니다.

예시를 통해 각 스트림 유형을 살펴보겠습니다.

읽을 수 있는 스트림

읽기 가능한 스트림을 사용하면 파일이나 네트워크 요청과 같은 소스에서 데이터를 청크 단위로 사용할 수 있습니다.

예: 읽기 가능한 스트림을 사용하여 파일 읽기

const fs = require('fs');

// Create a readable stream
const readableStream = fs.createReadStream('example.txt', 'utf8');

// Listen for 'data' events to read chunks of data
readableStream.on('data', (chunk) => {
  console.log('New chunk received:');
  console.log(chunk);
});

// Handle 'end' event when the file has been completely read
readableStream.on('end', () => {
  console.log('File reading completed.');
});

// Handle any errors
readableStream.on('error', (err) => {
  console.error('Error reading file:', err.message);
});

설명:

• fs.createReadStream()은 example.txt의 내용을 읽기 위한 스트림을 생성합니다.
• 스트림은 읽는 각 청크에 대해 'data' 이벤트를 내보내고, 읽기가 끝나면 'end' 이벤트를 내보냅니다.

쓰기 가능한 스트림

쓰기 가능한 스트림은 데이터를 파일에 저장하는 등 데이터를 청크 단위로 쓰는 데 사용됩니다.

예: 쓰기 가능한 스트림을 사용하여 파일에 데이터 쓰기

const fs = require('fs');

// Create a writable stream
const writableStream = fs.createWriteStream('output.txt');

// Write chunks of data to the file
writableStream.write('First chunk of data.\n');
writableStream.write('Second chunk of data.\n');

// End the stream
writableStream.end('Final chunk of data.');

// Handle 'finish' event when writing is complete
writableStream.on('finish', () => {
  console.log('Data writing completed.');
});

// Handle any errors
writableStream.on('error', (err) => {
  console.error('Error writing to file:', err.message);
});

설명:

• fs.createWriteStream()은 출력.txt에 쓰기 위한 쓰기 가능한 스트림을 생성합니다.
• write() 메서드는 데이터 청크를 스트림으로 보내는 데 사용됩니다. 모든 데이터가 기록되면 end() 메서드가 호출되어 스트림이 완료되었음을 알립니다.

이중 스트림

이중 스트림은 데이터를 읽고 쓸 수 있으며 데이터를 보내고 받아야 하는 네트워크 프로토콜과 같은 작업에 사용됩니다.

예: 맞춤형 이중 스트림

const { Duplex } = require('stream');

// Create a custom duplex stream
const myDuplexStream = new Duplex({
  read(size) {
    this.push('Reading data...');
    this.push(null);  // No more data to read
  },
  write(chunk, encoding, callback) {
    console.log(`Writing: ${chunk.toString()}`);
    callback();
  }
});

// Read from the stream
myDuplexStream.on('data', (chunk) => {
  console.log(chunk.toString());
});

// Write to the stream
myDuplexStream.write('This is a test.');
myDuplexStream.end();

설명:

• 이중 스트림은 읽기 및 쓰기 작업을 모두 수행할 수 있습니다. 이 예에서는 이중 스트림에 대한 사용자 정의 읽기 및 쓰기 방법을 정의합니다.

스트림 변환

변환 스트림을 사용하면 데이터가 통과할 때 데이터를 수정하거나 변환할 수 있습니다. 특별한 유형의 이중 스트림입니다.

예: 대문자 텍스트로의 간단한 변환 스트림

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

// Create a custom transform stream
const toUpperCaseTransform = new Transform({
  transform(chunk, encoding, callback) {
    this.push(chunk.toString().toUpperCase());
    callback();
  }
});

// Pipe data through the transform stream
process.stdin.pipe(toUpperCaseTransform).pipe(process.stdout);

설명:

• 변환 스트림은 입력을 받아 처리하고(이 경우 텍스트를 대문자로 변환) 수정된 데이터를 출력합니다.
• 이 예에서는 데이터가 표준 입력(process.stdin)에서 변환 스트림을 통해 파이프되고 결과가 콘솔(process.stdout)로 출력됩니다.

배관 스트림

스트림을 사용하는 가장 일반적인 방법 중 하나는 스트림을 함께 "파이프"하는 것입니다. 이는 한 스트림에서 다른 스트림으로 데이터를 전달하는 것을 의미합니다. 파일에서 읽고 다른 파일에 쓰는 등 데이터를 단계별로 처리해야 할 때 유용합니다.

예: 읽기 가능한 스트림을 쓰기 가능한 스트림으로 파이핑

const fs = require('fs');

// Create a readable stream
const readableStream = fs.createReadStream('input.txt');

// Create a writable stream
const writableStream = fs.createWriteStream('output.txt');

// Pipe the readable stream into the writable stream
readableStream.pipe(writableStream);

// Handle 'finish' event when piping is done
writableStream.on('finish', () => {
  console.log('File copied successfully.');
});

설명:

• pipe() 메소드는 읽기 가능한 스트림(input.txt)의 데이터를 쓰기 가능한 스트림(output.txt)으로 직접 전달합니다.

실제 사용 사례: 대용량 파일 업로드 스트리밍

실제 애플리케이션에서는 대용량 파일을 서버에 업로드해야 할 수도 있습니다. 전체 파일을 메모리에 로드하는 대신 스트림을 사용하여 파일 업로드를 효율적으로 처리할 수 있습니다.

예: Node.js 및 multer를 사용하여 스트림을 사용하여 파일 업로드

const express = require('express');
const multer = require('multer');
const fs = require('fs');

const app = express();
const upload = multer({ dest: 'uploads/' });

app.post('/upload', upload.single('file'), (req, res) => {
  const readableStream = fs.createReadStream(req.file.path);
  const writableStream = fs.createWriteStream(`./uploads/${req.file.originalname}`);

  // Pipe the uploaded file to the writable stream
  readableStream.pipe(writableStream);

  writableStream.on('finish', () => {
    res.send('File uploaded and saved.');
  });

  writableStream.on('error', (err) => {
    res.status(500).send('Error saving file.');
  });
});

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

Explanation:

• We use multer to handle file uploads. When the file is uploaded, it is piped from a temporary location to the desired directory on the server.
• This method is efficient as it streams the file data instead of holding it all in memory at once.

Best Practices for Working with Streams

1. Error Handling: Always handle errors in streams to avoid unhandled exceptions, especially when dealing with file systems or network operations.

Example:

   readableStream.on('error', (err) => {
     console.error('Stream error:', err.message);
   });

1. Flow Control: Be mindful of flow control when reading and writing data, as writable streams can become overwhelmed if data is being written faster than it can be consumed.

Example:

   writableStream.write(chunk, (err) => {
     if (err) console.error('Error writing chunk:', err.message);
   });

1. Use Pipe for Simplicity: When transferring data between streams, always prefer using pipe() instead of manually managing the flow of data.

Conclusion

Streams in Node.js offer a powerful and efficient way to handle data, especially in cases where data comes in large quantities or needs to be processed incrementally. From reading and writing files to handling network requests and processing data in real time, streams allow you to build scalable and performant applications. In this article, we explored the different types of streams, how to use them, and real-world use cases to deepen your understanding of stream-based processing in Node.js.

위 내용은 Node.js의 스트림 이해 — 효율적인 데이터 처리의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!