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


969

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.


4
Ce qui m'a jeté ici, c'était requireun dossier dans le même répertoire sous Windows. Vous devez utiliser l'adressage de style Unix: ./mydirau lieu de l'ancien simple mydir.
Ben

1
J'ai créé un module pour importer des scripts, exporter vers un fichier et inclure un module depuis un node_modulesdossier extérieur . npmjs.com/package/node-import J'espère que cela peut vous aider. Merci!
Nanang Mahdaen El-Agung

Réponses:


1416

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

101
+1 Bien joué, limite même le code importé à son propre espace de noms. Je vais devoir en prendre note pour plus tard.
Evan Plaice

8
Je me demande s'il est possible d'importer des scripts externes. require("http://javascript-modules.googlecode.com/svn/functionChecker.js")ne semble pas importer correctement le module. Existe-t-il un autre moyen d'importer des scripts externes?
Anderson Green

6
Et si je dois passer une variable dans la fonction Like, bar: function (a, b) {// du code}
Nishutosh Sharma

5
Puisque vous exposez des propriétés, j'utiliserais les exportations au lieu de module.exports. Pour les exportations par rapport à module.exports: stackoverflow.com/questions/5311334/…
Farm

4
comment appeler la fonction bar (), à l'intérieur de la fonction foo (), signifie comment accéder à une fonction avec une autre
pitu

303

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.


41
Cool, cela est utile pour mettre rapidement des bibliothèques JS conçues pour le côté client dans une application node.js sans avoir besoin de maintenir une fourche de style Node.
Kos

18
Je viens de répondre à la question d'origine, qui concerne l'inclusion de code et non l'écriture de modules. Les premiers peuvent présenter des avantages dans certaines situations. En outre, votre hypothèse sur require est fausse: le code est certainement évalué, mais il reste dans son propre espace de noms et n'a aucun moyen de "polluer" l'espace de noms du contexte appelant, vous devez donc l'évaluer () vous-même. Dans la plupart des cas, l'utilisation de la méthode décrite dans ma réponse est une mauvaise pratique, mais ce n'est pas moi qui devrait décider si c'est pour TIMEX.
Udo G

14
@EvanPlaice: avez-vous une meilleure suggestion qui répond réellement à la question ? Si vous devez inclure un fichier qui n'est pas un module , avez-vous une meilleure approche que celle-ci?
jalf

8
Il y a parfois quand vous avez besoin d'inclure, et parfois d'exiger, ce sont deux concepts fondamentalement différents dans la plupart des langages de programmation, Node JS également. Pour être honnête, la possibilité d'inclure js en place devrait faire partie de Node, mais son évaluation est essentiellement une solution décente. A voté.
J. Martin

4
Notez que cela est incompatible avec use strict - car use strict contraindra l'utilisation d'eval en bloquant l'introduction de nouvelles variables via eval, etc.
timbo

189

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')()


12
Comment cela n'a-t-il pas plus de +1? C'est une vraie solution à ce que la question demande (bien que ce ne soit pas «officiel»). Il est également un million de fois plus facile à déboguer que eval () car le nœud peut donner une pile d'appels utile au lieu de pointer vers le fichier réel au lieu d'être simplement indéfini.
user3413723

5
Notez que vous ne pouvez pas "utiliser le mode" strict "dans le module importé.
David

1
@Nick Panov: génial! Il convient de noter que cela fonctionne car thisdans une fonction est la portée globale lorsque la fonction est appelée directement (non liée en aucune façon).
Udo G

3
cela a juste changé ma vie, pas de blague - avait un fichier de plus de 1000 lignes que je ne pouvais pas casser car les variables de différentes méthodes sont toutes corrélées et auraient besoin d'être toutes dans la même portée ... require('blah.js')();devrait permettez-moi de les importer tous dans la même portée !!! Merci!!!
Sam Johnson

2
C'est une excellente astuce! Attention: si vous déclarez la fonction module.exports en utilisant la syntaxe de raccourci () => {} plutôt que la déclaration standard function () {}, elle échoue. Cela m'a pris une heure pour comprendre où était le problème! (Les fonctions fléchées n'ont pas leur propre propriété «this»: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… )
Ryan Griggs

117

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

Quelle version de js cela fonctionne-t-il?
Mirv - Matt

39

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 () 
{
};

34

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.


2
Je comprends à quel point il est moche d'un hack, mais cela m'a certainement aidé.
lindhe

30

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

26

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
    }

1
Cela fonctionne, mais ne sommes-nous pas censés utiliser la syntaxe des modules lors de l'inclusion de scripts?
Kokodoko du

25

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

J'ai trouvé vm.runInThisContext dans une autre réponse SO et je l'utilisais pour inclure des fichiers de code Javascript "vanilla". Ensuite, cependant, j'ai essayé de l'utiliser pour inclure du code qui dépendait de la fonctionnalité du nœud (par exemple, "var fs = require ('fs')"), et cela ne fonctionnerait pas. Dans ce cas cependant, la ou les solutions "d'évaluation" notées dans quelques réponses fonctionnent effectivement.
Dexygen

En y réfléchissant un peu plus, lorsque vous commencez à avoir besoin d'inclure du code qui dépend de la fonctionnalité du nœud, il est probablement temps d'écrire un module, bien que la solution eval puisse être la première étape de ce processus
Dexygen

Un seul qui a travaillé dans node.js en 2019
Meesern

13

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.


12

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 .


11

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.


1
Un exemple vaut mieux qu'un lien
tno2007

11

À 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 :)


10

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.


10

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

3

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

2

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;

2

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


2

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.

1

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.


1

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

1

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>

0

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.


0

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 

-3

Utilisation:

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

app.js:

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

1
Vous ne devriez presque jamais utiliser un répertoire complet. Vous devriez envisager d'utiliser des chemins relatifs comme:./tools.js
Matthew D Auld
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.