Devrais-je éviter en utilisant Java Énoncés sur l'Étiquette?

Question

Aujourd'hui j'ai eu un collègue de travail, suggèrent je refactoriser mon code pour utiliser une étiquette de contrôle de flux à travers 2 boucles for imbriquées que j'avais créé.Je n'ai jamais utilisé avant, parce que personnellement, je pense qu'ils diminuent la lisibilité d'un programme.Je suis prêt à changer d'avis à propos de les utiliser si l'argument est suffisamment solide cependant.Quelles sont les opinions des gens sur l'étiquette?

Answer 1

De nombreux algorithmes sont exprimés plus facilement si vous pouvez sauter à travers les deux boucles (ou une boucle contenant une instruction switch).Ne vous sentez pas mal à ce sujet.D'autre part, il peut indiquer une trop grande complexité de la solution.Afin de prendre du recul et de regarder le problème.

Certaines personnes préfèrent "d'une seule entrée, une seule sortie approche à toutes les boucles.C'est-à-dire en évitant la rupture (et continue) et de retour anticipé pour les boucles tout à fait.Il peut en résulter de code dupliqué.

Ce que je vais éviter de le faire est d'introduire auxiliaire variables.Masquage de flux de contrôle au sein de l'état ajoute à la confusion.

Le fractionnement marqué boucles en deux méthodes peuvent être difficiles.Les Exceptions sont probablement trop lourd.Essayez une seule entrée, une seule sortie approche.

Answer 2

Les étiquettes sont comme goto:Utilisez-les avec parcimonie, et seulement quand ils font de votre code plus rapide et plus important encore, plus compréhensible,

par exemple, Si vous êtes dans les grandes boucles de six niveaux de profondeur et que vous rencontrez une condition qui rend le reste de la boucle inutile pour terminer, il n'y a aucun sens à avoir 6 piège supplémentaire des portes dans vos instructions de condition pour sortir de la boucle au début.

Les étiquettes (goto) ne sont pas mal, c'est juste que parfois les gens les utilisent dans de mauvaises manières.La plupart du temps nous sommes en train d'essayer d'écrire notre code de sorte qu'il est compréhensible pour vous et à la prochaine programmeur qui vient le long.Le rendant ultra-rapide est une préoccupation secondaire (méfiez-vous de l'optimisation prématurée).

Lorsque les Étiquettes (goto) sont mal utilisés ils rendre le code moins lisible, ce qui provoque la douleur pour vous et à la prochaine développeur.Le compilateur n'a pas de soins.

Answer 3

Il y a peu d'occasions où vous avez besoin d'étiquettes et ils peuvent être source de confusion parce qu'ils sont rarement utilisés.Toutefois, si vous devez utiliser l'un puis l'utiliser.

BTW:cette compile et s'exécute.

class MyFirstJavaProg {  
        public static void main(String args[]) {
           http://www.javacoffeebreak.com/java101/java101.html
           System.out.println("Hello World!");
        }
}

Answer 4

Je suis curieux d'entendre ce que votre alternative aux étiquettes.Je pense que c'est assez bien allez faire bouillir l'argument de "retourner le plus tôt possible" vs"utiliser une variable pour stocker la valeur de retour et retourner à la fin."

Les étiquettes sont assez standard lorsque vous avez des boucles imbriquées.La seule façon de vraiment diminuer la lisibilité, c'est quand un autre développeur n'a jamais vu auparavant et ne pas comprendre ce qu'ils signifient.

Answer 5

Je n'ai jamais vu des étiquettes utilisées dans la "nature" dans du code Java.Si vous voulez vraiment briser à travers les boucles imbriquées, voir si vous pouvez restructurer votre méthode de manière à ce qu'un début de l'instruction return est-ce que vous voulez.

Techniquement, je pense qu'il y a pas beaucoup de différence entre un début de retour et une étiquette.Pratiquement, cependant, presque tous les développeurs Java a connu un début de retour et sait ce qu'il fait.Je suppose que beaucoup de développeurs pourrait au moins être surpris par un label, et probablement confus.

On m'a enseigné la seule entrée / sortie unique de l'orthodoxie à l'école, mais depuis, j'ai appris à apprécier début de retour des déclarations et de sortir de la boucle comme un moyen de simplifier le code et le rendre plus clair.

Answer 6

Je dirais en faveur d'entre eux, à certains endroits, je les ai trouvé particulièrement utile dans cet exemple:

nextItem: for(CartItem item : user.getCart()) {

  nextCondition : for(PurchaseCondition cond : item.getConditions()) {
     if(!cond.check())
        continue nextItem;
     else
        continue nextCondition;

  }
  purchasedItems.add(item);
}

Answer 7

Je pense qu'avec la nouvelle boucle for-each, l'étiquette peut être vraiment clair.

Par exemple:

sentence: for(Sentence sentence: paragraph) {
  for(String word: sentence) {
    // do something
    if(isDone()) {
      continue sentence;
    }
  }
}

Je pense qu'a l'air vraiment clair par avoir votre étiquette de la même variable dans la nouvelle for-each.En fait, peut-être que Java doit être mal et ajouter implicite des étiquettes pour chaque variables heh

Answer 8

J'ai utiliser un Java étiquetés une boucle de la mise en œuvre d'un Crible de la méthode pour trouver les nombres premiers (fait pour l'un de le projet Euler problèmes de mathématiques) qui fait qu'il est 10 fois plus rapide par rapport à boucles imbriquées.Par exemple, si(condition) revenir à la boucle externe.

private static void testByFactoring() {
    primes: for (int ctr = 0; ctr < m_toFactor.length; ctr++) {
        int toTest = m_toFactor[ctr];
        for (int ctr2 = 0; ctr2 < m_divisors.length; ctr2++) {
            // max (int) Math.sqrt(m_numberToTest) + 1 iterations
            if (toTest != m_divisors[ctr2]
                        && toTest % m_divisors[ctr2] == 0) {
                continue primes; 
            }
        } // end of the divisor loop
    } // end of primes loop
} // method

J'ai demandé à un programmeur C++ comment le mauvais marqué les boucles, il a dit qu'il allait les utiliser avec parcimonie, mais ils peuvent parfois venir dans maniable.Par exemple, si vous avez 3 boucles imbriquées et pour certaines conditions, vous voulez retourner à l'extérieur de la boucle.

Donc, ils ont leur utilité, cela dépend du problème que vous essayez de résoudre.

Answer 9

Je n'ai jamais utiliser des étiquettes dans mon code.Je préfère créer un garde et de l'initialiser à null ou une autre valeur inhabituelle.Cette garde est souvent un objet de résultat.Je n'ai pas vu une de mes collègues de travail à l'aide d'étiquettes, ni trouvé dans notre référentiel.Cela dépend vraiment de votre style de codage.À mon avis, à l'aide d'étiquettes permettrait de diminuer la lisibilité que ce n'est pas une commune de la construction et, habituellement, il n'est pas utilisé en Java.

Answer 10

Oui, vous devez éviter d'utiliser l'étiquette, sauf s'il y a une raison particulière de les utiliser (l'exemple de la simplification de la mise en œuvre d'un algorithme est pertinent).Dans ce cas, je vous conseille l'ajout d'assez de commentaires ou d'autres documents pour expliquer le raisonnement derrière cela pour que personne ne viennent plus tard et de la mutilation qu'elle hors de la notion d ' "améliorer le code" ou "se débarrasser de l'odeur de code, ou de quelque autre potentiellement BS excuse.

Je voudrais d'assimiler ce genre de question à décider du moment où l'on devrait ou ne devrait pas utiliser le ternaire si.Le chef de la justification est qu'il peut entraver la lisibilité et à moins que le programmeur est très prudent de nommer les choses d'une manière raisonnable, que l'utilisation de conventions telles que des étiquettes peuvent rendre les choses bien pires.Supposons que l'exemple de l'utilisation de 'nextCondition" et "nextItem' avait utilisé "loop1" et "loop2" pour ses noms de marque.

Personnellement, les étiquettes sont l'une de ces caractéristiques qui ne font pas beaucoup de sens pour moi, en dehors de l'Assemblée ou de BASE et d'autres de la même limitée langues.Java est beaucoup plus classique et normal de la boucle et de contrôle des constructions.

Answer 11

J'ai trouvé les étiquettes pour être parfois utile dans les tests, pour séparer l'habitude d'installation, exercice et de vérifier les phases de groupe et les états connexes.Par exemple, à l'aide de la BDD de la terminologie:

@Test
public void should_Clear_Cached_Element() throws Exception {
    given: {
        elementStream = defaultStream();
        elementStream.readElement();
        Assume.assumeNotNull(elementStream.lastRead());
    }
    when:
        elementStream.clearLast();
    then:
        assertThat(elementStream.lastRead()).isEmpty();
}

Votre choix de mise en forme peut varier, mais l'idée de base est que les étiquettes, dans ce cas, fournir un notable de la distinction entre la logique sections comprenant votre test, mieux que des commentaires.Je pense que le Spock bibliothèque s'appuie sur cette fonctionnalité très à déclarer ses phases de tests.