Remove duplicate $PATH entries with awk command

Question

I am trying to write a bash shell function that will allow me to remove duplicate copies of directories from my PATH environment variable.

I was told that it is possible to achieve this with a one line command using the awk command, but I cannot figure out how to do it. Anybody know how?

Answer 1

If you don't already have duplicates in the PATH and you only want to add directories if they are not already there, you can do it easily with the shell alone.

for x in /path/to/add …; do
  case ":$PATH:" in
    *":$x:"*) :;; # already there
    *) PATH="$x:$PATH";;
  esac
done

And here's a shell snippet that removes duplicates from $PATH. It goes through the entries one by one, and copies those that haven't been seen yet.

if [ -n "$PATH" ]; then
  old_PATH=$PATH:; PATH=
  while [ -n "$old_PATH" ]; do
    x=${old_PATH%%:*}       # the first remaining entry
    case $PATH: in
      *:"$x":*) ;;          # already there
      *) PATH=$PATH:$x;;    # not there yet
    esac
    old_PATH=${old_PATH#*:}
  done
  PATH=${PATH#:}
  unset old_PATH x
fi

Answer 2

Here's an intelligible one-liner solution that does all the right things: removes duplicates, preserves the ordering of paths, and doesn't add a colon at the end. So it should give you a deduplicated PATH that gives exactly the same behavior as the original:

PATH="$(perl -e 'print join(":", grep { not $seen{$_}++ } split(/:/, $ENV{PATH}))')"

It simply splits on colon (split(/:/, $ENV{PATH})), uses uses grep { not $seen{$_}++ } to filter out any repeated instances of paths except for the first occurrence, and then joins the remaining ones back together separated by colons and prints the result (print join(":", ...)).

If you want some more structure around it, as well as the ability to deduplicate other variables as well, try this snippet, which I'm currently using in my own config:

# Deduplicate path variables
get_var () {
    eval 'printf "%s\n" "${'"$1"'}"'
}
set_var () {
    eval "$1=\"\$2\""
}
dedup_pathvar () {
    pathvar_name="$1"
    pathvar_value="$(get_var "$pathvar_name")"
    deduped_path="$(perl -e 'print join(":",grep { not $seen{$_}++ } split(/:/, $ARGV[0]))' "$pathvar_value")"
    set_var "$pathvar_name" "$deduped_path"
}
dedup_pathvar PATH
dedup_pathvar MANPATH

That code will deduplicate both PATH and MANPATH, and you can easily call dedup_pathvar on other variables that hold colon-separated lists of paths (e.g. PYTHONPATH).

Answer 3

Here's a sleek one:

printf %s "$PATH" | awk -v RS=: -v ORS=: '!arr[$0]++'

Longer (to see how it works):

printf %s "$PATH" | awk -v RS=: -v ORS=: '{ if (!arr[$0]++) { print $0 } }'

Ok, since you're new to linux, here is how to actually set PATH without a trailing ":"

PATH=`printf %s "$PATH" | awk -v RS=: '{ if (!arr[$0]++) {printf("%s%s",!ln++?"":":",$0)}}'`

btw make sure to NOT have directories containing ":" in your PATH, otherwise it is gonna be messed up.

some credit to:

• this blog
• this thread

Answer 4

Here is an AWK one liner.

$ PATH=$(printf %s "$PATH" \
     | awk -vRS=: -vORS= '!a[$0]++ {if (NR>1) printf(":"); printf("%s", $0) }' )

where:

• printf %s "$PATH" prints the content of $PATH without a trailing newline
• RS=: changes the input record delimiter character (default is newline)
• ORS= changes the output record delimiter to the empty string
• a the name of an implicitly created array
• $0 references the current record
• a[$0] is a associative array dereference
• ++ is the post-increment operator
• !a[$0]++ guards the right hand side, i.e. it makes sure that the current record is only printed, if it wasn't printed before
• NR the current record number, starting with 1

That means that AWK is used to split the PATH content along the : delimiter characters and to filter out duplicate entries without modifying the order.

Since AWK associative arrays are implemented as hash tables the runtime is linear (i.e. in O(n)).

Note that we don't need look for quoted : characters because shells don't provide quoting to support directories with : in its name in the PATH variable.

Awk + paste

The above can be simplified with paste:

$ PATH=$(printf %s "$PATH" | awk -vRS=: '!a[$0]++' | paste -s -d:)

The paste command is used to intersperse the awk output with colons. This simplifies the awk action to printing (which is the default action).

Python

The same as Python two-liner:

$ PATH=$(python3 -c 'import os; from collections import OrderedDict; \
    l=os.environ["PATH"].split(":"); print(":".join(OrderedDict.fromkeys(l)))' )

Answer 5

As long as we are adding non-awk oneliners:

PATH=$(zsh -fc "typeset -TU P=$PATH p; echo \$P")

(Could be as simple as PATH=$(zsh -fc 'typeset -U path; echo $PATH') but zsh always reads at least one zshenv configuration file, which can modify PATH.)

It uses two nice zsh features:

• scalars tied to arrays (typeset -T)
• and arrays that autoremove duplicate values (typeset -U).

Answer 6

There has been a similar discussion about this here.

I take a bit of a different approach. Instead of just accepting the PATH that is set from all the different initialization files that get installed, I prefer using getconf to identify the system path and place it first, then add my preferred path order, then use awk to remove any duplicates. This may or may not really speed up command execution (and in theory be more secure), but it gives me warm fuzzies.

# I am entering my preferred PATH order here because it gets set,
# appended, reset, appended again and ends up in such a jumbled order.
# The duplicates get removed, preserving my preferred order.
#
PATH=$(command -p getconf PATH):/sbin:/usr/sbin:/usr/local/bin:/usr/local/sbin:$PATH
# Remove duplicates
PATH="$(printf "%s" "${PATH}" | /usr/bin/awk -v RS=: -v ORS=: '!($0 in a) {a[$0]; print}')"
export PATH

[~]$ echo $PATH
/bin:/usr/bin:/sbin:/usr/sbin:/usr/local/bin:/usr/local/sbin:/usr/lib64/ccache:/usr/games:/home/me/bin

Answer 7

As others have demonstrated it is possible in one line using awk, sed, perl, zsh, or bash, depends on your tolerance for long lines and readability. Here's a bash function that

• removes duplicates
• preserves order
• allows spaces in directory names
• allows you to specify the delimiter (defaults to ':')
• can be used with other variables, not just PATH
• works in bash versions < 4, important if you use OS X which for licensing issues does not ship bash version 4

bash function

remove_dups() {
    local D=${2:-:} path= dir=
    while IFS= read -d$D dir; do
        [[ $path$D =~ .*$D$dir$D.* ]] || path+="$D$dir"
    done <<< "$1$D"
    printf %s "${path#$D}"
}

usage

To remove dups from PATH

PATH=$(remove_dups "$PATH")

If path+="$D$dir" above is replaced with path="$path$D$dir", then this function also deduplicates entries correctly in zsh (in addition to bash). Without this change, a space will be inserted before every colon when this function is used in zsh.

Answer 8

PATH=`perl -e 'print join ":", grep {!$h{$_}++} split ":", $ENV{PATH}'`
export PATH

This uses perl and has several benefits:

1. It removes duplicates
2. It keeps sort order
3. It keeps the earliest appearance (/usr/bin:/sbin:/usr/bin will result in /usr/bin:/sbin)

Answer 9

Recent bash versions (>= 4) also of associative arrays, i.e. you can also use a bash 'one liner' for it:

PATH=$(IFS=:; set -f; declare -A a; NR=0; for i in $PATH; do NR=$((NR+1)); \
       if [ \! ${a[$i]+_} ]; then if [ $NR -gt 1 ]; then echo -n ':'; fi; \
                                  echo -n $i; a[$i]=1; fi; done)

where:

• IFS changes the input field separator to :
• declare -A declares an associative array
• ${a[$i]+_} is a parameter expansion meaning: _ is substituted if and only if a[$i] is set. This is similar to ${parameter:+word} which also tests for not-null. Thus, in the following evaluation of the conditional, the expression _ (i.e. a single character string) evaluates to true (this is equivalent to -n _) - while an empty expression evaluates to false.

Answer 10

PATH=`awk -F: '{for (i=1;i<=NF;i++) { if ( !x[$i]++ ) printf("%s:",$i); }}' <<< "$PATH"`

Explanation of awk code:

1. Separate the input by colons.
2. Append new path entries to associative array for fast duplicate look-up.
3. Prints the associative array.

In addition to being terse, this one-liner is fast: awk uses a chaining hash-table to achieve amortized O(1) performance.

based on Removing duplicate $PATH entries

Answer 11

Also sed (here using GNU sed syntax) can do the job:

MYPATH=$(printf '%s\n' "$MYPATH" | sed ':b;s/:\([^:]*\)\(:.*\):\1/:\1\2/;tb')

this one works well only in case first path is . like in dogbane's example.

In general case you need to add yet another s command:

MYPATH=$(printf '%s\n' "$MYPATH" | sed ':b;s/:\([^:]*\)\(:.*\):\1/:\1\2/;tb;s/^\([^:]*\)\(:.*\):\1/:\1\2/')

It works even on such construction:

$ echo "/bin:.:/foo/bar/bin:/usr/bin:/foo/bar/bin:/foo/bar/bin:/bar/bin:/usr/bin:/bin" \
| sed ':b;s/:\([^:]*\)\(:.*\):\1/:\1\2/;tb;s/^\([^:]*\)\(:.*\):\1/\1\2/'

/bin:.:/foo/bar/bin:/usr/bin:/bar/bin

Answer 12

This is my version:

path_no_dup () 
{ 
    local IFS=: p=();

    while read -r; do
        p+=("$REPLY");
    done < <(sort -u <(read -ra arr <<< "$1" && printf '%s\n' "${arr[@]}"));

    # Do whatever you like with "${p[*]}"
    echo "${p[*]}"
}

Usage: path_no_dup "$PATH"

Sample output:

rany$ v='a:a:a:b:b:b:c:c:c:a:a:a:b:c:a'; path_no_dup "$v"
a:b:c
rany$

Answer 13

The right way of removing duplicates suggested by @ghm1014 and @rush (in the comment) using sort:

PATH=`echo -e ${PATH//:/'\n'} | awk '{printf("%d|%s\n", NR, $0)}' | sort -t '|' -k 2 -u | sort -t '|' -k 1 -g | cut -f2 -d'|'`; export PATH=${PATH//[$'\n']/:}

Answer 14

Since people resorted to suggesting perl oneliners, I'll also throw a coin into the pot. This one is in ruby (and way less cryptic that everything else, IMO):

PATH="$(ruby -e 'puts ENV["PATH"].split(":").uniq.join(":")')"

Answer 15

Use awk to split the path on :, then loop over each field and store it in an array. If you come across a field which is already in the array, that means you have seen it before, so don't print it.

Here is an example:

$ MYPATH=.:/foo/bar/bin:/usr/bin:/foo/bar/bin
$ awk -F: '{for(i=1;i<=NF;i++) if(!($i in arr)){arr[$i];printf s$i;s=":"}}' <<< "$MYPATH"
.:/foo/bar/bin:/usr/bin

(Updated to remove the trailing :.)

Answer 16

A solution - not one that is as elegant as those that change the *RS variables, but perhaps reasonably clear:

PATH=`awk 'BEGIN {np="";split(ENVIRON["PATH"],p,":"); for(x=0;x<length(p);x++) {  pe=p[x]; if(e[pe] != "") continue; e[pe] = pe; if(np != "") np=np ":"; np=np pe}} END { print np }' /dev/null`

The entire program works in the BEGIN and END blocks. It pulls your PATH variable from the environment, splitting it into units. It then iterates over the resulting array p (which is created in order by split()). The array e is an associative array that is used to determine whether or not we've seen the current path element (e.g. /usr/local/bin) before, and if not, is appended to np, with logic to append a colon to np if there is already text in np. The END block simply echos np. This could be further simplified by adding the -F: flag, eliminating the third argument to split() (as it defaults to FS), and changing np = np ":" to np = np FS, giving us:

awk -F: 'BEGIN {np="";split(ENVIRON["PATH"],p); for(x=0;x<length(p);x++) {  pe=p[x]; if(e[pe] != "") continue; e[pe] = pe; if(np != "") np=np FS; np=np pe}} END { print np }' /dev/null

Naïvely, I believed that for(element in array) would preserve order, but it doesn’t, so my original solution doesn’t work, as folks would get upset if someone suddenly scrambled the order of their $PATH:

awk 'BEGIN {np="";split(ENVIRON["PATH"],p,":"); for(x in p) { pe=p[x]; if(e[pe] != "") continue; e[pe] = pe; if(np != "") np=np ":"; np=np pe}} END { print np }' /dev/null

Answer 17

export PATH=$(echo -n "$PATH" | awk -v RS=':' '(!a[$0]++){if(b++)printf(RS);printf($0)}')

Only the first occurrence is kept and relative order is well maintained.

Answer 18

(To explain @Michał Politowski 's answer:)

for zsh:

PATH=$(zsh --no-rcs -c "P_scaler=$PATH ; typeset -T P_scaler  P_array ;  typeset -U P_array ; echo \$P_scaler")

Answer 19

Here is a version I created a while back based on @Giles_'so stop being evil' answer above. However, my version ignores the case of the variables. This works for removing duplicates on case insensitive OSes like Windows and MacOS. Thus such things as "C:\Windows" and "C:\WINDOWS" are the same path.

low_PATH="$(tr '[:upper:]' '[:lower:]' <<<$PATH )"

if [ -n "$PATH" ]; then
  old_PATH=$PATH:; PATH= ; lPATH=
  while [ -n "$old_PATH" ]; do
    x=${old_PATH%%:*}       # the first remaining entry
    l=${low_PATH%%:*}       # The lowercase we compare
    case $lPATH: in
      *:"$l":*) ;;          # already there? Do nothing
      *) PATH=$PATH:$x      # not there yet? Add it
         lPATH=$lPATH:$l;;
    esac
    old_PATH=${old_PATH#*:} # Next entry
    low_PATH=${low_PATH#*:}
  done
  PATH=${PATH#:}
  unset old_PATH x low_PATH lPATH l
fi

Features:

• Removes duplicate paths
• Preserves order
• Ignores case
• Spaces in paths are allowed

May not work with all versions of Bash.

Answer 20

I would do it just with basic tools such as tr, sort and uniq:

NEW_PATH=`echo $PATH | tr ':' '\n' | sort | uniq | tr '\n' ':'`

If there is nothing special or weird in your path it should work