Erreur: Aucun moteur par défaut n'a été spécifié et aucune extension n'a été fournie.

Question

Je travaille à travers la mise en place d'un serveur http en utilisant node.js et le moteur. Cependant, je continue à me heurter à des problèmes pour lesquels je dispose de peu d’informations sur la résolution du problème. Je vous serais reconnaissant de l’aider à résoudre ce problème. Merci d'avance.

Error: No default engine was specified and no extension was provided. 
at new View (...\node_modules\express\lib\view.js:41:42) 
at Function.app.render (...\node_modules\express\lib\application.js:484:12) 
at ServerResponse.res.render (...\node_modules\express\lib\response.js:783:7) 
at Layer.handle (...\app.js:123:7) 
at trim_prefix (...\node_modules\express\lib\router\index.js:225:17) 
at c (...\node_modules\express\lib\router\index.js:198:9) 
at Function.proto.process_params (...\node_modules\express\lib\router\index.js:253:12) 
at next (...\node_modules\express\lib\router\index.js:189:19) 
at next (...\node_modules\express\lib\router\index.js:202:7) 
at next (...\node_modules\express\lib\router\index.js:166:38)

Vous trouverez ci-dessous ce que j'ai configuré pour démarrer ce moteur.

var http = require('http');  
var module = require("module")
var logger = require('morgan');
var express = require('express');
var app =  module.exports = express();
var silent = 'test' == process.env.NODE_ENV;
var httpServer = http.createServer(app);  // app middleware

app.enable('strict routing');
// app.all('*', function(req, res, next)/*** CORS support.*/
// {
//   if (!req.get('Origin')) return next();// use "*" here to accept any Origin
//   res.set('Access-Control-Allow-Origin', 'http://localhost:3000');
//   res.set('Access-Control-Allow-Methods', 'GET, POST');
//   res.set('Access-Control-Allow-Headers', 'X-Requested-With, Content-Type');
//   res.set('Access-Control-Allow-Max-Age', 3600);
//   if ('OPTIONS' == req.method) return res.send(200);
//   next();
// });
app.set('views', __dirname + '/views'); // general config
app.set('view engine', 'html');
app.get('/404', function(req, res, next){
next();// trigger a 404 since no other middleware will match /404 after this one, and we're not responding here
});
app.get('/403', function(req, res, next){// trigger a 403 error
  var err = new Error('not allowed!');
  err.status = 403;
  next(err);
});
app.get('/500', function(req, res, next){// trigger a generic (500) error
  next(new Error('keyboard cat!'));
});
app.use(express.static(__dirname + '/public')); 
//error handlers
app.use(logErrors);
app.use(clientErrorHandler);
app.use(errorHandler);  
// middleware with an arity of 4 are considered error handling middleware. When you next(err)
// it will be passed through the defined middleware in order, but ONLY those with an arity of 4, ignoring regular middleware.
function clientErrorHandler(err, req, res, next) {
  if (req.xhr) {// whatever you want here, feel free to populate properties on `err` to treat it differently in here.
  res.send(err.status || 500, { error: err.message });
  } 
  else 
  { next(err);}
};
// create an error with .status. we can then use the property in our custom error handler (Connect repects this prop as well)
function error  (status, msg) {
  var err = new Error(msg);
  err.status = status;
  return err;
};
function logErrors  (err, req, res, next) {
  console.error(err.stack);
  next(err);
};
function errorHandler (err, req, res, next) {
  res.status(500);
  res.render('error', { error: err });
};

// Error handlers
// Since this is the last non-error-handling middleware use()d, we assume 404, as nothing else responded.
// $ curl http://localhost:3000/notfound
// $ curl http://localhost:3000/notfound -H "Accept: application/json"
// $ curl http://localhost:3000/notfound -H "Accept: text/plain"
app.use(function(req, res, next){
  res.status(404); 
  if (req.accepts('html')) {// respond with html page
    res.render('404', { url: req.url });
    return;
  } 
  if (req.accepts('json')) {// respond with json
    res.send({ error: 'Not found' });
    return;
  } 
  res.type('txt').send('Not found');// default to plain-text. send()
});

// error-handling middleware, take the same form as regular middleware, however they require an
// arity of 4, aka the signature (err, req, res, next).when connect has an error, it will invoke ONLY error-handling middleware.

// If we were to next() here any remaining non-error-handling middleware would then be executed, or if we next(err) to
// continue passing the error, only error-handling middleware would remain being executed, however here
// we simply respond with an error page.
app.use(function(err, req, res, next){
  // we may use properties of the error object here and next(err) appropriately, or if we possibly recovered from the error, simply next().
  res.status(err.status || 500);
  res.render('500', { error: err });
});

if (!module.parent) {// assigning to exports will not modify module, must use module.exports
  app.listen(3000);
  silent || console.log('Express started on port 3000');
};

Answer 1

Les commandes res.render génèreront une erreur si vous n'utilisez pas de moteur de vue.

Si vous voulez juste servir json, remplacez les lignes res.render('error', { error: err }); dans votre code par:

res.json({ error: err })

PS: Les gens ont généralement aussi un message dans l'objet retourné:

res.status(err.status || 500);
res.json({
  message: err.message,
  error: err
});

Answer 2

Le moteur de vue vous manque, par exemple, utilisez jade :

change ton

app.set('view engine', 'html');

avec

app.set('view engine', 'jade');

Si vous souhaitez utiliser une syntaxe conviviale pour HTML, utilisez plutôt ejs

app.engine('html', require('ejs').renderFile);
app.set('view engine', 'html');

EDIT

Comme vous pouvez le lire dans le module view.js Express View

module.exports = View;

/**
 * Initialize a new `View` with the given `name`.
 *
 * Options:
 *
 *   - `defaultEngine` the default template engine name
 *   - `engines` template engine require() cache
 *   - `root` root path for view lookup
 *
 * @param {String} name
 * @param {Object} options
 * @api private
 */

function View(name, options) {
  options = options || {};
  this.name = name;
  this.root = options.root;
  var engines = options.engines;
  this.defaultEngine = options.defaultEngine;
  var ext = this.ext = extname(name);
  if (!ext && !this.defaultEngine) throw new Error('No default engine was specified and no extension was provided.');
  if (!ext) name += (ext = this.ext = ('.' != this.defaultEngine[0] ? '.' : '') + this.defaultEngine);
  this.engine = engines[ext] || (engines[ext] = require(ext.slice(1)).__express);
  this.path = this.lookup(name);
}

Vous devez avoir installé un default engine

Express recherche la présentation par défaut par program.template comme vous pouvez le lire ci-dessous:

mkdir(path + '/views', function(){
      switch (program.template) {
        case 'ejs':
          write(path + '/views/index.ejs', ejsIndex);
          break;
        case 'jade':
          write(path + '/views/layout.jade', jadeLayout);
          write(path + '/views/index.jade', jadeIndex);
          break;
        case 'jshtml':
          write(path + '/views/layout.jshtml', jshtmlLayout);
          write(path + '/views/index.jshtml', jshtmlIndex);
          break;
        case 'hjs':
          write(path + '/views/index.hjs', hoganIndex);
          break;

      }
    });

et comme vous pouvez le lire ci-dessous:

program.template = 'jade';
if (program.ejs) program.template = 'ejs';
if (program.jshtml) program.template = 'jshtml';
if (program.hogan) program.template = 'hjs';

le moteur de vue par défaut est jade

Answer 3

Mettez en commentaire les lignes res.render dans votre code et ajoutez-y next(err);. Si vous n'utilisez pas de moteur de visualisation, le code res.render générera une erreur.

Désolé, vous devrez également commenter cette ligne:

app.set('view engine', 'html');

Ma solution aurait pour résultat de ne pas utiliser un moteur de visualisation. Vous n'avez pas besoin d'un moteur de visualisation, mais si c'est le but, essayez ceci:

app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');
//swap jade for ejs etc

Vous aurez également besoin des lignes res.render lorsque vous utilisez un moteur de visualisation. Quelque chose comme ça:

// error handlers
// development error handler
// will print stacktrace
if (app.get('env') === 'development') {
  app.use(function(err, req, res, next) {
    res.status(err.status || 500);
    res.render('error', {
    message: err.message,
    error: err
    });
  });
}
// production error handler
// no stacktraces leaked to user
app.use(function(err, req, res, next) {
  res.status(err.status || 500);
  next(err);
  res.render('error', {
  message: err.message,
  error: {}
  });
});

Answer 4

Si vous souhaitez rendre un fichier html, utilisez

response.sendfile('index.html');

alors vous retirez du

app.set('view engine', 'html');

la seule chose est de mettre votre index.html dans les vues. ou rendre le dossier public statique et mettre le fichier index.html en public

Answer 5

définir le moteur de vue de manière suivante

app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

Answer 6

Si tout ce dont vous avez besoin est d’envoyer du code HTML en ligne dans le code, nous pouvons utiliser ci-dessous

var app = express();
app.get('/test.html', function (req, res) {
   res.header('Content-Type', 'text/html').send("<html>my html code</html>");
});

Answer 7

Les réponses ci-dessus sont correctes, mais j’ai trouvé qu’une simple faute de frappe pouvait également générer cette erreur. Par exemple, j'avais var routeur = express () au lieu de var routeur = express.Router () et j'ai eu cette erreur. Donc, il devrait être le suivant:

// App.js 
var express = require('express');
var app = express();
var bodyParser = require('body-parser');
app.use(bodyParser.urlencoded({ extended:false}));
// assuming you put views folder in the same directory as app.js
app.set('views', __dirname + '/views')
app.engine('ejs', ejs.renderFile);
app.set('view engine', 'ejs');
// router - wherever you put it, could be in app.js
var router = express.Router();
router.get('/', function (req,res) {
  res.render('/index.ejs');
})

Answer 8

Je viens de recevoir ce message d'erreur et le problème était que je ne configurais pas correctement mon middleware.

Je construis un blog dans la pile MEAN et une analyse syntaxique du corps requise pour les fichiers . Jade que j'utilisais le côté avant. Voici l'extrait de code de mon fichier "/middleware/index.js " de mon projet.

var express = require('express');
var morgan = require('morgan');
var session = require('express-session');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');

module.exports = function (app) {
app.use(morgan('dev'));

// Good for now
// In the future, use connect-mongo or similar
// for persistant sessions
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({
    extended: true
}));
app.use(cookieParser());
app.use(session({secret: 'building a blog', saveUninitialized: true, resave: true}));

De plus, voici mon fichier " package.json ", vous utilisez peut-être différentes versions de technologies. Note: comme je ne suis pas sûr des dépendances entre eux, j'inclus tout le fichier ici:

"dependencies": {
    "body-parser": "1.12.3",
    "consolidate": "0.12.1",
    "cookie-parser": "1.3.4",
    "crypto": "0.0.3",
    "debug": "2.1.1",
    "express": "4.12.2",
    "express-mongoose": "0.1.0",
    "express-session": "1.11.1",
    "jade": "1.9.2",
    "method-override": "2.3.2",
    "mongodb": "2.0.28",
    "mongoose": "4.0.2",
    "morgan": "1.5.1",
    "request": "2.55.0",
    "serve-favicon": "2.2.0",
    "swig": "1.4.2"
  }

J'espère que ça aide quelqu'un! Bonne chance!

Answer 9

Vous pouvez utiliser express-error-handler pour utiliser des pages HTML statiques pour la gestion des erreurs et éviter de définir un gestionnaire de vues.

L'erreur a probablement été causée par un 404, peut-être un favicon manquant (si vous aviez inclus le message de la console précédent). Le "gestionnaire de vues" de "html" ne semble pas être valide dans 4.x express.

Quelle que soit la cause, vous pouvez éviter de définir un gestionnaire de vue (valide) tant que vous modifiez des éléments supplémentaires de votre configuration.

Vos options sont de résoudre ce problème sont les suivantes:

• Définir un gestionnaire de vues valide comme dans d'autres réponses
• Utilisez send () au lieu de render pour renvoyer le contenu directement

http://expressjs.com/en/api.html#res.render

Utiliser render sans chemin de fichier appelle automatiquement un gestionnaire de vues comme avec les deux lignes suivantes de votre configuration:

res.render('404', { url: req.url });

et:

res.render('500);

Assurez-vous d’installer Express-Error-Handler avec:

npm install --save express-error-handler

Puis importez-le dans votre app.js

var ErrorHandler = require('express-error-handler');

Puis changez votre traitement des erreurs pour utiliser:

// define below all other routes
var errorHandler = ErrorHandler({
  static: {
    '404': 'error.html' // put this file in your Public folder
    '500': 'error.html' // ditto
});

// any unresolved requests will 404
app.use(function(req,res,next) {
  var err = new Error('Not Found');
  err.status(404);
  next(err);
}

app.use(errorHandler);