Jak zastąpić ciąg znaków w wielu plikach w wierszu poleceń Linuksa

Podobne do odpowiedzi Kaspara, ale z flagą g, aby zastąpić wszystkie zdarzenia na linii.

find ./ -type f -exec sed -i 's/string1/string2/g' {} \;

Dla globalnych przypadków niewrażliwych:

find ./ -type f -exec sed -i 's/string1/string2/gI' {} \;

ODPOWIEDŹ@kev jest dobra, ale dotyczy tylko plików w bezpośrednim katalogu.Poniższy przykład wykorzystuje grep do rekurencyjnego znajdowania plików. To działa dla mnie za każdym razem.

grep -rli 'old-word' * | xargs -i@ sed -i 's/old-word/new-word/g' @

Podział polecenia

Grep-r: --recursive , recursively read all files under each directory.
grep-l: --print-with-matches , wypisuje nazwę KAŻDEGO pliku, który ma dopasowanie, zamiast drukowania pasujących linii.
grep-i: --ignoruj-case .

Xargs : przekształć STDIN na argumenty, wykonaj odpowiedź .
xargs-i@ ~ command zawiera @~: Symbol zastępczy dla argumentu, który ma być użyty w określonej pozycji w ~command~, znak @ jest symbolem zastępczym, który może zostać zastąpiony dowolnym ciągiem znaków.

Sed-i: edycja plików w miejscu, Bez kopii zapasowych.
sed s/regexp / replacement / : substitute string matching regexp with zamiennik .
sed s / regexp / replacement / g: global , Zastąp dla każdego meczu zamiast tylko pierwszego meczu.

To mi pomogło:

find ./ -type f -exec sed -i 's/string1/string2/' {} \;

Howerver, this did not: sed -i 's/string1/string2/g' *. Może " foo "nie miało być string1, a" bar " Nie string2.

Istnieje już kilka standardowych odpowiedzi na to pytanie. Ogólnie można użyć find do rekurencyjnej listy plików, a następnie wykonać operacje za pomocą sed lub perl.

W przypadku większości szybkich zastosowań polecenie rpl jest znacznie łatwiejsze do zapamiętania. Oto replacement (foo -> bar), rekurencyjnie na wszystkich plikach:

rpl -R foo bar .

Prawdopodobnie będziesz musiał go zainstalować (apt-get install rpl lub podobne).

Jednak w przypadku trudniejszych prac, które wymagają wyrażenia regularne i back substitution, lub zmiany nazw plików, a także search-and-replace, najbardziej ogólne i potężne narzędzie, jakie znam, to repren, mały skrypt w Pythonie, który napisałem jakiś czas temu w celu wykonania bardziej skomplikowanych zadań związanych ze zmianą nazwy i refaktoryzacją. Powody, dla których możesz go preferować to:

• Obsługa zmiany nazw plików, jak również wyszukiwanie i zastępowanie zawartości pliku.
• Zobacz zmiany przed przystąpieniem do wykonywania wyszukiwania i zamiany.
• wsparcie wyrażenia regularne z podstawianiem wstecznym, całymi wyrazami, bez rozróżniania wielkości liter i zachowywaniem wielkości liter (replace foo -> bar, Foo -> Bar, FOO -> BAR).
• współpracuje z wieloma zamiennikami, w tym swapami (foo -> bar i bar -> foo) lub zestawami niestandardowych zamienników (foo -> bar, f -> x).

Aby go użyć, pip install repren. sprawdź README dla przykładów.

Aby zastąpić ciąg znaków w wielu plikach, możesz użyć:

grep -rl string1 somedir/ | xargs sed -i 's/string1/string2/g'

Np.

grep -rl 'windows' ./ | xargs sed -i 's/windows/linux/g'

Źródło blog

Aby zastąpić ścieżkę w plikach (unikając znaków escape) możesz użyć następującego polecenia:

sed -i 's@old_path@new_path@g'

Znak @ oznacza, że wszystkie znaki specjalne powinny być ignorowane w następującym łańcuchu.

Jeśli twój ciąg znaków ma ukośnik (/), możesz zmienić ogranicznik na '+'.

find . -type f -exec sed -i 's+http://example.com+https://example.com+g' {} +

To polecenie uruchamiałoby się rekurencyjnie w bieżącym katalogu.

Biorąc pod uwagę, że chcesz wyszukać ciąg search i zastąpić go replace w wielu plikach, jest to moja sprawdzona w bitwie, jednolinijkowa formuła :

grep -RiIl 'search' | xargs sed -i 's/search/replace/g'

Szybkie wyjaśnienie grepa:

• -R - wyszukiwanie rekurencyjne
• -i - wielkość liter
• -I - pomiń pliki binarne(chcesz tekst, prawda?)
• -l - wypisuje prostą listę jako wynik. Potrzebne dla pozostałych poleceń

Wyjście grep jest następnie przesyłane do sed (przez xargs), który służy do faktycznego zastępowania tekstu. Znacznik -i zmieni plik bezpośrednio. Usuń go, aby uzyskać tryb "suchego biegu".

Wystąpienia pierwszego wiersza "foo" zostaną zastąpione przez "bar". I możesz użyć drugiej linii, aby sprawdzić.

grep -rl 'foo' . | xargs sed -i 's/foo/bar/g'
grep 'foo' -r * | awk -F: {'print $1'} | sort -n | uniq -c

Jeśli masz listę plików, możesz użyć

replace "old_string" "new_string" -- file_name1 file_name2 file_name3

Jeśli masz wszystkie pliki możesz użyć

replace "old_string" "new_string" -- *

Jeśli masz listę plików z rozszerzeniem, możesz użyć

replace "old_string" "new_string" -- *.extension

" Możesz również użyć find i sed, ale uważam, że ta mała linia Perla działa dobrze.

perl -pi -w -e 's/search/replace/g;' *.php

• - E oznacza wykonanie następującej linii kodu.
• - I mean edit in-place
• - w zapisywanie ostrzeżeń
• -pętla p

" (z http://www.liamdelahunty.com/tips/linux_search_and_replace_multiple_files.php )

Moje najlepsze wyniki pochodzą z używania Perla i grepa (aby upewnić się, że plik ma wyszukiwane wyrażenie)

perl -pi -w -e 's/search/replace/g;' $( grep -rl 'search' )

Na MacBooku Pro, użyłem następujących (zainspirowany https://stackoverflow.com/a/19457213/6169225):

sed -i '' -e 's/<STR_TO_REPLACE>/<REPLACEMENT_STR>/g' *

-i '' zapewni, że nie wykonujesz żadnych kopii zapasowych.

-e dla nowoczesnych regex.

Wymyśliłem własne rozwiązanie, zanim znalazłem to pytanie (i odpowiedzi). Szukałem różnych kombinacji "replace" "kilka" i "XML", ponieważ to była moja aplikacja, ale nie znalazłem tej konkretnej.

Mój problem: miałem pliki spring xml z danymi dla przypadków testowych, zawierające złożone obiekty. Refaktor w kodzie źródłowym Javy zmienił wiele klas i nie miał zastosowania do plików danych xml. Aby zapisać dane przypadków testowych, musiałem zmienić całą klasę nazwy we wszystkich plikach xml, rozmieszczone w kilku katalogach. Wszystko to podczas zapisywania kopii zapasowych oryginalnych plików xml (choć nie było to koniecznością, ponieważ kontrola wersji uratowałaby mnie tutaj).

Szukałem jakiejś kombinacji find + sed, bo to działało u mnie w innych sytuacjach, ale nie z kilkoma zamiennikami na raz.

Potem znalazłem ask Ubuntu response i pomogło mi zbudować linię komend:

find -name "*.xml" -exec sed -s --in-place=.bak -e 's/firstWord/newFirstWord/g;s/secondWord/newSecondWord/g;s/thirdWord/newThirdWord/g' {} \;

I zadziałało idealnie (dobrze, mój przypadek miał sześć różnych zamienników). Ale pamiętaj, że dotknie wszystkich *.pliki xml w bieżącym katalogu. Z tego powodu, a jeśli jesteś odpowiedzialny za system kontroli wersji, możesz najpierw filtrować i przekazywać tylko sed tym, którzy faktycznie mają pożądane ciągi; jak:

find -name "*.xml" -exec grep -e "firstWord" -e "secondWord" -e "thirdWord" {} \; -exec sed -s --in-place=.bak -e 's/firstWord/newFirstWord/g;s/secondWord/newSecondWord/g;s/thirdWord/newThirdWord/g' {} \;

Naprawdę kiepski, ale nie udało mi się uruchomić żadnego z komend sed na OSX, więc zamiast tego zrobiłem to głupie:

:%s/foo/bar/g
:wn

^ - skopiuj te trzy linie do schowka( tak, Zawiera końcową nową linię), a następnie:

Vi *

I przytrzymaj command-v, dopóki nie powie, że nie ma już żadnych plików.

grep --include={*.php,*.html} -rnl './' -e "old" | xargs -i@ sed -i 's/old/new/g' @

Edytor strumienia modyfikuje wiele plików "inplace" po wywołaniu przełącznikiem -i, który pobiera plik kopii zapasowej kończący się jako argument. Więc

sed -i.bak 's/foo/bar/g' *

Zastępuje foo przez bar we wszystkich plikach w tym folderze, ale nie schodzi do podfolderów. Spowoduje to jednak wygenerowanie nowego pliku .bak dla każdego pliku w katalogu. Aby to zrobić rekurencyjnie dla wszystkich plików w tym katalogu i wszystkich jego podkatalogach, potrzebujesz helpera, takiego jak find, aby przemierzyć katalog drzewo.

find ./ -print0 | xargs -0 sed -i.bak 's/foo/bar/g' *

find pozwala na dalsze ograniczenia co do tego, jakie pliki należy modyfikować, poprzez podanie dalszych argumentów, takich jak find ./ -name '*.php' -or -name '*.html' -print0, jeśli to konieczne.

Uwaga: GNU sed nie wymaga zakończenia pliku, sed -i 's/foo/bar/g' * również będzie działać; FreeBSD sed wymaga rozszerzenia, ale dopuszcza odstęp pomiędzy, więc sed -i .bak s/foo/bar/g * Działa.

Skrypt dla Komendy multiedit

multiedit [-n PATTERN] OLDSTRING NEWSTRING

Z odpowiedzi Kaspara zrobiłem skrypt Basha, aby zaakceptować argumenty linii poleceń i opcjonalnie ograniczyć nazwy plików pasujące do wzorca. Zapisz w swojej $PATH i utwórz plik wykonywalny, a następnie użyj powyższej komendy.

Oto scenariusz:

#!/bin/bash
_help="\n
Replace OLDSTRING with NEWSTRING recursively starting from current directory\n
multiedit [-n PATTERN] OLDSTRING NEWSTRING\n

[-n PATTERN] option limits to filenames matching PATTERN\n
Note: backslash escape special characters\n
Note: enclose STRINGS with spaces in double quotes\n
Example to limit the edit to python files:\n
multiedit -n \*.py \"OLD STRING\" NEWSTRING\n"

# ensure correct number of arguments, otherwise display help...
if [ $# -lt 2 ] || [ $# -gt 4 ]; then echo -e $_help ; exit ; fi
if [ $1 == "-n" ]; then  # if -n option is given:
        # replace OLDSTRING with NEWSTRING recursively in files matching PATTERN
        find ./ -type f -name "$2" -exec sed -i "s/$3/$4/g" {} \;
else
        # replace OLDSTRING with NEWSTRING recursively in all files
        find ./ -type f -exec sed -i "s/$1/$2/" {} \;
fi

Jeśli plik zawiera odwrotne ukośniki (Zwykle ścieżki), możesz spróbować czegoś takiego:

sed -i -- 's,<path1>,<path2>,g' *

Ex:

sed -i -- 's,/foo/bar,/new/foo/bar,g' *.sh (in all shell scripts available)

Aby utrzymać mój osobisty węzeł angielski, napisałem skrypt narzędziowy, który pomaga zastąpić wiele par Starego/Nowego ciągu, dla wszystkich plików w katalogu rekurencyjnie.

Wielokrotna para Starego / Nowego ciągu jest zarządzana w mapie skrótu.

Katalog można ustawić za pomocą wiersza poleceń lub zmiennej środowiskowej, mapa jest mocno zakodowana w skrypcie, ale w razie potrzeby można zmodyfikować kod, aby załadować go z pliku.

Wymaga Basha 4.2, ze względu na nowe cecha.

En_standardize.sh:

#! /bin/bash
# (need bash 4.2+,)
# 
# Standardize phonetic symbol of English.
# 
# format:
#   en_standardize.sh [<dir>]
# 
# params:
# * dir
#   target dir, optional,
#   if not specified then use environment variable "$node_dir_en",
#   if both not provided, then will not execute,
# * 
# 

paramCount=$#

# figure target dir,
if [ $paramCount -ge 1 ]; then # dir specified
    echo -e "dir specified (in command):\n\t$1\n"
    targetDir=$1
elif [[ -v node_dir_en ]]; then # environable set,
    echo -e "dir specified (in environment vairable):\n\t$node_dir_en\n"
    targetDir=$node_dir_en
else # environable not set,
    echo "dir not specified, won't execute"
    exit
fi

# check whether dir exists,
if [ -d $targetDir ]; then
    cd $targetDir
else
    echo -e "invalid dir location:\n\t$targetDir\n"
    exit
fi

# initial map,
declare -A itemMap
itemMap=( ["ɪ"]="i" ["ː"]=":" ["ɜ"]="ə" ["ɒ"]="ɔ" ["ʊ"]="u" ["ɛ"]="e")

# print item maps,
echo 'maps:'
for key in "${!itemMap[@]}"; do
    echo -e "\t$key\t->\t${itemMap[$key]}"
done
echo -e '\n'

# do replace,
for key in "${!itemMap[@]}"; do
    grep -rli "$key" * | xargs -i@ sed -i "s/$key/${itemMap[$key]}/g" @
done

echo -e "\nDone."
exit

Użycie polecenia ack byłoby dużo szybsze, jak to:

ack '25 Essex' -l | xargs sed -i 's/The\ fox \jump/abc 321/g'

Również jeśli w wyniku wyszukiwania jest biała spacja. Musisz od tego uciec.

Podaję przykład naprawiania częstego błędu shebang w źródłach Pythona.

Możesz spróbować podejścia grep / sed. Oto jeden, który działa z GNU sed i nie złamie repo Gita:

$ grep -rli --exclude '*.git*' '#!/usr/bin/python' . | xargs -I {} \
gsed -i '' -e 's/#!\/usr\/bin\/python/#!\/usr\/bin\/env python/' {}

Lub możesz użyć greptile :)

$ greptile -x .py -l -i -g '#!/usr/bin/env python' -r '#!/usr/bin/python' .

Właśnie przetestowałem pierwszy skrypt, a drugi powinien działać. Uważaj na znaki ucieczki, myślę, że w większości przypadków powinno być łatwiejsze korzystanie z greptile. Oczywiście z sed można zrobić wiele ciekawych rzeczy, a za to może być lepiej opanować używanie go z xargs.

Znalazłem ten z innego posta (nie pamiętam który) i choć nie najbardziej elegancki, jest prosty i jako początkujący użytkownik Linuksa nie sprawił mi żadnych kłopotów

for i in *old_str* ; do mv -v "$i" "${i/\old_str/new_str}" ; done

Jeśli masz spacje lub inne znaki specjalne użyj \

for i in *old_str\ * ; do mv -v "$i" "${i/\old_str\ /new_str}" ; done

Dla łańcuchów w podkatalogach użyj * *

for i in *\*old_str\ * ; do mv -v "$i" "${i/\old_str\ /new_str}" ; done

Poniższe polecenie może być użyte do przeszukiwania plików i ich zastąpienia:

find . | xargs grep 'search string' | sed 's/search string/new string/g'

Na przykład

find . | xargs grep abc | sed 's/abc/xyz/g'

Jest łatwiejszy sposób, używając prostego pliku skryptu:

   # sudo chmod +x /bin/replace_string_files_present_dir

Otwórz plik w gedit lub edytorze do wyboru, używam gedit tutaj.

   # sudo gedit /bin/replace_string_files_present_dir

Następnie w edytorze wklej następujący plik

   #!/bin/bash
   replace "oldstring" "newstring" -- *
   replace "oldstring1" "newstring2" -- *
   #add as many lines of replace as there are your strings to be replaced for 
   #example here i have two sets of strings to replace which are oldstring and 
   #oldstring1 so I use two replace lines.

Zapisz plik, Zamknij gedit, następnie wyjdź z terminala lub po prostu zamknij go, a następnie uruchom go, aby móc załadować nowy skrypt, który dodałeś.

Przejdź do katalogu, w którym masz wiele plików, które chcesz edytować. Następnie uruchom:

  #replace_string_files_present_dir

Prasa wprowadź, a to automatycznie zastąpi oldstring i oldstring1 we wszystkich plikach, które je zawierają, odpowiednio poprawnymi newstring i newstring1.

Pomija wszystkie katalogi i pliki, które nie zawierają starych ciągów.

Może to pomóc w wyeliminowaniu żmudnej pracy pisania w przypadku, gdy masz wiele katalogów z plikami, które wymagają wymiany ciągu znaków. Wszystko, co musisz zrobić, to przejść do każdego z tych katalogi, następnie uruchom:

#replace_string_files_present_dir

Wszystko, co musisz zrobić, to upewnić się, że dodałeś lub dodałeś wszystkie ciągi zastępcze, jak pokazałem ci powyżej:

replace "oldstring" "newstring" -- *

Na końcu pliku /bin / replace_string_files_present_dir.

Aby dodać nowy łańcuch zastępczy wystarczy otworzyć utworzony przez nas skrypt wpisując w terminalu:

sudo gedit /bin/replace_string_files_present_dir

Nie martw się o liczbę dodanych łańcuchów zastępczych, nie będą one miały wpływu, jeśli oldstring nie został znaleziony.

Chciałbym dodać notatkę, aby zrobić dwie rzeczy na raz - znaleźć plik, który zawiera ciąg znaków, a następnie wykonać zastąpienie, używając metody find 'chaining':

find  . -type f -iname \*.php -exec fgrep -l "www." {} \; -exec sed -i "s|www||g" {} \;      

• W tym przypadku usuń anachroniczne " www " z adresów URL znalezionych w plikach PHP.

• 'fgrep-l' uruchamia się tylko wtedy, gdy znajdzie co najmniej jedno dopasowanie w pliku, nie generuje innego wyjścia. Nie zapomnij o separatorach'\;'!