как лучше всего организовать код?
 

такс. попробую обьяснить проблему на как можно более абстрактном примере.

есть две функции, которые совершают аналогичные в конечном результате действия. Их совместить низя. Но проблема не в этом.

Эти две функции разрастаются ещё на две (раньше на три, пока я не смекнул, как можно совместить две из них в одну, это неважно).

В итоге получается аж 4 функции!

это введение. теперь, собственно, перейду к абстрактному коду на примере одной из двух функций :

итак, есть две функции (т.к. корневая разрастается) : A и B.

function A(){};
function B(){};

функция B оперирует с переданным ей аргументом с переданными её настройками. Так сказать, "опциональное декорирование".

function B(obj, opt1, opt2){
    /*её тело совсем неважно, но пусть будет так :*/
    obj[opt1] = opt2;
};

Функция A, в свою очередь, принимает аргументы для настройки, генерирует аргументы для B и вскармливает всё это функции B :

function A(opt, another_opt){
    var z = "";
    z = "my string is : "+opt+" and it contains "+another_opt;
    var d = {};
    B(d, "options", z);
    /*.....*/
};

Обе функции являются процедурными, т.е. не возвращают результата.

как видите, первая функция является "надстройкой" над второй. Проблема заключается в том, что необходимо сохранить последовательность действий A и B.

Вопрос заключается в том, как можно их совместить в одну. Нет, не тупо сделать вторую свойством первой, а именно совместить.

В голове крутится аргумент-переключатель Boolean-типа, который будет находиться в начале функции и выполнять определённые действия, но в этом случае функция превращается в рекурсивную. На примере кода это будет :

function A(switcher,args/*1,2,3*/){
    if(switcher === true){
        /*привычные для A действия*/
        var d = {};
        A(true, d, arg2, arg3);
        // дальшейшие операции с d.
    } else {
        /*тут код функции B*/
        arg1[arg2] = arg[3];
    }
};

Вопрос к вам, о форумчане : как бы это сделали вы и как это логичнее сделать?

melky,
а чего, по порядку выполнять нельзя?

function(args...){
//выполняется первая часть, код функции A, сохраняет локальные переменные
//далее сразу идёт код функции B, который пользуется этими переменными
}

Если я правильно понял, что какая то основная функция будет много раз вызывать эти две, то так вполне нормально.

Если ты не вызываешь напрямую B - сделай её локальной для A...

то, что ты описал, называется каррингом. тут иное, т.к. A передает в B непостоянные аргументы, которые нельзя сохранять в замыкании.

угумс. по сути пока что так и делается. но хочется уменьшить обьём кода без потери понятливости. да и использвуется B только в двух случаях, так что её не особо желательно сохранять.

melky,
Да не, причём тут замыкания. Ведь функцией B будет пользоваться только A, правильно? Ну тогда так:

function(a1, a2){
var b1, b2, b3;

//код A, он меняет переменные b1, b2, b3. Использует a1, a2

//код B, он использует переменные b1, b2, b3
}

Ну а если не только функция A будет пользоваться B, то так:

function(a1, a2, flag){
var b1, b2, b3;

if(!flag) { // false или опущен флаг, по умолчанию используем функцию A
//код A, он меняет переменные b1, b2, b3. Использует a1, a2
}
//код B, он использует переменные b1, b2, b3
}

Если против подхода с !flag, как вы когда то писали про isNaN, то можно так:

function(a1, a2, flag){
var b1, b2, b3;
A:{
if(flag) break A;
//код A, он меняет переменные b1, b2, b3. Использует a1, a2
}
//B:{ условно блок B
//код B, он использует переменные b1, b2, b3
//{
}

UPD:
Да, чтот поспешил с 2мя последними вариантами, но в этом потоке, что бы можно было передавать аргументы B. Сейчас исправлюсь.
UPD2:

function(flag){
var b1, b2, b3, a1, a2, i = 0, args, flag;
typeof arguments[0] == 'boolean'  && ++i && (flag = arguments[0]);
args = Array.prototype.slice.call(arguments, i);
if(flag) {
//выставляем значения для функции B
b1 = args[0], b1 = args[1], b2 = args[2];
}else{
a1 = args[0], a2 = args[1];
//код A, он меняет переменные b1, b2, b3. Использует a1, a2
}
//код B, он использует переменные b1, b2, b3
}

Ну это замудренно :)

и ещё одной внутренней функцией.

похоже на переключатель из первого поста :) наверное, так и буду делать. точнее, так и буду делать, если не найду более понятного варианта.

melky,
Я там выше исправился, но уже слишком, хотя я бы сделал так :)

на том уровне абстракции, на котором ты объяснил проблему, ничего сделать нельзя. А зачем эта надстройка вообще нужна? Почему сразу не передавать в B нормальные опции?

function A(obj, opt1, opt2){
  switch (!opt2) {
     case true:
        opt2="my string is : "+obj+" and it contains "+opt1;
        obj={};
        opt1="options";
     case false:
     alert(obj.a)
        obj[opt1] = opt2;
     break;
  }
}

Так чтоли?

то же. с флагом мне легче читать.
всем спасибо )