There really is a very simple and effective trick that makes the chains created in this way assemble perfectly, optimizing the code to the maximum:

• SEPARADORCreate an empty variable at the beginning and assign it at the end of each iteration:

JAVA WITHOUT USING THE TECHNIQUE

final String SEPARADOR = ",";
StringBuilder cadena = new StringBuilder("");
for (String s : listaDeStrings) {   
    if (cadena.equals("")) {
        cadena.append(s);
    } else {
        cadena.append(SEPARADOR);
        cadena.append(s);
    }
}

JAVA

String SEPARADOR = "";
StringBuilder cadena= new StringBuilder();
for (String s : listaDeStrings) {   
    cadena.append(SEPARADOR);
    cadena.append(s);
    SEPARADOR = ",";
}

JAVASCRIPT/JQUERY WITHOUT USING THE TECHNIQUE

var separador = ",";
var cadena= "";

$('.datos').each(function(index, value) {
    if (cadena === "") {
        cadena += separador + value.value;
    } else {
        cadena += separador + value.value;
        separador = ",";
    }
});

JAVASCRIPT/JQUERY

var separador = "";
var cadena = "";

$('.datos').each(function(index, value) {
    cadena += separador + value.value;
    separador = ",";
});

There it is for whoever wants to use it.

• Greatly visually improves clarity and readability
• Greatly improves performance
• Facilitates data integrity.

This is another way of looking at it.

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

And from there:

1. array.push()add an element to the array
2. array.join()concatenate 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 that works for all languages. Even within the same language, the optimal method may vary depending on the data structure where the data to be concatenated is.

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

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

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

If after implementing it you find that you need to improve performance, a possible option, if the way of traversing the data allows it, 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 looping through the data allow it to be done.

The other answers compare against an empty string. I don't understand if that is part of the definition of the problem. If it isn't, 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 laps. The least expensive is to trim the comma at the end.

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

Delete the trailing comma. A single operation once per row. Finish

Now that's the least of the problems some of the java and js demos have shown you inefficiency is the rule... You can do much more optimal things with C# or C, C++... But hey 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

Note that the result does not include any ', ' after David.