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

Logs undefined, por quê?

Para elaborar o que o @Raynos disse, a função que você definiu é um retorno de chamada assíncrono. Ele não é executado imediatamente, é executado quando o carregamento do arquivo é concluído. Quando você chama readFile, o controle é retornado imediatamente e a próxima linha de código é executada. Portanto, quando você chama console.log, seu retorno de chamada ainda não foi invocado e esse conteúdo ainda não foi definido. Bem-vindo à programação assíncrona.

Abordagens de exemplo

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

Ou melhor ainda, como mostra o exemplo do Raynos, envolva sua chamada em uma função e transmita seus próprios retornos de chamada. (Aparentemente, essa é uma prática recomendada). Acho que adquirir o hábito de agrupar suas chamadas assíncronas na função que recebe um retorno de chamada economizará muitos problemas e códigos confusos.

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

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

Na verdade, existe uma função síncrona para isso:

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

Assíncrono

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

Lê assincronamente todo o conteúdo de um arquivo. Exemplo:

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

O retorno de chamada recebe dois argumentos (err, data), em que data é o conteúdo do arquivo.

Se nenhuma codificação for especificada, o buffer bruto será retornado.

SÍNCRONO

fs.readFileSync(filename, [encoding])

Versão síncrona do fs.readFile. Retorna o conteúdo do arquivo chamado filename.

Se a codificação for especificada, essa função retornará uma sequência. Caso contrário, ele retornará um buffer.

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

Usando promessas com o ES7

Uso assíncrono com mz / fs

O mzmódulo fornece versões promissificadas da biblioteca de nós principais. Usá-los é simples. Primeiro instale a biblioteca ...

npm install mz

Então...

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

Como alternativa, você pode escrevê-los em funções assíncronas:

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

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

use isso para chamar um arquivo de forma síncrona, sem codificar sua saída de exibição como um buffer.

Esta linha irá funcionar,

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

maneira de ler arquivos sincronizados e assíncronos:

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

Fraude do nó Disponível em read_file .

Como dito, fs.readFileé uma ação assíncrona. Isso significa que, quando você instrui o nó a ler um arquivo, é necessário considerar que levará algum tempo e, enquanto isso, o nó continuará executando o código a seguir. No seu caso, é:console.log(content); .

É como enviar parte do seu código para uma longa viagem (como ler um arquivo grande).

Dê uma olhada nos comentários que escrevi:

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

É por isso content ainda está vazio quando você o registra. O nó ainda não recuperou o conteúdo do arquivo.

Isso pode ser resolvido movendo-se para console.log(content)dentro da função de retorno de chamada, logo após content = data;. Dessa forma, você verá o log quando o nó terminar de ler o arquivo e depois contentobtém um valor.

Use a biblioteca promisify incorporada (Nó 8+) para tornar essas funções antigas de retorno de chamada mais elegantes.

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

Isso ocorre apenas porque o nó é assíncrono e não espera a função de leitura. Assim que o programa for iniciado, o valor do console será definido como indefinido, o que é realmente verdadeiro porque não há valor atribuído à variável de conteúdo. Para lidar, podemos usar promessas, geradores, etc. Podemos usar a promessa dessa maneira.

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

O seguinte é função funcionaria para asyncencapsular ou prometer thencadeias

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

você pode ler o arquivo

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

Adicionando você pode gravar em um arquivo,

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

e até encadeá-lo

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

Em outras palavras, você está lidando com o node.js, que é de natureza assíncrona.

Quando falamos de assíncrono, estamos falando sobre fazer ou processar informações ou dados enquanto lida com outra coisa. Não é sinônimo de paralelo, lembre-se.

Seu código:

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

Com sua amostra, ele basicamente faz a parte console.log primeiro, portanto a variável 'conteúdo' é indefinida.

Se você realmente deseja a saída, faça algo assim:

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

Isso é assíncrono. Vai ser difícil se acostumar, mas é o que é. Novamente, esta é uma explicação grosseira, mas rápida, do que é assíncrono.