Как я могу получить уникальные значения из массива в Bash?

У меня почти такой же вопрос, как здесь .

У меня есть массив, который содержит aa ab aa ac aa adи т.д. Теперь я хочу выбрать все уникальные элементы из этого массива. Думал, это будет просто с sort | uniqили с, sort -uкак они упоминали в этом другом вопросе, но в массиве ничего не изменилось ... Код:

echo `echo "${ids[@]}" | sort | uniq`

Что я делаю не так?

Немного взломано, но это должно сработать:

echo "${ids[@]}" | tr ' ' '\n' | sort -u | tr '\n' ' '

Чтобы сохранить отсортированные уникальные результаты обратно в массив, выполните Array assignment :

sorted_unique_ids=($(echo "${ids[@]}" | tr ' ' '\n' | sort -u | tr '\n' ' '))

Если ваша оболочка поддерживает herestrings ( bashследует), вы можете избавить echoпроцесс, изменив его на:

tr ' ' '\n' <<< "${ids[@]}" | sort -u | tr '\n' ' '

Вход:

ids=(aa ab aa ac aa ad)

Выход:

aa ab ac ad

Пояснение:

• "${ids[@]}"- Синтаксис для работы с массивами оболочки, независимо от того, используются ли они как часть echoили как строка. В @части означает «все элементы в массиве»
• tr ' ' '\n'- Преобразуйте все пробелы в символы новой строки. Поскольку ваш массив рассматривается оболочкой как элементы в одной строке, разделенные пробелами; и потому, что sort ожидает ввода в отдельные строки.
• sort -u - сортировать и сохранять только уникальные элементы
• tr '\n' ' ' - преобразовать символы новой строки, которые мы добавили ранее, обратно в пробелы.
• $(...)- Подмена команд
• Кроме того: tr ' ' '\n' <<< "${ids[@]}"это более эффективный способ:echo "${ids[@]}" | tr ' ' '\n'

Если вы используете Bash версии 4 или выше (что должно быть в любой современной версии Linux), вы можете получить уникальные значения массива в bash, создав новый ассоциативный массив, содержащий каждое из значений исходного массива. Что-то вроде этого:

$ a=(aa ac aa ad "ac ad")
$ declare -A b
$ for i in "${a[@]}"; do b["$i"]=1; done
$ printf '%s\n' "${!b[@]}"
ac ad
ac
aa
ad

Это работает, потому что в любом массиве (ассоциативном или традиционном, на любом языке) каждый ключ может появляться только один раз. Когда forцикл достигает второго значения aain a[2], он перезаписывает то, b[aa]что было изначально установлено для a[0].

Выполнение чего-либо в собственном bash может быть быстрее, чем с использованием каналов и внешних инструментов, таких как sortи uniq, хотя для больших наборов данных вы, вероятно, увидите лучшую производительность, если будете использовать более мощный язык, такой как awk, python и т. Д.

Если вы чувствуете себя уверенно, вы можете избежать forцикла, используя printfвозможность повторно использовать свой формат для нескольких аргументов, хотя это, кажется, требуется eval. (Прекратите читать, если вас это устраивает.)

$ eval b=( $(printf ' ["%s"]=1' "${a[@]}") )
$ declare -p b
declare -A b=(["ac ad"]="1" [ac]="1" [aa]="1" [ad]="1" )

Причина, по которой требуется это решение, evalзаключается в том, что значения массива определяются до разделения слов. Это означает, что результат подстановки команды считается одним словом, а не набором пар ключ = значение.

Хотя здесь используется подоболочка, для обработки значений массива используются только встроенные функции bash. Обязательно оценивайте свое использование evalкритически. Если вы не уверены на 100%, что Чепнер, Гленн Джекман или Грейкэт не найдут ошибок в вашем коде, используйте вместо этого цикл for.

Я понимаю, что на этот вопрос уже был дан ответ, но он оказался довольно высоко в результатах поиска и может кому-то помочь.

printf "%s\n" "${IDS[@]}" | sort -u

Пример:

~> IDS=( "aa" "ab" "aa" "ac" "aa" "ad" )
~> echo  "${IDS[@]}"
aa ab aa ac aa ad
~>
~> printf "%s\n" "${IDS[@]}" | sort -u
aa
ab
ac
ad
~> UNIQ_IDS=($(printf "%s\n" "${IDS[@]}" | sort -u))
~> echo "${UNIQ_IDS[@]}"
aa ab ac ad
~>

Если в ваших элементах массива есть пробел или какой-либо другой специальный символ оболочки (и можете ли вы быть уверены, что они отсутствуют?), То, чтобы захватить их в первую очередь (и вы всегда должны делать это), выразите свой массив в двойных кавычках! напр "${a[@]}". Bash буквально интерпретирует это как «каждый элемент массива в отдельном аргументе ». В bash это всегда работает, всегда.

Затем, чтобы получить отсортированный (и уникальный) массив, мы должны преобразовать его в формат, понятный для сортировки, и иметь возможность преобразовать его обратно в элементы массива bash. Это лучшее, что я придумал:

eval a=($(printf "%q\n" "${a[@]}" | sort -u))

К сожалению, это не удается в частном случае пустого массива, превращая пустой массив в массив из 1 пустого элемента (потому что printf имеет 0 аргументов, но все равно печатает, как если бы он имел один пустой аргумент - см. Объяснение). Так что вы должны уловить это в if или чем-то подобном.

Объяснение: Формат% q для printf "экранирует оболочку" напечатанного аргумента, точно так же, как bash может восстановить что-то вроде eval! Поскольку каждый элемент печатается оболочкой с экранированием на собственной строке, единственным разделителем между элементами является новая строка, а присвоение массива принимает каждую строку как элемент, анализируя экранированные значения в буквальный текст.

например

> a=("foo bar" baz)
> printf "%q\n" "${a[@]}"
'foo bar'
baz
> printf "%q\n"
''

Eval необходим для удаления экранирования каждого значения, возвращаемого в массив.

'sort' может использоваться для упорядочивания вывода цикла for:

for i in ${ids[@]}; do echo $i; done | sort

и удалите дубликаты с помощью "-u":

for i in ${ids[@]}; do echo $i; done | sort -u

Наконец, вы можете просто перезаписать свой массив уникальными элементами:

ids=( `for i in ${ids[@]}; do echo $i; done | sort -u` )

этот тоже сохранит порядок:

echo ${ARRAY[@]} | tr [:space:] '\n' | awk '!a[$0]++'

и изменить исходный массив уникальными значениями:

ARRAY=($(echo ${ARRAY[@]} | tr [:space:] '\n' | awk '!a[$0]++'))

Чтобы создать новый массив, состоящий из уникальных значений, убедитесь, что ваш массив не пуст, а затем выполните одно из следующих действий:

Удалить повторяющиеся записи (с сортировкой)

readarray -t NewArray < <(printf '%s\n' "${OriginalArray[@]}" | sort -u)

Удалить повторяющиеся записи (без сортировки)

readarray -t NewArray < <(printf '%s\n' "${OriginalArray[@]}" | awk '!x[$0]++')

Предупреждение: не пытайтесь сделать что-то вроде NewArray=( $(printf '%s\n' "${OriginalArray[@]}" | sort -u) ). Он разбивается о пробелы.

номер кошки.txt

1 2 3 4 4 3 2 5 6

вывести строку в столбец: cat number.txt | awk '{for(i=1;i<=NF;i++) print $i}'

1
2
3
4
4
3
2
5
6

найти повторяющиеся записи: cat number.txt | awk '{for(i=1;i<=NF;i++) print $i}' |awk 'x[$0]++'

4
3
2

Заменить повторяющиеся записи: cat number.txt | awk '{for(i=1;i<=NF;i++) print $i}' |awk '!x[$0]++'

1
2
3
4
5
6

Найдите только записи Uniq: cat number.txt | awk '{for(i=1;i<=NF;i++) print $i|"sort|uniq -u"}

1
5
6

Без потери первоначального заказа:

uniques=($(tr ' ' '\n' <<<"${original[@]}" | awk '!u[$0]++' | tr '\n' ' '))

Если вам нужно решение, которое использует только внутренние компоненты bash, вы можете установить значения как ключи в ассоциативном массиве, а затем извлечь ключи:

declare -A uniqs
list=(foo bar bar "bar none")
for f in "${list[@]}"; do 
  uniqs["${f}"]=""
done

for thing in "${!uniqs[@]}"; do
  echo "${thing}"
done

Это выведет

bar
foo
bar none

Другой вариант работы со встроенными пробелами - разделить нуль с помощью printf, выделить с помощью sort, а затем использовать цикл, чтобы упаковать его обратно в массив:

input=(a b c "$(printf "d\ne")" b c "$(printf "d\ne")")
output=()

while read -rd $'' element
do 
  output+=("$element")
done < <(printf "%s\0" "${input[@]}" | sort -uz)

В конце этого, inputи outputсодержат нужные значения ( при условии , порядок не важен):

$ printf "%q\n" "${input[@]}"
a
b
c
$'d\ne'
b
c
$'d\ne'

$ printf "%q\n" "${output[@]}"
a
b
c
$'d\ne'

Как насчет этого варианта?

printf '%s\n' "${ids[@]}" | sort -u

Попробуйте это, чтобы получить значения uniq для первого столбца в файле

awk -F, '{a[$1];}END{for (i in a)print i;}'

# Read a file into variable
lines=$(cat /path/to/my/file)

# Go through each line the file put in the variable, and assign it a variable called $line
for line in $lines; do
  # Print the line
  echo $line
# End the loop, then sort it (add -u to have unique lines)
done | sort -u