Вопрос по javascript, node.js – Получить данные из fs.readFile

240
var content;
fs.readFile('./Index.html', function read(err, data) {
    if (err) {
        throw err;
    }
    content = data;
});
console.log(content);

бревнаundefined, Зачем?

fs.readFileSync также имеет интересные функции для чтения файла, даже если он в формате unicode utf8. Praneeth
Нотабене fs.readFile также может сделать это ^ см. мой ответ ниже Dominic

Ваш Ответ

13   ответов
11

var data = fs.readFileSync('tmp/reltioconfig.json','utf8');

используйте это для синхронного вызова файла, без кодирования вывод его вывода в виде буфера.

Error: User Rate Limit Exceeded
Error: User Rate Limit Exceeded
6

const fs = require('fs')
function readDemo1(file1) {
    return new Promise(function (resolve, reject) {
        fs.readFile(file1, 'utf8', function (err, dataDemo1) {
            if (err)
                reject(err);
            else
                resolve(dataDemo1);
        });
    });
}
async function copyFile() {

    try {
        let dataDemo1 = await readDemo1('url')
        dataDemo1 += '\n' +  await readDemo1('url')

        await writeDemo2(dataDemo1)
        console.log(dataDemo1)
    } catch (error) {
        console.error(error);
    }
}
copyFile();

function writeDemo2(dataDemo1) {
    return new Promise(function(resolve, reject) {
      fs.writeFile('text.txt', dataDemo1, 'utf8', function(err) {
        if (err)
          reject(err);
        else
          resolve("Promise Success!");
      });
    });
  }
Error: User Rate Limit Exceeded
Error: User Rate Limit Exceeded
3

Эта линия будет работать,

const content = fs.readFileSync('./Index.html', 'utf8');
console.log(content);
Error: User Rate Limit Exceeded
Error: User Rate Limit Exceededfs.readFileSyncError: User Rate Limit ExceededawaitError: User Rate Limit Exceedednodejs.org/api/fs.html#fs_fs_promises_apiError: User Rate Limit Exceeded karaxuna
3

Используйте встроенную библиотеку Promisify (Node 8+), чтобы сделать эти старые функции обратного вызова более элегантными.

const fs = require('fs');
const util = require('util');

const readFile = util.promisify(fs.readFile);

async function doStuff() {
  try {
    const content = await readFile(filePath, 'utf8');
    console.log(content);
  } catch (e) {
    console.error(e);
  }
}
7

Синхронизация и асинхронное чтение файла:

//fs module to read file in sync and async way

var fs = require('fs'),
    filePath = './sample_files/sample_css.css';

// this for async way
/*fs.readFile(filePath, 'utf8', function (err, data) {
    if (err) throw err;
    console.log(data);
});*/

//this is sync way
var css = fs.readFileSync(filePath, 'utf8');
console.log(css);

Читы узла доступны наread_file.

1

Грубо говоря, вы имеете дело с node.js, который является асинхронным по своей природе.

Когда мы говорим об асинхронности, мы говорим о выполнении или обработке информации или данных, когда имеем дело с чем-то другим. Это не синоним параллели, пожалуйста, напомните.

Ваш код:

var content;
fs.readFile('./Index.html', function read(err, data) {
    if (err) {
        throw err;
    }
    content = data;
});
console.log(content);

С вашим примером, он в основном сначала выполняет console.log, таким образом, переменная 'content' apos; быть неопределенным.

Если вы действительно хотите вывод, сделайте что-то вроде этого:

var content;
fs.readFile('./Index.html', function read(err, data) {
    if (err) {
        throw err;
    }
    content = data;
    console.log(content);
});

Это асинхронно. Будет трудно привыкнуть, но это то, что есть. Опять же, это грубое, но быстрое объяснение того, что такое асинхронность.

7

Как сказано,fs.readFile это асинхронное действие. Это означает, что когда вы указываете узлу читать файл, вы должны учитывать, что это займет некоторое время, а тем временем узел продолжал выполнять следующий код. В вашем случае это:console.log(content);.

Это похоже на отправку какой-то части вашего кода для длительной поездки (например, чтение большого файла).

Посмотрите на комментарии, которые я написал:

var content;

// node, go fetch this file. when you come back, please run this "read" callback function
fs.readFile('./Index.html', function read(err, data) {
    if (err) {
        throw err;
    }
    content = data;
});

// in the meantime, please continue and run this console.log
console.log(content);

Вот почемуcontent все еще пусто, когда вы входите в систему. узел еще не получил содержимое файла.

Это может быть решено путем перемещенияconsole.log(content) внутри функции обратного вызова, сразу послеcontent = data;, Таким образом, вы увидите журнал, когда узел завершит чтение файла и послеcontent получает значение.

93

function readContent(callback) {
    fs.readFile("./Index.html", function (err, content) {
        if (err) return callback(err)
        callback(null, content)
    })
}

readContent(function (err, content) {
    console.log(content)
})
readContent(function (err, content)Error: User Rate Limit Exceeded
fs.readFile('index.html', callback)
Error: User Rate Limit ExceededeventError: User Rate Limit ExceededcError: User Rate Limit Exceeded
Error: User Rate Limit Exceededfunction readContent(callback)Error: User Rate Limit ExceededcallbackError: User Rate Limit Exceeded
Error: User Rate Limit Exceeded karaxuna
55

Using Promises with ES7

Asynchronous use with mz/fs

mz Модуль предоставляет обещанные версии библиотеки базового узла. Использовать их просто. Сначала установите библиотеку ...

npm install mz

Затем...

const fs = require('mz/fs');
fs.readFile('./Index.html').then(contents => console.log(contents))
  .catch(err => console.error(err));

В качестве альтернативы вы можете написать их в асинхронных функциях:

async function myReadfile () {
  try {
    const file = await fs.readFile('./Index.html');
  }
  catch (err) { console.error( err ) }
};
Error: User Rate Limit Exceeded
Error: User Rate Limit Exceeded
Error: User Rate Limit Exceeded
4

var fs = require('fs');
var path = (process.cwd()+"\\text.txt");

fs.readFile(path , function(err,data)
{
    if(err)
        console.log(err)
    else
        console.log(data.toString());
});
1

Вы можете прочитать файл по

var readMyFile = function(path, cb) {
      fs.readFile(path, 'utf8', function(err, content) {
        if (err) return cb(err, null);
        cb(null, content);
      });
    };

Добавив, вы можете написать в файл,

var createMyFile = (path, data, cb) => {
  fs.writeFile(path, data, function(err) {
    if (err) return console.error(err);
    cb();
  });
};

и даже связать это вместе

var readFileAndConvertToSentence = function(path, callback) {
  readMyFile(path, function(err, content) {
    if (err) {
      callback(err, null);
    } else {
      var sentence = content.split('\n').join(' ');
      callback(null, sentence);
    }
  });
};
284

Чтобы пояснить, что сказал @Raynos, определенная вами функция является асинхронным обратным вызовом. Он не выполняется сразу, а выполняется после завершения загрузки файла. Когда вы вызываете readFile, управление возвращается немедленно и выполняется следующая строка кода. Поэтому, когда вы вызываете console.log, ваш обратный вызов еще не был вызван, и этот контент еще не был установлен. Добро пожаловать в асинхронное программирование.

Пример подходов

const fs = require('fs');
var content;
// First I want to read the file
fs.readFile('./Index.html', function read(err, data) {
    if (err) {
        throw err;
    }
    content = data;

    // Invoke the next step here however you like
    console.log(content);   // Put all of the code here (not the best solution)
    processFile();          // Or put the next step in a function and invoke it
});

function processFile() {
    console.log(content);
}

Или, что еще лучше, как показывает пример Raynos, оберните ваш вызов в функцию и передайте свои собственные обратные вызовы. (Очевидно, это лучшая практика) Я думаю, что привычка заключать в асинхронные вызовы функцию, которая выполняет обратный вызов, избавит вас от многих хлопот и грязного кода.

function doSomething (callback) {
    // any async callback invokes callback with response
}

doSomething (function doSomethingAfter(err, result) {
    // process the async result
});
Error: User Rate Limit Exceeded
Error: User Rate Limit Exceeded
Error: User Rate Limit Exceeded'utf8'Error: User Rate Limit Exceededstackoverflow.com/questions/9168737/…
208

На самом деле есть синхронная функция для этого:

http://nodejs.org/api/fs.html#fs_fs_readfilesync_filename_encoding

Asynchronous

fs.readFile(filename, [encoding], [callback])

Asynchronously reads the entire contents of a file. Example:

fs.readFile('/etc/passwd', function (err, data) {
  if (err) throw err;
  console.log(data);
});

The callback is passed two arguments (err, data), where data is the contents of the file.

If no encoding is specified, then the raw buffer is returned.


SYNCHRONOUS

fs.readFileSync(filename, [encoding])

Synchronous version of fs.readFile. Returns the contents of the file named filename.

If encoding is specified then this function returns a string. Otherwise it returns a buffer.

var text = fs.readFileSync('test.md','utf8')
console.log (text)
Error: User Rate Limit ExceededAF 42 F1Error: User Rate Limit Exceeded
Error: User Rate Limit Exceeded
Error: User Rate Limit Exceededdata. if (Buffer.isBuffer( data){ result = data.toString('utf8'); }Error: User Rate Limit Exceedednodejs.org/api/buffer.html

Похожие вопросы