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

Je travaille sur la mise en place d'un serveur http à l'aide de node.js et du moteur. Cependant, je continue de rencontrer des problèmes que j'ai peu d'informations sur la façon de résoudre. J'apprécierais de l'aide pour résoudre ce problème.

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)

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

Le contenu de res.render générera une erreur si vous n'utilisez pas de moteur de vue.

Si vous souhaitez simplement servir json, remplacez les res.render('error', { error: err });lignes de votre code par:

res.json({ error: err })

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

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

Il vous manque le moteur de vue, par exemple utilisez jade :

change ton

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

avec

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

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

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

ÉDITER

Comme vous pouvez le lire à partir du module de vue express view.js

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

Expressrecherchez la mise en page par défaut program.templatecomme 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 visualisation par défaut est jade

Commentez les res.renderlignes de votre code et ajoutez-les à la next(err);place. Si vous n'utilisez pas de moteur de visualisation, le res.rendercontenu générera une erreur.

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

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

Ma solution aurait pour conséquence de ne pas utiliser de moteur de visualisation. Vous n'avez pas besoin d'un moteur de visualisation, mais si tel est l'objectif, essayez ceci:

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

Vous aurez également besoin des res.renderlignes lors de l'utilisation d'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: {}
  });
});

Si vous souhaitez rendre un fichier html, utilisez:

response.sendfile('index.html');

Ensuite, vous supprimez:

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

Mettez votre *.htmldans le viewsrépertoire, ou servez un publicrépertoire en tant que répertoire statique et mettez le index.htmldans le répertoire public.

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

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

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

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 j'avais besoin d'une analyse du corps pour les fichiers .jade que j'utilisais sur le côté frontal. 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}));

Aussi, voici mon fichier " package.json ", vous utilisez peut-être différentes versions de technologies. Remarque: parce que je ne suis pas sûr des dépendances entre eux, j'inclus le fichier entier 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 cela aide quelqu'un! Bonne chance!

Les réponses ci-dessus sont correctes, mais j'ai trouvé qu'une simple faute de frappe peut également générer cette erreur. Par exemple, j'avais var router = express () au lieu de var router = express.Router () et j'ai obtenu cette erreur. Cela devrait donc ê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');
})

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

L'erreur a probablement été causée par un 404, peut-être un favicon manquant (apparent si vous aviez inclus le message de console précédent). Le «gestionnaire de vue» 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 pour résoudre ce problème sont:

• Définissez un gestionnaire de vue valide comme dans les autres réponses
• Utilisez send () au lieu de render pour renvoyer directement le contenu

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

L'utilisation de render sans chemin de fichier appelle automatiquement un gestionnaire de vue 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');

Modifiez ensuite votre gestion 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);

Définissez simplement le moteur de vue dans votre code.

var app = express(); 
app.set('view engine', 'ejs');

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

J'ai eu le même problème (pour faire un projet de pile moyenne) .. le problème est que je n'ai pas mentionné le formate pour installer npm ie; pug ou jade, ejs etc. donc pour résoudre ce goto npm et entrez express --view = pug nomdossier. Cela chargera les fichiers pug nécessaires (index.pug, layout.pug etc.) dans votre dossier donné.

si vous avez cette erreur en utilisant le générateur express, je l'ai résolue en utilisant

express --view=ejs myapp

au lieu de

express --view=pug myapp