Comment lire correctement un fichier avec async / wait?

Je ne peux pas comprendre comment async/ awaitfonctionne. Je le comprends un peu mais je ne peux pas le faire fonctionner.

function loadMonoCounter() {
    fs.readFileSync("monolitic.txt", "binary", async function(err, data) {
       return await new Buffer( data);
  });
}

module.exports.read = function() {
  console.log(loadMonoCounter());
};

Je sais que je pourrais utiliser readFileSync, mais si je le fais, je sais que je ne comprendrai jamais async/ awaitet je vais simplement enterrer le problème.

Objectif: appeler loadMonoCounter()et renvoyer le contenu d'un fichier.

Ce fichier est incrémenté à chaque incrementMonoCounter()appel (à chaque chargement de page). Le fichier contient le vidage d'un tampon en binaire et est stocké sur un SSD.

Peu importe ce que je fais, j'obtiens une erreur ou undefineddans la console.

Pour utiliser await/ asyncvous avez besoin de méthodes qui renvoient des promesses. Les fonctions principales de l'API ne font pas cela sans des wrappers comme promisify:

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

// Convert fs.readFile into Promise version of same    
const readFile = util.promisify(fs.readFile);

function getStuff() {
  return readFile('test');
}

// Can't use `await` outside of an async function so you need to chain
// with then()
getStuff().then(data => {
  console.log(data);
})

À noter, readFileSyncne prend pas de rappel, il renvoie les données ou lève une exception. Vous n'obtenez pas la valeur souhaitée car la fonction que vous fournissez est ignorée et vous ne capturez pas la valeur de retour réelle.

Depuis Node v11.0.0, les promesses fs sont disponibles nativement sans promisify:

const fs = require('fs').promises;
async function loadMonoCounter() {
    const data = await fs.readFile("monolitic.txt", "binary");
    return new Buffer(data);
}

C'est la version TypeScript de la réponse de @ Joel. Il est utilisable après le Node 11.0:

import { promises as fs } from 'fs';

async function loadMonoCounter() {
    const data = await fs.readFile('monolitic.txt', 'binary');
    return Buffer.from(data);
}

Vous pouvez facilement encapsuler la commande readFile avec une promesse comme ceci:

async function readFile(path) {
    return new Promise((resolve, reject) => {
      fs.readFile(path, 'utf8', function (err, data) {
        if (err) {
          reject(err);
        }
        resolve(data);
      });
    });
  }

puis utilisez:

await readFile("path/to/file");

Vous pouvez utiliser fs.promisesdisponible nativement depuis Node v11.0.0

import fs from 'fs';

const readFile = async filePath => {
  try {
    const data = await fs.promises.readFile(filePath, 'utf8')
    return data
  }
  catch(err) {
    console.log(err)
  }
}

Il existe une fs.readFileSync( path, options )méthode synchrone.