Effective Perl Programming: Writing Better Programs with Perl

s///   [See substitute operator]

Salzenberg, Chip  

scalar context:

       grep selection expression  

       range operator in;  

scalar m//g match   2nd   3rd  

Schwartzian Transform   2nd  

Schwartzian Transform:

       as example of slicing and nesting[Schwartzian Transform:example of slicing and nesting]  

scope:

       lexical  

       of a my variable  

       package  

       run-time  

searching for methods  

select operator  

self variable;  

SelfLoader module  

sequence:

       in regular expression[sequence:regular expression];   2nd   3rd  

setsockopt function:

       establishing multiple connections using;  

setuid:

       Perl program running as  

shareable library:

       XS module;  

shift operator:

       @_ as a default  

       @ARGV as a default  

       reading subroutine arguments with  

shorthands and syntax quirks   2nd  

shuffling a list  

SIGCHLD signal:

       handling to prevent zombie processes;   2nd  

signal handler hash:

       'IGNORE'  

       assignment to  

       assignment to;  

signal handler:

       in eval block[signal handler:eval block]  

       preventing zombie processes with   2nd  

       reinstalling  

       with POSIX signals[signal handler:POSIX signals]  

single-element slice:

       on left-hand side of assignment[single-element slice:left-hand side]  

single-element slice;  

single-quoted string  

single-quoted string:

       q;  

slice   2nd  

slice:   [See also hash slice;]

       in computing ranks[slice:computing ranks]  

       instead of element;  

       is a list of elements[slice:list of elements]  

       localizing with local;  

       maintaining a queue with  

       selecting elements from a result with;  

       single-element.   [See single-element slice]

       sorting with  

       swapping elements with;  

slicing:

       multidimensional array or hash;  

       with map [slicing:map]  

Socket module:

       always use  

       constant functions in  

       sorting Internet addresses with   2nd  

SOCKET_STREAM:

       in Socket module  

soft reference:

       accessing symbol table with;  

       disabling with strict refs  

       local variable and  

soft reference;  

software ICs   2nd  

sort block  

sort operator:

       basic use of  

       uses string comparisons by default[sort operator:string comparisons]  

sort subroutine  

sort subroutine:

       called many times for each key  

       modifying $a and $b in  

sorting   2nd  

sorting:

       ASCIIbetically  

       by file modification time[sorting:file modification time]   2nd  

       ignoring case;  

       in reverse order[sorting:reverse order];  

       keys of a hash by corresponding values;  

       on multiple keys[sorting:multiple keys]  

       Orcish Maneuver  

       Schwartzian Transform  

       to obtain ranks[sorting:obtain ranks];   2nd  

       using array indices[sorting:array indices];  

       with pack[sorting:pack];  

       with split;  

spaceship operator  

spaceship operator:

       sorting with   2nd  

special variables :

       localizing with local;  

       main package and  

speed:

       local * on arguments  

       match variables  

       memory-free parentheses  

       my faster than local;  

       of assignment and subscripting[speed:assignment and subscripting ]  

       passing references into subroutines  

       profiling with Devel::DProf  

       run-time warnings and  

       split vs. pattern match  

       strict module and  

       subroutine arguments  

       writing XSUBs for  

splice operator:

       shortening array with  

       shuffling a list with  

split operator:

       C comments  

        delimiter retention mode;  

       in literal slice[split operator:literal slice]  

       lists of lists with;  

       memory-free parentheses and;  

       scalar context of arguments  

       sorting with  

       vs. pattern match[split operator:pattern match]  

       vs. unpack[split operator:unpack];  

sprintf operator

       formatting numbers with  

sprintf()  

stack snapshots:

       from -Dtls command line option  

stack:

       in XSUB[stack:XSUB]  

stat operator:

       result cached in _  

       vs. file test operators  

statement modifier:

       eliminating parentheses and braces with  

static variable:

       creating with BEGIN and my  

       shared  

STDIN filehandle:

       as a default  

STORE method.   [See under tied hash]

stream:

       reading from;   2nd  

strict module:

       in examples[strict module:examples]  

       recommended for debugging  

       when to use  

strict refs:

       disables soft references   2nd  

strict subs:

       bareword quoting and  

       turns off poetry mode  

strict vars:

       $a and $b   2nd  

       catching misspellings with  

string comparison operators:

       instead of regular expressions  

       look like words  

string context  

Stross, Charlie  

sub { }   [See anonymous subroutine constructor]

subroutine  

subroutine:

       argument checking;   2nd  

       array arguments are flattened  

       calling nonexistent  

       containing BEGIN block  

       context of return value  

       copying and naming arguments  

       DESTROY.   [See See object-oriented programming: destructor]

       effect of my and local  

       effect of my and local;  

       exporting from XSUB  

       followed by package name ;  

       functionality computed at run time  

       inheriting @_;  

       named parameters  

       parentheses around arguments of  

       passing anonymous hash constructor  

       passing array or hash by reference  

       passing filehandles and dirhandles  

       passing typeglob   2nd  

       prefixed with ampersand  

       prefixed with ampersand;  

       prototype.   [See prototypes ]

       reading arguments  

       reference to.   [See code ref]

       variable interpolation and  

subs module:

       declaring subroutines with  

subscript:

       in dereferencing syntax[subscript:dereferencing syntax]  

substitute operator:

       /e option  

       /o option  

       /x option  

       containing <>;  

       inside map;  

       match variables in   2nd  

       memory variables in  

substitute operator[regular expression: ]  

substr operator:

       as lvalue;  

       instead of regular expression   2nd  

       reference to result of  

       tokenizing strings with  

SUPER:: package:

       data inheritance and;  

       inheritance list for current package;  

SV:

       C data type in XSUB  

       internal data type   2nd  

sv_mortalcopy();  

swapping:

       elements with a slice   2nd  

       values with list assignments  

Swiss Army Chainsaw  

symbol table  

symbol table:

       accessing through soft reference  

       accessing through typeglob  

       entry for each unique identifier  

       manipulating  

       my variables and  

       packages implemented with  

symbolic reference.   [See soft reference]

sysread operator:

       quickly reading a file with  

system error variable:

       numeric vs. string context;