AWK

AWK (awk) é uma linguagem específica de domínio projetada para processamento de texto e normalmente usada como uma ferramenta de extração de dados e geração de relatórios. Como sed e grep, é um filtro e é um recurso padrão da maioria dos sistemas operacionais do tipo Unix.

A linguagem AWK é uma linguagem de script orientada a dados que consiste em um conjunto de ações a serem executadas em fluxos de dados textuais – executados diretamente em arquivos ou usados como parte de um pipeline – para fins de extração ou transformação de texto, como como produzir relatórios formatados. A linguagem usa extensivamente o tipo de dados string, arrays associativos (isto é, arrays indexados por strings-chave) e expressões regulares. Enquanto o AWK tem um domínio de aplicação pretendido limitado e foi especialmente projetado para suportar programas de uma linha, a linguagem é Turing-completa, e até mesmo os primeiros usuários do AWK no Bell Labs frequentemente escreviam grandes programas AWK bem estruturados.

O AWK foi criado no Bell Labs na década de 1970 e seu nome é derivado dos sobrenomes de seus autores: Alfred Aho, Peter Weinberger e Brian Kernighan. A sigla é pronunciada da mesma forma que o nome da espécie de ave auk, que está ilustrada na capa de The AWK Programming Language. Quando escrito em letras minúsculas, como awk, refere-se ao programa Unix ou Plan 9 que executa scripts escritos na linguagem de programação AWK.

História

O AWK foi inicialmente desenvolvido em 1977 por Alfred Aho (autor do egrep), Peter J. Weinberger (que trabalhou em pequenos bancos de dados relacionais) e Brian Kernighan. AWK leva o nome de suas respectivas iniciais. De acordo com Kernighan, um dos objetivos do AWK era ter uma ferramenta que manipulasse facilmente números e strings. O AWK também foi inspirado na linguagem de programação de Marc Rochkind, que foi usada para procurar padrões em dados de entrada e foi implementada usando yacc.

Como uma das primeiras ferramentas a aparecer na versão 7 do Unix, o AWK adicionou recursos computacionais a um pipeline Unix além do shell Bourne, a única linguagem de script disponível em um ambiente Unix padrão. É um dos utilitários obrigatórios da Especificação UNIX Única e é exigido pela especificação Linux Standard Base.

O AWK foi significativamente revisado e expandido em 1985–88, resultando na implementação GNU AWK escrita por Paul Rubin, Jay Fenlason e Richard Stallman, lançada em 1988. GNU AWK pode ser a versão mais amplamente implantada porque está incluída no Pacotes Linux baseados em GNU. O GNU AWK é mantido exclusivamente por Arnold Robbins desde 1994. A fonte nawk (Novo AWK) de Brian Kernighan foi lançada pela primeira vez em 1993 sem divulgação e publicamente desde o final dos anos 1990; muitos sistemas BSD o usam para evitar a licença GPL.

AWK foi precedido por sed (1974). Ambos foram projetados para processamento de texto. Eles compartilham o paradigma orientado a linha e orientado a dados e são particularmente adequados para escrever programas de uma linha, devido ao loop principal implícito e às variáveis de linha atuais. O poder e concisão dos primeiros programas AWK – notavelmente o poderoso tratamento de expressões regulares e concisão devido a variáveis implícitas, que facilitam as frases de efeito – junto com as limitações do AWK na época, foram inspirações importantes para a linguagem Perl (1987). Na década de 1990, Perl tornou-se muito popular, competindo com AWK no nicho de linguagens de processamento de texto Unix.

Estrutura de programas AWK

AWK lê a entrada uma linha de cada vez. Uma linha é digitalizada para cada padrão no programa, e para cada padrão que corresponde, a ação associada é executada.

—Alfred V. Aho

Um programa AWK é uma série de pares de ação padrão, escritos como:

condição ( Acção ?condição ( Acção ?...

onde condição é normalmente uma expressão e ação é uma série de comandos. A entrada é dividida em registros, onde, por padrão, os registros são separados por caracteres de nova linha para que a entrada seja dividida em linhas. O programa testa cada registro em relação a cada uma das condições e executa a ação para cada expressão verdadeira. Tanto a condição quanto a ação podem ser omitidas. A condição é padronizada para corresponder a cada registro. A ação padrão é imprimir o registro. Esta é a mesma estrutura de ação padrão do sed.

Além de uma expressão AWK simples, como foo == 1 ou /^foo/, a condição pode ser BEGIN ou END fazendo com que a ação seja executada antes ou depois de todos os registros terem sido lidos, ou pattern1, pattern2 que corresponde ao intervalo de registros começando com um registro que corresponda a pattern1 até e incluindo o registro que corresponde a padrão2 antes de tentar corresponder novamente a padrão1 nas linhas subsequentes.

Além dos operadores aritméticos e lógicos normais, as expressões AWK incluem o operador til, ~, que corresponde a uma expressão regular em uma string. Como açúcar sintático útil, /regexp/ sem usar o operador til corresponde ao registro atual; esta sintaxe deriva de sed, que por sua vez a herdou do editor ed, onde / é usado para pesquisa. Essa sintaxe de usar barras como delimitadores para expressões regulares foi posteriormente adotada por Perl e ECMAScript e agora é comum. O operador til também foi adotado pelo Perl.

Comandos

Os comandos AWK são as instruções que são substituídas por action nos exemplos acima. Os comandos do AWK podem incluir chamadas de funções, atribuições de variáveis, cálculos ou qualquer combinação dos mesmos. AWK contém suporte embutido para muitas funções; muitos mais são fornecidos pelos vários tipos de AWK. Além disso, alguns tipos suportam a inclusão de bibliotecas vinculadas dinamicamente, que também podem fornecer mais funções.

O comando de impressão

O comando print é usado para imprimir texto. O texto de saída sempre termina com uma string predefinida chamada separador de registro de saída (ORS), cujo valor padrão é uma nova linha. A forma mais simples deste comando é:

print

Isso exibe o conteúdo do registro atual. Em AWK, os registros são divididos em campos, e estes podem ser exibidos separadamente:

print $1

Exibe o primeiro campo do registro atual

print $1, $3

Exibe os primeiros e terceiro campos do registro atual, separados por uma cadeia predefinida chamada de separador de campo de saída (OFS) cujo valor padrão é um caractere de espaço único

Embora esses campos ($X) possam ter semelhanças com variáveis (o símbolo $ indica variáveis em Perl), eles na verdade se referem aos campos do registro atual. Um caso especial, $0, refere-se ao registro inteiro. Na verdade, os comandos "print" e "imprimir $0" são idênticos em funcionalidade.

O comando print também pode exibir os resultados de cálculos e/ou chamadas de função:

/regex_pattern/ ( # Ações para executar no evento o registro (linha) corresponde ao regex_pattern acima impressão 3+2 impressão Foobar(3) impressão Foobar(variável) impressão pecado(3- Não.2)?

A saída pode ser enviada para um arquivo:

/regex_pattern/ ( # Ações para executar no evento o registro (linha) corresponde ao regex_pattern acima impressão "expressão" > "Nome de arquivo"?

ou através de um cano:

/regex_pattern/ ( # Ações para executar no evento o registro (linha) corresponde ao regex_pattern acima impressão "expressão" | "comando"?

Variáveis incorporadas

As variáveis internas do Awk incluem as variáveis de campo: $1, $2, $3 e assim por diante ($0 representa o registro inteiro). Eles mantêm o texto ou valores nos campos de texto individuais em um registro.

Outras variáveis incluem:

• NR: Número de registros. Mantém uma contagem atual do número de registros de entrada lidos tão longe de todos os arquivos de dados. Começa em zero, mas nunca é automaticamente redefinido para zero.
• FNR: Arquivo Número de Registros. Mantém uma contagem atual do número de registros de entrada lidos até agora no arquivo atual. Esta variável é automaticamente redefinida para zero cada vez que um novo arquivo é iniciado.
• NF: Número de campos. Contém o número de campos no registro de entrada atual. O último campo no registro de entrada pode ser designado por $NF, o campo 2nd-to-last por $(NF-1), o campo 3rd-to-last por $(NF-2), etc.
• FILENAME: Contém o nome do arquivo de entrada atual.
• FS: Separador de campo. Contém o "separador de campo" usado para dividir campos no registro de entrada. O padrão, "espaço branco", permite qualquer sequência de espaço e caracteres tab. FS pode ser transferido com outra sequência de caracteres ou caracteres para alterar o separador de campo.
• RS: Separador de registro. Armazena o caractere atual do separador de gravação. Uma vez que, por padrão, uma linha de entrada é o registro de entrada, o caractere de separador de registro padrão é uma "nova linha".
• OFS: Separador de campo de saída. Armazena o "separador de campo de saída", que separa os campos quando Awk os imprime. O padrão é um caractere "espaço".
• ORS: Separador de registro de saída. Armazena o "separador de registro de saída", que separa os registros de saída quando Awk os imprime. O padrão é um caractere "newline".
• OFMT: Formato de saída. Armazena o formato para saída numérica. O formato padrão é "%.6g".

Variáveis e sintaxe

Os nomes das variáveis podem usar qualquer um dos caracteres [A-Za-z0-9_], com exceção das palavras-chave do idioma. Os operadores + - * / representam adição, subtração, multiplicação e divisão, respectivamente. Para concatenação de strings, basta colocar duas variáveis (ou constantes de strings) uma ao lado da outra. É opcional usar um espaço no meio se constantes de string estiverem envolvidas, mas dois nomes de variáveis colocados adjacentes um ao outro requerem um espaço entre eles. Aspas duplas delimitam constantes de string. As declarações não precisam terminar com ponto e vírgula. Finalmente, comentários podem ser adicionados aos programas usando # como o primeiro caractere em uma linha.

Funções definidas pelo usuário

Em um formato semelhante ao C, as definições de função consistem na palavra-chave função, o nome da função, os nomes dos argumentos e o corpo da função. Aqui está um exemplo de uma função.

função add_three (número) ( retorno número + 3?

Esta instrução pode ser invocada da seguinte forma:

(padrão) ( impressão add_three(36) Saídas ''39'' '?

Funções podem ter variáveis que estão no escopo local. Os nomes deles são adicionados ao final da lista de argumentos, embora os valores para eles devam ser omitidos ao chamar a função. É convenção adicionar algum espaço em branco na lista de argumentos antes das variáveis locais, para indicar onde os parâmetros terminam e as variáveis locais começam.

Exemplos

Olá mundo

Aqui está o costumeiro "Olá, mundo" programa escrito em AWK:

BEGIN ( impressão "Olá, mundo!" saída?

Imprimir linhas com mais de 80 caracteres

Imprime todas as linhas com mais de 80 caracteres. Observe que a ação padrão é imprimir a linha atual.

comprimento($0) > 80

Contar palavras

Conte as palavras na entrada e imprima o número de linhas, palavras e caracteres (como wc):

( palavras - Sim. NF Chars - Sim. comprimento + 1 # adicionar um para contar para o personagem de linha nova no final de cada registro (linha)?FIM ( impressão NR, palavras, Chars ?

Como não há padrão para a primeira linha do programa, cada linha de entrada corresponde por padrão, então as ações de incremento são executadas para cada linha. Observe que palavras += NF é uma abreviação de palavras = palavras + NF.

Soma da última palavra

( S - Sim. $NF ?FIM ( impressão S + 0 ?

s é incrementado pelo valor numérico de $NF, que é a última palavra na linha conforme definido pelo separador de campo do AWK (por padrão, espaço em branco). NF é o número de campos na linha atual, por exemplo 4. Como $4 é o valor do quarto campo, $NF é o valor do último campo da linha, independentemente de quantos campos essa linha tenha ou se tem mais ou menos campos do que as linhas circundantes. $ é, na verdade, um operador unário com a precedência de operador mais alta. (Se a linha não tiver campos, então NF é 0, $0 é a linha inteira, que neste caso está vazia, exceto por possíveis espaços em branco, e também o valor numérico 0.)

No final da entrada, o padrão END corresponde, então s é impresso. No entanto, como pode não haver nenhuma linha de entrada, caso em que nenhum valor foi atribuído a s, por padrão, será uma string vazia. Adicionar zero a uma variável é um idioma do AWK para convertê-la de uma string em um valor numérico. (Concatenar uma string vazia é forçar de um número para uma string, por exemplo, s "". Observe que não há nenhum operador para concatenar strings, eles' re apenas colocado adjacentemente.) Com a coerção, o programa imprime "0" em uma entrada vazia, sem ela, uma linha vazia é impressa.

Corresponde a um intervalo de linhas de entrada

NR % 4 - Sim. 1, NR % 4 - Sim. 3 ( Impressão "%6d %sn", NR, $0 ?

A declaração de ação imprime cada linha numerada. A função printf emula o padrão C printf e funciona de forma semelhante ao comando print descrito acima. O padrão para correspondência, no entanto, funciona da seguinte forma: NR é o número de registros, normalmente linhas de entrada, que o AWK leu até agora, ou seja, o número da linha atual, começando em 1 para a primeira linha de entrada. % é o operador de módulo. NR % 4 == 1 é verdadeiro para a 1ª, 5ª, 9ª, etc., linhas de entrada. Da mesma forma, NR % 4 == 3 é verdadeiro para a 3ª, 7ª, 11ª, etc., linhas de entrada. O padrão de intervalo é falso até que a primeira parte corresponda, na linha 1, e então permanece verdadeiro até e inclusive quando a segunda parte corresponde, na linha 3. Em seguida, permanece falso até que a primeira parte corresponda novamente na linha 5.

Assim, o programa imprime as linhas 1,2,3, pula a linha 4 e depois 5,6,7 e assim por diante. Para cada linha, ele imprime o número da linha (em um campo de 6 caracteres) e o conteúdo da linha. Por exemplo, quando executado nesta entrada:

Roma
Florença
Milão
Nápoles
Turim
Veneza

O programa anterior imprime:

 1 Roma
2 Florença
3 Milão
5 Turim
6 Veneza

Imprimindo a parte inicial ou final de um arquivo

Como um caso especial, quando a primeira parte de um padrão de intervalo é constantemente verdadeira, por ex. 1, o intervalo começará no início da entrada. Da mesma forma, se a segunda parte for constantemente falsa, por ex. 0, o intervalo continuará até o final da entrada. Por exemplo,

 - Aqui..., 0

imprime linhas de entrada da primeira linha correspondente à expressão regular ^--cut here--$, ou seja, uma linha contendo apenas a frase "--cut here-- ", até o fim.

Calcular frequências de palavras

Frequência de palavras usando matrizes associativas:

BEGIN ( FS= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ="[^a-zA-Z]+"?( para (Eu...= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =1; Eu...<NF; Eu...++) palavrasNão.Mais baixo($Eu...)++?FIM ( para (Eu... em palavras) impressão Eu..., palavrasNão.Eu...]?

O bloco BEGIN define o separador de campo para qualquer sequência de caracteres não alfabéticos. Observe que os separadores podem ser expressões regulares. Depois disso, chegamos a uma ação simples, que executa a ação em cada linha de entrada. Nesse caso, para cada campo da linha, adicionamos um ao número de vezes que aquela palavra, primeiro convertida para minúscula, aparece. Por fim, no bloco END, imprimimos as palavras com suas frequências. A linha

para (i em palavras)

cria um loop que percorre o array words, definindo i para cada subscrito do array. Isso é diferente da maioria das linguagens, onde esse loop passa por cada valor na matriz. O loop, portanto, imprime cada palavra seguida por sua contagem de frequência. tolower foi uma adição ao One True awk (veja abaixo) feito depois que o livro foi publicado.

Corresponde ao padrão da linha de comando

Este programa pode ser representado de várias maneiras. O primeiro usa o shell Bourne para criar um script de shell que faz tudo. É o mais curto destes métodos:

Não!padrão= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ="$1"turnoAwk ' '"$pattern"'/ { print FILENAME ":" $0 } ' "$@"

O $pattern no comando awk não é protegido por aspas simples para que o shell expanda a variável, mas precisa ser colocado entre aspas duplas para lidar adequadamente com os padrões que contêm espaços. Um padrão por si só, da maneira usual, verifica se a linha inteira ($0) corresponde. FILENAME contém o nome do arquivo atual. awk não possui operador de concatenação explícito; duas strings adjacentes as concatenam. $0 expande para a linha de entrada original inalterada.

Existem maneiras alternativas de escrever isso. Este script de shell acessa o ambiente diretamente de dentro do awk:

Não!exportação padrão= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ="$1"turnoAwk '$0 ~ ENVIRON["pattern"] { print FILENAME ":" $0 } ' "$@"

Este é um script de shell que usa ENVIRON, uma matriz introduzida em uma versão mais recente do One True awk após a publicação do livro. O subscrito de ENVIRON é o nome de uma variável de ambiente; seu resultado é o valor da variável. Isso é como a função getenv em várias bibliotecas padrão e POSIX. O shell script cria uma variável de ambiente pattern contendo o primeiro argumento, então descarta esse argumento e faz com que o awk procure o padrão em cada arquivo.

~ verifica se o operando esquerdo corresponde ao operando direito; !~ é seu inverso. Observe que uma expressão regular é apenas uma string e pode ser armazenada em variáveis.

A próxima maneira usa a atribuição de variável de linha de comando, na qual um argumento para awk pode ser visto como uma atribuição a uma variável:

Não!padrão= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ="$1"turnoAwk '$0 ~ padrão { imprimir FILENAME ":" $0 } ' "Obrigado"$pattern" "$@"

Ou você pode usar a opção de linha de comando -v var=value (por exemplo, awk -v pattern="$pattern"...).

Finalmente, isso é escrito em awk puro, sem a ajuda de um shell ou sem a necessidade de saber muito sobre a implementação do script awk (como a atribuição de variáveis na linha de comando), mas é um pouco longo:

BEGIN ( padrão = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ARGVNão.1] para (Eu... = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 1; Eu... < ARGC; Eu...++) Remover primeiro argumento ARGVNão.Eu...] = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ARGVNão.Eu... + 1] ARGC-... se (ARGC - Sim. 1) ( # O padrão era a única coisa, então a força lida da entrada padrão (usado pelo livro) ARGC = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 2 ARGVNão.1] = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = "... ??$0 ~ padrão ( impressão NOME " $0 ?

O BEGIN é necessário não apenas para extrair o primeiro argumento, mas também para evitar que seja interpretado como um nome de arquivo após o término do bloco BEGIN. ARGC, o número de argumentos, é sempre ≥1, pois ARGV[0] é o nome do comando que executou o script, na maioria das vezes a string "awk". Observe também que ARGV[ARGC] é uma string vazia, "". # inicia um comentário que se expande até o final da linha.

Observe o bloco if. O awk apenas verifica se deve ler a entrada padrão antes de executar o comando. Isso significa que

Awk 'prog '

funciona apenas porque o fato de não haver nomes de arquivos é verificado apenas antes de prog ser executado! Se você definir explicitamente ARGC como 1 para que não haja argumentos, o awk simplesmente será encerrado porque parece que não há mais arquivos de entrada. Portanto, você precisa dizer explicitamente para ler a entrada padrão com o nome de arquivo especial -.

Scripts AWK independentes

Em sistemas operacionais do tipo Unix, os scripts AWK independentes podem ser construídos usando a sintaxe shebang.

Por exemplo, um script que imprime o conteúdo de um determinado arquivo pode ser criado criando um arquivo chamado print.awk com o seguinte conteúdo:

# -( impressão $0 ?

Ele pode ser invocado com: ./print.awk <filename>

O -f informa ao AWK que o argumento a seguir é o arquivo para ler o programa AWK, que é o mesmo sinalizador usado no sed. Uma vez que são frequentemente usados para one-liners, ambos os programas assumem como padrão a execução de um programa fornecido como um argumento de linha de comando, em vez de um arquivo separado.

Versões e implementações

O AWK foi escrito originalmente em 1977 e distribuído com a versão 7 do Unix.

Em 1985, seus autores começaram a expandir a linguagem, principalmente adicionando funções definidas pelo usuário. A linguagem é descrita no livro The AWK Programming Language, publicado em 1988, e sua implementação foi disponibilizada em lançamentos do UNIX System V. Para evitar confusão com a versão anterior incompatível, esta versão às vezes era chamada de & #34;novo awk" ou nawk. Essa implementação foi lançada sob uma licença de software livre em 1996 e ainda é mantida por Brian Kernighan (veja os links externos abaixo).

Versões antigas do Unix, como UNIX/32V, incluíam awkcc, que convertia AWK em C. Kernighan escreveu um programa para transformar awk em C++; seu estado não é conhecido.

• BWK awk, também conhecido como Nawk, refere-se à versão de Brian Kernighan. Foi chamado de "One True AWK" por causa do uso do termo em associação com o livro que originalmente descreveu a linguagem e o fato de que Kernighan era um dos autores originais da AWK. FreeBSD refere-se a esta versão como um-true-awk. Esta versão também tem características não no livro, como tolower e ENVIRON que são explicados acima; veja o arquivo FIXES no arquivo de origem para detalhes. Esta versão é usada por, por exemplo, Android, FreeBSD, NetBSD, OpenBSD, macOS e illumos. Brian Kernighan e Arnold Robbins são os principais contribuintes para um repositório de fontes para Nawk: github.com/umtrueawk/awk.
• Gawk (GNU awk) é outra implementação de software livre e a única implementação que faz sérios progressos na implementação de internacionalização e localização e redes TCP/IP. Foi escrito antes de a implementação original se tornar disponível livremente. Ele inclui seu próprio depurador, e seu profiler permite que o usuário faça melhorias de desempenho medidas para um script. Ele também permite ao usuário estender a funcionalidade com bibliotecas compartilhadas. Algumas distribuições Linux incluem Gawk como sua implementação padrão AWK. A partir da versão 5.2 (setembro 2022) Gawk inclui um recurso de memória persistente que pode lembrar variáveis e funções definidas por script de uma invocação de um script para o próximo e passar dados entre scripts não relacionados, como descrito no Persistent-Memory Gawk Manual do Usuário: www.gnu.org/software/gawk/manual/pm-gawk/.
  • Gawk-csv. A extensão CSV de Gawk fornece instalações para lidar com dados formatados de entrada e saída CSV.
• Mawk é uma implementação muito rápida de AWK por Mike Brennan baseado em um interpretador de bytecode.
• O que se passa? é um garfo de mawk, permitindo que as aplicações incorporam várias instâncias paralelas de intérpretes awk.
• Awka (cujo front end é escrito no topo da Mawk programa) é outro tradutor de scripts AWK em código C. Quando compilados, incluindo estáticamente o libawka.a do autor, os executáveis resultantes são consideravelmente acelerados e, de acordo com os testes do autor, comparar muito bem com outras versões de AWK, Perl ou Tcl. Os scripts pequenos se transformarão em programas de 160-170 kB.
• Tawk (Thompson AWK) é um compilador AWK para Solaris, DOS, OS/2 e Windows, previamente vendido pela Thompson Automation Software (que deixou suas atividades).
• Jawk é um projeto para implementar o AWK em Java, hospedado no SourceForge. As extensões para o idioma são adicionadas para fornecer acesso a recursos Java dentro de scripts AWK (ou seja, threads Java, soquetes, coleções, etc.).
• xgawk é um garfo de Gawk que se estende Gawk com bibliotecas dinamicamente carregáveis. A extensão XMLgawk foi integrada na versão oficial do GNU Awk 4.1.0.
• QSEAWK é uma implementação integrada do interpretador AWK incluída na biblioteca QSE que fornece interface de programação de aplicação de incorporação (API) para C e C++.
• O que se passa? é um intérprete muito pequeno, somente função, reentrant, embeddable escrito em C
• BusyBox inclui uma implementação AWK escrita por Dmitry Zakharov. Esta é uma implementação muito pequena adequada para sistemas embarcados.
• CLAWK por Michael Parker fornece uma implementação AWK em Common Lisp, baseado na biblioteca de expressão regular do mesmo autor.

Livros

• Aho, Alfred V.; Kernighan, Brian W.; Weinberger, Peter J. (1988-01-01). A linguagem de programação AWK. New York, NY: Addison-Wesley. ISBN 0-201-07981-X. Retrieved 2017-01-22.
• Robbins, Arnold (2001-05-15). Eficaz awk Programming (3a ed.). Sebastopol, CA: O'Reilly Media. ISBN 0-596-00070-7. Retrieved 2009-04-16.
• Dougherty, Dale; Robbins, Arnold (1997-03-01). sed & awk (2a ed.). Sebastopol, CA: O'Reilly Media. ISBN 1-56592-225-5. Retrieved 2009-04-16.
• Robbins, Arnold (2000). Eficaz Programação Awk: Guia do Usuário para Gnu Awk (1.0.3 ed.). Bloomington, IN: iUniverse. ISBN 0-595-10034-1. Arquivado do original em 12 de abril de 2009. Retrieved 2009-04-16.