Beschneiden eines bestimmten Zeichens aus einer Zeichenfolge

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

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

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

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

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

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.

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.

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'

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

versuchen:

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

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
}

function trim(text, val) {
    return text.replace(new RegExp('^'+val+'+|'+val+'+$','g'), '');
}

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!

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.