müssen express.js controller oop Tipps

Ich bin Neuling in der web-Entwicklung entwickelt haben und ein web-server mit node und express. Ich habe verwendet, MVC-Muster, mit Modellen, die sequelizejs Objekte. Aber, für meine Controller, dir wenig bis gar kein OOP aktuell und ich würde gerne wissen, einige OO-Schreibweise-Controller anstatt mit anonymen Funktionen, um Anfragen zu bedienen:

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

Vielleicht kann ich Objekte erstellen, für jede route über die URL und das Modell als Eigenschaften und Methoden, die HTTP-Verben:

//Use test.model for interacting with model
app.get(test.URL,test.get);
app.post(test.URL,test.post);
app.put(test.URL,test.put);
app.patch(test.URL,test.patch);
app.delete(test.URL,test.delete);

Aber, es sieht aus wie overkill, da die meisten/alle controller-Objekte, die auf diese Weise am Ende wird die singletons mit keine Vererbung, Polymorphie und Wiederverwendung.

Frage: gibt es eine bessere OO Art zu schreiben-Controller ?

InformationsquelleAutor user2103008 | 2013-09-05

Könnten Sie eine controller-Klasse, wo der Konstruktor einen express-Objekt, das einrichten von Routen für Sie. Dies ist ein Beispiel base Controller Klasse:

/**
 * @param connect can either be Sencha Labs' `connect` module, or
 */
function Controller(express) {
  var self = this;
  var name = '/' + this._name;
  express.post(name, function (req, res, next) {
    self._create(req, res, next);
  });
  express.get(name, function (req, res, next) {
    self._read(req, res, next);
  });
  express.put(name + '/:id', function (req, res, next) {
    self._update(req, res, next);
  });
  express.delete(name + '/:id', function (req, res, next) {
    self._delete(req, res, next);
  });
}

//Since there aren't any protected variables in JavaScript, use
//underscores to tell other programmers that `name` is protected. `name`
//(or, more technically, `_name`) is still accessible, but at least, if a
//team is disciplined enough, they'd know better than to access variables
//with underscores in them.
Controller.prototype._name = '';

Controller.prototype._create = function (req, res, next) {
};

Controller.prototype._read = function (req, res, next) {
};

Controller.protoype._update = function (req, res, next) {
};

Controller.prototype._delete = function (req, res, next) {
};

Und erstellen Sie dann eine Users controller, der sich von der Controller "class":

function UsersController(express) {
  Controller.call(this, express);
}

//This is not the most perfect way to implement inheritance in JavaScript,
//this is one of the many ways.
UsersController.prototype = Controller.prototype;

UsersController.prototype._name = 'users'

//An example override of the base `Controller#create` method.
UsersController.prototype._create = function (req, res, next) {
  db.save(req.body, function (err) {
    if (err) res.send(500, err.message);
    res.redirect('/');
  });
};

UsersController.prototype._read = function (req, res, next) {
  db.read(function (err, users) {
    if (err) res.send(500, err.message);
    res.send(users);
  });
};

Sobald Sie haben alle die entsprechenden Controller deklariert und definiert, können Sie mit der Umsetzung beginnen, die Sie dann auf Ihre ausdrückliche app.

//Initialize a new instance of your controller.
var usersController = new UsersController(app);

P. S.: Für die express-Aufrufe im Konstruktor, es ist ein weiterer Weg, um Ihre create, read, update, delete Strecken (und alle anderen Routen). Ich wollte einfach nicht, Sie zu verwirren zunächst.

function Controller(express) {
  var name = '/' + this._name;
  express.post(name, this._create.bind(this));
  express.get(name, this._read.bind(this));
  express.put([name , ':id'].join('/'), this._update.bind(this));
  express.delete([name, ':id'].join('/'), this._delete.bind(this));
};

Jede chance, die Sie hinzufügen könnte, ein Beispiel dafür, wie app übergeben wird, an den controller mit module.exports?

InformationsquelleAutor Sal

Ich geschrieben habe, ein einfaches Beispiel in Maschinenschrift, die zeigt, wie schreibt man einen controller für eine express-Anwendung, mit der objektorientierten Programmierung in den Sinn. Es kann leicht angewendet werden, um ES6:

Server.ts

import * as express from 'express';
import {CategoryController} from 'src/view/CategoryController';

export default class Server {
  public app: express.Application;

  constructor() {
    this.app = express();
    this.app.get('/', (request, response) => response.send('Root page without OOP.'));
    //Using a controller to serve a view
    this.app.use('/categories', CategoryController);
  }
}

CategoryController.ts

import {Router, Request, Response} from 'express';

const router: Router = Router();

router.get('/', (request: Request, response: Response): Response => {
  const payload: { [index: string]: string[] } = {categories: ['CSS', 'HTML', 'JavaScript', 'TypeScript']};
  return response.json(payload);
});

export const CategoryController: Router = router;

InformationsquelleAutor Benny Neugebauer

Nicht wirklich die Antwort, aber ich erstellt einen Knoten Modul-handle automatisch einrichten-express-Routen.
Dynamic-Routen

//app.js
require('dynamic-routes')(app, __dirname + '/routes/');

dann

//routes/index.js
module.exports = {
    priority: 1000, //this is the `/` handler, should it should be the last route.
    path: '/',

    //this function gets passed the express object one time for any extra setup
    init: function(app) { 
        app.head(function(req, res) {});
    },

    GET: function(req, res) {
        res.end('GET ');
    },

    POST: function(req, res) {
        res.json(req.data);
    }
};

InformationsquelleAutor OneOfOne

0

Einer Art und Weise zu organisieren express in eine OOP-Weise, ist die Verwendung eines bestehenden Rahmens, der das Gerüst für diese. sails.js ist die beliebteste MVC-framework für node heutzutage, und verwendet express.js für das routing.

InformationsquelleAutor Travis Webb

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.