Returning values between different scopes in javascript

Question

I'm a novice to Javascript, and experienced programmer, and i'm struggling real hard with grasping the concept in pattern and design of the best structure to use and approach while building applications. A few areas are quite new to me, one being mastering the scopes and closure of Javascript.

So to make this as clean as possible for you guys i've attached a sample of code to this post, hoping that someone may put my logic to place and give me a guideline to re-think and think right.

The code that i'm posting is part of a very simple file system / helper library (Node.js, express) that is used to scan directories, run a few conditions on those directories and return the result as a map in dimensions of an array to another library (not posted). The code you see is my current "testing" condition. I've commented it fairly.

The gist: https://gist.github.com/jimmiehansson/6235613 (FULL VIEW OR CODE / LIBRARY)

Sample code block (with problem in returning values)

ApiFS.prototype.scan = function(){          
    var self = this;
    var b;
    fs.readdir(stgs.fsPath, function(err,folders){      
        if(folders.length<1) { console.log(errLog.fsEmpty); return; }       
        rslt = self.walk(folders);          
        rslt.forEach(function(itm){
            if(!self.exclusion(rslt)){ b=self.loader(stgs.fsPath,itm); }        
        });                     
    }, ioResponse);
    console.log(b); // undefined <----      
}

So enough icebreaking. My biggest problem:

No matter what I do, the scope (hoisting) and closures which are fairly small, get in my way. I use no getter or setter currently, because I simply don't know how I should? Is my logic completely off, or am I missing something rather fundamental?

In the code you will see that the scan() prototype function makes a single call to each function "helper" that return either true/false value or an array.

I can work with these simply by returning values to the main scan() function, however I cannot for the sake of my life get those values from the fs.readdir() function to return outside of the scope, for instance outside of ioResponse callback.

What is my logic missing, how can I better approach this (even if it means reconstructing every thing) I am worried that I am doing something terribly wrong in my approach to design and layout these functions, and how i handle the values in between them.

Any assistance is greatly appreciated!

Answer 1

This has nothing to do with scope, it is about timing. readdir is asynchronous. It sends off the request to the filesystem and then lets the previous function carry on.

console.log(b); executes before b=self.loader() does.

If you want to work with data from a function that takes a callback, you need to perform that work inside the callback.

Answer 2

Quentin is correct. You'll definitely have to get used to the async nature of node programs. Just to make it clear, this should work as you expect.

ApiFS.prototype.scan = function(callback){          
    var self = this;
    var b;
    fs.readdir(stgs.fsPath, function(err, folders) {      
        if(folders.length<1) { console.log(errLog.fsEmpty); return; }

        var results = [];
        async.each(folders, function(folder) {
            if(!self.exclusion(folder)) { 
                results.push(self.loader(stgs.fsPath, itm)); 
            }            
        }, function() {});

        if(typeof(callback) == "function") {
            callback(b);
        }
    });
}

ApiFS.scan(function(files) {
    // Do something with files
});

Untested Refactoring of your Gist

var fs = require('fs'),
    async = require('async'),
    _ = require('underscore'),
    path = require('path');

ApiFS = function(options){
    errLog = [];
    errLog.fsEmpty = "No existing directories or empty, cannot continue."; 
}

ApiFS.prototype.scan = function(callback) {          
    var self = this,
        results = {};
    fs.readdir(options.fsPath, function(err, folders) {
        if(folders.length<1) return callback(errLog.fsEmpty);       
        async.forEach(folders, function(folder) {
            if(!self.exclude(folder)) {
                self.loadFiles(folder, function(err, files) {
                    results[folder] = files;
                });
        }, function(err) {
            callback(err, results);
        });                     
    });     
}

ApiFS.prototype.exclude = function(folder){       
    if(options.exclude.length === 0){
        return false;
    }

    return _.contains(options.exclude, folder);
}

ApiFS.prototype.loadFiles = function(folder, callback) { 
    fs.readdir(path.join(options.fsPath, folder), function(err, files) {
        callback(err, files);
    });
};

exports = module.exports = ApiFS;