Node.js에서 파일 작성

Node.js를 사용할 때 파일에 쓰는 방법을 찾으려고 노력했지만 성공하지 못했습니다. 어떻게해야합니까?

파일 시스템 API 에는 많은 세부 사항이 있습니다 . 가장 일반적인 방법은 다음과 같습니다.

const fs = require('fs');

fs.writeFile("/tmp/test", "Hey there!", function(err) {
    if(err) {
        return console.log(err);
    }
    console.log("The file was saved!");
}); 

// Or
fs.writeFileSync('/tmp/test-sync', 'Hey there!');

현재 파일을 작성하는 세 가지 방법이 있습니다.

1. fs.write(fd, buffer, offset, length, position, callback)

   버퍼가 디스크에 기록되도록 콜백을 기다려야합니다. 버퍼링되지 않았습니다.

2. fs.writeFile(filename, data, [encoding], callback)

   모든 데이터는 동시에 저장해야합니다. 순차적 쓰기를 수행 할 수 없습니다.

3. fs.createWriteStream(path, [options])

   WriteStream콜백을 기다릴 필요가 없으므로 편리한를 만듭니다 . 그러나 다시 버퍼링되지 않습니다.

WriteStream이름에서 알 수 있듯이 A 는 스트림입니다. 정의상 스트림은 한 방향으로 이동하는 데이터를 포함하는 "버퍼"입니다 (소스 ► 대상). 그러나 쓰기 가능한 스트림이 반드시 "버퍼링"되는 것은 아닙니다. 스트림은 n시간 을 쓸 때“버퍼링” 되며 time n+1에 버퍼가 가득 차서 플러시되어야하기 때문에 스트림이 버퍼를 커널에 보냅니다.

다시 말해, “버퍼”는 객체입니다. 그것이 "버퍼링되었는지"여부는 그 객체의 속성이다.

코드를 보면 WriteStream쓰기 가능한 Stream개체 에서 상속됩니다 . 주의를 기울이면 내용을 플러시하는 방법을 알 수 있습니다. 버퍼링 시스템이 없습니다.

문자열을 쓰면 버퍼로 변환 된 다음 기본 레이어로 전송되어 디스크에 기록됩니다. 문자열을 작성할 때 버퍼를 채우지 않습니다. 따라서 그렇게 할 경우 :

write("a")
write("b")
write("c")

당신은하고 있습니다 :

fs.write(new Buffer("a"))
fs.write(new Buffer("b"))
fs.write(new Buffer("c"))

그것은 I / O 레이어에 대한 세 번의 호출입니다. "버퍼"를 사용하고 있지만 데이터는 버퍼링되지 않습니다. 버퍼링 된 스트림은 fs.write(new Buffer ("abc"))I / O 계층에 대한 한 번의 호출을 수행합니다.

현재로서는, Node.js를 v0.12에서 (안정 버전이 2015년 2월 6일을 발표했다) 이제 두 가지 기능을 지원 cork()하고 uncork(). 이러한 함수는 최종적으로 쓰기 호출을 버퍼링 / 플러시 할 수있는 것으로 보입니다.

예를 들어 Java에는 버퍼 스트림 ( BufferedOutputStream, BufferedWriter...) 을 제공하는 클래스가 있습니다 . 3 바이트를 쓰면이 바이트는 3 바이트에 대해서만 I / O 호출을 수행하는 대신 버퍼 (메모리)에 저장됩니다. 버퍼가 가득 차면 내용이 플러시되고 디스크에 저장됩니다. 이것은 성능을 향상시킵니다.

디스크 검색을 수행하는 방법을 기억하면서 아무것도 발견하지 못했습니다.

물론 좀 더 발전시킬 수 있습니다. 전체 파일을 한 번에 쓰지 않고 비 차단, 비트 및 조각 쓰기 :

var fs = require('fs');
var stream = fs.createWriteStream("my_file.txt");
stream.once('open', function(fd) {
  stream.write("My first row\n");
  stream.write("My second row\n");
  stream.end();
});

동기 쓰기

fs.writeFileSync (파일, 데이터 [, 옵션])

fs = require('fs');

fs.writeFileSync("synchronous.txt", "synchronous write!")

비동기 쓰기

fs.writeFile (파일, 데이터 [, 옵션], 콜백)

fs = require('fs');

fs.writeFile('asynchronous.txt', 'asynchronous write!', (err) => {
  if (err) throw err;
  console.log('The file has been saved!');
});

어디

file <string> | <Buffer> | <URL> | <integer> filename or file descriptor
data <string> | <Buffer> | <Uint8Array>
options <Object> | <string>
callback <Function>

공식 파일 시스템 (fs) docs를 읽을 가치가 있습니다.

var path = 'public/uploads/file.txt',
buffer = new Buffer("some content\n");

fs.open(path, 'w', function(err, fd) {
    if (err) {
        throw 'error opening file: ' + err;
    }

    fs.write(fd, buffer, 0, buffer.length, null, function(err) {
        if (err) throw 'error writing file: ' + err;
        fs.close(fd, function() {
            console.log('file written');
        })
    });
});

나는 ./articles/file-system의 색인을 좋아 했다 .

그것은 나를 위해 일했다.

node.js에서 파일을 작성하는 방법을 참조하십시오 . .

fs = require('fs');
fs.writeFile('helloworld.txt', 'Hello World!', function (err) {
    if (err) 
        return console.log(err);
    console.log('Wrote Hello World in file helloworld.txt, just check it');
});

helloworld.txt의 내용 :

Hello World!

업데이트 :
: 현재 디렉토리에서와 마찬가지로 리눅스에서 노드 쓰기, 내가 단지의 경우이 댓글을 추가 할 수 있도록하지 않는 일부 다른 사람 같다
이를 사용하여 ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH);파일이 작성되는 경우 얻을.

제공된 답변은 날짜가 있으며 최신 방법은 다음과 같습니다.

const fsPromises = require('fs').promises
await fsPromises.writeFile('/path/to/file.txt', 'data to write')

자세한 내용은 여기 문서를 참조하십시오

나는 "쓰기"에 대한 질문을 알고 있지만 더 일반적인 의미에서 "추가"는 루프에서 파일에 텍스트를 추가하기 위해 파일을 쉽게 사용할 수 있기 때문에 유용합니다 (파일이 있는지 여부에 관계없이). 다음과 같이 줄을 추가하려면 "\ n"을 사용하십시오.

var fs = require('fs');
for (var i=0; i<10; i++){
    fs.appendFileSync("junk.csv", "Line:"+i+"\n");
}

노드가이를위한 내장 기능을 가지고 있기 때문에 매우 간단 fs합니다. 파일 시스템 을 의미 하며 기본적으로 NodeJS 파일 시스템 모듈입니다. ...

따라서 먼저 다음과 같이 server.js 파일 에 필요합니다 .

var fs = require('fs');

fs파일에 쓰는 방법이 거의 없지만 선호하는 방법은을 사용하는 것입니다 appendFile. 이것은 파일에 물건을 추가하고 파일이 존재하지 않으면 하나를 만들 것입니다.

fs.appendFile('myFile.txt', 'Hi Ali!', function (err) {
  if (err) throw err;
  console.log('Thanks, It\'s saved to the file!');
});

 var fs = require('fs');
 fs.writeFile(path + "\\message.txt", "Hello", function(err){
 if (err) throw err;
  console.log("success");
}); 

예를 들어 : 파일을 읽고 다른 파일에 씁니다.

  var fs = require('fs');
    var path = process.cwd();
    fs.readFile(path+"\\from.txt",function(err,data)
                {
                    if(err)
                        console.log(err)
                    else
                        {
                            fs.writeFile(path+"\\to.text",function(erro){
                                if(erro)
                                    console.log("error : "+erro);
                                else
                                    console.log("success");
                            });
                        }
                });

fs (파일 시스템) 모듈을 사용하여 파일에 쓸 수 있습니다 .

다음은 수행 방법에 대한 예입니다.

const fs = require('fs');

const writeToFile = (fileName, callback) => {
  fs.open(fileName, 'wx', (error, fileDescriptor) => {
    if (!error && fileDescriptor) {
      // Do something with the file here ...
      fs.writeFile(fileDescriptor, newData, (error) => {
        if (!error) {
          fs.close(fileDescriptor, (error) => {
            if (!error) {
              callback(false);
            } else {
              callback('Error closing the file');
            }
          });
        } else {
          callback('Error writing to new file');
        }
      });
    } else {
      callback('Could not create new file, it may already exists');
    }
  });
};

약속 및 async/ await문 을 사용하여이 콜백 내부 콜백 코드 구조를 제거 할 수도 있습니다 . 이것은 비동기 코드 구조를 훨씬 더 평평하게 만듭니다. 이를 위해 편리한 util.promisify (original) 함수가 활용 될 수 있습니다. 콜백에서 약속으로 전환 할 수 있습니다. fs아래 함수가 있는 예제를 살펴보십시오 .

// Dependencies.
const util = require('util');
const fs = require('fs');

// Promisify "error-back" functions.
const fsOpen = util.promisify(fs.open);
const fsWrite = util.promisify(fs.writeFile);
const fsClose = util.promisify(fs.close);

// Now we may create 'async' function with 'await's.
async function doSomethingWithFile(fileName) {
  const fileDescriptor = await fsOpen(fileName, 'wx');

  // Do something with the file here...

  await fsWrite(fileDescriptor, newData);
  await fsClose(fileDescriptor);
}

여기서 우리는 두 동작을 읽고 쓰는 데 w +를 사용하며 파일 경로를 찾지 못하면 자동으로 생성됩니다.

fs.open(path, 'w+', function(err, data) {
    if (err) {
        console.log("ERROR !! " + err);
    } else {
        fs.write(data, 'content', 0, 'content length', null, function(err) {
            if (err)
                console.log("ERROR !! " + err);
            fs.close(data, function() {
                console.log('written success');
            })
        });
    }
});

내용은 파일에 기록해야 할 내용과 길이 'content.length'를 의미합니다.

다음은 로컬에서 csv 파일을 읽고 csv 파일을 로컬에 쓰는 방법의 샘플입니다.

var csvjson = require('csvjson'),
    fs = require('fs'),
    mongodb = require('mongodb'),
    MongoClient = mongodb.MongoClient,
    mongoDSN = 'mongodb://localhost:27017/test',
    collection;

function uploadcsvModule(){
    var data = fs.readFileSync( '/home/limitless/Downloads/orders_sample.csv', { encoding : 'utf8'});
    var importOptions = {
        delimiter : ',', // optional 
        quote     : '"' // optional 
    },ExportOptions = {
        delimiter   : ",",
        wrap        : false
    }
    var myobj = csvjson.toSchemaObject(data, importOptions)
    var exportArr = [], importArr = [];
    myobj.forEach(d=>{
        if(d.orderId==undefined || d.orderId=='') {
            exportArr.push(d)
        } else {
            importArr.push(d)
        }
    })
    var csv = csvjson.toCSV(exportArr, ExportOptions);
    MongoClient.connect(mongoDSN, function(error, db) {
        collection = db.collection("orders")
        collection.insertMany(importArr, function(err,result){
            fs.writeFile('/home/limitless/Downloads/orders_sample1.csv', csv, { encoding : 'utf8'});
            db.close();
        });            
    })
}

uploadcsvModule()

fs.createWriteStream(path[,options])

optionsstart파일의 시작 부분을지나 특정 위치에 데이터를 쓸 수 있는 옵션 도 포함 할 수 있습니다 . 파일을 바꾸지 않고 수정 하려면 기본 모드 flags가 r+아닌 모드 가 필요할 수 있습니다 w. 인코딩은 Buffer에서 허용되는 인코딩 중 하나 일 수 있습니다 .

경우 autoClose에 참 (기본 동작)로 설정 'error'또는 'finish'파일 기술자가 자동으로 종료됩니다. 만약autoClose 거짓, 파일 기술자는 오류가있는 경우에도 폐쇄되지 않습니다. 응용 프로그램은 응용 프로그램을 닫고 파일 디스크립터 누출이 없는지 확인해야합니다.

ReadStream 과 마찬가지로 , fd지정된 경우 WriteStream 은 path인수 를 무시 하고 지정된 파일 설명자를 사용합니다. 이는 'open'이벤트가 발생 하지 않음을 의미합니다 . fd차단해야합니다. non-blocking fd은 net.Socket 으로 전달되어야합니다 .

경우 options문자열이며, 다음은 인코딩을 지정합니다.

이 긴 기사를 읽은 후. 작동 방식을 이해해야합니다. 여기에 예가 createWriteStream()있습니다.

/* The fs.createWriteStream() returns an (WritableStream {aka} internal.Writeable) and we want the encoding as 'utf'-8 */
/* The WriteableStream has the method write() */
fs.createWriteStream('out.txt', 'utf-8')
.write('hello world');

도서관 이용 가능 easy-file-manager

npm에서 먼저 설치 npm install easy-file-manager

파일을 업로드하고 제거하는 샘플

var filemanager = require('easy-file-manager')
var path = "/public"
var filename = "test.jpg"
var data; // buffered image

filemanager.upload(path,filename,data,function(err){
    if (err) console.log(err);
});

filemanager.remove(path,"aa,filename,function(isSuccess){
    if (err) console.log(err);
});

다음 코드 예제로 파일을 작성할 수 있습니다.

var data = [{ 'test': '123', 'test2': 'Lorem Ipsem ' }];
fs.open(datapath + '/data/topplayers.json', 'wx', function (error, fileDescriptor) {
  if (!error && fileDescriptor) {
    var stringData = JSON.stringify(data);
    fs.writeFile(fileDescriptor, stringData, function (error) {
      if (!error) {
        fs.close(fileDescriptor, function (error) {
          if (!error) {
            callback(false);
          } else {
            callback('Error in close file');
          }
        });
      } else {
        callback('Error in writing file.');
      }
    });
  }
});