Regeln (?) Von Parens/Klammern Verwendung in Perl

Question

Hat einige Suche, konnte aber nichts nützliches finden. Ich frage mich, ob es eine Übersichtstabelle für Anfänger Sortierung gibt, um über die "Regeln" der Verwendung von Parens/Klammern, insbesondere die Unterschiede zwischen(), [], {} zu lernen. Leider, in meiner Erfahrung, use strict und use warnings sagen Sie mir nicht, wenn ich die falschen parens verwende.

Zum Beispiel sind unten die legit Codes (b/c sie kamen von Ikegami).

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

Aber sind diese unten auch legit? Oft ist es schwer genug (für mich) zu wissen, ob es andere Teile (Logik) der Codes sind, die das Problem verursachen. Parens für mich (ein Anfänger) zu sortieren, scheint trivial bis gut zu sein. Jeder Leitfaden zur richtigen Verwendung von Parens ist großartig.

@{"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 haben Brackets, Klammern und Parens alle mehrere Bedeutungen, aber geschweifte Klammern haben wahrscheinlich am meisten.

• Parens
  • aussortieren Vorrang 2 * 3 + 4 vs. 2 * (3 + 4).
    • Das Abgrenzen von Argumentlisten für Funktionen ist ein Teil davon: join "", 1, 2, 3 vs.join("", 1, 2), 3
    • Surround Argument Liste des Methodenaufrufes mit Pfeil Operator: $foo->bar(1, 2) (nicht für leere arglist erforderlich)
  • Force-Interpretation des vorherigen Bareword als Unterprogramm-Aufruf. Vergleichen Sie Foo->new und Foo()->new.
  • Invoke coderefs mit Pfeil Betreiber: $code->()
  • Unterprogramm Prototypen sub foo ($$;$%) { ... }
• Eckige Klammern
  • Array Index-Operator my @array = 1 .. 5; $array[1]
  • ArrayRef Literale my $aref = [1 .. 5]
• Curly Klammern
  • Blocks (für do, sub, map, grep, conditionals, Schleifenkonstrukte, bare Blöcke, bezeichnet mit Blöcken, ...)
  • Hash Subskript Operator $hash{foo}
  • hashref literal my $hashref = { a => 3, b => 2 }
  • Dative Block print { $filehandles[5] } "Hello world"
  • Circumfix-Dereferenzoperatoren @{ $aref }, %{ $hashref }, ...
  • Paketblöcke package Foo { ... }

... und fast alle Zeichen als Trennzeichen für Kursähnliche Operatoren q//, qq//, qr//, qx//, m//, s///, tr///, y/// verwendet werden, um interessante Sachen führende wie s(foo){bar}g

---

@{"genotype".($i)} verwendet Curlies für symbolische Dereferenzierung, und Parens (unnötigerweise) sortieren Vorrang.

@{$genotype[$i]} verwendet Klammern als Array-Index-Operator und curlies für Dereferenzieren

$genotype[$i] = [ split (/:/, $original_line[$i])] hat verschiedene Teile: $genotype[$i] und $original_line[$i] Verwendung Brackets für Array Subskribierung. Die = [ ... ] verwendet Klammern, um eine anonyme Arrayref zu erstellen. Die Parens in split(/:/, ...) begrenzen nur die Argumentliste für split (die Präzedenz sortieren).

my @genotype = map {[split /:/]} @original_line[6..14] verwendet Klammern als Array-Subscript-Operator in @original_line[6..14] und für ein anonymes Array in [split /:/]. Die Curlies werden verwendet, um einen Block als erstes Argument zu map zu bilden.

Answer 2

map hat zwei Syntaxen

map BLOCK LIST 
map EXPR, LIST 

In beiden Fällen kann Pars um die args wie ein normales Unter verwendet werden.

map(BLOCK LIST) 
map(EXPR, LIST) 

Eine Sache Bemerkenswert ist, dass, während LIST eine leere Liste zurückkehren kann, kann es nicht ganz weggelassen werden, wie Sie können für U-Boote.

---

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

ist ein Beispiel für map BLOCK LIST, während

map([split /:/]) 

illegal EXPR bietet, aber keine Liste. Hier sind akzeptabel Syntaxen:

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

---

Wenn der Ausdruck war wie etwas (2 + $ _) * 3, müssen Sie nur die folgenden Optionen:

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

Wenn Sie die Pars aus, dass entfernen Endlich kann am Ende, Sie mit dem illegalen

map(2+$_) 

Sie disambiguate mit +

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

aber es ist besser, auf die Notation map BLOCK LIST umzuschalten.