module-pattern

I would like to call a public method from a private one but the property "this" refers to the window object. Please note i am trying to apply the module pattern. You can find a working code example at jsfiddle.net // how can i access a public method from a private one? // (in this example publicAlert from privateMethod) // this refers to the window object. $(function() { var modulePattern = (function($) { var privateMethod = function() { appendText("called privateMethod()"); this.publicAlert(); }; var appendText = function(texToAppend) { var text = $('#output').text() + " | " + texToAppend; $(

For the module pattern, I'm doing something like: (function(namespace) { // tons of code // blabla })(window.myGlobalNamespace); How do I split the code? I can think of a few ways, like use a hierachy of namespaces, or expand the object outside by window.myGlobalNamespace.additionalFunc = function () {//blabla} . What are the other ways? What are the pros and cons? Which one is considered better practice? Both of the two answers suggest RequireJS. Can you please explain how RequireJS can solve these problems: first.js: (function(context) { var parentPrivate = 'parentPrivate'; })(window

I'm trying to implement the inheritance with the module pattern in this way: Parent = function () { //constructor (function construct () { console.log("Parent"); })(); // public functions return this.prototype = { test: function () { console.log("test parent"); }, test2: function () { console.log("test2 parent"); } }; }; Child = function () { // constructor (function () { console.log("Child"); Parent.call(this, arguments); this.prototype = Object.create(Parent.prototype); })(); // public functions return this.prototype = { test: function() { console.log("test Child"); } } }; but I can't to

I'm a complete newbie to ninject I've been pulling apart someone else's code and found several instances of nInject modules - classes that derive from Ninject.Modules.Module, and have a load method that contains most of their code. These classes are called by invoking the LoadModule method of an instance of StandardKernel and passing it an instance of the module class. Maybe I'm missing something obvious here, but what is the benefit of this over just creating a plain old class and calling its method, or perhaps a static class with a static method? Jarrett Meyer The Ninject modules are the

I would like to know if the module pattern or Constructor/protoType pattern is more applicable to my work. Basically I am using unobtrusive javascript -- the HTML document has a reference to the .js file. My understanding of the module pattern: call an INIT method (which is basically a public method i can create and return using the module pattern) In the INIT method, assign all click events etc. This sounds like the perfect pattern for my situation, as I don't need to create Objects and inheritance hierarchies etc. My understanding of the Constructor/Prototype pattern: for creating objects

Having trouble getting the following to pass jslint/jshint /*jshint strict: true */ var myModule = (function() { "use strict"; var privVar = true, pubVar = false; function privFn() { return this.test; // -> Strict violation. } function pubFn() { this.test = 'public'; // -> Strict violation. privFn.call(this); // -> Strict violation. } return { pubVar: pubVar, pubFn: pubFn }; }()); myModule.pubFn(); I understand it's being caused by the use of this in a function declaration, but I read something Crockford wrote and he said the violation is meant to prevent global variable pollution - but the

I've been using the module pattern for a while, but recently have started wanting to mix in functions and properties into them to increase code re-use. I've read some good resources on the subject, but still am a bit uncertain as to the best approach. Here is a module: var myModule = function () { var privateConfigVar = "Private!"; //"constructor" function module() {} module.publicMethod = function () { console.log('public'); } function privateMethod1() { console.log('private'); } return module; } And here is a mixin object: var myMixin = function () {}; Mixin.prototype = { mixinMethod1: