grepping uma string fixa no início de uma linha (Português)

Se você apenas precisa verificar se uma correspondência foi encontrada ou não, corte todas as linhas de entrada para o comprimento do prefixo desejado ($1) e use grep de padrão fixo:

if cut -c 1-"${#1}" | grep -qF "$1"; then echo "found" else echo "not found" fi 

Também é fácil obter a contagem das linhas correspondentes:

cut -c 1-"${#1}" | grep -cF "$1" 

Ou os números das linhas de todas as linhas correspondentes (os números das linhas começam em 1):

cut -c 1-"${#1}" | grep -nF "$1" | cut -d : -f 1 

Você pode alimentar os números das linhas para head e tail para obter o texto completo das linhas correspondentes, mas nesse ponto é mais fácil apenas encontrar uma linguagem de script moderna como Python ou Ruby.

(Os exemplos acima assumem Posix grep e cut. Eles assumem que o arquivo a ser pesquisado vem da entrada padrão, mas pode ser facilmente adaptado para receber um nome de arquivo.)

Editar: Você também deve garantir que o padrão ( $1) não é uma string de comprimento zero. Caso contrário, cut falhará dizendo values may not include zero. Além disso, se estiver usando Bash, use set -o pipefail para detectar saídas de erro por cut.

Uma maneira de usar perl que respeitará as barras invertidas

v="$1" perl -ne "print if index($_, $ENV{"v"} )==0" file 

Isso define a variável de ambiente v para o comando, então imprime se o índice da variável é 0, ou seja, o início da linha.

Você também pode fazer o mesmo no awk

v="$1" awk "index($0, ENVIRON["v"])==1" file 

Esta é uma opção totalmente bash, não que eu recomende o bash para processamento de texto, mas funciona.

#!/usr/bin/env bash # searches for $1 at the beginning of the line of its input len=${#1} while IFS= read -r line do [[ "${line:0:len}" = "$1" ]] && printf "%s\n" "$line" done 

O script calcula o comprimento len do parâmetro inserido $ 1, em seguida, usa a expansão do parâmetro em cada linha para ver se os primeiros len caracteres correspondem a $ 1. Se sim, imprime a linha.

Se seu $1 for puro ASCII e seu grep tem a opção -P (para habilitar PCRE), você pode fazer isso:

 #!/bin/bash line_start="$1" line_start_raw=$(printf "%s" "$line_start" | od -v -t x1 -An) line_start_hex=$(printf "\\x%s" $line_start_raw) grep -P "^$line_start_hex"  

A ideia aqui é que grep -P permite expressões regulares com \xXX para especificar caracteres literais, onde XX é o valor ASCII hexadecimal desse caractere. O caractere er é correspondido literalmente, mesmo que seja um caractere regex especial.

od é usado para converter o início da linha esperado em uma lista de valores hexadecimais, que são então amarrados juntos, cada um prefixado com \x por printf. ^ é então anexado a esta string para construir o regex necessário.

Se seu $1 for Unicode, então isso se torna um pouco mais difícil, porque não há uma correspondência 1: 1 de caracteres para bytes hexadecimais como saída por od.

Se o seu grep tiver a opção -P, o que significa PCRE , você pode fazer isso:

grep -P "^\Q$1\E" 

Consulte esta pergunta , e consulte o documento PCRE para obter detalhes, se desejar.

Como um filtro:

perl -ne "BEGIN {$pat = shift} print if /^\Q$pat/" search-pattern 

Executar em um ou mais arquivos:

perl -ne "BEGIN {$pat = shift} print if /^\Q$pat/" search-pattern file.. 

A seção “Quoting metacaracteres” da documentação perlre explica:

Quoting metacaracteres

Metacaracteres com barra invertida em P erl são alfanuméricos, como \b, \w, \n. Ao contrário de algumas outras linguagens de expressão regular, não há símbolos de barra invertida que não sejam alfanuméricos. Portanto, qualquer coisa que se pareça com \\, \(, \), \[, \], \{ ou \} é sempre interpretado como um personagem literal, não um metacaractere. Isso já foi usado em um idioma comum para desativar ou citar os significados especiais de metacaracteres de expressão regular em uma string que você deseja usar como padrão. Basta citar todos os caracteres que não sejam “palavras”:

 $pattern =~ s/(\W)/\\$1/g; 

(Se use locale estiver definido, isso depende de o local atual.) Hoje é mais comum usar a função quotemeta ou a \Q sequência de escape de metaquitação para desativar os significados especiais de todos os metacaracteres assim:

 /$unquoted\Q$quoted\E$unquoted/ 

Cuidado se você colocar barras invertidas literais (aquelas que não estão dentro de variáveis interpoladas) entre \Q e \E, a interpolação de barra invertida entre aspas pode levar a resultados confusos. Se você precisar usar barras invertidas literais em \Q...\E, consulte “Detalhes sangrentos da análise de construções citadas” em perlop .

quotemeta e \Q são totalmente descritos em quotemeta .

Se houver um caractere que você usa “t use, você pode usar isso para marcar o início da linha. Por exemplo, $"\a" (ASCII 007). É feio, mas vai funcionar:

{ echo "this is a line to match"; echo "but this is not"; } >file.txt stuffing=$"\a" # Guaranteed never to appear in your source text required="this" # What we want to match that beginning of a line match=$(sed "s/^/$stuffing/" file.txt | grep -F "$stuffing$required" | sed "s/^$stuffing//") if [[ -n "$match" ]] then echo "Yay. We have a match: $match" fi 

Se você não precisa das linhas correspondentes, pode descartar a sed final e usar grep -qF. Mas é muito mais fácil com awk (ou perl) …

Quando quiser olhar um arquivo sem um loop, você pode usar:
Corte o arquivo com o comprimento da pesquisa string

Procure strings fixas e retorne os números das linhas

 grep -Fn "$1" <(cut -c1-${#1} < file) 

Use os números das linhas para algo como sed -n "3p;11p" file

 sed -n "$(grep -Fn "$1" <(cut -c1-${#1} < file) | sed "s/:.*/p;/" | tr -d "\n")" file 

Quando quiser excluir essas linhas, use

 sed "$(grep -Fn "$1" <(cut -c1-${#1} < file) | sed "s/:.*/d;/" | tr -d "\n")" file