IT

어디에서 특정 문자 자르기

lottoking 2020. 9. 9. 08:13
반응형

어디에서 특정 문자 자르기

이 메소드 에 해당 하는 JavaScript 는 무엇입니까?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 = "\\\\";
  return s.replace(new RegExp(
    "^[" + c + "]+|[" + c + "]+$", "g"
  ), "");
}

s = ".foo..oo...";
console.log(s, "->", trim(s, "."));
s = "|foo||oo|||";
console.log(s, "->", trim(s, "|"));
s = "]foo]]oo]]]";
console.log(s, "->", trim(s, "]"));
s = "\\foo\\\\oo\\\\\\";
console.log(s, "->", trim(s, "\\"));

내가 잘 이해 어느 특정 문자가 많은 시작 또는 존재하는 경우에만 제거하고 싶습니다 (예 : ||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

이 질문을 최신 상태로 유지 비용 :

여기에 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);
}

이렇게하면 한 번에 여러 문자를 사용할 수 있습니다.

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

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

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

가장자리에서 문자가 반복되지 않는다고 확신하는 사용 사례의 경우.

Regex는 Trim과 같은 간단한 문제에 너무 복잡해 보입니다.

씨 #

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

Javascript, x.TrimLeft ( '|') 예제-단순 (단 하나의 문자 만 잘라 냄)

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

var result = y;
console.log(y);

자바 스크립트 전체 예제 (@Tobo 답변 및 @rooby 제안 덕분에)

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();");

나는 trimStart와 trimEnd에 약간 게으르다. 각면을 다듬어야하는 양을 찾는 것이 더 많이입니다. 그런 다음 부분을 한 번만 호출하십시오. 그러나 바라건대 당신은 아이디어를 얻고 이것이 도움이됩니다!

참고 : 이것은 es6에 해당됩니다. 이 중 일부는 es2019에서 구현 될 수 있습니다.

더 긴 호스트를 사용하는 경우 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'

이것은 모든 선행 및 후행 구분자를 트리밍합니다.

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

내가 아는 한, jQuery에는 귀하가 요청하는 방법이 내장 된 기능이 없습니다. 그러나 javascript를 사용하면 replace를 사용하여 문자열의 내용을 변경할 수 있습니다.

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

이것은 | 아무것도없이.

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

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

lodash를 살펴보고 trim기능 을 구현하는 방법을 제안 합니다.

참조 Lodash 트림을 문서 및 대한 소스 트리밍을 수행하는 정확한 코드를 볼 수 있습니다.

나는 이것이 귀하의 질문에 정확한 대답을 제공하지 않는다는 것을 알고 있지만 다른 사람들이 유용하다고 생각할 수 있으므로 그러한 질문에 대한 라이브러리에 대한 참조를 설정하는 것이 좋습니다.

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

이 방법을 시도하십시오.

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

시험:

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

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

반응형

'IT' 카테고리의 다른 글

C ++에서 부스트를 사용하여 UUID 생성의 예  (0) 2020.09.09
Swift의 정적 함수 변수  (0) 2020.09.09
Xcode 9에서 분기 전환  (0) 2020.09.09
PreferenceFragment 내에서 기본 설정 변경을 수신하는 방법은 무엇입니까?  (0) 2020.09.09
비례를 유지하면서 이미지로 div를 어떻게 채울 수 있습니까?  (0) 2020.09.09

'IT'의 다른글

  • 현재글어디에서 특정 문자 자르기

관련글

댓글

티스토리툴바