как преобразовать строку в массив символов? [Дубликат]

Самое простое, полное и изящное решение:

$ read -a ARRAY <<< $(echo "abcdefg" | sed 's/./& /g')  

и test

$ echo ${ARRAY[0]}
  a

$ echo ${ARRAY[1]}
  b

Объяснение : read -a читает stdin as массив и присваивает его переменной ARRAY для обработки пробелов в качестве разделителя для каждого элемента массива.

Оценка повторения строки для sed просто добавляет необходимые пробелы между каждым символом.

Мы используем Здесь String (& lt; & lt; & lt; & lt;) для подачи stdin команды чтения.

Вы можете получить доступ к каждой букве отдельно уже без преобразования массива:

$ foo="bar"
$ echo ${foo:0:1}
b
$ echo ${foo:1:1}
a
$ echo ${foo:2:1}
r

Если этого недостаточно, вы можете использовать что-то вроде этого:

$ bar=($(echo $foo|sed  's/\(.\)/\1 /g'))
$ echo ${bar[1]}
a

Если вы можете 't даже использовать sed или что-то в этом роде, вы можете использовать первый метод выше в сочетании с циклом while, используя длину исходной строки (${#foo}) для сборки массива.

Внимание: код ниже не работает, если строка содержит пробелы. Я думаю, что ответ Вон Катона имеет больше шансов выжить со специальными символами.

thing=($(i=0; while [ $i -lt ${#foo} ] ; do echo ${foo:$i:1} ; i=$((i+1)) ; done))

Для тех, кто приземлился здесь, чтобы узнать, как это сделать в fish :

Мы можем использовать встроенную команду string (начиная с v2.3.0) для обработки строк.

↪ string split '' abc
a
b
c

Выход представляет собой список, поэтому операции массива будут работать.

↪ for c in (string split '' abc)
      echo char is $c
  end
char is a
char is b
char is c

Вот более сложный пример, повторяющий строку с индексом.

↪ set --local chars (string split '' abc)
  for i in (seq (count $chars))
      echo $i: $chars[$i]
  end
1: a
2: b
3: c

string=hello123

for i in $(seq 0 ${#string})
    do array[$i]=${string:$i:1}
done

echo "zero element of array is [${array[0]}]"
echo "entire array is [${array[@]}]"

Нулевой элемент массива - [h]. Весь массив - [h e l l o 1 2 3 ].

Если текст может содержать пробелы:

eval a=( $(echo "this is a test" | sed "s/\(.\)/'\1' /g") )

Если вы хотите сохранить это в массиве, вы можете сделать это:

string=foo
unset chars
declare -a chars
while read -N 1
do
    chars[${#chars[@]}]="$REPLY"
done <<<"$string"x
unset chars[$((${#chars[@]} - 1))]
unset chars[$((${#chars[@]} - 1))]

echo "Array: ${chars[@]}"
Array: f o o
echo "Array length: ${#chars[@]}"
Array length: 3

Конечный x необходим для обработки факта добавления новой строки после $string, если это не содержит.

Если вы хотите использовать символы, разделенные NUL, вы можете попробовать следующее:

echo -n "$string" | while read -N 1
do
    printf %s "$REPLY"
    printf '\0'
done

Как ответ на Alexandro de Oliveira, я считаю следующее более элегантным или, по крайней мере, более интуитивным:

while read -r -n1 c ; do arr+=("$c") ; done <<<"hejsan"

В качестве альтернативы итерации по 0 .. ${#string}-1 с циклом for / while есть два других способа, с которыми я могу думать: только bash : используя =~ и используя printf ]. (Существует третья возможность использования выражения eval и {..} последовательности, но это не имеет ясности.)

С правильной средой и поддержкой NLS в bash они будут работать с не-ASCII, как можно надеяться, удаляя потенциальные источники сбоев со старыми системными инструментами, такими как sed, если это вызывает беспокойство.

Используя =~ и регулярные выражения, преобразуя строку в массив в одном выражении:

string="wonkabars"
[[ "$string" =~ ${string//?/(.)} ]]       # splits into array
printf "%s\n" "${BASH_REMATCH[@]:1}"      # loop free: reuse fmtstr
declare -a arr=( "${BASH_REMATCH[@]:1}" ) # copy array for later

Способ это работает, чтобы выполнить расширение string, которое заменяет каждый отдельный символ для (.), а затем сопоставляет это сгенерированное регулярное выражение с группировкой для захвата каждого отдельного символа в BASH_REMATCH[]. Индекс 0 установлен на всю строку, так как этот специальный массив доступен только для чтения, вы не можете его удалить, обратите внимание на :1, когда массив расширен, чтобы пропустить индекс 0, если это необходимо. Некоторые быстрые тесты для нетривиальных строк (> 64 символа) показывают, что этот метод существенно быстрее, чем один, используя операции bash и операции с массивом.

Вышеупомянутое будет работать со строками, содержащими строки новой строки , =~ поддерживает POSIX ERE, где . по умолчанию совпадает с чем-либо, кроме NUL , то есть регулярное выражение скомпилировано без REG_NEWLINE. (Поведение POSIX-обработки текста утилит по умолчанию по-разному отличается и обычно является.)

Вторая опция, используя printf:

string="wonkabars"
ii=0
while printf "%s%n" "${string:ii++:1}" xx; do 
  ((xx)) && printf "\n" || break
done 

Этот цикл увеличивает индекс ii для печати одного символа за раз и разрывается, когда символов нет. Это было бы еще проще, если bash printf вернул количество символов, напечатанных (как на C), а не статус ошибки, вместо этого количество напечатанных символов будет записано в xx с помощью %n. (Это работает как минимум до bash-2.05b.)

С bash-3.1 и printf -v var у вас немного больше гибкости и вы можете избежать падения с конца строки, если вы будете делать что-то, кроме печати символов, например для создания массива:

declare -a arr
ii=0
while printf -v cc "%s%n" "${string:(ii++):1}" xx; do 
    ((xx)) && arr+=("$cc") || break
done

Если ваша строка хранится в переменной x, это создает массив y с отдельными символами:

i=0
while [ $i -lt ${#x} ]; do y[$i]=${x:$i:1};  i=$((i+1));done

AWK весьма удобен:

a='123'; echo $a | awk 'BEGIN{FS="";OFS=" "} {print $1,$2,$3}'

, где FS и OFS являются разделителем для чтения и распечатки