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

Günlükler undefined, neden?

@Raynos'un söylediklerini ayrıntılı olarak açıklamak için, tanımladığınız işlev eşzamansız bir geri aramadır. Hemen yürütülmez, dosya yükleme tamamlandığında yürütülür. ReadFile öğesini çağırdığınızda, denetim hemen döndürülür ve sonraki kod satırı yürütülür. Dolayısıyla console.log'u çağırdığınızda, geri aramanız henüz çağrılmadı ve bu içerik henüz ayarlanmadı. Eşzamansız programlamaya hoş geldiniz.

Örnek yaklaşımlar

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

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

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

Ya da daha iyisi, Raynos örneğinin gösterdiği gibi, çağrınızı bir işleve sarın ve kendi geri aramalarınızı iletin. (Görünüşe göre bu daha iyi bir uygulamadır) Async çağrılarınızı geri arama yapan bir işlevle sarma alışkanlığına girmenin size çok fazla sorun ve dağınık kod kazandıracağını düşünüyorum.

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

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

Bunun için aslında bir Eşzamanlı işlev vardır:

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

eşzamanlı olmayan

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

Bir dosyanın tüm içeriğini eşzamansız olarak okur. Misal:

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

Geri arama, verilerin dosyanın içeriği olduğu iki bağımsız değişkenden (err, veri) geçirilir.

Kodlama belirtilmezse, ham arabellek döndürülür.

SENKRON

fs.readFileSync(filename, [encoding])

Fs.readFile dosyasının eşzamanlı sürümü. Dosyaadı adlı dosyanın içeriğini döndürür.

Kodlama belirtilirse, bu işlev bir dize döndürür. Aksi takdirde bir tampon döndürür.

var text = fs.readFileSync('test.md','utf8')
console.log (text)

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

ES7 ile Vaatleri Kullanma

Mz / fs ile eşzamansız kullanım

mzModül merkez düğüm kütüphanesinin promisified sürümlerini içerir. Bunları kullanmak basittir. Önce kütüphaneyi kurun ...

npm install mz

Sonra...

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

Alternatif olarak, bunları eşzamansız işlevlerde yazabilirsiniz:

async function myReadfile () {
  try {
    const file = await fs.readFile('./Index.html');
  }
  catch (err) { console.error( err ) }
};

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

bu dosyayı bir çıktıyı tampon olarak kodlamadan senkronize olarak çağırmak için kullanın.

Bu hat çalışacak,

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

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

eşitleme ve zaman uyumsuz dosya okuma yolu:

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

Düğüm Hilesi read_file adresinde mevcut .

Söylendiği gibi, fs.readFile asenkron bir eylemdir. Bu, düğüme bir dosyayı okumasını söylediğinizde, bunun biraz zaman alacağını ve bu arada düğümün aşağıdaki kodu çalıştırmaya devam ettiğini düşünmeniz gerektiği anlamına gelir. Senin durumunda bu kadar: console.log(content);.

Kodunuzun bir kısmını uzun bir yolculuk için göndermek gibi (büyük bir dosyayı okumak gibi).

Yazdığım yorumlara bir göz atın:

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

Bu yüzden content oturum açtığınızda hala boş. düğüm henüz dosyanın içeriğini almadı.

Bu console.log(content), hemen sonra geri arama işlevinin içinde hareket ederek çözülebilir content = data;. Bu şekilde, düğüm dosyayı okuduktan ve sonra contentbir değer aldığında günlüğü görürsünüz .

Bu eski geri arama işlevlerini daha zarif hale getirmek için yerleşik promisify kitaplığını (Node 8+) kullanın.

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

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

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

Bunun nedeni, düğümün eşzamansız olması ve okuma işlevini beklememesi ve program başlar başlamaz değeri tanımsız olarak konsolide etmesidir. İşlemek için vaatler, jeneratörler vb. Kullanabiliriz. Sözü bu şekilde kullanabiliriz.

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

dosyayı okuyabilirsin

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

Ekleyerek dosyaya yazabilirsiniz,

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

ve hatta birlikte zincirleme

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

Kabaca söylemek gerekirse, doğası gereği asenkron olan node.js ile uğraşıyorsunuz.

Zaman uyumsuzluk hakkında konuştuğumuzda, başka bir şeyle uğraşırken bilgi veya veri yapmaktan veya işlemekten bahsediyoruz. Paralel ile eşanlamlı değildir, lütfen hatırlatırız.

Senin kodun:

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

Örneğin, temel olarak önce console.log bölümünü yapar, böylece 'içerik' değişkeni tanımsız olur.

Çıktıyı gerçekten istiyorsanız, bunun gibi bir şey yapın:

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

Bu eşzamansız. Alışmak zor olacak, ama olan bu. Yine, bu zaman uyumsuzluğun ne olduğunun kaba ama hızlı bir açıklamasıdır.

Aşağıdaki fonksiyon asyncsarma veya söz thenzincirleri için işe yarar

const readFileAsync =  async (path) => fs.readFileSync(path, 'utf8');