Esecuzione dell'ordine per due istruzioni consecutive

Question

Esecuzione dell'ordine per due istruzioni consecutive

#1 da (9 voti)
#2 da (4 voti)
#3 da (2 voti)

1

Ho il seguente codice:

subroutine foo(int index)
{
    // Check A.
    // Critical: Check A must precede Check B below.
    if (index == 1)
    {
        return true;
    }

    // Check B.
    if (index - 2 < 0)
    {
        return false;
    }

    return true;
}

Il codice è una rappresentazione semplificata di uno scenario reale in cui sto verificando la validità dei segni di punteggiatura in una stringa.

La mia domanda: esiste un costrutto in qualsiasi linguaggio che garantisca che l'ordine delle due istruzioni if sia mantenuto così com'è? (Senza dover inserire un commento nel codice come ho fatto e spero che sia ascoltato.)

Per il caso in cui index è 1, se Check B viene spostato prima di Check A, Check A non verrà mai catturato e foo () restituirà sempre false, che è male.

Ancora una volta, la mia preoccupazione è per il mantenimento del codice da parte dei futuri programmatori. Ci sono circa 10 se le istruzioni nel codice, una dopo l'altra, e il loro ordine è importante.

MODIFICA 1:

Sono uno sviluppatore esperto, e mi chiedo davvero se ci sono nuovi sviluppi nelle lingue che consentano ciò che sto chiedendo in precedenza. Mi dispiace di non averlo chiarito.

EDIT 2:

In risposta a commenti che suggeriscono index < 2 invece di index - 2 < 0: non sono d'accordo. index - 2 indica che sono interessato se esiste un articolo due posizioni prima dell'indice corrente, mentre index < 2 non trasmette le stesse informazioni. (Certo, questa è la mia opinione!)

conditions

posta Sabuncu 22.01.2016 - 12:11

fonte

3 risposte

4

Probabilmente in tutte le lingue rilevanti, le istruzioni vengono elaborate in ordine.

E questo è valido per l'intero codice del programma. Anche i programmi più semplici non funzionerebbero diversamente.

Se qualcuno è autorizzato a modificare il codice ma non ne capisce nulla, non c'è molto che tu possa fare al riguardo, tranne la rimozione dei suoi diritti per farlo.

Niente di sbagliato con un commento nel codice se è difficile da capire, o il refactoring del codice per rendere i suoi intenti più chiari, naturalmente.

Modifica (come nel commento):

Più facile è la comprensione del tuo codice, minori sono le possibilità di complicarlo. Ad esempio, (index < 2) sarebbe molto più facile da leggere e capire per me. E in questo caso, è uguale a (index < 0) . Quindi questa funzione restituisce sempre true per i numeri positivi, quindi l'intera funzione è semplice come return index > 0 .

Rendi la tua logica il più facile da seguire possibile.

E - come un'altra risposta ha sottolineato - questo dovrebbe essere catturato comunque da un test unitario.

risposta data 22.01.2016 - 12:21

fonte

2

Quindi, ti stai chiedendo come proteggere il tuo codice da goffi sviluppatori futuri? Questo è un compito difficile che viene solitamente gestito applicando tecniche di organizzazione del codice e non costrutti linguistici.

In questo caso specifico, vorrei semplicemente assicurarmi che riordinando i blocchi if non funzionasse in modo corretto il mio metodo. In questo modo:

subroutine foo(int index)
{
    bool checkA = (index == 1);
    bool checkB = (index - 2 < 0);

    if (checkA)
    {
        return true;
    }

    if (!checkA && checkB)
    {
        return false;
    }

    return true;
}

Ovviamente, potresti ottenere lo stesso risultato mettendo CheckB nel blocco else di CheckA , ma poi annidiamo ifs, cosa che non mi piace.

risposta data 22.01.2016 - 12:44

fonte

Leggi altre domande sui tag conditions

modello di progettazione per classe con dati allegati Qual è il gap di prestazioni del ninja, perché è così grande e come possiamo superarlo?

score 9 · Accepted Answer

Chiunque possa modificare il codice sorgente può rimuovere tutto ciò che potresti inserire per "proteggerlo". Puoi fare due cose:

Scegli un buon nome per la funzione che trasmette la tua intenzione
Fornisci test delle unità che si interromperanno se qualcuno cambia la funzione

Entrambi non impediscono ai futuri programmatori di modificare qualsiasi cosa, se necessario, ma avranno alcune indicazioni su come la funzione è stata pensata per comportarsi.

Un'altra opzione sarebbe quella di trasformare queste dipendenze temporali in strutture strutturali avendo il primo generare / restituire qualcosa che il secondo richiede come input. Ma questo è probabilmente eccessivo per qualcosa di semplice come il tuo esempio. Robert C. Martin menziona questa tecnica nel suo libro "Codice pulito".