Hvordan etterligne søkeord argumenter i Actionscript 3 funksjoner

stemmer
7

Funksjoner i Python kan kalles ved hjelp av søkeord argumentene form ordet = verdi. For eksempel er den følgende funksjon:

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print -- This parrot wouldn't, action,
    print if you put, voltage, volts through it.
    print -- Lovely plumage, the, type
    print -- It's, state, !

kan kalles i en av følgende måter:

parrot(1000)
    parrot(action = 'VOOOOOM', voltage = 1000000)
    parrot('a thousand', state = 'pushing up the daisies')
    parrot('a million', 'bereft of life', 'jump')

Actionscript 3 ikke har dette anlegget. Hvordan skulle jeg best etterligne det?

Publisert på 03/01/2009 klokken 23:03
kilden bruker
På andre språk...                            


4 svar

stemmer
0

Du kan gjennomføre noe lignende ved hjelp av variabelt antall argumenter til en funksjon vist her .

Svarte 03/01/2009 kl. 23:26
kilden bruker

stemmer
7

Det vil ikke kaste noen feil ved kompilering hvis du rotet deg, men du kan gjøre noe som dette:

public function awesomefunction(input:Object):void {
    if (input.foo) trace("got foo");
    if (input.bar) trace("got bar");
}

Og så når du ringer det gjør slik:

awesomefunction( { foo : 23, bar : 99 } );

De {} parentes skape et inline objekt. En lang omstendelig versjon av koden ovenfor kan skrives slik:

var obj:Object = new Object();
obj.foo = 23;
obj.bar = 99;
awesomefunction( obj );

Hvis du gir den en matrise i stedet:

awesomefunction( [23, 99 ] );

([] Er forkortelse for en matrise forresten)

Indeksene blir accesible som dette:

public function awesomefunction(input:Object):void {
    if (input[0]) trace("got foo");
    if (input[1]) trace("got bar");
}

Så for å bringe det hele toghether du kan bruke det faktum at || operatør returnerer verdien av objektet som først evalueres til sant, ikke bare sant å gjøre:

public function awesomefunction(input:Object):void {
    var foo:int = input.foo || input[0];
    var bar:int = input.bar || input[1];
    if (foo) trace("got foo:", foo);
    if (bar) trace("got bar:", bar);
}

I så fall vil funksjonen ovenfor gir samme effekt for alle disse tre samtaler:

awesomefunction( { foo : 23, bar :55 } );
awesomefunction( { bar : 55, foo : 23 } );
awesomefunction( [ 23, 55 ] );

Dette vil imidlertid ikke tillate deg å blande navngitt og nummerert, men du kan gjøre som dette:

awesomefunction( { foo : 23, 1 : 55 } );

Det er ikke veldig pen, men det fungerer!

Svarte 03/01/2009 kl. 23:47
kilden bruker

stemmer
1

Det er en spesiell type i Actionscript 3.0 heter ... (hvile) . Sett denne typen i parameterlisten for en funksjon, og deretter at funksjonen er i stand til å akseptere en rekke argumenter. Riktig sytanx er: ... arrayName , hvor arrayName er navnet på tabellen som vil holde argumentene.

offentlig funksjon ForYou (... args): void {
   for (var i: int = 0; i 
Svarte 04/01/2009 kl. 01:04
kilden bruker

stemmer
4

Det korte svaret er at i Actionscript, rekkefølgen på parametrene er en del av en funksjon signatur. For å komme rundt det faktum, enten du trenger å gjøre ekstra arbeid, eller unn deg dårlig koding praksis som vil bite deg senere. Jeg vil si at du har to "gode" alternativer for å få fleksibilitet ligner på det du leter etter. Den formelle måte ville være å definere en data klasse for å opptre som funksjon parameter. Det er:

public class ComplaintData {
    public var state:String = "a stiff";
    public var action:String = "voom";
    public var type:String = "Norwegian Blue";
    public var voltage:String;

    public function ComplaintData( v:String ) {
        voltage = v;
    }
}

// somewhere else....

function parrot( cd:ComplaintData ) {
    trace "-- This parrot wouldn't " + cd.action;
    // etc.
}

var cd:ComplaintData = new ComplaintData( "a million" );
cd.action = "jump";
parrot( cd );

Hvis situasjonen er mer ad-hoc, er en mindre formell tilnærming for å lage liberalt bruk av valgfrie parametere, og tillater anroperen å passere null for en hvilken som helst ikke-etterfølgende parameter de ønsker å utelate. Dette får du fleksibilitet, men du ofre en god del av renslighet:

function parrot( voltage:String, 
                 state:String=null, 
                 action:String=null, 
                 type:String=null)  {
    if (state==null) { state = 'a stiff'; }
    if (action==null) { action = 'voom'; }
    if (type==null) { type = 'Norwegian Blue'; }
    // ....
}
parrot('1000')
parrot('1000000', null, 'jump')

Men hvis begge disse alternativene synes uhåndterlig, det er fordi de er. I det lange løp, tror jeg det er til syvende og sist best å internalisere ideen om at beordret parameterlister er en del av Actionscript grammatikk, og du er sannsynligvis bedre av ikke å prøve å unngå dem. Å gjøre det enten offer enkelhet (som ovenfor), eller fører til dårlig fremgangsmåter (for eksempel ved bruk av ustrukturerte gjenstander for parametere, som foreslått i andre svar, som ofrer mange fordeler med type og feilsjekking).

Den mest balansert måte å jobbe med grammatikken er det bare å bruke valgfrie parametere når det er mulig, slik:

function parrot( voltage:String, 
                 state:String='a stiff', 
                 action:String='voom', 
                 type:String='Norwegian Blue')  {
    // ...
}
parrot('1000');
parrot('1000000', 'pushing up the daisies');
parrot('a million', 'bereft of life', 'jump')

Du har fortsatt å leve med det faktum at bare følgende parametere kan utelates, men det er hvordan språket er gjort (og hvordan de innfødte metoder defineres og brukes).

Svarte 06/01/2009 kl. 04:47
kilden bruker

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more