dividir la cadena en dos en un índice dado y devolver ambas partes

Tengo una cadena que necesito dividir en un índice dado y luego devolver ambas partes, separadas por una coma. Por ejemplo:

string: 8211 = 8,211
        98700 = 98,700

Entonces necesito poder dividir la cadena en cualquier índice dado y luego devolver ambas mitades de la cadena. Los métodos integrados parecen realizar la división pero solo devuelven una parte de la división.

string.slice solo devuelve la parte extraída de la cadena. string.split solo le permite dividir en caracteres, no en la cadena de índice.substring hace lo que necesito pero solo devuelve la subcadena string.substr muy similar, aún solo devuelve la subcadena

Prueba esto

function split_at_index(value, index)
{
 return value.substring(0, index) + "," + value.substring(index);
}

console.log(split_at_index('3123124', 2));

ES6 1 revestimiento

// :: splitAt = number => Array<any>|string => Array<Array<any>|string>
const splitAt = index => x => [x.slice(0, index), x.slice(index)]

console.log(
  splitAt(1)('foo'), // ["f", "oo"]
  splitAt(2)([1, 2, 3, 4]) // [[1, 2], [3, 4]]
)
  

Puede expandirlo fácilmente para dividirlo en múltiples índices y tomar una matriz o cadena

const splitOn = (slicable, ...indices) =>
  [0, ...indices].map((n, i, m) => slicable.slice(n, m[i + 1]));

splitOn('foo', 1);
// ["f", "oo"]

splitOn([1, 2, 3, 4], 2);
// [[1, 2], [3, 4]]

splitOn('fooBAr', 1, 4);
//  ["f", "ooB", "Ar"]

rastreador de problemas de lodash: https://github.com/lodash/lodash/issues/3014

También puede utilizar el formateador de números JS disponible en

https://code.google.com/p/javascript-number-formatter/

Opciones de formato

http://jsfiddle.net/chauhangs/hUE3h/

  format("##,###.", 98700)
  format("#,###.", 8211)

¿Algo como esto?...

 function stringConverter(varString, varCommaPosition)
 {
   var stringArray = varString.split("");
   var outputString = '';
   for(var i=0;i<stringArray.length;i++)
   {
     if(i == varCommaPosition)
      {
        outputString = outputString + ',';
      }

     outputString = outputString + stringArray[i];
   }  

   return outputString;
 }

También puedes hacerlo así.
https://jsfiddle.net/Devashish2910/8hbosLj3/1/#&togetherjs=iugeGcColp

var str, result;
str = prompt("Enter Any Number");

var valueSplit = function (value, length) {
    if (length < 7) {
        var index = length - 3;
        return str.slice(0, index) + ',' + str.slice(index);
    }
    else if (length < 10 && length > 6) {
        var index1, index2;
        index1 = length - 6;
        index2 = length - 3;
        return str.slice(0,index1) + "," + str.slice(index1,index2) + "," + str.slice(index2);
    }
}

result = valueSplit(str, str.length);
alert(result);

Si la elegancia del código ocupa un lugar más alto que el impacto de rendimiento de las expresiones regulares, entonces

'1234567'.match(/^(.*)(.{3})/).slice(1).join(',')
=> "1234,567"

Hay mucho espacio para modificar aún más la expresión regular para que sea más preciso.

Si join()no funciona, es posible que deba usar mapcon un cierre, momento en el que las otras respuestas aquí pueden ser menos bytes y ruido de línea.

function splitText(value, index) {
  if (value.length < index) {return value;} 
  return [value.substring(0, index)].concat(splitText(value.substring(index), index));
}
console.log(splitText('this is a testing peace of text',10));
// ["this is a ", "testing pe", "ace of tex", "t"] 

Para aquellos que quieran dividir un texto en una matriz usando el índice.

Si quieres un truco de una sola línea usando expresiones regulares y cadenas interpoladas ...

const splitString = (value, idx) => value.split(new RegExp(`(?<=^.{${idx}})`));
console.log(splitString('abcdefgh', 5));

Este código dice dividir la cadena reemplazando el valor devuelto en la expresión regular. La expresión regular devuelve una posición, no un carácter, por lo que no perdemos caracteres en la cadena inicial. La forma en que lo hace es encontrar la posición, a través de una mirada atrás y la^ ancla, donde había indexcaracteres desde el principio de la cadena.

Para resolver su problema propuesto de agregar comas cada tercera posición desde el final, la expresión regular sería ligeramente diferente y usaríamos reemplazar en lugar de dividir.

const values = [ 8211, 98700, 1234567890 ];
const addCommas = (value, idx) => value.replace(new RegExp(`(?=(.{${idx}})+$)`, 'g'), ',');

console.log(values.map(v => addCommas(v.toString(), 3)));

Aquí encontramos la idxposición th desde el final usando una mirada hacia adelante y el $ancla, pero también capturamos cualquier número de esos conjuntos de posiciones desde el final. Luego reemplazamos la posición con una coma. Usamos la gbandera (global) para que reemplace cada ocurrencia, no solo la primera encontrada.