Wilt u glashelder worden over de structuur van de NodeJS-app (volledige JavaScript-stack)

Oké, dit is een vrij brede vraag en ik ben zeker geen expert, maar ik zal hier mijn best doen.

TL;DR

routes zijn controllers die vertellen welke logica moet worden uitgevoerd wanneer een gebruiker zijn browser naar een bepaald pad binnen uw app navigeert, inclusief welke weergaven moeten worden weergegeven en welke gegevens naar die weergaven moeten worden verzonden
models zijn precies dat - datamodellen binnen uw applicatie
module.exports = vertelt een bestand wat het precies "exporteert", dat is welke code moet worden uitgevoerd of toegankelijk is vanuit uw hoofdapp-bestand.
require(..) bevat een module. Je kunt dit op een variabele zetten zodat je later modulefuncties kunt aanroepen, of gewoon een functie uitvoeren als dat alles is module.exports geeft terug.

Door deze technieken te combineren, kunt u een solide raamwerk voor al uw toepassingen vaststellen.

Lang antwoord

Express biedt een solide raamwerk voor het structureren van uw Node.js-toepassing. Node is volledig onafhankelijk van Express, maar vanwege de populariteit van Express gaan ze praktisch hand in hand. Eenmaal geïnstalleerd, kan Express worden gebruikt om een scaffold-webproject (met opties) te genereren waarop u desgewenst kunt bouwen.

Controllers

Een gegenereerd project maakt /routes/index.js , die (als je MVC begrijpt) in wezen je belangrijkste controller is . Een route in express wordt als volgt geschreven:

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

Laten we dat opsplitsen:onze applicatievariabele (app) wordt verteld dat op een GET-verzoek naar '/path' om een anonieme callback-functie uit te voeren met req, res, next variabelen (respectievelijk verzoek, antwoord, terugbellen). Ik vind het handig om dit te zien als een aangepaste gebeurtenishandler.

Het is belangrijk op te merken dat we op dit punt ook app.post . kunnen bellen met dezelfde syntaxis voor berichten naar een URL in tegenstelling tot get.

Binnen onze anonieme callback behandelen we alle inkomende gegevens en geven we een weergave voor de gebruiker. Dit is waar de meeste van mijn bedrijfslogica terechtkomt, dus het is eigenlijk logisch om hier GEEN anonieme functies te gebruiken. Hier is een voorbeeld van een eenvoudige callback die alleen een startpagina weergeeft:

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

    //some business logic

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

Wanneer de gebruiker het indexpad van onze applicatie probeert te KRIJGEN (/ ), renderen we gewoon onze home weergave die, vanuit de root van ons project, wordt opgeslagen in een views map.

Maar wat als we dit willen modulair maken, zodat we niet al onze routes in onze hoofd app.js declareren? of server.js ?

We gebruiken module.exports = .. in onze modules om onze server te vertellen wat er precies moet worden opgenomen. In mijn controller exporteer ik een enkele functie die de toepassing als argument neemt en die gebruikt om onze routes als volgt te definiëren:

Controllers/Gebruiker.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});
        }
    });

};

Maak je geen zorgen over de req.db code, voeg ik de database toe aan het verzoek in mijn toepassing, maar dat wordt niet standaard gedaan. Begrijp gewoon dat ik hier een lijst met 'gebruikers' krijg en de gebruiker doorverwijs naar de index van mijn app als die er niet is.

Modellen

Mongoose biedt ons een geweldige interface voor het schrijven van modellen. Bij mangoest is het schrijven van modellen een proces van drie stappen:

Definieer een schema
Definieer modellogica
Genereer en exporteer het model

Hier is een voorbeeld van een User model:

Modellen/Gebruiker.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;

Server-app

module.exports wordt gebruikt om ons te helpen bij het definiëren van enige modulariteit in onze codebase. Wanneer we een knooppunttoepassing uitvoeren, voeren we uiteindelijk één JavaScript-bestand uit (u hebt dat bestand al gezien met server.js of app.js ).

Om te voorkomen dat dit bestand te groot wordt bij meerdere modellen en routes, gebruiken we require(module) om code uit andere JS-bestanden op te nemen. module in ons geval zou dit een pad zijn naar de module die we willen vereisen. Als u de volgende documentstructuur heeft:

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

Om uw gebruikerscontroller op te nemen van app.js , zou je schrijven:require('./Controllers/User') . Omdat onze controllermodules gewoon functies exporteren, kunnen we die functie direct na onze instructie 'vereiste' aanroepen door simpelweg haakjes aan het einde toe te voegen (met welke parameters dan ook). Inclusief mijn controllers ziet er als volgt uit:

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

Ik geef de eigenlijke app door, omdat mijn module (hieronder) eenvoudig een functie exporteert die bedrijfslogica toevoegt aan de routes van mijn app. Dit hoeft alleen te worden aangeroepen en nooit te worden gebruikt, dus ik sla mijn controller niet op als een variabele om later methoden aan te roepen.

Het opnemen van modellen is een beetje anders, omdat we misschien een bewerking willen uitvoeren die ons model definieert. We kunnen dit doen door onze vereiste code een beetje aan te passen:

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

Nu kunnen we methoden van ons gebruikersmodel altijd aanroepen. Mongoose geeft ons gratis veel basisfunctionaliteit:

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

De bovenstaande functie zal al onze gebruikers vinden en vervolgens een anonieme functie uitvoeren met een mogelijke err (is null als er geen problemen zijn) en vervolgens een lijst van onze gebruikers in JSON-indeling. Best handig.

Door al deze concepten te combineren, maakt u een eenvoudige webtoepassing met Express en Node.js. Laat het me weten in de reacties als er iets is dat ik kan verduidelijken over hoe ik Express gebruik. Dit is zeer oppervlakkige kennis en ik raad aan om in de documentatie te duiken en naar plug-ins te kijken om de mogelijkheden van uw apps uit te breiden. Veel succes!