Fehler: Es wurde keine Standard-Engine angegeben und keine Erweiterung bereitgestellt

Ich arbeite daran, einen http-Server mit node.js und engine einzurichten. Ich stoße jedoch immer wieder auf Probleme, bei denen ich nur wenige Informationen zur Lösung habe. Ich würde mich über Hilfe bei der Lösung dieses Problems freuen.

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)

Unten ist, was ich eingerichtet habe, um diesen Motor zu starten.

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

Das res.render-Zeug löst einen Fehler aus, wenn Sie keine View-Engine verwenden.

Wenn Sie nur json bedienen möchten, ersetzen Sie die res.render('error', { error: err });Zeilen in Ihrem Code durch:

res.json({ error: err })

PS: Personen haben normalerweise auch eine Nachricht im zurückgegebenen Objekt:

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

Ihnen fehlt die View Engine, zum Beispiel verwenden Sie Jade :

ändere dein

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

mit

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

Wenn Sie eine HTML-freundliche Syntax verwenden möchten, verwenden Sie stattdessen ejs

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

BEARBEITEN

Wie Sie aus view.js Express View Module lesen können

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

Sie müssen a installiert haben default engine

ExpressSuchen Sie nach der Standardlayoutansicht, program.templatewie Sie unten lesen können:

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;

      }
    });

und wie Sie unten lesen können:

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

Die Standard-Ansichts-Engine ist jade

Kommentieren Sie die res.renderZeilen in Ihrem Code aus und fügen Sie sie next(err);stattdessen hinzu. Wenn Sie keine Ansichts-Engine verwenden, res.renderwird ein Fehler ausgegeben.

Entschuldigung, Sie müssen auch diese Zeile auskommentieren:

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

Meine Lösung würde jedoch dazu führen, dass keine View Engine verwendet wird. Sie benötigen keine Ansichts-Engine, aber wenn dies das Ziel ist, versuchen Sie Folgendes:

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

Sie benötigen die res.renderLinien auch, wenn Sie eine Ansichts-Engine verwenden. Etwas wie das:

// 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: {}
  });
});

Wenn Sie eine HTML-Datei rendern möchten, verwenden Sie:

response.sendfile('index.html');

Dann entfernen Sie:

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

Legen Sie Ihre *.htmlin das viewsVerzeichnis oder dienen Sie einem publicVerzeichnis als statisches Verzeichnis und setzen Sie die index.htmlin das Verzeichnis public.

Stellen Sie die Ansichtsmaschine folgendermaßen ein

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

Wenn alles, was benötigt wird, ist, HTML-Code inline in den Code zu senden, können wir unten verwenden

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

Ich habe gerade diese Fehlermeldung erhalten und das Problem war, dass ich meine Middleware nicht richtig eingerichtet habe.

Ich baue ein Blog im MEAN- Stack auf und benötige Body-Parsing für die Jade- Dateien, die ich auf der Front-End-Seite verwendet habe. Hier ist der Codeausschnitt aus meiner Datei " /middleware/index.js " aus meinem Projekt.

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

Hier ist auch meine " package.json " -Datei. Möglicherweise verwenden Sie verschiedene Versionen von Technologien. Hinweis: Da ich mir der Abhängigkeiten zwischen ihnen nicht sicher bin, füge ich hier die gesamte Datei ein:

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

Hoffe das hilft jemandem! Alles Gute!

Die obigen Antworten sind richtig, aber ich habe festgestellt, dass ein einfacher Tippfehler auch diesen Fehler erzeugen kann. Zum Beispiel hatte ich var router = express () anstelle von var router = express.Router () und bekam diesen Fehler. Es sollte also folgendes sein:

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

Sie können den Express-Error-Handler verwenden, um statische HTML-Seiten für die Fehlerbehandlung zu verwenden und das Definieren eines View-Handlers zu vermeiden.

Der Fehler wurde wahrscheinlich durch einen 404 verursacht, möglicherweise ein fehlendes Favicon (offensichtlich, wenn Sie die vorherige Konsolenmeldung eingefügt haben). Der 'View Handler' von 'html' scheint in 4.x Express nicht gültig zu sein.

Unabhängig von der Ursache können Sie die Definition eines (gültigen) Ansichtshandlers vermeiden, solange Sie zusätzliche Elemente Ihrer Konfiguration ändern.

Sie haben folgende Möglichkeiten, um dieses Problem zu beheben:

• Definieren Sie einen gültigen View-Handler wie in anderen Antworten
• Verwenden Sie send () anstelle von render, um den Inhalt direkt zurückzugeben

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

Wenn Sie Rendern ohne Dateipfad verwenden, wird automatisch ein Ansichtshandler aufgerufen, wie in den folgenden zwei Zeilen Ihrer Konfiguration:

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

und:

res.render('500);

Stellen Sie sicher, dass Sie den Express-Error-Handler installieren mit:

npm install --save express-error-handler

Importieren Sie es dann in Ihre app.js.

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

Ändern Sie dann Ihre Fehlerbehandlung, um Folgendes zu verwenden:

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

Stellen Sie einfach die View Engine in Ihren Code ein.

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

Fehler: Es wurde keine Standard-Engine angegeben und keine Erweiterung bereitgestellt

Ich habe das gleiche Problem (für ein Mean-Stack-Projekt). Das Problem ist, dass ich das Format für die Installation von npm nicht erwähnt habe, dh; Mops oder Jade, EJS usw. Um dies zu lösen, gehen Sie zu npm und geben Sie express --view = Mops Ordnername ein. Dadurch werden die erforderlichen Mops-Dateien (index.pug, layout.pug usw.) in den angegebenen Ordner geladen.

Wenn Sie diesen Fehler mithilfe des Express-Generators haben, habe ich ihn mithilfe von behoben

express --view=ejs myapp

anstatt

express --view=pug myapp