Cắt ký tự cụ thể khỏi một chuỗi

Là gì JavaScript tương đương này C#Phương pháp:

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

C # chỉ cắt ký tự đã chọn ở đầu và cuối chuỗi!

Một dòng là đủ:

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

Một giải pháp chung:

function trim (s, c) {
  if (c === "]") c = "\\]";
  if (c === "\\") c = "\\\\";
  return s.replace(new RegExp(
    "^[" + c + "]+|[" + c + "]+$", "g"
  ), "");
}

chars = ".|]\\";
for (c of chars) {
  s = c + "foo" + c + c + "oo" + c + c + c;
  console.log(s, "->", trim(s, c));
}

Nếu tôi hiểu rõ, bạn chỉ muốn xóa một ký tự cụ thể khi nó nằm ở đầu hoặc ở cuối chuỗi (ví dụ: ||fo||oo||||should be foo||oo). Bạn có thể tạo một hàm đặc biệt như sau:

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

Tôi đã thử nghiệm chức năng này với mã bên dưới:

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

Bạn có thể sử dụng một biểu thức chính quy như:

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

CẬP NHẬT:

Nếu bạn muốn tổng quát hóa điều này thành một hàm, bạn có thể làm như sau:

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

để giữ cho câu hỏi này được cập nhật:

đây là một cách tiếp cận mà tôi sẽ chọn trên hàm regex bằng cách sử dụng toán tử lây lan 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);
}

Phiên bản cải tiến sau nhận xét của @fabian (chỉ có thể xử lý các chuỗi chứa cùng một ký tự)

function trimByChar(string, character) {
  const arr = Array.from(string);
  const first = arr.indexOf(character);
  const last = arr.reverse().indexOf(character);
  return string.substring(first + 1, string.length - last - 1);
}

Một phiên bản ít regex dễ nhìn:

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

Đối với các trường hợp sử dụng mà chúng tôi chắc chắn rằng không có sự lặp lại của các ký tự ngoài rìa.

Nếu bạn đang xử lý các chuỗi dài hơn, tôi tin rằng điều này sẽ tốt hơn hầu hết các tùy chọn khác bằng cách giảm số lượng chuỗi được phân bổ xuống không hoặc một:

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'

Hoặc nếu bạn muốn cắt từ một tập hợp nhiều ký tự:

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'

CHỈNH SỬA: Để giải trí, hãy cắt các từ (thay vì các ký tự riêng lẻ)

// Helper function to detect if a string contains another string
//     at a specific position. 
// Equivalent to using `str.indexOf(substr, pos) === pos` but *should* be more efficient on longer strings as it can exit early (needs benchmarks to back this up).
function hasSubstringAt(str, substr, pos) {
    var idx = 0, len = substr.length;

    for (var max = str.length; idx < len; ++idx) {
        if ((pos + idx) >= max || str[pos + idx] != substr[idx])
            break;
    }

    return idx === len;
}

function trimWord(str, word) {
    var start = 0,
        end = str.length,
        len = word.length;

    while (start < end && hasSubstringAt(str, word, start))
        start += word.length;

    while (end > start && hasSubstringAt(str, word, end - len))
        end -= word.length

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

// Usage:
trimWord('blahrealmessageblah', 'blah');

Điều này có thể cắt một số ký tự cùng một lúc:

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

Nếu bạn xác định các hàm này trong chương trình của mình, chuỗi của bạn sẽ có phiên bản nâng cấp trimcó thể cắt tất cả các ký tự đã cho:

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)

Nguồn

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

Theo hiểu biết của tôi, jQuery không có một hàm tích hợp như phương pháp mà bạn đang hỏi. Tuy nhiên, với javascript, bạn chỉ có thể sử dụng Replace để thay đổi nội dung chuỗi của mình:

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

Điều này sẽ thay thế tất cả các lần xuất hiện của | không có gì.

Cái này cắt tất cả các mê sảng đầu và cuối

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

Tôi khuyên bạn nên xem xét lodash và cách họ triển khai trimchức năng.

Xem Lodash Trim để biết tài liệu và nguồn để xem mã chính xác thực hiện việc cắt tỉa.

Tôi biết điều này không cung cấp câu trả lời chính xác cho câu hỏi của bạn, nhưng tôi nghĩ thật tốt khi đặt tham chiếu đến thư viện về câu hỏi như vậy vì những người khác có thể thấy nó hữu ích.

Cách tốt nhất để giải quyết tác vụ này là (tương tự với trimhàm PHP ):

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>

Tái bút: tại sao tôi đăng câu trả lời của mình, khi hầu hết mọi người đã làm nó trước đó? Bởi vì tôi đã tìm thấy sai lầm "tốt nhất" trong tất cả các câu trả lời ở đó: tất cả đều sử dụng meta '+' thay vì '*', 'nguyên nhân trimphải xóa các ký tự NẾU CHÚNG Ở BẮT ĐẦU VÀ / HOẶC KẾT THÚC, nhưng nó trả về chuỗi ban đầu trong trường hợp khác .

mở rộng về câu trả lời của @leaf, đây là câu trả lời có thể có nhiều ký tự:

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
}

Tôi thích giải pháp từ @ Pho3niX83 ...

Hãy mở rộng nó bằng "word" thay vì "char" ...

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

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

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

(lưu ý thoát kép. \\cần thiết, để có một dấu gạch chéo thực sự trong chuỗi , sau đó dẫn đến thoát |trong regExp ).

Chỉ một số ký tự cần regExp-Escaping. , trong số đó có người điều hành đường ống.

thử:

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

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

Hãy thử phương pháp này:

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