Jaki styl formatowania klamr preferujecie? I czy przeszkadza wam, gdy inni wolą odmienny?

W paru językach kod pisze się pomiędzy klamrami

{
//...
//...
}

I niektórzy ludzie wolą by klamra otwierająca była w tej samej linii co słówko jakieś:

void xyz() {
//...
//...
}

natomiast inni wolą klamrę zepchnąć na dół

void xyz()
{
//...
//...
}

Ja preferuję spychanie klamry na dół, bo czytelniej dla mnie kod wygląda i ładniej, inni mogą też tak lubić lub wolą odwrotnie. Przeszkadza wam, gdy inni ludzie wolą korzystać z innego stylu niż wy? Czy podchodzicie do tego neutralnie mówiąc "kwestia gustu"? Mi nie przeszkadza, który sposób ktoś woli, ważne, że ja mam prawo wyboru. Na YT też są wyskillowani programiści, którzy też mają różny gust. Ogólnie chciałem wiedzieć jakie zdanie macie o spychaniu i niespychaniu klamry otwierającej.

Mi obojętnie kiedyś wolałem pisać z klamra na dole teraz obok z linijką przerwy za klamrą. Inna sprawa, że takie coś ustala się przed rozpoczęciem projektu i powinno być stałe dla całego projektu :)

function cosTam {
    
    return "cos tam";
}

Taki, jaki jest ogólnie przyjęty w danym języku lub w danym projekcie (jeśli są jakieś specjalne wymagania). W Javie klamra otwierająca w tej linijce co deklaracja funkcji. W c# z tego co pamiętam, to dawało się osobną linię.

W pythonie nie ma klamer (buahah @katelx)

Całe szczęście większość edytorów pozwala przeformatować i nie muszę szukać klamr nie wiadomo gdzie - dla mnie logicznym jest, że jak pisze klaprę otwierająca to zamykająca będzie na tym samym poziomie (tak jak begin i end - na tym samym poziomie - w innych jezykach)

A jak z if, stawiacie klamry jeżeli wywołujecie jedną funkcję?

if(warunek)
    funkcja()
else .... 

Czy?

if(warunek) {
                funkcja()
}
else ....

Jeżeli piszesz sam to faktycznie warto się kierować konwencją która wynika z dobrych praktyk, lecz podczas pisania większych projektów wiele zależy od tego na jaki styl umówisz się z resztą ludzi. Najważniejsze żeby był taki sam, a to mocno upraszcza sprawe;)

W JavaScript koniecznie klamra w nowej linijce. W przeciwnym razie jest się podążającym za mainstreamem lamerem bez własnej osobowości.
;)

@Alag

Koniecznie klamry, jak ktoś będzie chciał coś dopisać to się może zamieszać trochę.

@Wizzie

from __future__ import braces

@Alag lepiej używać klamer, bo zazwyczaj prędzej czy później się coś tam dopisuje i pozwala to uniknąć błędów.
Jak juz to czytelniejszym zapisem będzie:

if(warunek) zrobCos()
else zrobCosInnego()

bo przynajmniej ktos czarno na bialym widzi, ze sa ominiete klamry.

@Alag ja albo

 
if(warunek)
    funkcja()
else 
    .... 

albo

 
if(warunek)
{
    funkcja()
}
else 
{
    .... 
}

Inne zaburzają czytelność

kaczus napisał(a)

Inne zaburzają czytelność

Nie zawsze - jeśli indentacja jest prawidłowa to powinno nawet znośnie wyglądać; Ja zawsze wolałem klamrę otwierającą blok pisać w nowej linii i do dziś tak wolę.

Mi to obojętna, ale wnerwiają mnie debile, którym nie jest to obojętne i na siłę próbują narzucić swoje widzimisię.
A takie debile potrafią "naprawiać" kod na swoją modłę, nawet kiedy jest przykaz z góry że standard jest inny.
A brak przestrzegania wybranego standardu to już mnie wnerwia.

Ostatnio trafiłem na ćwoka, który wszystkie proste getery i settery przenosi z pliku cpp do nagłówka, bo dla niego to jest czytelniejsze. Fakt, że nie ma w tej gestii ustalonego standardu, ale po co on to zmienia? Tłumaczę mu, że psuję historię, nie da się wstawić do settera lub gettera breakpointa, a on mi pieprzy o jakiś optymalizacjach, które są naprawdę nieistne (mikrooptymalizacje) i że mniej pisania (nie on to napisał, ale sam przepisuje, więc durny argument).
Próbowałem wytłumaczyć mu, że marnuje czes na głupoty, ale się poddałem i stwierdziłem, że nie będę się kopał z koniem.
Gość oczywiście na stronie wiki z opisem standardu kodowania rozpoczął oczywiście flame na temat stawiania klamerek (wykłócał się z głównym architektem, który pracuje bezpośrednio dla klienta).

Herb Sutter w "C++ Coding Standards" pisał (mniej więcej, piszę z głowy):

Każdy dobry programista musi umieć czytać kod w dowolnym stylu formatowania, który jest spójny, logiczny i powszechnie akceptowany.

To dotyczy gdzie otwierać klamrę, jakie wcięcia mają klamry itd. Wprawdzie w tagach są Java i C#, ale myślę że to jest uniwersalne.

A idiotów umyślnie formatujących wbrew przyjętemu standardowi w projekcie powinno się wywalać.

Osobiście wolę jak klamra zaczyna się w nowej linii, bo mam symetrię między otwarciem a zamknięciem i łatwiej mi zobaczyć blok kodu, ale przez jakiś czas pracowałem w firmie, gdzie przyjęli formatowanie Javowe (kod w C++) i też dało się żyć.

Obojętne. W JS piszę w tej samej linii( i dobrze sie czuję jako "podążającym za mainstreamem lamer bez własnej osobowości" :* ), za to w C++, C# w nowej.

w javie i c preferuje

blablabla {
//body
}

w c#

blablabla
{
//body
}

w groovy itp

blablabla { /* body */ } // bo zazwyczaj jest tu jakis maly expression

jak ktos stosuje inna konwencje to raczej sie nie pluje (chyba ze np. w ogole pomija klamry tam gdzie sa opcjonalne)

Ja tam najbardziej lubię (i akceptuję)

if (warunek) then
begin
  lista operacji;
end;

a nie jakieś tam { } :P

Fi3rce napisał(a):

@Alag lepiej używać klamer, bo zazwyczaj prędzej czy później się coś tam dopisuje i pozwala to uniknąć błędów.
Jak juz to czytelniejszym zapisem będzie:

if(warunek) zrobCos()
else zrobCosInnego()

bo przynajmniej ktos czarno na bialym widzi, ze sa ominiete klamry.
Takie coś to zło wcielone w czystej postaci :] Objawia się dopiero podczas debugowania. Chodzi i 1 linijkę. Jak debugujesz bez wchodzenia do funkcji (bardzo często tak robię) to nie wiadomo czy funkcja zrobCos() się wykonała, czy nie, bo to jedna i ta sama linijka.

if(warunek){//..}