LIBOF

Manuais para a linha de comandos

Man » Manual awk online - documentação online detalhada para a página de manual awk

🌍 ☰ 
gawk - linguagem de processamento e verificação de padrões

SINTAXE

gawk [ opções no estilo POSIX ou GNU ] -f arquivo-de-programa [ -- ] arquivo ...
gawk [ opções no estilo POSIX ou GNU ] [ -- ] texto-do-programa arquivo ...

LEIA PRIMEIRO

Esta página de manual é fornecida como cortesia. Observe que a Fonte Única de Verdade para gawk é o manual Texinfo, disponível online em vários formatos em https://www.gnu.org/software/gawk/manual. Ele também pode ser instalado no subsistema Info em seu sistema e, portanto, estar disponível por meio do comando info(1).

Em caso de qualquer contradição entre o manual Texinfo e esta página de manual, o manual deve ser considerado como autoritativo.

DESCRIÇÃO

Gawk é a implementação do GNU da linguagem de programação AWK. Ele está em conformidade com a definição da linguagem no padrão POSIX 1003.1. Esta versão, por sua vez, é baseada na descrição em A Linguagem de Programação AWK, de Aho, Kernighan e Weinberger. Gawk fornece os recursos adicionais encontrados na versão atual do awk de Brian Kernighan e numerosas extensões específicas do GNU.

A linha de comando consiste em opções para o próprio gawk, o texto do programa AWK (se não for fornecido por meio do opções -f ou --include) e valores a serem disponibilizados nas variáveis pré-definidas ARGC e ARGV AWK.

PREFÁCIO

Esta página de manual é intencionalmente o mais concisa possível. Detalhes completos são fornecidos em GAWK: Programação AWK Eficaz, e você deve consultá-lo para obter a história completa de qualquer recurso específico. Quando possível, links para a versão online do manual são fornecidos.

FORMATO DAS OPÇÕES

As opções Gawk podem ser opções de uma letra no estilo POSIX tradicional ou opções longas no estilo GNU. As opções POSIX começam com um único "-", enquanto as opções longas começam com "--". As opções longas são fornecidas para recursos específicos do GNU e para recursos obrigatórios do POSIX.

As opções específicas do Gawk são normalmente usadas na forma de opções longas. Os argumentos para as opções longas são ou unidos à opção por um sinal de "=", sem espaços intermediários, ou podem ser fornecidos no próximo argumento da linha de comando. As opções longas podem ser abreviadas, desde que a abreviação permaneça única.

Além disso, cada opção longa tem uma opção curta correspondente, para que a funcionalidade da opção possa ser usada dentro de scripts executáveis #!.

OPÇÕES

Gawk aceita as seguintes opções. As opções padrão são listadas primeiro, seguidas pelas opções para extensões gawk, listadas alfabeticamente pelo curto nome da opção.

-f arquivo-de-programa, --file arquivo-de-programa

Leia o código do programa AWK do arquivo arquivo-de-programa, em vez do primeiro argumento da linha de comando. Várias opções -f podem ser usadas. Os arquivos lidos com -f são tratados como se eles começam com uma declaração @namespace "awk" implícita.

-F fs, --field-separator fs
Use fs como separador de campo na entrada (o valor da variável predefinida FS).

-v var=val, --assign var=val
Atribua o valor val à variável var, antes do início da execução do programa. Esses valores de variáveis estarão disponíveis na regra BEGIN de um programa AWK.

-b, --characters-as-bytes
Trate todos os dados de entrada como caracteres de um único byte. A opção --posix substitui esta.

-c, --traditional
Execute no modo de compatibilidade. No modo de compatibilidade, gawk se comporta de forma idêntica ao awk de Brian Kernighan; nenhuma das extensões específicas do GNU é reconhecida.

-C, --copyright
Imprima a versão curta da mensagem de informações de direitos autorais do GNU na saída padrão e saia com sucesso.

-d[file], --dump-variables[=file]
Imprima uma lista ordenada de variáveis globais, seus tipos e valores finais em um arquivo. O arquivo padrão é awkvars.out no diretório atual.

-D[file], --debug[=file]
Habilite a depuração de programas AWK. Por padrão, o depurador lê comandos interativamente do teclado (entrada padrão). O argumento de arquivo opcional especifica um arquivo com uma lista de comandos para o depurador executar de forma não interativa.
Neste modo de execução, gawk carrega o código-fonte do programa AWK e, em seguida, solicita comandos de depuração. Gawk só pode depurar o código-fonte do programa AWK fornecido com as opções -f e --include. O depurador está documentado em GAWK: Effective AWK Programming; consulte https://www.gnu.org/software/gawk/manual/html_node/Debugger.html#Debugger.

-e program-text, --source program-text
Use program-text como código-fonte do programa AWK. Cada argumento fornecido via -e é tratado como se começasse com uma instrução implícita @namespace "awk".

-E file, --exec file
Semelhante a -f, no entanto, esta opção é a última a ser processada. Isso deve ser usado com scripts #!, especialmente para aplicativos CGI, para evitar passar opções ou código-fonte na linha de comando de uma URL. Esta opção desativa as atribuições de variáveis da linha de comando.

-g, --gen-pot
Analise e processe o programa AWK e gere um arquivo em formato GNU .pot (Portable Object Template) na saída padrão com entradas para todas as strings localizáveis no programa. O programa em si não é executado.

-h, --help
Imprima um resumo relativamente curto das opções disponíveis na saída padrão. De acordo com os Padrões de Codificação GNU, essas opções causam uma saída imediata e bem-sucedida.

-i include-file, --include include-file
Carregue uma biblioteca de código-fonte awk. Isso pesquisa a biblioteca usando a variável de ambiente AWKPATH. Se a pesquisa inicial falhar, uma nova tentativa será feita após a adição do sufixo .awk. O arquivo será carregado apenas uma vez (ou seja, os duplicados são eliminados) e o código não constitui o código-fonte do programa principal. Os arquivos lidos com --include são tratados como se começassem com uma instrução implícita @namespace "awk".

-I, --trace
Imprime os nomes internos do bytecode conforme são executados durante a execução do programa. O rastreamento é impresso no erro padrão. Cada "código de operação" é precedido por um sinal de "+" na saída.

-k, --csv
Habilita o processamento especial CSV. Consulte a seção "Valores Separados por Vírgula" para obter mais detalhes.

-l lib, --load lib
Carrega uma extensão gawk da biblioteca compartilhada lib. Isso pesquisa a biblioteca usando a variável de ambiente AWKLIBPATH. Se a pesquisa inicial falhar, uma nova tentativa será feita após anexar o sufixo de biblioteca compartilhada padrão para a plataforma. Espera-se que a rotina de inicialização da biblioteca seja chamada dl_load().

-L [value], --lint[=value]
Fornece avisos sobre construções que são duvidosas ou não portáveis para outras implementações de AWK. Consulte https://www.gnu.org/software/gawk/manual/html\_node/Options.html\#Options para obter a lista de valores possíveis para value.

-M, --bignum
Força a aritmética de precisão arbitrária em números. Esta opção não tem efeito se o gawk não for compilado para usar as bibliotecas GNU MPFR e GMP. (Nesse caso, o gawk emite um aviso.)

NOTA: Este recurso está em período de teste. O principal mantenedor do gawk não está mais oferecendo suporte a ele, embora haja um membro da equipe de desenvolvimento que o faz. Se essa situação mudar, o recurso será removido do gawk.

-n, --non-decimal-data
Reconhece valores octais e hexadecimais nos dados de entrada. Use esta opção com extrema cautela!

-N, --use-lc-numeric
Força o gawk a usar o caractere de ponto decimal do locale ao analisar os dados de entrada.

-o[file], --pretty-print[=file]
Emite uma versão formatada dos programas no arquivo. O arquivo padrão é awkprof.out no diretório atual. Esta opção implica --no-optimize.

-O, --optimize
Habilita as otimizações padrão do gawk na representação interna do programa. Esta opção está ativa por padrão.

-p[prof-file], --profile[=prof-file]
Inicia uma sessão de criação de perfil e envia os dados de criação de perfil para prof-file. O padrão é awkprof.out no diretório atual. O perfil contém contagens de execução de cada instrução no programa na margem esquerda e contagens de chamadas de função para cada função definida pelo usuário. O gawk é executado mais lentamente neste modo. Esta opção implica --no-optimize.

-P, --posix
Isso ativa o modo de compatibilidade e desabilita várias extensões comuns.

-r, --re-interval
Habilita o uso de expressões de intervalo na correspondência de expressões regulares. As expressões de intervalo são habilitadas por padrão, mas esta opção permanece para compatibilidade com versões anteriores.

-s, --no-optimize
Desabilita as otimizações padrão do gawk na representação interna do programa.

-S, --sandbox
Executa o gawk no modo de sandbox, desabilitando a função system(), a redireção de entrada com getline, a redireção de saída com print e printf e o carregamento de extensões dinâmicas. A execução de comandos (por meio de pipelines) também é desabilitada.

-t, --lint-old

Fornece avisos sobre construções que não são portáveis para a versão original do UNIX awk.

-V, --version

Imprime informações de versão para esta cópia específica do gawk na saída padrão. Isso é útil ao relatar bugs. De acordo com os Padrões de Codificação GNU, essas opções fazem com que o programa termine imediatamente com sucesso.

-- Sinaliza o final das opções. Isso é útil para permitir que argumentos adicionais para o programa AWK comecem com um "-".

No modo de compatibilidade, quaisquer outras opções são sinalizadas como inválidas, mas são ignoradas. Em operação normal, desde que o texto do programa tenha sido fornecido, as opções desconhecidas são passadas para o programa AWK no array ARGV para processamento.

Para compatibilidade com POSIX, a opção -W pode ser usada, seguida pelo nome de uma opção longa.

EXECUÇÃO DO PROGRAMA AWK

Um programa AWK consiste em uma sequência de diretivas opcionais, instruções de padrão-ação e definições de função opcionais.

@include "nome_do_arquivo"
@load "nome_do_arquivo"
@namespace "nome"
padrão { instruções de ação }
function nome(lista de parâmetros) { instruções }

O Gawk primeiro lê o código do programa dos arquivos de programa especificados, dos argumentos para --source ou do primeiro argumento não-opção na linha de comando. As opções -f e --source podem ser usadas várias vezes na linha de comando. O Gawk lê o texto do programa como se todos os arquivos de programa e textos de origem da linha de comando fossem concatenados.

Além disso, linhas que começam com @include podem ser usadas para incluir outros arquivos de origem em seu programa. Isso é equivalente a usar a opção --include.

Linhas que começam com @load podem ser usadas para carregar funções de extensão em seu programa. Isso é equivalente a usar a opção --load.

A variável de ambiente AWKPATH especifica um caminho de pesquisa a ser usado ao encontrar arquivos de origem especificados com as opções -f e --include. Se esta variável não existir, o caminho padrão é ". :/usr/local/share/awk". (O diretório real pode variar, dependendo de como o gawk foi construído e instalado.) Se um nome de arquivo fornecido à opção -f contiver um caractere "/", nenhum caminho de pesquisa é executado.

A variável de ambiente AWKLIBPATH especifica um caminho de pesquisa a ser usado ao encontrar arquivos de origem especificados com a opção --load. Se esta variável não existir, o caminho padrão é "/usr/local/lib/gawk". (O diretório real pode variar, dependendo de como o gawk foi construído e instalado.)

O Gawk executa programas AWK na seguinte ordem. Primeiro, todas as atribuições de variáveis especificadas com a opção -v são executadas. Em seguida, o gawk compila o programa em um formulário interno. Em seguida, o gawk executa o código nas regras BEGIN (se houver) e, em seguida, procede a ler cada arquivo nomeado no array ARGV (até ARGV[ARGC-1]). Se não houver arquivos nomeados na linha de comando, o gawk lê a entrada padrão.

Se um nome de arquivo na linha de comando tiver o formato var=val, ele será tratado como uma atribuição de variável. A variável var receberá o valor val. (Isso acontece depois que todas as regras BEGIN forem executadas.)

Se o valor de um elemento específico de ARGV estiver vazio (""), o gawk ignora esse elemento.

Para cada arquivo de entrada, se existir uma regra BEGINFILE, o gawk executa o código associado antes de processar o conteúdo do arquivo. Da mesma forma, o gawk executa o código associado às regras ENDFILE após processar o arquivo.

Para cada registro na entrada, o gawk verifica se ele corresponde a algum padrão no programa AWK. Para cada padrão com o qual o registro corresponde, o gawk executa a ação associada. Os padrões são testados na ordem em que aparecem no programa.

Finalmente, após toda a entrada ser esgotada, o gawk executa o código na(s) regra(s) END (se houver).

Diretórios na Linha de Comando

De acordo com o POSIX, os arquivos nomeados na linha de comando awk devem ser arquivos de texto. O comportamento é "indefinido" se não forem. A maioria das versões de awk trata um diretório na linha de comando como um erro fatal.

Para o gawk, um diretório na linha de comando produz um aviso, mas é ignorado. Se alguma das opções --posix ou --traditional for especificada, o gawk retorna a tratar diretórios na linha de comando como um erro fatal.

VARIÁVEIS, REGISTROS E CAMPOS

As variáveis AWK são dinâmicas; elas são criadas quando são usadas pela primeira vez. Seus valores são números de ponto flutuante ou strings, ou ambos, dependendo de como são usados. Além disso, o gawk permite que as variáveis tenham tipo de expressão regular. AWK também tem arrays unidimensionais; arrays com múltiplas dimensões podem ser simulados. No entanto, o gawk fornece arrays de arrays reais. Várias variáveis predefinidas são definidas à medida que um programa é executado; elas são descritas conforme necessário e resumidas abaixo.

Registros

Normalmente, os registros são separados por caracteres de nova linha. Você pode controlar como os registros são separados atribuindo valores à variável interna RS. Consulte https://www.gnu.org/software/gawk/manual/html_node/Records.html para obter os detalhes.

Campos

À medida que cada registro de entrada é lido, o gawk divide o registro em campos, usando o valor da variável FS como o separador de campo. Além disso, FIELDWIDTHS e FPAT podem ser usados para controlar a divisão de campos de entrada. Consulte os detalhes, começando em https://www.gnu.org/software/gawk/manual/html_node/Fields.html.

Cada campo no registro de entrada pode ser referenciado por sua posição: $1, $2 e assim por diante. $0 é o registro inteiro, incluindo espaços em branco à esquerda e à direita.

A variável NF é definida como o número total de campos no registro de entrada.

Referências a campos inexistentes (ou seja, campos após $NF) produzem a string nula. No entanto, atribuir a um campo inexistente (por exemplo, $(NF+2) = 5) aumenta o valor de NF, cria quaisquer campos intermediários com a string nula como seus valores e faz com que o valor de $0 seja recalculado, com os campos sendo separados pelo valor de OFS. Referências a campos com números negativos causam um erro fatal. A diminuição de NF faz com que os valores dos campos após o novo valor sejam perdidos e o valor de $0 seja recalculado, com os campos sendo separados pelo valor de OFS.

Atribuir um valor a um campo existente faz com que todo o registro seja reconstruído quando $0 for referenciado. Da mesma forma, atribuir um valor a $0 faz com que o registro seja dividido novamente, criando novos valores para os campos.

Valores Separados por Vírgula

Quando invocado com a opção -k ou --csv, o gawk não usa a determinação regular de registros e a divisão de campos conforme descrito acima. Em vez disso, os registros são terminados por quebras de linha não delimitadas e os campos são separados por vírgulas. Aspas duplas podem ser usadas para envolver campos que contenham vírgulas, quebras de linha ou aspas duplas duplicadas. Consulte [https://www.gnu.org/software/gawk/manual/html_node/Comma-Separated-Fields.html] para obter mais detalhes.

Variáveis Internas

As variáveis internas do Gawk são listadas abaixo. Esta lista é propositalmente concisa. Para obter detalhes, consulte [https://www.gnu.org/software/gawk/manual/html_node/Built_002din-Variables.html].

ARGC        O número de argumentos da linha de comando.

ARGIND      O índice em ARGV do arquivo atual que está sendo processado.

ARGV        Array de argumentos da linha de comando. O array é indexado de 0 a ARGC - 1.

BINMODE     Em sistemas não POSIX, especifica o uso do modo "binário" para toda a E/S de arquivo. Consulte [https://www.gnu.org/software/gawk/manual/html_node/PC-Using.html](https://www.gnu.org/software/gawk/manual/html_node/PC-Using.html) para obter os detalhes.

CONVFMT     O formato de conversão para números, "%.6g" por padrão.

ENVIRON     Um array contendo os valores do ambiente atual. O array é indexado pelos nomes das variáveis de ambiente, cada elemento sendo o valor dessa variável.

ERRNO       Se ocorrer um erro de sistema ao fazer uma redirecionamento para getline, durante uma leitura para getline ou durante um fechamento, ERRNO é definido como uma string descrevendo o erro. O valor está sujeito à tradução em locais que não sejam o inglês.

FIELDWIDTHS Uma lista separada por espaços das larguras dos campos. Quando definido, o gawk analisa a entrada em campos de largura fixa, em vez de usar o valor da variável FS como o separador de campos. Cada largura de campo pode ser precedida opcionalmente por um valor separado por dois pontos, especificando o número de caracteres a serem ignorados antes do início do campo.

FILENAME    O nome do arquivo de entrada atual. Se nenhum arquivo for especificado na linha de comando, o valor de FILENAME é "-". No entanto, FILENAME não está definido dentro da regra BEGIN (a menos que seja definido por getline).

FNR         O número do registro de entrada no arquivo de entrada atual.

FPAT        Uma expressão regular que descreve o conteúdo dos campos em um registro. Quando definido, o gawk analisa a entrada em campos, onde os campos correspondem à expressão regular, em vez de usar o valor de FS como o separador de campos.

FS          O separador de campo de entrada, um espaço por padrão. Consulte [https://www.gnu.org/software/gawk/manual/html_node/Field-Separators.html](https://www.gnu.org/software/gawk/manual/html_node/Field-Separators.html) para obter os detalhes.

FUNCTAB     Uma matriz cujos índices e valores correspondentes são os nomes de todas as funções definidas pelo usuário ou de extensão no programa. NOTA: você não pode usar a instrução delete com a matriz FUNCTAB.

IGNORECASE  Controla a diferenciação de maiúsculas e minúsculas em todas as operações de expressão regular e string. Veja https://www.gnu.org/software/gawk/manual/html_node/Case_002dsensitivity.html para detalhes.

LINT        Fornece controle dinâmico da opção --lint dentro de um programa AWK.

NF          O número de campos no registro de entrada atual.

NR          O número total de registros de entrada vistos até agora.

OFMT        O formato de saída para números, "%.6g" por padrão.

OFS         O separador de campos de saída, um espaço por padrão.

ORS         O separador de registros de saída, uma nova linha por padrão.

PREC        A precisão de trabalho de números de ponto flutuante de precisão arbitrária, 53 por padrão.

PROCINFO    Os elementos desta matriz fornecem acesso a informações sobre o programa AWK em execução. Veja https://www.gnu.org/software/gawk/manual/html_node/Auto_002dset para detalhes.

ROUNDMODE   O modo de arredondamento a ser usado para aritmética de números de precisão arbitrária, por padrão "N" (modo IEEE-754 roundTiesToEven). Veja https://www.gnu.org/software/gawk/manual/html_node/Setting-the-rounding-mode para detalhes.

RS          O separador de registros de entrada, uma nova linha por padrão.

RT          O terminador de registro. O Gawk define RT como o texto de entrada que correspondeu ao caractere ou expressão regular especificada por RS.

RSTART      O índice do primeiro caractere correspondido por match(); 0 se não houver correspondência.

RLENGTH     O comprimento da string correspondida por match(); -1 se não houver correspondência.

SUBSEP      A string usada para separar vários subscritos em elementos de matriz, por padrão "\034".

SYMTAB      Uma matriz cujos índices são os nomes de todas as variáveis globais e matrizes atualmente definidas no programa. Você não pode usar a instrução delete com a matriz SYMTAB, nem atribuir a elementos com um índice que não seja um nome de variável.

TEXTDOMAIN  O domínio de texto do programa AWK; usado para encontrar as traduções localizadas para as strings do programa.

Matrizes

As matrizes são indexadas com uma expressão entre colchetes ([ e ]). Se a expressão for uma lista de expressões (expr, expr ...) então o subscrito da matriz é uma string consistindo da concatenação do valor (string) de cada expressão, separados pelo valor da variável SUBSEP. Essa facilidade é usada para simular matrizes multidimensionais. Por exemplo:

i = "A"; j = "B"; k = "C"
x[i, j, k] = "hello, world\n"

atribui a string "hello, world\n" ao elemento da matriz x que é indexado pela string "A\034B\034C". Todas as matrizes em AWK são associativas, ou seja, indexadas por valores de string.

O operador especial in pode ser usado para testar se uma matriz tem um índice consistindo de um valor particular:

if (val in array)
    print array[val]

Se o array tiver vários subscritos, use (i, j) em array.

A construção in também pode ser usada em um loop for para iterar sobre todos os elementos de um array. No entanto, a construção (i, j) in array só funciona em testes, não em loops for.

Um elemento pode ser excluído de um array usando a instrução delete. A instrução delete também pode ser usada para excluir todo o conteúdo de um array, simplesmente especificando o nome do array sem um subscrito.

O gawk suporta arrays multidimensionais verdadeiros. Não exige que esses arrays sejam “retangulares”, como em C ou C++. Veja [https://www.gnu.org/software/gawk/manual/html_node/Arrays] para obter detalhes.

Espaços de Nomes

O Gawk fornece uma instalação de espaço de nomes simples para ajudar a contornar o fato de que todas as variáveis em AWK são globais.

Um nome qualificado consiste em dois identificadores simples unidos por dois pontos (::). O identificador à esquerda representa o espaço de nomes e o identificador à direita é a variável dentro dele. Todos os nomes simples (não qualificados) são considerados como estando no espaço de nomes “atual”; o espaço de nomes padrão é awk. No entanto, os identificadores simples que consistem apenas em letras maiúsculas são forçados para o espaço de nomes awk, mesmo que o espaço de nomes atual seja diferente.

Você muda o espaço de nomes atual com a diretiva @namespace "name".

Os nomes das funções internas predefinidas padrão não podem ser usados como nomes de espaço de nomes. Os nomes das funções adicionais fornecidas pelo gawk podem ser usados como nomes de espaço de nomes ou como identificadores simples em outros espaços de nomes. Para obter mais detalhes, consulte [https://www.gnu.org/software/gawk/manual/html_node/Namespaces.html#Namespaces].

Tipagem e Conversão de Variáveis

As variáveis e os campos podem ser números (de ponto flutuante), ou strings, ou ambos. Eles também podem ser expressões regulares. A forma como o valor de uma variável é interpretado depende do seu contexto. Se usado em uma expressão numérica, será tratado como um número; se usado como uma string, será tratado como uma string.

Para forçar uma variável a ser tratada como um número, adicione zero a ela; para forçá-la a ser tratada como uma string, concatene-a com a string nula.

Variáveis não inicializadas têm o valor numérico zero e o valor de string "" (a string nula ou vazia).

Quando uma string deve ser convertida em um número, a conversão é realizada usando strtod(3). Um número é convertido em uma string usando o valor de CONVFMT como uma string de formato para sprintf(3), com o valor numérico da variável como o argumento. No entanto, mesmo que todos os números em AWK sejam de ponto flutuante, os valores inteiros são sempre convertidos como inteiros.

O Gawk executa comparações da seguinte forma: Se duas variáveis forem numéricas, elas serão comparadas numericamente. Se um valor for numérico e o outro tiver um valor de string que seja uma “string numérica”, as comparações também serão feitas numericamente. Caso contrário, o valor numérico é convertido em uma string e uma comparação de string é realizada. Duas strings são comparadas, é claro, como strings.

Observe que as constantes de string, como "57", não são strings numéricas; são constantes de string. O conceito de "string numérica" aplica-se apenas a campos, entrada getline, FILENAME, elementos ARGV, elementos ENVIRON e os elementos de um array criado por split() ou patsplit() que são strings numéricas. A ideia básica é que apenas a entrada do usuário, e somente a entrada do usuário, que se parece com um número, deve ser tratada como tal.

Constantes Octais e Hexadecimais

Você pode usar constantes octais e hexadecimais no estilo C em seu programa AWK. Por exemplo, o valor octal 011 é igual a 9 em decimal, e o valor hexadecimal 0x11 é igual a 17 em decimal.

Constantes de String

As constantes de string em AWK são sequências de caracteres delimitadas por aspas duplas (como "valor"). Dentro das strings, certas sequências de escape são reconhecidas, como em C. Consulte https://www.gnu.org/software/gawk/manual/html_node/Escape-Sequences para obter os detalhes.

Constantes de Expressão Regular

Uma constante de expressão regular é uma sequência de caracteres delimitada por barras (como /valor/).

As sequências de escape descritas no manual também podem ser usadas dentro de constantes de expressão regular (por exemplo, /[ \t\f\n\r\v]/ corresponde a caracteres de espaço em branco).

Gawk fornece constantes de expressão regular fortemente tipadas. Elas são escritas com um símbolo de liderança @ (como em: @/valor/). Essas constantes podem ser atribuídas a escalares (variáveis, elementos de array) e passadas para funções definidas pelo usuário. As variáveis que foram assim atribuídas têm tipo de expressão regular.

PADRÕES E AÇÕES

AWK é uma linguagem orientada a linhas. O padrão vem primeiro e, em seguida, a ação. As instruções de ação são delimitadas por { e }. Seja o padrão ausente ou a ação ausente, mas, claro, não ambos. Se o padrão estiver ausente, a ação é executada para cada registro de entrada. Uma ação ausente é equivalente a

{ print }

que imprime todo o registro.

Os comentários começam com o caractere # e continuam até o final da linha. As linhas em branco podem ser usadas para separar as instruções. Normalmente, uma instrução termina com uma nova linha, no entanto, este não é o caso para as linhas que terminam com uma vírgula, {, ?, :, && ou ||. As linhas que terminam com do ou else também têm suas instruções automaticamente continuadas na linha seguinte. Em outros casos, uma linha pode ser continuada terminando-a com uma "\", caso em que a nova linha é ignorada. No entanto, um "\" após um # não é especial.

Várias instruções podem ser colocadas em uma linha, separando-as com um ";". Isso se aplica tanto às instruções dentro da parte da ação de um par padrão-ação (o caso usual) quanto às próprias instruções padrão-ação.

Padrões

Os padrões AWK podem ser um dos seguintes:

BEGIN
END
BEGINFILE
ENDFILE
/expressão regular/
expressão relacional
padrão && padrão
padrão || padrão
padrão ? padrão : padrão
(padrão)
! padrão
padrão1, padrão2

BEGIN e END são dois tipos especiais de padrões que não são testados contra a entrada. As partes de ação de todos os padrões BEGIN são mescladas como se todas as instruções tivessem sido escritas em uma única regra BEGIN. Elas são executadas antes que qualquer entrada seja lida. Da mesma forma, todas as regras END são mescladas e executadas quando toda a entrada é esgotada (ou quando uma instrução de saída é executada). Os padrões BEGIN e END não podem ser combinados com outros padrões em expressões de padrão. Os padrões BEGIN e END não podem ter partes de ação ausentes.

BEGINFILE e ENDFILE são padrões especiais adicionais cujas ações são executadas antes de ler o primeiro registro de cada arquivo de entrada da linha de comando e após ler o último registro de cada arquivo. Dentro da regra BEGINFILE, o valor de ERRNO é uma string vazia se o arquivo foi aberto com sucesso. Caso contrário, há algum problema com o arquivo e o código deve usar nextfile para ignorá-lo. Se isso não for feito, gawk produz seu erro fatal usual para arquivos que não podem ser abertos.

Para padrões /expressão regular/, a instrução associada é executada para cada registro de entrada que corresponde à expressão regular. As expressões regulares são essencialmente as mesmas das de egrep(1). Consulte [https://www.gnu.org/software/gawk/manual/html_node/Regexp.html](https://www.gnu.org/software/gawk/manual/html_node/Regexp.html) para obter detalhes sobre expressões regulares.

Uma expressão relacional pode usar qualquer um dos operadores definidos abaixo na seção sobre ações. Estes geralmente testam se certos campos correspondem a certas expressões regulares.

Os operadores &&, || e ! são AND lógico, OR lógico e NOT lógico, respectivamente, como em C. Eles usam avaliação de curto-circuito, também como em C, e são usados para combinar expressões de padrão mais primitivas. Como na maioria das linguagens, parênteses podem ser usados para alterar a ordem de avaliação.

O operador ?: é como o mesmo operador em C. Se o primeiro padrão for verdadeiro, então o padrão usado para teste é o segundo padrão; caso contrário, é o terceiro. Apenas um do segundo e terceiro padrões é avaliado.

A forma pattern1, pattern2 de uma expressão é chamada de padrão de intervalo. Ele corresponde a todos os registros de entrada começando com um registro que corresponde ao pattern1 e continuando até um registro que corresponde ao pattern2, inclusive. Ele não se combina com nenhum outro tipo de expressão de padrão.

Ações

As instruções de ação são colocadas entre chaves, { e }. As instruções de ação consistem nas instruções usuais de atribuição, condicionais e de loop encontradas na maioria das linguagens. Os operadores, instruções de controle e instruções de entrada/saída disponíveis são baseados naqueles em C.

Operadores

Os operadores em AWK, em ordem de precedência decrescente, são:

(...)       Agrupamento

$           Referência de campo.

++ --       Incremento e decremento, prefixo e pós-fixo.

^           Exponenciação.

+ - !       Mais unário, menos unário e negação lógica.

* / %       Multiplicação, divisão e módulo.

+ -         Adição e subtração.

space       Concatenação de strings.

|   |&      I/O de pipeline para getline, print e printf.

< > <= >= == !=

Os operadores relacionais padrão.

~ !~        Correspondência de expressão regular, correspondência negada.

in          Membro de array.

&&          AND lógico.

||          OR lógico.

?:          A expressão condicional C. Tem o seguinte formato: expr1 ? expr2 : expr3. Se expr1 for
verdadeiro, o valor da expressão é expr2; caso contrário, é expr3. Apenas um de expr2
e expr3 é avaliado.

= += -= *= /= %= ^=

Atribuição. Tanto a atribuição absoluta (var = valor) quanto a atribuição de operador (as outras formas) são suportadas.

Instruções de Controle

As instruções de controle são as seguintes:

if (condição) instrução [ else instrução ]
while (condição) instrução
do instrução while (condição)
for (expr1; expr2; expr3) instrução
for (var in array) instrução
break
continue
delete array[index]
delete array
exit [ expressão ]
{ instruções }
switch (expressão) {
case valor|regex : instrução
...
[ default: instrução ]
}

Instruções de I/O

As instruções de entrada/saída são as seguintes:

close(arquivo [, como])   Fecha um arquivo, pipeline ou coprocess aberto. O parâmetro opcional como só
deve ser usado ao fechar uma das extremidades de um pipeline bidirecional para um coprocess. Deve ser um
valor de string, ou "to" ou "from".

getline               Define $0 do próximo registro de entrada; define NF, NR, FNR, RT.

getline <arquivo       Define $0 do próximo registro do arquivo; define NF, RT.

getline var           Define var do próximo registro de entrada; define NR, FNR, RT.

getline var <arquivo     Define var do próximo registro do arquivo; define RT.

comando | getline [var]

Executa o comando, direcionando a saída para $0 ou var, conforme acima, e RT.

comando |& getline [var]

Executa o comando como um coprocess, direcionando a saída para $0 ou var, conforme acima, e RT. (O comando também pode ser um socket. Consulte a subseção Nomes de arquivos especiais, abaixo).

fflush([arquivo])        Esvazia quaisquer buffers associados ao arquivo ou pipeline de saída aberto. Se
o arquivo estiver ausente ou se for uma string nula, então esvazia todos os arquivos e pipelines de saída
abertos.

next                  Interrompe o processamento do registro de entrada atual. Lê o próximo registro de entrada e
inicia o processamento novamente com o primeiro padrão no programa AWK. Ao
atingir o final dos dados de entrada, executa qualquer regra(s) END.

nextfile              Interrompe o processamento do arquivo de entrada atual. O próximo registro de entrada lido vem
do próximo arquivo de entrada. Atualiza FILENAME e ARGIND, redefine FNR para 1 e
inicia o processamento novamente com o primeiro padrão no programa AWK. Ao
atingir o final dos dados de entrada, executa as regras ENDFILE e END.

print                 Imprime o registro atual. O registro de saída é terminado com o valor
de ORS.

print lista-de-expressões Imprime expressões. Cada expressão é separada pelo valor de OFS. O
registro de saída é terminado com o valor de ORS.

print expr-list >file Imprime expressões em um arquivo. Cada expressão é separada pelo valor de OFS. O registro de saída é terminado com o valor de ORS.

printf fmt, expr-list Formata e imprime.

printf fmt, expr-list >file

Formata e imprime em um arquivo.

system(cmd-line) Executa o comando cmd-line e retorna o status de saída. (Isso pode não estar disponível em sistemas não POSIX.) Consulte [https://www.gnu.org/software/gawk/manual/html_node/I_002fO-Functions.html#I_002fO-Functions] para obter detalhes completos sobre o status de saída.

Redirecionamentos de saída adicionais são permitidos para print e printf.

print ... >> file

Anexa a saída ao arquivo.

print ... | command

Escreve em um pipe.

print ... |& command

Envia dados para um coprocesso ou socket. (Veja também a subseção Nomes de Arquivos Especiais, abaixo.)

A função getline retorna 1 em caso de sucesso, zero no final do arquivo e -1 em caso de erro. Se o valor de errno(3) indicar que a operação de E/S pode ser repetida e PROCINFO["input", "RETRY"] estiver definido, então -2 será retornado em vez de -1, e chamadas adicionais para getline podem ser tentadas. Após um erro, ERRNO é definido para uma string descrevendo o problema.

NOTA: Falha ao abrir um socket bidirecional resulta em um erro não fatal sendo retornado para a função de chamada. Se estiver usando um pipe, coprocesso ou socket com getline, ou de print ou printf dentro de um loop, você deve usar close() para criar novas instâncias do comando ou socket. AWK não fecha automaticamente pipes, sockets ou coprocessos quando eles retornam EOF.

As versões AWK das instruções printf e da função sprintf() são semelhantes às de C. Para obter detalhes, consulte [https://www.gnu.org/software/gawk/manual/html_node/Printf.html].

Nomes de Arquivos Especiais

Ao realizar redirecionamento de E/S de print ou printf para um arquivo ou por meio de getline de um arquivo, gawk reconhece certos nomes de arquivos especiais internamente. Esses nomes de arquivos permitem o acesso a descritores de arquivos abertos herdados do processo pai do gawk (geralmente o shell). Esses nomes de arquivos também podem ser usados na linha de comando para nomear arquivos de dados. Os nomes de arquivos são:

- O fluxo de entrada padrão.

/dev/stdin O fluxo de entrada padrão.

/dev/stdout O fluxo de saída padrão.

/dev/stderr O fluxo de saída de erro padrão.

/dev/fd/n O arquivo associado ao descritor de arquivo aberto n.

Os seguintes nomes de arquivos especiais podem ser usados com o operador coprocessador |& para criar conexões de rede TCP/IP:

/inet/tcp/lport/rhost/rport
/inet4/tcp/lport/rhost/rport
/inet6/tcp/lport/rhost/rport

Arquivos para uma conexão TCP/IP na porta local lport para o host remoto rhost na porta remota rport. Use uma porta de 0 para que o sistema escolha uma porta. Use /inet4 para forçar uma conexão IPv4 e /inet6 para forçar uma conexão IPv6. O uso de /inet simples usa o padrão do sistema (provavelmente IPv4). Usável apenas com o operador de E/S bidirecional |&.

/inet/udp/lport/rhost/rport
/inet4/udp/lport/rhost/rport
/inet6/udp/lport/rhost/rport

Semelhante, mas usa UDP/IP em vez de TCP/IP.

Funções Numéricas

AWK possui as seguintes funções aritméticas integradas:

atan2(y, x) Retorna o arco tangente de y/x em radianos.

cos(expr) Retorna o cosseno de expr, que está em radianos.

exp(expr) A função exponencial.

int(expr) Trunca para um inteiro.

log(expr) A função logaritmo natural.

rand() Retorna um número aleatório N, entre zero e um, de tal forma que 0 ≤ N < 1.

sin(expr) Retorna o seno de expr, que está em radianos.

sqrt(expr) Retorna a raiz quadrada de expr.

srand([expr]) Usa expr como a nova semente para o gerador de números aleatórios. Se nenhum expr for fornecido, usa a hora do dia. Retorna a semente anterior para o gerador de números aleatórios.

Funções de String

Gawk tem as seguintes funções de string integradas; os detalhes são fornecidos em https://www.gnu.org/software/gawk/manual/html_node/String-Functions.

asort(s [, d [, how] ]) Retorna o número de elementos na matriz de origem s. Ordena o conteúdo de s usando as regras normais do gawk para comparar valores e substitui os índices dos valores ordenados em s por inteiros sequenciais começando em 1.
Se a matriz de destino opcional d for especificada, primeiro duplica s em d e, em seguida, ordena d, deixando os índices da matriz de origem s inalterados.
A string opcional how controla a direção e o modo de comparação. Os valores válidos para how são descritos em https://www.gnu.org/software/gawk/manual/html\_node/String-Functions.html\#String-Functions. s e d podem ser a mesma matriz; isso só faz sentido quando o terceiro argumento também é fornecido.

asorti(s [, d [, how] ])
Retorna o número de elementos na matriz de origem s. O comportamento é o mesmo que o de asort(), exceto que os índices da matriz são usados para a ordenação, não os valores da matriz. Quando terminar, a matriz é indexada numericamente e os valores são os dos índices originais. Os valores originais são perdidos; portanto, forneça uma segunda matriz se desejar preservar os originais. O propósito da string opcional how é o mesmo que para asort().
Aqui também, s e d podem ser a mesma matriz; isso só faz sentido quando o terceiro argumento também é fornecido.

gensub(r, s, h [, t]) Pesquisa na string de destino t em busca de correspondências da expressão regular r. Se h for uma string que começa com g ou G, então substitui todas as correspondências de r por s.
Caso contrário, h é um número que indica qual correspondência de r substituir. Se t não for fornecido, usa $0 em vez disso. Dentro do texto de substituição s, a sequência \n, onde n é um dígito de 1 a 9, pode ser usada para indicar apenas o texto que correspondeu à n-ésima subexpressão entre parênteses. A sequência \0 representa todo o texto correspondente, assim como o caractere &. Ao contrário de sub() e gsub(), a string modificada é retornada como o resultado da função e a string de destino original não é alterada.

gsub(r, s [, t])        Para cada substring que corresponda à expressão regular r na string t,
substitua pela string s e retorne o número de substituições. Se t não for
fornecido, use $0. Um & no texto de substituição é substituído pelo
texto que foi realmente correspondido. Use \& para obter um & literal. (Isso deve
ser digitado como "\\&"; veja https://www.gnu.org/software/gawk/manual/html_node/Gory-Details.html#Gory-Details para uma discussão mais completa das
regras para ampersands e barras invertidas no texto de substituição de
sub(), gsub() e gensub().)

index(s, t)             Retorne o índice da string t na string s, ou zero se t não estiver
presente. (Isso implica que os índices de caracteres começam em um.)

length([s])             Retorne o comprimento da string s, ou o comprimento de $0 se s não for
fornecido. Com um argumento de array, length() retorna o número de elementos
no array.

match(s, r [, a])       Retorne a posição em s onde a expressão regular r ocorre, ou zero
se r não estiver presente, e defina os valores de RSTART e RLENGTH. Observe que
a ordem dos argumentos é a mesma do operador ~: str ~ re. Veja
https://www.gnu.org/software/gawk/manual/html_node/String-Functions.html#String-Functions para uma descrição de como o array a é
preenchido, se for fornecido.

patsplit(s, a [, r [, seps] ])
Divide a string s no array a e no array de separadores seps na
expressão regular r, e retorna o número de campos. Os valores dos elementos
são as porções de s que corresponderam a r. O valor de seps[i] é o separador, possivelmente nulo, que apareceu após a[i]. O valor de seps[0] é o
separador inicial, possivelmente nulo. Se r for omitido, FPAT será usado em vez disso.
Os arrays a e seps são limpos primeiro. A divisão se comporta de forma idêntica
à divisão de campos com FPAT.

split(s, a [, r [, seps] ])
Divide a string s no array a e no array de separadores seps na
expressão regular r, e retorna o número de campos. Se r for omitido,
FS será usado em vez disso. Os arrays a e seps são limpos primeiro. seps[i] é
o separador de campo correspondido por r entre a[i] e a[i+1]. A divisão se comporta de forma idêntica à divisão de campos.

sprintf(fmt, expr-list) Imprime expr-list de acordo com fmt e retorna a string resultante.

strtonum(str)           Examina str e retorna seu valor numérico. Se str começar com um 0 à esquerda, trate-o como um número octal. Se str começar com um 0x ou 0X,
trate-o como um número hexadecimal. Caso contrário, assuma que é um número decimal.

sub(r, s [, t])         Assim como gsub(), mas substitua apenas a primeira substring correspondida. Retorna
zero ou um.

substr(s, i [, n])      Retorna a substring de s que começa em i com, no máximo, n caracteres. Se n for
omitido, use o restante de s.

tolower(str)            Retorna uma cópia da string str, com todos os caracteres maiúsculos em str
traduzidos para seus correspondentes minúsculos. Caracteres não alfabéticos
permanecem inalterados.

toupper(str)            Retorna uma cópia da string str, com todos os caracteres minúsculos em str
traduzidos para seus correspondentes maiúsculos. Caracteres não alfabéticos
permanecem inalterados.

Gawk é compatível com multibyte. Isso significa que index(), length(), substr() e match() operam em termos de caracteres, e não de bytes.

Funções de Tempo

Gawk fornece as seguintes funções para obter carimbos de data/hora e formatá-los. Os detalhes são fornecidos em [https://www.gnu.org/software/gawk/manual/html_node/Time-Functions.]

mktime(datespec [, utc-flag])
Converte `datespec` em um carimbo de data/hora do mesmo formato retornado por `systime()` e retorna o resultado. Se `utc-flag` estiver presente e for diferente de zero ou nulo, o horário será considerado no fuso horário UTC; caso contrário, o horário será considerado no fuso horário local. Se `datespec` não contiver elementos suficientes ou se o horário resultante estiver fora do intervalo, `mktime()` retorna -1. Consulte [https://www.gnu.org/software/gawk/manual/html_node/Time-Functions.html#Time-Functions](https://www.gnu.org/software/gawk/manual/html_node/Time-Functions.html#Time-Functions) para obter detalhes sobre `datespec`.

strftime([format [, timestamp[, utc-flag]]])
Formata `timestamp` de acordo com a especificação em `format`. Se `utc-flag` estiver presente e for diferente de zero ou nulo, o resultado estará em UTC; caso contrário, o resultado estará no horário local. O `timestamp` deve ser do mesmo formato retornado por `systime()`. Se `timestamp` estiver ausente, o horário atual do dia será usado. Se `format` estiver ausente, um formato padrão equivalente à saída de `[date]({filename}../../date)(1)` será usado. O formato padrão está disponível em `PROCINFO["strftime"]`. Consulte a especificação da função `strftime()` em ISO C para obter as conversões de formato que têm garantia de estarem disponíveis.

systime()
Retorna o horário atual do dia como o número de segundos desde a Época (1970-01-01 0000:00 UTC em sistemas POSIX).

Funções de Manipulação de Bits

Gawk fornece as seguintes funções de manipulação de bits. Elas funcionam convertendo valores de ponto flutuante de dupla precisão em inteiros uintmax_t, executando a operação e, em seguida, convertendo o resultado de volta para ponto flutuante. Passar operandos negativos para qualquer uma dessas funções causa um erro fatal.

As funções são:

and(v1, v2 [, ...])
Retorna o resultado da operação bit a bit AND dos valores fornecidos na lista de argumentos. Deve haver pelo menos dois.

compl(val)
Retorna o complemento bit a bit de `val`.

lshift(val, count)
Retorna o valor de `val`, deslocado para a esquerda em `count` bits.

or(v1, v2 [, ...])
Retorna o resultado da operação bit a bit OR dos valores fornecidos na lista de argumentos. Deve haver pelo menos dois.

rshift(val, count)
Retorna o valor de `val`, deslocado para a direita em `count` bits.

xor(v1, v2 [, ...])
Retorna o resultado da operação bit a bit XOR dos valores fornecidos na lista de argumentos. Deve haver pelo menos dois.

Funções de Tipo

As seguintes funções fornecem informações relacionadas ao tipo de seus argumentos.

isarray(x)
Retorna `true` se `x` for um array, `false` caso contrário.

typeof(x)
Retorna uma string indicando o tipo de `x`. A string será uma de "array", "number", "regexp", "string", "strnum", "unassigned" ou "undefined".

Funções de Internacionalização

As seguintes funções podem ser usadas dentro do seu programa AWK para traduzir strings em tempo de execução. Para obter detalhes completos, consulte https://www.gnu.org/software/gawk/manual/html_node/I18N-Functions.html#I18N-Functions.

bindtextdomain(directory [, domain])

Especifica o diretório onde o gawk procura os arquivos .gmo, caso eles não possam ou não devam ser colocados nos locais "padrão". Retorna o diretório onde o domínio é "vinculado". O domínio padrão é o valor de TEXTDOMAIN. Se o diretório for uma string nula (""), então bindtextdomain() retorna o vínculo atual para o domínio dado.

dcgettext(string [, domain [, category]])
Retorna a tradução de string no domínio de texto domain para a categoria de localidade category. O valor padrão para domain é o valor atual de TEXTDOMAIN. O valor padrão para category é "LC_MESSAGES".

dcngettext(string1, string2, number [, domain [, category]])
Retorna a forma plural usada para o número da tradução de string1 e string2 no domínio de texto domain para a categoria de localidade category. O valor padrão para domain é o valor atual de TEXTDOMAIN. O valor padrão para category é "LC_MESSAGES".

Funções com Valor Booleano

Você pode criar valores especiais do tipo booleano; consulte o manual para saber como eles funcionam e por que existem.

mkbool(expression)

Com base no valor booleano de expression, retorna um valor verdadeiro ou um valor falso. Os valores verdadeiros têm valor numérico um. Os valores falsos têm valor numérico zero.

FUNÇÕES DEFINIDAS PELO USUÁRIO

As funções em AWK são definidas da seguinte forma:

function name(lista de parâmetros) { declarações }

As funções são executadas quando são chamadas dentro de expressões em padrões ou ações. Os parâmetros reais fornecidos na chamada de função são usados para instanciar os parâmetros formais declarados na função. Os arrays são passados por referência, outras variáveis são passadas por valor.

As variáveis locais são declaradas como parâmetros extras na lista de parâmetros. A convenção é separar as variáveis locais dos parâmetros reais, adicionando espaços extras na lista de parâmetros. Por exemplo:

function f(p, q,     a, b)   # a e b são locais
{
...
}

/abc/     { ... ; f(1, 2) ; ... }

O parêntese esquerdo em uma chamada de função deve seguir imediatamente o nome da função, sem nenhum espaço intermediário. Essa restrição não se aplica às funções integradas listadas acima.

As funções podem chamar umas às outras e podem ser recursivas. Os parâmetros de função usados como variáveis locais são inicializados para a string nula e o número zero quando a função é invocada.

Use return expr para retornar um valor de uma função. O valor de retorno é indefinido se nenhum valor for fornecido, ou se a função retornar "caindo" no final.

As funções podem ser chamadas indiretamente. Para fazer isso, atribua o nome da função a ser chamada, como uma string, a uma variável. Em seguida, use a variável como se fosse o nome de uma função, prefixada com o sinal @, como assim: function myfunc() { print "myfunc called" ... }

{    ...
the_func = "myfunc"
@the_func()    # chama através de the_func para myfunc
...
}

Se --lint for fornecido, gawk emite um aviso sobre chamadas a funções não definidas no momento da análise, em vez de no tempo de execução. Chamar uma função não definida no tempo de execução é um erro fatal.

CARREGAMENTO DINÂMICO DE NOVAS FUNÇÕES

Você pode adicionar dinamicamente novas funções escritas em C ou C++ ao interpretador gawk em execução com a instrução @load. Os detalhes completos estão além do escopo desta página do manual; consulte https://www.gnu.org/software/gawk/manual/html_node/Dynamic-Extensions.html#Dynamic-Extensions.

SINAIS

O perfilador gawk aceita dois sinais. SIGUSR1 faz com que ele descarregue um perfil e a pilha de chamadas de função para o arquivo de perfil, que é awkprof.out ou qualquer arquivo nomeado com a opção --profile. Em seguida, ele continua a execução. SIGHUP faz com que gawk descarregue o perfil e a pilha de chamadas de função e, em seguida, saia.

INTERNACIONALIZAÇÃO

As constantes de string são sequências de caracteres delimitadas por aspas duplas. Em ambientes que não são de língua inglesa, é possível marcar strings no programa AWK como exigindo tradução para o idioma local. Essas strings são marcadas no programa AWK com um sublinhado inicial (“_”). Por exemplo,

gawk 'BEGIN { print "hello, world" }'

sempre imprime hello, world. Mas,

gawk 'BEGIN { print _"hello, world" }'

pode imprimir bonjour, monde na França. Consulte https://www.gnu.org/software/gawk/manual/html_node/Internationalization.html#Internationalization para as etapas envolvidas na produção e execução de um programa AWK que pode ser localizado.

EXTENSÕES GNU

Gawk tem um número excessivo de extensões para o POSIX awk. Elas são descritas em https://www.gnu.org/software/gawk/manual/html_node/POSIX_002fGNU.html. Todas as extensões podem ser desativadas ao invocar gawk com as opções --traditional ou --posix.

VARIÁVEIS DE AMBIENTE

A variável de ambiente AWKPATH pode ser usada para fornecer uma lista de diretórios que gawk pesquisa ao procurar arquivos nomeados pelas opções -f, --file, -i e --include, e a diretiva @include. Se a pesquisa inicial falhar, o caminho é pesquisado novamente após adicionar .awk ao nome do arquivo.

A variável de ambiente AWKLIBPATH pode ser usada para fornecer uma lista de diretórios que gawk pesquisa ao procurar arquivos nomeados pelas opções -l e --load.

A variável de ambiente GAWK_PERSIST_FILE, se presente, especifica um arquivo a ser usado como armazenamento de suporte para memória persistente. Consulte GAWK: Effective AWK Programming para obter os detalhes.

A variável de ambiente GAWK_READ_TIMEOUT pode ser usada para especificar um tempo limite em milissegundos para ler dados de entrada de um terminal, pipe ou comunicação bidirecional, incluindo sockets.

Para conexão a um host remoto via socket, GAWK_SOCK_RETRIES controla o número de tentativas, e GAWK_MSEC_SLEEP o intervalo entre as tentativas. O intervalo está em milissegundos. Em sistemas que não suportam usleep(3), o valor é arredondado para um número inteiro de segundos.

Se POSIXLY_CORRECT existir no ambiente, então gawk se comporta exatamente como se --posix tivesse sido especificado na linha de comando. Se --lint foi especificado, gawk emite uma mensagem de aviso a esse respeito.

STATUS DE SAÍDA

Se a instrução exit for usada com um valor, então gawk sai com o valor numérico fornecido.

Caso contrário, se não houver problemas durante a execução, gawk sai com o valor da constante C EXIT_SUCCESS. Isso geralmente é zero.

Se ocorrer um erro, gawk sai com o valor da constante C EXIT_FAILURE. Isso geralmente é um.

Se gawk sair devido a um erro fatal, o status de saída é 2. Em sistemas não POSIX, este valor pode ser mapeado para EXIT_FAILURE.

INFORMAÇÕES DA VERSÃO

Esta página de manual documenta gawk, versão 5.3.

AUTORES

A versão original do UNIX awk foi projetada e implementada por Alfred Aho, Peter Weinberger e Brian Kernighan dos Laboratórios Bell. Ozan Yigit é o atual mantenedor. Brian Kernighan ocasionalmente se envolve em seu desenvolvimento.

Paul Rubin e Jay Fenlason, da Free Software Foundation, escreveram gawk, para ser compatível com a versão original do awk distribuída no Seventh Edition UNIX. John Woods contribuiu com várias correções de bugs. David Trueman, com contribuições de Arnold Robbins, tornou gawk compatível com a nova versão do UNIX awk. Arnold Robbins é o atual mantenedor.

Veja GAWK: Effective AWK Programming para uma lista completa dos contribuidores do gawk e sua documentação.

Veja o arquivo README na distribuição do gawk para obter informações atualizadas sobre os mantenedores e quais portas são atualmente suportadas.

RELATOS DE BUGS E PERGUNTAS

Se você encontrar um bug no gawk, use o programa gawkbug(1) para relatá-lo.

Instruções completas para relatar um bug são fornecidas em https://www.gnu.org/software/gawk/manual/html_node/Bugs.html. Leia e siga cuidadosamente as instruções fornecidas lá. Isso tornará o relatório e a resolução de bugs muito mais fáceis para todos os envolvidos. Sério.

Por outro lado, se você tiver uma pergunta sobre como realizar uma tarefa específica usando awk ou gawk, envie um e-mail para _ com sua solicitação de ajuda.

BUGS

A opção -F não é necessária, dado o recurso de atribuição de variáveis da linha de comando; ela permanece apenas para compatibilidade com versões anteriores.

Esta página de manual é muito longa; gawk tem muitos recursos.

VEJA TAMBÉM

egrep(1), sed(1), gawkbug(1), printf(3) e strftime(3).

The AWK Programming Language, segunda edição, Alfred V. Aho, Brian W. Kernighan, Peter J. Weinberger, Addison-Wesley, 2023. ISBN 9-780138-269722.

GAWK: Effective AWK Programming, Edição 5.3, fornecida com o código-fonte do gawk. A versão atual
deste documento está disponível online em https://www.gnu.org/software/gawk/manual.

A documentação do GNU gettext, disponível online em https://www.gnu.org/software/gettext.

EXEMPLOS

Imprime e ordena os nomes de login de todos os usuários:

BEGIN     { FS = ":" }
{ print $1 | "sort" }

Conta o número de linhas em um arquivo:

{ nlines++ }
END  { print nlines }

Precede cada linha pelo seu número no arquivo:

{ print FNR, $0 }

Concatena e adiciona o número da linha (uma variação sobre o tema):

{ print NR, $0 }

Executa um comando externo para linhas específicas de dados:

tail -f access_log |
awk '/myhome.html/ { system("nmap " $1 ">> logdir/myhome.html") }'

PERMISSÕES DE CÓPIA

Copyright © 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002, 2003, 2004, 2005 2007, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 2024, 2025 Free Software Foundation, Inc.

É concedida permissão para fazer e distribuir cópias literais desta página de manual, desde que o aviso de direitos autorais e este aviso de permissão sejam preservados em todas as cópias.

É concedida permissão para copiar e distribuir versões modificadas desta página de manual sob as condições para cópia literal, desde que todo o trabalho derivado resultante seja distribuído sob os termos de um aviso de permissão idêntico a este.

É concedida permissão para copiar e distribuir traduções desta página de manual para outro idioma, sob as condições acima para versões modificadas, exceto que este aviso de permissão possa ser declarado em uma tradução aprovada pela Fundação.