Node.js 파일에 쓰는 중

Node.js 파일에 쓰는 중

Node.js를 사용할 때 파일에 쓰는 방법을 찾고 있지만 성공하지 못했습니다.내가 어떻게 그럴 수 있을까?

File System 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])

   를 만듭니다.콜백을 기다릴 필요가 없기 때문에 편리합니다.하지만 역시 버퍼링이 되지 않습니다.

A는 이름 그대로 스트림입니다.스트림은 정의상 한 방향으로 이동하는 데이터를 포함하는 "버퍼"입니다(소스 dest 대상).그러나 쓰기 가능한 스트림이 반드시 "버퍼링"되는 것은 아닙니다.스트림을 쓸 때 "버퍼링"됩니다.n, 시간, 시간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 계층에 대한 호출은 3번입니다."버퍼"를 사용하지만 데이터는 버퍼링되지 않습니다.버퍼링된 스트림은 다음과 같습니다.fs.write(new Buffer ("abc")) 콜, I/O 레이어 1 콜

현재 Node.js v0.12(2015년 02월 06일 발표된 안정 버전)에서는 및 두 가지 기능이 지원됩니다.이러한 함수는 최종적으로 기입 콜을 버퍼링/플래시 할 수 있게 됩니다.

들어 스트림을 (Java)가 .BufferedOutputStream,BufferedWriter 차면 됩니다.버퍼가 가득 차면 내용이 플러시되고 디스크에 저장됩니다.이로 인해 퍼포먼스가 향상됩니다.

디스크 액세스 방법을 기억하고 있을 뿐, 아무것도 검출되지 않았습니다.

물론 조금 더 고급으로 만들 수 있습니다.비블로킹, 비트 및 조각 쓰기, 전체 파일 쓰기:

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("foo.txt", "bar");

비동기 쓰기

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

fs = require('fs');

fs.writeFile('foo.txt', 'bar', (err) => { if (err) throw err; });

어디에

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

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

업데이트: 비동기/대기

fs = require('fs');
util = require('util');
writeFile = util.promisify(fs.writeFile);

fn = async () => { await writeFile('foo.txt', 'bar'); }

fn()

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');
        })
    });
});

제공된 답변은 날짜가 있으며, 이를 위한 새로운 방법은 다음과 같습니다.

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

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

./articles/파일 시스템의 인덱스가 마음에 들었습니다.

그것은 나에게 효과가 있었다.

자세한 내용은 "How do I write files in 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');
});

헬로월드의 내용입니다.txt:

Hello World!

directory와 에서는 그렇지 것 같기 에 Linux의 write in current directory가 아닌 경우를이합니다.
「」를 해 주세요.ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH);이치노

"write"에 대한 질문은 알고 있지만, 일반적으로 "append"는 파일에 텍스트를 추가하는 루프에서 사용하기 쉽기 때문에 도움이 될 수 있습니다(파일의 유무).행을 추가하려면 "\n"을 사용합니다.

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

에는 이되어 있기 에 아주 이 기능을 ,, 노, 노, 노, 노, 노, 노, 노, 노, ok, ok, ok, ok, ok, ok, ok, ok, ok, ok, ok, ok, ok, ok, ok, ok, ok, ok, ok, ok, ok, ok, ok,fsFile System(파일 시스템)의 약자로 NodeJS File System(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!');
});

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');
    }
  });
};

Promise 및 Promise를 사용하여 이 Callback-Inside-Callback 코드 구조를 삭제할 수도 있습니다.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);
}

 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");
                            });
                        }
                });

여기에서는 읽기/쓰기 작업 모두에 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는 파일에 쓸 내용과 파일의 길이인 content.length를 의미합니다.

스트림으로 파일에 쓸 수 있습니다.

이렇게 하면 됩니다.

const fs = require('fs');

const stream = fs.createWriteStream('./test.txt');
stream.write("Example text");

다음은 로컬에서 파일 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])

options를 포함할 수도 있습니다.start파일 시작 부분 이후의 위치에 데이터를 쓸 수 있는 옵션입니다.파일을 치환하지 않고 수정하려면flags의 모드r+디폴트 모드가 아닌w. 부호화는 버퍼에 의해 받아들여지는 부호화 중 하나입니다.

ifautoClose는 true 동작)로 .'error' ★★★★★★★★★★★★★★★★★」'finish'파일 설명자가 자동으로 닫힙니다. ifautoClose가 발생해도 .false는닫히지 않습니다.애플리케이션을 닫고 파일 기술자 누출이 없는지 확인하는 것은 응용 프로그램의 책임입니다.

ReadStream과 마찬가지로fd지정된 경우 WriteStream은 다음 명령을 무시합니다.path지정된 파일 기술자를 사용합니다.은 '안 된다'는 뜻이 .'open'이벤트가 발생합니다. fd할 가 있다;fd는 net에 전달해야 합니다.소켓

ifoptions는 문자열이며 부호화를 지정합니다.

그 후에 이 긴 기사를 읽습니다.당신은 그것이 어떻게 작동하는지 이해해야 합니다. 그럼 예를 .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');

포인트 1:

파일에 쓸 경우.는 파일에 이미 저장된 내용을 삭제하고 새 내용을 씁니다.fs.module을 사용합니다.write File()

포인트 2:

파일에 추가하려는 경우.는 파일에 이미 저장된 항목을 삭제하지 않고 파일 내용에 새 항목을 추가합니다.그런 다음 먼저 파일을 읽고 내용을 읽을 수 있는 값에 추가한 다음 파일에 씁니다. 따라서 fs.promes.readFile 및 fs.promes를 사용합니다.write File()

---

예 1: JSON 파일에 JSON 개체를 씁니다.

const fs = require('fs');
const data = {table:[{id: 1, name: 'my name'}]}
const file_path = './my_data.json'
writeFile(file_path, data)
async function writeFile(filename, writedata) {
  try {
    await fs.promises.writeFile(filename, JSON.stringify(writedata, null, 4), 'utf8');
    console.log('data is written successfully in the file')
  }
  catch (err) {
    console.log('not able to write data in the file ')
  }
}

---

예2 : 데이터를 JSON 파일에 추가하는 경우.데이터 {id:1, name:'my name'}을(를) 동일한 폴더 루트의 my_data.json 파일에 추가하려고 합니다.append_data(file_path, data) 함수를 호출하기만 하면 됩니다.

파일이 존재하는 경우 JSON 파일에 데이터를 추가하거나 파일을 생성하여 해당 파일에 데이터를 추가합니다.

const fs = require('fs');
const data = {id: 2, name: 'your name'}
const file_path = './my_data.json'
append_data(file_path, data)

async function append_data(filename, data) {

  if (fs.existsSync(filename)) {
    var read_data = await readFile(filename)
    if (read_data == false) {
      console.log('not able to read file')
    } else {
      read_data.table.push(data)  //data must have the table array in it like example 1
      var dataWrittenStatus = await writeFile(filename, read_data)
      if (dataWrittenStatus == true) {
        console.log('data added successfully')
      } else {
        console.log('data adding failed')
      }
    }
  }
}

async function readFile(filePath) {
  try {
    const data = await fs.promises.readFile(filePath, 'utf8')
    return JSON.parse(data)
  }
  catch (err) {
    return false;
  }
}

async function writeFile(filename, writedata) {
  try {
    await fs.promises.writeFile(filename, JSON.stringify(writedata, null, 4), 'utf8');
    return true
  }
  catch (err) {
    return false
  }
}

도서관을 하실 수 .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.');
      }
    });
  }
});

언급URL : https://stackoverflow.com/questions/2496710/writing-to-files-in-node-js