Hoe kan ik het bestand met async/wait correct lezen?

Ik kan er niet achter komen hoe async/awaitwerkt. Ik begrijp het een beetje, maar ik krijg het niet voor elkaar.

function loadMonoCounter() {
    fs.readFileSync("monolitic.txt", "binary", async function(err, data) {
       return await new Buffer( data);
  });
}
module.exports.read = function() {
  console.log(loadMonoCounter());
};

Ik weet het, ik zou readFileSynckunnen gebruiken, maar als ik dat doe, weet ik dat ik async/awaitnooit zal begrijpen en ik’ Ik zal het probleem gewoon begraven.

Doel: Roep loadMonoCounter()aan en retourneer de inhoud van een bestand.

Dat bestand wordt verhoogd elke keer dat incrementMonoCounter()wordt aangeroepen (elke pagina die wordt geladen). Het bestand bevat de dump van een buffer in binair en is opgeslagen op een SSD.

Wat ik ook doe, ik krijg een foutmelding of undefinedin de console.

Antwoord 1, autoriteit 100%

Sinds Node v11.0.0 fs-beloften native beschikbaar zijn zonder promisify:

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

Antwoord 2, autoriteit 63%

Om await/asyncte gebruiken, heb je methoden nodig die beloften inleveren. De kern-API-functies doen dat niet zonder wrappers zoals 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);
})

Als een opmerking, readFileSyncneemt geen callback, het retourneert de gegevens of genereert een uitzondering. U krijgt niet de gewenste waarde omdat de functie die u opgeeft, wordt genegeerd en u niet de werkelijke retourwaarde vastlegt.

Antwoord 3, autoriteit 13%

Dit is de TypeScript-versie van het antwoord van @Joel. Het is bruikbaar na Node 11.0:

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

Antwoord 4, autoriteit 9%

Je kunt het readFile-commando gemakkelijk inpakken met een belofte als volgt:

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

gebruik dan:

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

Antwoord 5, autoriteit 8%

U kunt fs.promisesgebruiken die standaard beschikbaar zijn sinds 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)
  }
}

Antwoord 6, autoriteit 4%

Om het beknopt te houden en alle functionaliteit van fste behouden:

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

Als u fsen fs.promisesafzonderlijk importeert, krijgt u toegang tot de volledige fsAPI en blijft deze leesbaarder… Zodat zoiets als het volgende voorbeeld is gemakkelijk te realiseren.

// the 'next example'
fsPromises.access('monolitic.txt', fs.constants.R_OK | fs.constants.W_OK)
    .then(() => console.log('can access'))
    .catch(() => console.error('cannot access'));

Antwoord 7, autoriteit 4%

Van knooppunt v14.0.0

const {readFile} = require('fs/promises');
const myFunction = async()=>{
    const result = await readFile('monolitic.txt','binary')
    console.log(result)
}
myFunction()

Antwoord 8

Er is een fs.readFileSync( path, options )methode, die synchroon is.

Antwoord 9

const fs = require("fs");
const util = require("util");
const readFile = util.promisify(fs.readFile);
const getContent = async () => {
let my_content;
try {
  const { toJSON } = await readFile("credentials.json");
  my_content = toJSON();
  console.log(my_content);
} catch (e) {
  console.log("Error loading client secret file:", e);
 }
};

Antwoord 10

Ik lees het bestand met behulp van de Promise. Voor mij is het goed:

const fs = require('fs')
//function which return Promise
const read = (path, type) => new Promise((resolve, reject) => {
  fs.readFile(path, type, (err, file) => {
    if (err) reject(err)
    resolve(file)
  })
})
//example how call this function
read('file.txt', 'utf8')
    .then((file) => console.log('your file is '+file))
    .catch((err) => console.log('error reading file '+err))
//another example how call function inside async
async function func() {
  let file = await read('file.txt', 'utf8')
  console.log('your file is '+file)
}

Antwoord 11

U kunt mijn aanpak hieronder vinden:
Eerst had ik fs nodig als fsBase, daarna plaatste ik de “beloften” in de fs-variabele.

const fsBase = require('fs');
const fs = fsBase.promises
const fn = async () => {
    const data = await fs.readFile('example.txt', 'utf8');
    console.log(data);
};
fn();

Antwoord 12

zie dit voorbeeld
https://www.geeksforgeeks.org/node-js-fs-readfile -methode/

// Include fs module
var fs = require('fs');
// Use fs.readFile() method to read the file
fs.readFile('demo.txt', (err, data) => {
  console.log(data);
})