Vill du bli kristallklar om NodeJS appstruktur (Full JavaScript Stack)

Okej, det här är en ganska bred fråga och jag är definitivt ingen expert, men jag ska göra mitt bästa här.

TL;DR

routes är kontroller som talar om vilken logik som ska köras när en användare navigerar sin webbläsare till en viss sökväg i din app, inklusive vilka vyer som ska renderas och vilken data som ska skickas till dessa vyer
models är just det - datamodeller i din applikation
module.exports = talar om för en fil exakt vad den "exporterar", det är vilken kod som behöver köras eller nås från din huvudappfil.
require(..) innehåller en modul. Du kan ställa in detta på en variabel så att du kan anropa modulfunktioner senare, eller helt enkelt köra en funktion om det är allt som module.exports returnerar.

Genom att kombinera dessa tekniker kan du få en solid ram för alla dina applikationer.

Långt svar

Express ger en solid ram för att strukturera din Node.js-applikation. Node är helt oberoende av Express, men på grund av hur populär Express är går de praktiskt taget hand i hand. När det väl har installerats kan Express användas för att skapa ett ställningswebbprojekt (med tillval) som du kan bygga ovanpå om du vill.

Kontroller

Ett genererat projekt skapar /routes/index.js , som (om du förstår MVC) i grunden är din huvudsakliga kontroller . En rutt i express skrivs som så:

app.get('/path', function(req, res, next){ .. } );

Låt oss bryta ner det:vår applikationsvariabel (app) får veta det på en GET-begäran till '/path' för att utföra en anonym återuppringningsfunktion med req, res, next variabler (request, response, callback). Jag tycker att det är användbart att tänka på detta som en anpassad händelsehanterare.

Det är viktigt att notera vid det här laget att vi också kan kalla app.post med samma syntax för inlägg till en URL i motsats till gets.

Inom vår anonyma återuppringning hanterar vi all inkommande data och gör en vy för användaren. Det är här det mesta av min affärslogik hamnar, så det är faktiskt vettigt att INTE använda anonyma funktioner här. Här är ett exempel på en grundläggande återuppringning som bara visar en hemsida:

app.get('/', function(req, res, next){

    //some business logic

    res.render('views/home');
});

När användaren försöker få indexsökvägen för vår applikation (/ ), renderar vi helt enkelt vårt home vy som, från roten av vårt projekt, lagras i en views mapp.

Men tänk om vi vill modularisera detta så att vi inte deklarerar alla våra rutter i vår huvudsakliga app.js eller server.js ?

Vi använder module.exports = .. i våra moduler för att tala om för vår server exakt vad som ska inkluderas. I min kontroller exporterar jag en enda funktion som tar applikationen som ett argument och använder det för att definiera våra rutter så här:

Kontroller/User.js

 module.exports = function(app){

    app.get('/users', function(req, res){
        var users = req.db.collection('users').find();
        if (!users) {
            console.log("no users found");
            res.redirect('/');
        } else {
            res.render('users/index', {users : users});
        }
    });

};

Oroa dig inte för req.db kod, bifogar jag databasen till begäran i min ansökan men det görs inte som standard. Förstå helt enkelt att jag får en lista över "användare" här och omdirigerar användaren till indexet för min app om det inte finns några.

Modeller

Mongoose ger oss ett bra gränssnitt för att skriva modeller. Med mongoose är skrivandet av modeller en process i tre steg:

Definiera ett schema
Definiera modelllogik
Generera och exportera modellen

Här är ett exempel på en User modell:

Modeller/User.js

var mongoose = require('mongoose'),
    userSchema = new mongoose.Schema({

        name: { type: String, required: true },
        joinDate: {type: Date, default: date.now }

    }),
    User = mongoose.model('user', userSchema);

module.exports = user;

Serverapp

module.exports används för att hjälpa oss att definiera en viss modularitet till vår kodbas. När vi kör en nodapplikation kör vi i slutändan en enda JavaScript-fil (du har redan sett den filen med server.js eller app.js ).

För att den här filen inte ska bli för stor med flera modeller och rutter använder vi require(module) för att inkludera kod från andra JS-filer. module i vårt fall skulle det vara en väg till den modul vi vill kräva. Om du har följande dokumentstruktur:

| Controllers
    - User.js
| Models
    - User.js
| Views
app.js

För att inkludera din användarkontroll från app.js , skulle du skriva:require('./Controllers/User') . Eftersom våra styrmoduler helt enkelt exporterar funktioner kan vi anropa den funktionen direkt efter vår require-sats genom att helt enkelt lägga till parenteser i slutet (med vilka parametrar som krävs). Att inkludera mina kontroller ser ut så här:

require('./Controllers/User')(app)

Jag passerar in själva appen, eftersom min modul (nedan) helt enkelt exporterar en funktion som lägger till affärslogik till min apps rutter. Detta behöver bara anropas och aldrig användas, så jag fångar inte min styrenhet som en variabel för att anropa metoder på senare.

Att inkludera modeller är lite annorlunda, eftersom vi kanske vill utföra någon operation som vår modell definierar. Vi kan göra detta genom att ändra vår kravkod lite:

var User = require('./Models/User');

Nu kan vi anropa metoder för vår användarmodell när som helst. Mongoose ger oss massor av basfunktioner gratis:

User.find({}, function(err, users){ .. });

Ovanstående funktion kommer att hitta alla våra användare och sedan köra en anonym funktion med ett potentiellt err (är null om inga problem) och sedan en lista över våra användare i JSON-format. Ganska snyggt.

Genom att kombinera alla dessa koncept skapar du en grundläggande webbapplikation med Express och Node.js. Låt mig veta i kommentarerna om det är något jag kan förtydliga om hur jag använder Express. Det här är kunskap på mycket ytnivå, och jag föreslår att du gräver i dokumentationen och tittar på plugins för att utöka kapaciteten för dina appar. Lycka till!