-0[octal/hexadecimal]

find . -name '*.orig' -print0 | perl -n0e unlink

The special value 00 will cause Perl to “slurp” files in paragraph mode. Any value 0400 or above will cause Perl to slurp files whole, but by convention the value 0777 is the one normally used for this purpose.

You can also specify the separator character using hexadecimal notation: -0xHHH…, where the H are valid hexadecimal digits. Unlike the octal form, this one may be used to specify any Unicode character, even those beyond 0xFF. So if you really want a record separator of 0777, specify it as -0x1FF. (This means that you cannot use the -x option with a directory name that consists of hexadecimal digits, or else Perl will think you have specified a hex number to -0.)

-a

perl -ane 'print pop(@F), "\n";'

is equivalent to

while (<>) {
    @F = split(' ');
    print pop(@F), "\n";
}

An alternate delimiter may be specified using -F.

-C [number/list]

A partir da versão 5.8.1, o -C pode ser seguido por um número ou uma lista de letras de opção. As letras, seus valores numéricos e efeitos são os seguintes; listar as letras é igual a somar os números.

Por exemplo, -COE e -C6 ativam o UTF-8-ness no STDOUT e no STDERR. Repetir letras é apenas redundante, não cumulativo nem alternativo.

As opções io significam que qualquer abertura subsequente () (ou operações de E / S similares ) no escopo do arquivo atual terá a camada : utf8 PerlIO implicitamente aplicada a elas, ou seja, UTF-8 é esperado de qualquer fluxo de entrada e UTF-8 é produzido para qualquer fluxo de saída. Este é apenas o padrão, com camadas explícitas em open () e com binmode () é possível manipular fluxos como de costume.

-Cpor si só (não seguido por nenhum número ou lista de opções) ou a sequência vazia “” para a variável de ambiente PERL_UNICODE , tem o mesmo efeito que -CSDL . Em outras palavras, os identificadores de E / S padrão e a camada open () padrão são processados ​​por UTF-8, mas apenas se as variáveis ​​de ambiente do código de idioma indicarem um código de idioma UTF-8. Esse comportamento segue o comportamento UTF-8 implícito (e problemático) do Perl 5.8.0. (Consulte UTF-8 não é mais o padrão nos códigos de idioma UTF-8 em perl581delta.)

Você pode usar -C0 (ou ” 0 ” para PERL_UNICODE ) para desativar explicitamente todos os recursos Unicode acima.

A variável mágica somente leitura $ {^ UNICODE}reflete o valor numérico dessa configuração. Essa variável é definida durante a inicialização do Perl e, posteriormente, é somente leitura. Se você deseja efeitos de tempo de execução, use o três-arg open () , o dois-arg binmode () e o pragma aberto .

(No Perls anterior à 5.8.1, a opção -C era uma opção apenas para Win32 que permitia o uso de APIs Win32 de “chamada de sistema ampla” com reconhecimento de Unicode. No entanto, esse recurso praticamente não foi utilizado e, portanto, a opção de linha de comando ” reciclado “.)

Nota: Desde o perl 5.10.1, se a opção -C for usada no #!linha, ele também deve ser especificado na linha de comando, pois os fluxos padrão já estão configurados neste momento na execução do interpretador perl. Você também pode usar binmode () para definir a codificação de um fluxo de E / S.

-c

-d , -dt

-d: MOD [ = bar , baz ]
 -dt: MOD [ = bar , baz ]

-Dletters
-Dnumber

As an alternative, specify a number instead of list of letters (e.g., -D14 is equivalent to -Dtls):

All these flags require -DDEBUGGING when you compile the Perl executable (but see :opd in Devel::Peek or ‘debug‘ mode in re which may change this). See the INSTALL file in the Perl source distribution for how to do this. This flag is automatically set if you include -g option when Configure asks you about optimizer/debugger flags.

If you’re just trying to get a print out of each line of Perl code as it executes, the way that sh -x provides for shell scripts, you can’t use Perl’s -D switch. Instead do this:

# If you have "env" utility
env PERLDB_OPTS="NonStop=1 AutoTrace=1 frame=2" perl -dS program
# Sintaxe do shell Bourne
PERLDB_OPTS = "NonStop = 1 AutoTrace = 1 quadro = 2" programa perl -dS
# csh sintaxe
(setenv PERLDB_OPTS "NonStop = 1 AutoTrace = 1 quadro = 2"; programa perl -dS)

-e  linha de comando

-E  linha de comando

-f

O Perl pode ser criado para que, por padrão, tente executar o $ Config {sitelib} /sitecustomize.pl na inicialização (em um bloco BEGIN ). Esse é um gancho que permite ao administrador do sistema personalizar como o Perl se comporta. Por exemplo, ele pode ser usado para adicionar entradas ao array @INC para fazer com que o Perl encontre módulos em locais fora do padrão.

Perl realmente insere o seguinte código:

INÍCIO {
    faça {local $ !; -f "$ Config {sitelib} /sitecustomize.pl"; }
    && do "$ Config {sitelib} /sitecustomize.pl";
}

Uma vez que é um verdadeiro fazer (e não uma exigem ), sitecustomize.pl não precisa retornar um verdadeiro valor. O código é executado no pacote principal , em seu próprio escopo lexical. No entanto, se o script morrer, $ @ não será definido.

O valor de $ Config {sitelib} também é determinado no código C e não é lido no Config.pm , que não é carregado.

O código é executado muito cedo. Por exemplo, quaisquer alterações feitas no @INC aparecerão na saída de ” perl -V “. Obviamente, os blocos END também serão executados muito tarde.

Para determinar em tempo de execução se esse recurso foi compilado em seu perl , você pode verificar o valor de $ Config {usesitecustomize} .

-F padrão

-h

-i [ extensão ]

Se nenhuma extensão for fornecida e o sistema o suportar, o arquivo original será mantido aberto sem um nome enquanto a saída é redirecionado para um novo arquivo com o nome do arquivo original. Quando o perl sai, limpa ou não, o arquivo original é desvinculado.

Se a extensão não contiver um * , ela será anexada ao final do nome do arquivo atual como sufixo. Se a extensão contiver um ou mais * caracteres, cada * será substituído pelo nome do arquivo atual. Em termos de Perl, você pode pensar nisso como:

($ backup = $ extensão) = ~ s / \ * / $ nome_do_arquivo / g;

Isso permite adicionar um prefixo ao arquivo de backup, em vez de (ou além de) um sufixo:

Perl -pi'orig_ * '-e' / bar / baz / 'fileA 
# backup em 'orig_fileA'

Ou até para colocar cópias de backup dos arquivos originais em outro diretório (desde que o diretório já exista):

Perl -pi'old / *. orig '-e' s / bar / baz / 'fileA  
# backup para 'old / fileA.orig'

Esses conjuntos de one-liners são equivalentes:

# sobrescrever arquivo atual
arquivo perl -pi -e / bar / baz / ' 
# sobrescrever arquivo atual
Perl -pi '*' -e 's / bar / baz /' fileA 
# backup em 'fileA.orig'
Perl -pi'.orig '-e' / bar / baz / 'fileA 
# backup em 'fileA.orig'
Perl -pi '*. orig' -e 's / bar / baz /' fileA 

Da casca , dizendo

perl -p -i.orig -e "s / foo / bar /; ..."

é o mesmo que usar o programa:

#! / usr / bin / perl -pi.orig s / foo / bar /;

que é equivalente a

#! / usr / bin / perl
$ extension = '.orig';
LINHA: while (<>) 
{
  if ($ ARGV ne $ oldargv) 
  {
    if ($ extensão! ~ / \ * /) 
    {
      $ backup = $ ARGV. extensão $;
    }
    outro 
    {
      ($ backup = $ extensão) = ~ s / \ * / $ ARGV / g;
    }
    renomear ($ ARGV, $ backup);
    aberto (ARGVOUT, "> $ ARGV");
    selecione (ARGVOUT);
    $ oldargv = $ ARGV;
  }
  s / foo / bar /;
}
continuar 
{
  impressão; # isso imprime no nome do arquivo original
}
selecione (STDOUT);

exceto que o formulário -i não precisa comparar $ ARGV com $ oldargv para saber quando o nome do arquivo foi alterado. No entanto, ele usa ARGVOUT para o identificador de arquivo selecionado. Observe que STDOUT é restaurado como o identificador de arquivo de saída padrão após o loop.

Como mostrado acima, o Perl cria o arquivo de backup, independentemente de qualquer saída ser realmente alterada. Portanto, esta é apenas uma maneira elegante de copiar arquivos:

Perl -p -i '/ some / file / path / *' -e 1 arquivo1 arquivo2 arquivo3 ...

ou

Perl -p -i'.orig '-e 1 arquivo1 arquivo2 arquivo3 ...

Você pode usar eof sem parênteses para localizar o final de cada arquivo de entrada, caso deseje anexar a cada arquivo ou redefinir a numeração das linhas.

Se, para um determinado arquivo, o Perl não conseguir criar o arquivo de backup conforme especificado na extensão, ele ignorará esse arquivo e continuará com o próximo (se existir).

Você não pode usar -i para criar diretórios ou remover extensões de arquivos.

O Perl não expande ~ nos nomes de arquivos, o que é bom, já que algumas pessoas o usam para seus arquivos de backup:

Perl -pi ~ -e 's / foo / bar /' arquivo1 arquivo2 arquivo3 ...

Observe que, como -i renomeia ou exclui o arquivo original antes de criar um novo arquivo com o mesmo nome, os links físicos e físicos no estilo Unix não serão preservados. Finalmente, a opção -i não impede a execução quando nenhum arquivo é fornecido na linha de comando. Nesse caso, nenhum backup é feito (o arquivo original não pode, é claro, ser determinado) e o processamento prossegue de STDIN para STDOUT conforme o esperado.

-I diretório

-l [ octnum ]

perl -lpe 'substr($_, 80) = ""'

Note that the assignment $\ = $/ is done when the switch is processed, so the input record separator can be different than the output record separator if the -l switch is followed by a -0 switch:

gnufind / -print0 | perl -ln0e 'print "found $_" if -p'

This sets $\ to newline and then sets $/ to the null character.

-m[-]module
-M[-]module
-M[-]'module ...' 
-[mM][-]module=arg[,arg]...

-Mmodule executes use module ; before executing your program. You can use quotes to add extra code after the module name, e.g., ‘-MMODULE qw(foo bar)’.

If the first character after the -M or -m is a dash (–) then the ‘use‘ is replaced with ‘no‘.

You can also say -mMODULE=foo,bar or -MMODULE=foo,bar as a shortcut for ‘-MMODULE qw(foo bar)’. This avoids the need to use quotes when importing symbols. The actual code generated by -MMODULE=foo,bar is use module split(/,/,q{foo,bar}). Note that the = form removes the distinction between -m and -M.

A consequence of this is that -MMODULE=number never does a version check, unless MODULE::import() itself is set up to do a version check, which could happen for example if MODULE inherits from Exporter.

-n

LINE:
    while (<>) {
    ...           # your program goes here
}

Note that the lines are not printed by default. See -p to have lines printed. If a file named by an argument cannot be opened for some reason, Perl warns you about it and moves on to the next file.

Also, note that <> passes command line arguments to open, which doesn’t necessarily interpret them as file names.

Here is an efficient way to delete all files that haven’t been modified for at least a week:

find . -mtime +7 -print | perl -nle unlink

This is faster than using the -exec switch of find because you don’t have to start a process on every filename found. It does suffer from the bug of mishandling newlines in pathnames, which you can fix if you follow the example under -0.

BEGIN and END blocks may be used to capture control before or after the implicit program loop, just as in awk.

-p

LINE:
    while (<>) {
	...         # your program goes here
    } continue {
	print or die "-p destination: $!\n";
}

If a file named by an argument cannot be opened for some reason, Perl warns you about it, and moves on to the next file. Note that the lines are printed automatically. An error occurring during printing is treated as fatal. To suppress printing use the -n switch. A -p overrides a -n switch.

BEGIN and END blocks may be used to capture control before or after the implicit loop, just as in awk.

-s

#!/usr/bin/perl -s
if ($xyz) { print "$xyz\n" }

Do note that a switch like –help creates the variable ${-help}, which is not compliant with use strict “refs”. Also, when using this option on a script with warnings enabled you may get a lot of spurious “used only once” warnings.

-S

On some platforms, this also makes Perl append suffixes to the filename while searching for it. For example, on Win32 platforms, the “.bat” and “.cmd” suffixes are appended if a lookup for the original name fails, and if the name does not already end in one of those suffixes. If your Perl was compiled with DEBUGGING turned on, using the -Dp switch to Perl shows how the search progresses.

Typically this is used to emulate #! startup on platforms that don’t support #!. It’s also convenient when debugging a script that uses #!, and is thus normally found by the shell’s $PATH search mechanism.

This example works on many platforms that have a shell compatible with Bourne shell:

#!/usr/bin/perl
eval 'exec /usr/bin/perl -wS $0 ${1+"$@"}'
if $running_under_some_shell;

The system ignores the first line and feeds the program to /bin/sh, which proceeds to try to execute the Perl program as a shell script. The shell executes the second line as a normal shell command, and thus starts up the Perl interpreter. On some systems $0 doesn’t always contain the full pathname, so the -S tells Perl to search for the program if necessary. After Perl locates the program, it parses the lines and ignores them because the variable $running_under_some_shell is never true. If the program will be interpreted by csh, you will need to replace ${1+”$@”} with $*, even though that doesn’t understand embedded spaces (and such) in the argument list. To start up sh rather than csh, some systems may have to replace the #! line with a line containing just a colon, which will be politely ignored by Perl. Other systems can’t control that, and need a totally devious construct that will work under any of csh, sh, or perl, such as the following:

eval '(exit $?0)' && eval 'exec perl -wS $0 ${1+"$@"}'
& eval 'exec /usr/bin/perl -wS $0 $argv:q'
if $running_under_some_shell;

If the filename supplied contains directory separators (and so is an absolute or relative pathname), and if that file is not found, platforms that append file extensions will do so and try to look for the file with those extensions added, one by one.

On DOS-like platforms, if the program does not contain directory separators, it will first be searched for in the current directory before being searched for on the PATH. On Unix platforms, the program will be searched for strictly on the PATH.

-t

Note: This is not a substitute for -T! This is meant to be used only as a temporary development aid while securing legacy code: for real production code and for new secure code written from scratch, always use the real -T.

-T

-u

-U

-v

-V

-V:configvar

perl -V:libc

libc='/lib/libc-2.2.4.so';

perl -V:lib.

libs='-lnsl -lgdbm -ldb -ldl -lm -lcrypt -lutil -lc';
libc='/lib/libc-2.2.4.so';

perl -V:lib.*

libpth='/usr/local/lib /lib /usr/lib';
libs='-lnsl -lgdbm -ldb -ldl -lm -lcrypt -lutil -lc';
lib_ext='.a';
libc='/lib/libc-2.2.4.so';
libperl='libperl.a';
....

Additionally, extra colons can be used to control formatting. A trailing colon suppresses the linefeed and terminator “;“, allowing you to embed queries into shell commands. (mnemonic: PATH separator “:“.)

echo "compression-vars: " `perl -V:z.*: ` " are here !" 

compression-vars: zcat='' zip='zip' are here !

A leading colon removes the “name=” part of the response, this allows you to map to the name you need. (mnemonic: empty label)

echo "goodvfork="`./perl -Ilib -V::usevfork`

goodvfork=false;

Leading and trailing colons can be used together if you need positional parameter values without the names. Note that in the case below, the PERL_API parameters are returned in alphabetical order.

echo building_on `perl -V::osname: -V::PERL_API_.*:` now 

building_on 'linux' '5' '1' '9' now

-w

Essa opção realmente apenas habilita a variável global $ ^ W ; normalmente, o pragma de advertência de uso de escopo lexicamente é o preferido. Você pode desativar ou promover erros fatais avisos específicos usando ganchos __WARN__ , conforme descrito em perlvar e warn . Veja também perldiag eperltrap . Um recurso de aviso refinado também está disponível se você deseja manipular classes inteiras de avisos.

-W

-X

Diretório -x -x

Todas as referências aos números de linha pelo programa (avisos, erros, …) tratam o #! linha como a primeira linha. Portanto, um aviso na segunda linha do programa, que está na 100ª linha do arquivo, será relatado como linha 2, não como linha 100. Isso pode ser substituído usando a diretiva #line .

Se um nome de diretório for especificado, o Perl mudará para esse diretório antes de executar o programa. O -xswitch controla apenas o descarte do lixo principal. O programa deve ser finalizado com __END__ se houver lixo à direita a ser ignorado; o programa pode processar todo ou qualquer lixo posterior por meio do identificador de arquivo DATA, se desejado.

O diretório, se especificado, deve aparecer imediatamente após o -x, sem espaço em branco.

CASA

LOGDIR

CAMINHO

PERL5LIB

Se PERL5LIB não estiver definido, PERLLIB será usado. Diretórios são separados (como em PATH) por dois pontos em plataformas semelhantes ao Unix e por ponto e vírgula no Windows (o separador de caminho apropriado é fornecido pelo comando perl -V: path_sep ).

Ao executar verificações de contaminação, porque o programa estava executando setuid ou setgid ou a opção -T ou -t foi especificada, nem PERL5LIB nem PERLLIB são consultados. O programa deveria dizer:

use lib "/ my / directory";

PERL5OPT

PERLIO

É convencional iniciar nomes de camadas com dois pontos (por exemplo : perlio ) para enfatizar sua semelhança com os “atributos” variáveis. Mas o código que analisa as strings de especificação de camada, que também é usado para decodificar a variável de ambiente PERLIO , trata os dois pontos como um separador.

Um PERLIO não definido ou vazio é equivalente ao conjunto de camadas padrão para sua plataforma; por exemplo ,: unix: perlio em sistemas semelhantes ao Unix e : unix: crlf no Windows e outros sistemas semelhantes ao DOS .

A lista se torna o padrão para todas as E / S do Perl. Consequentemente, apenas as camadas internas podem aparecer nesta lista, pois as camadas externas (como : encoding () ) precisam de E / S para carregá-las. Consulte pragma aberto para saber como adicionar codificações externas como padrões.

As camadas que fazem sentido incluir na variável de ambiente PERLIO são resumidas resumidamente abaixo. Para mais detalhes, consulte PerlIO .

O conjunto padrão de camadas deve fornecer resultados aceitáveis ​​em todas as plataformas.

Para plataformas Unix, isso será equivalente a ” unix perlio ” ou ” stdio “. O Configure está configurado para preferir a implementação ” stdio ” se a biblioteca do sistema fornecer acesso rápido ao buffer; caso contrário, ele usa a implementação ” unix perlio “.

No Win32, o padrão nesta versão (5.14) é ” unix crlf “. O ” stdio ” do Win32 possui vários bugs / recursos incorretos para o Perl IO, dependendo da versão e do fornecedor do compilador C. Usar nossa própria camada crlf como buffer evita esses problemas e torna as coisas mais uniformes. A camada crlf fornece conversão CRLF, bem como buffer.

A versão atual (5.14 até a presente redação) usa o unix como a camada inferior no Win32 e, portanto, ainda usa as rotinas de descrição de arquivos numéricos do compilador C. Há uma camada win32 nativa experimental, que deve ser aprimorada e deve se tornar o padrão no Win32.

A variável de ambiente PERLIO é completamente ignorada quando o Perl é executado no modo de contaminação.

PERLIO_DEBUG

env PERLIO_DEBUG = / dev / tty script perl ...

e no Win32, o equivalente aproximadamente:

set PERLIO_DEBUG=CON
perl script ...

This functionality is disabled for setuid scripts and for scripts run with -T.

PERLLIB

The PERLLIB environment variable is completely ignored when Perl is run in taint mode.

PERL5DB

BEGIN { require "perl5db.pl" }

The PERL5DB environment variable is only used when Perl is started with a bare -d switch.

PERL5DB_THREADED

PERL5SHELL

Note that Perl doesn’t use COMSPEC for this purpose because COMSPEC has a high degree of variability among users, leading to portability concerns. Besides, Perl can use a shell that may not be fit for interactive use, and setting COMSPEC to such a shell may interfere with the proper functioning of other programs (which usually look in COMSPEC to find a shell fit for interactive use).

Before Perl 5.10.0 and 5.8.8, PERL5SHELL was not taint checked when running external commands. It is recommended that you explicitly set (or delete) $ENV{PERL5SHELL} when running in taint mode under Windows.

PERL_ALLOW_NON_IFS_LSP

Setting this environment variable to 1 means that Perl will use the first suitable LSP enumerated in the catalog, which keeps McAfee Guardian happy, and in that particular case Perl still works too because McAfee Guardian’s LSP actually plays other games which allow applications requiring IFS compatibility to work.

PERL_DEBUG_MSTATS

If set, this dumps out memory statistics after execution. If set to an integer greater than one, also dumps out memory statistics after compilation.

PERL_DESTRUCT_LEVEL

PERL_DL_NONLAZY

PERL_ENCODING

PERL_HASH_SEED

If the option is provided, and PERL_PERTURB_KEYS is NOT set, then a value of ‘0‘ implies PERL_PERTURB_KEYS=0 and any other value implies PERL_PERTURB_KEYS=2.

PLEASE NOTE: The hash seed is sensitive information. Hashes are randomized to protect against local and remote attacks against Perl code. By manually setting a seed, this protection may be partially or completely lost.

PERL_PERTURB_KEYS

When set to “1” or “RANDOM” then traversing keys will be randomized. Every time a hash is inserted into the key order will change in a random fashion. The order may not be repeatable in a following program run even if the PERL_HASH_SEED has been specified. This is the default mode for perl.

When set to “2” or “DETERMINISTIC” then inserting keys into a hash will cause the key order to change, but in a way that is repeatable from program run to program run.

NOTE: Use of this option is considered insecure, and is intended only for debugging non-deterministic behavior in Perl’s hash function. Do not use it in production.

PERL_HASH_SEED_DEBUG

Note that any information about the hash function, especially the hash seed is sensitive information: by knowing it, one can craft a denial-of-service attack against Perl code, even remotely. Do not disclose the hash seed to people who don’t need to know it. See also hash_seed() and key_traversal_mask() in Hash::Util.

An example output might be:

HASH_FUNCTION = ONE_AT_A_TIME_HARD HASH_SEED = 
0x652e9b9349a7a032 PERTURB_KEYS = 1 (RANDOM)

PERL_MEM_LOG

$ 3>foo3 PERL_MEM_LOG=3m perl ...

PERL_ROOT

PERL_SIGNALS

PERL_UNICODE

SYS$LOGIN