what does this line of code in express.js mean? - javascript

Can someone explain in depth what does this line of code mean in NodeJS:
var app = module.exports = express.createServer();

express.createServer();
The above line has the instance of express and creates a server instance (server handle) and returns the whole export class.
With the above, you are setting both module.exports as well as app to do further.

It can be rewritten as:
module.exports = express.createServer();
var app = module.exports;

Related

wrong routing with koa-router in koa

I am learning Koa, with basic exercise, but i can´t achieve implement a simple routing, with the code that i got from this page, and this is what i did:
var koa = require('koa');
var router = require('koa-router'); //require it
var app = new koa();
var ro = router();
//and we'll set up 2 routes, for our index and about me pages
ro.get('/hello', getMessage);
function *getMessage() {
this.body = "Hello world!";
};
app.use(ro.routes());
app.listen(8008);
console.log('Koa listening on port 8008');
i did´t get any specific error, because the app run with the command node index.js, but i can see any print in the page that i routed.
and i only have 1 file in my folder myproyectoks, and it is index.js, and that's the file that i'm working.
any information that you need pls ask me :D, because i could be forgot something.
The example is out-of-date - Koa middleware is promise-based and generator functions will no longer work directly. The router documentation suggests the following form:
const Koa = require('koa')
const Router = require('#koa/router')
const router = new Router()
router.get(
'/hello',
ctx => ctx.body = 'Hello world!'
)
const app = new Koa()
app.use(router.routes())
app.listen(8008)
To note the other differences, the router module is a class that requires instantiation and the context is passed as an argument to the request handler.

Can someone explain how i can use module.exports this way

I am trying to understand what is going on when I use module.exports with a variable in a model view controller type project. I just do not understand what the book means by using it in this way
var express = require("./config/express.js");
var app = express();
app.listen(3000);
module.exports = app; // my problem is right here what is it doing
console.log("Server running at http://localhost:3000/");
my config/ express file is also here
var express = require("express");
module.exports = function()
{
var app = express();
require("../app/routes/index.server.routes.js")(app);
return app;
}
The first example is exporting the Express app directly and the second example is exporting a function that returns the Express app.
This means that in the first example, require(...) will return app. In the second example, you would need to do require(...)() to have app returned.

Achieve best performance when passing variables through different node.js modules/files

In a node application it's common that you start loading some modules like this:
var express = require('express')
, app = express()
, mongodb = require('mongodb')
, http = require('http');
Now, let's say you have a routes.js file which looks like this:
module.exports = function(app) {
app.get('/', function(req, res) {
res.render('homepage');
});
// other routes
};
So when you call that routes.js file, you pass the app var:
require('./routes')(app);
My question is: what is happening there? Is there resource consumption when passing the app variable to the routes module? I know that node.js caches modules, but I would like to know how that affects variables passed between them and I wonder if the following approach is efficient:
Let's start loading some modules, but let's do in a different way:
var _ = {};
_.express = require('express');
_.app = _.express();
_.mongodb = require('mongodb');
_.http = require('http');
Routes.js:
module.exports = function(_) {
_.app.get('/', function(req, res) {
res.render('homepage');
});
// other routes
};
Call to routes.js:
require('./routes')(_);
Obviously the _ variable will be a large one, but it will include anything you may need in any module. So I wonder if the size of the passed variable affects performance, in which case it would be just stupid to pass more data than needed.
I seek for achieving the best achievable performance in my applications while I try to simplify things when writing code, so any advice that may help with this, or any explanation about how this works behind the scenes in node.js will be appreciated.
Thanks in advance.
See here.
tl;dr: objects are passed by reference, not by value. So you are not expanding your memory consumption when you pass the same object multiple times to multiple modules.

Get access to Express mountpath from inside a module

In an attempt to build a truly modular express app (one that can run stand alone or as a part of another app) I need to find out the cleanest way to find the mount path from inside the subapp. For a short example, lets say that there are two files: main.js and subapp.js
main.js
var express = require('express');
var app = express();
var localApp = express();
var subapp = require('./subapp');
app.use('/foo', subapp);
app.use('/bar', localApp);
console.log(localApp.mountpath); // yes, this prints '/bar' as expected
...
subapp.js
var express = require('express');
var app = express();
var truePath = app.mountpath; // I wish this would point to '/foo', but instead points to '/'
...
module.exports = app;
What is the best way (as in cleanest) to find the mountpath from inside the module? I'm doing this trying to solve this problem: Access to mountpath variable from inside a template using express in a non hardwired way.
As shown in the example, tried already with app.mountpath without success
As answered by alsotang, this is actually a problem of execution sequence, but it can be solved in what I think is a clean way. There is an event that is fired after the module is mounted, so you can do:
var truePath = = "/";
app.on('mount', function (parent) {
truePath = app.mountpath;
});
Where in real life truePath could be app.locals.truePath, so it can be accessed from inside the views.
eh..It's a problem of execution sequence.
In your subapp.js, the app.mountpath statement is before module.exports = app.
But only you export the app, then the app be mounted, then it would be set the mountpath property.
so, you should retrieve mountpath after the app be mounted by outer express.
My suggestion are two:
set the mountpath in your subapp.js. And outer express read this property.
perhaps you think 1 is not truly modular. so you can alternatively define a config file. and both main.js and subapp.js read mountpath from the config.
Try req.baseUrl:
app.js
var express = require('express');
var app = express();
var foo = require('./foo');
app.use('/foo', foo);
app.listen(3000);
foo.js
var express = require('express');
var router = express.Router();
router.get('/', function(req, res) {
console.log(req.baseUrl); // '/foo'
res.send('foo');
});
module.exports = router;

var express = require('express'); var app = express(), What is express()?? is it a method or a constructor? Where does it come from

var express = require('express');
var app = express();
This is how we create an express application. But what is this 'express()'? Is it a method or a constructor? Where does it come from??
Is it a method or a constructor?
Neither; it's a function, although if you said "method" I don't think anyone would give you a hard time.
A method is a function attached to an object. In JavaScript, methods are just mostly functions that you reference via object properties. (Update: As of ES2015, if you use method syntax to create them, they're slightly more than that because they have access to super.)
A constructor, in JavaScript, is a function you call via the new operator. Even though other functions may create things, we don't typically call them "constructors" to avoid confusion. Sometimes they may be "creator" or "builder" functions.
Where does it come from?
ExpressJS is a NodeJS module; express is the name of the module, and also the name we typically give to the variable we use to refer to its main function in code such as what you quoted. NodeJS provides the require function, whose job is to load modules and give you access to their exports. (You don't have to call the variable express, you can do var foo = require('express'); and use foo instead, but convention is that you'd use the module's name, or if only using one part of a module, to use the name of that part as defined by the module's documentation.)
The default export of express is a bit unusual in that it's a function that also has properties on it that are also functions (methods). That's perfectly valid in JavaScript,¹ but fairly unusual in some other languages. That's why you can create an Application object via express(), but also use express.static(/*...*/) to set up serving static files.
¹ In fact, it's completely normal. Functions have a couple of standard methods by default: call, apply, and toString for instance.
You’ll use Node’s require function to use the express module. require is similar to keywords like import or include in other languages. require takes the name of a package as a string argument and returns a package. There’s nothing special about the object that’s returned—it’s often an object, but it could be a function or a string or a number.
var express = require('express');
=> Requires the Express module just as you require other modules and and puts it in a variable.
var app = express();
=> Calls the express function "express()" and puts new Express application inside the app variable (to start a new Express application).
It's something like you are creating an object of a class. Where "express()" is just like class and app is it's newly created object.
By looking the code of express below you are good to go what is really happening inside.
File 1: index.js
'use strict';
module.exports = require('./lib/express');
File 2 : lib/express.js
'use strict';
var EventEmitter = require('events').EventEmitter;
var mixin = require('merge-descriptors');
var proto = require('./application');
var Route = require('./router/route');
var Router = require('./router');
var req = require('./request');
var res = require('./response');
/**
* Expose `createApplication()`.
*/
exports = module.exports = createApplication;
function createApplication() {
var app = function(req, res, next) {
app.handle(req, res, next);
};
mixin(app, EventEmitter.prototype, false);
mixin(app, proto, false);
app.request = { __proto__: req, app: app };
app.response = { __proto__: res, app: app };
app.init();
return app;
}
exports.application = proto;
exports.request = req;
exports.response = res;
exports.Route = Route;
exports.Router = Router;
});
How require works
When you call require('some_module') in node here is what happens:
if a file called some_module.js exists in the current folder node will load that, otherwise:
Node looks in the current folder for a node_modules folder with a some_module folder in it.
If it doesn't find it, it will go up one folder and repeat step 2
This cycle repeats until node reaches the root folder of the filesystem, at which point it will then check any global module folders (e.g. /usr/local/node_modules on Mac OS) and if it still doesn't find some_module it will throw an exception.
Ancient post. I think the original poster was confused about why the syntax to call the function exported by module express is
var app = express()
instead of
var app = express.express()
To clarify: require() function does not create a reference to that 'module'. There's no such thing as reference to a module. There's only reference to thing(s) exported by a module.
require('xxx.js'), where the .js extension can be omitted, returns whatever is exported by that xxx.js file. If that xxx.js file exports an object, require('xxx.js') returns an object; if a function is exported, require('xxx.js') returns a function; if a single string is exported, require('xxx.js') returns a string...
If you check source code of file express.js, you will see that it exports a single function. So in
var express = require('express')
The first express is assigned whatever is exported by module express, which in this case happens to be a single function. express is a function, not a reference to a module. Hence on second row you just invoke that function:
var app = express()
Hope this helps!
let me answer this question by an example.
create 2 javascript files.
play1.js and express.js
//express.js
function createApplication(){
var app = 'app';
return app;
}
module.exports = createApplication;
//keep in mind that we are not doing module.exports = {createApplication}
now import express.js in play1.js file
//play1.js
var express = require('./express);
var app = express();
// this will call createApplication function as app is referencing to it.
console.log(app); // "app"
Whenever you import a module like
const express = require('express')
express is a module with functions or objects or variables assigned to it .
take a look at /lib/express
you are able to access the function createApplication inside express module as express() because the function is assigned directly to the module like
exports = module.exports = createApplication;
function createApplication(){
var app = function(req, res, next) {
app.handle(req, res, next);
};
//other codes
}
so you are able to access the function createApplication just calling express() as function
now when you check out the other section of the express library, you can see a bunch of other objects attached to the exports special object as well.
/**
* Expose the prototypes.
*/
exports.application = proto;
exports.request = req;
exports.response = res;
/**
* Expose constructors.
*/
exports.Route = Route;
exports.Router = Router;
// other exports
these objects or function assigned to export special object can be accessed from the import section using express as an object.
express.{name}
express.Route
express.Router etc
In the end you are just exporting a bunch of methods or objects that are attached to the module.export special object inside express js file
to read more on module.export special object go here
1- var express = require('express');
first line require the express package .js file, und "require" it's only returnd what was exported in the js file with (module.exports).
so we have only pointer to this function .
2- var app = express();
in second line, we use 'app' as pleaceholder to receive the output from express() function, which is an object, we can use it in our code (by accessing his methods and properties like any other Class )
in other words, we use the 'app' Object, which which produced from 'express()' function, that we imported from 'express.js' file .
NOTE 1) and of course we can give any name instead of 'app' , but it's a good practice when you follow what the most developers use to name this packages, that make easier to understand your code specialty when you work in team.
NOTE 2) after ES6, we use 'const' instead of 'var' .
Simple what we wrote in node js when we require a modules for our application
const modue_need1=require('module_name');
const modue_need2=require('module_name2');
const modue_need3=require('module_name3');
const modue_need4=require('module_name4');
const modue_need....=require('module_name.....');
So for every module, we need to write such a big code, and time-consuming now to reduce these lengthy codes and time slice what we do? We need node js Framework like Express js
which will overcome these problems mean "write less, do more"
we just use this two-line and all the requirement(modules) about our app will be their in-app object which we can use whenever we need so do not need to call require for every module.
"write less, do more"
const express=require('express');
const app=express();
console.log(app);

Categories

Resources