regex - una - grep buscar palabra exacta

¿Cómo usar grep para unir múltiples cadenas en la misma línea?

Question

Estoy tratando de usar grep para grep líneas que contienen dos cadenas diferentes. He intentado lo siguiente, pero esto coincide con las líneas que contienen string1 o string2 que no es lo que quiero.

grep ''string1/|string2'' filename

Entonces, ¿cómo puedo emparejar con grep solo las líneas que contienen ambas cadenas ?

Answer 1

A menudo me encuentro con el mismo problema que el tuyo, y acabo de escribir un guión:

function m() { # m means ''multi pattern grep''

    function _usage() {
    echo "usage: COMMAND [-inH] -p<pattern1> -p<pattern2> <filename>"
    echo "-i : ignore case"
    echo "-n : show line number"
    echo "-H : show filename"
    echo "-h : show header"
    echo "-p : specify pattern"
    }

    declare -a patterns
    # it is important to declare OPTIND as local
    local ignorecase_flag  filename linum header_flag colon result OPTIND

    while getopts "iHhnp:" opt; do
    case $opt in
        i)
        ignorecase_flag=true ;;
        H)
        filename="FILENAME," ;;
        n)
        linum="NR," ;;
        p)
        patterns+=( "$OPTARG" ) ;;
        h)
        header_flag=true ;;
        /?)
        _usage
        return ;;
    esac
    done

    if [[ -n $filename || -n $linum ]]; then
    colon="/":/","
    fi

    shift $(( $OPTIND - 1 ))

    if [[ $ignorecase_flag == true ]]; then
    for s in "${patterns[@]}"; do
            result+=" && s~/${s,,}/"
    done
    result=${result# && }
    result="{s=tolower(/$0)} $result"
    else
    for s in "${patterns[@]}"; do
            result="$result && /$s/"
    done
    result=${result# && }
    fi

    result+=" { print "$filename$linum$colon"/$0 }"

    if [[ ! -t 0 ]]; then       # pipe case
    cat - | awk "${result}"
    else
    for f in "$@"; do
        [[ $header_flag == true ]] && echo "########## $f ##########"
        awk "${result}" $f
    done
    fi
}

Uso:

echo "a b c" | m -p A 
echo "a b c" | m -i -p A # a b c

Puedes ponerlo en .bashrc si quieres.

Answer 2

Coloque las cadenas que desea grep en un archivo

echo who    > find.txt
echo Roger >> find.txt
echo [44][0-9]{9,} >> find.txt

Luego busca usando -f

grep -f find.txt BIG_FILE_TO_SEARCH.txt 

Answer 3

Creo que esto es lo que estabas buscando:

grep -E "string1|string2" filename

Creo que respuestas como esta:

grep ''string1.*string2/|string2.*string1'' filename

solo coincida con el caso en el que ambos estén presentes, ni uno ni el otro, ni ambos.

Answer 4

Deberías tener grep así:

$ grep ''string1'' file | grep ''string2''

Answer 5

Digamos que necesitamos encontrar el recuento de varias palabras en un archivo de prueba. Hay dos formas de hacerlo

1) Use el comando grep con patrón de coincidencia de expresiones regulares

grep -c ''/</(DOG/|CAT/)/>'' testfile

2) Utilice el comando egrep

egrep -c ''DOG|CAT'' testfile 

Con egrep no necesita preocuparse por la expresión y simplemente separar palabras por un separador de tuberías.

Answer 6

El | operador en una expresión regular significa o. Es decir, string1 o string2 coincidirán. Podrías hacerlo:

grep ''string1'' filename | grep ''string2''

que canalizará los resultados del primer comando al segundo grep. Eso debería darte solo líneas que coincidan con ambos.

Answer 7

Líneas encontradas que solo comienzan con 6 espacios y terminan con:

 cat my_file.txt | grep
 -e ''^      .*(/.c$|/.cpp$|/.h$|/.log$|/.out$)'' # .c or .cpp or .h or .log or .out
 -e ''^      .*[0-9]/{5,9/}$'' # numers between 5 and 9 digist
 > nolog.txt

Answer 8

Para buscar archivos que contengan todas las palabras en cualquier orden en cualquier lugar:

grep -ril /'action/' | xargs grep -il /'model/' | xargs grep -il /'view_type/'

El primer grep inicia una búsqueda recursiva ( r ), ignorando el caso ( i ) y enumerando (imprimiendo) el nombre de los archivos que coinciden ( l ) para un término ( ''action'' con las comillas simples) que ocurren en cualquier parte del archivo.

Los siguientes greps buscan los otros términos, conservando la insensibilidad del caso y enumerando los archivos coincidentes.

La lista final de archivos que obtendrá serán los que contengan estos términos, en cualquier orden en cualquier parte del archivo.

Answer 9

Podrías probar algo como esto:

(pattern1.*pattern2|pattern2.*pattern1)

Answer 10

Puedes usar grep ''string1'' filename | grep ''string2'' grep ''string1'' filename | grep ''string2''

O bien, grep ''string1.*string2/|string2.*string1'' filename

Answer 11

Si tiene un grep con una opción -P para una regex perl limitada, puede usar

grep -P ''(?=.*string1)(?=.*string2)''

que tiene la ventaja de trabajar con cadenas superpuestas. Es algo más sencillo usar perl como grep , porque puedes especificar el y la lógica más directamente:

perl -ne ''print if /string1/ && /string2/''

Answer 12

Solo dale múltiples opciones.

 -e pattern, --regexp=pattern
         Specify a pattern used during the search of the input: an input
         line is selected if it matches any of the specified patterns.
         This option is most useful when multiple -e options are used to
         specify multiple patterns, or when a pattern begins with a dash
         (`-'').

Por lo tanto, el comando se convierte en:

grep -e "string1" -e "string2" filename

_{Nota: Arriba cité el manual de la versión de BSD, pero parece que es lo mismo en Linux .}

Answer 13

Tu método fue casi bueno, solo falta el -w

grep -w ''string1/|string2'' filename

Answer 14

Y a medida que la gente sugirió perl y python, y intrincados scripts de shell, aquí un simple enfoque awk :

awk ''/string1/ && /string2/'' filename

Después de haber mirado los comentarios a la respuesta aceptada: no, esto no hace multi-línea; pero eso tampoco es lo que pidió el autor de la pregunta.

Answer 15

para el partido multilínea:

echo -e "test1/ntest2/ntest3" |tr -d ''/n'' |grep "test1.*test3"

o

echo -e "test1/ntest5/ntest3" >tst.txt
cat tst.txt |tr -d ''/n'' |grep "test1.*test3/|test3.*test1"

solo tenemos que eliminar el carácter de nueva línea y ¡funciona!

Answer 16

grep ''(string1.*string2 | string2.*string1)'' filename

obtendrá línea con string1 y string2 en cualquier orden

Answer 17

grep -i -w ''string1/|string2'' filename

Esto funciona para la concordancia exacta de palabras y las palabras que no coinciden con mayúsculas y minúsculas, para eso se usa -i