• 
  • Weitere Informationen zu diesem Buch:
    Volltextsuche im Buch bei Google Print

    Inhaltsverzeichnis | Index | Probekapitel | Kolophon | Rezensionen |
    Errata | Beispiele per FTP | Slashdot-Rezension des Originaltitels |

Symbole

0 Kommandozeilen–Option 504, 509

0 but true 734

Ausschluß bei –w 733

0+ Operator (Konvertierung) 365

32–Bit–Systeme 643

64–Bit–Systeme 643

& (Ampersand) 99

& Operator (bitorientiertes UND) 104

&& Operator (logisches UND) 27, 105, 327

&&= Operator (Zuweisung) 109

&= Operator (Zuweisung) 109

Adresse–von–Operator (in C) 113

in Dateinamen 774

Perl–Version 5, -nderungen in der Anwendung 17

Prototypzeichen 235

für Subroutinennamen 6, 55-56, 131, 226

in Prototypen 234

' (einfaches Anführungszeichen) 62

Variableninterpolation unterdrücken 7, 66

Verarbeitung von _bersetzungs–Escapes unterdrücken 200

* (Asterisk) 99

** Operator (Potenzierung) 94

**= Operator (Zuweisung) 109

*? Quantifier 166

*= Operator (Zuweisung) 109

Dereferenzierungsoperator (in C) 113

für Globbing bei Dateinamen 87

Metazeichen 147, 164

Multiplikativ–Operator 92, 97

Prototyp–Zeichen 235

Quantifier 39, 166, 184

für Typeglob–Namen 6, 56, 81

@ (At–Zeichen)

@+ (@LAST_MATCH_END) Array mit Endpositionen 193, 688

@– (@LAST_MATCH_START) Array mit Startpositionen 193, 689

@_ Array (@ARG) 227, 681

für Arraynamen 6, 55

im Debugger 525

in Formatzeilen 243

Prototyp–Zeichen 235

in Strings, Schützen durch Backslash 64

Veränderungen in Perl–Versionen 609

! (Ausrufezeichen)

! Operator (logische Negation), _berladung 367

! Operator (Negation) 95

!! Debugger–Befehl 532

!= Operator (ungleich) 28, 104, 604

!~ Operator (Bindung) 96

Verwendung mit Mustererkennungsoperatoren 150

in Debugger–Befehlen 532

für komplementierte Zeichensätze 182

\ (Backslash) 62

\\ Anführungszeichen, Interpretation mit 7

\Q–Notation zum Backslashing aller nicht–alphanumerischen Zeichen 64

bei mehrzeiligen Befehlen im Debugger 527

als Verzeichnis–Separator unter MS–DOS 919

als Fluchtsymbol für Zeichen 63

zum Schutz von Metazeichen 146, 164

Interpretation durch Regex–Parser 199

für Metazeichen 165

um Metafolgen von Nicht–Metazeichen zu erzeugen 146

für Metazeichen 147

für mehrzeilige Debugger–Befehle 524

quotemeta–Funktion für 791

quotierte Strings, übermäßigen Gebrauch vermeiden in 66

Referenzoperator 95, 254, 266

Rückwärtsreferenz und 42 b16>

` (Backtick) 65, 443

Anwendungsbeispiel 7

Operator 74, 83, 608, 624

Portabilität des 646

qx und 791

Sicherheit und 585

void–Kontext und 624

– (Bindestrich) 99, 209

–*– für Emacs 505

– – Kommandozeilen–Option 509

– – Autodekrement–Operator 26, 94

–= Operator (Zuweisung) 109

–> Operator (Arrow) 93, 262

Dereferenzierung mit 93

Methodenaufruf und 325

arithmetischer Negationsoperator 95

in Debugger–Befehlen 531

Subtraktions–Operator 98

in Zeichenbereichen 173

Zeichensatz–Subtraktion 181

$ (Dollar–Zeichen) 12

$line 33

$0 ($PROGRAM_NAME) 693

$1 etc. 679

$a und $b (sort–Variablen) 679

$' ($POSTMATCH) 152, 192, 612, 692

$& ($MATCH) 152, 192, 612, 690

$* 679

$@ ($EVAL_ERROR) 683

$! ($ERRNO, $OS_ERROR) 28, 646, 691

$\ ($OUTPUT_RECORD_SEPARATOR) 514, 692

$` ($PREMATCH) 152, 192, 612, 693

$$ ($PROCESS_ID) 57, 693

$#

Präfix für letzten Arrayindex 79

veraltete Variable für numerische Ausgabe 679

$: ($FORMAT_LINE_BREAK_CHARACTERS) 245, 685

$? ($CHILD_ERROR) 681

Backtick–Operator und 83

close–Funktion und 715

$= ($FORMAT_LINES_PER_PAGE) 246, 685

$> ($EFFECTIVE_USER_ID) 682

$^ ($FORMAT_TOP_NAME) 246, 249, 605, 685

$^A ($ACCUMULATOR) 249, 680

Ausgabe der formline–Funktion 739

$^C ($COMPILING) 682

$^D($DEBUGGING) 510, 682

$^E ($EXTENDED_OS_ERROR) 684

$^F ($SYSTEM_FD_MAX) 440, 696, 735

$^H (Hinweise für Perl–Parser) 685

$^I ($INPLACE_EDIT) 686

$^L ($FORMAT_FORMFEED) 246, 685

$^M (Memory–Pool) 690

$^O ($OSNAME) 641, 690

$^P ($PERLDB) 692

$^S ($EXCEPTIONS_BEING_CAUGHT) 684

$^T ($BASETIME) 103, 681

$^V ($PERL_VERSION) 692

$^W ($WARNING) 142, 696

$^X ($EXECUTABLE_NAME) 684

$[ (Index der ersten Arrayvariable) 679

$] ($PERL_VERSION) 690

${^ (interne Variablennamen) 57

${^WARNING_BITS} 697

${^WIDE_SYSTEM_CALLS} 419, 697

$( ($REAL_GROUP_ID) 693

$) ($EFFECTIVE_GROUP_ID) 682, 693

$<; ($REAL_USER_ID) 694

$, ($OUTPUT_FIELD_SEPARATOR) 691

$– ($FORMAT_LINES_LEFT) 246, 249, 685

$+ ($LAST_PAREN_MATCH) 192, 689

$% ($FORMAT_PAGE_NUMBER) 246, 685

$. ($INPUT_LINE_NUMBER) 106, 687

Rücksetzen mit close–Funktion 715

$; ($SUBSCRIPT_SEPARATOR) 81, 695

$/ ($INPUT_RECORD_SEPARATOR) 509, 687

$~ ($FORMAT_NAME) 246, 605, 685

$_ ($ARG), Variable 37, 40, 680

Angle–Operator und 83

foreach–Anweisungen und 122

glob–Funktion mit 87

grep–Funktion und 752

map–Funktion und 763

$| ($OUTPUT_AUTOFLUSH) 246, 605, 691

beim Debugger 525

Dereferenzierung mit 261

Interpolation von skalaren Variablen und 64

beim Matching, Zeilenende–Zusicherung 156, 187

Metazeichen 147, 164

Prototyp–Zeichen 235

für Skalarvariablen–Namen 6, 10, 54

# (Doppelkreuz)

#! (Shebang–Notation) 19, 504

Sicherheitsprobleme durch 588

Simulieren bei nicht–Unix–Systemen 506

für Kommentare 51

/x–Modifier, Verwendung mit 154

in Formaten 244

Quoting–Zeichen, Whitespace und 67

: (Doppelpunkt)

:: bei vollständig qualifizierten Namen 57

:: in Modulnamen, Umwandlung in Verzeichnis–Separatoren 312

:: für Paket–Identifier 68, 302, 609

in Labels 119

in Modul–Importlisten 684

in Muster–Clustern 195

in Subroutinen–Deklarationen 239-240 b16>

in XSUBs 551

Zeilenumbrüche bei Formaten mit $: 685

? (Fragezeichen) 99

? Quantifier 39, 166, 184

(?!) 211

?: Operator (Konditional–) 108, 130

?? Quantifier 166, 184

(?=) 211

(?>) 213

(?<;!) 212

(?<;=) 212

Metazeichen 147, 164

Quantifier 166

= (Gleichheitszeichen)

= Operator (Zuweisung) 7

= = Operator 25, 28, 104, 604

= => Aktuelle–Zeile–Markierung 525

=> Operator 11, 79

=~– Operator (Bindung) 37, 96

Verwendung mit Pattern–Matching–Operatoren 150

Debugger–Befehl 533

in POD–Direktiven 652

> (rechte spitze Klammer)

> Operator 22, 28, 103

<;> Zeileneingabeoperator siehe Angle–Operator

>= Operator 28, 103

>> Operator 98

>>= Operator 109

in Debugger–Befehlen 532

für Globbing von Dateinamen 86

in Dateinamen 771

für Rechtsausrichtung 248

^ (Hütchen)

^= Operator (Zuweisung) 109

besonderes Verhalten im Muster verhindern 173

für Fülltext in Formaten 243

Invertierung von Zeichenklassen 173

beim Matching 209

Zeilenende–Zusicherung 156

Metazeichen 147, 164

Operator (bitorientiertes EXKLUSIV–ODER) 104

Zeilenanfang–Zusicherung 40-41, 187

[ ] (eckige Klammern)

[ Metazeichen 147, 164

Array–Composer 254

Arrays und 10, 12

\C für Unicode und 422

für Zeichenklassen 38, 165, 169, 172

zur Erkennung von Zeichen 209

und \p, \P für Unicode 422

Vorrang von 91

\X für Unicode und 423

{ } (geschweifte Klammern) 274, 604, 622

{ Metazeichen 147, 164

für Anweisungsblöcke 31, 52, 117

und Datei–Globbing vor langer Zeit 87

in Debugger–Befehlen 532

in Formaten 244

Hashschlüssel umschließend 12

Hash–Composer 255

für Hashes 13

Identifier in 64

leere Blöcke erzeugen mit 128

Quantifier 39, 166

in Strings 302

Suchmuster verdeutlichen mit 68

für Unicode 170, 421

Vorrang 91

( ) (Klammern) 12, 91, 605, 623

(...) Gruppierung 165

(?:MUSTER)–Notation, Clustering ohne festzuhalten 193

automatisch einfügen mit Deparse 497

für Rückwärtsreferenzen 42, 190, 192

Capturing (Festhalten) in Mustern 148, 152, 159

in Funktionen 699

Gleichgewicht 222

Gruppierungsoperator 209

Konditional–Operator, Verwendung mit 108

für Listenwerte 75-76

Metazeichen 147, 164

als Quoting–Zeichen 77

in Subroutinenaufrufen 226, 240

<; (linke spitze Klammer)

<;> Operator siehe Angle–Operator

<;> Zeileneingabeoperator siehe Angle–Operator

<; Operator 22, 28, 103

<;= Operator 28, 103

<;=> Operator 28, 104, 812

<;<; für Here–Dokumente 68, 98

<;<;= Operator (Zuweisung) 109

in Debugger–Befehlen 531

für Dateinamen–Globbing mit <;> 86

in Dateinamen 771

zur Linksausrichtung 248

, (Komma)

$, Variable 691

Fehler in print–Anweisungen 604

große Zahlen und 62

Operator 111

skalarer Kontext 611

Operator siehe auch  =>–Operator

in print–Anweisungen 692

Schleifendeklarationen, Verwendung in 121

Schlüssel/Wert–Paare und 11, 79

als Separator 12

Separierung von Listenwerten 75, 77

Vorrang 92, 136

+ (Pluszeichen) 99

+? Quantifier 166

+= Operator (Zuweisung) 109

++ Autoinkrement–Operator 26, 94

additiver Operator 98

in Dateinamen 771

Metazeichen 147, 164

Quantifier 38, 166, 184

unärer Operator 92, 95

% (Prozentzeichen) 99

%= Operator (Zuweisung) 109

für Hashnamen 10, 55

Modulus–Operator 97

Prototyp–Zeichen 235

für Prüfsummen 844

zur Kennzeichnung des Variablentyps 6

. (Punkt) 99

... (Bereichsoperator) 106

in @INC 876

.= Operator (Zuweisung) 109

.. Bereichsoperator 106

in Zeichenklassen 182

Datei–Globbing und 749

Metazeichen 147, 164

in Mustern 209

Operator (Verkettung) 616

Quantifier, Nutzung in 39

Trennzeichen in v–Strings 70

Vektoren (IP–Adressen) 742

Verkettungsoperator 24, 98

automatische Generierung durch Stringification–Handler 367

Zeichen–Wildcard 39, 154, 171

; (Semikolon)

einfache Anweisungen, endend mit 51, 115

in Debugger–Befehlen 527

Fehler, Weglassen von 604

in Dateinamen, Sicherheitsrisiken 584

/ (Slash) 99

/= Operator 109

// siehe m//–Operator

Debugger–Befehl 531

Divisionsoperator 97

Root–Verzeichnis 714

Trennzeichen, ersetzen 65

~ (Tilde)

Auflösung des Home–Verzeichnisses 749

bitorientierter Negationsoperator 95

zur Unterdrückung von Leerzeilen 245

_ (Unterstrich)

doppelt 71

Felder, Verwendung in 872

globales Dateihandle 679

große Zahlen und 62

in Identifiern 51, 57

Portabilität 645

Tainting und 580

in Variablennamen 303, 624

Veränderungen in Perl–Versionen 609

| (vertikaler Strich)

–| Pipe–Pseudobefehl 445

...|... Alternierung 148, 165, 195

|– Pipe–Pseudobefehl 444

|= Operator (Zuweisung) 109

|| Operator (logisches ODER) 105, 197, 327

Vorrang, chdir vs. 92

||= Operator (Zuweisung) 109

|| Debugger–Befehl 533

Debugger–Befehl 533

für Zentrierung 247

in Dateinamen 771

Metazeichen 147, 164

Operator (bitorientiertes ODER) 104

A

–A Datei–Testoperator 101, 103, 681

\a (Alarm– oder Bell–Zeichen) 63

–a Kommandozeilen–Switch (Autosplit) 509, 684

\A (String–Grenze) 187

Abbildung von Schlüsseln, Pseudo–Hashes 347

Abfangen

Ausnahmen 727

Signale 429

zuwenig Arbeitsspeicher 690

Abfangen der Ausgabe

von externem Befehl 834

von Funktionen 446

Abfangen von Signalen, Handler 429

abgeleitete Klassen 322

Methoden als Wrapper um Basisklassenmethoden 337

Abkürzungen, Text 892

abs–Funktion 704

komplexe Zahlen und 930

_berladung 369

Absatz–Trennzeichen 51

Absatzmodus 509, 687

Abschneiden

Argumentliste 538

Arrays 79

Zahlen 753

Abstraktion 299

in der objektorientierten Programmierung 324

accept–Funktion

Anwendungsbeispiel 457-458, 927

Definition 705

Portabilität 642

bei im voraus gestarteten Servern 438

Signale und 432

Verwendung mit connect 716

Verwendung mit FileHandle–Modul 833

Accessor–Methoden 332

erzeugen 345

Klassendaten–Methoden, arbeitend wie 357

mittels Autoloading erzeugen 350

mittels Closures erzeugen 351

Pseudo–Hashes und 347

$ACCUMULATOR 680

ActiveState Perl–Distribution

Installation auf Windows–Systemen 506

Microsoft–spezifische Module 901

PPM (Perl Package Manager) 569

Addition 23

überladener Plus–Operator (+) 363

additive Operatoren 98

Adresse–von–Operator (in C) 113

Adressen

C verglichen mit Perl 608

ermitteln aus Hostnamen 744

gepackter Socket 748

Netzwerk, ermitteln aus Hostnamen 742

Netzwerk, in Namen übersetzen 742, 744

Socketnamen als 706

wiederverwendete, Ausgabe des Inhalts 538

Aktionen (Debugger)

Auflistung aller 529

Befehlsausführung festlegen aus Debugger 531

.al (Dateinamen–Erweiterung) 308

Alarm–(Bell–)Zeichen 63

alarm–Funktion 705

Mischen mit sleep 811

Portabilität 642

für Timeouts beim Pattern–Matching 602

Algorithmen, Perl–Module für 567

Aliase

für Zeichen 170

Debugger–Befehl für 533

durch Zuweisung an Typeglob 305

in for/foreach–Schleifen 123

Suchen/Ersetzen von Elementen in Arrays 160

von Symboltabellen–Einträgen 58, 82

ALRM–Signal

Anwendungsbeispiel 429

Definition 433

Alternierung 148

Geltungsbereich beschränken 193

Matching des einen oder des anderen (...|...) 165

in Mustern 195

Vorrang, Pattern–Matching 207

Zeichenklassen und 173

Anfänge von Strings erkennen 187

Anfänger, gängige Fehler von 603

Anführungszeichen 7

doppelte 149

in formline–Argumenten 739

interpolativer Kontext 74

in geschweiften Klammern 64

bei Nicht–Unix–Systemen 507

Quoting–Operatoren 65

Strings 8

Art der Stringausgabe ändern 538

Strings und 62

weglassen 67

 siehe auch 1  Anführungszeichen unter Symbole

 siehe auch 1  doppeltes ­Anführungszeichen und einfaches Anführungszeichen unter Symbole

Anhalten siehe Beenden

Anhängen

Elemente an Arrays 281, 790

Elemente zu existierendem Hash 290

Strings an Strings mit .= 25, 109

anhängende Leerzeichen in Stringvergleichen 103

Anker 41, 186

anonym

Array–Composer 254

Arrays

Hash von, erzeugen 287

zweidimensionaler Array–Slice 283

Hash–Composer 255

Hashes

Array von, erzeugen 289

Datenstruktur für Objekte 330

hinzufügen zu mehrdimensionalen Hashes 291

Pipes 442

Referenten 253

Subroutinen 225

Vergabe von Namen zur Laufzeit 306

Subroutinen–Composer 257

Anpassen, Debugger 535

Editor–Unterstützung 535

Funktionen für 542

init–Dateien nutzen 535

Optionen 536

Anweisungen 115

einfache 115

globale Deklarationen und 132

if und unless 118

Perl, evaluieren aus C 558

Schleifen siehe Schleifen

verglichen mit Schleifensteuerungsoperatoren 127

zusammengesetzte 117

AnyDBM_File–Modul 896

Apache–Webserver 556

CGI::Apache–Modul 896

mod_perl–Erweiterung 492

Perl–Module für 568

„ä“–Grad 89

höchster zu niedrigstem, Auflistung 90

$ARG ($_) 83, 680

Argumente, formal 681 b16>

@ARGV–Array 85, 681

–s Switch und 516

Anwendungsbeispiel 33, 126, 163, 216, 451, 826

EOF und 727

pop und 787

shift und 808

Tainting und 577

$ARGV–Variable 677, 681

bei C und Perl 608

ARGV–Dateihandle 677

ARGVOUT–Dateihandle 681

arithmetische Operatoren 95

binäre arithmetische Operatoren 23, 94

Reihenfolge der Evaluierung 23

_berladung 363, 366

Arkustangens–Funktion siehe atan2

Arrays 6, 9, 53-54, 68

@_–Arrays 227

Werte in my–Liste kopieren 228

anonym, Objekte implementiert als 346

use fields–Pragma, Probleme umgehen mit 347

anonym, Referenzen auf 254

assoziativ siehe Hashes

Ausgabestil, im Debugger ändern 538

AV (Array Value) 548

Elemente anhängen 790

Elemente entfernen aus 808, 816

Elemente ersetzen/entfernen 816

Elemente voranstellen 845

Elemente, Zuweisung temporärer Werte an 760

erstes Element von 679

exists–Funktion und 731

Größe 78

von Hashes 288

erzeugen 289

Zugriff und Ausgabe 290

Hashes von 286

Index–Trennsymbol siehe Dollar–Zeichen, $; unter Symbole

Initialisieren mit x–Operator 97

letztes Element 78

Listen und 75

mehrdimensional 13, 279

Namen 55

negative Indizes, Zählung vom Ende des Arrays 611

Parsing von Text in 892

Performance 616

pop–Funktion und 787

Referenzen auf 253

s///–Operator (Substitution) und 160

Tying 387

Methoden zum 388

Schreibweise 392

Tie::Array–Modul 898

über tie gebundene, delete–Funktion und 611

_bergabe mittels Referenz an/aus Funktionen 232

Variablen von 68

Verarbeitung, Funktionen zur 702

verschachtelt 279

zweidimensionale Arrays, Erzeugung und Zugriff 280

vertrauenswürdige (Tainting) 577

Arrow–Operator (–>), zur Dereferenzierung 262

 siehe auch 1  Bindestrich unter Symbole

ASCII 50

Konvertierung in Unicode 421

Umwandlung in Zeichen 714

Werte für Zeichen 778

ASP, Perl–Module für 569

assoziative Arrays siehe Hashes

Assoziativität von Operatoren 89, 103

Astronomie, Perl–Module für 569

async–Funktion (im Thread–Modul) 467

atan2–Funktion

komplexe Zahlen und 930

zur Berechnung von pi 706

$atime–Dateistatistik 823

Atome 208

beim Pattern–Matching 209

atomische Operation 591

Attribute

attributes–Pragma 897

Dateien, Testoperatoren 29

Klasse 767

Zustand speichern 356

locked und Methoden, Verwendung mit Threads 355

locked, Subroutinen 476

Lvalue, Subroutinen 355

bei objektorientierter Programmierung 332

Objekte, Hashes von 14

Subklassen, Superklasse überschreiben 346

Subroutinen 239

Namen, Syntax für 240

Variableninterpolation und 778

attributes–Pragma 239, 862

attrs–Modul (veraltet) 897

Audio, Perl–Module für 569

Auflistung von Code 530

Aufruf

mittels Referenz 227, 232

mittels Wert 228

Subroutinen, indirekt 226

aufrufen siehe ausführen

Aufrufer 324

Ausdrücke

AUDR und LISTE 117

goto und 131 b16>

s///e und 215

Schleifen und 120

ausführbares Image 482

Ausführen

andere Programme aus Perl 834

Code 490

konditional 28

Reihenfolge 501

Methoden 324

Perl–Programme 19, 483, 503

unbeaufsichtigt (Parsing–Optionen) 539

Ausführlichkeit

Debugger 537

Warnungen 897

Ausführungsphase 483

verglichen mit Laufzeit 484

Ausgabe 21

Array und Hash, Stil ändern (Debugger) 538

Dateien, open–Modus für 772

Datensatz–Trennsymbol siehe $\ unter Symbole

Datensatzformate deklarieren 243

Debugger, wählen 539

Feld–Trennsymbol siehe Dollar–Zeichen, $, unter Symbole

Format–Ausgabeakkumulator 739

Funktionen für 702

Pipes 442

bidirektional 447

filtern 445

STDOUT als Pipe zu anderen Programmen 443

tridirektional 447

Prüfung von Dateideskriptoren für 804

Selektion von Dateihandles für 803

Verwendung von ioctl für 754

XSUBs 554

Ausgabe abfangen

von externem Befehl 834

von Funktionen 446

 siehe auch 1  STDOUT–Dateihandle

Ausgaben

Arrays von Hashes 290

Hashes von Arrays 288

mehrdimensionale Arrays 282, 286, 290

mehrdimensionale Hashes 292, 295

Typeglob–Inhalte 538

verschachtelte Datenstrukturen 529

Ausnahmen

abfangen 695, 727

auslösen bei Fehlern 897

auslösen zur Anzeige eines Subroutinen–Fehlers 229

auslösende Funktionen 704

in abgekoppelten Child–Threads 470

die und 722

Module für 898

Threads, abfangen 469

unsichere Daten 578

Ausrichtung 243

Ausrufezeichen (!) siehe Ausrufezeichen unter Symbole

Authentifizierung, Perl–Module für 568, 897

Autodekrement–Operator (– –) 26, 94

magischer 368

Autoflushing von Puffern 691

Autogenerierung, _berladung 366

unterbinden 372

Autoinkrement–Operator (++) 26, 94, 368

magischer 94

AUTOLOAD–Subroutine 131, 307, 341

und goto 751

AutoLoader–Modul 308, 899

Autoloading

Erzeugung von Accessoren mittels 350

Methoden 341

automatische Zeilenende–Verarbeitung 514

Autorisierung, Perl–Module für 568

AutoSplit–Modul 308, 899

Portabilität 645

Autosplit–Modus (mit –a–Switch) 509

autouse–Pragma 863, 899

Autovivification 93, 732

Definition 263

von Dateihandles 770, 923

von Typeglobs 259, 400

AV (interner Arraywert) 548

awk 36

Konvertierung nach Perl 81

B

\b Backspace–Zeichen 167

in Regex–Zeichenklassen 173, 188, 209

\b–Zusicherung (Wortgrenze) 41, 147, 188

für Backspace 173, 209

\B–Zusicherung (Nicht–Wortgrenze) 167, 188

–B Datei–Testoperator 102

–b Datei–Testoperator 100

B–Modul 900

B::Asmdata–Modul 900

B::Assemble–Modul 900

B::Bblock–Modul 900

B::Bytecode–Modul 494, 900

B::C– und B::CC–Module 495, 900

B::Debug–Modul 900

B::Deparse–Modul 496, 901

B::Disassembler–Modul 901

B::Lint–Modul 496, 901

B::Showlex–Modul 901

B::Stash–Modul 901

B::Terse–Modul 901

B::Xref–Modul 496, 901

Backends, Compiler 493, 900

generische Schnittstelle auf 901

Module 493

Backquotes (`) siehe Backticks unter Symbole

Backslash (\) siehe Backslash unter Symbole

Backspace 63

\b–Zusicherung in Zeichenklassen 167, 173, 188, 209

Backtick (`) siehe Backtick unter Symbole

Backtracking 205

beim Pattern–Matching 205

Teilmuster ohne Backtracking 213

Backup–Dateien 513

Barewords 67

-nderungen in Perl–Versionen 609

strict–Pragma, Nutzung abfragen 143

vermeiden, Gründe 606

base–Pragma 336, 864, 897

Pseudo–Hash–Implementierungen, Anforderungen an 348

$BASETIME 681

basetime ($^T) 681

BASIC, Programmiersprache, logische Operatoren aus 27

Basisklassen 322, 898

Aufruf aller überschriebenen Methoden 340

Konstruktoren und 334

Methoden überschreiben aus 337

für POD–Filter und –_bersetzer 898

UNIVERSAL–Modul, allen Klassen bereitstellen 898

Basisname, Dateien 893

bedingte Ausführung von Code 28

Bedingungsvariablen 476

Beenden

Debugger 537

Einmal–Blöcke 127

Endlosschleifen 122

if– oder unless–Blöcke 128

Perl–Debugger 533

Programme 3

Prozesse 757

Beendigung von Escape–Sequenzen für die Zeichen–Modifikation 64

Beendigung von Threads

detach–Methode 470

join–Methode 468

Befehle

Debugger 527

Aktionen und 531

Breakpunkte 528

Code lokalisieren 530

Datenstrukturen ausgeben 529

Debugger beenden 533

Debugger neu starten 533

Dokumentation ausgeben 534

Einzelschritt und Ausführung 527

Optionen bearbeiten 534

Tracing 529

Hashes von Funktionen speichern in 294

Namen für 16

Nutzung bei eingeschränkten Privilegien 585

unter POD 653

Pufferung 691

zur Schleifensteuerung 125

Verarbeitung von 503

Lage von Perl 508

 siehe auch 1  Interpreter; Perl–Interpreter

wieder aufrufen, Debugger–Option 536

Befehls–History im Debugger 524

Befehlseingabeoperator siehe Backtick–Operator

Befehlspufferung siehe Pufferung, Befehl

BEGIN–Blöcke 482, 548

@INC einrichten 312

Initialisierung von Variablen vor dem Aufruf von Subroutinen 231

Parsing einer Datei ändern durch 499

Reihenfolge der Abarbeitung 498

beidseitige Pipe, mit über tie gebundenem Dateihandle öffnen 406

benannt

Pipes 449

unäre Operatoren 98

Auflistung 98

Zeichen 63

einfügen 422

Metasymbole für 171

Benchmark–Modul 900

Laufzeiten verschiedener Codeversionen vergleichen 902

Benutzer

Authentifizierung, Perl–Module für 568

CPU–Zeiten 839

eingeschränkte Privilegien zuweisen 576

Informationen ermitteln über 703

Benutzer–Effizienz, Perl–Programmierung 621

Benutzer–ID siehe UID

benutzerdefinierte Funktionen siehe Subroutinen

Benutzernamen, Eintrag in passwd–Datei 747

Benutzerschnittstellen, Module 896

Bereiche

Zeichen 173

Zeichensätze, angeben in 162

Bereichsoperator (.. und ...) 106

Berichte (Reports) generieren 243

Beschmutzung (Poluting) des Namensraums 314

Betriebssysteme xvii

#!–Technik, Simulation auf Nicht–Unix–Systemen 506

Aufruf des Interpreters mit #!–Zeile 504

flock–Unterstützung 435

fork–Unterstützung 442

GUIs benötigende 645

Kommandointerpreter für 503

Modulnamen übersetzen in Verzeichnisnamen 312

Namen 690

Perl–Interpreter starten 19

Perl–Module für 567

Portabilität von Perl–Programmen 565, 641

Schnittstellen auf, bearbeiten 894

Signale und Standardverhalten von 430

Sockets, Support für 455

Threading von Bibliotheken 466

Zeilenvorschübe, Varianten 642

Zuverlässigkeit von Signalen 432

Bibliotheken

C/C++, laden als Perl–Erweiterungen 899-900

Definition 856

ExtUtils::Liblist–Modul 899

math–Bibliothek (C) 555

nicht–installierte Erweiterungen von MakeMaker 899

Perl–Bibliotheksdateien, Suche nach 520

Perl, Modul installieren in 570

bidirektionale Kommunikation, Pipes 447

bidirektionales Rendering, Unicode–Eigenschaften 178

Big–Endian 643

mit pack 780

mit vec 849

/bin/sh siehe sh

binär

Modus für Dateihandles 706

Operatoren siehe binäre Operatoren

pack–Funktion 780

Wiederholungsoperator (x) 24

Binärdatei 776

Dekompilierung mit B::Deparse–Modul 497

als reguläre Datei 29

binäre Operatoren 23, 89, 89

_berladung 362

bind–Funktion 706

Anwendungsbeispiel 457

Portabilität 642

SO_REUSEADDR und 808

Bindung

DBM–Datei an Hash 718

Operatoren (=~, !~) 37, 96, 150

Variablen an Pakete 377, 837, 845

binmode–Funktion 706, 776

Portabilität 642

mit seek und tell bei DOS 642

sysopen und 832

für mit tie gebundene Dateihandles 403 b16>

Biologie, Perl–Module für 569

Bitmasken 804

bitorientierte Operatoren 104, 112

Negationsoperator (~) 95

Anwendungsbeispiel 932

_berladung 367

UND–Operator (&), Anwendungsbeispiel 932

Bitshift–Operatoren (<<, >>) 98, 109

Bitshift–Operatoren (<<, >>) siehe auch  linke spitze Klammer und rechte spitze Klammer unter Symbole

Bitvektor, Arrayschnittstelle für 413

bless–Funktion 257, 268, 330, 708

Anwendungsbeispiel 626, 708, 794

implizite Dereferenzierung und 253

Konstruktoren, Verwendung mit 330

Typeglobs und 258

verglichen mit tie 378

blib–Pragma 865, 899

blib–Verzeichnis 553

$blksize–Dateistatistik 823

Blöcke 31, 52, 115, 117, 262

continue–Block 120

leere 127

Paketdeklaration 301

Schleifen und 758

 siehe auch 1  Anweisungen

Blockeigenschaften, Unicode 179

Blockpufferung siehe Pufferung, Block

$blocks–Dateistatistik 823

Boolesch

Definition für Wahrheit 30

Kontext 73

Boolescher Konvertierungsoperator 365

m//–(Match–)Operator in 156

Operatoren 29

Werte 8

Bootstrapping von Modulen 552, 899

break–Anweisung siehe last–Operator

break–Befehl (in C) 607

Breakpunkte

Auflistung aller 529

entfernen 529

setzen 523, 526, 528

Watch–Ausdrücke und 529

Breite

von Zahlen 643

Zeichen–Repräsentation 418

BSD::Resource–Modul, prozeßbezogene Ressourcen–Limits setzen 602

Bugs in Perl melden xxxi, 946

Bundles 566

Byte–Bedeutungen, Zeichenklassen–Abkürzungen 174

Bytecode 482, 547

ByteLoader–Modul 494, 901 b16>

Bytes 49

Bitshift–Operatoren 98

lesen 792, 833

Zeichen verglichen mit 417, 701

bytes–Pragma 421, 894

C

–c Dateitest 100

–c Kommandozeilen–Switch 509, 548, 682

Perl–Compiler und 485

–C Kommandozeilen–Switch (systemeigene Wide–Character–API) 419, 510, 697

–C Dateitest 103, 681

\C Wildcard–Metasymbol (Matching eines einzelnen Bytes in C) 167, 171, 422

/c–Modifier 162

fehlgeschlagene Matches, Suche nach 189

C

Bibliothek, Coredumps erzeugende Signale in 429

Bibliotheksfunktionen 700

C–Codegeneratoren 495

C–Stack, Speichern von C–Variablen auf 491

fcntl.h–Definitionen, als Perl–Konstanten laden 894

Matching eines Zeichens 422

Operatoren

bei Perl fehlende 113

logische Operatoren 105

Vorrang–Beziehungen 91

Perl erweitern mit 547, 549

Erweiterungen erzeugen 551

externe C–Bibliothek, Verwendung von Funktionen aus 555

Wrapper um Perl–Funktionen 550

XSUBs und XS 550

Perl verwenden aus 556

Kompilierung eingebetteter Perl–Programme 556

Perl–Anweisung evaluieren 558

Perl–Interpreter einbinden 557

Perl–Stack manipulieren 560

Perl–Subroutine aufrufen aus 557

XSUB–Ein– und –Ausgaben 554

Präprozessor 516

Programmierung, Unterschiede zu Perl 607

Sicherheit verglichen mit Perl 577

statische Variable 230

struct 783

syslog–Funktionen aus Perl nutzen 894

Typedefs 548

Wrapper–Programme 588

Zugriff auf Perl 493 b16>

Caching 276, 451

Anwendungsbeispiel 395, 627, 629

bereitstellende Module 412-413

von Zeichenklassen 182

von Dateien 893

von im Speicher liegenden Objekten 356

von Methoden–Lookups 336

mit stat 679

von Systemdateien 617, 741

Web 568

Callbacks 270, 827

in Pod::Parser 663

in XML::Parser 634

caller–Funktion 709

Anwendungsbeispiel 235, 354, 394, 664, 936

und der Kontext–Stack 491

Perls Debugger und 540

Veränderungen über Perl–Versionen hinweg 610

Verwendung mit goto 131, 751

can–Methode (UNIVERSAL–Paket) 339

Capturing (Festhalten) in Mustern 190

Clustering 193

Wörter, alphanumerisch 157

Carp–Modul 382, 898, 904

 siehe auch 1  die–Funktion; warn–Funktion

case–Struktur 129

Casting, Strings und 61

cat–Befehl (Unix) 395

cbreak–Option 740

/cg–Modifier 157

CGI

CGI.pm–Modul 905

mod_perl und xxix

Newsgruppen xxxi

Notwendigkeit des Taint–Modus 577

Performance unter mod_perl 492

Perl–Module für 568, 896

Safe–Abteile 595, 598

scheinbar hängende Skripten 738

Sicherheit von Skripten 459

 siehe auch 1  HTML

CGI::Apache–Modul 896

CGI::Carp–Modul 896, 905

CGI::Cookie–Modul 896

CGI::Fast–Modul 896

CGI::Pretty–Modul 896

CGI::Push–Modul 896

charnames–Pragma 422, 894

Charts erzeugen 243

chdir–Funktion 710

Anwendungsbeispiel 118, 586, 644, 723

Beispiel für _berschreibung 318

mit Cwd–Modul 908

Verhalten ohne Argument 520

Vorrang und 92 b16>

CHECK–Blöcke 482, 548

Reihenfolge der Ausführung 498

Chemie, Perl–Module für 569

Child–Prozesse

ID zurückgeben 737

lesbar, starten 443

schreibbar, starten 442

 siehe auch 1  Prozesse

$CHILD_ERROR 681

chmod–Funktion 20, 710

Anwendungsbeispiel 87, 700, 844

Portabilität 642

chomp–Funktion 22, 711

$\ und 514

$/ und 687

Anwendungsbeispiel 608, 630, 717, 819

Stringlänge und 423

verglichen mit chop 712

chop–Funktion 22, 712

Anwendungsbeispiel 26, 903

Effizienz 613

Stringlänge und 423

 siehe auch 1  chomp–Funktion

chown–Funktion 713

bei POSIX–Systemen 932

Portabilität 642

chr–Funktion 714

Anwendungsbeispiel 70, 368, 763

CRLFs und 460

Unicode und 171, 179, 424

 siehe auch 1  ord

chroot–Funktion 595, 714

Portabilität 642

Class::Contract–Modul 354

Class::Multimethods–Modul 338

Class::Struct–Modul 892, 906

Clients

Name ermitteln 458

TCP 456

UDP 460

Cloisters 194

close–Funktion 444, 715

Anwendungsbeispiel 22, 118, 298, 438

Anwendungsbeispiel in Pipes 442-443, 773

Locking von Dateien und 436

Portabilität 645

Socketverbindung abbauen mit 716

Zeilennummern und 687

Close–on–Exec–Flag 593, 696, 705

fcntl und 440, 734, 775

Socket und 811

socketpair und 812

closedir–Funktion 716

Portabilität 646

 siehe auch 1  opendir b16>

Closures 137, 269, 270, 827

Anwendungsbeispiel 343

erzeugen 226

Erzeugung von Accessor–Methoden mit 351

als Funktionsschablonen 271

in Threads 467

private Objekte, Verwendung für 352

in Threads 467

verschachtelte Subroutinen emulieren mit 272

Zuweisung an Glob zur Definition einer Subroutine 308

Clustering in Mustern 193

ohne Capturing, Gründe 193

cmp–Funktion (in File::Compare) 915

cmp–Operator 28, 104, 812

_berladung 369

Code

Behandlung unsicheren Codes, abgesicherte Bereiche 595

Effizienz 619

mit Debugger extrahieren und ausgeben 530

unsicherer Code 594

als Daten maskierter Code 599

Beispiele für safe 598

Vermischung von Zeichen– und Codesemantik 420

wiederverwenden 626

Code–Teilmuster in regulären Ausdrücken 219

Codeerzeugung 482, 900

Codegeneratoren 493, 494

Bytecode–Generator 494

C–Code–Generatoren 495

coderef siehe Subroutinen, Referenzen auf

Combining Character Sequence erkennen mit \X 172, 423

Common Gateway Interface siehe CGI

comp.lang.perl–Newsgruppen xxx

Compiler

globale Deklarationen und 132

Regex–Compiler 203

Compiler, Perl 682

Backends 493

Hinweise für 685

Interpreter, Interaktion mit 497

verwandte Module 567, 900

Comprehensive Perl Archive Network siehe CPAN

COMSPEC–Umgebungsvariable 521

Config–Modul 899

%Config–Hash 556, 642

Betriebssystem–Abbildung von Signalnamen auf

–nummern 430

connect–Funktion 716

Anwendungsbeispiel 456

Portabilität 642

Socket–Modul und 935

Verwendung von IO::Socket anstelle von 456

constant–Pragma 306

Container–Klassen mit Zeigern auf selbstreferenzierende Datenstrukturen 344

continue–Befehl (in C) 607

continue–Block 120, 124-125

continue–Block siehe auch  Schleifen

Control–A 159

Control–C 63

Signale, Handler für 429

Control–C und Control–Z, Signale erzeugen mit 428

Control–D als EOF (Zeilenende) 71, 638

Control–Z als EOF 638

Control–Z als EOF (Zeilenende 71

Cookies (HTTP) setzen und einlesen 896

copy–Konstruktor 371

Copy–on–Write–Semantik 464

Core–Dateien 517

Core–Module, Perl 567

CORE–Pseudopaket 318, 337

CORE::GLOBAL–Pseudopaket 318

Coredumps

Denial–of–Service–Probleme beim Pattern–Matching 602

dump–Funktion für 725

Signale in C–Bibliothek triggern 429

Thread::Signal–Modul, verhindern mit 480

cos–Funktion 716

Anwendungsbeispiel 489, 706

komplexe Zahlen und 930

Math::Trig und 930

CPAN (Comprehensive Perl Archive Network) xxiii, 16, 300, 311, 565

CPAN–Modul 899, 908

Installation von Modulen mit 569

Portabilität 647

Module

dekomprimieren und entpacken 570

erzeugen 571

Installation in Perl–Bibliothek 570

installieren und kompilieren 569

kompilieren 570

Modul–Kategorien 567

modules–Verzeichnis 566

tie–Modul 412

Unterverzeichnisse 565

CPAN–Module kompilieren 570

CPU

Bedingungsvariablen für Threads 476

Freigabe durch Threads 471

Zeitscheiben für Prozesse 839

Zugriff bei Multitasking–Umgebung 587

CRLF, in Internet–Programmen 460

 siehe auch 1  Zeilenvorschub (Newline)

crypt–Funktion 717

Anwendungsbeispiel 78

Portabilität 642

$ctime–Dateistatistik 823

Curses, Perl–Module für 567

Cwd–Modul 893

aktuelles Arbeitsverzeichnis für Prozeß ermitteln 908

D

^D (Control–D) als EOF 638

–d Kommandozeilen–Switch 510, 523, 543

–d Dateitest 29, 100

–D Kommandozeilen–Switch 510

\d (für Ziffer) 38

/d–Modifier 162-163

Daemons

Perl–Module für 568

taint–Modus, Bedeutung der Aktivierung bei 577

_ _DATA_ _–Token 71

DATA–Dateihandle 682

Data::Dumper–Modul 298, 897, 909

Datagramme 454

date–Funktion siehe localtime–Funktion

Datei schreibbar, Testoperator 29, 100

Dateideskriptoren 735, 804

Dateihandles, übergeben mit 440

für über tie gebundene Dateihandles zurückgeben 404

übergeben durch Umgebungsvariable oder Kommandozeilen–Option 441

Dateideskriptoren vorbereiten 804

Dateien

abschneiden 840

aktuelle Position zurückgeben 836

Alter 103

Binärmodus 706

Core 517

Dateiende (End–of–File, EOF) 726

Deskriptoren siehe Dateideskriptoren

do FILE–Operator 724

Eigentümer und Gruppe ändern 713

entfernen 843

Funktionen für 702

Geltungsbereiche 137

Handles für siehe Dateihandles

bei Interprozeßkommunikation 434

Dateihandles übergeben 439

Locking–Mechanismen 435

mit Low–Level–Systemaufruf lesen 833

Module mit Cross–Plattform–Zugriffsmethoden 893

Module zur Formatkonvertierung 568

Module, Autoloading 308

Namen ändern 796

open–Funktion 769

Perl–Module für 568-569

Perl–Module unterbringen in einer Datei 300

Pfad–Komponenten, Trennzeichen für 644

portabel öffnen 645

schließen 715

Statistik 823

symbolische Links 829

temporär 921

Testoperatoren siehe Dateitests

über Low–Level–Systemaufruf öffnen 831

über Low–Level–Systemaufruf schreiben 835

überschreiben 771

Umbenennen, Programm zum 728

Unterscheidung Text/Binär 776

Variablen mit lexikalischem Geltungsbereich und 59

Win32API::File–Modul 902

Zugriff bei eingeschränkten Privilegien 585

Zugriffs– und Modifikationszeiten 823, 847

Zugriffsrechte 832, 841

Zugriffsrechte siehe Zugriffsrechte, Dateien

Dateihandles 21

Angle–Operator und 83

anonyme 258

assoziierte Formate, Standardnamen für 243

binden 398

kreative Dateihandles 406

Datei–Locks auf 436

Datenbytes lesen aus 792

duplizieren, Gründe 775

Endung _TOP 245, 685

erzeugen 21

Funktionen für 702

für Ausgabe auswählen 803

implizite Referenzierung in 253

indirekte 715

lokalisieren 82, 760

Namen für 56

Objektmethoden für, Verwendung 894

open–Funktion 769

Pipes, explizit schließen 773

Positionierung des Dateizeigers 802

Referenzen auf 258

SelectSaver–Modul 894

Sicherheit, verglichen mit Dateinamen 590

syslog, Ausgabe binden an 413

Tying, Methoden für 399

Typeglobs für 81

_bergabe mittels IPC 439

durch Standard–Dateihandles 439

übergeben 235

Dateinamen 71

%INC–Hash 686

& (Ampersand) in 774

ändern 796

Auflösung 749

Betrachten eines anderen Programms oder einer eval–Anweisung 531

ermitteln aus symbolischen Links 794

externe Daten in, Sicherheitsrisiken 583

Globbing 86, 646

Globbing siehe auch  glob–Funktion

Linking mit harten Links 759

Modi für das Íffnen 771

symbolische Links 829

Dateisysteme, Portabilität 644

Dateitests 29, 100

–p, Prüfung auf FIFO 449

Portabilität 642

Race Conditions bei 589

Daten

Behandlung unsicherer Daten 576

byteorientierte Daten verglichen mit zeichenorientierten Daten 417

fester Länge, Funktionen für 702

Screendump erzeugen 897

unsichere

als Daten maskierter Code 599

Erkennung vertrauenswürdiger Daten 579

Umgebung aufräumen 583

Zugriff auf Befehle und Dateien bei eingeschränkten Privilegien 585

Datenbanken

Perl–Module für den Betrieb von 567

Perl–Verbindungen zu 145

Tying von Hashvariablen an 377

 siehe auch 1  DBD; DBI

Datensatz–(Record–)Modus 688

Datensätze

Ausgabe–Trennsymbol siehe Dollar–Zeichen, $\ unter Symbole

Eingabe–Trennsymbol siehe Dollar–Zeichen, $/ unter Symbole

Funktionen für 702

variabler Länge 245

verschiedener Datenstrukturen 294

Generierung eines Hashs von 296

Komposition, Zugriff und Ausgabe 295

Datenstrukturen 279, 567

Arrays von Hashes 288

Datensätze komplexer Datenstrukturen 294

Hashes von Arrays 286

Hashes von Funktionen 294

komplex, als Skalare repräsentieren 13

lineare in Perl 251

mehrdimensionale Hashes 290

für Objekte 330

Objekte siehe Objekte

Organisation bei Perl 286

persistente Datenstrukturen mittels tie 413

Referenzen auf 253

selbstreferenzierend, Container–Klassen mit Zeigern auf 344 b16>

sichern 298

String–Repräsentation erzeugen 298

Datentypen 6

eingebaute 52

interne, Perl und C 548

Konvertierung zwischen C und Perl 560

Module für 892

Skalare siehe Skalare

TYPE–Deklarationen in Perl 766

Typeglobs 81

Datenzugriff, Threads 471

Bedingungsvariablen 476

Deadlock 474

Lock aufheben 474

Locking von Methoden 476

Locking von Subroutinen 474

Synchronisation mit lock 472

Datumsangaben

Perl–Module für 567

Portabilität 647

DB–Modul 897

caller–Funktion 710

DBD (Datenbanktreiber), Perl–Module für 567

DBI (Datenbankschnittstelle), Perl–Module für 567

DBM–Dateien

dbmclose– und dbmopen–Funktionen 718

komplexe Datenwerte speichern in 909

Locking 438

Löschen aus 721

Module für 896

Portabilität 647

Speicherung komplexer Datenwerte in 412

dbmclose–Funktion 377

Portabilität 642

dbmopen–Funktion 377

DBMs und 379

Locking und 438

Portabilität 642

dbprofpp–Programm 543

DB_File–Modul 896

Data::Dumper–Modul, verwenden mit 909

Deadlock in Threads 474

Deallozierung von Speicher 276

Debugger–Befehlszeile 537

Debugging 510, 523, 682

Backend–Module für das 493

bei über tie gebundenem Dateihandle aktivieren 406

Bug–Reports xxxi

DB–Modul 897

Debug–Level, durch Klasse oder Instanzen setzen 357

Debugger anpassen 535

Debugger–Code, Befehl zum Laden 520

Debugger–Support, Perl 540 b16>

Debugger, unbeaufsichtigte Ausführung 539

Devel::Peek–Modul für XS–Programme 897

Flags 682

für C–Programmierer 607

für reumütige Perl 4–Programmierer 609

für scharfe Shell–Programmierer 608

globale Destruktion von Objekten und anderen Referenzen steuern 521

häufige Fehler von Neulingen 603

mehrdimensionale Arrays 283

Perl–Debugger, Befehle 527

Perl, mit –DDEBUGGING–Option des C–Compilers 335

Steuerung aus Programmen 526

_berladung 376

Unix–Sicherheits–Bugs 588

 siehe auch 1  Taint–Checking

DEFAULT–Pseudosignal 430

defined–Funktion 719

Anwendungsbeispiel 304, 439, 441, 711, 718, 773

Arrays und 74

Subroutinen und 226

verglichen mit exists und Wahrheit 731

wantarray und 229

Zeileneingabeoperator und 84

 siehe auch 1  undef–Funktion

Definitionen

Klassen (objektorientierte Module als) 311

Subroutinen 227

laden aus anderen Dateien 133

laden mittels AUTOLOAD 308

verglichen mit Deklarationen 132

Deklarationen 3, 115

eingeschränkter Geltungsbereich 134

Formate 243

globale Variablen 132

mit lexikalischem Geltungsbereich 138

Methoden, Lvalue–Rückgabe anzeigen 355

Paket 134, 301, 785

Pakete 14

structs 349

Subroutine 132, 225, 827

anonym 225

Variablen 115, 134

deklarativer Ansatz, Programmierung regulärer Ausdrücke 215

Dekomprimierung von CPAN–Modulen 570

Dekrementieren von Variablen 26

DEL in Hexadezimal 63

delete–Funktion 721

Anwendungsbeispiel 265, 521

Pseudo–Hashes und 266

über tie gebundene Arrays, gelöschte Werte nicht zurückgebend 611

verglichen mit undef 842 b16>

Demokrit 591

Denial–of–Service–Probleme (Muster und reguläre Ausdrücke), Sicherheitserwägungen 601

dequeue–Methode (Thread–Modul) 478

Dereferenzierung 253, 260-262

Arrayelemente 282

Hashwerte als Funktionen 294

Operator siehe Arrow–Operator

Typeglobs 304

 siehe auch 1  Referenzen

Dereferenzierungsoperator in C (*) 113

Dereferenzierungsoperatoren, _berladung 370

Destruktoren 343

Garbage Collection mit 344

kontrollieren 521

Shared Memory und Semaphoren 453

detach–Methode 470

$dev–Dateistatistik 823

Devel::DProf–Modul 897

Profiling der Ausführung von Subroutinen mit 543

Devel::Peek–Modul 897

Devel::SelfStubber–Modul 899

Devel::SmallProf–Modul 546

Dezimalpunkte ausrichten 244

Diagnosemeldungen siehe Fehlermeldungen; Warnungen

diagnostics–Pragma 897

Diamantoperator (<;>) 22

Diamantoperator (<;=>) 104

_ _DIE_ _–Hook 695

Anwendungsbeispiel 852

die–Funktion 722

Alarm und 433

Anwendungsbeispiel 92, 105, 118, 621, 623

END–Blöcke und 499

eval und 727

in Signal–Handlern 429

Setzen des exit–Wertes für 691

Signal–Handler 429

sigtrap–Pragma und 880

verglichen mit exit–Funktion 733

verglichen mit warn 851

 siehe auch 1  Carp–Modul

 siehe auch 1  _ _DIE_ _

dieLevel–Debugger–Option 537

Direktiven (POD) 653

Disziplinen 776

Dateihandles setzen mit binmode 706

Division siehe multiplikative Operatoren

DNS (Domain Name Server) 454

do 93

BLOCK 116, 723

abbrechen 128

Iteration 128

FILE 724

Schleifensteuerung 116, 127, 605

SUBROUTINE 116, 725

verglichen mit require 724

doc–Verzeichnis (CPAN), offizielle Perl–Manpages 565

Dokumentation

Bücher über Perl xxviii

Bug–Reports xxxi

C–Bibliotheksfunktionen 700

eingebettet in Perl–Programmen siehe POD

Module für 898

Perl–Manpages xxv

für Standardmodule 311

Standard–Pager aufrufen 534

Dollar–Zeichen ($) siehe Dollar–Zeichen unter Symbole

doppelte Anführungszeichen, Strings in, Interpolation und Verkettung 24

doppelte–Anführungszeichen–Kontext 74

skalare Variablen auflösen in 158

dosish.h–Datei 506

down–Methode (Thread::Semaphore–Modul) 479

DProf siehe Devel::DProf–Modul

dump–Funktion 725

Portabilität 642

Dumpvalue–Modul 897

DynaLoader–Modul 309, 552, 899

dynamisches Linking 551

C–Quellcode aus Perl 549

dynamisches Scoping 134, 136

local, Anwendung auf globale Variablen 140

Muster–Variablen 152, 158

E

–e Kommandozeilen–Switch 504, 511

–e Dateitest 29, 100

/e–Modifier 159, 217

E–Mail siehe Mail

each–Funktion 293, 725

Anwendungsbeispiel 837

Effizienz 618

keys und 755

über tie gebundene Hashes und 392, 397

 siehe auch 1  keys

 siehe auch 1  values–Funktion

eckige Klammern ([ ]) siehe eckige Klammern unter Symbole

Editoren, Debugging–Support für 535

effektive GID ($EFFECTIVE_GROUP_ID) 682, 693

 siehe auch 1  Dollar–Zeichen unter Symbole

effektive UID ($EFFECTIVE_USER_ID) 682

 siehe auch 1  Dollar–Zeichen, $<; und $> unter Symbole b16>

Effizienz

in Perl–Programmen 611

Profiling 543

Eigenschaften

Groß–/Kleinschreibung, Unicode 423

bei objektorientierter Programmierung 332

Unicode 172, 424

Eigentumsrechte, Datei 713

Einbettung von Perl 547, 556, 899

Evaluierung von Perl–Anweisungen aus C 558

Kompilierung eingebetteter Programme 556

Perl–Interpreter in C–Programme einbinden 557

Perl–Stack von C aus bearbeiten 560

einfache Anführungszeichen ('), Unterdrückung der Variableninterpolation 7

einfache Anführungszeichen (')

Kontraktionen in Wörtern, Verwechslung vermeiden 212

Neukompilierung von Mustern und 154

als Paket–Trennsymbol 302

Unterdrückung der Variableninterpolation und Verarbeitung von _bersetzungs–Escapes 200

Einfachvererbung 334

Einfügen zusätzlicher Arrayelemente 845

Eingabe

Dateideskriptoren prüfen für 804

Dateien, Ende bestimmen mit EOF 513

Dateien, open–Modus für 771

Dateihandles 21

 siehe auch 1  @ARGV–Array; STDIN–Dateihandle

Datensatz–Separator siehe Dollar–Zeichen, $/ unter Symbole

Debugger, wählen 539

Ein–Zeichen–Eingabe, gepuffert und ungepuffert 740

Funktionen für 702

Operatoren 82

Pipes 442

bidirektional 447

mehrstufige Pipelines 443

tridirektional 447

Verwendung von ioctl für 754

XSUBs 554

Eingabe von Variablen

Skalare 60

Untertypen, Umwandlung von 61

 siehe auch 1  STDIN–Dateihandle

eingebaut (built–in)

Datentypen 52

Funktionen

Auflistung nach Typ 898

Prototyping von Subroutinen zur Emulation von 234 b16>

_berschreiben 318

Zeichensemantiken, operierend auf 421

Methoden, Aufruf überschriebener 337

Einlesen von Dateien 509

Einsammeln von Zombie–Prozessen 431

Server 459

Einzeiler 19

Einzelschrittverarbeitung von Code 527

Elemente in Arrays 10

Ellipsen (...) 165

else–Anweisungen 31

elsif–Anweisungen 32

emacs

–*– Sequenzen 505

reguläre Ausdrücke, Verwendung 36

Support für Debugger 535

_ _END_ _–Token 71, 618, 638

END–Blöcke 482

exit–Wert von Programmen modifizieren 499

Reihenfolge der Ausführung 498

überspringen 499

endgrent–Funktion 740

Portabilität 642

endhostent–Funktion 743

Portabilität 642

Endlosschleifen 122

endnetent–Funktion 703

Portabilität 642

endprotoent–Funktion 746

Portabilität 642

endpwent–Funktion 746

Portabilität 642

endservent–Funktion 748

Portabilität 642

English–Modul 247, 897

enqueue–Methode (Thread–Modul) 478

Entfernen

aller Debugger–Aktionen 531

Arrayelemente 787, 808, 816

Breakpunkte 529

Dateien 843

entdeckte, aber nicht ersetzte Zeichen 162

Hashelemente 721

Umgebungsvariable 683

Verzeichnisse 800, 843

Zeichen 711

Entpacken von CPAN–Modulen 570

Entschlüsselung siehe Verschlüsselung

Entwickler–Support, Module für 567

%ENV–Hash 683

Löschen aus 721

Portabilität 646

Env–Modul 897

env–Programm, Perl starten mit 505 b16>

eof–Funktion 33, 617, 726

Anwendungsbeispiel 107, 126, 662

sysread und 833

Verwendung bei über tie gebundenen Dateihandles 403

eq–Operator 28, 104, 604

Anwendungsbeispiel 32, 35

Errno–Modul 897

Ersetzen von Arrayelementen 816

Ersetzung erkannter Teilstrings siehe s///–(Substitutions–)Operator

Ersetzungsstrings aufbauen mit /e–Modifier 217

Erweitern, Dateinamen 749

Erweiterung von Arrays 78

Erweiterung von Perl 549

Erweiterungen erzeugen 551, 897

Funktionen externer C–Bibliotheken verwenden 555

XSUB–Ein– und –Ausgaben 554

XSUBs und XS, Perl einbinden in 550

Erzeugungszeit siehe Modifikationszeit, Datei

ESC–Zeichen 63

Escape–Sequenzen für Steuerzeichen 62, 200

/etc/group Datei 617, 740

/etc/hosts Datei 743

/etc/networks Datei 744

/etc/passwd Datei 617, 746

/etc/protocols Datei 746

/etc/services Datei 748

/etc/utmp Datei 743

eval (Safe–Modul) 596

eval–exec–Hack 20, 505, 516-517, 636

eval–Funktion 58, 93, 251, 612, 727

Anwendungsbeispiel 235

Ausnahmen in Threads, Verwendung bei 470

Ausnahmen und 695, 703

AUTOLOAD, Verwendung in 308

caller und 709

während der Kompilierung 482

Datenstrukturen wiederherstellen mit 298, 909

die und 638

die–Funktion und 722

do und 724

Fehler aus 683

Formate, Verwendung in 248

interpolierter Code und 601

Pakete und 303

Peephole–Optimierung und 487

qr und 826

return und 799

Rückgabewert 632

Laufzeit und 484

s///ee und 160, 215

Schleifen und 125, 127, 613

Strings und 137

_berladung, -ndern zur Laufzeit 375

_bersetzen mit Variablen 163

vertrauenswürdige Daten, Verwendung bei 579, 598

eval–Methode in Threads 469

$EVAL_ERROR 683

eval_sv– und eval_pv–Funktionen 558

$EXCEPTIONS_BEING_CAUGHT 684

exec–Funktion 729, 834

Anwendungsbeispiel 578, 586

Dateihandles, zwischen Aufrufen offenhalten 440, 696, 775

END–Blöcke und 483, 499

fork und 731

Portabilität 642, 646

Shell vermeiden 600

_berschreiben, Ausnahme auslösen bei 913

 siehe auch 1  System

$EXECUTABLE_NAME 684

execv–Funktion (in C) 730

execvp–Funktion (in C) 729

Existenz eines Prozesses überprüfen 431

exists–Funktion 628, 731

Anwendungsbeispiel 351, 354, 521

Entfernen und 721

für Hash aufrufen 397

Pseudo–Hashes und 265

über tie gebundene Hashes und 390

exit–Funktion 3, 505, 733, 738

Anwendungsbeispiel 439

Batch–Verarbeitung, Verwendung für 621

END–Blöcke und 499

Threads und 468, 470

exit–Status 681

EXKLUSIV–ODER–Operator (XOR) 104, 112

exklusive Datei–Locks 435

erhalten 437

exp–Funktion 733

Anwendungsbeispiel 17

expat XML–Parser 633

Expect–Modul 448, 569

explizite Methodenaufrufe 324

@EXPORT–Array 684

Export von Symbolen 311, 313-314

ohne Verwendung der import–Methode aus Exporter 316

Exporter–Modul 552, 899

Modul–Privatsphäre und 314

export_fail–Methode 317

@EXPORT_OK–Array 684

%EXPORT_TAGS–Hash 684

export_to_level–Methode 316

$EXTENDED_OS_ERROR 684

externe Subroutinen, Portabilität 647

Extrahieren von Substrings 828

ExtUtils::Command–Modul 899

ExtUtils::Embed–Modul 557, 899

ExtUtils::Install–Modul 899

ExtUtils::Installed–Modul 899

ExtUtils::Liblist–Modul 899

ExtUtils::MakeMaker–Modul 572, 899

 siehe auch 1  MakeMaker

ExtUtils::Manifest–Modul 899

ExtUtils::Mkbootstrap–Modul 899

ExtUtils::Mksymlists–Modul 899

ExtUtils::MM_Cygwin–Modul 899

ExtUtils::MM_OS2–Modul 899

ExtUtils::MM_Unix–Modul 899

ExtUtils::MM_VMS–Modul 900

ExtUtils::MM_Win32–Modul 900

ExtUtils::Packlist–Modul 900

ExtUtils::testlib–Modul 900

F

@F–Array 684

–F Kommandozeilen–Switch 509, 512

–f Dateitest 29, 100

Fallback bei _berladung von Schlüssel 372

Falsch–Werte 8

FAQ, Perl, online 603

Fast CGI–Protokoll 896

fatal–Modul 897

fcntl–Funktion 733

Close–on–Exec–Flag, bearbeiten 440, 593, 775

Fcntl–Modul und 914

verglichen mit FileHandle–Modul 923

flock und 736

h4ph und 858

Portabilität 642

Rückgabewert 754

Sicherheitsrisiken bei 593

Fcntl–Modul 894, 914

Fehler

$@–Variable für 683

$!–Variable für 691

$?–Variable für 681

Carp–Modul 904

CGI::Carp–Modul 906

fehlgeschlagener Export von Symbolen 317

kein Arbeitsspeicher 690

Schreiben an httpd– oder andere CGI–Fehlerlogs 896

Subroutinen 229

unsichere Daten 578

warn–Funktion, Fehlermeldungen erzeugend 851

 siehe auch 1  STDERR–Dateihandle

Fehler bei Bindungsauflösung 410

Fehlermeldungen 626, 945

Benutzer–Effizienz erhöhen mit 621

Fehlersuche siehe Debugging

fehlgeschlagene Matches, Suche hinter 189 b16>

Feld–Trennzeichen, anderes festlegen 509

feste 8–Bit–Zeichen 419

%FIELDS–Hash 685

fields–Pragma 336, 346, 897

FIFOs 449

_ _FILE_ _ setzen 637

_ _FILE_ _–Token 71

File::Basename–Modul 644, 893

File::CheckTree–Modul 893

File::chmod–Modul 711

File::Compare–Modul 893

File::Copy–Modul 893

File::DosGlob–Modul 893

File::Find–Modul 893

File::Glob–Modul 893

File::Path–Modul 893

File::Spec–Modul 644, 893

File::Spec::Functions–Modul 893

File::Spec::Mac–Modul 893

File::Spec::OS/2–Modul 893

File::Spec::Unix–Modul 893

File::Spec::VMS–Modul 893

File::Spec::Win32–Modul 893

File::stat–Modul 893

Anwendungsbeispiel 921

 siehe auch 1  stat

File::Temp–Modul, Race Conditions, Gefahr von 593

fileglob–Operator 86

FileHandle–Modul 247, 249, 893

fileno–Funktion 735

Portabilität 642

 siehe auch 1  Dateideskriptoren

filetest–Pragma 101

Filter, Quellcode 44, 639

Filtern der Ausgabe durch mit fork arbeitendes open 445

find–Funktion 37

Dateibäume durchgehen wie 893

FindBin–Modul 900

findstr–Funktion 36-37

Flags siehe Modifier

Flags siehe Switches, Kommandozeile

Fließkommazahlen 61, 783

Math::BigFloat–Modul 892

rand–Funktion, zurückgebend 791

Speicherung im Computer, Anordnung 643

flock–Funktion 383, 435, 735

Alarm und 433

Portabilität 642

Flushing von Puffern 691

fmt (Unix–Utility) 248

Fonts, Perl–Module für 568

for 34, 116, 120

als Alias für foreach 122

Suchen und Ersetzen von Elementen in Arrays 160

foreach–Schleifen 34, 116, 122, 612

$_ und 130

-nderungen in Perl–Versionen 611

Schleifenvariable, Perl– verglichen mit Shell–Programmierung 608

Suchen und Ersetzen von Elementen in Arrays 160

fork–Funktion 444, 737

Anwendungsbeispiel 439

Batch–Verarbeitung, Verwendung zur 621

bidirektionale Kommunikation mit 448

Child–Prozesse, Vererbung der Parent–Dateihandles 439, 441

$$ und 693

exec und 731

fork–open 444-445, 774

Kloning von Interpretern unter Windows 464, 492

Locks, über Aufrufe hinweg erben 737

perlfork–Dokumentation 428

Pipe–open, Shell vermeiden 586

Pipes und 442, 786

Portabilität 642, 646

Server selbst klonen mit 458

shutdown und 810

socketpair und 812

verglichen mit dem Thread–Modell 465

wait und 850

Zombie–Prozesse und 431

formale Argumente 681

Formatdeklaration 738

 siehe auch 1  write–Funktion

Formate 243

Argumentlisten für, Evaluierung im Listenkontext 610

Ausgabe–Akkumulator 739

B::Xref–Modul, Cross–Referenzen mit C 496

deklarieren 243, 738

fmt (Unix–Utility) 248

Fußzeilen 249

Integerwerte 783

lexikalische Variablen in 246

pack/unpack 780

Seitennummern 685

für Strings 820

Top–of–Form–Verarbeitung 245

Variablen 246

Zeichen in 780

Zugriff auf Format–Interna 249

$FORMAT_FORMFEED 685

$FORMAT_LINES_LEFT 685

$FORMAT_LINES_PER_PAGE 685

$FORMAT_LINE_BREAK_CHARACTERS 685

$FORMAT_NAME 685

$FORMAT_PAGE_NUMBER 685

$FORMAT_TOP_NAME 685

formfreie Sprachen 50

formline–Funktion 249, 739

$^A und 680

Fortran 51

Fortsetzungszeilen 126, 685

Freigabe–Kontrolle

um implizite Schleifen 515

von Objekten 343

Fußzeilen 249

Funktionen 16, 699

Auflistung nach Kategorie 702

Autoloading 307, 341

benannte unäre Operatoren 98

byteorientierte Wrapper für 421

C–Bibliothek 700

Debugger anpassen 542

Debugger, intern aufrufen 536

eingebaute, Auflistung nach Typ 898

generieren 270

Hashes von 294

interpolieren 392

in Listen– oder skalarem Kontext 701

Module, an Programme exportieren 314

Namen 625

Operatoren und 89

öffentliche _berladung 374

Perl Wrapper um C 550

Perl, Variationen zwischen Plattformen 642

Referenzen als Ein– und Ausgaben 233

Rückgabe vertrauenswürdiger Daten 704

Rückkehr–Operatoren in 125

Schablonen für siehe Closures

Signalbehandlung 429

Socket–bezogene 455

Standardargumente, Fehler vermeiden mit 606

temporäre Dateinamen generierend 592

Thread–Modul 467

überschreiben 318

 siehe auch 1  Subroutinen

 siehe auch 1  unter spezifischen Funktionsnamen

Funktionsaufrufe 92

Pipe, Low–Level für bidirektionale Kommunikation 448

G

–g Dateitest 100

/g–Modifier 157, 159

\G Positionszusicherung 157, 189

Garbage Collection 276

mit DESTROY–Methoden 344

Objekte mit über tie gebundenen Variablen 384

GDBM (GNU DBM)

GDBM_File–Modul 896

Locking von Dateien unter 438 b16>

ge–Operator 28

 siehe auch 1  rechte spitze Klammer unter Symbole

gebundenes Array erzeugen 388

Geltungsbereiche 5, 55

Block 117, 137

Datei 137

Deklarationen 134

 siehe auch 1  local; my; our

dynamisch 140

in foreach–Schleifen 123

Funktionen für 703

in for–Schleifen 121

Geltungsbereichs–Stack 491

in if–Anweisungen 119

lexikalischer Geltungsbereich 58, 136

my– und our–Variablen 301

Paketdeklarationen 301

Pattern–Matching–Operationen 152

private Variablen siehe lexikalische Variablen

Signalbehandlung 430

strict–Pragma und 16

Subroutinen 230

in Threads 479

in while–Schleifen 120

gemeinsam genutzte Dateien, Locks für 435

Generatoren für Perl 636

andere Sprachen in Perl 636

in anderen Sprachen 637

Quellfilter 639

generierte Muster 216

gepackte Socketadresse 745

Geschichte von Perl 667

geschweifte Klammern ({ }) siehe geschweifte Klammern unter Symbole

Geschwindigkeit siehe Effizienz; Performance

getc–Funktion 614, 740

in über tie gebundenen Dateihandles 401

getenv siehe Umgebungsvariable

getgrent–Funktion 740

Portabilität 642

überschreiben 941

getgrgid–Funktion 741

Portabilität 642

getgrnam–Funktion 741

Portabilität 642

gethost*–Funktionen, eingebaute überschreiben 895

gethostbyaddr–Funktion 742

Anwendungsbeispiel 458, 461, 749

Caching der Rückgabewerte von 617

getpeername und 745

Portabilität 642

Rückkonvertierung von Zeichen in Bytes 419

Socket–Modul und 935

überschreiben 931 b16>

gethostbyname–Funktion 742

Anwendungsbeispiel 458

Portabilität 642

Socket–Modul und 935

überschreiben 931

gethostent–Funktion 743

Portabilität 642, 743

getlogin–Funktion 743

Portabilität 642

getnet*–Funktionen, eingebaute überschreiben 895

getnetbyaddr–Funktion 744

Portabilität 642

getnetbyname–Funktion 744

Portabilität 642

getnetent–Funktion 744

Getopt::Long–Modul 892

Getopt::Std–Modul 892

Getopts::*–Modul 126

getpeername–Funktion 458, 745

Anwendungsbeispiel 935

getpgrp–Funktion 745

Portabilität 642

getppid–Funktion 745

Anwendungsbeispiel 757

Portabilität 642

getpriority–Funktion 745

Portabilität 642

setpriority, Anwendungsbeispiel mit 808

getproto*–Funktionen, eingebaute überschreiben 895

getprotobyname–Funktion 746

Anwendungsbeispiel 460

Portabilität 642

Socket–Modul und 935

getprotobynumber–Funktion 746

Portabilität 642

getprotoent–Funktion 746

Portabilität 642

getpwent–Funktion 746

Anwendungsbeispiel 78, 720

Portabilität 642

überschreiben 942

getpwnam–Funktion 747

Anwendungsbeispiel 394, 713-714

Portabilität 642

überschreiben 942

getpwuid–Funktion 743, 747

Anwendungsbeispiel 394, 469, 717

Benutzernamen und –information ermitteln 866

Home–Verzeichnis ermitteln mit 106

Portabilität 642

überschreiben 942

getserv*–Funktionen, eingebaute überschreiben 895

getservbyname–Funktion 748

Anwendungsbeispiel 460

Portabilität 642

Socket–Modul und 935

getservbyport–Funktion 748

Portabilität 642

getservent–Funktion 748

Portabilität 642

getsockname–Funktion 748

Portabilität 642

getsockopt–Funktion 749

Portabilität 642

$gid–Dateistatistik 823

GID (Gruppen–ID) 713

angenommene 445

Datei–Lookup nach 741

effektive 682

 siehe auch 1  $( und $) in Dollar–Zeichen unter Symbole

gieriges Matching 39, 185-186, 208

Token 51

GIFs, Perl–Module für 568

Gimp, Perl–Module für 568

= (Gleichheitszeichen), => Operator 111

Gleich–Methode (Thread–Modul) 470

Gleich–Operator (==) 104

Gleichheitsoperatoren 104

glob–Funktion 86-87, 749

und <;> 369

Anwendungsbeispiel 749, 843

Portabilität 642

überschreiben 318

global (Variablen) 134

deklarieren 132, 138, 778

local, Verwendung bei 140

lokalisieren 759

Paketvariablen als 301

Threads, Zugriff in 471

Verwendung kontrollieren mittels strict–Pragma 142

Vordeklaration mit vars–Pragma 897

globales Matching siehe /g–Modifier

Globbing von Dateinamen 86, 893

Portabilität 646

„Glue–Language„, Perl als 21

gmtime–Funktion 750, 892

Anwendungsbeispiel 784

utime und 848

und die time–Funktion 839

überschreiben 894, 940

umkehren 940

 siehe auch 1  localtime

 siehe auch 1  Zeit

Gnome, Perl–Module für 567 b16>

goto–Funktion 131, 308, 612, 751

-nderungen in Perl–Versionen 610

dump und 725

wegoptimierte Blöcke und 489, 610

Graphen, Perl–Module für 568

Grave–Akzent siehe Backtick unter Symbole

Greenwich Mean Time (GMT) 750

Grenzen, Wörter siehe \b– und \B–Zusicherungen

grep–Funktion 624, 752

Anwendungsbeispiel 232, 318, 394, 407, 443, 458, 710

$_ und 628

eigene 236

Verzeichnis, Anwendungsbeispiel mit 793

void–Kontext und 624

 siehe auch 1  map–Funktion

grep–Utility 37, 201

Groß–/Kleinschreibung 56

ändern 164

Barewords, Probleme mit 67

Escape–Sequenzen zur Verarbeitung von, Variablen–Interpolationslauf 169

Escapesequenzen für 63

Großbuchstaben, umwandeln (\u–Escape) 158

Label–Namen 119

lc und lcfirst, Funktionen 758

Methodennamen, über tie gebundene Variablen 379

in Modulnamen 891

in Modulnamen 312

Paket–/Modulnamen 624

sensitives Matching deaktivieren 153, 156, 159, 201

Subroutinennamen 226

Titelschreibweise (Titlecase) 164

Translationsoperatoren, Verwendung von Unicode–Tabellen 423

uc und ucfirst, Funktionen 840

Größer–als–Operator (>) siehe gt

Größer–als–Operator (>) siehe rechte spitze Klammer unter Symbole

Größer–oder–gleich–Operator (>=) siehe ge

Größer–oder–gleich–Operator (>=) siehe rechte spitze Klammer unter Symbole

Großschreibung, Umwandlung in 63, 158

Gruppen

Benutzer

Funktionen für 703

Gruppenname 741

Mitglieder, Login–Namen 740

IDs siehe GID

Namen für 741 b16>

Prozesse 430

beenden 757

Funktionen für 703

Rückgabe der Priorität 745

Gruppierungsoperator 148, 165, 209

für Ausdrücke 91

Verschachtelung 192

gt–Operator 28

 siehe auch 1  rechte spitze Klammer unter

Symbole

Gtk, Perl–Module für 567

GUIs

Perl–Module für 567

Perl/Tk 621

guts 547

GV (interner Glob–Wert) 548

H

–h Kommandozeilen–Switch 512

h4xs–Utility 550-551, 572

Handler

overload 362-363

as_string–Handler 366

fehlt 372

für Signale 429

Handles 6

gebundene, Basisklassen–Definitionen für 898

Referenzen auf 258

Verzeichnisse 893

 siehe auch 1  Dateihandles

Hardware–Treiber, Perl–Module zur Interaktion mit 567

harte Links (auf Dateinamen) 759

harte Referenzen 93, 251, 254

%SIG–Array 429

verwenden 260

Closures 269

Hashes 6, 9-10, 53, 79

%SIG, Referenzen auf Signal–Handler 428

anonym

als Objekt–Datenstrukturen 330, 344

Referenzen auf 255

anstelle linearer Suchen 612

von Arrays 286

generieren 287

Zugriff und Ausgabe 288

Arrays von 288

generieren 289

Ausgabestil, im Debugger ändern 538

Bedingungen kaskadieren anstelle von 130

beschränkte, implementieren 354

binden 377, 392

Methoden für 393

Tie::Hash–Modul 898 b16>

komplexer Datensätze 296

DBM–Dateien binden an 718

Elemente, Zuweisung temporärer Werte an 760

exists–Funktion und 731

HV (Hash Value) Typedef in C 548

Initialisierung mit x–Operator 97

lineare Lookup–Tabellen, Zugriff auf 279

mehrdimensional 290

generieren 291

Zugriff und Ausgabe 292 b16>

Namen für 55

Organisation der Daten in 286

Referenzen als Schlüssel 275

Referenzen auf 253

Rückgabe von Werten aus 848

Schlüssel 10, 53

entfernen 392

geschweifte Klammern ({ }), einschließen in 12

Liste aller zurückgeben 755

Modulpfade (im %INC–Hash) 312

Organisieren und Zugreifen auf Daten in 286

Referenzen als 898

Rückgabe mit each–Funktion 702, 725

Symboltabelle 304

Zahl finden in 81

Schlüssel/Wert–Paare 10, 53, 79

in String festhalten mit m//g–Operator 157

zurückgeben mit each–Funktion 725

sortierte Ausgabe 123

Symboltabellen 303

Schlüssel/Wert–Paare in 304

Typeglobs in 304

_bergabe mittels Referenz an oder von Funktionen 232

umkehren 799

Verarbeitung, Funktionen für 702

vertrauenswürdige 577

Werte entfernen aus 721

Haushalt, Perl–Module für 567

Header, Formatnamen 249

Here–Dokumente 68

anhängendes Semikolon (;) vermeiden 604

Einrückung 70

hex–Funktion 752

 siehe auch 1  oct

 siehe auch 1  sprintf

hexadezimal 62, 752

Konvertierung von Zahlen 159

Zeichenwerte 170

Hinweise (Hints), Compiler 685

History von Debugger–Befehlen 524

HOME–Umgebungsvariable 520

Home–Verzeichnis 710

Homepage von Perl xxx b16>

Hostnamen

aus Netzwerkadressen ermitteln 742

in Adressen übersetzen 742, 744

Sys::Hostname–Modul 894

Hosts (entfernte), Erreichbarkeit prüfen 895

hosts–Datei siehe /etc/hosts

HTML (Hypertext Markup Language)

Code, sauber formatierten Code erzeugen 896

generieren mit CGI–Modul 896

Perl–Module für 568 b16>

POD–Dateien, konvertieren in 898

 siehe auch 1  CGI

HTTP (Hypertext Transfer Protocol)

Cookies setzen und ermitteln 896

Links, Suche nach 37

Perl–Module für 568

Hütchen (^) siehe Hütchen unter Symbole

HV (interner Hashwert) 548

Hypothekenberechnung, Perl–Module für 569

I

–i Kommandozeilen–Switch 512

–I Kommandozeilen–Switch 504, 514

/i–Modifier 153, 156, 159

I18N::Collate–Modul 894

Identifier 51, 57

alphanumerische Unicode–Zeichen 422

Barewords und 67

beginnt mit Unterstrich ( _ ), Veränderungen in Perl–Versionen 609

bloße 67

effektive UIDs und GIDs

schützen gegen 585

verglichen mit realen 576

einfaches Anführungszeichen (') in 63

einschließen in geschweifte Klammern 64

Paket 302

in Paket–Symboltabelle 302

Perl–Module 312

PID (Prozeß–ID) 430, 775

ermitteln 592

Semaphoren 806

Shared Memory–Segmente 809

Thread–IDs 470

verglichen mit Namen 57

 siehe auch 1  GID; PID; UID

Ideographen 38

erkennen mit \w 422

ideographische unäre Operatoren 95

Idiome, Perl 626 b16>

if–Anweisungen 28, 31, 116, 118

C, Unterschiede zu Perl 607

in case–Strukturen 129

logische Operatoren und 27

IGNORE–Pseudosignal 430

imperativer Programmierstil 215

implizite Referenzierung und Dereferenzierung 253

impliziter Methodenaufruf 324

Import 133, 312

Semantiken in Pakete 846

Subroutinen aus einem anderen Modul 226

Symbole von einem Paket in ein anderes 305

 siehe auch 1  Exporter–Modul; Symbole exportieren b16>

import–Methode 311, 316, 753

_berladung von Konstanten 373

@INC–Array 312, 686, 900

lib–Pragma und 875

Verzeichnisse aufnehmen 514

%INC–Hash 312, 686

index–Funktion 753

Anwendungsbeispiel 453

$[ und 679

Stringlänge und 423

Indirection 60, 251

zwischen Verwendung und Implementierung der Klasse 324

indirekte Dateihandles 770

indirekte Objekte

Anwendungsbeispiel 295

Definition 326-327

expliziter Pfad, _bergabe in Slot 579

Mehrdeutigkeiten 327

Indizierung 612

in Arrays 10

negative 53

Indizierung von Arrays 288

inet_ntoa–Funktion (Socket–Modul) 742

Infix–Dereferenzierungsoperator siehe Arrow–Operator

Infix–Operatoren 23

INIT–Blöcke 482

Initialisierung von Variablen vor Subroutinenaufrufen 231

Reihenfolge der Ausführung 498, 500

init–Programm 745

Initialisierung

Arrays und Hash–Slices 97

Ausdrücke 120

Debugger, anpassen mit init–Dateien 535

Hashvariablen 79

Objekte 332

Variablen vor dem Aufruf von Subroutinen 231

Inkrementierung von Variablen 26 b16>

Inlining konstanter Funktionen 236

vermeiden 237

$ino–Dateistatistik 823

Inplace–Editierung ($^I, $INPLACE_EDIT) 512

Inplace–Editing ($^I, $INPLACE_EDIT) 686

$INPUT_LINE_NUMBER 687

$INPUT_RECORD_SEPARATOR 509, 687

Installation

Module, CPAN 569

in Perl–Bibliothek 570

unterstützendes Modul 899

installierte Module, _bersicht 899

Instanzdaten 332, 344

Entwicklung eigenständiger Funktionen für 345

Generierung von Accessoren mittels Autoloading 350

Generierung von Accessoren mittels Closures 351

Generierung von Klassen mittels Class::Struct 349

neue Features, Perl 5.6 355

Verwendung von Closures für private Objekte 352

Instanzen 321

Instanzmethoden 321

Objektreferenzen als Aufrufer für 324

int–Funktion 753

Anwendungsbeispiel 791

integer–Pragma 97

Anwendungsbeispiel 861

Definition 874

Integerwerte 753, 783

bitorientierte Operationen mit 104

Byteordnung von 643

in C 52

dicht packen in Strings 780, 848

Formate 62, 783, 820-821

IV (interner Integerwert), Typedef in C 548

in Kommandozeilen–Switches 925

Konvertierung in UTF–8 424

Math::BigInt–Modul 361

Muster, Anwendungsbeispiele in 198

Potenzierung 560

Standardmodule für Arithmetik mit 892

Strings als Vektoren von 848

_berladung 373

 siehe auch 1  integer–Pragma

 siehe auch 1  Math::BigFloat–Modul

 siehe auch 1  Math::BigInt–Modul

Internationalisierung 49, 648

Perl–Module für 568, 894

Textdaten, mit Unicode 417

interne Variablennamen, Perl 57

Internet TCP–Clients/Server 456

Internetdienste, CPAN–Module für 455

Internetprotokolle, Perl–Module für 567 b16>

Interpolation

Konditionale in Muster 223

Match–Time 222

Interpolation, Variable 7

Arraywerte 68

bei Strings in doppelten Anführungszeichen 149

bei Strings in doppelten Anführungszeichen 24, 64

Funktionen und 392

glob–Operator, Verwendung 88

Listenwerte 76

Muster und 150

Pattern–Matching, steuern mit 199

Rückwärtsreferenzen 42

skalare Werte 62 b16>

interpolativer Kontext 74

Interpreter 5

für Befehle 503

Quoting bei Unix–Systemen 507

Objekt–Destruktion bei Shutdown 344

Threads 464

Interpreter, Perl 19, 490, 492

Aufruf mit #! (Shebang–Zeile) 504

Compiler, Interaktion mit 497

in Anwendungen einbetten 492

mehrere, ausführen 492

persistent 556

Zugriff aus C 556-557

Interprozeßkommunikation siehe IPC; IPC::*–Module

Interpunktionsvariable, English–Modul 897

Interpunktionszeichen, Matching von Wortgrenzen und 188

Interrupt–Signale, Handler für 429

ints 783

Invertierung von Arrays und Hashes 799

IO–Modul 893

IO::*–Module 569

IO::Dir–Modul 893

IO::File–Modul 894

IO::Handle–Modul 894

IO::Pipe–Modul 894

IO::Poll–Modul 894

IO::Pty–Modul 448

IO::Seekable–Modul 894

IO::Select–Modul 894

IO::Socket–Modul 455, 895, 927

IO::Socket::INET–Modul 456, 895

IO::Socket::UNIX–Modul 895

ioctl–Funktion 754

Anwendungsbeispiel 754

Fenstergröße bestimmen mit 939

h4ph und 858

Portabilität 642

Rückgabewert 754

IP (Internet–Protokoll) 454

Adressen

Netzwerknamen und 744

UTF–8–Repräsentation von 419

v–String–Notation für 742

IPC (Interprozeßkommunikation) 427

Dateien als Mechanismus zur 434

im Internet 427

Module für 893

Pipes 442

bidirektional 447

Portabilität 646

zwischen Prozessen auf der gleichen Maschine 428

Signale 428 b16>

Sockets in 454

Message–Passing 460

Netzwerk–Clients 456

Netzwerk–Server 457

 siehe auch 1  System V IPC

IPC::Msg–Modul 895

IPC::Open2–Modul 556, 895, 928

IPC::Open3–Modul 556, 895, 928

IPC::Semaphore–Modul 895

IPC::Shareable–Modul 451

IPC::SysV–Modul 895

irreguläre Dateien 29

@ISA–Array 334, 688, 961, 994, 1002

use base–Pragma und 864

Vererbung durch 335

isa–Methode (UNIVERSAL–Paket) 339

Isolation verdächtigen Codes 595

Iteration siehe Schleifen

iterative Anweisungen 32

foreach–Anweisung 34

für Schleifen 34

until–Anweisung 33

while–Schleifen 33

iterativer Operator, _berladung 369

ithreads 464

Perl–API für 492

itimer–Routinen 705

IV (interner Integerwert) 548

J

Java, Perl–Module für 567

join–Funktion 755

Anwendungsbeispiel 68, 161, 268, 818

Effizienz 616

verglichen mit pack 785

verglichen mit split 820

 siehe auch 1  split b16>

join–Methode (Thread–Modul) 468

Ausnahmen abfangen aus 469

jumpenv–Stack 491

K

–k Dateitest 100

Kamele

die durch’s Nadelöhr gehen 69

Pferde verglichen mit 4

pink und blau 669

kanonische Zerlegung von Zeichen 177

Kanonisierung, Zeichen, Information über 422

Kapselung 14, 264, 322

namensraumbasiert 413

Objekte in Closures 352 b16>

Kategorien

von Zeichen 176

von Funktionen 702

Kernel

Generierung von Signalen 428

Threads und 465

Unix, Bug im set–id–Skript 588

Zombies automatisch einsammeln 431

Zuverlässigkeit von Signalen 432

keys–Funktion 12, 44, 81, 755

Anwendungsbeispiel 232, 288, 848

zum Zählen der Hasheinträge 758

typischer Schnitzer mit 609

über tie gebundene Hashes und 397

 siehe auch 1  each

 siehe auch 1  each–Funktion; values–Funktion

 siehe auch 1  values

kill–Funktion 428, 757

Anwendungsbeispiel 431

END–Verarbeitung und 499

zur Auflistung von Signalen 430

Microsoft–Systeme und 431

Portabilität 642

kill siehe beenden

Kitt, Perl als 21

Klammern ( ) siehe Klammern unter Symbole

Klassen 300, 321

Basis siehe Basisklassen

Datenmanagement 356

Speicherung von Referenzen auf Klassendaten im Objekt selbst 358

Funktionen für 703

Generierung mit Class::Struct–Modul 349

Implementierung über tie gebundener Dateihandles 398

Implementierung über tie gebundener Hashes 392

@ISA–Array, einbinden mit base–Pragma 336

Objekte zuweisen an 330

objektorientierte Module als Definitionen von 311

Pakete 93, 323, 837, 845

Perl 172

Pseudo–Hash–Implementierungen von 766

Quoting von Paketen für 328

tie implementieren 378

Tying von Skalaren 380

Vererbung zwischen 334

base–Pragma 897

Methoden–Autoloading 341

private Methoden vermeiden bei 342

überschriebene Methoden, Zugriff auf 337

UNIVERSAL–Klasse und 339

verglichen mit Modulen 300

Versionsnummer zurückgeben 340 b16>

Klassenmethoden 321

Konstruktoren als 331

Paketnamen als Aufrufer für 324

Thread–Klasse 467

Kleiner–als–Operator (<;) 103

Kleiner–oder–gleich–Operator (<;=) 103

Kleinschreibung, Umwandlung in 63

Komma (,) siehe Komma unter Symbole

Kommandozeile

Bildschirmdarstellung 537

Module zur Verarbeitung 892

Perl–Interpreter aufrufen über 19

Perl–Module zum Editieren 567

Kommandozeilen–Switches siehe Verarbeitung von Optionen; Switches, Kommandozeile

Kommentare

Definition 51

mehrzeilige 652

mit /x–Modifier 154

Perl–Syntax verglichen mit C–Syntax 608

vorab entfernen 198

kompatible Zerlegung von Zeichen 177

Kompilierung 481, 547

Code 484

eingebettes Perl–Programm (in C) 556

Lebenszyklus von Perl–Programmen 482

Codegenerierungsphase 482

Kompilierungsphase 482

Rekonstruktion des Parsing–Baums 483

Reihenfolge der 501

Kompilierungseinheiten 58

Kompilierungsphase 548

Kompilierungszeit

Kontrolle des Debuggers während 526

verglichen mit Kompilierungsphase 484

Komplementierung siehe Negation

komplexe Datenstrukturen

als Skalare darstellen 14

erzeugen bei Perl 279

Konditional–Anweisungen

Ausdrücke in Schleifen 120

Interpolation in Muster 223

ohne geschweifte Klammern 118

 siehe auch 1  if–Anweisungen; unless–Anweisungen

Konditional–Kontext siehe Boolescher Kontext

Konditional–Operator (?:) 108, 130

Konfiguration

Perl–Module 568

Perl, Debugging 511

Konstanten 306

Inlining konstanter Funktionen 236

Perl, Laden von fcntl.h–Definitionen als 894

System V IPC, definieren für 895

_berladung 373 b16>

Konstruktoren 257, 321, 330

bless–Funktion und 330

Initialisierer 332

Klassennamen oder Objekte, Arbeiten mit 332

Namen 332

new–Methode 768

über tie gebundene Variable, Klassen 378

vererbbare 331

Zugriffsprüfungen, einrichten in 354

Kontext 71

Boolescher Kontext 73

interpolativer Kontext (Anführungszeichen) 74

skalarer Kontext und Listenkontext 71

void 74, 851

 siehe auch 1  Listenkontext; skalarer Kontext

Kontext–Stack 491

Kontraktionen in Wörtern, nicht verwechseln mit einfachen Anführungszeichen 212

Kontrollstrukturen 30

Wahrheit, Definition 30

Kontrollvariablen 122

Konvertierung

ASCII–Wert in Zeichen 714

Dateiformate, Module für 568

Datentypen zwischen C und Perl 560

Dezimalzahlen nach binär, oktal oder hexadezimal 820

Hexadezimalzahlen in Dezimalzahlen 752

Listenwerte in Strings 755, 780

Oktahlzahlen in Dezimalzahlen 769

Strings in Listenwerte 817, 843

Unicode–Werte in Zeichen 714

Zahlen in/aus Hexadezimal 159

Zeichen in ASCII–Werte 778

Zeit 750, 761

zwischen Integerwerten und UTF–8–Zeichen 424

zwischen Sprachen 639 b16>

Konvertierungsoperatoren

Boolescher Kontext, Interpretation von Objekten bei 365

Stringifikation 365

Umwandlung von Nicht–Zahlen in Zahlen 365

Kopieren von Dateinamen oder Dateihandles 893

Kreditkarten, Perl–Module für 569

kreisförmige Referenzen 276

aufbrechen 344

_berladung vermeiden bei 370

Kryptographie 823

künstliche Sprachen 4

Kürzen von Arrays 79 b16>

L

–l Dateitest 100, 514

Label 117, 125

goto und 131, 751, 959

Namen für 56

Pakete und 302

Schleifen und 119, 124, 624, 976

Laden von Datenstrukturen von Platte 296

Länge

von Arrays 78

eines erkannten Strings 186, 688

von Strings in Mustern 614, 758

von Unicode–Strings 421, 423

last–Operator 35, 122, 125, 130, 615, 624, 757

Anwendungsbeispiel 86, 124, 629

Schleifensteuerung und 127

Verwendung in do/while 128

$LAST_PAREN_MATCH 689

lc–Funktion 758

Anwendungsbeispiel 44, 120, 130, 151

Sortierung mit 813

lcfirst–Funktion 758

le–Operator 28

 siehe auch 1  linke spitze Klammer unter

Symbole

 siehe auch 1  lt–Operator

Lebenszyklus von Perl–Programmen 482

Ausführungsphase 483

Codegenerierungsphase 482

Kompilierungsphase 482

Parse–Tree–Rekonstruktion 483

leere Blöcke 127

case–Strukturen aufbauen mit 129

Leere–Subklasse–Test 334

Leerzeichen 51

Leerzeilen, Wahr–Wert von 33

leftmost longest 186

length–Funktion 758

Anwendungsbeispiel 100

byteorientierter Wrapper für 421 b16>

pos und 788

Zeichenpositionen und 423

lesbare Datei, Datei–Testoperator 29, 100

Lesen

Dateien, open–Modus und 772

Daten über Low–Level–Systemaufruf 833

Shared Memory–Segment–ID 809

less–Pragma 897

lexikalische Analyse 548

im Perl–Compiler 484

lexikalische Variablen 134, 246, 765

dateibezogen, Speicherung anonymer Subroutine in 342

ausgeben mit B::Showlex 901

Persistenz über Funktionsaufrufe 231 b16>

Speicherung in rekursiven lexikalischen Zwischen–Stacks 491

symbolische Referenzen und 273

Threads, Zugriff in 471

Zugriff von Funktionen 230

lexikalische Warnungen 898

$^W und 518

${^WARNING_BITS} 697

 siehe auch 1  warnings–Pragma

lexikalischer Geltungsbereich 55, 136

Closures und 269

Dateien und 59

Deklaration 134

Deklaration siehe auch  my

Namensräume und 855

our–Deklarationen und 778

Paketvariablen, Suche nach 59

Pragmas und 141

Privatsphäre und 352

Variablen gebunden an 58

Variablen und 230

verglichen mit lexikalischer Analyse 485

 siehe auch 1  Geltungsbereich

lib–Pragma 312, 900

#line–Direktive 637

_ _LINE_ _–Token 71

LineInfo–Debuggeroption 537

link–Funktion 759

Portabilität 642

 siehe auch 1  symbolische Links

 siehe auch 1  Symlink

Links

HTTP, Suche nach 37

Hyperlinks siehe auch  CGI

Hyperlinks siehe auch  HTML

Hyperlinks siehe auch  HTTP

 siehe auch 1  symbolische Links

Linksausrichtung 248

Linksshift–Operator (<;<;) siehe linke spitze Klammer unter Symbole

lint (Prüfprogramm für C–Programme) 496

Listen 9, 43, 72, 117

Chopping 712

aktueller Threads im Prozeß 471

als Funktionsargumente 699

geordnet, Datensätze in Arrays 286

interpolieren 76

Konvertierung in Skalare 12

linearisieren 699

Listen, LISTen 75

map–Funktion und 763

Nullisten 76

replizieren mit x–Operator 97

Skalare, Rückgabe– und Parameterwerte von Subroutinen 227 b16>

sortieren 812

umkehren 799

Verarbeitung, Funktionen für 702

verglichen mit Arrays 75

verschachtelte 279

Zuweisung 77

 siehe auch 1  Arrays

listen–Funktion 759

Anwendungsbeispiel 457

Portabilität 642

Listenkontext 43, 71

anderes Verhalten von Operationen im 606

Angle–Operator im 84

Ausdrücke im siehe LISTen

Backslash–Operator, bereitstellend 267

Bereichsoperator (..) im 106

erkennen im Debugger 525

Evaluierung von Ausdrücken im Debugger 530

foreach–Anweisungen, bereitstellend 35

Funktionen im 701

Hashes im 12

Hashvariablen, Verwendung im 80

Komma–Operator im 111

Konditional–Operator im 108

Listenzuweisung im 111

Lvalues im 135

m//–Operator im 156

m//g, Auflistung aller gefundenen Treffer 157

skalaren Kontext erzwingen anstelle 801

Subroutinen, Aufruf und Evaluierung im 228

Listenoperatoren 89, 91, 111

unäre Operatoren, Unterscheidung 99

$LIST_SEPARATOR 690

Literale 146

numerisch siehe numerische Literale

Pseudoliterale siehe Eingabeoperatoren

String siehe Stringliterale

UTF–8, aktivieren bei 421 b16>

Little–Endian 643

Beispiel 784

pack und 781

local

Dateihandles 82

Signal–Handler–Zuweisung 430

Variablen siehe local–Deklarationen

local–Deklarationen 135, 137, 759

globale Variablen, Verwendung bei 140

Speicherung interner Werte von 491

typische Programmierfehler mit 605

verglichen mit my 607

locale–Pragma 894

Locales

Deklarationen, Stringvergleiche und 103

Dezimalpunkte in Formaten 244

locale–Pragma mit POSIX–Zeichenklassen 183

Module und Pragmas für 568, 894

Perl–Zeichenklassen–Abkürzungen und 174

Unicode und 758

localtime–Funktion 761, 892

Anwendungsbeispiel 77, 343, 906

File::stat und 824

strftime und 931

und time–Funktion 839

überschreiben 895, 940

umkehren 940

 siehe auch 1  gmtime

 siehe auch 1  Zeit

lock–Funktion 472, 762

Anwendungsbeispiel 587

Referenz als Argument für 253

locked–Attribut (Subroutinen) 239, 355, 474, 476

Locking von Dateien 435

Aufheben, beim Schließen von Dateien 436

DBM–Dateien 438, 719

flock–Funktion 735

gemeinsamer (shared) und exklusiver Zugriff 435

Locking von Methoden 476

log–Funktion (logarithm) 762

komplexe Zahlen und 930

Logdateien, Perl–Module für 569

LOGDIR–Variable 520

Login–Namen

Funktionen für 703

getgrent–Funktion 740

getgrgid–Funktion 741

getgrnam–Funktion 741

getlogin–Funktion 743

logische Operatoren 27, 112

Negationsoperator (!) 95

ODER–Operator (||) 105, 197

Verwendung mit Listenoperatoren 132

Trennung, Parent– und Child–Prozesse 463

_berladung 367

UND–Operator (&&) 105

Vorrang 327

Lokalisierung siehe auch  Locales

Long 783

Long Long 783

Lookahead 211

Lookaround 211

Lookbehind 211

Löschen von Hashes 397

Löschen siehe Entfernen

lstat–Funktion 762

_ und 102, 679

Portabilität 642

überschreiben 893

 siehe auch 1  stat

 siehe auch 1  symbolische Links

 siehe auch 1  Symlink b16>

lt–Operator 28

 siehe auch 1  le

 siehe auch 1  linke spitze Klammer unter

Symbole

Lvalues 53, 55

?: und 109

Effizienz von 630

identifizieren mit ref 795

Lvalue–Attribut von Subroutinen 240

Methoden, Deklarieren zum Anzeigen der Rückkehr aus 355

Modifier und 135

Operatoren und 25

Pattern–Matching–Operatoren, Verwendung mit 151

Referenzen und 93

Subroutinen und 56

Zuweisungsoperatoren und 110

M

/m–Modifier 153, 156, 159

–M Dateitest 101, 103, 681

–m Kommandozeilen–Switch 514

–M Kommandozeilen–Switch 514

blib–Pragma und 865

m// (Match–Operator) 74, 146, 156, 531, 605, 762

=~ (Bindungs–)Operator, Verwendung mit 150

Interpolation bei doppelten Anführungszeichen bereitstellen 149

Modifier für 153, 156

pos–Funktion und 787

m//g, Veränderungen über Perl–Versionen 610

m?? (Match–Operator) 158, 531

reset–Funktion und 798

Macintosh–Betriebssystem

Aufruf von Perl–Anwendungen 506

File::Spec::Mac–Modul 893 b16>

Kommandozeilenschnittstelle bei 19

Quoting bei 508

magisches Autodekrement und Autoinkrement 94, 107, 368, 385

Mail

Perl–Module für 568

senden, Portabilität und 646

main–Paket 59, 301

Makefile, für Perl–Erweiterungen anlegen 899

Makefile.PL 551, 569, 571

MakeMaker 571-572

malloc

Fehler 690

PERL_DEBUG_MSTATS–Umgebungsvariable, verwenden mit 521

man–Befehl xxv, 311, 534

MANIFEST–Datei 552, 899 b16>

Manpages xxv

CPAN doc–Unterverzeichnis 565

Pod::Man–Modul 898

map–Funktion 44, 624, 763

Anwendungsbeispiel 44, 202, 298

Schwartzsche Transformation und 815

Umwandlung in Großbuchstaben mit 401

void–Kontext und 624

 siehe auch 1  grep–Funktion

Mapping von Schlüsseln, Pseudo–Hashes 347

Markierungs–Stack 491

Marshalling–Module 909

$MATCH 690

Match–Operator (??) siehe m??

Match–Operator (m//) siehe m//

Matching siehe Muster

Math::BigFloat–Modul 892

Math::BigInt–Modul 361, 892

Math::Complex–Modul 892

Math::Trig–Modul 892

Mathematik

Bibliothek (C) 555

mathematische Funktionen, _berladung 369

Operatoren 23, 89

Perl–Module für 567

maximale und minimale Element–Trefferanzahl festlegen 39

maximales Matching 166, 185

mehrdimensionale Arrays 13, 279

mehrdimensionale Hashes 290

Erzeugung 291

Zugriff und Ausgabe 292

Mehrfachvererbung 334

AUTOLOAD–Subroutine und 341

Methoden 340

SUPER–Pseudopaket, Arbeiten mit 338

Member–Daten 332

Mengen, Schnittmengen 232

Message Digests, Perl–Module für 568

Metasymbole

alphanumerisch, in Mustern 167

Erweiterungssyntax für 166

in Mustern 164, 170

Metazeichen 146, 618

Escaping mit Backslash (\) 164

Escaping mit quotemeta 791

in exec–Argumenten 729

in Mustern 164

Shell, in Pipe–Befehlen 773

strukturelle 147

method–Attribut (Subroutinen) 239, 355

Methode (in overload–Pragma) 374

Methoden 264, 321

Arrays mit tie bindende 388

aufgerufen von über tie gebundenen Variablen 379

aufrufen 324

explizit oder implizit 324

mittels Arrow–Operator 325

mittels indirekter Objekte 326

verglichen mit Subroutinenaufrufen 331

automatisch ladende 341

Deklarationen, Rückgabe von Lvalues anzeigend 355

Hashes mit tie bindende 393

Klassendaten, wie Accessoren arbeitend 357

Locking (Objektmethoden) 476

Namen für 625

Perl–Klassen, Vererbung von 344

private Methoden, Vererbung ignorieren mit 342

Referenzen auf 270

Skalare mit tie bindende 380

Subroutinen als 323

Suche nach

Klassenvererbung 335

Vererbung durch @ISA–Array 335

Thread–Klasse 467

für über tie gebundene Arrays 387

für über tie gebundene Dateihandles 398

für über tie gebundene Hashes 392

überschreiben 337

UNIVERSAL–Klasse 339

hinzufügen zu 340

verglichen mit Subroutinen 225, 324

zu einer existierenden Klasse hinzufügen 338

Microsoft Windows

ActiveState–Perl–Distribution 506

CPAN–Module 570

Datei–Globbing mit File::DosGlob 893

File::Spec::Win32–Modul 893

Forking und Klonen von Interpretern 464

Perl–Module für 569, 901

Portierungsinformation (perlwin32) 428

Quoting bei NT 507

Registrierung, bearbeiten 413

Shell, alternative Shell für Perl festlegen 520

Signalnummer 0 bei 431

Wide–Character–APIs verwendende Systemaufrufe 419

Win32::Pipe–Modul 449

MIDI, Perl–Module für 569

MIME, Perl–Module für 568

minimales Matching 40, 166, 185

Minus–Operator (–) 95

mkdir–Funktion 763

Anwendungsbeispiel 625

verglichen mit mkdir–Systemaufruf 617

mkfifo–Funktion 449

MLDBM–Modul 412

Data::Dumper–Modul, Verwendung mit 909

mmap–Systemaufruf 451

$mode–Dateistatistik 823

Modems, Perl–Module für 567

Modi, Íffnen von Dateien 771

Modifier

Anweisungen

einfache 116

verglichen mit Quantifiern 148

Muster 153

einschränken 194

m// (Match–Operator) 156

s///–(Substitutions–)Operator 159

tr///–(Transliterations–)Operator 162

Modifikationszeit, Datei 823, 847

Module xx, 14, 300, 311

Backend 493

CPAN 16, 566

ablegen im 300

dekomprimieren und entpacken 570

erzeugen 571

Installation in Perl–Bibliothek 570

Kategorien 567

kompilieren 570

Mail senden 646

Portabilität 647

Programmen zugänglich machen 569

Verzeichnis für 565

eingebaute Funktionen überschreiben 318

erzeugen 313

Privatsphäre und der Exporter 314

Versionsprüfung 317

Export von Symbolen verhindern 317

Funktionen für 703

Groß–/Kleinschreibung von 57

importieren 899

in separate Dateien zerlegen 308

Klassen, Privatsphäre durch Speicherung in 342

Klassensystem und 336

Namen an andere Module exportieren 753

Namen für 624

Sicherheit von Threads und 466

Standardmodule 891

Basisklassen 898

Benutzerschnittstellen 896

Betriebssystem–Schnittstellen, bearbeiten 894

Dateien, Cross–Plattform–Methoden für den Zugriff 893

Datentypen 892

DBM 896

Dokumentationsunterstützung 898

Entwicklerunterstützung 900

Installationsunterstützung 899

Internationalisierung und Locales 894

Kommandozeilen 892

Netzwerke und Interprozeßkommunikation 895

objektorientierter Datei–, Verzeichnis– und IPC–Zugriff 893

Perl–Compiler und –Codegenerator 900

Perl–Spracherweiterungen und Externes 897

Sicherheit 897

Text verarbeiten mit 892

Warnungen und Ausnahmen 898

testen 551, 554, 573

Thread–Module 478

tie–Module im CPAN 412

verglichen mit Klassen 300

 siehe auch 1  Pakete

Modulus–Operator (%) 97

mod_perl 492, 556

mögliche Treffer, Menge festlegen 195

MS–DOS–Betriebssystem, Perl–Programme aufrufen 506

msgctl–Funktion 764

Portabilität 642

msgget–Funktion 764

Portabilität 642

msgrcv–Funktion 764

Portabilität 642

msgsnd–Funktion 765

Portabilität 642

$mtime–Dateistatistik 823

Multiplikation 23

Strings, Wiederholungsoperator 24

multiplikative Operatoren 24, 97

Multiprocessing

Prozessorzugriff, Unvorhersehbarkeit des 587

Thread–Modell 465

Multithreading 463

Muster (und reguläre Ausdrücke) 36, 145

abschließendes Trennzeichen für 149

alphanumerische Metasymbole 167

Autosplitting mittels –a–Switch 512

bedingte Interpolation in 223

Capturing und Clustering in 190

Clustering in 193

Codeevaluierung zur Matching–Zeit 219

Debugger, Befehle für Matching 531

deklarativer Ansatz in 215

Erweiterungssyntax 166

Lookaround–Zusicherungen 211

Funktionen für Matching 702

generierte 216

gieriges Matching 39, 208

grep–Funktion und 752

leftmost longest 186

von links das Längste 186

Matching

$`–, $&–, $'–Variablen und 152, 158

Operatoren für 36, 149

Teilmustern entsprechende Teilstrings 152

Matching–Vorrang 205

Metazeichen und Metasymbole in 164

Metasymbole 170

minimales Matching 40

Modifier 153

eingrenzende 194

Musterinterpolation zur Matching–Zeit 222

Perl–Code in 215

Positionen für Matching 186

Programmierstil für 215

Quantifier in 148, 165, 184, 208

Quoting–Zeichen in 65

re–Pragma, Standardverhalten ändern von 897

rekursives Matching 222

Rückwärtsreferenzen 42, 190

Sicherheitsaspekte 601

split–Funktion und 150, 817

Steuerung des Matchings 197

Perl–Flußkontrolle, Musterausführung entscheiden 197

Regex–Compiler 203

study–Funktion 825

Substitutionsevaluierung 217

trickreiche Muster 211

Unicode–Eigenschaften, Matching 423

für unsichere Daten 580

Veränderungen in den einzelnen Perl–Versionen 609

wiederholt vorkommende Wörter in Absätzen finden 155

Zeichen in 146

Zeichen, anstelle von Bytes erkennen 422

Zeichenklassen 38, 172

Verwechslungen mit Arrayindizes 68

Zusicherungen in 147

Zusicherungen, Definition eigener 223

 siehe auch 1  m//–Operator; m??–Operator

Muster–Bindungsoperator 37

Muster–Interpolation bei Erkennung 222

Musterabschnitte 182

Mutatoren, Kopieren und 371

my–Funktion 58, 115, 123, 134-137

Anwendungsbeispiel 230

Deklaration 765

Closures und 269

 siehe auch 1  local–Deklarationen; our–Deklarationen

Effizienz 616

Kontextregeln und 72

Pakete und 301

Schleifenvariablen und 120

typische Fehler mit 605

verglichen mit local 141, 607

verglichen mit our 58

Zuweisung von Listen an 78

 siehe auch 1  lexikalischer Geltungsbereich; local–Deklarationen; our–Deklarationen b16>

N

–n Kommandozeilen–Switch 515

\n siehe Zeilenvorschub (Newline)

Nachrichten

beim Einstieg in und Verlassen von Subroutinen ausgeben 538

Funktionen für 764

IPC::Msg–Modul 895

mittels UDP weitergeben 460

Skript eingebettet in 519

System V IPC 451

über Sockets empfangen 795

über Sockets senden 807

Namen 55

Array 55

Attribute 240

Befehle 16

von Benutzern siehe Benutzernamen

von Betriebssystemen 690

Computer siehe Hostnamen

Datei siehe Dateinamen

Format siehe Formate; deklarieren

Funktion 16

Geltungsbereiche, begrenzen auf 135

Groß–/Kleinschreibung, Konventionen bei Perl 56

Gruppennamen 741

Hash 55

Hashes, speichern in 9

Hostnamen in Netzwerkadressen übersetzen 742

in Netzwerkadressen übersetzen 744

Klassen, Unterscheidung von Subroutinen 329

Konstruktoren 332

Labels und Dateihandles 56

Login siehe Login–Namen

Lookup 58

Methoden, über tie gebundene Variablen 379

mit Dateihandles assoziierte Formate 243

Module 312

Groß–/Kleinschreibung in 312

Module/Pakete 624

Netzwerkadressen, ermitteln aus 742, 744

Paket 302

Parameter 228

Ports, ermitteln aus Nummer 748

Programm siehe Dollar–Zeichen, $0 unter Symbole

Protokolle

aus Portnummern bestimmen 748

übersetzen in/aus Zahlen 746

Signal 430

Socket 706

Subroutine 56, 226

Groß–/Kleinschreibung von 226

Symboltabellen 303

von temporären Dateien 592

Typeglob 81

für Variablen 5, 54, 624

verglichen mit Identifiern 57

Namensräume 55

Kapselung basierend auf 413

Module und 314

für Pakete 15

Zugriff, einschränken mit Safe–Modul 595

 siehe auch 1  Pakete

natürliche Sprachen 4

Umgebungsvariable 520

NDBM_File–Modul 896

ne–Operator 28, 604

 siehe auch 1  Ausrufezeichen unter Symbole

Negation

arithmetischer Negationsoperator (–) 95

bitorientierter Negationsoperator (~) 95

logischer Negationsoperator (!) 95

_berladung 367

POSIX–Zeichenklassen 183

Zeichenklassen 40, 173-174

 siehe auch 1  Ausrufezeichen unter Symbole

negative Arrayindizes 53, 611

negative Lookahead–Zusicherungen 208, 211

negative Lookbehind–Zusicherungen 212

Net::hostent–Modul 743, 895

Class::Struct, zur Erzeugung von Objekten und Accessoren 907

Net::netent–Modul 744, 895

Net::Ping–Modul 895

Net::proto–Modul 746

Net::protoent–Modul 895

Net::servent–Modul 895

Netnews siehe Usenet

networks–Datei siehe /etc/networks

Netzwerke

Clients 456

Dienste, Perl–Module zur Interaktion mit 569

Module für 455, 567, 895

Netzwerkadressen, Umwandlung in Namen 742, 744

Netzwerkinformation, Funktionen zur Gewinnung 703

Server 457

Win32–Netzwerk–Module 901

Neukompilierung von Mustern, Beschränken mit /o–Modifier 154

new–Methode 467, 768

Newsgruppen siehe Usenet

next–Operator 35, 120, 125-126, 768

bei do { } while 128, 607

next if–Konstrukt 613

Verlassen von Einmal–Blöcken mit 127

NFA (nicht–deterministischer finiter Automat) 205

NFS (Netzwerk–Dateisysteme), Beschränkungen 454

nicht gleich siehe Gleichheitsoperatoren;relationale Operatoren

nicht–deterministischer finiter Automat (NFA) 205

nicht–initialisierte Variablen 8

nicht–interaktiver Modus, Debugger wechseln in 539

NICHT–Operator (!) 95

 siehe auch 1  Ausrufezeichen unter Symbole

$nlink–Dateistatistik 823

\NNN Metasymbol 170

no–Deklarationen 132, 313, 385, 768

 siehe auch 1  Pragmas

nomethod–Schlüssel 372

Null

Dateihandle 85

Nulliste 76, 79

Nullwerte 8

Null–Device, Unix 409

Nullängen–Zusicherungen 147, 165, 186

Quantifier und 148

numerierte Variablen 679

numerische Literale 62

numerischer Kontext 73

Nummern 6

Befehle, History für Debugger 524

Zeilennummern (_ _LINE_ _–Token) 71, 637

Ports, Protokollnamen ermitteln aus 748

Protokoll 746

NV (interner Double–Wert) 548

O

/o Modifier (Einmal) 199

/o–Modifier 153-154, 157, 159

–o Dateitest 100

–O Dateitest 100

O–Modul 493, 495, 901

Objekte 14, 321

Blessing 93, 708

Destruktion (global), kontrollieren 521

Funktionen für 703

Instanz–Destruktoren 343

Garbage Collection mit 344

Instanzdaten

Accessoren erzeugen mittels Autoloading 350

Accessoren erzeugen mittels Closures 351

Klassen erzeugen mittels Class::Struct 349

neue Features, Perl 5.6 355

private Objekte, Verwendung von Closures für 352

Instanzdaten verwalten 344, 346

Klassen 300

Klassendaten verwalten 356

Konstruktoren 330

Initializer 332

vererbbar 331

 siehe 1 Konstruktoren

Methoden 264

Locking 476

Referenzen auf siehe Closures

Threads 467

Perl–Objektsystem 323

Referenzen auf, in Skalaren 7

Speicherung in anderen Objekten verglichen mit Vererbung 344

über tie gebundene Variablen, darunterliegende 378

Referenz aufbrechen 411

Umwandlung in Strings 268

Vererbung 334

durch @ISA–Array 335

objektorientierte Programmierung 300, 311, 321, 321

Abstraktion 324

Module für 311, 567, 893

portable Operationen für Dateinamen 893

Referenzen in Perl, emulieren 301

oct–Funktion 62, 769

Anwendungsbeispiel 62

chmod, Verwendung mit 711

 siehe auch 1  hex

 siehe auch 1  sprintf

ODBC, Perl–Module für 569

ODER–Operator 27, 105-106, 112, 197, 625

| (bitorientiert) 104

Listenoperatoren, Verwendung mit 132

Vorrang, ODER verglichen mit || 27, 327

 siehe auch 1  vertikaler Strich unter Symbole

Íffnen

Dateien mittels Low–Level–Systemaufruf 831

Sockets 811

Offsets

für m//–Fortschritt 787

read–Funktion und 792

seek–Funktion 802

Oktalzahlen 62, 769

$/ festlegen als 509

Zeichen, repräsentierend 170, 418

Oktet siehe Bytes

OLE, Perl–Module für 569

OOP siehe objektorientierte Programmierung

Opcode–Modul 897

Opcodes 485, 490, 548

open 769

open–Funktion 21, 444

$^F und 696

$. und 715

Anwendungsbeispiel 86

bei Pipes 442

Listenargument–Form, Shell vermeiden mit 600

Sicherheitsrisiken durch 583

Zwei–Argument–Form 773 b16>

benannte Pipes und 450

Dateideskriptor in Dateihandle umwandeln 441

fileno–Funktion und 735

fork–open 444, 774

 siehe auch 1  fork

Liste mit Dateien und 258

Locking von Dateien und 437

Modi der Drei–Argument–Form 771

Netzwerk–Server und 458

open–Pragma und 877

Portabilität 642, 645-646

set–id–Programme und 585

Sicherheit und 577

temporäre Dateien und 591

über tie gebundene Dateihandles und 400

_bergabe von Dateihandles mit 439

verglichen mit binmode 706

verglichen mit FileHandle–Modul 923

verglichen mit Open2 und Open3 447

verglichen mit sysopen 831

 siehe auch 1  sysopen–Funktion

open–Pragma 877

Open2–, Open3–Bibliotheksmodule 447

opendir–Funktion 778

 siehe auch 1  readdir

Operanden–Stack 491

Operationen, Kontext und 71

Operatoren 23, 89

Assoziativität 89

C, bei Perl fehlend 113

logische Operatoren 27

zur Schleifensteuerung 125

Matching und Substitution 146 b16>

Pattern–Matching 149

Modifier für 153

Positionen verglichen mit Längen in Unicode 423

Quoting–Operatoren 65

Quoting–Zeichen, syntaktische -hnlichkeit mit 8

skalarer Kontext, für Parameter bereitstellen 8

Stringoperatoren 24

überladbar 91, 361, 364, 892

arithmetische Operatoren 366

bitorientierte Operatoren 367

Dereferenzierungsoperatoren 370

iterative Operatoren 369

Konvertierungsoperatoren 365

logischer Negationsoperator 367

ringförmige Referenzen, Probleme mit 370

Vergleichsoperatoren 369

Zuweisungsoperatoren 367

Verben als 17

Vorrang 23, 89

bei C, in Perl beibehalten 91

Zugriff, beschränken mit Safe–Modul 597

Zuweisungsoperatoren 25 b16>

ops–Pragma 897

Optimierung

im Perl–Compiler 484

Performance und 612

Optionen siehe Modifier; Switches, Kommandozeile

Optionsverarbeitung, Perl–Module für 568, 892

ord–Funktion 714, 778

Portabilität 648

Unicode und 424

 siehe auch 1  chr

OS/2–Betriebssystem

File::Spec::OS2–Modul 893

Perl–Anwendungen starten unter 506

$OSNAME ($^O–Variable) 690

$OS_ERROR 691

our–Deklarationen 58, 115, 135, 137, 778

globale Variablen, mit lexikalischem Geltungsbereich 138

Gründe für Existenz 143

Kontextregeln und 72

strict–Pragma und 884

vars–Pragma und 886

verglichen mit my 765

verglichen mit subs– und vars–Pragma 861

$OUTPUT_AUTOFLUSH 691

$OUTPUT_FIELD_SEPARATOR 691

$OUTPUT_RECORD_SEPARATOR 692

overload–Pragma 362

overloading 361 b16>

P

\p Unicode–Matching 422

\P Unicode–Matching 422

–p Dateitest 100, 449

–p Kommandozeilen–Switch 515

–P Kommandozeilen–Switch 516

Paßwörter 823

crypt–Funktion und 717

passwd–Datei 746

Perl–Module für 568

pack–Funktion 643, 780

Anwendungsbeispiel 70, 765, 806, 830

Byteordnung und 643

Schablonenzeichen für 780

Stringlänge und 423

UTF–8 und 424

vec und 850

 siehe auch 1  unpack

Pads 55

Paketdeklaration 134, 301, 785

Pakete 14, 55, 57, 299

bless–Funktion, Argumente 330

Blessing von Objekten in 708

Identifier 302

in @ISA–Array, Vererbung durch 335

Methoden hinzufügen bei vorhandenen 338

Methoden und Subroutinen, Auflösung von 324

Namen für 68, 624

Quoting 328

Semantiken importieren 846

Symboltabellen 303

ausgeben 538

Trennsymbole für 302

Variablen binden an 837, 845

Zerlegung für Autoloading 899

 siehe auch 1  Module; Namensräume

Paketvariablen 57, 59

Deklaration in Block–Geltungsbereich packen 357

deklarieren 778

Klassendaten speichern in 357

Threads, kein Schutz in 472

 siehe auch 1  globale Variablen

PalmPilot, Perl–Module für 567

Parameter

skalarer Kontext, bereitstellen für 8

Subroutinen

arbeiten mit 228

in–place ändern 229

 siehe auch 1  Argumente

Parent–Klassen 322

Parent–Prozesse

 siehe 1 Prozesse

Parsing 548

im Perl–Compiler 484 b16>

Interpolation bei doppelten Anführungszeichen und reguläre Ausdrücke 149

Text, Perl–Module für 568

Parsing–Bäume (parse trees) 482, 485

intern, festhalten 493

Rekonstruktion 483, 494

PATH–Umgebungsvariable 20, 516, 520

Sicherheit und 583

PAUSE 571

PDL (Perl Data Language) 567

Performance xx

messen 839

Perl–Programme, Effizienz in 611

Perl

Bibliothek, CPAN–Module einfügen 570

Black 669

C, verwenden aus 549

Erweitern mit XSUB 554

Erweiterungen erzeugen 551

externe C–Bibliotheksfunktionen verwenden 555

XSUBs und XS 550

einbetten in C 556

Kompilierung eingebetteter Programme 556

Perl–Anweisung evaluieren aus C 558

Perl–Interpreter in C–Programm einfügen 557 b16>

Perl–Stack, Bearbeitung aus C 560

Perl–Subroutine aufrufen aus C 557

Erweiterungen und Interna, Module für 897

Geschichte 667

Lage auf Ihrem System 508

Module für Schnittstellen zu anderen Sprachen 568

Programme, Lebenszyklus 482

Programmierung, gängige Praktiken 603

spezielle Zeichen 6

Thread–Programmierung in 466

Versionen 690, 692

Verwendung von Unicode, Vorbehalte 425

virtuelle Maschine 490, 492

Perl Data Language–(PDL–)Modul 283

Perl Package Manager (PPM) 569

Perl–Interpreter 19, 482

–s–Switch 523

Sticky–Bit 618

Switches siehe Switches, Kommandozeile

Perl–Lyrik 669

Perl/Tk 621

Perl–Module für 567

PERL5DB–Umgebungsvariable 520

Debugger anpassen mit 536

PERL5LIB–Umgebungsvariable 520

PERL5OPT–Umgebungsvariable 520

PERL5SHELL–Umgebungsvariable 520

perlapi–Dokumentation 558

perlcall–Dokumentation 560

perlcc–Befehl 493, 682

pbyscript, resultierend aus 494

$PERLDB 692

PERLDB_OPTS–Umgebungsvariable

AutoTrace–Option, Tracing von Anweisungen in der Kompilierungsphase 526

Debugger anpassen mittels 535

perldoc–Befehl xxv, 311

Debugger aufrufen 534

perlembed–Dokumentation 556

eval_sv–Funktion in 560

perlfork–Dokumentation 428

perllocale–Dokumentation 758

perlmodinstall–Dokumentation 569

perlport–Dokumentation 428

Portabilitätsinformation zu Funktionen 704

perlwin32–Dokumentation 428

PERL_DEBUG_MSTATS–Umgebungsvariable 521

PERL_DESTRUCT_LEVEL–Umgebungsvariable 344, 521

$PERL_VERSION 690, 692

persistente Datenstrukturen mittels tie 413

persistenter Perl–Interpreter 556

Pfad für Bibliothekssuche 686

Pfadnamen für installierte Module 312

Pi 706, 866

Picture–Zeilen 243, 738

PID (Prozeß–ID) 693, 775

Prozeßgruppe ermitteln aus 745

 siehe auch 1  Prozesse

Pipe (|) siehe vertikaler Strich unter Symbole

pipe–Funktion 786

Portabilität 642, 646

verglichen mit socketpair 448, 812

Win32 und 449

Pipelines

mehrstufige, für Ausgabe 442

mehrstufige, für Eingabe 443

Pipes

bei Interprozeßkommunikation 442

benannte Pipes 449

Selbstgespräche führender Prozeß 444

beidseitige, mit über tie gebundenem Dateihandle öffnen 406

bidirektional, Interprozeßkommunikation 447

IO::Pipe–Modul 894

open–Funktion, Sicherheitsrisiken durch 583

Read–only–Dateihandles, öffnen 773

schließen 715

Plain Old Documentation siehe POD

Pluralitäten 9

.pm–Dateien 300

zugehörige Dateien laden mit 313

POD 651

Direktiven 653

einbetten in Perl 51

Module 659

Perl–Module für 567

_bersetzer 651, 659

Pod::Checker–Modul 898

Pod::Functions–Modul 898

Pod::Html–Modul 898

Pod::InputObjects–Modul 898

Pod::Man–Modul 898

Pod::Parser–Modul 898

Pod::Select–Modul 898

Pod::Text–Modul 898

Pod::Text::Termcap–Modul 899

Pod::Usage–Modul 899

POE (Perl Object Environment) 567

poll–Funktion 894

Polymorphismus 322

pop–Funktion 279, 787, 809

Anwendungsbeispiel 77, 232, 633, 756

splice und 816

split und 818

über tie gebundene Arrays 391

 siehe auch 1  shift

popen–Funktion (C) 556

Portabilität

von Dateien und Dateisystemen 644

Funktionen, Informationen zur 704

gethostent und 743

Informationen zur 428

von Perl–Programmen 641

von Signalen 646

Testen der Effizienz von 620

Portierungen, Perl, auf Betriebssysteme 565

Ports, Namen/Nummer–_bersetzungen für 748

pos–Funktion 188, 787

@+ und 688

\G und 189

Stringlänge und 423

Positionen 186

Beginn von Strings, erkennen 187

Ende von Strings, erkennen 187

Position direkt hinter letztem Treffer spezifizieren 189

Stringlänge und 423

substr–Funktion, bearbeiten mit 187

Vorrang beim Pattern–Matching 206

Wortgrenzen erkennen 188

Positionszusicherungen 189

Reihenfolge des Matchings ändern mit 196

positive Lookahead–Zusicherungen 208, 211

POSIX–Klassen 172

POSIX–Modul 894

exportierte Funktionen und Variablen ermitteln mit 313

getattr–Funktion 740

Signale blockieren mit 433

strftime–Funktion 761

Postinkrement– und Postdekrement–Operatoren 26, 89

$POSTMATCH 692

PostScript, Perl–Module für 568

Potenzierung von Integerwerten 560

Potenzierungsoperator (**) 94

PPM (Perl Package Manager) 569

Präfix–Operatoren 23, 89

Metazeichen fungierend als 164

Pragmas 16, 133, 141, 300, 514, 846, 861

charnames 63

lexikalisch beschränkte 141

Module und 313

Namen, Groß–/Kleinschreibung in 57

Präinkrement– und Prädekrement–Operatoren 26

Präprozessor (C) 516

$PREMATCH 693

print–Funktion 22, 44, 616, 788

in CGI–Skripten 637

Datensätze abschließen mit $\ 692

Effizienz 612, 616

Felder trennen mit $, 691

Flushing mit $| 691

indirektes–Objekt–Notation 327

Klammern und 99

Kommafehler bei 604

Objekte und 365

select und 803

über tie gebundene Dateihandles und 401

überschreiben, Ausnahmen auslösen bei 913

verglichen mit read 792

verglichen mit write 246, 854

 siehe auch 1  printf

printf–Funktion 108, 789, 820

$# und 679

Anwendungsbeispiel 716, 742, 824, 840

Effizienz 612

Stil und 635

über tie gebundene Dateihandles und 402

überschreiben, Ausnahmen auslösen wenn 913

 siehe auch 1  print

 siehe auch 1  sprintf

PrintRet–Debuggeroption 537

Priorität, Prozeß 745, 807

private Methoden, Vererbung ignorieren mittels 342

private Objekte, Verwendung von Closures für 352

private Variablen siehe local

Privatsphäre 322

Perl–Module und 314

$PROCESS_ID 693

Profiler, Perl 543

Profiling mit Devel::DProf 897

Programmargumente, Shell verglichen mit Perl 609

Programme

ausführen 834

Coredumps in 725

Debugger steuern aus 526

durchgehen mit Debugger 527

Notendurchschnitt, Berechnung und Ausgabe 18

verlassen 3, 733

Programmfluß, Steuerungsfunktionen für den 702

Programmiersprache, Perl–Module mit Schnittstellen zu 568

Programmierung, Perl 603

dateiverarbeitende Programme, Entwicklung portabler 645

Effizienz 611

fließend 626

häufige Fehler bei Anfängern 603

Portabilität 641

Programmgeneratoren

für andere Sprachen in Perl 636

Quellfilter 639

Stil 215, 622

Programmname

Perl–Executable 684

Perl–Skript 693

$PROGRAM_NAME 693

progressives Matching 189

Projekte (große), Vorteile des strict–Pragmas bei 16

Protokolle, Name/Nummer–_bersetzungen 746 b16>

Prototypen 233

& (Ampersand), vermeiden bei Subroutinennamen 234

Closures, zuweisen an 272

eingebaute Funktionen emulieren 234

implizite _bergabe mittels Referenz in 253

Inlining konstanter Funktionen 236

sorgfältige Verwendung von 238

Prototypfunktion, Ausnahme auslösen beim _berschreiben 913

Prozeß–ID (PID)

Prozeßgruppe ermitteln aus 745, 807

waitpid–Funktion 850

zurückgeben 745

zurückgeben mit fork 737

Prozeßgruppen 430, 745, 807

prozeduraler Programmierstil 215

Prozeduren 16

Prozentzeichen (%) siehe Prozent unter Symbole

Prozesse

auf Existenz prüfen 431

beenden (kill) 757

fork–Funktion 737

Funktionen für 703

Gruppe ermitteln 807

Identifier (PID) 775

Interprozeßkommunikation 427

Dateien 434

im Internet 427

Sockets 454

System V IPC 450

zwischen Prozessen auf der gleichen Maschine 428

Multitasking–Umgebungen, CPU–Zugriff 587

Priorität, setzen 807

Priorität, zurückgeben 745

Signale an Prozeßgruppen 430

STDIN, STDOUT und STDERR in 21

Threads und 463

umask für 841

Variablen für 683

Warten auf 850

Zombie 431

Prozessor siehe CPU

Prüfsummen 844

Prüfung für taint 577

Pseudo–Hashes 264

Klassen implementieren mit 766

Vererbung und 348

simulieren mit overload–Funktion 370

use fields–Pragma, Verwendung mit 347

Pseudo–Operatoren, _berladung und 365

Pseudobefehle, Piping 444

Pseudoliterale siehe Eingabeoperatoren b16>

Pufferung

Befehle 691

Anwendungsbeispiel 456

bei IPC::Open2 928

bidirektionale Pipes, Probleme mit 447

Block 691

mit exec 730

nicht–geflushte Puffer in Perl–Versionen 737

mit Pipe 786

mit seek 802

zeichenorientierte Eingabe 740, 932

Zeilenpufferung 691

Punkt siehe Punkt unter Symbole

Punktdateien mit über tie gebundenen Hashes bearbeiten 393

push–Funktion 54, 279, 790, 809

Anwendungsbeispiel 232, 281

emulieren 233

Hashes und 10

pop–Funktion 54

Referenz auf Arrays und 261

splice und 816

über tie gebundene Arrays und 391

 siehe auch 1  unshift

Push–Pop–(PP–)Codes 490

PV (interner Stringwert) 548

pwd–Befehl (Unix) 617

Python 51

Unterschiede zu Perl 604 b16>

Q

q//–(Quoting–)Operator 373

qr//–(Quote Regex–)Operator 74, 150, 202

Modifier für 153

Qt, Perl–Module für 567

Quantifier 38-39, 148, 165, 184, 614

Atome und 208

gierig 186

minimale und maximale 166, 185

Punkt–(.)Metazeichen, Verwendung mit 171

Zeichenklassen und 173

Quellcode

CPAN, für Perl–Distribution 566

Entwicklungswerkzeuge für 495

Fenster um Breakpunkt, untersuchen 525

Filter für 494, 567, 639

fremder Code, ausführen 575

Queues 279

Thread::Queue–Modul 478

Quit–Signale, Handler für 429

quotemeta–Funktion 791

Anwendungsbeispiel 222

Quoting, Pakete 328

qw–Operator 67, 77 b16>

qx//–Operator 65, 74, 83

open–Pragma und 877

Portabilität 642

readpipe und 794

 siehe auch 1  Backtick unter Symbole; system–Funktion

R

–r Dateitest 29, 100

–R Dateitest 100

Race Conditions

Behandlung 589

Dateitests und 873

langsame Operationen und 433

Locking von Dateien und 383, 435

Unix–Kernel und 588

rand–Funktion 92, 791

Anwendungsbeispiel 92, 131, 369, 600, 717

 siehe auch 1  srand

$rdev–Dateistatistik 823

re–Pragma 897

read–Funktion 792

Signale und 432

über tie gebundene Dateihandles und 403

verglichen mit print 792

 siehe auch 1  sysread

readdir–Funktion 792

 siehe auch 1  opendir

readline–Funktion 83, 793

ReadLine–Modul siehe auch  Term::ReadLine–Modul

readlink–Funktion 794

Portabilität 642

readpipe–Funktion 794

Portabilität 642

reale GID ($REAL_GROUP_ID) 693

 siehe auch 1  Dollar–Zeichen, $( unter Symbole

reale UID ($REAL_USER_ID) 682, 694

 siehe auch 1  Dollar–Zeichen, $<; unter Symbole

reale Werte, Testen mit defined–Funktion 719

recallCommand–Debuggeroption 536

Rechtsausrichtung 248

Rechtsshift (>>–)Operator siehe rechte spitze Klammer unter Symbole

recv–Funktion 795

Anwendungsbeispiel 461

Portabilität 642

Sockets und 807

 siehe auch 1  send

redo–Operator 125-126, 795

Redundanz bei Perl 29

ref–Funktion 330, 795

Anwendungsbeispiel 332, 351, 363, 367, 383

attributes–Pragma und 863

Definition 267 b16>

Referenten 252

Objekte als 323

Referenzen 7, 251

auf anonyme Daten 254

auf über tie gebundene Arrays 388

Blessing 330

Casting zu anderen Zeigertypen 61

auf Dateihandles 258, 770

auf Datenstrukturen 253

definieren 251

Destruktion, kontrollieren 521

erzeugen 254

mit Backslash–Operator 254

auf Funktionen, in Datenstrukturen speichern 294

geschweifte Klammern und eckige Klammern mit 274

auf Hashes 286

mehrdimensionale Hashes 294

Hashschlüssel als 898

Indirection und 60, 251

Locking 473

in mehrdimensionalen Arrays 280

auf Objekte 257, 264, 323, 330

Aufrufer für Instanzmethoden 324

_berladung und 361

objektorientierte Programmierung und 301

Perl, verglichen mit C–Zeigern 113

Prüfung auf 795

ringförmig

Speichernutzung bei 276

_berladung, vermeiden bei 370

schwache 276

schwächen und aufbrechen 344

auf Signal–Handler (benutzerdefiniert) 428

auf über tie gebundene skalare Variablen 381

String–Repräsentation erzeugen 268, 275, 282-283

auf Subroutinen 226

auf Subroutinen, erhalten von oder übergeben an 305

symbolische 273

in Symboltabellen auf andere Symboltabellen 304

auf Symboltabelleneinträge 259, 306

_bergabe mittels 227

übergeben 232

auf über tie gebundene Variablenobjekte, aufbrechen 411

Wahr–Wert von 30

reftype–Funktion (attributes–Pragma) 330

Regex siehe Muster

Regexps siehe Muster

Registrierung (Microsoft Windows)

bearbeiten 413, 569, 902

.pl–Erweiterungen und 506 b16>

reguläre Ausdrücke siehe Muster

reguläre Dateien, Testen auf 29

Reihenfolge siehe Vorrang

Rekursion

von lexikalischen Padstacks 491

beim Pattern–Matching 222

von Subroutinen 230

relationale Datenbanken

Hashes binden an (Tie::DBI) 412

Hashes binden an (Tie::RDBM) 413

 siehe auch 1  Datenbanken

relationale Operatoren 103

Nichtassoziativität von 103

rename–Funktion 796

Anwendungsbeispiel 513, 728

Portabilität 645

require–Funktion 133, 312, 686, 797

@INC und 857

base–Pragma und 864

caller und 709

Geltungsbereiche und 137

Laden von Funktionen und 231

lib–Pragma und 875

Paket–Deklarationen und 301, 785

Perl–Bibliotheken und 856

tie und 379

verglichen mit do 724

verglichen mit use 846

_ _DATA_ _ und 71

 siehe auch 1  use

REs siehe Muster

reservierte Wörter 56

Barewords, möglicher Konflikt mit 67

reset–Funktion 798

return–Funktion 125, 228, 799

Beendigung von Threads mit 468

eval und 128, 727

Fehler und 229

reval–Methode, verdächtigen Code ausführen mit 596

reverse–Funktion 44, 799

Anwendungsbeispiel 44, 122, 368

scalar und 424

Verbote mit sort 610

Revision siehe Version

rewinddir–Funktion 800

 siehe auch 1  opendir

rindex–Funktion 800

Stringlänge und 423

rmdir–Funktion 800

root–Verzeichnis, Redefinition 714

rot13–Verschlüsselung 162

Routinen siehe Subroutinen

RS (awk–Variable) siehe $INPUT_RECORD_SEPARATOR

RSTART (awk–Variable) siehe At–Zeichen unter Symbole

RTF, Perl–Module für 568

Rückkehr–Stack 491

Rückwärtsreferenzen 42, 156, 605, 679

erzeugen mit Klammern 192

Muster aus passenden Teilstrings ableiten 222

Zugriff mittels numerierter Variablen 191

 siehe auch 1  Capturing; Muster

Runden von Zahlen mit sprintf–Funktion 754

RV (interner Referenzwert) 548

Rvalues 53

S

–S Dateitest 100

–s Dateitest 100

/s–Modifier 153, 156, 159, 162

–S Kommandozeilen–Switch 516

–s Kommandozeilen–Switch 516, 523

\s–Metazeichen 38

s///–(Substitutions–)Operator 74, 146, 158, 605

=~ und !~, Bindungsoperatoren 150

Interpolation bei doppelten Anführungszeichen 149

Modifier für 153

Pattern–Modifier für 159

Safe–Modul 595, 897

unsicherer Code 595

Save–Stack 491

scalar–Funktion 73, 801

Anwendungsbeispiel 267

Arrays und Hashes, Größe bestimmen 758

Prototypen und 233

reverse und 424

Schablonen, Strings 780

Zeichen für pack/unpack 780

Scheduling und Präemptions–Regeln, Threads 466

Schleifen 32, 119, 605, 624

Endlosschleifen 122

eval–Funktion in 613

foreach–Schleifen 34

für Schleifen 34, 120

\G–Zusicherung, Verwendung in 190

Iteration durch 121

Kommentare und Leerzeilen vor Verarbeitung entfernen 198

Labels für 124

last–Operator und 35, 122, 757

next–Operator und 35, 768

redo–Operator und 795

reset–Funktion und 798

s///–Operator, Verwendung bei Arrays 160

Slices extrahieren, mehrdimensionale Arrays 283

Steuerungsoperatoren für, verglichen mit Anweisungen 127

until–Schleifen 120 b16>

Verwendung in globalen Substitutionen 161

while–Schleifen 33, 120

Schließen

Server–Verbindungen (einseitig) 457

über tie gebundener Dateihandles 402

Schlüssel, Hashes siehe Hashes, Schlüssel

Schnittmengen 232

Schnittstellen 322

Bytesemantik verglichen mit Zeichensemantik 419

Schreiben

in Dateien, open–Modus und 772

Daten mittels Low–Level–Systemaufruf 788-789, 835, 853

in Shared Memory–Segmente 810

Skripten siehe Skripten

schwache Referenzen 276

SDBM_File–Modul 896

Search::Dict–Modul 892

sed 36, 162

seed, Zufallszahl 822

seek–fähige I/O–Objekte 894

seek–Funktion 802

Anwendungsbeispiel 437

DOS–Textmodus und 642

Fcntl–Modul und 914

File::Temp und 593

über tie gebundene Dateihandles und 402

–x–Switch und 519

 siehe auch 1  tell–Funktion

seekdir–Funktion 803

telldir und 837

 siehe auch 1  opendir

 siehe auch 1  telldir

Seitenanfang–Verarbeitung 245, 685, 803, 853

Seitenvorschub (form feed) 685

Seitenzahlen 685

selbsterkennende Zeichen 210

select–Funktion (Ausgabe–Dateihandle) 788, 803, 894

Anwendungsbeispiel 246, 457, 513, 775, 853

FileHandle–Modul als Ersatz für 923

für Formatvariablen 246

IPC::Open3 und 447

Portabilität 642

Variablen und 676

select–Funktion (für Dateideskriptoren) 735, 803-804

Anwendungsbeispiel 460

fileno und 735

IPC::Open3 und 929

sleep–Operationen mit 450, 805, 811

select–Systemaufruf, Multiplexing der Ein–/Ausgabe zwischen Clients 458

SelectSaver–Modul 894

self–Methode (Thread–Modul) 470

SelfLoader–Modul 308, 900

Devel::SelfStubber–Modul, Verwendung mit 899

Semantiken, Import in Pakete 846

Semaphore

Funktionen für 806

IPC::Semaphore–Modul 895

Shared Memory 451

System V IPC 451

Thread–Sicherheit und 466

Thread::Semaphore–Modul 479

Verwendung beim Datei–Locking 438

Win32::Semaphore–Modul 902

semctl–Funktion 806

Portabilität 642

semget–Funktion 806

Portabilität 642

semop–Funktion 806

Portabilität 642

send–Funktion 807

Portabilität 642

 siehe auch 1  recv

sequentielles Matching 207

Serialisierung von Perl–Datenstrukturen 897

serielle Schnittstellen, Perl–Module für 567

Server 457

Klon–Forking zur Behandlung eingehender Verbindungen 458

Perl–Module für 568

Taint–Modus, Bedeutung der Aktivierung 577

TCP 456

Server–Push (CGI–Skripting) 896

Service–Port–Name/Nummer–_bersetzungen 748

set–id Programme, Bugs im Unix–Kernel, Sicherheitsprobleme mit 588

set–id–Programme 576

gefährliche Operationen behandeln 585

setgid 445, 576

 siehe auch 1  set–id–Programme

setgrent–Funktion 740

Portabilität 642

sethostent–Funktion 743

Portabilität 642

setnetent–Funktion 703, 744

Portabilität 642

setpgrp–Funktion 430, 807

Portabilität 642

setpriority–Funktion 807

Portabilität 642

setprotoent–Funktion 746

Portabilität 642

setpwent–Funktion 746

Portabilität 642

setservent–Funktion 748

Portabilität 642

setsockopt–Funktion 808

Anwendungsbeispiel 457, 460

Portabilität 642 b16>

setuid 445, 576

 siehe auch 1  set–id–Programme

sh (Bourne Shell)

–x–Emulation mit Perl 511

#!–Notation und 505

eval–exec–Hack und 20, 516

exec und 729

exit–Werte aus 835

Piping mit 773

Piping und 443

system–Funktion und 577

User::pwent und 941

 siehe auch 1  Shells

Shadow, Paßwort–Einträge 747

Shared Memory, System V IPC 451

Funktionen für 809

kontrollierter Zugriff auf 451

Shebang–Notation siehe #! unter Symbole

shell–Modul 894

Shells

Alternativen für Perl, Windows–Systeme 520

Anführungszeichen, übergeben 512

Befehle beginnend mit % oder $ 504

Bourne Shell (sh) 505

Debugger–Befehle und 532

I/O–Streams, einrichten 21

Pipe–Befehle mit Shell–Metazeichen, übergeben an 773

Pipe–Befehle mit speziellen Zeichen, Behandlung 442

Sicherheitsfallen vermeiden 600

starten, Zeichen für 536

Umgebungsvariable 519, 876

Sicherheitsrisiken 583

temporär setzen 519

umgehen mit –| 445

verglichen mit Perl 608

vermeiden bei open über Pipe mit mehreren Argumenten 443

Verwendung vermeiden 586

shift–Funktion 34, 98, 279, 808-809

@_ und 628

Anwendungsbeispiel 766

Effizienz 612

Queues und 790

splice und 816

 siehe auch 1  pop

 siehe auch 1  unshift

Shift–Operatoren 98

shmctl–Funktion 809

Anwendungsbeispiel 453

Portabilität 642

ShMem–Paket 452

shmget–Funktion 809

Anwendungsbeispiel 452

Portabilität 642

shmread–Funktion 809

Anwendungsbeispiel 453

Portabilität 642

shmwrite–Funktion 810

Anwendungsbeispiel 453

Portabilität 642

short (Datentyp) 821

Short–Circuit–Operatoren siehe logische Operatoren

shutdown–Funktion 457, 810

Anwendungsbeispiel 812

Portabilität 642

Socket trennen mit 716

shutdown–Systemaufruf 457

sichere Bereiche für unsicheren Code 595

Sicherheit xxi, 575, 823

Behandlung unsicheren Codes 594

als Daten maskierter Code 599

Behandlung unsicherer Daten 576

Befehls– und Dateizugriff bei beschränkten Privilegien 585

Erkennung nicht–vertrauenswürdiger Daten 579

Umgebung aufräumen 583

Behandlung von Timing–Fehlern 587

Race Conditions 589

Sicherheitsfehler des Unix–Kernels 588

temporäre Dateien 591

Datei–Testoperatoren und 873

Module für 568, 897

unsicherer Code, Behandlung, safe–Abteile für 595

Win32::FileSecurity–Modul 901

Sichern von Datenstrukturen 298

Sicherungsdateien 513

%SIG–Hash 428, 694

sigaction–Systemaufruf 432

SIGALRM–Signal 705

Signal–Handler definieren als Strings 303

Signal–Level–Debuggeroption 537

Signale 427, 428

%SIG–Hash 428, 694

Perl verglichen mit C 608

abfangen mit sigtrap–Pragma 429, 894

an Prozeßgruppen 430

Coredumps, auslösen in C–Bibliothek 429

Portabilität 646

Prozesse beenden (kill) mit 757

Quellen 428

sperren 433

Thread::Signal–Modul 480

Threads, ausliefern an 466

Timeout langsamer Operationen 433

Zombie–Prozesse und 431

sigprocmask–Systemaufruf 433

sigtrap–Pragma 429 b16>

sin–Funktion 811

Anwendungsbeispiel 489, 706

komplexe Zahlen und 930

Singularitäten siehe Skalare

$size–Dateistatistik 823

Skalare 6-7, 53

Funktionen zur Bearbeitung 702

harte Referenzen als 253

komplexe Datenstrukturen, repräsentieren als 14

konstant siehe auch  Konstanten

Liste von siehe Arrays

Listen, Konvertierung in 12

Parameter– und Rückgabelisten, Subroutinen 227

Pattern–Matching–Operatoren, anwenden auf 151

Perl, Umwandlung in C–Typen 559

Referenzen 7

SV (skalarer Wert) in C 548

Tying 379

Basisklassendefinitionen 898

magische Zählervariablen 385

Methoden für 380

nicht–lokalisierte Verwendung von $_–Variablen verhindern 385

ungeordnete Menge von siehe Hashes

Variablen

im Anführungszeichen–Kontext 158

in spitzen Klammern 86

Namen für 54

Wahrheit, Evaluierung in 30 b16>

Werte 60

Here–Dokumente 68

Interpolation von Arraywerten 68

numerische Literale 62

Operatoren für 91

Stringliterale 62

v–String–Literale 70

Zeichen, Länge von 758

skalarer Kontext 71

/g–Modifier, Verwendung in 157

Ausdrücke in siehe EXPRs

Bereichsoperator (..) 106

Boolesche Werte und 73

erkennen im Debugger 525

erzwingen 801

Funktionen in 701

Hashvariablen evaluieren in 80

Komma–Operator in 111, 611

Konditional–Operator in 108

Listenzuweisung in 78, 111

Lvalues in 135

m//–(Match–)Operator in 156

sich anders verhaltende Operationen in 606

Subroutinen, Aufruf und Evaluierung in 228

Untertypen 73

void–Kontext 74 b16>

Skripten

anhalten 811

Ausführung 834

Ausführungszeit 103

Beenden mit exec 729

CGI, Taint–Modus und 577

Coredump 517

CPAN–Verzeichnis von 566

Debugging 510

 siehe auch 1  Debugging

Ende–Markierung für 71

erzeugen mit –e–Switch 511

häufige Fehler von Anfängern 603

idiomatisches Perl 626

implizite _bergabe mittels Standardeingabe 504

in Nachrichten einbetten 519

Interpretation, Shells verglichen mit Perl 608

mit Perl–Interpreter assoziieren 19

Namen von siehe Dollar–Zeichen, $0 unter Symbole

Performance 611

Sprachen, Prüfung auf 179

Stil 622

Suche nach 516

Suche und Kompilierung 504

Syntax prüfen 509

Testskripten 900

unsicher 594

Skripten anhalten 811

sleep–Funktion 811

Alarm und 705

Anwendungsbeispiel 122

Auflösung unter einer Sekunde 805

select–Funktion anstelle von 805

Slices 55

von Arrays 605

Anwendungsbeispiel 77, 107

Syntax 94

von Hashes, Anwendungsbeispiel 872

Initialisierung mit x 97

Interpolation von 64, 690

local und 135, 141

mehrdimensionaler Arrays 283

Pfeile und Dereferenzierung 263

Referenzen und 267

Zuweisung an 72

socket–Funktion

accept und 705

Autovivification mit 760

Portabilität 642

Socket–Modul 455, 895

inet_ntoa–Funktion 742

Netzwerk–Client, Verbindung mit Server 456

socketpair–Funktion 448, 812

Portabilität 642 b16>

Sockets

Adresse festlegen 706

Funktionen für 455, 748

gepackte sockaddr–Adresse ermitteln 745

in Interprozeßkommunikation 454

Message–Passing 460

Netzwerk–Clients 456

Netzwerk–Server 457

listen–Funktion für 759

Low–Level–Zugriff, Funktionen für 703

Module für 895

Nachrichten empfangen über 795

Nachrichten senden über 807

öffnen mit socket–Funktion 811

Optionen setzen 808

Protokolle und 427

schließen 715, 810

TCP und 454

Unix–Domain–Sockets 454

verbinden 716

Verbindung herunterfahren 810

Verbindungen von Clients akzeptieren 705

Zeilenvorschübe, senden über 642

sort–Funktion 12, 44, 812

Hashes und 290

Locales und 877

Lokalisierung von $a und $b 676

Optimierung 488

reverse und 610

Stringlänge und 423

Variablen 679

Vergleichsoperatoren in 29

Sortieren

Arrays in Hashes von 288

Hashes 293

Listen 812

Schlüssel und Werte, Hashes 755

_berladung und 369

Speicher

Garbage Collection 276

Shared Memory Segment–ID 809

Shared Memory, System V IPC 451

kontrollierter Zugriff auf 451

Statistik ausgeben 521

Verwaltung, Destruktoren und 343

zuwenig 690

Speicherpositionen, Lvalues für 25

Speicherung komplexer Datenwerte in DBM–Dateien 412

sperrend, Shared Locks 435

sperrende Aufrufe, Locks in Threads 473

sperrende Signale 433

spezielle Variablen 678

spezielle Zeichen 209, 377

Spiele, Perl–Module für 569 b16>

splice–Funktion 816

Anwendungsbeispiel 369, 386, 787, 790

Effizienz 612

über tie gebundene Arrays und 391

Veränderungen in Perl–Versionen 609

verglichen mit delete 721

split–Funktion 36, 150, 194, 817

Anwendungsbeispiel 18, 78, 116, 287, 289, 627, 763

Effizienz 613, 616

join und 161

Muster und 36

reverse und 368

_berschreiben, Ausnahmen auslösen bei 913

 siehe auch 1  join

Sprachen

natürliche verglichen mit künstlichen 4

übersetzen 639

Zeichen prüfen für 179

Spracherweiterungen, Perl–Module für 567

sprintf–Funktion 402, 820

Anwendungsbeispiel 159, 380, 769

Punktvektor–Notation und 742

Runden mit 754

Stringlänge und 423

über tie gebundene Dateihandles und 398, 402

zweistellige Jahreszahlen und 750

 siehe auch 1  hex

 siehe auch 1  oct

 siehe auch 1  printf

sqrt–Funktion 822

Anwendungsbeispiel 811

komplexe Zahlen und 930

srand–Funktion 822

 siehe auch 1  rand

src–Verzeichnis (CPAN) 566

Stacks 10, 279

Backtracing mit T–Befehl 525

Disziplinen 777

Evaluierung von Ausdrücken 53

Perl Virtual Machine 491

Perl, bearbeiten aus C 560

Subroutinen, aktuelle Aufrufe 709

Standard Unicode–Eigenschaften 176

Standardausgabe siehe STDOUT

Standardeingabe siehe STDIN

Standardfehler siehe STDERR

Standardpaket 134

Startposition des erkannten Strings 689

stat–Funktion 823

_ und 102, 679

Anwendungsbeispiel 77

Datei–Zugriffsrechte und 769

Dateihandles, aufrufen auf 591

File::stat und 581 b16>

Portabilität 642

Superuser–Skripten und 102

überschreiben 893

 siehe auch 1  File::stat

 siehe auch 1  lstat

state, Vererbung mit Klassendaten–Accessor–Methoden 359

statische Geltungsbereiche siehe lexikalische Geltungsbereiche

statische Variablen (in C/C++) 230

statisches Linking 551

Statistik, Perl–Module für 567

Status eines endenden Prozesses 681

STDERR–Dateihandle 21, 626, 695, 735

Ausgabe an anderen Prozeß senden 413

neu zuweisen 459

_bergabe von Dateihandles an neue Programme mittels 439

STDIN–Dateihandle 21, 695, 735

–i–Kommandozeilen–Switch und 513

Lesen einzelner Zeichen aus 740

neu zuweisen 459

_bergabe von Dateihandles an neue Programme durch 439

STDOUT–Dateihandle 21-22, 695, 735

–i–Kommandozeilen–Switch und 513

Ausgabe <;/indexterm><;indexterm><;primary>Strings<;/primary><;secondary>ausgeben 788

neu zuweisen 459

_bergabe von Dateihandles an neue Programme durch 439

Sternchen (*) siehe Asterisk

Steuerzeichen 62, 182

Metasymbole in Mustern 170

Nicht–ASCII bei Macintosh 508

Sticky Bit 618

Stil, Programmierung mit 622

Strg–Zeichen siehe Control–*

strict–Pragma 16, 58, 142, 273, 883, 897

Barewords und 606

Stringende erkennen 187

Stringifikation 365

von Datenstrukturen 298

Module für 909

von Objekten 268

von Referenzen 268, 275, 282-283

_berladung 404

Stringliterale 62

v–Strings (Vektor oder Version) 70

Zeilenvorschübe in 64

Strings 6

Bereichsoperator, arbeiten mit 107

binär siehe binäre Zahlen

bitorientierte Operatoren, arbeiten mit 104

Darstellung ändern im Debugger 538 b16>

doppelte Anführungszeichen

Veränderungen in Perl–Versionen 610

Zeicheninterpolation bei 63

erstes Zeichen 679

eval–Funktion und 612

Formate für 820

Grenz–Zusicherungen 41, 187

Groß–/Kleinschreibung von siehe Groß–/Kleinschreibung

hexadezimal siehe Hexadezimalzahlen

in Teilstrings zerlegen 817

index–Funktion und 753

Joining 755

als Kompilierungseinheit 58

Kontext 73

Konvertierung in Listenwerte 843

Konvertierung in Zahlen 61

0x–, 0b– und 0–Präfix, Behandlung 62

Listenwerte, Konvertierung in 780

modifizieren 160

oktal siehe Oktalzahlen

Operatoren 24, 604

Quoting 8

Referenzen und 275

rindex–Funktion und 800

study–Funktion und 825

Teilstrings ersetzen (s///–Operator) 158

Teilstrings extrahieren 828

umbrechen siehe Dollar–Zeichen, $: unter Symbole

vec–Funktion und 848

Vergleiche 103

Vergleichsoperatoren 28

Verkettung 98, 616

mit join–Funktion 755

Wahr–Werte von 30

Werte ausgeben als 268

Zeilenvorschübe enthaltende, Matching 153

 siehe auch 1  Text

Stripping 711

struct

emulieren 349

formatieren 783

Struct::Class–Modul 346

strukturelle Metasymbole 165

strukturelle Metazeichen in regulären Ausdrücken 147

StrVal (in overload–Pragma) 374

Stubs für Module erzeugen 899

study–Funktion 825

sub–Deklaration 225, 235, 257, 827

Subklassen 322

Attribute, Superklassen–Vorfahren überschreiben 346 b16>

Subroutinen 6, 17, 225, 323

abbrechen mit exit 733

anonym 225

Referenzen auf 257

Argumente 681

Attribute, lesen und setzen 897

Aufruf–Stack 709

aufrufen

Ausführung ohne Einzelschritt 527

indirekt 226

verglichen mit Methodenaufrufen 331

Autoloading 307, 341, 899

B::Xref–Modul, Cross–Referenzen mit C 496

Barewords, verwechseln mit 609

benannte, Interaktion zwischen Compiler/Interpreter 497

Daten an und von übergeben 227

Debugger–Befehl für Pattern–Matching–Auflistungen 531

definieren 227

Definitionen laden aus anderen Dateien 133

deklarieren 132, 827

in Paket mit AUTOLOAD 342

do SUBROUTINE–Operator 725

ersetzen durch goto 131, 751

extern 549

Portabilität 647

Fehler anzeigen 229

Import aus anderem Modul 226

Klassen mit gleichem Namen 328

Konstante 306

Locking für Threads 474

locked–Attribut 476

Lvalue–fähige 355

Methodenauflösung, Schritte der 335

mit lexikalischem Geltungsbereich 765

Namen für 55-56

Namen von 226

Parameterlisten, arbeiten mit 228

Performance und 614

Perl, Aufruf aus C 557

Prototyping 233

sorgfältige Nutzung 238

Redefinition, Inlining und 237

Referenzen auf

empfangen von oder übergeben an 305

in Skalaren 7

Referenzen zurückgebende 257

Rückgabewerte 228, 799

Schleifensteuerung und 127

Scoping 230

_bergabe von Referenzen an 232

verglichen mit Methoden 324

verschachtelt 272

 siehe auch 1  Funktionen b16>

subs–Pragma 342, 897

eingebaute Funktionen überschreiben mit 318

$SUBSCRIPT_SEPARATOR 81, 695

Substantive 5

Pakete, Handling von 15

Substitution

Evaluierung von 217

Operator siehe s///

Shells verglichen mit Perl 608

substr–Funktion 828

\G und 189

-nderung von Stringpositionen mit 187

Anwendungsbeispiel 367, 453, 663, 712

chop–Funktion und 712

Effizienz 614, 618

Stringlänge und 423

verglichen mit speziellen Variablen 689

Zeilen ausrichten mit 514

Subtraktion

von Zeichensätzen 181

Pattern–Modifier aus Cloister 194

überladene Objekte 363

Suche

grep–Funktion für 752

linear, verglichen mit Hashes 612

Pfad für Bibliothekssuchen 686

Regeln für Namenssuche 59

reguläre Ausdrücke in siehe Muster

nach Skripten 516

nach Teilstrings 158, 753, 800

Text, Perl–Module für 568

Suchen und Ersetzen, globales 159

SUPER–Pseudoklasse 337

Superklassen 322

SV (interner skalarer Wert) 548

SWIG–System, XSUBs automatisch generieren 550

switch–Anweisung 129, 615

Perl verglichen mit C 607

Switches, Kommandozeile 504, 508

–e 504

– – 509

–0 504, 509

–a 509, 684

–c 509

–d 510, 523, 543

–e 19, 511

Ein–Zeichen–Switches, Verarbeitung mit Clustering 892

–F 509, 512

–h 512

–I 504, 512, 514

–l 514

–m 514

–n 515

–p 515-516

–s 516

Standard, Switches als 520

–T 459, 517, 576

–u 517-518

–v 518

–w 20, 518, 945

–x 504, 519

 siehe auch 1  individuelle Switch–Namen; Perl–Interpreter

Sx, Perl–Modul für 567

Symbole

aus Exportliste weglassen oder aus Importliste entfernen 315

exportieren 313, 317

Import in aktuelles Paket 312

Metasymbole, generische Wildcards 171

symbolische Dereferenzierung, prüfen mit strict–Pragma 143

 siehe auch 1  Dereferenzierung

symbolische Links 829

Dateinamen ermitteln aus 794

lstat–Funktion und 762

Sicherheitsrisiken unter Unix 588

 siehe auch 1  symlink

symbolische Referenzen 251, 273

Symboltabellen 55, 57, 303

aktuelles Paket, Verwendung ermitteln 301

Aliasing von Einträgen 82

ausgeben für Pakete 538

Formatnamen–Identifier in 739

local–Operator, temporäre -nderungen vornehmen mit 141

mit Referenzen auf andere Symboltabellen 304

Pakete 302, 786

Referenzen auf 259

Symbol–Modul 892

symbolische Referenzen, die Einträge benennen in 253

in vollständig qualifizierten Namen 57

symlink–Funktion 829

Portabilität 642, 644

Synchronisation, Datenzugriff bei Threads 472

Syntax

bei Perl 53

prüfen 509

Sys::Hostname–Modul 894

Sys::Syslog–Modul 894

syscall–Funktion 705, 829

fileno und 735

h4ph und 858

Portabilität 642

Rückgabewert 701

setitimer und 811

syslog, Dateihandle binden an 413

sysopen–Funktion 437, 831

Anwendungsbeispiel 584, 592, 931

Datei–Zugriffsrechte und 841

Dateien überschreiben und 590

Fcntl–Modul und 914

Locking von Dateien 437

open und 776

open–Pragma und 877

Portabilität 642

Race Conditions vermeiden 450

Tainting und 584

 siehe auch 1  open–Funktion

sysread–Funktion 833

Anwendungsbeispiel 836, 933

seek und 802

über tie gebundene Dateihandles und 403

verglichen mit read 792

 siehe auch 1  read

System V IPC 450

Funktionen für 703

Funktionen für Semaphore 806

IPC::SysV–Modul 895

Nachrichten, Systemaufrufe für 764

Portabilität 646

Prozeßgruppen beenden (kill) 757

Shared Memory, Funktionen für 809

Systemaufrufe 427

Unzuverlässigkeit von Signalen 432

system–Funktion 834

$? und 499, 681, 722

Effizienz 617-618

exit und 738

Listenargumentform, Shell vermeiden mit 600

Portabilität 642, 646

set–id–Programme und 585

Tainting und 579

_berschreiben 913

verglichen mit Backticks 624

verglichen mit exec 729

verglichen mit Systemaufrufen xxviii

wait und 850

Windows–Shells und 520

 siehe auch 1  exec

 siehe auch 1  qx

Systemaufrufe 829

neu starten 433

Performance und 617

Perl verglichen mit C 608

Signalunterbrechung von 432

$SYSTEM_FD_MAX 696

syswrite–Funktion 398, 835

Anwendungsbeispiel 384

seek und 802

Signal–Handler und 694

über tie gebundene Dateihandles und 398, 403 b16>

T

\t–Zusicherung 147

–T Kommandozeilen–Switch 455, 517, 576

Server und 459

–T Dateitest 29, 102

–t Dateitest 100

Tabellen siehe mehrdimensionale Arrays

Tags

HTML und XML, Transformation von Text in 224

Symbolmengen, Exporter 317

Taint–Checking 459, 517, 576

aktivieren mit –T 577

benötigende Programme 576

CGI–Programme und 598

–D und 510

Dateihandles, entfernen für 925

Definition 575, 577

File::Glob und 919

interpolierter Code und 601

Muster und 221, 879

PERL5LIB und 520

Safe–Abteile und 598

Taint–Modus 576

vertrauenswürdige Daten zurückgebende Funktionen 704

taintperl–Programm 610

tan–Funktion 706

Math::Trig und 930

 siehe auch 1  atan2

tar–Dateien, Perl–Module für 568

Tastatur–Sequenzen, Signale generieren mit 428

TCP

Client/Server 456

IO::Socket::INET und 456-457

Socket–Modul und 456

Sockets und 454

über Internet–Domain–Sockets 454

verglichen mit UDP 460

 siehe auch 1  IO::Socket

 siehe auch 1  setsockopt

tee–Programm, Unix 409

Teilarrays und Teilhashes, Referenzen auf (in Arrays) 9

Teilmuster ohne Backtracking 213

Teilstrings, Suche nach und Ersetzung mit s///–Operator 158

tell–Funktion 836

Anwendungsbeispiel 437, 802

DOS–Textmodus und 642

fgetpos als Alternative zu 924

über tie gebundene Dateihandles und 402

telldir–Funktion 837

seekdir und 837

 siehe auch 1  opendir

 siehe auch 1  seekdir b16>

temporäre Dateien

erzeugen mit FileHandle 924

File::Temp und 593, 921

Gefahren bei 591

POSIX–Modul und 931

Sicherheitsrisiken bei 591

temporäre Werte 53

Tengwar 422

Term::Cap–Modul 896

Term::Complete–Modul 896

Term::ReadKey–Modul 535, 740

Term::ReadLine–Modul 535, 896

Unterstützung für Debugger deaktivieren 539

Term::Rendezvous–Modul 539

Terme 53

Beziehungen zwischen, ausdrücken mit Operatoren 89

Vorrang 91

Terminal zum Debugging von I/O 539

Termination siehe Beenden

ternärer Operator 23, 89

?: als 108, 130

_berladung, funktioniert nicht mit 362

Test von Modulen 573

bei Installation 573

durch nette Freiwillige 573

test–Befehl (Unix) 20

Test–Modul 900

test.pl 551, 554

Test::Harness–Modul 900

Testen

definierte Werte 719

auf vertrauenswürdige Daten 579

Tests für Dateien siehe Datei–Testoperatoren b16>

Text

lexikalischer Geltungsbereich und 55

Perl–Module für 568, 892

POD–Daten, Umwandlung in formatiertes ASCII 898

umbrechen 249

Unicode als internationales Medium für 417

Verarbeitung, Perl–Fähigkeiten 145

 siehe auch 1  Strings

Text umbrechen, Perl–Modul für 568

Text::Abbrev–Modul 892

Text::ParseWords–Modul 892

Text::Wrap–Modul 892

Textdateien (–T–Datei–Testoperator) 29, 102

Texteditoren

Skripten eingeben mit 19

Zählung von Zeilennummern, Unterschiede zu Perl 51

Textstämme, Perl–Module für 568 b16>

Thread–Modul 466

Detach–Methode, Threads herunterfahren mit 470

join–Methode, Ausnahmen abfangen aus 469

Thread–Destruktion 468

Thread–Erzeugung 467

Threads identifizieren 470

Zuteilung eines Prozessors 471

Thread::Queue–Modul 478

Thread::Semaphore–Modul 466, 477, 479

Thread::Signal–Modul 480

Threads 463, 762

locked– und method–Attribute 355

Locking 762

mehrere, in einem Interpreter 492

Prozeßmodell 463

Thread–Modell 465

Datenzugriff 471

Kontrolle, _bergabe zwischen Threads 478

tid–Methode (Thread–Modul) 470

tie–Funktion 377, 837

Anwendungsbeispiel 275, 909

CPAN–Module für 412

DBM–Dateien und 438

Fehler bei Bindungsaufhebung 410

Portabilität 645

use oder require und 379

verglichen mit bless 378

 siehe auch 1  tied

 siehe auch 1  Tying von Variablen

tie–Modul im CPAN 412

Tie::Array–Modul 387, 898

SPLICE–Subroutine 391

Tie::Counter–Modul 385

Tie::DBI–Modul 412

Tie::DevNull–Modul 408

Tie::DevRandom–Modul 408

Tie::Hash–Modul 393, 898

Tie::Persistent–Modul 413

Tie::RefHash–Modul 898

Tie::Scalar–Modul 380, 898

Tie::SecureHash–Modul 354, 413

Tie::StdArray–Modul 387

Tie::STDERR–Modul 413

Tie::StdHash–Modul 393

Tie::StdScalar–Modul 380

Tie::SubstrHash–Modul 898

Tie::Syslog–Modul 413

Tie::Tee–Modul 408

Tie::TextDir–Modul 413

Tie::TransactHash–Modul 413

Tie::VecArray–Modul 413

Tie::Watch–Modul 413

tied–Funktion 378, 839

Anwendungsbeispiel 396

 siehe auch 1  tie

Tilde (~) siehe Tilde unter Symbole

time–Funktion 839, 892

Portabilität 648

Umwandlung in Felder 750, 761

 siehe auch 1  gmtime

 siehe auch 1  localtime

 siehe auch 1  utime

Time::gmtime–Modul 894

Time::HiRes–Modul 706

Time::localtime–Modul 895

Time::tm–Modul 895

timelocal–Subroutine 761

Timeout langsamer Operationen 433

times–Funktion 839

Portabilität 642

Timing

mit Alarmen 705

Fehler behandeln 587

Race Conditions behandeln 589

temporäre Dateien 591

Unix–Kernel–Sicherheits–Bugs 588

Laufzeiten von alternativen Codeversionen, Vergleiche 902

Skript ausführen 103

Vergleiche zur Subroutinen–Ausführung 543

Titelschreibweise

\u– und ucfirst–Funktion 164

ucfirst 423

Tk 536

 siehe auch 1  Perl/Tk

Token 51, 484

mehrdeutige Zeichen, Probleme mit 99

Parsing von Text in Liste von 892

Tokenizing siehe auch  lexikalische Analyse

Top–Level–Paket 59

Topikalisierung 14

tr///–Operator 150, 162, 840, 854

=~ und !~ Bindungsoperatoren 150

Modifier für 153

Zeichen, Transliteration mit 423

Trace–Modus ein–/ausschalten (Debugger) 529

Tracing im Debugger 525, 529

Translations–Escapes in Anführungszeichen 200

Transliteration siehe tr///

Trennsymbole definieren mit split–Operator 36

Trennzeichen, Mustererkennungsoperatoren und 151

Trigonometrie mit Math::Trig 892

trinärer Operator siehe ternärer Operator

truncate–Funktion 840

Anwendungsbeispiel 437

Portabilität 642

try–Block 727

TTY 448

Tying von Variablen 275, 377

Arrays 387

Dateihandles 398

Fehler bei Bindungsaufhebung 410

Hashes 392

Skalare 379

Typecasting–Operator (in C) 113

Typedefs (C) 548

Typeglobs 6, 56, 81, 251, 268

anonym 258

erzeugen mit Symbol–Modul 892

Autovivification 400

Dateihandle–Referenzen, erzeugen 258

Inhalt ausgeben 538

IO::Handle–Objekt 259

local–Funktion, verwenden mit 760

Prototyp–Symbol (*) 6

Subroutinen, auflösen in 324

in Symboltabellen–Hashes 304

Symboltabellen–Aliasing mit 306

Variablen, an Klassen binden mittels 378

verglichen mit Referenzen auf Typeglobs 258

Typemap 551

Typen siehe Datentypen

U

–u Kommandozeilen–Switch 517

\u–Escape 158

–u Dateitest 100

–U Kommandozeilen–Switch 518

_bergabe mittels Referenz 227

Prototypen, die Funktionsaufrufe deklarieren als 253

_bergabe mittels Wert, @_–Werte in my–Liste kopieren 228

_bergabe von Referenzen 232

überladene Stringkonstanten, Text übersetzen mit 223

_berladung 91

Autogenerierung 366

copy–Konstruktor (=) 371

Definition 72

Diagnose 376

Funktionen für 374

Handler 363

Konstanten 373

zur Laufzeit 375

mathematische Funktionen 369

nomethod und fallback 372

overload–Pragma 362, 892

Overloaded (Methode im overload–Pragma) 374

ringförmige Referenzen, vermeiden 370

Sortierung und 369

Stringification 404

überladbare Operatoren 364

Vererbung und 375 b16>

_berschreiben

Basisklassenmethoden 337

Funktionen 318

_berschreiben vorhandener Dateien, Race Conditions und 590

überschriebene Methoden (Basisklasse), Aufruf aller 340

_bersetzung 840, 854

zwischen Programmiersprachen 639

uc–Funktion 423, 840

Anwendungsbeispiel 353, 401, 915

Sortierung mit 813

ucfirst–Funktion 423, 841

Anwendungsbeispiel 345, 941

UDP

Anwendungsbeispiel 460

Pakete 454

Sockets und 454

_bergabe von Nachrichten mit 460

verglichen mit TCP 460

$uid–Dateistatistik 823

UID (Benutzer–ID) 713

angenommene 445

effektiv und real 682

Einträge aus passwd–Datei 747

umask–Funktion 841

Anwendungsbeispiel 586

mkdir und 763

open und 772

Portabilität 642

sysopen und 832

Umbrechen von Text 249, 892

Perl–Module für 568

Umgebung, aufräumen 583

Umgebungsvariable 519, 683

Env–Modul 897

Module, Verwendung bei Perl 521

PERLDB_OPTS, Debuggeroptionen setzen mit 540

PERL_DESTRUCT_LEVEL 344

Portabilität 646

Shells verglichen mit Perl 609

Taint–Checking 577

Umkehrung von print– und printf–Anweisungen (über tie gebundene Dateihandles) 398

unäre Operatoren 23, 89, 89

Arithmetik 26

benannte 88, 92, 98

Auflistung 98

Boolesch 29

Funktionen, verhalten sich wie 91

identifizieren durch Ansicht 606

ideographische 95

Listenoperatoren, unterscheiden von 71, 99

Prototyping von Funktionen als 238

_berladung 362

UND (&) bitorientierter Operator 104

UND (&&) logischer Operator 27, 105, 112, 625

Vorrang bei and und && 27, 327

undef (Wert) 31, 73, 77, 719

select und 450, 805

 siehe auch 1  defined

 siehe auch 1  undef–Funktion

undef–Funktion 842

Anwendungsbeispiel 722, 732

Arrays, Speicher freigeben von 79

Dateien komplett einlesen mit $/ 298, 687

Effizienz 617-618

Hashes und 756

 siehe auch 1  undef (Wert)

undefinierte Skalare 60

undefinierte Subroutinen, Aufruf mit AUTOLOAD 307

Underscore–Modul 386

ungeordnete Listen siehe Hashes

Ungleich–Operator (!=) 104

 siehe auch 1  Ausrufezeichen unter Symbole

Ungleichheit siehe Gleichheitsoperatoren; relationale Operatoren

Unicode 50, 417

\w–Metazeichen (Wort) und 38

Absatztrennzeichen 51

Editoren für 421

Eigenschaften 172, 174

bidirektionales Rendering 178

Block–Eigenschaften 179

Perl–Zeichenklassen–Abkürzungen und 174

Perl, zusammengesetzte 175

Silben, Klassifizierung nach Vokallauten 179

Standard 176

Zerlegung von Zeichen 177

Eigenschaften–Datenbank 424

in Identifiern 57

Information zu 175

Konvertierung in Zeichen 714

Locales und 758

Smiley 63, 714

Titelschreibweise (Titlecase) 164

Umwandlungstabellen für Groß–/Kleinschreibung 423

Unicode–Standard, Version 3.0 425

Unterstützung aktivieren 894

Verwendung in Perl, Vorbehalte 425

Wildcard–Metasymbole, Matching mit 171

Zeilentrennzeichen 51

Zusammenfassung, Zugriff 424

UNIVERSAL–Klasse 339, 898

Methoden, erweitern um 340

Unix 7

#! und 19

Aufruf von Perl und 503

CPAN–Module, installieren unter 570

Datei–Globbing unter 893

Dateideskriptoren unter 735

Dateiende unter 638

Dateipfade unter 644

Emulation unter Windows 901

File::Spec::Unix–Modul 893

fork unter 738

Funktionen in Perl 701, 704

geschweifte Klammern in 274

Installation von Perl unter xxiv

IPC und 427

Kernel–Interpretation der #!–Zeile abschneiden 504

Kommandozeile xxxii

Perls Herkunft und xvii

Pfade unter 517

Quoting 507

Shells 7

Sicherheits–Bugs 588

Signale und 431, 433

Sockets und 454, 895

test–Befehl, Testskripten und 20

_berschreiben von Funktionen zur Emulation von 318

Zeilenvorschübe 642, 707, 776

Zeit 839

Zugriffsrechte 841

unless–Anweisungen 32, 116

verglichen mit if–Anweisungen 119

unlink–Funktion 843

Anwendungsbeispiel 73, 396

Portabilität 645

Socket–Modul und 935 b16>

unpack–Funktion 643, 780, 843

Anwendungsbeispiel 718, 754, 778, 823, 830, 845

Byteordnung und 643

Effizienz 614

Portabilität 620

Stringlänge und 423

UTF–8 und 424

vec und 850

 siehe auch 1  pack

unqualifizierte Namen, Suche nach 58

unshift–Funktion 279, 809, 845

Anwendungsbeispiel 663, 700, 760

splice und 816

 siehe auch 1  push

 siehe auch 1  shift

unsichere Abhängigkeit (Fehler) 578

unsichere Operationen 518

unsigned short 821

Unternamensräume für Variablen 56

untie–Funktion 377, 411, 718, 845

Anwendungsbeispiel 438, 837

ausstehende Referenzen 379 b16>

until–Schleifen 116

up–Methode (Thread::Semaphore–Modul) 479

upcase–Funktion 228

use 15, 132-133, 141, 300, 312, 548

globales und lexikalisches Scoping von 134

tie–Funktion und 379

 siehe auch 1  Module; Pragmas

 siehe auch 1  require

use fields–Pragma, Feld–Deklarationen mit 346

Usenet

Perl–Module für 568

Perl–Newsgruppen xxx

User::grent–Modul 741, 895

User::pwent–Modul 747, 895

Class::Struct, zur Erzeugung von Objekten und Accessoren 907

UTF–8 50, 174, 418, 418

binmode und 706

CGI–Skripten und 598

Effizienz 614

I/O–Disziplinen und 776, 877

Matching von Zeichen 167

Portabilität 620, 644

Smiley und 70

Umwandlung in siehe expat

Umwandlung in/von Bytes 420

verglichen mit utf8 419

 siehe auch 1  utf8–Pragma

UTF–8–Zeichen, Umwandlung in Integerwerte 424

utf8–Pragma 171, 175, 421, 894

Anwendungsbeispiel 181

globaler Wechsel von Schnittstellen auf 697

Locales und 183

 siehe auch 1  UTF–8

utime–Funktion 847

Portabilität 642

 siehe auch 1  Zeit

utmp–Datei siehe /etc/utmp

UV (interner Integerwert ohne Vorzeichen) 548

V

–v Kommandozeilen–Switch 518

v–Strings (Vektor oder Version) 70

in $^V 692

–V Kommandozeilen–Switch 518

values–Funktion 726, 848

über tie gebundene Hashes und 392, 397

 siehe auch 1  each

 siehe auch 1  keys

variable Länge, Datensätze 245

variable Länge, Zeichen siehe UTF–8

Variablen 54, 91, 260

anonym 254

Array siehe Arrays

Attribute, Ermitteln und Setzen 897

B::Xref–Modul, Cross–Referenzen mit C 496

Bedingungsvariablen 476

Bindung an Pakete 845

Debugger, anpassen 536

deklarieren 115, 134

globale 138

lexikalische 136

Dumping mit V im Debugger 304

Format 246

Hash 80

 siehe auch 1  Hashes

Initialisierung vor Aufruf von Subroutinen 231

Interpolation siehe Interpolation, Variable

Klassenvariablen 356

lexikalische Geltungsbereiche 765

local siehe local–Deklarationen

Lokalisierung 759

Module, an Programme exportieren 314

my siehe my

Namen für 5, 624

Namen in verschachtelten Symboltabellen 57

nicht–initialisierte 8

our siehe our–Deklarationen

Paket 57, 301

ausgeben 530

Speichernutzung 538

Perl verglichen mit C, Namen von 607

private siehe local

Scoping, Verwendung des strict–Pragmas mit 16

Shell–Programmierung verglichen mit Perl 608

Skalar siehe Skalare

spezielle 678

statisch (in C/C++) 230

Steuerungsvariable, in foreach–Schleife 122

Strings, Matching über bekannte Strings 199

Tainting und 577

Tying 377, 837

Arrays 387

Dateihandles 398

Fehler bei Bindungsaufhebung 410

Hashes 392

Skalare 379

_bersetzen mit 163

Umgebung 683

verglichen mit Werten 5

vollständig qualifiziert, Zugriff von außerhalb des Pakets 595

Watch–Punkte, Plazierung von 413

Werte, Zuweisung und 26

wiederholte Substitutionen vornehmen 161

Zurücksetzen von Werten 798

 siehe auch 1  Datentypen

 siehe auch 1  Referenzen

Variableninterpolation 64

glob–Operator, verwenden 88 b16>

variadische Funktionen in Perl 227

vars–Modul 897

vec–Funktion 848

Anwendungsbeispiel 461, 804

Stringlänge und 423

Vektoren, Strings als 822, 848

Verarbeitung von Shell–Befehlen 504

Verben 16

Pakete, Behandlung 15

Verbindungen, herunterfahren 810

Vererbung 322

Basisklasse, Aufbau während der Kompilierung 897

beschränkter Zugriff und 354

durch @ISA–Array 335

Klasse 301, 334

Einfach– oder Mehrfach–Vererbung 334

Klassen–Vorfahren 358

Konstruktoren 331

Modul, aus Exporter–Klasse 315

Pseudo–Hash–Implementierung und 348

_berladung und 375

Vergleiche

Dateien 893

Laufzeit verschiedener Codeversionen 900

Strings 103, 604

Thread–Objekte 470

Vergleichsoperatoren 28, 104

sort–Funktion und 812

_berladung 369

Verkettung von Strings

mit join 755

Optimierung durch Compiler 488

Verkettungsoperator (.) 24, 98

Anwendungsbeispiel 98

Anwendungsbeispiel bei Zuweisung 26

Autogenerierung durch Stringifikation–Handler 367

Effizienz 614, 616

Stringkonstanten, _berladung 374

Vermischtes (Funktionen) 703

verschachtelt

Arrays 279

Datenstrukturen 13, 529

Destruktion 343

Listen 279

Subroutinen 272

Verschlüsselung 717

Perl–Module für 568, 897

VERSION–Methode 340

Versionen, Perl 690

ermitteln mit $^V 692

in #!–Zeile plazieren 505

Module, Prüfung von 317

spezifizieren 508

Veränderungen zwischen Perl 4 und 5 609

vertikaler Strich (|) siehe vertikaler Strich unter Symbole

Vertrag zwischen Modul und Benutzer 314

Verzeichnisse

aktuelles Arbeitsverzeichnis, Pfad ermitteln 893

anlegen 763

Arbeitsverzeichnis wechseln 710

Datei–Testoperator 29

Dateitests auf Bäume 893

DirHandle–Modul 893

entfernen 800, 843

Funktionen für 702

IO::Dir–Modul 893

Lesen von Einträgen aus 792

opendir–Funktion 778

Perl–Module für 568

portabel erzeugen und entfernen 893

rewinddir–Funktion 800

root, Redefinition 714

schließen 716

seekdir–Funktion 803

Voranstellen in @INC 514

vi–Editor

Debugger, Unterstützung für 535

reguläre Ausdrücke, Verwendung 36

Video, Perl–Module für 569

virtuelle Maschine, Perl 490, 492

virtuelle Verbindungen (als TCP–Streams) 454

VMS–Betriebssystem

Aufruf von Perl–Anwendungen auf 506

File::Spec::VMS–Modul 893

void–Kontext 27, 74, 78, 624, 851

Erkennung im Debugger 525

Vokallaute, Klassifikation von Silben nach 179

vollständig qualifizierte Namen 57

Vorab–Vergrößerung von Arrays 616

Voranstellen

Elemente an Arrays 845

Verzeichnisse in @INC 514

Vordeklaration von Subroutinen 342, 897

Vorrang 91, 699

Definition 89

Diagnosemeldungen 945

logische Operatoren 27, 112, 327

Lvalue–Subroutinen und 241

Modifier verglichen mit Komma 136

my und 136

Online–Dokumentation zu xxvi

Regex–Matching 205

unäre Operatoren, höher als binäre 99

UND verglichen mit &&, ODER verglichen mit || 106

Veränderungen in den einzelnen Perl–Versionen 609

Vorverarbeitung von Perl 637

VRML, Perl–Module für 568

W

–w Kommandozeilen–Switch 136, 142, 518, 684, 945

Warnungen aktivieren mit 20

\w (Wort–Metazeichen) 38, 168

Ideographen erkennen mit 422

–w Dateitest 29, 100

Wagenrücklauf (Carriage Return) 63

in einer POSIX–Zeichenklasse 183

 siehe auch 1  Zeilenvorschub (Newline)

Wahr–Werte 8

Evaluierung 30

Evaluierung mit if– und unless–Anweisungen 31

wait–Funktion 850

$? und 681

die und 715

fork und 738

Portabilität 642

Zombie–Prozesse und 431

 siehe auch 1  waitpid

waitpid–Funktion 850

Anwendungsbeispiel 439, 448, 786, 932

close und 715

IPC::Open2 und 447, 928

IPC::Open3 und 928

Portabilität 642

Zombie–Prozesse und 431, 850

 siehe auch 1  wait

wantarray–Funktion 72, 229, 851

Anwendungsbeispiel 229, 446, 842

_ _WARN_ _–Hook 694

Anwendungsbeispiel 852

diagnostics–Pragma und 870

warn–Funktion 851

Anwendungsbeispiel 127

CGI–Skripten und 906

Zeilennummern und 638

 siehe auch 1  Carp

$WARNING 696

warnings–Pragma 142, 523, 622, 886, 898

_ _WARN_ _ und 695

 siehe auch 1  lexikalische Warnungen

${^WARNING_BITS} 697

warnLevel–Debuggeroption 537

Warnungen 518, 851, 945

–w–Switch, aktivieren 20

${^WARNING_BITS} 697

abfangen 694

Ausführlichkeit, erzwingen bei 897

Module für 898

permanent deaktivieren 519

über undefinierte Werte 115

über verbleibende Referenzen auf über tie gebundene Objekte 412

Watch–Ausdrücke 529

Watch–Punkte, auf Perl–Variablen setzen 413

WeakRef–Modul 344

Web xviii

Kamel–Info im xxxii

Perl–Module für 568, 896

Sites für Perl xxx

 siehe auch 1  CGI

 siehe auch 1  HTML

 siehe auch 1  HTTP

 siehe auch 1  mod_perl

Werte

Array siehe Arrays

Geltungsbereiche, beschränken auf 135

Hashes, sortieren 756

Referenzen 253

skalar siehe skalare Werte

undef 842

undefinierte, Wahr–Wert von 30

verglichen mit Variablen 5

Wetter, Perl–Module für 569

while–Schleifen 28, 33, 116, 120

Angle–Operator und $_ 83

Boolescher Kontext 73

eof–Funktion in 726

Listenzuweisung in 78

Whitespace 38, 51, 622, 699

/x–Modifier beim Pattern–Matching 154

führende, entfernen in Here–Dokumenten 70

Kanonisierung in einer Variable 161

Quoting–Zeichen, Verwendung in 66

als Variablenname oder Trennzeichen für Quotierungskonstrukt, -nderungen in 610

Zeichen in Formaten 244

Wide–Character–APIs

verwendende Systemaufrufe 419

Verwendung unter Perl auf Zielsystem aktivieren 510

${^WIDE_SYSTEM_CALLS} 697

wiederholt vorkommende Zeichen eliminieren 162

Wiederholungsoperator (x) 24, 97

wiederverwendete Adressen, Inhalt ausgeben 538

Wiederverwendung von Code 626

Wildcard–Metasymbole 171

Zeichenklassen und 173

Win32::ChangeNotify–Modul 901

Win32::Console–Modul 901

Win32::Event–Modul 901

Win32::EventLog–Modul 901

Win32::File–Modul 901

Win32::FileSecurity–Modul 901

Win32::Internet–Modul 901

Win32::IPC–Modul 901

Win32::Mutex–Modul 901

Win32::NetAdmin–Modul 901

Win32::NetResource–Modul 901

Win32::ODBC–Modul 901

Win32::OLE–Modul 901

Win32::OLE::Const–Modul 901

Win32::OLE::Enum–Modul 902

Win32::OLE::NLS–Modul 902

Win32::OLE::Variant–Modul 902

Win32::PerfLib–Modul 902

Win32::Pipe–Modul 449

Win32::Process–Modul 902

Win32::Semaphore–Modul 902

Win32::Service–Modul 902

Win32::Sound–Modul 902

Win32::TieRegistry–Modul 413, 902

Win32API::File–Modul 902

Win32API::Net–Modul 902

Win32API::Registry–Modul 902

Windows siehe Microsoft Windows

wissenschaftliche Notation 62

World Wide Web siehe Web

Wörter

festhalten 157

Listen von, programmierbare Befehlsvervollständigung bei 896

Wortlisten 77

Wortzeichen (\w) 38

Wrapper, C, um set–id–Skripten 588

write–Funktion 243, 245, 853

Anwendungsbeispiel 738

$= und 685

$^A und 680, 739

$^L und 685

$– und 685

$| und 691

formline und 739

Fußzeilen und 249

–i–Switch und 512

Picture–Zeilen und 738

select und 803

Stringlänge und 423

 siehe auch 1  Format

X

–x Dateitest 100

–X Dateitest 100

–x Kommandozeilen–Switch 504, 519

–X Kommandozeilen–Switch 519

\X Wildcard–Metasymbol 171, 423

/x–Modifier 153-154, 157, 159

x–Operator 24, 97

x=–Operator 109

XML, Perl–Module für 568

xor–Operator 28, 104, 112

XS

Code, Portabilität 647

Debugging–Tools für 897

externe Subroutinen, Wrapping 549

Funktionen, Abbildung zwischen C und Perl 550 b16>

XSLoader–Modul 900

xsubpp–Compiler 550

XSUBs

Ein– und Ausgabe 554

Wrapping von Subroutinen für Perl 549

 siehe auch 1  XS

Y

y///–Operator 150, 162, 854

yield–Funktion (Thread–Modul) 471

Z

^Z (Control–Z) als EOF 638

\Z–Metazeichen 187

–z Dateitest 100

Zahlen

abschneiden mit int 753

Arrays, speichern in 9

Ausrichtung am Dezimalpunkt 244

bitorientierte Operatoren 104

Breite von 643

\d (digit), Muster–Metazeichen 38

eingeben in Perl 61

Funktionen für 702

hexadezimal 159, 752

hexadezimal siehe hexadezimal b16>

Kommata einfügen in 247

Konvertierung nicht–numerischer Variablen in 365

oktal 769

oktal siehe Oktalzahlen

Seitennummern 685

Strings, Umwandlung in 61

Unterstriche in 62

Vergleichsoperatoren für 28

Wahr–Werte von 30

Ziffern in Namen 57

Zufallszahlen 791, 822

Zähler, magische Zählervariablen 385

Zeichen 49

$[–Variable 679

Aliase für 170

ASCII–Wert bestimmen siehe ord

aus ASCII–Wert 714

aus Unicode –Wert siehe chr

Eigenschaften, Definition eigener 181

 siehe auch 1  Unicode

Ersetzung in Strings 162

in Formaten 780

Groß–/Kleinschreibung siehe Groß–/Kleinschreibung

hexadezimal siehe hexadezimal

Konvertierung von 8–Bit–Zeichen in UTF–8–Zeichen variabler Länge 419

Länge 758

löschen 711

Metazeichen 146

in Mustern 146

oktal siehe Oktalzahlen

Prototyp 235

spezielle 209

spezielle Zeichen vor Variablennamen 377

verglichen mit Bytes 417, 701

Wildcards für 171

zeichenorientierte Eingabe 740

Zerlegung 177

Zeichenklassen 38, 172, 209

invertieren oder negieren 173

klassische Perl–Zeichenklassen 182

Metasymbole in 169, 173

mit Arrayindizes verwechseln 68

Perl–Abkürzungen 174

POSIX–Stil 182

selbstdefinierte 172

Unicode–Eigenschaften 174

Vergleich mit Zeicheneigenschaften von Unicode 422

vordefiniert, Verfügbarkeit von 422

Wildcard–Metasymbole und 171

Zeichenklassen nach POSIX 182

Zeichenkombination erkennen mit \X 172, 423 b16>

Zeichensätze

ASCII siehe ASCII

Portabilität 648

Reihenfolge und Bereiche von Zeichen 162

Unicode 417

Zeichensemantik

Auswirkungen 421

im Vergleich zu Bytesemantik 420

Zeiger 52

in C 251

Referenzen, Unmöglichkeit der Konvertierung in 61

auf Strings 782

Zeile einlesen (Operator) 22

Zeilen, Grenz–Zusicherungen 187

Zeilen–Trennsymbole, in Internet–Programmen 460

Zeilen–Trennzeichen 51

Zeileneingabeoperator 83, 512, 606

ARGV und 681

bei über tie gebundenen Dateihandles 401

Verwendung eines Globs anstelle von 87

Zeileneingabeoperatoren siehe Angle–Operator

Zeilenende–Verarbeitung, automatische 514

Zeilennummern 71

der Eingabedatei 637, 687

zeilenorientiertes Quoting siehe Here–Dokumente

Zeilenpufferung siehe Pufferung, Zeilen b16>

Zeilenvorschub (Newline) 3, 51, 642

chomp–Funktion, entfernen mit 711

in Dateinamen, Sicherheitsrisiken durch 584

entfernen 22

enthaltende Strings, Matching von 153

Leerzeilen, Wahr–Werte und 33

Portabilität 642

Punkt–Metazeichen (.), Matching 171

in Stringliteralen 64

Zeilenzähler siehe $.–Variable

Zeit 839

Alter von Dateien 103

Dateizugriff/–modifikation 823, 847

Greenwich Mean Time (GMT) 750

für lokale Zeitzone 761

Perl–Module für 567

sleep–Operation 811

Time::Local–Modul 892

UDP–Programm zur Zeitermittlung über andere Maschinen 460

Zeitbasis ($^T) 681

Zeitfunktionen, Perl–Funktionen für 703

Zentrierung 247 b16>

Zerlegung von Zeichen in einfachere Zeichen 177

Ziffern 38

in Namen 57

Zipping, Perl–Module für 568

Zirkumflex siehe ^ (Hütchen) unter Symbole

Zombie–Prozesse, einsammeln 431

Forking von Servern und 459

Zufallszahlen 791, 822

erzeugen als Handles oder Skalare 409

Zugriff

auf Array von Hashes 290

auf Datensätze komplexer Datenstrukturen 295

auf Elemente in über tie gebundenen Arrays 389

auf mehrdimensionale Arrays 282

auf mehrdimensionale Hashes 292

auf Slices mehrdimensionaler Arrays 283

auf überschriebene Methoden 337

bei Hashes von Arrays 288 b16>

Zugriffsprüfungen, im Konstruktor 354

Zugriffsrechte 832, 841

Benutzer, beschränken 576

Datei–Zugriffsrechte–Operatoren, interpretieren 101

Zugriffszeit, Datei 823, 847

zusammengesetzte Unicode–Eigenschaften 175

Zusicherungen (in Mustern) 147, 165

Definition eigener 223

Lookaround–Zusicherungen 211

Positionszusicherungen 186

\A– und ^–Zusicherungen (String–Grenze) 187

\b und \B (Wortgrenzen) 188

\G–Zusicherung 157

\z–, \Z– und $–Zusicherungen 187

Vorrang, Pattern–Matching 208

Zeichenklassen und 173

Zustand, Klassenobjekte und 356

Zuweisung

Elemente, zweidimensionale Arrays 281

an ?:–(Konditional–)Operator 109

an Listen 77

über tie gebundener Variablen 384

über tie gebundenes Arrayelement 389

Zuweisungsoperatoren 25, 53, 109

_berladung 367

 siehe auch 1  Copy–Konstruktor

Vorrang, -nderungen in Perl–Versionen 610

Werte, Rückgabe von 26

zuwenig Arbeitsspeicher 690

zweidimensionale Arrays, Erzeugung und Zugriff 280