Wat doet res.renderen hoe ziet het html-bestand eruit?
Mijn einddoel is om willekeurige door komma’s gescheiden waarden uit een tekstbestand in een html-bestand te laden (bijvoorbeeld). Ik kon alleen afleiden dat een weergave het html-bestand was, en callback geeft dat html-bestand terug.
Hier is de documentatie: http://expressjs.com/api.html#res.render.
Gegeven de context van een voorbeeldcode die ik heb gevonden, is er iets aan de hand met het gebruik van ejs(ingesloten javascript) met <%en %>.
Maar als ik mag toevoegen, ben ik gewoon incompetent of is de documentatie echt heel vaag en gaat ervan uit dat de lezer alles weet? Hoe had ik dit zelf kunnen bedenken? Is er officiële documentatie zodat ik volledig inzicht kan krijgen in het gebruik, de voordelen en valkuilen?
Bewerk 1
Ik wil er alleen aan toevoegen dat ik het ontzettend naar mijn zin heb om node.jste leren.
Ligt het aan mij of is de algemene documentatie erg vaag? Afgezien van slechte uitleg zoals hierboven, zijn er geen typespecificaties voor parameters of retourwaarden.
Bewerk 2
Laat me je wat meer specifieke vragen stellen boven de code.
Het eigenlijke bestand orders.ejsbevindt zich in views/orders.ejs. Hoe verwijst deze code ernaar?
HTML-fragment:
<tbody>
<% for(var i=0; i<orders.length; i++) {%>
<tr>
<td><%= orders[i].id %></td>
<td><%= orders[i].amount %></td>
<td><%= orders[i].time %></td>
</tr>
<% } %>
en de JS. Zie / Orders:
// Define routes for simple SSJS web app.
// Writes Coinbase orders to database.
var async = require('async')
, express = require('express')
, fs = require('fs')
, http = require('http')
, https = require('https')
, db = require('./models');
var app = express();
app.set('views', __dirname + '/views');
app.set('view engine', 'ejs');
app.set('port', process.env.PORT || 8080);
// Render homepage (note trailing slash): example.com/
app.get('/', function(request, response) {
var data = fs.readFileSync('index.html').toString();
response.send(data);
});
// Render example.com/orders
app.get('/orders', function(request, response) {
global.db.Order.findAll().success(function(orders) {
var orders_json = [];
orders.forEach(function(order) {
orders_json.push({id: order.coinbase_id, amount: order.amount, time: order.time});
});
// Uses views/orders.ejs
response.render("orders", {orders: orders_json});
}).error(function(err) {
console.log(err);
response.send("error retrieving orders");
});
});
// Hit this URL while on example.com/orders to refresh
app.get('/refresh_orders', function(request, response) {
https.get("https://coinbase.com/api/v1/orders?api_key=" + process.env.COINBASE_API_KEY, function(res) {
var body = '';
res.on('data', function(chunk) {body += chunk;});
res.on('end', function() {
try {
var orders_json = JSON.parse(body);
if (orders_json.error) {
response.send(orders_json.error);
return;
}
// add each order asynchronously
async.forEach(orders_json.orders, addOrder, function(err) {
if (err) {
console.log(err);
response.send("error adding orders");
} else {
// orders added successfully
response.redirect("/orders");
}
});
} catch (error) {
console.log(error);
response.send("error parsing json");
}
});
res.on('error', function(e) {
console.log(e);
response.send("error syncing orders");
});
});
});
// sync the database and start the server
db.sequelize.sync().complete(function(err) {
if (err) {
throw err;
} else {
http.createServer(app).listen(app.get('port'), function() {
console.log("Listening on " + app.get('port'));
});
}
});
// add order to the database if it doesn't already exist
var addOrder = function(order_obj, callback) {
var order = order_obj.order; // order json from coinbase
if (order.status != "completed") {
// only add completed orders
callback();
} else {
var Order = global.db.Order;
// find if order has already been added to our database
Order.find({where: {coinbase_id: order.id}}).success(function(order_instance) {
if (order_instance) {
// order already exists, do nothing
callback();
} else {
// build instance and save
var new_order_instance = Order.build({
coinbase_id: order.id,
amount: order.total_btc.cents / 100000000, // convert satoshis to BTC
time: order.created_at
});
new_order_instance.save().success(function() {
callback();
}).error(function(err) {
callback(err);
});
}
});
}
};
Antwoord 1, autoriteit 100%
Wat doet res.render en hoe ziet het html-bestand eruit?
res.render()functie compileert je sjabloon(gebruik geen ejs), voegt daar locals in en maakt html-uitvoer van die twee dingen.
Beantwoorden Bewerk 2deel.
// here you set that all templates are located in `/views` directory
app.set('views', __dirname + '/views');
// here you set that you're using `ejs` template engine, and the
// default extension is `ejs`
app.set('view engine', 'ejs');
// here you render `orders` template
response.render("orders", {orders: orders_json});
Het sjabloonpad is dus views/(eerste deel) + orders(tweede deel) + .ejs(derde deel) = == views/orders.ejs
Hoe dan ook, de documentatie van express.js is goed voor wat het doet. Het is een API-referentie, geen boek “hoe node.js te gebruiken”.
Antwoord 2, autoriteit 13%
Rendert een weergave en verzendt de weergegeven HTML-tekenreeks naar de client.
res.render('index');
Of
res.render('index', function(err, html) {
if(err) {...}
res.send(html);
});