web-dev-qa-db-fra.com

Obtenir des données de fs.readFile

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

Journaux undefined, pourquoi?

javascriptnode.js
234
karaxuna

Pour préciser ce que @Raynos a dit, la fonction que vous avez définie est un rappel asynchrone. Il ne s'exécute pas tout de suite, il s'exécute lorsque le chargement du fichier est terminé. Lorsque vous appelez readFile, le contrôle est renvoyé immédiatement et la ligne de code suivante est exécutée. Ainsi, lorsque vous appelez console.log, votre rappel n'a pas encore été appelé et ce contenu n'a pas encore été défini. Bienvenue dans la programmation asynchrone.

Exemples d'approches 

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

Ou mieux encore, comme le montre l'exemple de Raynos, encapsulez votre appel dans une fonction et transmettez vos propres rappels. (Apparemment, c'est une meilleure pratique) Je pense que prendre l'habitude de mettre vos appels asynchrones dans une fonction qui prend un rappel vous évitera beaucoup d'ennuis et du code compliqué.

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

doSomething (function doSomethingAfter(err, result) {
    // process the async result
});
283
Matt Esch

Il existe actuellement une fonction synchrone pour cela:

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

asynchrone

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

Lit de manière asynchrone l'intégralité du contenu d'un fichier. Exemple: 

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

Le callback reçoit deux arguments (err, data), où data correspond au contenu du fichier.

Si aucun codage n'est spécifié, le tampon brut est renvoyé.

SYNCHRONE

fs.readFileSync(filename, [encoding])

Version synchrone de fs.readFile. Renvoie le contenu du fichier nommé nomfichier.

Si le codage est spécifié, cette fonction renvoie une chaîne. Sinon, il retourne un tampon. 

var text = fs.readFileSync('test.md','utf8')
console.log (text)
222
Logan
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)
})
92
Raynos

Utilisation de promesses avec ES7

Utilisation asynchrone avec mz/fs

Le module mz fournit des versions promisifiées de la bibliothèque de noeuds principaux. Les utiliser est simple. Installez d'abord la bibliothèque ...

npm install mz

Ensuite...

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

Sinon, vous pouvez les écrire dans des fonctions asynchrones:

async function myReadfile () {
  try {
    const file = await fs.readFile('./Index.html');
  }
  catch (err) { console.error( err ) }
};
55
Evan Carroll
var data = fs.readFileSync('tmp/reltioconfig.json','utf8');

utilisez ceci pour appeler un fichier de manière synchrone, sans coder sa sortie affichée sous forme de tampon.

11
user2266928

manière de lire le fichier sync et async:

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

Node Cheat Disponible à read_file .

7
Zeeshan Hassan Memon

Comme dit, fs.readFile est une action asynchrone. Cela signifie que lorsque vous indiquez à noeud de lire un fichier, vous devez être conscient du temps nécessaire, et entre-temps, noeud continue à exécuter le code suivant. Dans votre cas, c'est: console.log(content);.

C'est comme envoyer une partie de votre code pour un long voyage (comme lire un gros fichier).

Regardez les commentaires que j'ai écrits:

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

C'est pourquoi content est toujours vide lorsque vous vous enregistrez. Le noeud n'a pas encore récupéré le contenu du fichier.

Cela pourrait être résolu en déplaçant console.log(content) dans la fonction de rappel, juste après le content = data;. De cette façon, vous verrez le journal lorsque le noeud aura fini de lire le fichier et obtiendra une valeur après content.

7
Taitu-lism
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!");
      });
    });
  }
6
doctorlee
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());
});
4
Masoud Siahkali

Utilisez la bibliothèque Promisify intégrée (Node 8+) pour rendre ces anciennes fonctions de rappel plus élégantes.

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);
  }
}
3
Dominic

Cette ligne fonctionnera,

const content = fs.readFileSync('./Index.html', 'utf8');
console.log(content);
3
Aravin

vous pouvez lire le fichier par

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

Ajout sur vous pouvez écrire dans le fichier,

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

et même enchaîner

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);
    }
  });
};
1
J. Doe

En gros, vous avez affaire à node.js, qui est de nature asynchrone.

Lorsque nous parlons d'async, nous parlons de traiter ou de traiter des informations ou des données tout en traitant avec autre chose. Ce n'est pas synonyme de parallèle, s'il vous plaît rappelez-vous.

Votre code: 

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

Avec votre exemple, il commence par la partie console.log, donc la variable 'contenu' étant indéfinie.

Si vous voulez vraiment la sortie, faites plutôt quelque chose comme ceci:

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

C'est asynchrone. Il sera difficile de s’habituer à, mais c’est ce que c’est… .. Encore une fois, c’est une explication grossière mais rapide de ce qu’est async.

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

Ceci est juste parce que le noeud est asynchrone et qu'il n'attendra pas la fonction de lecture et dès que le programme démarrera, il console la valeur comme indéfinie, ce qui est vrai car aucune variable n'est assignée à la variable de contenu . nous pouvons utiliser des promesses, des générateurs, etc. Nous pouvons utiliser la promesse de cette manière.

new Promise((resolve,reject)=>{
    fs.readFile('./index.html','utf-8',(err, data)=>{
        if (err) {
            reject(err); // in the case of error, control flow goes to the catch block with the error occured.
        }
        else{
            resolve(data);  // in the case of success, control flow goes to the then block with the content of the file.
        }
    });
})
.then((data)=>{
    console.log(data); // use your content of the file here (in this then).    
})
.catch((err)=>{
    throw err; //  handle error here.
})
0
Nouman Dilshad