Dans Node.js, comment «inclure» les fonctions de mes autres fichiers?

Disons que j'ai un fichier appelé app.js. Assez simple:

var express = require('express');
var app = express.createServer();
app.set('views', __dirname + '/views');
app.set('view engine', 'ejs');
app.get('/', function(req, res){
  res.render('index', {locals: {
    title: 'NowJS + Express Example'
  }});
});

app.listen(8080);

Et si j'ai des fonctions dans "tools.js". Comment les importer pour les utiliser dans apps.js?

Ou ... suis-je censé transformer des "outils" en module, puis en avoir besoin? << semble difficile, je fais plutôt l'import basique du fichier tools.js.

Vous pouvez exiger n'importe quel fichier js, il vous suffit de déclarer ce que vous souhaitez exposer.

// tools.js
// ========
module.exports = {
  foo: function () {
    // whatever
  },
  bar: function () {
    // whatever
  }
};

var zemba = function () {
}

Et dans votre fichier d'application:

// app.js
// ======
var tools = require('./tools');
console.log(typeof tools.foo); // => 'function'
console.log(typeof tools.bar); // => 'function'
console.log(typeof tools.zemba); // => undefined

Si, malgré toutes les autres réponses, vous souhaitez toujours inclure un fichier dans un fichier source node.js, vous pouvez utiliser ceci:

var fs = require('fs');

// file is included here:
eval(fs.readFileSync('tools.js')+'');

• La concaténation de chaîne vide +''est nécessaire pour obtenir le contenu du fichier sous forme de chaîne et non d'objet (vous pouvez également l'utiliser .toString()si vous préférez).
• Eval () ne peut pas être utilisé dans une fonction et doit être appelé à l'intérieur de la portée globale sinon aucune fonction ou variable ne sera accessible (c'est-à-dire que vous ne pouvez pas créer une include()fonction utilitaire ou quelque chose comme ça).

Veuillez noter que dans la plupart des cas, il s'agit d'une mauvaise pratique et que vous devriez plutôt écrire un module . Cependant, il existe des situations rares, où la pollution de votre contexte / espace de noms local est ce que vous voulez vraiment.

Mise à jour 2015-08-06

Veuillez également noter que cela ne fonctionnera pas avec "use strict";(lorsque vous êtes en "mode strict" ) car les fonctions et les variables définies dans le fichier "importé" ne sont pas accessibles par le code qui effectue l'importation. Le mode strict applique certaines règles définies par les nouvelles versions de la norme de langue. Cela peut être une autre raison d' éviter la solution décrite ici.

Vous n'avez pas besoin de nouvelles fonctions ni de nouveaux modules. Vous devez simplement exécuter le module que vous appelez si vous ne souhaitez pas utiliser l'espace de noms.

dans tools.js

module.exports = function() { 
    this.sum = function(a,b) { return a+b };
    this.multiply = function(a,b) { return a*b };
    //etc
}

dans app.js

ou dans tout autre .js comme myController.js:

au lieu de

var tools = require('tools.js') ce qui nous oblige à utiliser un espace de noms et à appeler des outils comme tools.sum(1,2);

on peut simplement appeler

require('tools.js')();

et alors

sum(1,2);

dans mon cas, j'ai un fichier avec les contrôleurs ctrls.js

module.exports = function() {
    this.Categories = require('categories.js');
}

et je peux utiliser Categoriesdans tous les contextes comme classe publique aprèsrequire('ctrls.js')()

Créez deux fichiers js

// File cal.js
module.exports = {
    sum: function(a,b) {
        return a+b
    },
    multiply: function(a,b) {
        return a*b
    }
};

Fichier js principal

// File app.js
var tools = require("./cal.js");
var value = tools.sum(10,20);
console.log("Value: "+value);

Sortie console

Value: 30

Voici une explication claire et simple:

Contenu Server.js:

// Include the public functions from 'helpers.js'
var helpers = require('./helpers');

// Let's assume this is the data which comes from the database or somewhere else
var databaseName = 'Walter';
var databaseSurname = 'Heisenberg';

// Use the function from 'helpers.js' in the main file, which is server.js
var fullname = helpers.concatenateNames(databaseName, databaseSurname);

Contenu Helpers.js:

// 'module.exports' is a node.JS specific feature, it does not work with regular JavaScript
module.exports = 
{
  // This is the function which will be called in the main file, which is server.js
  // The parameters 'name' and 'surname' will be provided inside the function
  // when the function is called in the main file.
  // Example: concatenameNames('John,'Doe');
  concatenateNames: function (name, surname) 
  {
     var wholeName = name + " " + surname;

     return wholeName;
  },

  sampleFunctionTwo: function () 
  {

  }
};

// Private variables and functions which will not be accessible outside this file
var privateFunction = function () 
{
};

Je cherchais également une fonction «include» de NodeJS et j'ai vérifié la solution proposée par Udo G - voir le message https://stackoverflow.com/a/8744519/2979590 . Son code ne fonctionne pas avec mes fichiers JS inclus. Enfin, j'ai résolu le problème comme ça:

var fs = require("fs");

function read(f) {
  return fs.readFileSync(f).toString();
}
function include(f) {
  eval.apply(global, [read(f)]);
}

include('somefile_with_some_declarations.js');

Bien sûr, cela aide.

créer deux fichiers par exemple app.jsettools.js

app.js

const tools= require("./tools.js")


var x = tools.add(4,2) ;

var y = tools.subtract(4,2);


console.log(x);
console.log(y);

tools.js

 const add = function(x, y){
        return x+y;
    }
 const subtract = function(x, y){
            return x-y;
    }

    module.exports ={
        add,subtract
    }

production

6
2

dire que nous veut appeler la fonction ping () et ajouter (30,20) qui est dans lib.js fichier de main.js

main.js

lib = require("./lib.js")

output = lib.ping();
console.log(output);

//Passing Parameters
console.log("Sum of A and B = " + lib.add(20,30))

lib.js

this.ping=function ()
{
    return  "Ping Success"
}

//Functions with parameters
this.add=function(a,b)
    {
        return a+b
    }

Le module vm dans Node.js offre la possibilité d'exécuter du code JavaScript dans le contexte actuel (y compris l'objet global). Voir http://nodejs.org/docs/latest/api/vm.html#vm_vm_runinthiscontext_code_filename

Notez qu'à partir d'aujourd'hui, il y a un bogue dans le module vm qui empêche runInThisContext de faire le bien lorsqu'il est appelé à partir d'un nouveau contexte. Cela n'a d'importance que si votre programme principal exécute du code dans un nouveau contexte et que ce code appelle runInThisContext. Voir https://github.com/joyent/node/issues/898

Malheureusement, l'approche with (globale) suggérée par Fernando ne fonctionne pas pour les fonctions nommées comme "function foo () {}"

En bref, voici une fonction include () qui fonctionne pour moi:

function include(path) {
    var code = fs.readFileSync(path, 'utf-8');
    vm.runInThisContext(code, path);
}

Udo G. a déclaré:

• L'eval () ne peut pas être utilisé à l'intérieur d'une fonction et doit être appelé à l'intérieur de la portée globale sinon aucune fonction ou variable ne sera accessible (c'est-à-dire que vous ne pouvez pas créer une fonction utilitaire include () ou quelque chose comme ça).

Il a raison, mais il existe un moyen d'affecter la portée globale d'une fonction. Améliorant son exemple:

function include(file_) {
    with (global) {
        eval(fs.readFileSync(file_) + '');
    };
};

include('somefile_with_some_declarations.js');

// the declarations are now accessible here.

J'espère que cela pourra aider.

Cela a fonctionné avec moi comme suit ...

Lib1.js

//Any other private code here 

// Code you want to export
exports.function1 = function(params) {.......};
exports.function2 = function(params) {.......};

// Again any private code

maintenant dans le fichier Main.js , vous devez inclure Lib1.js

var mylib = requires('lib1.js');
mylib.function1(params);
mylib.function2(params);

N'oubliez pas de placer Lib1.js dans le dossier node_modules .

Vous pouvez placer vos fonctions dans des variables globales, mais il est préférable de simplement transformer votre script d'outils en module. Ce n'est vraiment pas trop difficile - attachez simplement votre API publique à l' exportsobjet. Jetez un œil au module Comprendre les exportations de Node.js pour plus de détails.

À mon avis, une autre façon de faire est d'exécuter tout dans le fichier lib lorsque vous appelez la fonction require () en utilisant (function (/ * choses ici * /) {}) (); faire cela rendra toutes ces fonctions globales, exactement comme le eval () solution

src / lib.js

(function () {
    funcOne = function() {
            console.log('mlt funcOne here');
    }

    funcThree = function(firstName) {
            console.log(firstName, 'calls funcThree here');
    }

    name = "Mulatinho";
    myobject = {
            title: 'Node.JS is cool',
            funcFour: function() {
                    return console.log('internal funcFour() called here');
            }
    }
})();

Et puis dans votre code principal, vous pouvez appeler vos fonctions par leur nom comme:

main.js

require('./src/lib')
funcOne();
funcThree('Alex');
console.log(name);
console.log(myobject);
console.log(myobject.funcFour());

Fera cette sortie

bash-3.2$ node -v
v7.2.1
bash-3.2$ node main.js 
mlt funcOne here
Alex calls funcThree here
Mulatinho
{ title: 'Node.JS is cool', funcFour: [Function: funcFour] }
internal funcFour() called here
undefined

Faites attention à l' indéfini lorsque vous appelez my object.funcFour () , il en sera de même si vous chargez avec eval () . J'espère que cela aide :)

Je veux juste ajouter, au cas où vous auriez besoin de certaines fonctions importées de vos tools.js , alors vous pouvez utiliser une affectation de déstructuration qui est prise en charge dans node.js depuis la version 6.4 - voir node.green .

Exemple : (les deux fichiers sont dans le même dossier)

tools.js

module.exports = {
    sum: function(a,b) {
        return a + b;
    },
    isEven: function(a) {
        return a % 2 == 0;
    }
};

main.js

const { isEven } = require('./tools.js');

console.log(isEven(10));

production: true

Cela évite également que vous affectiez ces fonctions en tant que propriétés d'un autre objet, comme c'est le cas dans l'affectation (courante) suivante:

const tools = require('./tools.js');

où vous devez appeler tools.isEven(10).

REMARQUE:

N'oubliez pas de préfixer votre nom de fichier avec le chemin correct - même si les deux fichiers se trouvent dans le même dossier, vous devez préfixer avec ./

Depuis les documents Node.js :

Sans «/», «./» ou «../» de début pour indiquer un fichier, le module doit être un module principal ou être chargé à partir d'un dossier node_modules.

app.js

let { func_name } = require('path_to_tools.js');
func_name();    //function calling

tools.js

let func_name = function() {
    ...
    //function body
    ...
};

module.exports = { func_name };

Inclure le fichier et l'exécuter dans un contexte donné (non global)

fileToInclude.js

define({
    "data": "XYZ"
});

main.js

var fs = require("fs");
var vm = require("vm");

function include(path, context) {
    var code = fs.readFileSync(path, 'utf-8');
    vm.runInContext(code, vm.createContext(context));
}


// Include file

var customContext = {
    "define": function (data) {
        console.log(data);
    }
};
include('./fileToInclude.js', customContext);

C'est la meilleure façon que j'ai créée jusqu'à présent.

var fs = require('fs'),
    includedFiles_ = {};

global.include = function (fileName) {
  var sys = require('sys');
  sys.puts('Loading file: ' + fileName);
  var ev = require(fileName);
  for (var prop in ev) {
    global[prop] = ev[prop];
  }
  includedFiles_[fileName] = true;
};

global.includeOnce = function (fileName) {
  if (!includedFiles_[fileName]) {
    include(fileName);
  }
};

global.includeFolderOnce = function (folder) {
  var file, fileName,
      sys = require('sys'),
      files = fs.readdirSync(folder);

  var getFileName = function(str) {
        var splited = str.split('.');
        splited.pop();
        return splited.join('.');
      },
      getExtension = function(str) {
        var splited = str.split('.');
        return splited[splited.length - 1];
      };

  for (var i = 0; i < files.length; i++) {
    file = files[i];
    if (getExtension(file) === 'js') {
      fileName = getFileName(file);
      try {
        includeOnce(folder + '/' + file);
      } catch (err) {
        // if (ext.vars) {
        //   console.log(ext.vars.dump(err));
        // } else {
        sys.puts(err);
        // }
      }
    }
  }
};

includeFolderOnce('./extensions');
includeOnce('./bin/Lara.js');

var lara = new Lara();

Vous devez toujours indiquer ce que vous souhaitez exporter

includeOnce('./bin/WebServer.js');

function Lara() {
  this.webServer = new WebServer();
  this.webServer.start();
}

Lara.prototype.webServer = null;

module.exports.Lara = Lara;

Comme si vous aviez un fichier abc.txtet bien d'autres?

Créer 2 fichiers: fileread.jset fetchingfile.js, puis en fileread.jsécrire ce code:

function fileread(filename) {
    var contents= fs.readFileSync(filename);
        return contents;
    }

    var fs = require("fs");  // file system

    //var data = fileread("abc.txt");
    module.exports.fileread = fileread;
    //data.say();
    //console.log(data.toString());
}

En fetchingfile.jsécrivant ce code:

function myerror(){
    console.log("Hey need some help");
    console.log("type file=abc.txt");
}

var ags = require("minimist")(process.argv.slice(2), { string: "file" });
if(ags.help || !ags.file) {
    myerror();
    process.exit(1);
}
var hello = require("./fileread.js");
var data = hello.fileread(ags.file);  // importing module here 
console.log(data.toString());

Maintenant, dans un terminal: $ node fetchingfile.js --file = abc.txt

Vous passez le nom de fichier comme argument, en plus incluez tous les fichiers au readfile.jslieu de le passer.

Merci

Vous pouvez simplement simplement require('./filename').

Par exemple.

// file: index.js
var express = require('express');
var app = express();
var child = require('./child');
app.use('/child', child);
app.get('/', function (req, res) {
  res.send('parent');
});
app.listen(process.env.PORT, function () {
  console.log('Example app listening on port '+process.env.PORT+'!');
});

// file: child.js
var express = require('express'),
child = express.Router();
console.log('child');
child.get('/child', function(req, res){
  res.send('Child2');
});
child.get('/', function(req, res){
  res.send('Child');
});

module.exports = child;

Veuillez noter que:

1. vous ne pouvez pas écouter PORT sur le fichier enfant, seul le module parent express a un écouteur PORT
2. L'enfant utilise le «routeur», pas le moudle Express parent.

Je cherchais également une option pour inclure du code sans écrire de modules, resp. utiliser les mêmes sources autonomes testées d'un autre projet pour un service Node.js - et la réponse de jmparatte l'a fait pour moi.

L'avantage est que vous ne polluez pas l'espace de noms, je n'ai aucun problème avec "use strict";et cela fonctionne bien.

Voici un échantillon complet :

Script à charger - /lib/foo.js

"use strict";

(function(){

    var Foo = function(e){
        this.foo = e;
    }

    Foo.prototype.x = 1;

    return Foo;

}())

SampleModule - index.js

"use strict";

const fs = require('fs');
const path = require('path');

var SampleModule = module.exports = {

    instAFoo: function(){
        var Foo = eval.apply(
            this, [fs.readFileSync(path.join(__dirname, '/lib/foo.js')).toString()]
        );
        var instance = new Foo('bar');
        console.log(instance.foo); // 'bar'
        console.log(instance.x); // '1'
    }

}

J'espère que cela a été utile en quelque sorte.

Une autre méthode lors de l'utilisation de framework node.js et express.js

var f1 = function(){
   console.log("f1");
}
var f2 = function(){
   console.log("f2");
}

module.exports = {
   f1 : f1,
   f2 : f2
}

stocker cela dans un fichier js nommé s et dans le dossier statique

Maintenant, pour utiliser la fonction

var s = require('../statics/s');
s.f1();
s.f2();

J'ai trouvé une méthode assez grossière pour gérer cela pour les modèles HTML. Similairement à PHP<?php include("navigation.html"); ?>

server.js

var fs = require('fs');

String.prototype.filter = function(search,replace){
    var regex = new RegExp("{{" + search.toUpperCase() + "}}","ig");
    return this.replace(regex,replace);
}

var navigation = fs.readFileSync(__dirname + "/parts/navigation.html");

function preProcessPage(html){
    return html.filter("nav",navigation);
}

var express = require('express');
var app = express();
// Keep your server directory safe.
app.use(express.static(__dirname + '/public/'));
// Sorta a server-side .htaccess call I suppose.
app.get("/page_name/",function(req,res){
    var html = fs.readFileSync(__dirname + "/pages/page_name.html");
    res.send(preProcessPage(html));
});

page_name.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
    <title>NodeJS Templated Page</title>
    <link rel="stylesheet" type="text/css" href="/css/bootstrap.min.css">
    <link rel="stylesheet" type="text/css" href="/css/font-awesome.min.css">
    <!-- Scripts Load After Page -->
    <script type="text/javascript" src="/js/jquery.min.js"></script>
    <script type="text/javascript" src="/js/tether.min.js"></script>
    <script type="text/javascript" src="/js/bootstrap.min.js"></script>
</head>
<body>
    {{NAV}}
    <!-- Page Specific Content Below Here-->
</body>
</html>

navigation.html

<nav></nav>

Résultat de la page chargée

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
    <title>NodeJS Templated Page</title>
    <link rel="stylesheet" type="text/css" href="/css/bootstrap.min.css">
    <link rel="stylesheet" type="text/css" href="/css/font-awesome.min.css">
    <!-- Scripts Load After Page -->
    <script type="text/javascript" src="/js/jquery.min.js"></script>
    <script type="text/javascript" src="/js/tether.min.js"></script>
    <script type="text/javascript" src="/js/bootstrap.min.js"></script>
</head>
<body>
    <nav></nav>
    <!-- Page Specific Content Below Here-->
</body>
</html>

Si vous souhaitez profiter de plusieurs processeurs et d'une architecture de microservices, pour accélérer les choses ... Utilisez des RPC sur des processus fourchus.

Cela semble complexe, mais c'est simple si vous utilisez la pieuvre .

Voici un exemple:

sur tools.js ajouter:

const octopus = require('octopus');
var rpc = new octopus('tools:tool1');

rpc.over(process, 'processRemote');

var sum = rpc.command('sum'); // This is the example tool.js function to make available in app.js

sum.provide(function (data) { // This is the function body
    return data.a + data.b;
});

sur app.js, ajoutez:

const { fork } = require('child_process');
const octopus = require('octopus');
const toolprocess = fork('tools.js');

var rpc = new octopus('parent:parent1');
rpc.over(toolprocess, 'processRemote');

var sum = rpc.command('sum');

// Calling the tool.js sum function from app.js
sum.call('tools:*', {
    a:2, 
    b:3
})
.then((res)=>console.log('response : ',rpc.parseResponses(res)[0].response));

divulgation - Je suis l'auteur de poulpe, et construit si pour une utilisation similaire, car je n'ai trouvé aucune bibliothèque légère.

Pour transformer des "outils" en module, je ne vois pas du tout difficile. Malgré toutes les autres réponses, je recommanderais toujours l'utilisation de module.exports:

//util.js
module.exports = {
   myFunction: function () {
   // your logic in here
   let message = "I am message from myFunction";
   return message; 
  }
}

Nous devons maintenant affecter ces exportations à la portée globale (dans votre application | index | server.js)

var util = require('./util');

Vous pouvez maintenant faire référence et appeler la fonction comme:

//util.myFunction();
console.log(util.myFunction()); // prints in console :I am message from myFunction 

Utilisation:

var mymodule = require("./tools.js")

app.js:

module.exports.<your function> = function () {
    <what should the function do>
}