Refactoring di distanza etichettato con passanti

Question

Dopo mi sono convinto che sia etichettato pause/continua di un totale "nono" oltre qui, Ho bisogno di aiuto per rimuovere l'etichetta, al di fuori del mio codice.

Ho una matrice quadrata e un vettore che ha la stessa lunghezza.Il vettore ha già alcuni valori di una funzione dei valori nella matrice vettore è cambiato nel ciclo.

Spero, il codice frammento è fondamentalmente comprensibile...

vectorLoop:
for( int idx = 0; idx < vectorLength; idx++) {
    if( conditionAtVectorPosition( v, idx ) ) continue vectorLoop;

    matrixLoop:
    for( rowIdx = 0; rowIdx < n; rowIdx++ ) {
        if( anotherConditionAtVector( v, rowIdx ) ) continue matrixLoop;
        if( conditionAtMatrixRowCol( m, rowIdx, idx ) ) continue vectorLoop;
    }
    setValueInVector( v, idx );
}     

Si prega di convincere me, che non c'è più leggibile del/versione migliore, senza etichette.

Answer 1

Guardando le soluzioni presentate finora:

• Tutti guardano meno leggibile rispetto all'originale, in quanto prevedono di spendere più di codice, è il meccanismo del codice, piuttosto che sullo stesso algoritmo

• Alcuni di loro sono rotto, o erano prima sono stati modificati.Più schiacciante è il fatto che le persone si trovano a dover pensare piuttosto sodo su come scrivere il codice senza etichette e di non rompere nulla.

• Alcune sono dotate di una riduzione delle prestazioni di eseguire lo stesso test due volte, che non può sempre essere banale.L'alternativa, che è in corso la memorizzazione e il passaggio di turno booleane, che diventa brutto.

• Il Refactoring la parte di codice in un metodo è effettivamente un non-op:riorganizza come il codice è disposto nel file, ma non ha alcun effetto sul modo in cui è eseguito.

Tutti che mi fa credere che, almeno nel caso di questa domanda come è formulata, l'etichetta è la soluzione corretta e non ha bisogno di essere rielaborato di distanza.Certamente ci sono casi in cui le etichette sono utilizzati in modo non corretto e deve essere rielaborato di distanza.Io non penso che dovrebbero essere trattate come una regola inviolabile.

Answer 2

@Patrick si stanno assumendo la chiamata setValueInVector( v, idx );alla fine del secondo ciclo è OK.Se il codice è identico, logicamente, deve essere riscritto per somethng come questo:

for( int idx = 0; idx 

Answer 3

Facilmente, buon uomo.

for( int idx = 0; idx < vectorLength; idx++) {
  if( conditionAtVectorPosition( v, idx ) ) continue;

  for( rowIdx = 0; rowIdx < n; rowIdx++ ) {
    if( anotherConditionAtVector( v, rowIdx ) ) continue;
    if( conditionAtMatrixRowCol( m, rowIdx, idx ) ) break;
  }
  if( !conditionAtMatrixRowCol( m, rowIdx, idx ) )
    setValueInVector( v, idx );
}

EDIT:Tutto corretto si sono Anders.Ho modificato la mia soluzione da prendere in considerazione.

Answer 4

Dalla lettura del tuo codice.

• Ho notato il vostro eliminando le voci non vettoriale posizioni conditionAtVectorPosition quindi rimuovere le voci di righe a anotherConditionAtVector.
• Sembra che il controllo di righe a anotherConditionAtVector è ridondante, poiché qualunque sia il valore della idx è, anotherConditionAtVector dipende solo l'indice di riga (supponendo anotherConditionAtVector non ha effetti collaterali).

Così si può fare questo:

• Ottenere posizioni validi primo utilizzo conditionAtVectorPosition (queste sono le colonne valide).
• Quindi ottenere il valido righe utilizzando anotherConditionAtVector.
• Infine, utilizzare conditionAtMatrixRowCol utilizzando il valido colonne e righe.

Spero che questo aiuta.

Answer 5

@Nicolas

Alcuni di loro sono rotto, o erano prima sono stati modificati.Più schiacciante è il fatto che le persone stanno avendo pensare piuttosto sodo su come scrivere il codice senza etichette e di non rompere nulla.

Ho un altro punto di vista:alcuni di loro sono rotto, perché è difficile capire il comportamento dell'algoritmo originale.

Mi rendo conto che è soggettivo, ma non ho problemi a leggere l'algoritmo originale.E ' più corto e più chiara di proposte sostituzioni.

Quello che tutti i rifattorizzazione in questo thread non è emulare il comportamento di un etichetta con altre funzionalità del linguaggio come se fosse il porting del codice di un linguaggio che non hanno etichette.

Answer 6

Alcune sono dotate di una riduzione delle prestazioni di eseguire lo stesso test due volte, che non può sempre essere banale.L'alternativa, che è in corso la memorizzazione e il passaggio di turno booleane, che diventa brutto.

La pena di prestazioni è minore.Tuttavia sono d'accordo che l'esecuzione di un test due volte non è una bella soluzione.

Credo che la domanda era come rimuovere le etichette, non come ottimizzare l'algoritmo.Mi è parso che il poster originale era a conoscenza di come utilizzare il 'continua' e 'rompere' le parole chiave senza etichette, ma, naturalmente, la mia ipotesi potrebbe essere sbagliato.

Quando si tratta di prestazioni, il post non fornisce alcuna informazione circa l'attuazione delle altre funzioni, quindi per quanto ne so potrebbero anche essere scaricare i risultati via FTP come fatta di semplici calcoli inline dal compilatore.

Detto questo, facendo la stessa prova due volte non è ottimale, in teoria.

EDIT:In un secondo pensiero, l'esempio non è in realtà un orribile uso di etichette.Sono d'accordo che "goto è un no-no", ma a causa di un codice come questo.L'uso di etichette qui in realtà non influenzano la leggibilità del codice in modo significativo.Naturalmente, non sono obbligatori e possono facilmente essere omesso, ma non sono in uso, semplicemente perché "l'utilizzo di etichette è male" non è un buon argomento, in questo caso.Dopo tutto, la rimozione di etichette non rendere il codice più facile da leggere, come altri hanno già commentato.

Answer 7

Questa domanda non era su come ottimizzare l'algoritmo, ma grazie comunque ;-)

Al momento ho scritto, ho considerato l'etichetta continuare come leggibile soluzione.

Ho chiesto QUINDI un domanda circa la convenzione (con etichetta in tutte le protezioni o non) per le etichette in Java.

Fondamentalmente ogni risposta mi ha detto "non li uso - c'è sempre un modo migliore!refactor!".Così ho postato questa domanda per chiedere più leggibile (e quindi di meglio?) soluzione.

Fino ad ora, non sono del tutto convinti che le alternative presentate finora.

Per favore, non fraintendetemi.Le etichette sono il male, la maggior parte del tempo.

Ma nel mio caso, il test condizionali sono abbastanza semplici, e l'algoritmo è preso da un matematico di carta e quindi molto probabilmente non cambierà nel prossimo futuro.Quindi preferisco avere tutte le pertinenti parti visibili in una sola volta, invece di dover scorrere a un altro metodo chiamato qualcosa come checkMatrixAtRow(x).

Soprattutto al più complessi algoritmi matematici, lo trovo abbastanza difficile trovare un "buon" funzione-nomi - ma credo che è ancora un'altra questione

Answer 8

Penso che etichettati con passanti sono così rara che si può scegliere, qualunque sia il metodo di etichettatura funziona per voi - che avete ci rende le tue intenzioni con la continua perfettamente chiaro.

---

Dopo aver guidato la carica per suggerire refactoring del loop nella domanda originale e ora vedendo il codice in questione, penso che hai molto leggibile loop c'.

Quello che mi ero immaginato una porzione di codice, mettendo l'esempio reale, posso vedere è molto più pulito di quello che avevo pensato.

Le mie scuse per il malinteso.

Answer 9

Fa questo lavoro per voi?Ho estratto il ciclo interno in un metodo CheckedEntireMatrix (può essere un nome meglio di me) - Anche la mia versione di java è un po ' arrugginito..ma penso che si ottiene il messaggio

for( int idx = 0; idx < vectorLength; idx++) {
    if( conditionAtVectorPosition( v, idx ) 
    || !CheckedEntireMatrix(v)) continue;

    setValueInVector( v, idx );
}

private bool CheckedEntireMatrix(Vector v)
{
    for( rowIdx = 0; rowIdx < n; rowIdx++ ) {
        if( anotherConditionAtVector( v, rowIdx ) ) continue;
        if( conditionAtMatrixRowCol( m, rowIdx, idx ) ) return false;
    }   
    return true;
}

Answer 10

Gishu ha l'idea giusta :

for( int idx = 0; idx < vectorLength; idx++) {
    if (!conditionAtVectorPosition( v, idx ) 
        && checkedRow(v, idx))
         setValueInVector( v, idx );
}

private boolean checkedRow(Vector v, int idx) {
    for( rowIdx = 0; rowIdx < n; rowIdx++ ) {
        if( anotherConditionAtVector( v, rowIdx ) ) continue;
        if( conditionAtMatrixRowCol( m, rowIdx, idx ) ) return false;
    }  
    return true;
}

Answer 11

Io non sono troppo sicuro di capire prima di continuare.Vorrei copiare Gishu e scrivere qualcosa del genere ( scusate se ci sono alcuni errori ) :

for( int idx = 0; idx < vectorLength; idx++) {
    if( !conditionAtVectorPosition( v, idx ) && CheckedEntireMatrix(v))
        setValueInVector( v, idx );
}

inline bool CheckedEntireMatrix(Vector v) {
    for(rowIdx = 0; rowIdx < n; rowIdx++)
        if ( !anotherConditionAtVector(v,rowIdx) && conditionAtMatrixRowCol(m,rowIdx,idx) ) 
            return false;
    return true;
}

Answer 12

@Sadie:

Tutti guardano meno leggibile rispetto all'originale, in quanto prevedono di spendere più di codice, è il meccanismo del codice, piuttosto che sullo stesso algoritmo

Esternalizzare il secondo ciclo al di fuori dell'algoritmo non è necessariamente meno leggibile.Se il nome del metodo è ben scelto, può migliorare la leggibilità.

Alcuni di loro sono rotto, o erano prima sono stati modificati.Più schiacciante è il fatto che le persone si trovano a dover pensare piuttosto sodo su come scrivere il codice senza etichette e di non rompere nulla.

Ho un altro punto di vista:alcuni di loro sono rotto, perché è difficile capire il comportamento dell'algoritmo originale.

Alcune sono dotate di una riduzione delle prestazioni di eseguire lo stesso test due volte, che non può sempre essere banale.L'alternativa, che è in corso la memorizzazione e il passaggio di turno booleane, che diventa brutto.

La pena di prestazioni è minore.Tuttavia sono d'accordo che l'esecuzione di un test due volte non è una bella soluzione.

Il Refactoring la parte di codice in un metodo è effettivamente un non-op:riorganizza come il codice è disposto nel file, ma non ha alcun effetto sul modo in cui è eseguito.

Io non vedo il punto.Yep, non cambia il comportamento, come...refactoring?

Certamente ci sono casi in cui le etichette sono utilizzati in modo non corretto e deve essere rielaborato di distanza.Io non penso che dovrebbero essere trattate come una regola inviolabile.

Sono totalmente d'accordo.Ma come avete sottolineato, alcuni di noi hanno difficoltà durante il refactoring questo esempio.Anche se l'esempio iniziale è leggibile, è difficile da mantenere.