Funzioni annidate: devo passare esplicitamente degli argomenti o fare affidamento sull'ambito?

Naviga le tue risposte
2

Supponiamo che abbia una funzione f che utilizza due funzioni di aiuto h e g per portare a termine il lavoro. Ci sono due modi possibili per affrontare questa situazione.

(1) accetta argomenti espliciti e restituisce nuovi oggetti da ciascuna funzione di aiuto: 

def f(x):
    def h(x):
        <do something>
        return y
    def g(y):
        <do something else>
        return z
    return g(h(x))   \ x remains unchanged

(2) usa l'ambito di f per accedere e mutare l'argomento originale finché non si trova allo stato desiderato: 

def f(x):
    def h():
        <do something>
    def g():
        <do something else>
    h()
    g()
    return x       \ x is now different

Mi piace la situazione (1) perché pensa che sia più facile capire cosa sta succedendo, ma in realtà non ho motivi concreti per spiegare perché (1) sia migliore di quanto non abbia più senso per me.

Qual è il modo giusto di pensarci?

    
posta Logister 24.07.2016 - 21:31
fonte

2 risposte

3

Nessuno dei due. Di solito in questa situazione, non si desidera modificare x , ma si vuole approfittarne già nell'ambito. Questo ti dà: 

def f(x):
    def h():
        <do something using x>
        return y
    def g(y):
        <do something else>
        return z
    return g(h())

Queste funzioni sono molto piccole in genere, e l'utilizzo di variabili chiuse è da aspettarsi e in genere semplifica l'interfaccia.

    
risposta data 25.07.2016 - 04:11
fonte
2

L'opzione 1 consente di associare x, yez solo una volta e di rimanere immutabili. Molti tipi di linguaggi si stanno muovendo in questa direzione, ad esempio, Swift (un linguaggio strongmente tipizzato) ha un'istruzione let che introduce una variabile con un binding immutabile; Javascript (un linguaggio dinamicamente o non tipizzato a seconda di come lo si guarda) ha una dichiarazione const per l'introduzione di una variabile con un'associazione immutabile. I binding immutabili rendono i programmi più facili da mantenere.

L'opzione 1 consente a x, yez di essere di un tipo diverso, che è significativo per i linguaggi tipizzati staticamente, e tuttavia anche significativo per i programmatori di ragionare su codice in lingue digitate dinamicamente. Anche in un linguaggio tipizzato dinamicamente, spesso siamo in grado di fornire suggerimenti di tipo o annotazioni; questo è precluso dall'opzione 2 a meno che x y e z capiti che tutti abbiano lo stesso tipo.

    
risposta data 25.07.2016 - 03:47
fonte

Leggi altre domande sui tag

Integrazione continua e un rifattore massiccio Posso gestire le transazioni nell'interfaccia utente