Question

我有一个nodejs项目，其中sample.js包含两个函数函数A取决于函数B的回调。

// smaple.js

    //Both function are included in the same file 

        function B ( arg1 , callback ){
            // do some async
            async.map(arg1 , function(item, cb){
                     var a = item.a
                     var b = a*4
                     cb( null , {'a':a,'b':b})  
                },function(err , result){
                callback(err , result)
            } )


        }


        function A ( arg , callback ){
            if(condition1){
            callback(null , 1)
            }else{
             B ( arg , function( err , result){
                if(err){
                 callback(err , result)
                }
                else if (result ==1 ){

                callback ( null , 2)
                }else{
                callback ( null , 1)
                }

             })
            }
        }

情景2

        // function B is in outer.js and included as module
         //sample.js

        var outerfunction = require('./outer.js');

        function A ( arg , callback ){
            if(condition1){
            callback(null , 1)
            }else{
             outerfunction.B ( arg , function( err , result){
                if(err){
                 callback(err , result)
                }
                else if (result ==1 ){

                callback ( null , 2)
                }else{
                callback ( null , 1)
                }

             })
            }
        }


        outer.js


        function B ( arg1 , callback ){
            // do some async
            async.map(arg1 , function(item, cb){
                     var a = item.a
                     var b = a*4
                     cb( null , {'a':a,'b':b})  
                },function(err , result){
                callback(err , result)
            } )


        }

        module.exports.B = B ;

方案1是否是使用函数的正确方法？如果此代码使用群集模块并发运行会发生什么？

方案2是否是使用依赖函数的更好方法？这段代码在并发执行时表现更好吗？

哪种情况更好？

Answer 1

在javascript中，javascript文件在运行之前首先被解析，在解析时，所有定义为A和B的函数都是已知的。因此，所有顶级函数都是在任何代码运行之前定义的。有些人将此称为提升，因为范围内的所有函数定义都被提升到范围的顶部并在整个范围内可用。

因此，您可以这样做：

B();

function A() {
}

function B() {
}

而且，一切都会好起来的。

这种“提升”仅适用于使用上面显示的函数声明语法定义的函数。功能分配不适用于：

var B = function() {
};

在这种情况下，var B被提升到作用域的顶部，但是在该行代码实际执行之前它没有被分配函数值，它将按照代码的顺序执行。所以，这不起作用：

B();

var A = function() {
}

var B = function() {
}

当你尝试执行它时，B尚未被赋予其函数值。

将这些信息应用到您的两个场景中，您的第一个场景可以正常工作，因为A和B都是提升的函数定义，并且可以在文件的任何位置使用。

您的第二个场景也可以正常工作，因为您已经显式加载了模块并在调用之前获得了对B的引用。

使用群集模块时，两者应该没有区别。这些文件将在启动时加载一次，并且在您收到群集模块中的多个请求之前已经加载。

如何在单个js文件中定义依赖函数？

1 个答案: