¿Leer un archivo de texto con Node.js?

Necesito pasar un archivo de texto en la terminal y luego leer los datos, ¿cómo puedo hacer esto?

node server.js file.txt

¿Cómo paso en la ruta desde la terminal, cómo leo eso en el otro lado?

Querrá usar la process.argvmatriz para acceder a los argumentos de la línea de comandos para obtener el nombre del archivo y el módulo FileSystem (fs) para leer el archivo. Por ejemplo:

// Make sure we got a filename on the command line.
if (process.argv.length < 3) {
  console.log('Usage: node ' + process.argv[1] + ' FILENAME');
  process.exit(1);
}
// Read the file and print its contents.
var fs = require('fs')
  , filename = process.argv[2];
fs.readFile(filename, 'utf8', function(err, data) {
  if (err) throw err;
  console.log('OK: ' + filename);
  console.log(data)
});

Para desglosarlo un poco, por lo process.argvgeneral tendrá una longitud dos, el elemento cero es el intérprete del "nodo" y el primero es el script que el nodo está ejecutando actualmente, los elementos posteriores se pasaron en la línea de comandos. Una vez que haya extraído un nombre de archivo de argv, puede usar las funciones del sistema de archivos para leer el archivo y hacer lo que quiera con su contenido. El uso de muestra se vería así:

$ node ./cat.js file.txt
OK: file.txt
This is file.txt!

[Editar] Como menciona @wtfcoder, usar el fs.readFile()método " " podría no ser la mejor idea porque almacenará en búfer todo el contenido del archivo antes de cederlo a la función de devolución de llamada. Este almacenamiento en búfer podría usar una gran cantidad de memoria pero, lo que es más importante, no aprovecha una de las características principales de node.js: E / S asíncrona y con eventos.

La forma de "nodo" para procesar un archivo grande (o cualquier archivo, en realidad) sería usar fs.read()y procesar cada fragmento disponible tal como está disponible en el sistema operativo. Sin embargo, leer el archivo como tal requiere que realice su propio (posiblemente) análisis / procesamiento incremental del archivo y una cierta cantidad de almacenamiento en búfer podría ser inevitable.

Use fs con node.

var fs = require('fs');

try {  
    var data = fs.readFileSync('file.txt', 'utf8');
    console.log(data.toString());    
} catch(e) {
    console.log('Error:', e.stack);
}

En mi humilde opinión, fs.readFile()debería evitarse porque carga TODO el archivo en la memoria y no llamará a la devolución de llamada hasta que se haya leído todo el archivo.

La forma más sencilla de leer un archivo de texto es leerlo línea por línea. Recomiendo un BufferedReader :

new BufferedReader ("file", { encoding: "utf8" })
    .on ("error", function (error){
        console.log ("error: " + error);
    })
    .on ("line", function (line){
        console.log ("line: " + line);
    })
    .on ("end", function (){
        console.log ("EOF");
    })
    .read ();

Para estructuras de datos complejas como .properties o archivos json, necesita usar un analizador (internamente también debe usar un lector en búfer).

Puede usar readstream y pipe para leer el archivo línea por línea sin leer todo el archivo en la memoria una vez.

var fs = require('fs'),
    es = require('event-stream'),
    os = require('os');

var s = fs.createReadStream(path)
    .pipe(es.split())
    .pipe(es.mapSync(function(line) {
        //pause the readstream
        s.pause();
        console.log("line:", line);
        s.resume();
    })
    .on('error', function(err) {
        console.log('Error:', err);
    })
    .on('end', function() {
        console.log('Finish reading.');
    })
);

Estoy publicando un ejemplo completo que finalmente pude hacer funcionar. Aquí estoy leyendo en un archivo rooms/rooms.txtde un script.rooms/rooms.js

var fs = require('fs');
var path = require('path');
var readStream = fs.createReadStream(path.join(__dirname, '../rooms') + '/rooms.txt', 'utf8');
let data = ''
readStream.on('data', function(chunk) {
    data += chunk;
}).on('end', function() {
    console.log(data);
});