Javascript 如何以简单的方式将函数转换为RequireJS中的模块？

我一直在阅读文档，但我似乎无法轻松地做到这一点。我觉得我把这和使用相同单词的

node.js

混淆太多了，例如

require

，

exports

，

module

等等

想象一个这样的主脚本。（想象一下功能是复杂的）

现在假设我想在多个脚本中使用

showMessage（）。我该怎么做呢

在
Node.js
中，我将
showMessage（）
附加到
exports.showMessage
内部
showMessage.js
中，并在我想使用它的任何地方执行类似操作：

require(['jquery', 'domReady!'], function($) {

    var showMessage = require('showMessage'); // Easy huh?

    $("#staticButton").click(function() {
        showMessage('What does this button do?');
    });

});

但是对于
RequireJS
这会给我一个错误，我首先需要加载它。在使用上述语法之前，是否需要
要求
或
定义
？
我真的需要将它添加到主脚本
require
array中吗？我不喜欢那样。如果你有20个函数呢

require(['jquery', 'domReady!', func01, func02, (...) func20], function($, empty, func01, func02, (...) func20) {}

那是纯语法盐。我更喜欢
Node.js
sugar方式：

var func01 = require(func01),
    func02 = require(func02),
    (...)
    func20 = require(func20);

我把这两个弄糊涂了。有人能解释一下我是如何简单地将函数放入外部文件并尽可能简单地使用它们的吗


我假设模块化函数需要如下所示：

define(function(require, exports, module) {
    return function(message) {
        alert(message);
    }
});

…但是如果可以更容易地做到这一点，我很想听听。
你应该试着从模块的角度来考虑，在这种情况下，函数是更低级的东西。您定义模块，要求它们稍后将其公共“接口”作为具有某些属性的对象返回，这些属性可能恰好是函数

我发现有用的是“静态utils模块”模式：

utils.js

define(function () {
    return {
        showMessage: function (text) {
            alert(text);
        },
        foo: function () {
            alert('bar');
        }
    }
})

define({
    showMessage: function (text) {
        alert(text);
    },
    foo: function () {
        alert('bar');
    }
});

或简化的等效项：（>）

utils.js

define(function () {
    return {
        showMessage: function (text) {
            alert(text);
        },
        foo: function () {
            alert('bar');
        }
    }
})

define({
    showMessage: function (text) {
        alert(text);
    },
    foo: function () {
        alert('bar');
    }
});

然后，在main.js中：

define(['utils'], function (Utils) {
    Utils.showMessage('!');
})

如果您的依赖项太多（顺便说一句，这通常表明您的模块做得太多），您可以使用：

你应该试着从模块的角度来考虑，函数在这个上下文中是更低级的。您定义模块，要求它们稍后将其公共“接口”作为具有某些属性的对象返回，这些属性可能恰好是函数

我发现有用的是“静态utils模块”模式：

utils.js

define(function () {
    return {
        showMessage: function (text) {
            alert(text);
        },
        foo: function () {
            alert('bar');
        }
    }
})

define({
    showMessage: function (text) {
        alert(text);
    },
    foo: function () {
        alert('bar');
    }
});

或简化的等效项：（>）

utils.js

define(function () {
    return {
        showMessage: function (text) {
            alert(text);
        },
        foo: function () {
            alert('bar');
        }
    }
})

define({
    showMessage: function (text) {
        alert(text);
    },
    foo: function () {
        alert('bar');
    }
});

然后，在main.js中：

define(['utils'], function (Utils) {
    Utils.showMessage('!');
})

如果您的依赖项太多（顺便说一句，这通常表明您的模块做得太多），您可以使用：

谢谢你的解释。我认为你最后的例子最接近我想要的。结合您链接的文档，我应该使用
['require'，…]
启动依赖关系数组，并使用
函数（require，…）
进行回调，从那时起，我就可以
require
我想要的，有点像我提到的
节点
方式。我对你的答案投了赞成票，如果这是我的解决方案，我会接受的！我猜这使得
require（'utils'）静态加载程序。我可以预加载“utils”吗？如果I
require（'utils'）
在10个脚本中，它会加载
utils.js
10次吗？（如果我是正确的，它将只加载一次，因为根据文档，
requirejs
将
在内部将上述定义调用转换为依赖项数组。是的，1）每个模块的主体只加载/评估一次，不管需要多少次，如果您确实需要反向行为，请使您的模块返回一个工厂，该工厂在每次调用对象时都返回一个新的对象实例。2） 糖只是：糖语法；在评估模块主体之前，它使用正则表达式将其扩展为“完整”形式。谢谢！我认为他们应该从文档中这样简单的基本示例开始，因为它们很长，很无聊。最好的图书馆从一个简单的例子开始，它可以让用户相信它的价值，而无需事先了解。感谢您的解释。我认为你最后的例子最接近我想要的。结合您链接的文档，我应该使用
['require'，…]
启动依赖关系数组，并使用
函数（require，…）
进行回调，从那时起，我就可以
require
我想要的，有点像我提到的
节点
方式。我对你的答案投了赞成票，如果这是我的解决方案，我会接受的！我猜这使得
require（'utils'）静态加载程序。我可以预加载“utils”吗？如果I
require（'utils'）
在10个脚本中，它会加载
utils.js
10次吗？（如果我是正确的，它将只加载一次，因为根据文档，
requirejs
将
在内部将上述定义调用转换为依赖项数组。是的，1）每个模块的主体只加载/评估一次，不管需要多少次，如果您确实需要反向行为，请使您的模块返回一个工厂，该工厂在每次调用对象时都返回一个新的对象实例。2） 糖只是：糖语法；在评估模块主体之前，它使用正则表达式将其扩展为“完整”形式。谢谢！我认为他们应该从文档中这样简单的基本示例开始，因为它们很长，很无聊。最好的图书馆从一个简单的例子开始，它可以让用户相信它的价值，而无需事先了解。