web-dev-qa-db-ger.com

Beschneiden eines bestimmten Zeichens aus einer Zeichenfolge

Was ist das JavaScript Äquivalent zu dieser C#-Methode:

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

C # beschneidet das ausgewählte Zeichen nur am Anfang und Ende der Zeichenfolge!

58
fubo

Eine Zeile ist genug:

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

In einer Funktion:

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, "\\"));

74
leaf

Wenn ich es richtig verstanden habe, möchten Sie ein bestimmtes Zeichen nur dann entfernen, wenn es am Anfang oder am Ende der Zeichenfolge steht (zB: "|| fo || oo ||||" sollte zu "foo || oo" werden). . Sie können eine Ad-hoc-Funktion wie folgt erstellen:

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

Ich habe diese Funktion mit dem folgenden Code getestet:

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

Sie können einen regulären Ausdruck verwenden, zum Beispiel:

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

UPDATE:

Wenn Sie dies in eine Funktion verallgemeinern möchten, können Sie Folgendes tun:

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
12
neelsg

um diese Frage auf dem neuesten Stand zu halten: 

hier ist ein Ansatz, den ich über die Regex-Funktion mit dem ES6-Spread-Operator wählen würde. 

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);
}
11
Robin F.

Dies kann mehrere Zeichen gleichzeitig trimmen:

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
5
marlar

Dieser schneidet alle führenden und nachgestellten Trennzeichen ab

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
1
Dmitriy Botov

Soweit ich weiß, hat jQuery keine eingebaute Funktion, um die Methode, nach der Sie gefragt werden .. _. Mit Javascript können Sie jedoch einfach ersetzen, um den Inhalt Ihrer Zeichenfolge zu ändern:

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

Dies wird alle Vorkommen von | ersetzen mit nichts.

1
Ole Haugset

Eine Version ohne Regex, die das Auge schont:

const trim = (str, chars) => str.split(chars).filter(Boolean).join(chars);

Für Anwendungsfälle, bei denen wir sicher sind, dass sich die Zeichen an den Rändern nicht wiederholen.

1
mbaer3000

Wenn Sie mit längeren Zeichenfolgen arbeiten, sollte dies meiner Meinung nach die meisten anderen Optionen übertreffen, indem Sie die Anzahl der zugewiesenen Zeichenfolgen auf null oder eins reduzieren:

function trim(str, ch) {
    var start = 0, 
        end = str.length;

    while(start < end && str[start] === ch)
        ++start;

    while(end > start && str[end - 1] === ch)
        --end;

    return (start > 0 || end < str.length) ? str.substring(start, end) : str;
}

// Usage:
trim('|hello|world|', '|'); // => 'hello|world'

Oder wenn Sie aus mehreren Zeichen schneiden möchten:

function trimAny(str, chars) {
    var start = 0, 
        end = str.length;

    while(start < end && chars.indexOf(str[start]) >= 0)
        ++start;

    while(end > start && chars.indexOf(str[end - 1]) >= 0)
        --end;

    return (start > 0 || end < str.length) ? str.substring(start, end) : str;
}

// Usage:
trimAny('|hello|world   ', [ '|', ' ' ]); // => 'hello|world'
// because '.indexOf' is used, you could also pass a string for the 2nd parameter:
trimAny('|hello| world  ', '| '); // => 'hello|world'
1
Jason Larke

Ich mag die Lösung von @ Pho3niX83 ...

Lassen Sie uns es mit "Word" anstelle von "char" erweitern ...

function trimWord(_string, _Word) {

    var splitted = _string.split(_Word);

    while (splitted.length && splitted[0] === "") {
        splitted.shift();
    }
    while (splitted.length && splitted[splitted.length - 1] === "") {
        splitted.pop();
    }
    return splitted.join(_Word);
};
0
foxontherock

versuchen:

console.log(x.replace(/\|/g,''));
0
Man Programmer

um die Antwort von @leaf zu erweitern, kann man mehrere Zeichen annehmen:

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
}
0
AmitK
function trim(text, val) {
    return text.replace(new RegExp('^'+val+'+|'+val+'+$','g'), '');
}
0

Regex scheint ein bisschen zu komplex für ein einfaches Problem wie Trim?

C #

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

Javascript, x.TrimLeft ('|') Beispiel - einfach (aber schneidet nur ein einzelnes Zeichen ab)

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

var result = y;
console.log(y);

Volles Beispiel für Javascript (dank @Tobo Antwort)

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();");

Ich war ein bisschen faul mit trimStart und trimEnd. Es wäre effizienter zu finden, wie viel von jeder Seite getrimmt werden muss. Rufen Sie dann den Teilstring nur einmal auf. Aber hoffentlich bekommst du die Idee und das ist hilfreich!

0
TamusJRoyce

Ich würde vorschlagen, sich lodash anzuschauen und wie sie die Funktion trim implementiert haben.

Siehe Lodash Trim für die Dokumentation und die Quelle , um den genauen Code zu sehen, der das Trimmen ausführt.

Ich weiß, dass dies keine genaue Antwort auf Ihre Frage liefert, aber ich denke, es ist gut, einen Verweis auf eine Bibliothek auf eine solche Frage zu setzen, da andere sie nützlich finden könnten.

0
drew7721