Solución:
Puede combinar ambas expresiones regulares usando un OR cláusula|):
var r="00001011100000".replace(/^0+|0+$/g, "");
//=> "10111"
actualizar: Las soluciones de expresiones regulares anteriores reemplazan 0 con una cadena vacía. Para evitar este problema, use esta expresión regular:
var repl = str.replace(/^0+(d)|(d)0+$/gm, '$1$2');
Demostración de RegEx
Ruptura de expresiones regulares:
-
^: Confirmar inicio -
0+: Coincide con uno o más ceros -
(d): Seguido de un dígito que se captura en el grupo de captura n. ° 1 -
|: O -
(d): Coincide con un dígito capturado en el grupo de captura n. ° 2 -
0+: Seguido de uno o más ceros -
$: Afirmar final
Reemplazo:
Aquí estamos usando dos referencias posteriores de los grupos de captura de remolque:
$1$2
Básicamente, coloca un dígito después de los ceros iniciales y un dígito antes de volver a los ceros finales en el reemplazo.
Suponiendo que siempre tendrá al menos un dígito en los datos de entrada, puede usar este patrón /^0*(d+?)0*$/ con exec() y acceder al grupo de captura única.
Esto usa solo un grupo de captura, sin alternativas (canalizaciones), y asegura al menos un dígito en la salida, y no busca múltiples coincidencias (no g).
El grupo de captura utiliza un cuantificador diferido y el 0s utilizan cuantificadores codiciosos para mejorar la eficiencia. Anclas iniciales y finales (^ y $) se utilizan para garantizar que toda la cadena coincida.
console.log('0001001000 => '+ /^0*(d+?)0*$/.exec("00100100")[1]);
console.log('001 => ' + /^0*(d+?)0*$/.exec("001")[1]);
console.log('100 => ' + /^0*(d+?)0*$/.exec("100")[1]);
console.log('1 => ' + /^0*(d+?)0*$/.exec("1")[1]);
console.log('0 => ' + /^0*(d+?)0*$/.exec("0")[1]);
console.log('11 => ' + /^0*(d+?)0*$/.exec("11")[1]);
console.log('00 => ' + /^0*(d+?)0*$/.exec("00")[1]);
console.log('111 => ' + /^0*(d+?)0*$/.exec("111")[1]);
console.log('000 => ' + /^0*(d+?)0*$/.exec("000")[1]);O puede cambiar la mitad del trabajo a + para lanzar la cadena a int (esto tiene el beneficio adicional de estabilizar la entrada cuando no hay longitud) y luego dejar replace manejar el recorte del lado derecho.
La única mirada atrás ((?<=d)) se utiliza para garantizar una longitud de salida mínima de uno. ¿Puedo usar: mirar atrás en expresiones regulares de JS?
console.log('0001001000 => ' + (+'0001001000'.replace(/(?<=d)0*$/, "")));
console.log('[empty] => ' + (+''.replace(/(?<=d)0*$/, "")));
console.log('001 => ' + (+'001'.replace(/(?<=d)0*$/, "")));
console.log('100 => ' + (+'100'.replace(/(?<=d)0*$/, "")));
console.log('1 => ' + (+'1'.replace(/(?<=d)0*$/, "")));
console.log('0 => ' + (+'0'.replace(/(?<=d)0*$/, "")));
console.log('11 => ' + (+'11'.replace(/(?<=d)0*$/, "")));
console.log('00 => ' + (+'00'.replace(/(?<=d)0*$/, "")));
console.log('111 => ' + (+'111'.replace(/(?<=d)0*$/, "")));
console.log('000 => ' + (+'000'.replace(/(?<=d)0*$/, "")));