__resolve (propriété Object._

Référence à une fonction définie par l'utilisateur qui est appelée si le code ActionScript fait référence à une propriété ou une méthode non définie. Si le code ActionScript fait référence à une propriété ou méthode non définie d'un objet, Flash Player détermine si la propriété __resolve de l'objet est définie. Si la propriété __resolve est définie, la fonction à laquelle elle fait référence est exécutée et reçoit le nom de la propriété ou de la méthode non définie. Cela vous permet de fournir par programmation des valeurs pour les propriétés et les instructions non définies des méthodes non définies en leur donnant l'apparence des propriétés ou des méthodes définies. Cette propriété est particulièrement utile pour établir une communication client/serveur hautement transparente et elle est recommandée pour appeler les méthodes côté serveur.

Exemple

Les exemples suivants développent progressivement le premier exemple et illustrent cinq utilisations différentes de la propriété __resolve. Pour faciliter la compréhension, les instructions clés qui diffèrent de l'usage précédent sont indiquées en gras.

Utilisation 1 : l'exemple suivant utilise __resolve pour créer un objet où toute propriété non définie renvoie la valeur "Hello, world!".

// Création d'une occurrence d'un nouvel objet
var myObject:Object = new Object();

// Définition de la fonction __resolve
myObject.__resolve = function (name) {
    return "Hello, world!";
};
trace (myObject.property1); // Renvoie : Hello, world!
trace (myObject.property2); // Renvoie : Hello, world!

Utilisation 2 : l'exemple suivant utilise __resolve en tant que foncteur, qui est une fonction générant d'autres fonctions. L'utilisation de __resolve redirige les appels de méthode non définis vers une fonction générique nommée myFunction.

// Création d'une occurrence d'un nouvel objet
var myObject:Object = new Object();

// Définit une fonction pour __resolve afin d'appeler
myObject.myFunction = function (name) {
    trace("Method " + name + " was called");
};

// Définition de la fonction __resolve
myObject.__resolve = function (name) {
     return function () { this.myFunction(name); };
};

// Teste __resolve avec des noms de méthode non définis
myObject.someMethod(); // Renvoie : La méthode someMethod a été appelée
myObject.someOtherMethod(); // Renvoie : La méthode someOtherMethod a été appelée

Utilisation 3 : l'exemple suivant développe l'exemple précédent en permettant de placer les méthodes résolues en mémoire cache. En plaçant les méthodes en mémoire cache, __resolve n'est appelé qu'une seule fois pour chaque méthode concernée. Ceci autorise la construction paresseuse des méthodes d'objet. La construction paresseuse est une technique d'optimisation qui reporte la création, ou construction, des méthodes jusqu'à la première utilisation d'une méthode.

// Création d'une occurrence d'un nouvel objet
var myObject:Object = new Object();
// Définit une fonction pour __resolve afin d'appeler
myObject.myFunction = function (name) {
    trace("Method " + name + " was called");
};
// Définition de la fonction __resolve
myObject.__resolve = function (name) {
    trace("Resolve called for "+name); 
    // Pour déterminer quand __resolve est appelé
    // Appelle non seulement la fonction, mais enregistre également sa 
    // référence
    var f:Function = function () {
        this.myFunction(name);
    };
    // Crée une méthode object et lui associe la référence
    this[name] = f;
    // Renvoie la référence
    return f;
};
// Teste __resolve avec des noms de méthode non définis
// __resolve est appelé une seule fois pour chaque nom de méthode
myObject.someMethod(); // Appelle __resolve
myObject.someMethod(); // N'appelle pas __resolve car cette méthode est 
// désormais définie
myObject.someOtherMethod(); // Appelle __resolve
myObject.someOtherMethod(); // N'appelle pas call __resolve, la méthode 
// n'est plus non définie

Utilisation 4 : L'exemple suivant développe l'exemple précédent en réservant un nom de méthode, onStatus(), pour l'utilisation locale de façon à ce qu'il ne soit pas résolu de la même façon que les autres propriétés non définies. Le code ajouté figure en gras.

// Création d'une occurrence d'un nouvel objet
var myObject:Object = new Object();
// Définit une fonction pour __resolve afin d'appeler
myObject.myFunction = function (name) {
    trace("Method " + name + " was called");
};
// Définition de la fonction __resolve
myObject.__resolve = function (name) {
    // Réserve le nom "onStatus" pour l'utilisation locale
    if (name == "onStatus") {
        return undefined;
    } 
    trace("Resolve called for "+name); // Pour déterminer quand __resolve est appelé
    // Appelle non seulement la fonction, mais enregistre également sa 
    // référence
    var f:Function = function () {
        this.myFunction(name);
    };
    // Crée une méthode object et lui associe la référence
    this[name] = f;
    // Renvoie la référence
    return f;
};
// Teste __resolve avec le nom de méthode "onStatus"
trace(myObject.onStatus("hello"));
// Renvoie : undefined

Utilisation 5 : L'exemple suivant développe l'exemple précédent en créant un foncteur qui accepte des paramètres. Cet exemple utilise de façon intensive l'objet arguments et applique plusieurs méthodes de la classe Array.

// Création d'une occurrence d'un nouvel objet
var myObject:Object = new Object();

// Définit une fonction générique à appeler avec __resolve
myObject.myFunction = function (name) {
    arguments.shift();
    trace("Method " + name + " was called with arguments: " + arguments.join(','));
};

// Définition de la fonction __resolve
myObject.__resolve = function (name) {
    // Réserve le nom "onStatus" pour l'utilisation locale
    if (name == "onStatus") {
        return undefined;
    } 
    var f:Function = function () {
        arguments.unshift(name);
        this.myFunction.apply(this, arguments); 
    };
    // Crée une méthode object et lui associe la référence
    this[name] = f;
    // Renvoie la référence à la fonction
    return f;
};

// Teste __resolve avec des noms de méthode non définis et leurs paramètres
myObject.someMethod("hello");
// Renvoie : La méthode someMethod a été appelée avec des arguments : hello

myObject.someOtherMethod("hello","world");
// Renvoie : La méthode someOtherMethod a été appelée avec des arguments : hello,world

resolve (propriété Object.resolve)

Exemple

Voir aussi

__resolve (propriété Object.__resolve)

Exemple

Voir aussi

resolve (propriété Object.resolve)