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);
};