Ik ben bezig met het opzetten van een http-server met node.js en engine. Ik kom echter steeds problemen tegen waarvan ik weinig informatie heb over hoe ik ze kan oplossen. Ik zou graag wat hulp krijgen om dit op te lossen.
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)
Hieronder staat wat ik heb ingesteld om deze motor op te 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');
};
1, Autoriteit 100%
De res.Render-spullen gooien een foutmelding als u geen view-engine gebruikt.
Als u JON wilt serveren, vervang u de res.render('error', { error: err });lijnen in uw code met:
res.json({ error: err })
PS: Mensen hebben meestal ook een bericht in het geretourneerde object:
res.status(err.status || 500);
res.json({
message: err.message,
error: err
});
2, Autoriteit 79%
U mist de View Engine, gebruik bijvoorbeeld jade :
Wijzig uw
app.set('view engine', 'html');
met
app.set('view engine', 'jade');
Als u wilt, gebruik een HTML-vriendelijke syntaxisgebruik in plaats daarvan EJS
app.engine('html', require('ejs').renderFile);
app.set('view engine', 'html');
bewerken
Zoals u kunt lezen van View.js Express View Module
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);
}
Je moet een default enginehebben geïnstalleerd
Expresszoek standaard lay-outweergave op program.templatezoals u hieronder kunt lezen:
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;
}
});
en zoals je hieronder kunt lezen:
program.template = 'jade';
if (program.ejs) program.template = 'ejs';
if (program.jshtml) program.template = 'jshtml';
if (program.hogan) program.template = 'hjs';
de standaard weergave-engine is jade
Antwoord 3, autoriteit 12%
Reageer op de res.renderregels in je code en voeg in plaats daarvan next(err);toe. Als je geen view-engine gebruikt, zullen de res.renderdingen een foutmelding geven.
Sorry, je moet ook reageren op deze regel:
app.set('view engine', 'html');
Mijn oplossing zou er echter toe leiden dat ik geen view-engine zou gebruiken. Je hebt geen view engine nodig, maar als dat het doel is, probeer dan dit:
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');
//swap jade for ejs etc
Je hebt de regels res.renderook nodig als je een view-engine gebruikt. Zoiets als dit:
// 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: {}
});
});
Antwoord 4, autoriteit 10%
Als je een html-bestand wilt renderen, gebruik dan:
response.sendfile('index.html');
Vervolgens verwijder je:
app.set('view engine', 'html');
Zet uw *.htmlin de viewsdirectory, of serveer een publicdirectory als statische dir en plaats de index.htmlin de publicmap.
Antwoord 5, autoriteit 4%
stel de weergave-engine op de volgende manier in
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');
Antwoord 6, autoriteit 3%
Als alles wat nodig is, is om html-code inline in de code te verzenden, kunnen we hieronder gebruiken
var app = express();
app.get('/test.html', function (req, res) {
res.header('Content-Type', 'text/html').send("<html>my html code</html>");
});
Antwoord 7, autoriteit 2%
Vervang a.u.b.
app.set('view engin', 'html');
met
app.set('view engine', 'ejs');
Antwoord 8
in plaats van
app.get('/', (req, res) => res.render('Hellooooo'))
gebruik
app.get('/', (req, res) => res.send('Hellooooo'))
Antwoord 9
De bovenstaande antwoorden zijn correct, maar ik ontdekte dat een simpele typefout deze fout ook kan veroorzaken. Ik had bijvoorbeeld var router = express() in plaats van var router = express.Router() en kreeg deze foutmelding. Het zou dus het volgende moeten zijn:
// 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');
})
10
Als je deze fout hebt gemaakt door de Express Generator te gebruiken, heb ik het opgelost door
te gebruiken
express --view=ejs myapp
in plaats van
express --view=pug myapp
Antwoord 11
U kunt express-error-handler gebruiken om statische html-pagina’s te gebruiken voor foutafhandeling en om te voorkomen dat u een view-handler moet definiëren.
De fout werd waarschijnlijk veroorzaakt door een 404, misschien een ontbrekend favicon (schijnbaar als je het vorige consolebericht had toegevoegd). De ‘view handler’ van ‘html’ lijkt niet geldig te zijn in 4.x express.
Ongeacht de oorzaak, u kunt voorkomen dat u een (geldige) view-handler definieert zolang u aanvullende elementen van uw configuratie wijzigt.
Uw opties om dit probleem op te lossen zijn:
- Definieer een geldige weergave-handler zoals in andere antwoorden
- Gebruik send() in plaats van render om de inhoud direct terug te sturen
http://expressjs.com/en/api.html#res.render
Als u render zonder bestandspad gebruikt, wordt automatisch een view-handler aangeroepen, zoals bij de volgende twee regels uit uw configuratie:
res.render('404', { url: req.url });
en:
res.render('500);
Zorg ervoor dat u express-error-handler installeert met:
npm install --save express-error-handler
Importeer het vervolgens in uw app.js
var ErrorHandler = require('express-error-handler');
Verander dan uw foutafhandeling in:
// 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);
Antwoord 12
Stel gewoon view engine in je code in.
var app = express();
app.set('view engine', 'ejs');
Antwoord 13
Fout: er is geen standaardengine opgegeven en er is geen extensie opgegeven
Ik heb hetzelfde probleem (voor het doen van een gemiddeld stapelproject). Het probleem is dat ik het formaat niet heb genoemd om npm te installeren, d.w.z.; pug of jade,ejs etc. dus om dit op te lossen ga naar npm en voer express –view=pug mapnaam in. Dit zal de nodige pug-bestanden (index.pug,layout.pug enz..) in de opgegeven map laden.