Javascript 从字符串中修剪特定字符

与此

C

方法等价的JavaScript是什么：

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

---

C#仅在字符串的开头和结尾修剪所选字符

据我所知，jQuery没有您所询问的方法所内置的函数。 但是，对于javascript，您可以使用replace来更改字符串的内容：

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

这将用零替换所有出现的|。

尝试：

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

---

如果我理解得很好，您只想删除字符串开头或结尾的特定字符（例如：

foo | | | oo | | |

应该变成

foo | oo

）。您可以按如下方式创建临时功能：

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

我用下面的代码测试了这个函数：

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

---

可以使用正则表达式，例如：

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

更新：

如果希望将其概括为函数，可以执行以下操作：

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

一行就够了：

var x='| f | oo | |'；
变量y=x.replace（/^\\\\+\\\\\\\+$/g，”）；
写（x+'
'+y）以使此问题保持最新：

这里有一种方法，我会选择使用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);
}

@fabian注释后的改进版本（只能处理包含相同字符的字符串）


函数trimByChar1（字符串、字符）{
const arr=Array.from（字符串）；
const first=arr.findIndex（char=>char！==character）；
const last=arr.reverse（）.findIndex（char=>char！==character）；
返回（first==-1&&last===-1）？“”：string.substring（first，string.length-last）；
}
这可以一次修剪几个字符：

function trimChars (str, c) {
  var re = new RegExp("^[" + c + "]+|[" + c + "]+$", "g");
  return str.replace(re,"");
}

var x = "|f|oo||"; 
x =  trimChars(x, '|'); // f|oo

var y = "..++|f|oo||++..";
y = trimChars(y, '|.+'); // f|oo

var z = "\\f|oo\\"; // \f|oo\

// For backslash, remember to double-escape:
z = trimChars(z, "\\\\"); // f|oo

在您自己的脚本中使用，如果您不介意更改原型，这可以是一个方便的“黑客”：

因为我在我的一个脚本中广泛使用了trimChars函数，所以我更喜欢这个解决方案。但是有一些潜在的问题。
扩展@leaf的答案，这里有一个可以包含多个字符：

这一个修剪所有的领先和落后的纤度

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

我喜欢@Pho3niX83的解决方案

让我们用“word”而不是“char”来扩展它

更新：对不同解决方案的性能感到好奇，因此我在这里更新了一个基本基准：

在Chrome下运行的一些有趣和意外的结果。

请注意；测试仅在单个测试字符串上执行（需要修剪的前导字符和尾随字符）。此外，该基准仅给出原始速度的指示；其他因素，如内存使用也很重要。

如果您处理的是较长的字符串，我认为通过将分配的字符串数减少到零或一，这应该比大多数其他选项表现更好：

功能微调（str，ch）{
var start=0，
end=str.length；
while（startstart&&str[end-1]==ch）
--结束；
返回（开始>0 | |结束'你好|世界杯

或者，如果要从一组多个字符中修剪，请执行以下操作：

函数trimAny（str，chars）{
var start=0，
end=str.length；
while（start=0）
++开始；
while（end>start&&chars.indexOf（str[end-1]）>=0）
--结束；
返回（开始>0 | |结束”你好|世界杯
//因为使用了“.indexOf”，所以还可以为第二个参数传递字符串：
trimAny（“|你好|世界”，“|”）；//=>”你好|世界杯

编辑：为了好玩，修剪单词（而不是单个字符）

//用于检测字符串是否包含其他字符串的帮助函数
//在特定的位置。
//相当于使用'str.indexOf（substr，pos）==pos'，但是*应该*在更长的字符串上更有效，因为它可以提前退出（需要基准来支持）。
函数hasSubstringAt（str、substr、pos）{
变量idx=0，len=substr.length；
对于（var max=str.length；idx=max | | str[pos+idx]！=substr[idx]）
打破
}
返回idx==len；
}
功能词（str，word）{
var start=0，
end=str.length，
len=单词长度；
while（startstart&&hasSubstringAt（str、word、end-len））
结束-=字长
返回（开始>0 | |结束
我建议查看lodash以及他们是如何实现
trim
功能的

有关文档，请参阅，以查看进行修剪的确切代码

我知道这并不能准确回答您的问题，但我认为在这样一个问题上设置一个库的引用是很好的，因为其他人可能会发现它很有用。
一个简单易懂的无正则表达式版本：

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

对于使用案例，我们确定边缘没有重复的字符
 试试这个方法：

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


var a=“anan güzel mi？”；
如果（a.endsWith（“？”）a=a.slice（0，-1）；
document.body.innerHTML=a如果在程序中定义这些函数，字符串将具有升级版本的
trim
，可以修剪所有给定字符：


String.prototype.trimleet=函数（charlist）{
如果（字符列表===未定义）
charlist=“\s”；
返回这个。替换（新的RegExp（“^[”+charlist+“]+”）”）；
};
String.prototype.trim=函数（charlist）{
返回此.trimlight（charlist）.trimlight（charlist）；
};
String.prototype.trimRight=函数（charlist）{
如果（字符列表===未定义）
charlist=“\s”；
返回这个。替换（新的RegExp（“[”+char
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

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

+-----------------------------------+-----------------------+
| Test name                         | Executions per second |
+-----------------------------------+-----------------------+
| Index Version (Jason Larke)       | 949979.7 Ops/sec      |
| Substring Version (Pho3niX83)     | 197548.9 Ops/sec      |
| Regex Version (leaf)              | 107357.2 Ops/sec      |
| Boolean Filter Version (mbaer3000)| 94162.3 Ops/sec       |
| Spread Version (Robin F.)         | 4242.8 Ops/sec        |
+-----------------------------------+-----------------------+

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

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

"|Howdy".replace(new RegExp("^\\|"),"");