एक स्ट्रिंग से विशिष्ट चरित्र ट्रिम करें

Question

इस विधि के बराबर जावास्क्रिप्ट क्या है C#:

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

C # स्ट्रिंग के आरंभ और अंत में केवल चयनित वर्ण को चलाता है!

Answer 1

एक पंक्ति पर्याप्त है:

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

एक सामान्य समाधान:

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

Answer 2

अगर मैं अच्छी तरह से समझ गया हूं, तो आप केवल एक विशिष्ट चरित्र को निकालना चाहते हैं यदि यह शुरुआत में है या स्ट्रिंग के अंत में है (उदा: ||fo||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, "|") + "'" );

Comments

यह कचरा कलेक्टर के लिए एक मजेदार परीक्षा होगी, लेकिन मैं आपके ग्राहकों को इसके अधीन करने की सिफारिश नहीं करूंगा।

— सोरेनसेन

Answer 3

आप एक नियमित अभिव्यक्ति का उपयोग कर सकते हैं जैसे:

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 4

इस प्रश्न को अद्यतन रखने के लिए:

यहाँ एक दृष्टिकोण है जिसे मैं 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 की टिप्पणी के बाद बेहतर संस्करण (केवल उसी वर्ण वाले स्ट्रिंग को संभाल सकता है)

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

Comments

मुझे पता है कि रेगेक्स यहाँ ओवरकिल हैं, लेकिन आप इस विशेष कार्यान्वयन को क्यों चुनेंगे?

— निकोलस शैंक्स

यह कार्यान्वयन क्योंकि मैं व्यक्तिगत रूप से इसे अच्छी तरह से पठनीय पाता हूं। रेगेक्स केवल इसलिए नहीं क्योंकि रेगेक्स इंजन के भीतर निर्णय "ट्री" बहुत बड़ा है। और विशेष रूप से क्योंकि ट्रिमिंग के लिए उपयोग किए जाने वाले रेगेक्स में क्वेरी वर्ण होते हैं जो रेक्सएक्स इंजन के भीतर बैकट्रैकिंग को जन्म देते हैं। इस तरह के इंजन अक्सर पैटर्न को बाइट-कोड में संकलित करते हैं, मशीन निर्देशों से मिलते जुलते हैं। इंजन फिर कोड को निष्पादित करता है, निर्देश से निर्देश तक कूदता है। जब कोई निर्देश विफल होता है, तो यह इनपुट से मिलान करने का दूसरा तरीका खोजने के लिए वापस-ट्रैक करता है। nec की तुलना में बहुत अधिक चल रहा है।

— रॉबिन एफ।

जवाब देने के लिए धन्यवाद, हालाँकि मैं आपको यह समझाना चाहता था कि आप इसे करने के अन्य गैर-रेगेक्स तरीकों को क्यों चुनेंगे - मैं और उम्मीद कर रहा था कि "मुझे यह पठनीय लगे", मुझे लगता है।

— निकोलस शैंक्स

@RobinF। आपको लगता है कि findIndex () और रिवर्स () में लूप नहीं हैं? फिर से विचार करना।

— एंड्रयू

दो एनोटेशन: ट्रिम किए जाने वाले पात्र का केवल एक स्ट्रिंग कंटेंट को ट्रिम नहीं किया जाएगा। दूसरा बिंदु यह है: स्ट्रिंग को फैलाने वाले ऑपरेटर के साथ एक सरणी में विस्फोट करना, कोलाहल को भ्रमित करेगा और इसे उस में बदल देगा [].concat(string)जो वांछित परिणाम नहीं है। का उपयोग करते हुए Array.from(string)काम करेंगे।

— फाबियान

Answer 5

एक रेगेक्स-कम संस्करण जो आंख पर आसान है:

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

ऐसे मामलों के उपयोग के लिए जहां हम निश्चित हैं कि किनारों से वर्णों का कोई पुनरावृत्ति नहीं है।

Comments

काफी दिलचस्प ... इसलिए विभाजित होने वाले प्रत्येक सीमांकक के बराबर के लिए अपरिभाषित तत्व देता हैconst trim = (str, chars) => str.split(chars).filter(x => { Boolean(x); console.log(typeof(x), x, Boolean(x)); }).join(chars); const str = "#//#//abc#//test#//end#//"; console.log(trim(str, '#//'));

— TamusJRoyce

Answer 6

यदि आप लंबे समय तक तार के साथ काम कर रहे हैं, तो मेरा मानना ​​है कि यह या तो या तो आवंटित तार की संख्या को कम करके अन्य विकल्पों में से बेहतर प्रदर्शन करना चाहिए:

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'

संपादित करें: मज़े के लिए, शब्दों को ट्रिम करें (व्यक्तिगत पात्रों के बजाय)

// 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');

Comments

मैं इस समाधान को पसंद करता हूं क्योंकि यह वास्तव में, केवल कम के बजाय वास्तव में कुशल है।

— टेकहेड

मैं मानता हूं इसे प्राथमिकता दी जानी चाहिए। एक उत्तर दिया जो मैंने दिया था।

— तमसुराजॉय

Answer 7

यह एक बार में कई वर्णों को ट्रिम कर सकता है:

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

Comments

@fubo: नहीं, वास्तव में नहीं। यह एक डेमो है, यदि आप इसे एक कंसोल में पेस्ट करते हैं तो यह सिर्फ परिणाम का प्रिंट आउट लेगा। लेकिन मुझे लगता है कि यह भ्रामक हो सकता है, इसलिए मैंने इसे संपादित किया है।

— marlar

Answer 8

यदि आप अपने कार्यक्रम में इन कार्यों को परिभाषित करते हैं, तो आपके तार में एक उन्नत संस्करण होगा जो 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 9

मेरी जानकारी के लिए, jQuery के पास एक फंक्शन नहीं है, जो आपके बारे में पूछ रहा है। हालांकि जावास्क्रिप्ट के साथ, आप अपनी स्ट्रिंग की सामग्री को बदलने के लिए प्रतिस्थापित का उपयोग कर सकते हैं:

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

यह सभी घटनाओं को प्रतिस्थापित करेगा | किसी के साथ नहीं।

Comments

वहाँ एक तरीका है हटाने के लिए | केवल शुरुआत / अंत में?

— फुबो

मुझे वास्तव में लगता है कि यह पोस्ट आपको आपके प्रश्न पर गति प्रदान करने के लिए सबसे अधिक मिलेगा: stackoverflow.com/questions/20196088/…

— ओले हगसेट

@ फ़ुबो ज़रूर ... $इस तरह से केवल अंत में फेंक दें : "||spam|||".replace(/\|+$/g, "")या ^इस तरह से केवल शुरुआत के लिए:"||spam|||".replace(/^\|+/g, "")

— रफ़िन

Answer 10

यह सभी प्रमुख और अनुगामी delimeters को ट्रिम करता है

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 11

मैं सुझाव दूंगा कि वे लॉश को कैसे देखते हैं और उन्होंने किस तरह से trimकार्य को कार्यान्वित किया है।

प्रलेखन और स्रोत के लिए लोदश ट्रिम देखें सटीक कोड है कि trimming करता है देखने के लिए।

मुझे पता है कि यह आपके प्रश्न का सटीक उत्तर प्रदान नहीं करता है, लेकिन मुझे लगता है कि इस तरह के प्रश्न पर लाइब्रेरी का संदर्भ सेट करना अच्छा है क्योंकि अन्य इसे उपयोगी पा सकते हैं।

Comments

@TamusJRoyce समान नहीं

— gdbdable

@देवी मैं केवल सहमत हो सकती हूं। टिप्पणी के लिये आपका धन्यवाद। एक समुदाय समर्थित उपकरण में देख अच्छा जवाब।

— तमसुराज

Answer 12

इस कार्य को हल करने का सबसे अच्छा तरीका है (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>

पुनश्च: मैंने अपना जवाब क्यों पोस्ट किया, जब ज्यादातर लोग इसे पहले ही कर चुके थे? क्योंकि मुझे वहाँ सभी जवाबों में "सबसे अच्छी" गलती मिली: सभी ने '*' के बजाय '+' मेटा का उपयोग किया, 'कारण trimको चार्ट को हटाना होगा यदि वे START और / या अंत में हैं, लेकिन यह किसी अन्य मामले में मूल स्ट्रिंग लौटाता है ।

Answer 13

@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 14

मुझे @ 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 15

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

Answer 16

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

(ध्यान दें कि डबल भागने की \\जरूरत है । स्ट्रिंग में वास्तव में एक ही स्लैश है , जो फिर regExx| में भागने की ओर जाता है )।

केवल कुछ ही अक्षरों को regExp-भागने की आवश्यकता होती है। , उनमें से पाइप ऑपरेटर।

Answer 17

प्रयत्न:

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

Answer 18

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

Comments

यह केवल एक घटना को हटाता है, लेकिन जब तक चरित्र पूरी तरह से छंटनी नहीं करता है

— कोआलाबियर

डिफ़ॉल्ट स्ट्रिंग प्रोटोटाइप को ओवरराइड न करें या आप बाद में परेशानी के लिए पूछ रहे हैं। कहीं और अपने अलग कार्य बनाएँ।

— रॉबी

Answer 19

इस विधि का प्रयास करें:

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

Comments

क्यों? यह क्या करता है? यह कैसे काम करता है? एसओ पर कोड-केवल उत्तरों को निम्न गुणवत्ता माना जाता है। अपना उत्तर बताएं ताकि ओपी और भविष्य के कोई भी आगंतुक इससे सीख सकें।

— आतंक न करें