CODEWITHSUNDEEP
javascript
user656925
user656925

Reputation:

How do I group similar methods and variables together in an object oriented approach?

I'm looking for standard way to do this.. This post here explores 3 ways. Here to. Which way should you use for a generic case...is it a matter of preference.
For example if I use the instantiation way..than I have two lines of code instead of one...I have to instanitate the object...and than call the method... If I use a static type implementation than I don't have to instantiate any objects. The 3rd option the module pattern...is more costly b.c. it is self-executing.

If I had to name them:

  1. object - non static
  2. object - static
  3. module pattern

Which way is suggested in general so I don't have to debate this each time I begin to consolidate methods.

Here is an example of collected methods I would like to consolidate.

/********************
group:checks
********************/

var patterns = 
  {
  name: /^[a-zA-Z-\s]{1,20}$/,
  email: /^[a-zA-Z0-9._(-)]+@[a-zA-Z0-9.(-)]+\.[a-zA-Z]{1,4}$/,
  pass: /.{6,40}/,
  url:  /^[(-)\w&:\/\.=\?,#+]{1,}$/,
  aml:  /<(.+)_([a-z]){1}>$/
  };

/*
- check_generic() - generic 
*/

function check_generic(reg_ex_in,text,html_id,response)
  {
  if(!reg_ex_in.exec(text.value))
    {
    fill_id(html_id,response);
    return 0;
    }
  return 1;
  }

/*
- check_empty() - checks for empty text 
*/

function check_empty(text,html_id,response) 
  {
  for(var a=0;a<text.length;a++)
    {
    if(text[a].value==='')
      {
      fill_id(html_id,response);
      return 0;
      }
    }
  return 1;
  }

/*
- check_same() - checks if two text entries are the same 
*/

function check_same(text1,text2,html_id,response)
  {
  if((text1.value)!==(text2.value))
    {
    fill_id(html_id,response);return 0;
    }
  fill_id(html_id,'');
  return 1;
  }

Upvotes: 5

Views: 6488

Answers (1)

Demian Brecht
Demian Brecht

Reputation: 21368

Here's the rule I generally follow:

If I'm grouping a set of stateless static functions together (essentially namespacing them), I'll stick them in an object:

var MyNamespace = {
   patterns: {
      name: /^[a-zA-Z-\s]{1,20}$/,
      email: /^[a-zA-Z0-9._(-)]+@[a-zA-Z0-9.(-)]+\.[a-zA-Z]{1,4}$/,
      pass: /.{6,40}/,
      url:  /^[(-)\w&:\/\.=\?,#+]{1,}$/,
      aml:  /<(.+)_([a-z]){1}>$/
   },

   check_generic: function(reg_ex_in,text,html_id,response)
   {
      if(!reg_ex_in.exec(text.value))
      {
        fill_id(html_id,response);
        return 0;
      }
      return 1;
   }
};

If I want to have a stateful class implementation without concerning myself about access control, I'll use the instantiation method:

var MyClass = function(param) {
    // initialize here
};
MyClass.prototype = {
   // method definitions here
};

If I'm doing something a little more complex that requires access control, I'll use the module pattern:

var mod = (function() {
    var o = {};
    var _p = "myprivatestring";
    o.p = "mypublicstring";

    o.myfunc = function() {
        this.p = _p;
    };

    return o;
})();

console.log(mod.p);
mod.myfunc();
console.log(mod.p);

http://jsfiddle.net/dbrecht/WLN6Y/

Upvotes: 6

Related Questions