Develop Reference

where do module.exports export your function and what is the use of it when we still use require to import the code into your module

i Have written the following code in node.js
notes.js
console.log('notes app is running');
app.js
const notes = require('./notes.js');
console.log(notes);
When i import the code and run app.js output is shown as notes app is running
Now i updated the code for notes.js
console.log('notes app is running');
addNote = () =>{
console.log('addNote');
return 'New note';
} ;
Now i want to use the following arrow function in my code so updtaed my
app.js
const notes = require('./notes.js');
var res = notes.addNote();
console.log(res);
console.log(notes);
Now it is Throwing me error
notes.addNote is not a function
1) I know i should use module.exports.addNote
2) But i want to know why we can see a log which we have written in notes.js without using module.exports statment. why can't we use require statment and store total code and call the function from that varable as we do for a instance of a class
3)More preciously where do module.export export your code (i mean to which directrey )
4)Plese correct me if anything is wrong

(#1 and #4 don't need answers, so I've left them off.)
2) But i want to know why we can see a log which we have written in notes.js without using module.exports statment.
With Node.js's style of modules (which is a flavor of CommonJS), a module is loaded and executed when it's first required. Your console.log is in the module's code, so when you require it (the first time), that code gets run.
why can't we use require statment and store total code and call the function from that varable as we do for a instance of a class
You can, if that's what you want to do:
exports = {
// code here as object properties
addNote: () => {
console.log('addNote');
return 'New note';
}
};
and
const mod = require("./notes.js");
mode.addNote();
3)More preciously where do module.export export your code (i mean to which directrey )
To the module cache in memory.

Internally, node caches all modules. In order to do this, it starts at the entry point file (e.g. you app.js file) and recursively searches all require statements (or imports).
As node parses modules, any code at the top level of the file will execute - such as your console.log line
console.log('notes app is running');
However, note, that at this point nothing in the file has been exposed to any other part of your codebase. Instead, node takes any value that is exported via module.exports and adds it to an internal cache. This cache is keyed on the path to the file as appeared in the require statements (converted to an absolute path), so for example, the following require statements:
const module1 = require('../module1.js');
const module2 = require('../module2.js');
will result in cache entries which look like:
<path_to>/../module1.js = ... contents of module1.exports
<path_to>/../module2.js = ... contents of module2.exports
Any time you require one of those modules again, you will get the cached version of the modules, it will NOT re-parse the file. For your example, it means that not matter how many times you require the notes.js file, it will only print your console.log('notes app is running'); statement once.
Because of the way node loads modules in isolation, you can ONLY access the elements which are exported via module.exports. Which means any function you define in the file but do not export cannot be accessed.
So, to directly address your questions:
I know i should use module.exports.addNote
Yes. Though, not you can also assign a new object to module.exports, e.g module.exports = { addNote };
But i want to know why we can see a log which we have written in notes.js without using module.exports statment. why can't we use require statment and store total code and call the function from that varable as we do for a instance of a class
Because node parses all required files while generating it's cache
More preciously where do module.export export your code (i mean to which directrey )
They're not stored in a directory, but rather cached in memory based on the file name and contents of module.exports
Plese correct me if anything is wrong
guess this one doesn't need an answer

How to export an object with methods and properties

I have two js files in Electron (which uses Nodejs) and I try to export from one and require in another.
app.js:
App = {
server: {
host: '192.168.0.5',
user: 'root',
}
ping: function() {
}
}
exports.App = App
I have tried every way possible of exporting, including module.exports = App, module.exports.App = App and so on.
ping.js first attempt:
var App = require('../app.js') // I have also tried adding .App to the end
console.log(App) // This returns an object which contains the App object
ping.js second attempt:
var App = require('../app.js')
App.x = 'y'
console.log(App) // this returns an object which contains the App object and the x property
It may appear that App contains another App object, but console.log(App.App) says it doesn't exist.

The first thing I'd to do solve this would be to make sure I'm using the full path to the required module, as in:
const Path = require('path')
const App = require(Path.join(__dirname,'../app')) // the .js isn't needed here.
Note that this assumes that the app.js file is in the immediate parent directory of the one in which the application runs.
If that doesn't work, I'd make sure the files are where you think they are, and that the process you're running is located within the file system where you think it is. You can determine this by adding this to the top of your main script file:
console.log("current working directory:",process.cwd())
Or in es6:
console.log(`current working directory: %s`, process.cwd())
If the printed directory doesn't match your assumptions, modify your require statement accordingly.
And for the record, the "correct" way to export your App map would be to:
const App = {
...
}
module.exports = App
Or using es7:
export default App = {
...
}
(See export for more on es7 modules.)
Either way, you'd then require the module as:
const App = require(PATH_TO_APP)

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);

How to make object references available in Node modules?

I have an Express.js web app. In the main app.js file, I require() a bunch of third party dependencies. Recently I've started extracting parts of my app.js code into separate modules, e.g.
// in app.js
var users = require('./modules/users');
// and then e.g.
// users.add(doc);
Inside my modules, I sometimes need to use objects that are available in my main app.js file and I'm wondering what's the best way to pass references to those object to my modules.
My current approach:
// in app.js
// pass needed object references in initialization step
users.init([db, logger]);
and
// in modules/users.js
var db, logger;
exports.init = function (deps) {
db = deps[0];
logger = deps[1];
};
Does this approach make sense? Is there a better way to perform this?

Sure, just use modules! :)
// db.js
// create db instance here rather than in app.js
module.exports = db;
And
// logger.js
// create logger instance here rather than in app.js
module.exports = logger;
Then
// app.js
var db = require('./db');
And
// lib/somewhere.js
var db = require('../db');
This way you're able to rely on the CommonJS dependency injection system rather than on doing the dependency injection all by yourself (passing references around instead of requireing a module into yours).
The reason why this works as expected is that modules are only interpreted once, so if you instantiate everything once as opposed to using a factory function, it just works.

You should just be able to require modules as normal:
// users.js
var db = require('./db');
exports.init = function() {
// use db in here
};
However, sometimes this isn't possible and you will need to explicitly pass in the module.
One way to do it is to pass in dependencies when you require the module:
// users.js
module.exports = function(db, logger) {
return {
init: function() { /* use db and logger in here */}
};
}
// app.js
var db = ...;
var logger = ...;
var users = require('./users')(db, logger);
users.init();
This is the pattern that I personally prefer, I think it's cleaner to pass dependencies into the require than into some init method like you have in your example.
You'll see this done in ExpressJS code quite a lot, for example when we have all our routes in another file and need to pass our app instance around:
require('./routes')(app);

If you need something to be initialized specifically in app.js rather than their own module you can export them from app.js and then require app.js:
// app.js
var db = require("db"),
logger = require("logger");
// do your initialization with db and logger
module.exports = { db: db, logger: logger };
and then:
// users.js
var db = require("./app").db,
logger = require("./app").logger;
// use db and logger
This works because as #Nico mentioned, modules are interpreted once and app.js will not be interpreted each time it is required from elsewhere.

use a typescript module/class in the browser and in the server (Node.Js)

How would I use the same typescript class or module in a client side javascript file and in a server side node.js file?
I found a solution here where you manually create the exports variable instead of using TypeScript's export keyword but then you lose the type information for the class when you include it in node.js with the require keyword.

You can cast what comes out of the require function since you know what it's going to be.
module Lib {
export class Alpha {
bravo: number = 1;
}
}
// meanwhile back at the ranch
var _lib = <Lib> require("Lib");
var a = new _lib.Alpha();