Co się dzieje, gdy operator warunkowy i warunkowy jest w tej samej instrukcji Perla?

Question

Czy ktoś może wyjaśnić, jak działa ta linia?

return $y < 0 ? - pip2 : pip2 if $x == 0; 

jeśli $y <0 zwraca -pip2, ale to, co zwraca kiedy $y >= 0 i $x != 0?

Linia ta pochodzi z funkcji:

sub _atan { 
    my($y, $x) = @_; 

    return $y < 0 ? - pip2 : pip2 if $x == 0; 
    return atan($y/$x); 
} 

Answer 1

The postfix "czy" oznacza powrót Instrukcja jest wykonywana tylko wtedy, gdy warunek jest prawdziwy, więc

return $y < 0 ? - pip2 : pip2 if $x == 0; 

jest taka sama jak

if ($x == 0) 
{ 
    return $y < 0 ? - pip2 : pip2 ; 
} 

Jeśli jesteś zaskoczony przez: potrójnego operatora, które mogą być zapisane jako zwykły if też, uzyskując tym

if ($x == 0) 
{ 
    if ($y<0) 
    { 
     return -pip2; 
    } 
    else 
    { 
     return pip2; 
    } 
} 

Answer 2

jest tak samo jak

if($x == 0){ 
    if($y<0){ 
    return -pip2; 
    }else{ 
    return pip2; 
    } 
} 

cała funkcja wówczas postać:

sub _atan { 
    my($y, $x) = @_; 
    if($x == 0){ 
    if($y<0){ 
     return -pip2; 
    }else{ 
     return pip2; 
    } 
    }else{ 
    return atan($y/$x); 
    } 
} 

Answer 3

To dobry przykład trudnego do odczytania kodu.

Porównajmy kilka różnych sposobów, aby przepisać przykład kodu i zobaczyć, jak postępujemy, zachowując zwięzłość i poprawiając czytelność.

Ten trójargumentowy tylko wersja wygrywa dla zwięzłości, ale wciąż jest to trudne do odczytania:

sub _atan { 
    my($y, $x) = @_; 

    return $x == 0 ? ($y < 0 ? -pip2 : pip2) 
        : atan($y/$x); 
} 

Uważam, że przykuty operatorów warunkowych (:) są tylko do odczytu, gdy kolejne podmioty wchodzą w położeniu innym:

sub _atan { 
    my($y, $x) = @_; 

    return $x != 0 ? atan($y/$x) : 
      $y < 0 ? -pip2   : pip2; 
} 

Jeszcze krótszy, ale poprawia się czytelność.

Ale co z używaniem if i unless? Czy możemy również użyć zwięzłego, czytelnego kodu?

ze swej natury prosto if/else podejście będzie bardziej gadatliwy:

sub _atan { 
    my($y, $x) = @_; 

    my $atan; 
    if(x == 0) { 
     if($y < 0) { 
      $atan = -pip2; 
     } 
     else { 
      $atan = pip2; 
     } 
    } 
    else { 
     $atan = atan($y/$x) 
    }    

    return $atan; 
} 

Łatwo jest prześledzić przez wyżej i zobaczyć, co wynik będzie. Czytelność wygrywa, ale maleje zwięzłość.

uważam, że za pomocą formularzy oświadczenie modyfikatora unless i if zapewnić czystą sposób dodać logikę zwarciem do fragmentu kodu:

sub _atan { 
    my($y, $x) = @_; 

    return atan($y/$x) 
     unless $x == 0; 

    return -pip2 if $y < 0; 

    return pip2; 
} 

To jest zwarte i przejrzyste, ale wydaje mi się jak mamy więcej zwrotów niż potrzebujemy.

Jeśli więc wprowadzić operatora warunkowego do mieszanki otrzymujemy

sub _atan { 
    my($y, $x) = @_; 

    return atan($y/$x) 
     unless $x == 0;  

    return $y < 0 ? -pip2 : pip2; 
} 

Ta forma jest tak zwięzły jak każdy z powyższych form, ale o wiele łatwiej zrozumieć:

sub _atan { 
    my($y, $x) = @_; 

    return atan($y/$x) 
     unless $x == 0; 

    return $y < 0 ? -pip2 : pip2; 
} 

zagnieżdżonych klauzule "/ else" mogą być trudne do zrozumienia. Zachowując niewielką ostrożność podczas konstruowania kodu decyzyjnego można znacznie poprawić czytelność, a tym samym łatwość obsługi, zachowując jednocześnie zwięzłą ekspresję logiki bazowej.

Zapach kodu, który należy tutaj ustalić, to barokowa kombinacja operatora warunkowego (?:) z formularzem modyfikatora oświadczeń if. Zmieniając kolejność testów i starannie wybierając sposób, w jaki reprezentujemy logikę warunkową, byliśmy w stanie zachować zwięzłość i wyjaśnić kod.

Answer 4

Zbyt wiele linii używanych do rozwiązania problemu sprawia, że ​​kod jest trudny do utrzymania (zawsze zobowiązany do przewijania). Rozwiązanie zagnieżdżone, jeśli jest 4 razy dłuższe. Wyobraź sobie, że praca z ekranem jest 4 razy mniejsza. Moja ulubiona składnia to:

sub _atan { 
    my ($y, $x) = @_; 
    return atan ($y/$x) if $x != 0; 
    return $y < 0 ? -pip2 : pip2; 
} 

Korzyść z używania operatora postfiksu jest mniejsza, jeśli umieścisz je w następnej linii. Ta kolejność linii (zasugerowana przez @daotoad) pozwala umieścić stan postfiksu na prostszej linii.

Początkowa składnia jest również miła, ale nie chciałbym pracować nad kodem zawierającym sugerowane zagnieżdżone, jeśli poprzednie posty.