Chcesz uzyskać krystalicznie jasne informacje o strukturze aplikacji NodeJS (Pełny stos JavaScript)

W porządku, to dość szerokie pytanie i zdecydowanie nie jestem ekspertem, ale zrobię co w mojej mocy.

TL;DR

• routes to kontrolery, które informują, jaką logikę wykonać, gdy użytkownik nawiguje w przeglądarce do określonej ścieżki w Twojej aplikacji, w tym, które widoki renderować i jakie dane przesłać do tych widoków
• models są tylko tym - modele danych w Twojej aplikacji
• module.exports = mówi plikowi, co dokładnie „eksportuje”, czyli jaki kod musi być wykonany lub dostępny z głównego pliku aplikacji.
• require(..) zawiera moduł. Możesz ustawić to na zmiennej, aby móc później wywoływać funkcje modułu lub po prostu wykonać funkcję, jeśli to wszystko module.exports zwroty.

Połączenie tych technik może pomóc w zbudowaniu solidnej struktury dla dowolnej aplikacji.

Długa odpowiedź

Ekspres zapewnia solidną strukturę do strukturyzacji aplikacji Node.js. Node jest całkowicie niezależny od Express, ale ze względu na popularność Expressu praktycznie idą w parze. Po zainstalowaniu Express można użyć do wygenerowania projektu sieci szkieletowej (z opcjami), na którym można zbudować, jeśli chcesz.

Kontrolery

Wygenerowany projekt utworzy /routes/index.js , który (jeśli rozumiesz MVC) jest zasadniczo Twoim głównym kontrolerem . Trasa w ekspresie jest napisana w następujący sposób:

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

Rozłóżmy to:nasza zmienna aplikacji (app) otrzymuje informację, że w żądaniu GET do '/path' do wykonania anonimowej funkcji zwrotnej z req, res, next zmienne (odpowiednio żądanie, odpowiedź, wywołanie zwrotne). Uważam, że pomocne jest myślenie o tym jak o niestandardowej obsłudze zdarzeń.

Należy w tym miejscu zauważyć, że możemy również wywołać app.post z tą samą składnią dla postów na adres URL, a nie pobiera.

W ramach naszego anonimowego wywołania zwrotnego obsługujemy wszelkie przychodzące dane i renderujemy widok dla użytkownika. W tym miejscu kończy się większość mojej logiki biznesowej, więc faktycznie ma sens NIE używać tutaj funkcji anonimowych. Oto przykład podstawowego wywołania zwrotnego, które wyświetla tylko stronę główną:

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

    //some business logic

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

Gdy użytkownik próbuje UZYSKAĆ ​​ścieżkę indeksu naszej aplikacji (/ ), po prostu renderujemy nasz home widok, który z katalogu głównego naszego projektu jest przechowywany w views teczka.

Ale co, jeśli chcemy zmodularyzować to tak, abyśmy nie deklarowali wszystkich naszych tras w naszym głównym app.js lub server.js ?

Używamy module.exports = .. w naszych modułach, aby powiedzieć naszemu serwerowi, co dokładnie ma uwzględnić. W moim kontrolerze eksportuję pojedynczą funkcję, która przyjmuje aplikację jako argument i używa jej do definiowania naszych tras w następujący sposób:

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

};

Nie martw się o req.db kod, dołączam bazę danych do żądania w mojej aplikacji, ale nie jest to domyślnie robione. Po prostu zrozum, że otrzymuję tutaj listę „użytkowników” i przekierowuję użytkownika do indeksu mojej aplikacji, jeśli go nie ma.

Modele

Mongoose zapewnia nam świetny interfejs do pisania modeli. W przypadku mangusty pisanie modeli to trzyetapowy proces:

• Zdefiniuj schemat
• Zdefiniuj logikę modelu
• Generuj i eksportuj model

Oto przykład User model:

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

Aplikacja serwerowa

module.exports jest używany, aby pomóc nam zdefiniować modułowość naszego kodu. Kiedy uruchamiamy aplikację węzła, ostatecznie uruchamiamy pojedynczy plik JavaScript (znałeś już ten plik z server.js lub app.js ).

Aby ten plik nie stał się zbyt duży przy wielu modelach i trasach, używamy require(module) dołączyć kod z innych plików JS. module w naszym przypadku byłaby to ścieżka do modułu, którego chcemy wymagać. Jeśli masz następującą strukturę dokumentów:

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

Aby dołączyć kontroler użytkownika z app.js , napisałbyś:require('./Controllers/User') . Ponieważ nasze moduły kontrolerów po prostu eksportują funkcje, możemy wywołać tę funkcję natychmiast po naszej instrukcji require, dodając po prostu nawiasy na końcu (z dowolnymi wymaganymi parametrami). Łącznie z moimi kontrolerami wygląda tak:

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

Przechodzę w rzeczywistej aplikacji, ponieważ mój moduł (poniżej) po prostu eksportuje funkcję, która dodaje logikę biznesową do tras mojej aplikacji. Trzeba to tylko wywołać i nigdy nie używać, więc nie przechwytuję mojego kontrolera jako zmiennej do późniejszego wywoływania metod.

Uwzględnianie modeli jest nieco inne, ponieważ możemy chcieć wykonać jakąś operację, którą definiuje nasz model. Możemy to zrobić, zmieniając nieco nasz wymagany kod:

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

Teraz możemy wywoływać metody naszego modelu User w dowolnym momencie. Mongoose daje nam wiele podstawowych funkcji za darmo:

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

Powyższa funkcja znajdzie wszystkich naszych użytkowników, a następnie wykona anonimową funkcję z potencjalnym err (jest null, jeśli nie ma problemów), a następnie listę naszych użytkowników w formacie JSON. Całkiem fajnie.

Łącząc wszystkie te koncepcje, tworzysz podstawową aplikację internetową za pomocą Express i Node.js. Daj mi znać w komentarzach, jeśli jest coś, co mogę wyjaśnić na temat korzystania z Express. Jest to bardzo powierzchowna wiedza i sugeruję zagłębienie się w dokumentację i zapoznanie się z wtyczkami, aby rozszerzyć możliwości swoich aplikacji. Powodzenia!