regole (?) Di utilizzo di parentesi/parentesi in perl

Question

Effettuava alcune ricerche ma non riusciva a trovare nulla di utile. Mi chiedevo se c'è una tabella riassuntiva di ordinamento per i principianti per conoscere le "regole" dell'uso di parentesi/parentesi, in particolare, le differenze tra(), [], {}. Purtroppo, nella mia esperienza, use strict e use warnings non dirmi se uso i parens sbagliati.

Ad esempio, di seguito sono riportati i codici legit (b/c provengono da ikegami).

@{"genotype".($i)} 
@{$genotype[$i]} 
$genotype[$i] = [ split (/:/, $original_line[$i])] 
my @genotype = map {[split /:/]} @original_line[6..14] 

Ma questi sono anche i seguenti? Spesso è abbastanza difficile (per me) sapere se sono altre parti (logiche) dei codici che causano il problema. Ordinare tramite parens per me (un principiante) sembra banale per una buona codifica. Qualsiasi guida su come utilizzare correttamente Parens sarà grande.

@{"genotype".[$i]} 
@["genotype".($i)] 
@("genotype".($i)) 
@{$genotype($i)} 
@[$genotype($i)] 
$genotypes[$i] = (split (/:/, $original_line[$i])) 
my @genotype = map ([split /:/]) @original_line[6..14] 

Answer 1

In Perl, parentesi, parentesi graffe e parentesi hanno tutti più significati, ma le parentesi graffe probabilmente ne hanno di più.

• Parens
  • Classificare precedenza 2 * 3 + 4 vs. 2 * (3 + 4).
    • Delimitare gli elenchi di argomenti per le funzioni è una sottocategoria di questo: join "", 1, 2, 3 vs.join("", 1, 2), 3
    • Surround lista degli argomenti di chiamata di metodo con operatore freccia: $foo->bar(1, 2) (non necessario per arglist vuoto)
  • Forza interpretazione del bareword precedente come una chiamata di subroutine. Confronta Foo->new e Foo()->new.
  • coderefs Invoke con operatore freccia: $code->()
  • prototipi subroutine sub foo ($$;$%) { ... }
• parentesi quadre
  • Array pedice operatore my @array = 1 .. 5; $array[1]
  • rifarray letterali my $aref = [1 .. 5]
• graffe
  • Blocchi (per do, sub, map, grep, condizionali, costrutti di ciclo, blocchi nudi, blocchi etichettati, ...)
  • Hash pedice operatore $hash{foo}
  • rifhash letterale my $hashref = { a => 3, b => 2 }
  • blocco dativo print { $filehandles[5] } "Hello world"
  • Operatori di distorsione di circonferenza @{ $aref }, %{ $hashref }, ...
  • blocchi di pacchetto package Foo { ... }

... e quasi tutti i caratteri possono essere utilizzati come delimitatori per gli operatori quote-come q//, qq//, qr//, qx//, m//, s///, tr///, y///, portando a cose interessanti come s(foo){bar}g

---

@{"genotype".($i)} utilizza i ricci per la dereferenziazione simbolica e il paren- zio per (in modo non corretto) la priorità.

@{$genotype[$i]} utilizza parentesi come operatore indice di matrice, e graffe per dereferencing

$genotype[$i] = [ split (/:/, $original_line[$i])] prevede diverse parti: $genotype[$i] e $original_line[$i] uso staffe per matrice subscripting. Lo = [ ... ] usa parentesi per creare un arrayref anonimo. I paren in split(/:/, ...) delimitano semplicemente l'elenco degli argomenti per split (l'ordinamento della precedenza).

my @genotype = map {[split /:/]} @original_line[6..14] utilizza parentesi come operatore di indice in @original_line[6..14] e per un array anonimo in [split /:/]. I ricci sono usati per formare un blocco come primo argomento a map.

Answer 2

map ha due sintassi

map BLOCK LIST 
map EXPR, LIST 

In entrambi i casi, parens può essere usato in tutto args come un sub normale.

map(BLOCK LIST) 
map(EXPR, LIST) 

Una cosa da notare è che, mentre elenco può restituire un elenco vuoto, non può essere omesso del tutto, come si può per i sottomessi.

---

map { [split /:/] } @original_line[6..14] 

è un esempio di map BLOCK LIST, mentre

map([split /:/]) 

fornisce illegalmente ESPR, ma nessuna lista. Ecco sintassi accettabili:

map({ [split /:/] } @original_line[6..14]) 
map { [split /:/] } @original_line[6..14] 
map([split /:/], @original_line[6..14]) 
map [split /:/], @original_line[6..14] 

---

Se l'espressione era qualcosa di simile (2 + $ _) * 3, hai solo queste opzioni:

map({ (2+$_)*3 } ...) 
map { (2+$_)*3 } ... 
map((2+$_)*3, ...) 

Se si rimuove la parentesi da quella ultima, si finisce con l'illegale

map(2+$_) 

È possibile disambiguare utilizzando +

012.

map +(2+$_)*3, ... 

ma è preferibile passare alla notazione map BLOCK LIST.