Сомнения в разработке модуля NodeJS

Question

Я пытаюсь написать свой самый первый модуль NodeJS, но мне сложно понять некоторые концепции.

Вот код, который у меня сейчас есть (счетчик / генератор гена):

"use strict";

var ret = require('ret');

module.exports = function (regex) {
    if (Object.prototype.toString.call(regex) === '[object RegExp]') {
        regex = regex.source;
    }

    else if (typeof regex !== 'string') {
        regex = String(regex);
    }

    try {
        var tokens = ret(regex);
    }

    catch (exception) {
        return false;
    }

    return {
        charset: '',
        reference: [],
        count: function (token) {
            var result = 0;

            if ((token.type === ret.types.ROOT) || (token.type === ret.types.GROUP)) {
                if (token.hasOwnProperty('stack') === true) {
                    result = 1;

                    token.stack.forEach(function (node) {
                        result *= count(node);
                    });
                }

                else if (token.hasOwnProperty('options') === true) {
                    var options = [];

                    token.options.forEach(function (stack, i) {
                        options[i] = 1;

                        stack.forEach(function (node) {
                            options[i] *= count(node);
                        });
                    });

                    options.forEach(function (option) {
                        result += option;
                    });
                }

                if ((token.type === ret.types.GROUP) && (token.remember === true)) {
                    reference.push(token);
                }
            }

            else if (token.type === ret.types.POSITION) {
            }

            else if (token.type === ret.types.SET) {
                token.set.forEach(function (node) {
                    if (token.not === true) {
                        if ((node.type === ret.types.CHAR) && (node.value === 10)) {
                        }
                    }

                    result += count(node);
                });
            }

            else if (token.type === ret.types.RANGE) {
                result = (token.to - token.from + 1);
            }

            else if (token.type === ret.types.REPETITION) {
                if (isFinite(token.max) !== true) {
                    return Infinity;
                }

                token.value = count(token.value);

                for (var i = token.min; i <= token.max; ++i) {
                    result += Math.pow(token.value, i);
                }
            }

            else if (token.type === ret.types.REFERENCE) {
                if (reference.hasOwnProperty(token.value - 1) === true) {
                    result = 1;
                }
            }

            else if (token.type === ret.types.CHAR) {
                result = 1;
            }

            return result;
        }(tokens),
        generate: function () {
            return false;
        },
    };
};

Вопросы:

1. я звоню count правильно на моей первой итерации? count: function (token) {}(tokens)?
2. как я могу рекурсивно вызвать count метод? Я получаю "ReferenceError: счетчик не определен"
3. Является ли это правильным (или передовым) подходом определения небольшого модуля несколькими методами?

Простите, что я не опубликовал 3 разных вопроса, но я пока не очень разбираюсь в терминологии.

Answer 1

1. Соглашение для немедленно вызванных замыканий count: (function(args) {return function() {}})(args) но ваш путь также будет работать во всех средах.
2. Вы не можете, потому что, к сожалению, счет - это закрытие - см. 3.
3. Если вы хотите использовать методы вашего модуля внутри вашего модуля, я бы объявил модуль вне оператора return. Если вы хотите хороший пример этого, посмотрите исходный код подчеркивания/lodash.

Таким образом, вы можете определить свой модуль с помощью объявления, как скелет ниже

module.exports = function (regex) {
    //...
    var count = function(tokens) {
        //...
        return function() {
           //...
           var ret *= count(node);


           return ret;
        }
    }
    var mymod = {
        count: count(tokens)
        //...
    };
    //...
    return mymod;

};