Call one function inside the other, through a string

Just a suggestion, you can put the functions inside an object, and call it by name:

<script>
  function a() {
    var nomeDaFuncao = [função a ser chamada];

    var fncObj = {
        b: function(objeto) {
         . . .
        }

        c: function(objeto) {
         . . .
        }
    }

    fncObj[nomeDaFuncao](objeto);
  }
</script>

But it would be much better if you explain the reason for this strange logic ... because even the way I said, it sounds kind of weird having something like that ... does switch not solve? >     

You can use namespace for this. An object with several functions where it calls the function that needs and does not pollute the global space as in its original idea.

var validar = {

    date: function (value) {
        return [value, 'Função para data'];
    },
    text: function (value) {
        return [value, 'Função para texto'];
    },
    password: function (value) {
        return [value, 'Função para passwords'];
    }
}

And then you can use it like this:

// "el" no exemplo é o elemento que quer analisar
var type = el.getAttribute("type");
var retornoFuncao = validar[type](el.value);

Example

I used the same code inside each function but I imagine you wanted to adapt that part.

Hello, try doing this:

function a(){
    alert('olá a');
    var nomeFuncao = 'b';
    var b = function(){
        alert('olá b');
    };

    var c = function(){
        alert('olá c');
    };

    eval(nomeFuncao)();
}

JS Bin

You can also use this alternative without eval() :

func_a = function(arg1) {
    alert('call a '+ arg1);
};
func_b = function() {
    alert('b');
};
func_c = function() {
    alert('c');
};

var n = "a";

 window["func_" + n]('arg1');

JS Fiddle

Another option using Jquery:

$.main = {
    a : function(arg){
        alert('function a - arg: '+arg);
    },
    b : function(){
        alert('b');
    },
    c : function(){
        alert('c');
    },
    call : function(func,arg){
        $.main[func](arg);
    }
};
$.main.call('a','param 1');
$.main.call('b');
$.main.call('c');

With Jquery

Try to explicitly add your functions to the window object as here :

window.dyna = function(param) {
    alert("dyna " + param);
}
window["dyna"]("oi");

Some browsers do not even need this and it would work the way you did.

Edit 1

Testing here does not work in your example because the b() and c() functions are not directly on the window object. Therefore they are not found in the scope of window

Since they are created in the scope of function a() , they will only exist within function a() , and if within a() you want to access b() , for example, you have to do something like this:

this["b"]();
// que é o mesmo que this.b();

Edit 2

To use this , as I mentioned you have to do something like this, your problem is scope, so you have to attach your function to an object that is accessible in the scope where you intend to call it, in case the this , as follows in the sample code:

function a(nomeDaFuncao) {

  // anexa a function "b" ao objeto local this
  this.b  = function(param) {
      alert("b " + param);
  }

  // anexa a function "c" ao objeto local this
  this.c = function(param) {
      alert("c " + param);
  }

  // chama a function pelo nome no objeto local this
  this[nomeDaFuncao]("oi");
}

a(nomeDaFuncao);

Example here

To understand a little better how the scope of objects works in the javascript , I recommend this which is very good and this from MDN .

  

Note: I do not know what your real problem is in order to need such a solution, but whatever it may be, there may be simpler and cleaner ways to do it, but this solution will work for your current issue.