it-swarm-pt.tech

Escrevendo arquivos no Node.js

Eu tenho tentado encontrar uma maneira de gravar em um arquivo ao usar o Node.js, mas sem sucesso. Como eu posso fazer isso?

1311
Gjorgji

Há muitos detalhes na sistema de arquivos API . A maneira mais comum é:

const fs = require('fs');
fs.writeFile("/tmp/test", "Hey there!", function(err) {
    if(err) {
        return console.log(err);
    }

    console.log("The file was saved!");
}); 
2061
Brian McKenna

Atualmente, existem três maneiras de escrever um arquivo:

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

    Você precisa aguardar o retorno de chamada para garantir que o buffer seja gravado no disco. Não está em buffer.

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

    Todos os dados devem ser armazenados ao mesmo tempo; você não pode executar gravações sequenciais.

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

    Cria um WriteStream , o que é conveniente porque você não precisa esperar por um retorno de chamada. Mas, novamente, não está em buffer.

A WriteStream , como o nome diz, é um fluxo. Um fluxo, por definição, é “um buffer” contendo dados que se movem em uma direção (origem ► destino). Mas um fluxo gravável não é necessariamente “bufferizado”. Um fluxo é “bufferizado” quando você escreve n vezes, e no momento n+1, o fluxo envia o buffer para o kernel (porque está cheio e precisa ser liberado).

Em outras palavras: “A buffer” é o objeto. Se "está em buffer" ou não é uma propriedade desse objeto.

Se você olhar o código, o WriteStream herda de um objeto Stream gravável. Se você prestar atenção, verá como eles liberam o conteúdo. eles não têm nenhum sistema de buffering.

Se você escrever uma string, ela será convertida em um buffer e, em seguida, enviada para a camada nativa e gravada no disco. Ao escrever strings, eles não estão preenchendo qualquer buffer. Então, se você fizer:

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

Voce esta fazendo:

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

Isso é três chamadas para a camada de E/S. Embora você esteja usando “buffers”, os dados não são armazenados em buffer. Um fluxo em buffer faria: fs.write(new Buffer ("abc")), uma chamada para a camada de E/S.

A partir de agora, no Node.js v0.12 (versão estável anunciada em 02/06/2015) agora suporta duas funções: cork() e uncork() . Parece que essas funções finalmente permitirão que você armazene as chamadas de gravação.

Por exemplo, em Java, existem algumas classes que fornecem fluxos em buffer (BufferedOutputStream, BufferedWriter...). Se você escrever três bytes, esses bytes serão armazenados no buffer (memória) em vez de fazer uma chamada de E/S apenas por três bytes. Quando o buffer está cheio, o conteúdo é liberado e salvo no disco. Isso melhora o desempenho.

Eu não estou descobrindo nada, apenas lembrando como um acesso ao disco deve ser feito.

474
Gabriel Llamas

Você pode, claro, torná-lo um pouco mais avançado. Sem bloqueio, escrevendo bits e peças, não escrevendo o arquivo inteiro de uma só vez:

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();
});
216
Fredrik Andersson
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');
        })
    });
});
42
Mister P

Eu gostei Índice de ./articles/file-system.

Isso funcionou para mim.

Veja também Como eu escrevo arquivos em 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');
});

Conteúdo do helloworld.txt:

Hello World!

Atualizar:
Como no nó Linux escreva no diretório atual, parece que em outros não, então eu adiciono este comentário apenas no caso:
Usando esta ROOT_APP_PATH = fs.realpathSync('.'); console.log(ROOT_APP_PATH); para chegar onde o arquivo está escrito.

26
Sérgio

Gravação síncrona

fs.writeFileSync (arquivo, dados [ opções])

fs = require('fs');

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

Asynchronous Write

fs.writeFile (arquivo, dados [ opções], retorno de chamada)

fs = require('fs');

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

Onde

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

Vale a pena ler o sistema de arquivos oficial (fs) docs .

21
Moriarty

Eu sei a pergunta feita sobre "escrever", mas em um sentido mais geral "acrescentar" pode ser útil em alguns casos, pois é fácil de usar em um loop para adicionar texto a um arquivo (se o arquivo existe ou não). Use um "\ n" se você quiser adicionar linhas, por exemplo:

var fs = require('fs');
for (var i=0; i<10; i++){
    fs.appendFileSync("junk.csv", "Line:"+i+"\n");
}
9
Astra Bear
 var fs = require('fs');
 fs.writeFile(path + "\\message.txt", "Hello", function(err){
 if (err) throw err;
  console.log("success");
}); 

Por exemplo: leia o arquivo e grave em outro arquivo:

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

Aqui nós usamos w + para ler/escrever ambas as ações e se o caminho do arquivo não for encontrado, ele será criado automaticamente.

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

Conteúdo significa o que você precisa gravar no arquivo e seu tamanho, 'content.length'.

4
Gunjan Patel

Você pode gravar em um arquivo usando o módulo fs (file system).

Aqui está um exemplo de como você pode fazer isso:

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

Você também pode querer se livrar dessa estrutura de código de retorno de chamada dentro do callback usando as instruções Promises e async/await. Isso tornará a estrutura de código assíncrona muito mais plana. Para fazer isso, existe uma útil função util.promisify (original) . Isso nos permite mudar de callbacks para promessas. Dê uma olhada no exemplo com as funções fs abaixo:

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

4
Oleksii Trekhleb

Aqui está o exemplo de como ler o arquivo csv do local e gravar o arquivo csv no local.

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()
3
KARTHIKEYAN.A

As respostas fornecidas são datadas e uma maneira mais recente de fazer isso é:

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

veja o doco aqui para mais informações

3
TrevTheDev

Você pode usar a biblioteca easy-file-manager

instale primeiro a partir de npm npm install easy-file-manager

Amostra para fazer upload e remover arquivos

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);
});
2
Christoper

Você pode escrever em um arquivo pelo seguinte exemplo de código:

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

OK, é bem simples, pois o Node possui funcionalidade embutida para isso, é chamado de fs, que significa File System e basicamente, o módulo NodeJS File System ...

Então, primeiro, exija no seu arquivo server.js desta forma:

var fs = require('fs');

fs tem poucos métodos para escrever no arquivo, mas minha maneira preferida é usar appendFile, isso irá acrescentar os arquivos ao arquivo e se o arquivo não existir, irá criar um, o código pode ser como abaixo:

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

fs.createWriteStream(path[,options])

options também pode incluir uma opção start para permitir a gravação de dados em alguma posição após o início do arquivo. Modificar um arquivo em vez de substituí-lo pode exigir um modo flags de r+ em vez do modo padrão w. A codificação pode ser qualquer uma das aceitas pelo Buffer .

Se autoClose estiver definido como true (comportamento padrão) em 'error' ou 'finish', o descritor de arquivo será fechado automaticamente. Se autoClose for falso, o descritor de arquivo não será fechado, mesmo que haja um erro. É de responsabilidade do aplicativo fechá-lo e garantir que não haja vazamento do descritor de arquivo.

Como ReadStream , se fd for especificado, WriteStream irá ignorar o argumento path e usará o descritor de arquivo especificado. Isso significa que nenhum evento 'open' será emitido. fd deve estar bloqueando; fds não-bloqueantes devem ser passados ​​para net.Socket .

Se options for uma string, ela especifica a codificação.

Depois, lendo este longo artigo. Você deve entender como funciona. Então, aqui está um exemplo de 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');
0
user9258013

Tente o seguinte:

fs.readFile(`${__dirname}/fileName`, 'utf-8',(err, contents) => {
    if (err) throw Error(err){
        console.log(contents)
    }
});
0
sultan aslam