Question

与此C#方法等效的 JavaScript 是什么：

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

C＃仅在字符串的开头和结束处修剪所选字符！

Answer 1

如果我理解得很好，你只想在字符串的开头或结尾处删除特定字符（例如：＆＃34; || fo || oo ||||＆＃34;应该成为＆＃34; foo || oo＆＃34;）。您可以按如下方式创建ad hoc函数：

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

Answer 2

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

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

Answer 3

让这个问题保持最新：

这是我使用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 4

这可以一次修剪几个字符：

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 5

如果在程序中定义这些功能，则字符串将具有trim的升级版本，可以修剪所有给定的字符：

String.prototype.trimLeft = function(charlist) {
	if (charlist === undefined)
	charlist = "\s";

	return this.replace(new RegExp("^[" + charlist + "]+"), "");
};

String.prototype.trim = function(charlist) {
	return this.trimLeft(charlist).trimRight(charlist);
};

String.prototype.trimRight = function(charlist) {
	if (charlist === undefined)
	charlist = "\s";

	return this.replace(new RegExp("[" + charlist + "]+$"), "");
};

var withChars = "/-center-/"
var withoutChars = withChars.trim("/-")
document.write(withoutChars)

来源

https://www.sitepoint.com/trimming-strings-in-javascript/

Answer 6

解决此任务的最佳方法是（类似于PHP trim函数）：

function trim( str, charlist ) {
  if ( typeof charlist == 'undefined' ) {
    charlist = '\\s';
  }
  
  var pattern = '^[' + charlist + ']*(.*?)[' + charlist + ']*$';
  
  return str.replace( new RegExp( pattern ) , '$1' )
}

document.getElementById( 'run' ).onclick = function() {
  document.getElementById( 'result' ).value = 
  trim( document.getElementById( 'input' ).value,
  document.getElementById( 'charlist' ).value);
}

<div>
  <label for="input">Text to trim:</label><br>
  <input id="input" type="text" placeholder="Text to trim" value="dfstextfsd"><br>
  <label for="charlist">Charlist:</label><br>
  <input id="charlist" type="text" placeholder="Charlist" value="dfs"><br>
  <label for="result">Result:</label><br>
  <input id="result" type="text" placeholder="Result" disabled><br>
  <button type="button" id="run">Trim it!</button>
</div>

P.S .：为什么大多数人以前已经做过答案，但我为什么发布了答案？因为我在所有答案中都发现了“最好的”错误：所有人都使用了'+'而不是'*'，所以'trim必须删除字符（如果它们在开始和/或结束中，但是返回）否则为原始字符串。

Answer 7

对于像Trim这样的简单问题，正则表达式似乎有点过于复杂？

C＃

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

Javascript，x.TrimLeft（＆＃39; |＆＃39;）示例 - 简单（但仅修剪单个字符）

＆＃13;

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

＆＃13;

Javascript完整示例（感谢@Tobo回答和@rooby建议）

＆＃13;

class SutString extends String { // [S]tring[Ut]ility
  replaceFirstOnly(src, dest) {
    return new SutString(this.replace(src, dest)); // String.replace is misleading
  }
  replaceAll(src, dest) {
    return new SutString(this.split(src).join(dest));
  }

  reverse() {
    return new SutString(this.split("").reverse().join(""));
  }

  trimStart(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;
    }
    if (typeof(current) === 'string') {
      return new SutString(current);
    }
    return current;
  };

  trimEnd(delimiter = " ") {
    if (!delimiter) {
      return new SutString(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;
    }
    if (typeof(current) === 'string') {
      return new SutString(current);
    }
    return current;
  };

  trimString(delimiter = " ") {
    if (!delimiter) {
      return this.trim();
    }

    return this.trimStart(delimiter).trimEnd(delimiter);
  };
}
// Pushes all functions and properties from String to SutString,
//   returning SutString if the result is a string
for(let prop of Object.getOwnPropertyNames(String.prototype)) {
  if (prop === "constructor" || prop === "toString" || (""[prop]) instanceof Function) {
    continue;
  }
  let newprop = prop;
  if (typeof(SutString.prototype[prop]) !== 'undefined') {
    newprop = "base_" + prop;
  }
  SutString.prototype[newprop] = function() {
    const result = this.toString()[prop].apply(this, arguments);
    if (typeof(result) !== 'string') {
      return result;
    }
    return new SutString(result);
  }
}
var str = new SutString("|f|oo||");
var strWhitespace = new SutString(" |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();");

＆＃13;

我对trimStart和trimEnd有点懒惰。找到每个方面需要修剪多少会更有效。然后只调用一次substring。但希望你能得到这个想法，这很有帮助！

注意：这是特定于es6的。其中一些可能会在es2019中为您实现。

Answer 8

这会修剪所有前导和尾随的距离

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 9

如果您要处理更长的字符串，我认为这应该通过将分配的字符串数减少为零或一个来胜过大多数其他选择：

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'

或者如果要从一组多个字符中修剪，则：

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'

Answer 10

易于使用的无正则表达式版本：

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

对于用例，我们确定没有多余的字符重复出现。

Answer 11

我喜欢@ Pho3niX83的解决方案...

让我们用“单词”而不是“字符”扩展它。

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

Answer 12

const special = ':;"<>?/!`~@#$%^&*()+=-_ '.split("");
const trim = (input) => {
    const inTrim = (str) => {
        const spStr = str.split("");
        let deleteTill = 0;
        let startChar = spStr[deleteTill];
        while (special.some((s) => s === startChar)) {
            deleteTill++;
            if (deleteTill <= spStr.length) {
                startChar = spStr[deleteTill];
            } else {
                deleteTill--;
                break;
            }
        }
        spStr.splice(0, deleteTill);
        return spStr.join("");
    };
input = inTrim(input);
input = inTrim(input.split("").reverse().join("")).split("").reverse().join("");
return input;
};
alert(trim('@#This is what I use$%'));

Answer 13

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

（请注意两次转义。\\必须在字符串中实际上有一个斜杠，然后导致在<< strong> regExp ）。

Only few characters need regExp-Escaping.，其中包括管道运算符。

Answer 14

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

Answer 15

我建议查看lodash以及它们如何实现trim函数。

有关文档，请参见Lodash Trim，the source请参见进行修剪的确切代码。

我知道这不能为您的问题提供确切的答案，但是我认为最好在此类问题上建立对图书馆的引用，因为其他人可能会觉得有用。

Answer 16

据我所知，jQuery没有内置函数你正在询问的方法。但是，使用javascript，您只需使用replace来更改字符串的内容：

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

这将取代所有出现的事件什么都没有。

Answer 17

扩展@leaf的答案，这是一个可以包含多个字符的代码：

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 18

尝试此方法：

var a = "anan güzel mi?";
if (a.endsWith("?"))   a = a.slice(0, -1);  
document.body.innerHTML = a;

Answer 19

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

Answer 20

尝试：

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

修剪字符串中的特定字符

20 个答案:

来源