How can I convert an array into a comma separated string?

To make it easier to localize the change of IFS, use a function:

join () {
  local IFS="$1"
  shift
  echo "$*"
}

join , "${data[@]}"

There are a few ways to do this:

1. Join directly with printf (via Charles Duffy’s comment)

printf -v joined '%s,' "${data[@]}"
echo "${joined%,}"

The printf builtin implicitly joins arrays. You could print interactively like 3a below with a one-liner reading printf '%s,' "${data[@]}", but you'd be left with a trailing comma. (This method even works in POSIX shell, though you'd have to use $@ as your array since POSIX can't handle other array types).

2. Change the $IFS field separator (via chepner’s answer)

join_arr() {
  local IFS="$1"
  shift
  echo "$*"
}

join_arr , "${data[@]}"

This redefines the field separator within just the scope of this function so when the $data array is automatically expanded, it uses the desired delimiter instead of the first value of the global $IFS or (if it's empty or undefined) space.

This could be done without a function, but there's some nastiness about preserving $IFS: Charles Duffy notes that reverting IFS="$OLD_IFS" after temporarily reassigning it could evaluate to IFS="", but if $IFS was previously undefined, that's different from unset IFS and while it's possible to tease those apart, this functional approach is far cleaner thanks to its use of local to limit $IFS’s scope.

This solution only supports single-character delimiters. See #5 below for a similar function that supports delimiters of any length.

3a. Loop through its contents (and print incrementally)

delim=""
for item in "${data[@]}"; do
  printf "%s" "$delim$item"
  delim=","
done
echo # add a newline

If other code in that loop involves an external call (or even sleep 0.1), you'll actually watch this build piece by piece, which can be helpful in an interactive setting.

3b. Loop through its contents (and build a variable)

delim=""
joined=""
for item in "${data[@]}"; do
  joined="$joined$delim$item"
  delim=","
done
echo "$joined"

4. Save the array as a string and run replacement on it (note, the array must lack spaces*)

data_string="${data[*]}"
echo "${data_string//${IFS:0:1}/,}"

* This will only work if the first character of $IFS (space by default) does not exist in any of the array's items.

This uses bash pattern substitution: ${parameter//pattern/string} will replace each instance of pattern in $parameter with string. In this case, string is ${IFS:0:1}, the substring of $IFS starting at the beginning and ending after one character.

Z Shell (zsh) can do this in one nested parameter expansion:

echo "${${data[@]}//${IFS:0:1}/,}"

(Though Z Shell can also do it more elegantly with its dedicated join flag as echo "${(j:,:)data}" as noted by @DavidBaynard in a comment below this answer.)

5. Join with replacement in an implicit loop (via Nicholas Sushkin's answer to a duplicate question)

join_by() {
  local d="${1-}" f="${2-}"
  if shift 2; then
    printf %s "$f" "${@/#/$d}"
  fi
}

join_by , "${data[@]}"

This is very similar to #2 above (via chepner), but it uses pattern substitution rather than $IFS and therefore supports multi-character delimiters. $d saves the delimiter and $f saves the first item in the array (I'll say why in a moment). The real magic is ${@/#/$d}, which replaces the beginning (#) of each array element with the delimiter ($d). As you don't want to start with a delimiter, this uses shift to get past not only the delimiter argument but also the first array element (saved as $f), which is then printed right in front of the replacement.

printf has an odd behavior when you give it extra arguments as we do here. The template (%s) only specifies that there will be one argument, so the rest of the arguments act as if it's a loop and they're all concatenated onto each other. Consider changing that key line to printf "%s\n" "$f" "${@/#/$d}". You'll end up with a newline after each element. If you want a trailing newline after printing the joined array, do it with printf %s "$f" "${@/#/$d}" $'\n' (we need to use the $'…' notation to tell bash to interpret the escape; another way to do this would be to insert a literal newline, but then the code looks weird).