Tout le monde!

Supposons que j'ai cette classe en JavaScript:

function Animal()
{
    this.name = "name";
}

Animal.prototype.someMethod =
    function ()
    {
    }

Et cette sous-classe:

function Cat()
{
    Animal.call(this);
}

Cat.prototype = new Animal();
Cat.prototype.constructor = Cat;

Cat.prototype.someMethod =
    function ()
    {
        // I want to access the superclass "name" instance variable here
    }

Quelle est la syntaxe pour accéder à la variable d'instance de "super-classe" à partir de la méthode substituée dans la classe Cat?

Je vous remercie.

Marcos

MISE À JOUR : Eh bien, si vous voulez voir le vrai code, le voici. Le problème vient de la variable abc (juste une variable de test que j'utilisais).

var pesquisaAcervo;

$(
    function ()
    {
        carregadoBase();

        if ($("#form\\:tipoPesquisa").val() == "SIMPLES")
        {
            pesquisaAcervo = new PesquisaAcervoSimples();
        }
        else
        {
            pesquisaAcervo = new PesquisaAcervoAvancada();
        }
        pesquisaAcervo.paginaCarregada();
    }
);

// --- PesquisaAcervo ----------------------------------------------------------

function PesquisaAcervo()
{
    $("*:visible[id^='form:materiaisPesquisa']").
        change(this.materialMudado).keyup(this.materialMudado);

    this.abc = 10;
}

PesquisaAcervo.prototype.paginaCarregada =
    function ()
    {
        $("#cabecalhoPesquisa a").click(this.exibirDicasPesquisa);
        $("#cabecalhoPesquisa select").
            change(function () {$("#form").submit();}).
            keyup(function () {$(this).change();});

        $("*:visible[class*='foco']").focus().select();
    };

PesquisaAcervo.prototype.materialMudado =
    function ()
    {
    };

PesquisaAcervo.prototype.exibirDicasPesquisa =  
    function ()
    {
    };

// --- PesquisaAcervoSimples ---------------------------------------------------

function PesquisaAcervoSimples()
{
    PesquisaAcervo.call(this);

    $("#form\\:campos").change(
        function ()
        {
            $("#textoCampo").text($("#form\\:campos :selected").text() + ":");
        }
     ).keyup(function () {$(this).change();}).change();

    $("#pesquisaSimples a").click(
        function ()
        {
            pesquisaAcervo = new PesquisaAcervoAvancada();

            $("#pesquisaSimples").parent().hide();

            $("#pesquisaAvancada").parent().show();

            $("#form\\:tipoPesquisa").val("AVANCADO");
        }
   );
}

PesquisaAcervoSimples.prototype = new PesquisaAcervo();
PesquisaAcervoSimples.prototype.constructor = PesquisaAcervoSimples;

PesquisaAcervoSimples.prototype.materialMudado =
    function ()
    {
        alert(this.abc); // "undefined" here
    };

// --- PesquisaAcervoAvancada --------------------------------------------------

function PesquisaAcervoAvancada()
{
     PesquisaAcervo.call(this);
}

PesquisaAcervoAvancada.prototype = new PesquisaAcervo();
PesquisaAcervoAvancada.prototype.constructor = PesquisaAcervoAvancada;
0
Marcos 19 oct. 2011 à 22:30

4 réponses

Meilleure réponse

Votre code réel révèle le problème. Le problème est de savoir comment vous appelez materialMudado. Il est invoqué comme rappel pour un événement. Le mot clé this à l'intérieur du rappel fera référence à la cible de l'événement (qui n'a pas de propriété abc), pas à l'objet auquel la fonction "appartient".

Voici une démonstration simple:

function Test() {};

Test.prototype.callback = function() {
    alert(this);
}

var t = new Test();

$(document).click(t.callback);

Sortie (après avoir cliqué sur la page):

[object HTMLDocument]

Comparez à ceci:

function Test() {};

Test.prototype.callback = function() {
    alert(this);
}

var t = new Test();

$(document).click(function() {
    t.callback();
});

Production:

[object Object]

Dans ce deuxième exemple, nous fermons la variable t, en lui conservant une référence.

Appliquer cela à votre exemple produit quelque chose comme ceci:

function PesquisaAcervo() {
    var that = this;
    var callback = function() {
        that.materialMudado();
    };
    $("*:visible[id^='form:materiaisPesquisa']").
        change(callback).keyup(callback);

    this.abc = 10;
}
1
Wayne Burkett 19 oct. 2011 à 19:33

Utilisez simplement ce mot-clé:

function Animal()
{
    this.name = "name";
}

Animal.prototype.someMethod2 =
    function ()
    {
    }


function Cat()
{
    Animal.call(this);
}

Cat.prototype = new Animal();
Cat.prototype.constructor = Cat;

Cat.prototype.someMethod =
    function ()
    {
        alert(this.name);// I want to access the superclass "name" instance variable here
    }
var c = new Cat();
c.someMethod();

Ajoutez ce code en bas, je viens d'ajouter une alerte à votre méthode someMethod ...

Dans votre exemple, Cat dérive tout d'Animal, il a donc accès à la variable de nom

0
Nikoloff 19 oct. 2011 à 18:48

this.name devrait fonctionner. Je ne vois pas que vous remplaciez la propriété name dans votre fonction Cat, vous devriez donc être en mesure de faire simplement this.name et la chaîne protopicale fera le travail pour trouver la première instance de cette propriété qui devrait être {{X2} }.

0
Wayne Burkett 19 oct. 2011 à 18:36

Il n'y a pas de substitution pour une variable d'instance. Une variable d'instance n'est qu'une propriété de l'objet this. Vous pouvez le lire avec:

var x = this.name;

Ou lui attribuer avec:

this.name = "foo";

this.name accédera au nom, que vous ayez une instance d'un objet Animal ou une instance d'un objet Cat.

Si vous souhaitez affecter à la propriété name dans le constructeur Cat, vous pouvez simplement le faire avec

this.name = "Cat";

Une fois que vous avez une instance de travail d'un objet, les propriétés ne sont que des propriétés et il n'y a aucune distinction selon qu'une propriété a été créée par une superclasse ou une sous-classe. Ce ne sont que des propriétés de l'objet à ce stade et vous y accédez tous de la même manière avec la syntaxe this.propertyName.

0
jfriend00 19 oct. 2011 à 18:37
7826221