ultimo - split javascript array

Recortar el carácter específico de una cadena

Question

¿Cuál es el JavaScript equivalente a este método de C# ?

var x = "|f|oo||";
var y = x.Trim(''|''); // "f|oo"

C # recorta el personaje seleccionado solo al principio y al final de la cadena!

Answer 1

Éste arregla todos los delímetros delanteros y finales

const trim = (str, delimiter) => {
const pattern = `[^//${delimiter}]`;
const start = str.search(pattern);
const stop = str.length - str.split('''').reverse().join('''').search(pattern);
return str.substring(start, stop);
}
const test = ''||2|aaaa12bb3ccc|||||'';
console.log(trim(test, ''|'')); // 2|aaaa12bb3ccc

Answer 2

Esto puede recortar varios personajes a la vez:

String.prototype.trimChars = function (c) {
var re = new RegExp("^[" + c + "]+|[" + c + "]+$", "g");
return this.replace(re,"");
}
var x = "|f|oo||";
x = x.trimChars(''|''); // f|oo
var y = "..++|f|oo||++..";
y = y.trimChars(''|.+''); // f|oo
var z = "//f|oo//"; // /f|oo/
// For backslash, remember to double-escape:
z = z.trimChars("////"); // f|oo

Answer 3

Prueba esto:

var x = "|f|oo||";
var y = x.slice(1, 5, 7); ---> y=f|oo

Answer 4

Puede usar una expresión regular como:

var x = "|f|oo||";
var y = x.replace(/^[/|]+|[/|]+$/g, "");
alert(y); // f|oo

ACTUALIZAR:

Si desea generalizar esto en una función, puede hacer lo siguiente:

var escapeRegExp = function(strToEscape) {
// Escape special characters for use in a regular expression
return strToEscape.replace(/[/-/[/]///{/}/(/)/*/+/?/.///^/$/|]/g, "//$&");
};
var trimChar = function(origString, charToTrim) {
charToTrim = escapeRegExp(charToTrim);
var regEx = new RegExp("^[" + charToTrim + "]+|[" + charToTrim + "]+$", "g");
return origString.replace(regEx, "");
};
var x = "|f|oo||";
var y = trimChar(x, "|");
alert(y); // f|oo

Answer 5

Que yo sepa, jQuery no tiene una función incorporada del método que está preguntando. Sin embargo, con Javascript, puede usar replace para cambiar el contenido de su cadena:

x.replace(/|/i, ""));

Esto reemplazará todas las ocurrencias de | sin nada.

Answer 6

Regex parece demasiado complejo para un problema simple como Trim?

DO#

var x = "|f|oo||";
var y = x.Trim(''|''); // "f|oo"

Ejemplo de Javascript, x.TrimLeft (''|'') - simple (pero recorta solo un carácter)

var ltrim = "|";
var x = "|f|oo||";
var y = (x.startsWith(ltrim) ? x.substring(ltrim.length) : x); // "f|oo||"
var result = y;
console.log(y);

Ejemplo completo de Javascript (gracias a la respuesta de @Tobo)

String.prototype.trimStart = function(delimiter) {
if (!delimiter) {
return this.replace(/^/s+/gm, '''');
}
var current = this; var index = this.length;
while(current.startsWith(delimiter) && index >= 0) {
current = current.substring(delimiter.length);
--index;
}
return current;
};
String.prototype.reverse = function() {
return this.split("").reverse().join("");
}
String.prototype.trimEnd = function(delimiter) {
if (!delimiter) {
return this.reverse().replace(/^/s+/gm, '''').reverse();
}
var current = this; var index = this.length;
while(current.endsWith(delimiter) && index >= 0) {
current = current.substring(0, this.length - delimiter.length - 1);
--index;
}
return current;
};
String.prototype.trimString = function(delimiter) {
if (!delimiter) {
return this.trim();
}
return this.trimStart(delimiter).trimEnd(delimiter);
};
var str = "|f|oo||";
var strWhitespace = " |f|oo|| ";
console.log("/*" + str.trimStart("|") + "*/", "/"" + str + "/".trimStart(/"|/");");
console.log("/*" + str.trimEnd("|") + "*/", "/"" + str + "/".trimEnd(/"|/");");
console.log("/*" + str.trimString("|") + "*/", "/"" + str + "/".trimString(/"|/");");
console.log("/*" + strWhitespace.trimStart() + "*/", "/"" + strWhitespace + "/".trimStart();");
console.log("/*" + strWhitespace.trimEnd() + "*/", "/"" + strWhitespace + "/".trimEnd();");
console.log("/*" + strWhitespace.trimString() + "*/", "/"" + strWhitespace + "/".trimString();");

Estaba un poco flojo con trimStart y trimEnd. Sería más eficiente encontrar cuánto de cada lado necesita recortar. Luego llame a la subcadena solo una vez. ¡Pero espero que entiendas la idea y esto es útil!

Answer 7

Si lo entendí bien, desea eliminar un carácter específico solo si está al principio o al final de la cadena (por ejemplo: "|| fo || oo ||||" debería convertirse en "foo || oo") . Puede crear una función ad hoc de la siguiente manera:

function trimChar(string, charToRemove) {
while(string.charAt(0)==charToRemove) {
string = string.substring(1);
}
while(string.charAt(string.length-1)==charToRemove) {
string = string.substring(0,string.length-1);
}
return string;
}

Probé esta función con el siguiente código:

var str = "|f|oo||";
$( "#original" ).html( "Original String: ''" + str + "''" );
$( "#trimmed" ).html( "Trimmed: ''" + trimChar(str, "|") + "''" );

Answer 8

Una línea es suficiente:

var x = ''|f|oo||'';
var y = x.replace(/^/|+|/|+$/g, '''');
document.write(x + ''<br />'' + y);

^/|+ beginning of the string, pipe, one or more times
| or
/|+$ pipe, one or more times, end of the string

En una función:

function trim (s, c) {
if (c === "]") c = "//]";
if (c === "//") c = "////";
return s.replace(new RegExp(
"^[" + c + "]+|[" + c + "]+$", "g"
), "");
}
s = ".foo..oo...";
console.log(s, "->", trim(s, "."));
s = "|foo||oo|||";
console.log(s, "->", trim(s, "|"));
s = "]foo]]oo]]]";
console.log(s, "->", trim(s, "]"));
s = "//foo////oo//////";
console.log(s, "->", trim(s, "//"));

Answer 9

expandiendo la respuesta de @leaf, aquí hay una que puede tomar múltiples caracteres:

var trim = function (s, t) {
var tr, sr
tr = t.split('''').map(e => `////${e}`).join('''')
sr = s.replace(new RegExp(`^[${tr}]+|[${tr}]+$`, ''g''), '''')
return sr
}

Answer 10

para mantener esta pregunta actualizada:

Aquí hay un enfoque que elegiría sobre la función de expresión regular usando el operador de extensión ES6.

function trimByChar(string, character) {
const first = [...string].findIndex(char => char !== character);
const last = [...string].reverse().findIndex(char => char !== character);
return string.substring(first, string.length - last);
}

Answer 11

tratar:

console.log(x.replace(//|/g,''''));

Answer 12

String.prototype.TrimStart = function (n) {
if (this.charAt(0) == n)
return this.substr(1);
};
String.prototype.TrimEnd = function (n) {
if (this.slice(-1) == n)
return this.slice(0, -1);
};