Пасоны, помогите со стайлом OOP в очередной раз
 

function Cat () {

	this.say = function () {

	};


	this.run = function () {

		var speed = countSpeed(s / t, getAngle(0));


		function getAngle () {

		}

		function countSpeed () {

		}
	};

}

run и say - методы

но метод run использует функции getAngle и countSpeed которые работают с его локальными переменными, где в данном случае удобнее писать эти функции? ВНУТРИ метода? так как только он их использует, но бывают и такие полезные функции которые используют несколько методов, например say захочет использовать getAngle, и в каждом методе писать одно и то же не круто.

Но может сделать эти функции getAngle и countSpeed приватными методами? Но тогда они не будут иметь доступ к локальным переменным каждого метода который их использует и придется передавать эти переменные в качестве параметров?.

Как поступать если например заведомо 100% ТОЛЬКО run использует эти функции? писать их в нем? но это сильно раздувает сам метод и его уже неудобно читать не понятно где начало а где конец. Если же вынести эти функции во вне (не делая приватными _методами, а просто объявить) а они ЗАВЕДОМО используются только ОДНИМ методом (и как бы являются его частью просто вынесенной в отдельную функцию) то не будет ли возникать непонятков "что это ваще тут за функция и какой метод её использует и к какому она относится?" а так же придется передавать в эти функции локальные переменные самих методов которые им нужны.

В общем я остановился пока на раздувании метода этими функциями и объявляю их прямо у него внизу, так как ТОЛЬКО ЭТОТ МЕТОД использует эти функции и они являются как бы его частью (раз используют даже его локальные переменные), ПЛЮС гугл компиллер разворачивает эти функции просто в код который просто использует в методе, что вообще круто. НОО не сильно ли это раздувает метод?
А так же из минусов то что внутри этих функций нет доступа к this по этому приходится вверху любого конструктора писать либо
var self = this

либо выносить все используемые данным методом СВОЙСТВА обьекта в переменные логически названные, и к этим свойствам (через переменные) уже будут иметь доступ функции.




В общем как поступить? И что делать если например и метод say захочет использовать функцию getAngle а у него её нету...

почему нельзя написать просто как функцию?

как функцию ВНЕ тела метода? потому что эта функция использует локальные переменные метода.
а так же она относится К НЕМУ и использует её ТОЛЬКО ОН и если все такие функции выносить будет не понятно к какому методу какая функция относится.

Ну а зачем при каждом вызове метода пересоздавать эти функции? Нечем больше процессор пользователя занять чтоли?

а аргументы для чего придуманы)

тогда зачем ты её вообще создал? заинлайни и всё делов... императивщина ж.

nerv_,
это охуенный вариант! спасибо! гугл компиллер достает код из этих приватных методов и вставляет туда где он используеться тупо копируя.

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

Вопрос, если приватный метод захотят использовать 2 публичных то как это указать? Например если в данном случае публичный метод say захочет использовать приватный _getAngle ?


для инкапсуляции определенного действия и давания ему имени, для того чтобы код был более читабельный. КАЖДОЕ логическое действие, которое состоит из нескольких простых, нужно пихать в функцию и давать ей четкое название. КОД пишется ДЛЯ ЛЮДЕЙ а не для машин.

Код для машин, пишут компиляторы.

А не будет ли прототип таким образом засран тонной приватных методов, нафиг не нужных изначально конструируемому объекту, в которых сам чёрт ногу сломит?

Есть ещё такой вариант, для истинных фанатов замыканий:

Cat.prototype.say = function () {};

(function(proto){
    function getAngle() {}
    function countSpeed() {}      
    
    proto.run = function() {};
  
}(Cat.prototype));

И соответственно, если надо некие приватные функции сделать доступными для двух методов - добавить ещё одно обёртывающее замыкание и вынести функцию туда итд. До полного ада.)

вот и я думаю, это по сути не методы а части метода

продолжай

var Cat = (function () {

    // Обшие для всех котов переменные и ф-и ...

    var CatConstructor = function () {};

    CatConstructor.prototype = {
        // ...
    };

    return CatConstructor;
})();

jQuery плагины фигачу примерно по такой схеме

jQuery.fn.cat = (function ($, undefined) {

    var defaultOptions = {};

    var Cat = function (options, element) {
        if (!(this instanceof Cat)) {
            return new Cat(options, $(this));

            var self = this;
            this.options = $.extend(true, {}, defaultOptions, options);
            this.element = element;
        }
    };

    CatConstructor.prototype = {
        constructor: Cat
        // ...
    };

    return Cat;

})(jQuery);