문자열에서 특정 문자 잘라내기

문자열에서 특정 문자 잘라내기

이것에 해당하는 자바스크립트는 무엇입니까?C#방법:

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

C#은 문자열의 시작 부분과 끝 부분에서만 선택한 문자를 자릅니다!

한 줄이면 충분합니다.

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 = "\\^";
  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));
}

매 수c문자(길이 1의 문자열)여야 합니다.

주석에 언급된 대로 공백과 같은 여러 문자를 잘라내는 것이 일반적이므로 여러 문자를 지원하는 것이 유용할 수 있습니다.이를 위해 마이티 포크는 다음과 같은 기능을 사용할 것을 제안합니다.ifs는 다음과 같은 코드 행을 사용합니다.

c = c.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');

파트 이분부.[-/\\^$*+?.()|[\]{}]이며, 는 정식구특문집자합다니입수문의규입니다.$&는 일치하는로, 를,replace함수가 특수 문자를 이스케이프합니다.브라우저 콘솔에서 시도해 보십시오.

> "{[hello]}".replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')
"\{\[hello\]\}"

업데이트: 다양한 솔루션의 성능이 궁금하여 기본 벤치마크를 업데이트했습니다. https://www.measurethat.net/Benchmarks/Show/12738/0/trimming-leadingtrailing-characters

Chrome 아래에서 실행되는 몇 가지 흥미롭고 예상치 못한 결과.https://www.measurethat.net/Benchmarks/ShowResult/182877

+-----------------------------------+-----------------------+
| 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        |
+-----------------------------------+-----------------------+

단 하나의 테스트 문자열에 대해서만 테스트가 수행되었습니다(트리밍이 필요한 선행 문자와 후행 문자 모두 포함).또한 이 벤치마크는 원시 속도를 나타낼 뿐입니다. 메모리 사용량과 같은 다른 요인도 고려해야 합니다.

---

더 긴 문자열을 처리하는 경우 할당된 문자열 수를 0개 또는 1개로 줄임으로써 대부분의 다른 옵션보다 성능이 우수할 것으로 생각합니다.

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

잘 이나 끝에 ex: 만내잘이다면했예해가, 신특문자정가문을때원다를만제니기합하거있끝에당음처이나자열의은약예▁if▁only▁you▁it원(다ex니▁if:▁a:▁character:||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, "|") + "'" );

다음과 같은 정규식을 사용할 수 있습니다.

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

보기 쉬운 정규식이 없는 버전:

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

가장자리에서 문자가 반복되지 않는 것이 확실한 사용 사례에 사용됩니다.

이 질문을 최신 상태로 유지하기 위해:

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 trimByChar1(string, character) {
  const arr = Array.from(string);
  const first = arr.findIndex(char => char !== character);
  const last = arr.reverse().findIndex(char => char !== character);
  return (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

사용자의 스크립트에서 사용하고 프로토타입을 변경해도 괜찮으시다면 편리한 "해크"가 될 수 있습니다.

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

나는 스크립트 중 하나에서 trimChars 기능을 광범위하게 사용하기 때문에 이 솔루션을 선호합니다.그러나 개체의 프로토타입을 수정하는 데 잠재적인 문제가 있습니다.

만약 당신이 당신의 프로그램에서 이러한 기능들을 정의한다면, 당신의 문자열들은 다음의 업그레이드된 버전을 가질 것입니다.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/

const trim = (str, char) => {
    let i = 0;
    let j = str.length-1;
    while (str[i] === char) i++;
    while (str[j] === char) j--;
    return str.slice(i,j+1);
}
console.log(trim('|f|oo|', '|')); // f|oo

비정규 솔루션. 개의 포인터: 두개의포터:i & (음악) &j와 일치하는 (end). 포인터가 char와 일치하는 경우에만 이동하고 일치하지 않을 경우에는 중지합니다.남은 문자열을 반환합니다.

저는 로다쉬와 그들이 어떻게 구현했는지 검토하는 것을 제안하고 싶습니다.trim기능.

트리밍을 수행하는 정확한 코드를 보려면 설명서와 소스는 Lodash Trim을 참조하십시오.

이것이 당신의 질문에 대한 정확한 답을 제공하지 않는다는 것을 알지만, 다른 사람들이 그것을 유용하다고 생각할 수 있기 때문에 저는 그러한 질문에 대한 도서관에 대한 참조를 설정하는 것이 좋다고 생각합니다.

이 장치는 모든 선행 및 후행 딜리미터를 트리밍합니다.

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의 솔루션이 마음에 듭니다...

'char'가 아니라 'word'로 확장...

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

하는 가장 )입니다.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문자가 시작 및/또는 끝에 있으면 문자를 제거해야 하지만 그렇지 않으면 원래 문자열을 반환합니다.

정규식을 사용할 다른 버전입니다.

아니요 또는(|) 않음 사 전 역 없 음 및 용 됨 없 음 ( ▁)g 됨.) 중고.

function escapeRegexp(s) {
  return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
}

function trimSpecific(value, find) {
  const find2 = escapeRegexp(find);
  return value.replace(new RegExp(`^[${find2}]*(.*?)[${find2}]*$`), '$1')
}

console.log(trimSpecific('"a"b"', '"') === 'a"b');
console.log(trimSpecific('""ab"""', '"') === 'ab');
console.log(trimSpecific('"', '"') === '');
console.log(trimSpecific('"a', '"') === 'a');
console.log(trimSpecific('a"', '"') === 'a');
console.log(trimSpecific('[a]', '[]') === 'a');
console.log(trimSpecific('{[a]}', '[{}]') === 'a');

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

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

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

(이중 탈출에 유의합니다.\\문자열에 실제로 단일 슬래시가 있어야 탈출할 수 있습니다.|regExp)에 표시됩니다.

regExp-Escape.가 필요한 문자는 몇 개뿐이며, 그 중 파이프 연산자가 필요합니다.

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$%'));

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

제가 알기로는 jQuery는 당신이 문의하신 방법에 내장된 기능이 없습니다.그러나 Javascript를 사용하면 replace를 사용하여 문자열의 내용을 변경할 수 있습니다.

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

이것은 |의 모든 발생을 아무것도 아닌 것으로 대체할 것입니다.

시도:

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

다음 방법을 사용해 보십시오.

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

언급URL : https://stackoverflow.com/questions/26156292/trim-specific-character-from-a-string