Come leggere correttamente il file con async / await?

Non riesco a capire come async/ awaitfunziona. Lo capisco leggermente ma non riesco a farlo funzionare.

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

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

So che potrei usare readFileSync, ma se lo faccio, so che non capirò mai async/ awaite seppellirò il problema.

Obiettivo: chiamare loadMonoCounter()e restituire il contenuto di un file.

Quel file viene incrementato ogni volta che incrementMonoCounter()viene chiamato (ogni caricamento della pagina). Il file contiene il dump di un buffer in binario ed è memorizzato su un SSD.

Qualunque cosa faccia, ricevo un errore o undefinednella console.

Per usare await/ asynchai bisogno di metodi che restituiscano promesse. Le funzioni API principali non lo fanno senza wrapper come 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);
})

Come nota, readFileSyncnon accetta una richiamata, restituisce i dati o genera un'eccezione. Non ottieni il valore che desideri perché la funzione che fornisci viene ignorata e non stai acquisendo il valore di ritorno effettivo.

Poiché le promesse fs di Node v11.0.0 sono disponibili in modo nativo senza promisify:

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

Questa è la versione TypeScript della risposta di @ Joel. È utilizzabile dopo il nodo 11.0:

import { promises as fs } from 'fs';

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

Puoi facilmente racchiudere il comando readFile con una promessa in questo modo:

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

quindi usa:

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

È possibile utilizzare fs.promisesdisponibile in modo nativo a partire da 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)
  }
}

C'è un fs.readFileSync( path, options )metodo, che è sincrono.