Wie können Sie beim überladen einer Funktion in ActionScript?

Möchte ich eine Funktion in der Lage sein, in verschiedenen Arten. AS3 unterstützt nicht überladen direkt... so kann ich nicht Folgendes tun:

//THIS ISN'T SUPPORTED BY AS3

function someFunction(xx:int, yy:int, someBoolean:Boolean = true){
    //blah blah blah
}
function someFunction(arr:Array, someBoolean:Boolean = true){
    someFunction(arr[0], arr[1], someBoolean);
}

Wie kann ich es umgehen, und haben immer noch eine Funktion, die in der Lage ist, Argumente verschiedener Typen?

  • Ich bin sicher, du bekommst deine Antworten, aber ich bin nur courious warum würden Sie wollen, um die Methode überladen? Manchmal habe ich mich zu einem bestimmten Punkt, wenn das wirklich geholfen hätte, um fix eine schnelle problem, aber ich concider es SCHLECHTE PRAXIS, so dass ich nicht tun es.
  • Ich Stimme mit Mattias. W/o native Unterstützung für die überlastung, ist es schlechte Praxis, um eine Funktion akzeptieren, variable Parameter (es sei denn in sehr, sehr speziellen Situationen, die haben nichts zu tun mit überlastung)
  • Die Methode überladen ist eine unglaublich praktische Ergänzung zu jeder Sprache. Es würde Zeug wie Mathe Klassen so viel einfacher; nicht mehr multPoint(), multScalar (), etc, können Sie nur haben, mult()
  • Cool. Jede gute Beispiele dafür?
  • es ist nicht wirklich unterstützte in as3. die beste, die ich gesehen habe, ist so etwas wie zzzzBov Antwort: function mult( param:* ):void { if (param is Point) this._multPoint(); else if (param is Number) this._multScalar(); }
  • Ich Stimme mit peeps oben. Die Methode Überladen mit erstaunlich sein, wenn einheimische.. Alle "Hacks" sind es nicht Wert, die Umsetzung Zeit!

InformationsquelleAutor AS3 Guy | 2011-09-19
  1. 21

    Wenn Sie nur wollen, um in der Lage sein zu akzeptieren jede Art, die Sie verwenden können * zu ermöglichen, jede Art:

    function someFunction( xx:*, yy:*, flag:Boolean = true )
{
  if (xx is Number) {
    ...do stuff...
  } else if (xx is String) {
    ...do stuff...
  } else {
    ...do stuff...
  }
}

    Wenn Sie eine große Anzahl von verschiedenen Parametern, wo die Reihenfolge unwichtig ist, verwenden Sie ein Objekt Optionen:

    function someFunction( options:Object )
{
  if (options.foo) doFoo();
  if (options.bar) doBar();
  baz = options.baz || 15;
  ...etc...
}

    Wenn Sie eine variable Anzahl von Parametern, die Sie verwenden können, die ... - parameter (rest) :

    function someFunction( ... args)
{
  switch (args.length)
  {
    case 2:
      arr = args[0];
      someBool = args[1];
      xx = arr[0];
      yy = arr[1];
      break;
    case 3:
      xx = args[0];
      yy = args[1];
      someBool = args[2];
      break;
    default:
      throw ...whatever...
  }
  ...do more stuff...
}

    Fälle, in denen Sie aufrufen müssen, eine gemeinsame Funktion zu einer Anzahl von Klassen, sollten Sie die Schnittstelle üblich, jede Klasse:

    function foo( bar:IBazable, flag:Boolean )
{
  ...do stuff...
  baz = bar.baz()
  ...do more stuff...
}
    InformationsquelleAutor zzzzBov
  2. 2

    Nur haben könnten:

    function something(...args):void
{
    trace(args[0], args[1]);
}

    Diese Weise können Sie ganz einfach in einer Schleife durch deine Argumente und so zu (und auch check der argument-Typ):

    function something(...args):void
{
    for each(var i:Object in args)
    {
        trace(typeof(i) + ": " + i);
    }
}

something("hello", 4, new Sprite()); //string: hello
                                     //number: 4
                                     //object: [object Sprite]
    InformationsquelleAutor Marty
Schreibe einen Kommentar