在函数内部调用函数

Question

When I code stuff, I try to divide all things in functions (methods, if you like). Function X does stuff X, Y does tuff Y and not like method X does stuff X, Y & Z! This gives me more re-usable code. I like that. :)

Lets take a look on this code:

var user = {
  users: [],
  userCount: 0,
  addUser: function(user) {
    (this.users).push(user);
  },
  incrementCount: function() {
    ++this.userCount;
  }
}

var user = { // 2nd example.
  users: [],
  userCount: 0,
  addUser: function(user) {
    (this.users).push(user);
    ++this.userCount;
  }
}

(It's in JavaScript, but language here is non-essential.)

In my opinion, second example will be easier and safer to use for, lets say, API user. It's easy to forget to call user.incrementCount() . What do you think? Second example does it automatically.

So how to find a balance? Any best-practices about calling functions inside of functions?

Thanks for reading this.

Edit :

This came in my mind just now:

var user = {
  users: [],
  userCount: 0,
  addUser: function(user) {
    (this.users).push(user);
    this.incrementCount();
  },
  incrementCount: function() {
    ++this.userCount;
  }
}

Answer 1

It's a little different in JS, since there isn't a way to make functions truly private when using object literal notation, but...

It's all about the API you want your objects to expose to their consumers. Do you want consumers of your API to be able to increment the count separately from adding a user? If so:

{ addUser: /* snip */, incrementCount: /* snip */ }

Otherwise:

{ addUser: /* snip */, _incrementCount: /* snip */ }
// or just
{ addUser: /* snip */ }

In this particular case, I would strongly recommend against storing any separate count at all, since the users array already does that for you.

var user = {
  _users: [],
  addUser: function(user) {
      this._users.push(user);
  },
  getUserCount: function () {
      return this._users.length;
  }
  // and if you need to expose the users array directly,
  , getUsers: function () {
      return this._users;
  }
}

Answer 2

Personally, I don't think you should even expose that stuff through an API. Also, it would be easier and (at least in JavaScript) more intuitive, to just use users.length .

Ultimately, I think keeping your interface really simple is generally a good thing. Abstraction is a good thing. If I were using someone else's library, I'd be pretty disappointed to learn that I was expected to manually increment that value.

Update:

One more thing I think is worth mentioning:

By having your code maintain state internally and keeping the API simple, you not only make the user's life easier, but you also protect against misuse (to the extent that it's possible). It's easy to imagine a scenario where someone uses that increment method incorrectly, and as a result, it's going to break stuff.

Answer 3

You are right in saying "Function A does A-Stuff." BUT: a function that works on data, that is hidden (more or less) from the outside, should do stuff you want with the data (for Example add a User) and makes shure, that the data still is correct (for example if you have a list of users, increment the Usercounter to make make shure it is always correct). If you leave want the user of your API do this stuff for you, it is not comfortable anyways.

Imagine, you add more functionality to your list of users (for example, tell the user that it has been added to the list, store the Users in a binary tree and so on), and you have to do all the organisation stuff from the outside of your function, where are the benefits of that??

Answer 4

I know you've just intended the sample code to be a simple example, but with something like a count or length variable I can't think of a reason why I'd ever want to let that be set independent of the function(s) that add or remove items. When using the object you don't want to have to call an add() and an increment() method every time you add, and you really don't want to be able to do one without the other or your object ends up in an invalid state.

So I'd never do it the first way, and surely the way you added in your edit is even worse. There's nothing wrong with having your functions call each other, but again in your example I'd want the increment function to be private.

Better to make the count variable private and only allow it to be retrieved via a function and set via add/remove functions (though you don't even need a count variable when you can just return users.length ). The following pattern with an immediately executed anonymous function lets you have private variables and functions, and you only return an object containing public functions. The public functions can still access the private variables/functions, but the private stuff can't be accessed from outside.

var user = (function() {
   var users = [],    // private variables
       private1,
       private2;

   function privateFunction1() { /* do something */ }

   return {
      getUserCount : function() {
                       return users.length;
                     },
      addUser:       function(user) {
                       users.push(user);
                       // return index of new user
                       return users.length - 1;
                     },
      getUser :      function(userIndex) {
                       return users[userIndex];
                     },
      someFunc :     function(someParam) {
                       return someParam + privateFunction1();
                     }
   }
})();

user.addUser("Fred");
user.addUser("Mary");
console.log(user.getUserCount()); // 2
console.log(user.getUser(1));     // Mary