tar en fast sträng i början av en rad

Om du bara måste kontrollera om en matchning hittas eller inte, klipp alla inmatningsrader till längden på önskat prefix ($1) och använd sedan grep med fast mönster:

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

Det är också lätt att räkna med matchande rader:

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

Eller radnumren på alla matchande rader (radnummer börjar vid 1):

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

Du kan mata radnumren till head och tail för att få hela texten i matchande rader, men vid det tillfället är det lättare att bara nå ett modernt skriptspråk som Python eller Ruby.

(Exemplen ovan antar Posix grep och klipp. De antar att filen att söka kommer från standardinmatning, men kan enkelt anpassas för att ta ett filnamn istället.)

Redigera: Du bör också se till att mönstret ( $1) är inte en sträng med noll längd. Annars misslyckas cut med att säga values may not include zero. Om du använder Bash använder du set -o pipefail för att fånga felutgångar med cut.

Ett sätt att använda perl som kommer att respektera snedstreck

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

Detta ställer in miljövariabeln v för kommandot och skriver sedan ut om variabelns index är 0, dvs. början på raden.

Du kan också göra identiskt i awk

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

Här är ett alternativ för alla, inte att jag rekommenderar bash för textbehandling, men det fungerar.

#!/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 

Skriptet beräknar längden len för den inmatade parametern $ 1 och använder sedan parameterutvidgning på varje rad för att se om de första len -tecken matchar $ 1. Om så är fallet skriver ut linjen.

Om din $1 är ren ASCII och din grep har -P -alternativet (för att aktivera PCRE), du kan göra detta:

 #!/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"  

Tanken här är att grep -P tillåter regelbundna uttryck med \xXX för att ange bokstavstecken, där XX är hex-ASCII-värdet för det tecknet. er matchas bokstavligen, även om det annars är ett speciellt regex-tecken.

od används för att konvertera förväntad radstart till en lista med hex-värden, som strängas sedan ihop, var och en prefixas med \x av printf. ^ förbereds sedan den här strängen för att bygga den nödvändiga regexen.

Om din $1 är unicode, då blir detta ganska svårare, eftersom det inte finns en 1: 1-korrespondens mellan tecken och hexbyte som utdata av od.

Om din grep har alternativet -P, vilket betyder PCRE , du kan göra detta:

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

Se denna fråga , och se PCRE doc för detaljer om du vill.

Som ett filter:

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

Kör på en eller flera filer:

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

Avsnittet ”Citera metatecken” i perlerdokumentationen förklarar:

Citat metatecken

Backslashed metatecken i P erl är alfanumeriska, såsom \b, \w, \n. Till skillnad från andra språk med vanligt uttryck finns det inga bakåtstreckade symboler som inte är alfanumeriska. Så allt som ser ut som \\, \(, \), \[, \], \{ eller \} tolkas alltid som en bokstavlig karaktär, inte en metatecken. Detta användes en gång i ett vanligt språk för att inaktivera eller citera de speciella betydelserna av metatecken för reguljära uttryck i en sträng som du vill använda för ett mönster. Citera helt enkelt alla icke-“ord” -tecken:

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

(Om use locale är inställt beror detta på den aktuella platsen.) Idag är det vanligare att använda quotemeta -funktionen eller \Q metakvoterande escape-sekvens för att inaktivera alla metateckenens speciella betydelser så här:

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

Var uppmärksam på att om du lägger bokstavliga bakåtvända snedstreck (de som inte finns i interpolerade variabler) mellan \Q och \E, interpolering med bakåtvänd snedstreck kan leda till förvirrande resultat. Om du behöver använda bokstavliga snedstreck inom \Q...\E, se “Gory details of parsing citerade konstruktioner” in perlop .

quotemeta och \Q beskrivs fullständigt i quotemeta .

Om det finns ett tecken som du inte ”t använder, du kan använda det för att markera början på raden. Till exempel $"\a" (ASCII 007). Det är ful men det fungerar:

{ 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 

Om du inte behöver matchade rader kan du släppa efterföljande sed och använda grep -qF. Men det är mycket lättare med awk (eller perl) …

När du vill titta i en fil utan en loop kan du använda:
Klipp ut filen med längden på sökningen sträng

Leta efter fasta strängar och returnera radnummer

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

Använd linjenumren för något som sed -n "3p;11p" file

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

När du vill radera dessa rader använder du

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