Czy należy unikać używania instrukcji Java Label?

Etykiety są jak etykiety goto: używaj ich oszczędnie i tylko wtedy, gdy przyspieszą Twój kod i, co ważniejsze, bardziej zrozumiałe,

Na przykład, jeśli jesteś w dużych pętlach sześć poziomów głęboko i napotykasz warunek, który sprawia, że reszta pętli nie ma sensu, aby zakończyć, nie ma sensu mieć 6 dodatkowych drzwi pułapki w instrukcjach stanu, aby wcześniej wyjść z pętli.

Etykiety (i goto) nie są złe, po prostu czasami ludzie używają ich w złym sposoby. Przez większość czasu staramy się napisać nasz kod, aby był zrozumiały dla Ciebie i następnego programisty, który się pojawi. Dokonywanie uber-fast jest drugorzędnym problemem (należy uważać na przedwczesną optymalizację).

Gdy etykiety (i goto) są niewłaściwie używane, sprawiają, że kod jest mniej czytelny, co powoduje smutek dla Ciebie i następnego dewelopera. Kompilator ma to gdzieś.

Jest kilka sytuacji, kiedy potrzebujesz etykiet i mogą być mylące, ponieważ są rzadko używane. Jeśli jednak musisz go użyć, użyj go.

BTW: to kompiluje i uruchamia.

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

Jestem ciekaw, jaka jest Twoja alternatywa dla etykiet. Myślę, że jest to dość dużo będzie sprowadzać się do argumentu "return as early as possible" vs. " użyj zmiennej, aby utrzymać wartość zwracaną, i tylko return na końcu."

Etykiety są dość standardowe, jeśli masz zagnieżdżone pętle. Jedynym sposobem, w jaki naprawdę zmniejszają czytelność, jest to, że inny deweloper nigdy wcześniej ich nie widział i nie rozumie, co oznaczają.

Nigdy nie widziałem etykiet używanych "in the wild" w kodzie Java. Jeśli naprawdę chcesz przełamać zagnieżdżone pętle, sprawdź, czy możesz refaktorować metodę tak, aby Instrukcja early return wykonała to, co chcesz.

Technicznie rzecz biorąc, nie ma dużej różnicy między wczesnym powrotem a etykietą. Praktycznie jednak prawie każdy programista Javy widział wczesny powrót i wie, co robi. Domyślam się, że wielu programistów przynajmniej by się zdziwiło etykietą i prawdopodobnie zdezorientowany.

Uczono mnie ortodoksji pojedynczego wejścia / pojedynczego wyjścia w szkole, ale od tego czasu doceniam wczesne deklaracje powrotu i wyłamywanie się z pętli jako sposób na uproszczenie kodu i uczynienie go jaśniejszym.

Argumentowałbym za nimi w niektórych miejscach, uważam je za szczególnie przydatne w tym przykładzie:

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

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

  }
  purchasedItems.add(item);
}

Myślę, że dzięki nowej pętli for-each etykieta może być naprawdę przejrzysta.

Na przykład:

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

Myślę, że wygląda to bardzo jasno, mając Etykietę taką samą jak zmienna w new for-each. W sumie może Java powinna być zła i dodawać implicit labels for-each variables heh

Użyłem pętli o nazwie Java do implementacji metody Sieve do znajdowania liczb pierwszych (wykonanej dla jednego z problemów matematycznych projektu Eulera), która sprawiła, że była 10x szybsza w porównaniu do zagnieżdżonych pętli. Na przykład jeśli (pewien warunek) wrócić do zewnętrznej pętli.

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

Zapytałem programistę C++, jak złe są pętle, powiedział, że użyje ich oszczędnie, ale czasami mogą się przydać. Na przykład, jeśli masz 3 zagnieżdżone pętle i pod pewnymi warunkami chcesz wrócić do pętla zewnętrzna.

Nigdy nie używam etykiet w kodzie. Wolę utworzyć wartę i zainicjalizować ją na null lub inną nietypową wartość. Straż ta jest często obiektem wynikowym. Nie widziałem żadnego z moich współpracowników używających etykiet, ani nie znalazłem żadnego w naszym repozytorium. To naprawdę zależy od Twojego stylu kodowania. Moim zdaniem używanie etykiet zmniejszyłoby czytelność, ponieważ nie jest to powszechna konstrukcja i zazwyczaj nie jest używana w Javie.

Tak, należy unikać używania etykiet, chyba że istnieje konkretny powód ich używania(przykład uproszczenia implementacji algorytmu jest trafny). W takim przypadku radziłbym dodać wystarczające komentarze lub inną dokumentację, aby wyjaśnić to rozumowanie, aby ktoś nie pojawił się później i nie wymusił tego z jakiegoś pojęcia "ulepszenia kodu" lub "pozbycia się zapachu kodu" lub innej potencjalnie BS wymówki.

Przyrównałbym takie pytanie do decydując, kiedy należy LUB NIE należy używać trójnika if. Głównym uzasadnieniem jest to, że może to utrudniać czytelność i jeśli programista nie będzie bardzo ostrożny, aby nazwać rzeczy w rozsądny sposób, użycie konwencji, takich jak etykiety, może pogorszyć sprawę. Załóżmy, że przykład z 'nextCondition' i ' nextItem 'używał' loop1 'i' loop2 ' dla swoich nazw etykiet.

Osobiście etykiety są jedną z tych cech, które nie mają dla mnie większego sensu, poza Assembly czy BASIC i inne podobnie ograniczone języki. Java ma wiele bardziej konwencjonalnych / regularnych pętli i konstrukcji sterujących.

Uznałem, że etykiety są czasami przydatne w testach, aby oddzielić zwykłą konfigurację, ćwiczyć i zweryfikować fazy i grupować powiązane wyrażenia. Na przykład, używając terminologii BDD:

@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();
}

Twoje opcje formatowania mogą się różnić, ale główną ideą jest to, że etykiety, w tym przypadku, zapewniają zauważalne rozróżnienie między logicznymi sekcjami składającymi się na twój test, lepiej niż komentarze. Myślę, że Biblioteka Spock opiera się właśnie na tej funkcji, aby zadeklarować swoje fazy testowe.