This is another way of dealing with it.

In cases where you work with items, and you add them, the ideal is to use a array.

And from there:

1. array.push() adds an element in the array
2. array.join() concatenates all elements with a separator

Code

var separador = ',';
var items = []; //array vacío

for (var i = 0; i < 10; i++) {
    // agrega 1 elemento al array
    items.push(i);
}

//concatena con separador
var arrayManual = items.join(separador)

// mostrar el resultado
resultado.innerText = arrayManual;

<pre id="resultado"></pre>

There is no optimal method for all languages. Even within the same language, the optimal method may vary depending on the data structure where the data to concatenate is.

For 99% of programs, making code readable is more important than optimizing it. Make it readable first, and then optimize only if you verify that it is necessary.

• If the language has any function that does this, use it. It is the most readable and usually the most optimal. For example, in javascript it uses Array.join if the data is in an array.

• If not, just make it readable and don't worry about optimizing it for now. A if in the loop is readable, an empty variable that is updated in the loop as Jordi Castilla proposes in his answer as well. To prefer one method or another depends on each programmer.

If after implementing it you check that you need to improve performance, one possible option, if the way of traversing the data allows, is to take the first iteration out of the loop. For example:

List<String> listaConDatos = obtenerDatos();
StringBuffer resultado = new StringBuffer();
String separador = ",";

Iterator<String> it = listaConDatos.iterator();
if (it.hasNext()) {
  resultado.append(it.next());
  while (it.hasNext()) {
    resultado.append(separador);
    resultado.append(it.next());
  }
}

The problem is that this is clearly less readable, and not all ways of traversing the data allow it to be done.

The other answers compare to an empty string. I don't understand if that's part of the problem definition. If it is not, the following is my solution.

I usually use a variable boolean. Something like:

boolean primerElemento = false;
for (/* ... */) {
   if (primerElemento) {
      primerElemento = false;
   } else {
      buffer.append(",");
   }
   buffer.append(siguenteElemento);
}

Too many turns. The least expensive thing is to trim the comma at the end.

That's all, the larger the amount of data any 1-to-1 validation becomes too expensive, and it is precisely in that case when it needs to be optimal.

Clears the end comma. A single operation only once per row. End

Now that's the least of the problems some of the java and js demos that have shown you inefficiency is the rule... You can do things much more optimal with C # or C, C++... But well, you asked for something agnostic. There you have it .

In JAVA 8 we can do it like this:

public static void main(String[] args) {
    String[] array = {"Hola", "David"};
    System.out.println(concat(array));
}
public static String concat(String... strs) {
    StringJoiner joiner = new StringJoiner(", ");
    for (String str : strs) {
        joiner.add(str);
    }
    return joiner.toString();
}

The result will be: Hello, David

Notice that the result does not include any', ' behind David.