Problema con metodo en clases...

[Nemutagk]

Que tal compañeros, vengo a ustedes porque tengo un problema con los metodos de 2 clases, verán, si estancio las dos clases en un mismo archivo, pero si hay un metodo en cada clase que tenga el mismo nombre Javascript no diferencia los metodos de cada clase, si llamo al metodo "sumar" en la clase B (que se estancio después de la clase A) me llama al metodo pero de la clase A, mas no en metodo de la clase B, mi problema es que ambas clases reciben parametros diferentes (tanto en tipo como en numero), por lo cual me genera un error, mi pregunta es como hacer que Javascript diferencie cada metodo en su clase pertinente, dejo un ejemplo para que sea mas claro...

Código Javascript:

var ClassA = function() {
    var palabra = '';
 
    this.genPalabra = function() {
        generar();
 
        return palabra;
    }
 
    generar = function() {
        for(var i=0; i<10; i++) {
            palabra = palabra + ' pruebaA ' + i;
        }
    }
}
 
var ClassB = function() {
    var palabra = '';
 
    this.genPalabra = function() {
        generar();
 
        return palabra;
    }
 
    generar = function() {
        for(var i=0; i<10; i++) {
            palabra = palabra + ' pruebaB ' + i;
        }
    }
}
 
var classA = new ClassA();
classA.genPalabra(); //me genera prubaA X
 
var classB = new ClassB();
classB.genPalabra(); //me genera pruebaA X
 

Entiendo que Javascript esta muy lejos de tener POO decente, pero al menos deberia entender sobre que metodo es de cada clase y llamar a dicho metodo, en fin, ese es mi problema, no se si alguién tenga idea de como resolver esto que no sea cambiar el nombre del metodo.

Agradesco cualquier comentario o aportación....

[IsaBelM]

el problema que dices tener, realmente no lo tienes

genPalabra es un método privilegido lo cual implica que puede acceder a los métodos privados declarado en el ámbito de ClassA o ClassB

vuelve a probarlo por que creo que te has ofuscado

[Nemutagk]

Muchas gracias por responder, tal vez estoy mas ofuscado de lo que pienso, pero en verdad me esta sobre escribiendo el metodo/función, verás tengo dos clases Core.js y Session.js, en ambas tengo un metodo llamado "request" que envia una petición Ajax según los parámetros enviados:

Core.js

Código Javascript:

var Core = function() {
     //otras propiedades y metodos
 
     request = function(urlAjax,tipo,datosTipo,callback,historial) {
        debug('Ajax: nueva petición del tipo ' + tipo + ' a ' + urlAjax);
        removeDinamicEvents();
 
        var connect = $.ajax({
            url: urlAjax,
            type: tipo,
            cache: false,
            dataType: datosTipo
        });
 
        var responseAjax = null;
 
        ajaxNotification(urlAjax,tipo);
 
        connect.done(function(data) {
            debug('Ajax: respuesta satisfactoria');
 
            debug('Ajax: guardamos la peición como la ultima enviada');
            _ultPeticion = {
                'urlAjax': urlAjax,
                'tipo': tipo,
                'datosTipo': datosTipo,
                'callback': callback,
                'historial': historial
            }
 
            if (callback != 'return') {
                debug('Ajax: enviamos los datos obtenidos a la función callback ' + callback);
                window[callback].apply(null, [data,urlAjax,historial]);
            }else {
                debug('Ajax: retornamos los datos');
                responseAjax = data;
            }
        });
 
        connect.fail(function(jqXHR, error) {
            debug('Ajax: petición fallida, error ' + error);
 
            if (callback != 'return') {
                debug('Ajax: enviamos los datos obtenidos a la función callback ' + callback);
                window[callback].apply(this, [jqXHR.responseXML,urlAjax,historial]);
            }else {
                debug('Ajax: retornamos los datos');
                responseAjax = data;
            }
        });
    }
}
 

Session.js

Código Javascript:

var Session = function() {
    sessionRequest = function(urlAjax,tipo,callback,vars) {
        debug('Session: nueva petición ajax');
 
        if (typeof vars == 'undefined') {
            var connect = $.ajax({
                url: urlAjax,
                type: tipo,
                cache: false
            });
        }else {
            var connect = $.ajax({
                url: urlAjax,
                type: tipo,
                cache: false,
                data: vars
            });
        }
 
        var responseData;
 
        connect.done(function(data) {
            debug('Session: petición recibida con exito');
 
            if (callback != 'return') {
                debug('Session: llamando a la función ' + callback);
                window[callback].apply(null, [data]);
            }else {
                debug('Session: guardamos el resultado para retornarlo');
                responseData = data;
            }
        });
 
        connect.fail(function(jqXHR,error) {
            debug('Session: error al recibir la petición, error ' + error,'warn');
        });
 
        if (typeof responseData != 'undefined') {
            debug('Session: retornamos el valor!');
            return responseData;
        }
    }
}
 

Ambos metodos son muy parecidos, pero dentro de su ambito no lo son, el problema esta que las llamadas a dicho metodo dentro de cada clase siempre me las envia a la clase que se estancia al final, por lo cual se sobre escribe el primer metodo, al final, "window[callback]" me produce error porque no recibe el nombre de alguna función, si no recibe "tipoDato" (que puede ser XML, JSON, HTML), estoy buscando una solución pero no la encuentro, si te das cuenta, al final para seguir avanzando eh cambiado los nombres de los metodos, pero para mi eso es solo un parche, no una solución real, aun así sigo buscando como evitar este problema...

Gracias por tu tiempo en leer y contestar...

Nota: el metodo debug también se sobre escribe, aunque hay no tengo problema porque el metodo es el mismo en ambas clases...

[zerokilled]

buenas,
acostumbrese a declarar las variables con var. si bien como dice @isabelm, el método genPalabra se declara en el ámbito de cada clase pero en este caso pasan a ser globales y no locales debido a la iniciación sin var. simplemente debes poner por detrás de generar el keyword var. o bien puedes declarar la función (function declaration). es decir, function name (parameters) { body }. automáticamente javascript lo considera local al ámbito en que se declara.

[Nemutagk]

Muchas gracias por contestar @zerokilled...

Si bien entiendo, en Javascript para tener metodos públicos es necesario usar "this", sin embargo ahora con tu explicación me eh confundido un poco, usar el keyword "var" es unicamente para tener metodos privados (y obtener de alguna forma encapsulación) o es recomendable también para los metodos públicos, o de plano lo que estoy diciendo es una locura y unicamente es para los metodos privados?, de todos modos haré pruebas para ver como se comporta, gracias de nuevo por contestar...

Actualización: Eh estado "jugando" con esto de los "metodos locales o privados" y ahora eh notado un "problema" curioso, al agregar el keyword "var" a los metodos la función "window[callback]" me dejo de funcionar, por lo cual recurrí a "callback.apply(parámetros)", ahora mi duda es, que diferencia hay entre una y otra (window[callback] y callback.apply() o callback.call())? de antemano gracias por su ayuda!

Nota: por cierto, con el cambio a callback.apply() tube que cambiar la definición del nombre de la función a llamar, antes lo definia como string (el nombre de la función o metodo entre comillas o apostrofes), ahora debo pasarlo como variable...

[zerokilled]

bueno, tu confusión te tiene en un estado de locura, es lo único que tengo claro. si bien para hacer un método público se declara con this y para hacerlo privado se declara con var. ahora bien, tengase claro que esa asociación a sido atribuida como una forma de ver la implementación de clases en javascript. pues var en realidad es para declarar una variable de ámbito local. pero debido a ciertas características del lenguaje, se nos permite emular las clases u otra cosa. veamos.

Código:

function Klass(){
this.public = function(){ return "me acabas de invocar, ¿qué quieres?"; };
this.publicMember = "soy feo, pero no me molestes =(";
this.privileged = function(){ return private() +", "+ privateMember; };
var privateMember = "no me puedes tocar! =þ";
function private(){ return "soy el agente privado 007"; }
}

/* para probar en consola */
var k = new Klass();
k.public(); // "me acabas de ...";
k.publicMember; // "soy feo, ...";
k.private(); // se levanta una excepción porque no existe un miembro público llamado private;
k.privateMember; // devuelve undefined porque ese miembro no esta declarado;
k.privileged(); // "soy el agente ...";

en este ejemplo tienes tres miembros públicos y dos privados. los miembros privados no se pueden accesar desde el exterior. uno de los miembros públicos se le dice privilegiado porque tiene acceso a los miembros privados. si ese miembro privilegiado no existiera, en circunstancias normales lo que sucedería es que al finalizar la ejecucción del constructor Klass las variables locales se destruyen. pero en este ejemplo, al existir un método público que tiene acceso a los miembros privados, estos no se destruyen. eso es lo que se conoce como closure, la metodología de encapsulación en javascript. es a través de esta técnica que se implementa el concepto de clases en javascript.

Actualización: Eh estado "jugando" con esto de los "metodos locales o privados" y ahora eh notado un ...

hay una diferencia muy grande entre window[callback] y callback.apply. en el primero se asume dos cosas: primero y más importante que la declaración del callback está definida en el ámbito de window o lo mismo que en el entorno global. y segundo que el parámetro callback es un string. recuerda que esta sintaxis object[string] es una forma alterna a object.property. el segundo caso, callback.apply se entiende que el parámetro es una referencia a la función en si. es decir, que al invocar la función entre los argumentos debes pasar una referencia de una función.

[Nemutagk]

Excelente explicación, ahora queda claro, gracias por la ayuda!