Unix one-liner to swap / wrap two lines in multiple text files?

With GNU awk:

awk '
FNR==NR {if(FNR==14) x=$0;if(FNR==26) y=$0;next} 
FNR==14 {$0=y} FNR==26 {$0=x} {print}
' file file > file_with_swap

      

        
        
        
      

    

Using the following helper script allows power find ... -exec ./script '{}' l1 l2 \;

to find target files and swap lines l1

and l2

in each file in place. (this requires that there are no identical duplicate lines in the file that fall within the search range). The script uses sed

to read two swap lines from each file into an indexed array and passes the lines before sed

to complete the swap by matching. The call sed

uses the "negotiated first address" to restrict the second expression exchange to the first occurrence. An example of using the helper script below to swap lines 5

and 15

across all matching files:

find . -maxdepth 1 -type f -name "lnum*" -exec ../swaplines.sh '{}' 5 15 \;

      

        
        
        
      

    

For example, calling the find

above found files lnumorig.txt

and lnumfile.txt

in the current directory initially containing:

$ head -n20 lnumfile.txt.bak
 1  A simple line of test in a text file.
 2  A simple line of test in a text file.
 3  A simple line of test in a text file.
 4  A simple line of test in a text file.
 5  A simple line of test in a text file.
 6  A simple line of test in a text file.
<snip>
14  A simple line of test in a text file.
15  A simple line of test in a text file.
16  A simple line of test in a text file.
17  A simple line of test in a text file.
18  A simple line of test in a text file.
19  A simple line of test in a text file.
20  A simple line of test in a text file.

      

        
        
        
      

    

And I swapped the lines 5

and 15

by purpose:

$ head -n20 lnumfile.txt
 1  A simple line of test in a text file.
 2  A simple line of test in a text file.
 3  A simple line of test in a text file.
 4  A simple line of test in a text file.
15  A simple line of test in a text file.
 6  A simple line of test in a text file.
<snip>
14  A simple line of test in a text file.
 5  A simple line of test in a text file.
16  A simple line of test in a text file.
17  A simple line of test in a text file.
18  A simple line of test in a text file.
19  A simple line of test in a text file.
20  A simple line of test in a text file.

      

        
        
        
      

    

The helper script itself:

#!/bin/bash

[ -z $1 ] && {              # validate requierd input (defaults set below)
    printf "error: insufficient input calling '%s'. usage: file [line1 line2]\n" "${0//*\//}" 1>&2
    exit 1
}

l1=${2:-10}                 # default/initialize line numbers to swap
l2=${3:-15}

while IFS=$'\n' read -r line; do  # read lines to swap into indexed array
    a+=( "$line" ); 
done <<<"$(sed -n $((l1))p "$1" && sed -n $((l2))p "$1")"

((${#a[@]} < 2)) && {       # validate 2 lines read
    printf "error: requested lines '%d & %d' not found in file '%s'\n" $l1 $l2 "$1"
    exit 1
}

                            # swap lines in place with sed (remove .bak for no backups)
sed -i.bak -e "s/${a[1]}/${a[0]}/" -e "0,/${a[0]}/s/${a[0]}/${a[1]}/" "$1"

exit 0

      

        
        
        
      

    

Even though I didn't manage to do all of this in one liner , I decided it was worth posting it if you can use it or take ideas from it. Note: if you are using it, please check your satisfaction before disabling it on your system. The script is currently used sed -i.bak ...

to create backup copies of files modified for testing purposes. You can delete .bak

when satisfied, which suits your needs.

If you are not using to set the default swap lines in the helper script itself, I would change the first check of the check to [ -z $1 -o -z $2 -o $3 ]

to provide all the required arguments if the script.

While it identifies the lines to be replaced with a number , it relies on a direct match of each line to perform the swap. This means that any identical duplicate lines to the end of the swap range will cause an unintentional match and will not replace the intended lines. This is part of the limitation imposed by not keeping every line in the range of lines to be exchanged, as described in the comments. This is a compromise. There are many, many ways to approach this, each with their own advantages and disadvantages. Let me know if you have any questions.

Brute force method

In your comment, I revisited the script helper to use the brute-fourth copy / swap method, which will fix the problem with any duplicate lines in the search range. This helper gets lines through sed

as in the original, but then reads all lines from file

to tmpfile

, replacing the corresponding numbered lines when found. After filling, tmpfile

it is copied to the original file

and tmpfile

deleted.

#!/bin/bash

[ -z $1 ] && {              # validate requierd input (defaults set below)
    printf "error: insufficient input calling '%s'. usage: file [line1 line2]\n" "${0//*\//}" 1>&2
    exit 1
}

l1=${2:-10}                 # default/initialize line numbers to swap
l2=${3:-15}

while IFS=$'\n' read -r line; do  # read lines to swap into indexed array
    a+=( "$line" ); 
done <<<"$(sed -n $((l1))p "$1" && sed -n $((l2))p "$1")"

((${#a[@]} < 2)) && {       # validate 2 lines read
    printf "error: requested lines '%d & %d' not found in file '%s'\n" $l1 $l2 "$1"
    exit 1
}

                            # create tmpfile, set trap, truncate
fn="$1"
rmtemp () { cp "$tmpfn" "$fn"; rm -f "$tmpfn"; }
trap rmtemp SIGTERM SIGINT EXIT

declare -i n=1
tmpfn="$(mktemp swap_XXX)"
:> "$tmpfn"

                            # swap lines in place with a tmpfile
while IFS=$'\n' read -r line; do

    if ((n == l1)); then
        printf "%s\n" "${a[1]}" >> "$tmpfn"
    elif ((n == l2)); then
        printf "%s\n" "${a[0]}" >> "$tmpfn"
    else
        printf "%s\n" "$line" >> "$tmpfn"
    fi
    ((n++))

done < "$fn"

exit 0

      

        
        
        
      

    

if you want to swap two lines create script "swap.sh"

#!/bin/sh
sed -n "1,$((${2}-1))p" "$1"
sed -n "${3}p" "$1"
sed -n "$((${2}+1)),$((${3}-1))p" "$1"
sed -n "${2}p" "$1"
sed -n "$((${3}+1)),\$p" "$1"

      

        
        
        
      

    

Further

sh swap.sh infile_name 14 26 > outfile_name

      

        
        
        
      

    

If the line numbers to be swapped have been corrected, you can try something like the command sed

in the following example to have the lines swapped with multiple files in place:

#!/bin/bash

# prep test files
for f in a b c ; do
    ( for i in {1..30} ; do echo $f$i ; done ) > /tmp/$f
done

sed -i -s -e '14 {h;d}' -e '15 {N;N;N;N;N;N;N;N;N;N;G;x;d}' -e '26 G' /tmp/{a,b,c}
# -i: inplace editing
# -s: treat each input file separately
# 14 {h;d} # first swap line: hold ; suppress
# 15 {N;N;...;G;x;d} # lines between: collect, append held line; hold result; suppress
# 26 G # second swap line: append held lines (and output them all)

# dump test files
cat /tmp/{a,b,c}

      

        
        
        
      

    

(This is consistent with Ethan Reisner's comment.)