Uzyskaj podciąg między dwoma znakami za pomocą javascript

Próbuję wyodrębnić ciąg z większego ciągu, w którym dostaje wszystko między „:” a „;”.

obecny

Str = 'MyLongString:StringIWant;'

Pożądane wyjście

newStr = 'StringIWant'

Możesz tego spróbować

var mySubString = str.substring(
    str.lastIndexOf(":") + 1, 
    str.lastIndexOf(";")
);

Możesz także spróbować tego:

var str = 'one:two;three';    
str.split(':').pop().split(';')[0]; // returns 'two'

Posługiwać się split()

var s = 'MyLongString:StringIWant;';
var arrStr = s.split(/[:;]/);
alert(arrStr);

arrStrbędzie zawierać wszystkie ciągi rozdzielone przez :lub ;
Więc dostęp do każdego ciągu przezfor-loop

for(var i=0; i<arrStr.length; i++)
    alert(arrStr[i]);

@Babasaheb Gosavi Answer jest idealny, jeśli masz jedno wystąpienie podciągów („:” i „;”). ale gdy wystąpi wiele wystąpień, może to być nieco trudne.

Najlepszym rozwiązaniem, jakie wymyśliłem do pracy nad wieloma projektami, jest użycie czterech metod wewnątrz obiektu.

• Pierwsza metoda: polega na uzyskaniu podłańcucha między dwoma łańcuchami (jednak znajdzie tylko jeden wynik).
• Druga metoda: usunie (niedoszły) ostatnio znaleziony wynik z podciągami przed i przed nim.
• Trzecia metoda: wykona powyższe dwie metody rekurencyjnie na łańcuchu.
• Czwarta metoda: zastosuje trzecią metodę i zwróci wynik.

Kod

Tyle gadania, zobaczmy kod:

var getFromBetween = {
    results:[],
    string:"",
    getFromBetween:function (sub1,sub2) {
        if(this.string.indexOf(sub1) < 0 || this.string.indexOf(sub2) < 0) return false;
        var SP = this.string.indexOf(sub1)+sub1.length;
        var string1 = this.string.substr(0,SP);
        var string2 = this.string.substr(SP);
        var TP = string1.length + string2.indexOf(sub2);
        return this.string.substring(SP,TP);
    },
    removeFromBetween:function (sub1,sub2) {
        if(this.string.indexOf(sub1) < 0 || this.string.indexOf(sub2) < 0) return false;
        var removal = sub1+this.getFromBetween(sub1,sub2)+sub2;
        this.string = this.string.replace(removal,"");
    },
    getAllResults:function (sub1,sub2) {
        // first check to see if we do have both substrings
        if(this.string.indexOf(sub1) < 0 || this.string.indexOf(sub2) < 0) return;

        // find one result
        var result = this.getFromBetween(sub1,sub2);
        // push it to the results array
        this.results.push(result);
        // remove the most recently found one from the string
        this.removeFromBetween(sub1,sub2);

        // if there's more substrings
        if(this.string.indexOf(sub1) > -1 && this.string.indexOf(sub2) > -1) {
            this.getAllResults(sub1,sub2);
        }
        else return;
    },
    get:function (string,sub1,sub2) {
        this.results = [];
        this.string = string;
        this.getAllResults(sub1,sub2);
        return this.results;
    }
};

Jak używać?

Przykład:

var str = 'this is the haystack {{{0}}} {{{1}}} {{{2}}} {{{3}}} {{{4}}} some text {{{5}}} end of haystack';
var result = getFromBetween.get(str,"{{{","}}}");
console.log(result);
// returns: [0,1,2,3,4,5]

var s = 'MyLongString:StringIWant;';
/:([^;]+);/.exec(s)[1]; // StringIWant

Podoba mi się ta metoda:

var str = 'MyLongString:StringIWant;';
var tmpStr  = str.match(":(.*);");
var newStr = tmpStr[1];
//newStr now contains 'StringIWant'

Użyłem @tsds sposób, ale tylko przy użyciu funkcji podziału.

var str = 'one:two;three';    
str.split(':')[1].split(';')[0] // returns 'two'

słowo ostrzeżenia: jeśli therre nie ma „:” w ciągu dostępu do indeksu „1” tablicy wyrzuci błąd! str.split (':') [1]

dlatego droga @tsds jest bezpieczniejsza, jeśli istnieje niepewność

str.split(':').pop().split(';')[0]

function substringBetween(s, a, b) {
    var p = s.indexOf(a) + a.length;
    return s.substring(p, s.indexOf(b, p));
}

// substringBetween('MyLongString:StringIWant;', ':', ';') -> StringIWant
// substringBetween('MyLongString:StringIWant;;', ':', ';') -> StringIWant
// substringBetween('MyLongString:StringIWant;:StringIDontWant;', ':', ';') -> StringIWant

Możesz użyć funkcji wyższego rzędu, aby zwrócić „skompilowaną” wersję swojego ekstraktora, dzięki czemu jest szybszy.

Dzięki wyrażeniom regularnym i kompilowaniu wyrażenia regularnego po zamknięciu dopasowanie JavaScript zwróci wszystkie dopasowania.

To pozostawia nam jedynie konieczność usuwania tego, co wykorzystaliśmy jako nasze znaczniki (tj .:), {{i możemy użyć do tego długości łańcucha z plasterkiem.

function extract([beg, end]) {
    const matcher = new RegExp(`${beg}(.*?)${end}`,'gm');
    const normalise = (str) => str.slice(beg.length,end.length*-1);
    return function(str) {
        return str.match(matcher).map(normalise);
    }
}

Skompiluj raz i użyj wiele razy ...

const stringExtractor = extract(['{','}']);
const stuffIneed = stringExtractor('this {is} some {text} that can be {extracted} with a {reusable} function');
// Outputs: [ 'is', 'text', 'extracted', 'reusable' ]

Lub jednorazowe użycie ...

const stuffIneed = extract(['{','}'])('this {is} some {text} that can be {extracted} with a {reusable} function');
// Outputs: [ 'is', 'text', 'extracted', 'reusable' ]

Spójrz także na replacefunkcję Javascript, ale używając funkcji zastępującej argument (Zrobiłbyś to, jeśli na przykład robiłeś silnik mini szablonów (interpolacja ciągów) ... lodash.get może być również pomocny, aby uzyskać wartości, które chcesz zamienić ? ...

Moja odpowiedź jest za długa, ale może komuś pomóc!

Możesz także użyć tego ...

function extractText(str,delimiter){
  if (str && delimiter){
    var firstIndex = str.indexOf(delimiter)+1;
    var lastIndex = str.lastIndexOf(delimiter);
    str = str.substring(firstIndex,lastIndex);
  }
  return str;
}


var quotes = document.getElementById("quotes");

// &#34 - represents quotation mark in HTML

<div>


  <div>
  
    <span id="at">
      My string is @between@ the "at" sign
    </span>
    <button onclick="document.getElementById('at').innerText = extractText(document.getElementById('at').innerText,'@')">Click</button>
  
  </div>
  
  <div>
    <span id="quotes">
      My string is "between" quotes chars
    </span>
    <button onclick="document.getElementById('quotes').innerText = extractText(document.getElementById('quotes').innerText,'&#34')">Click</button>
  
  </div>

</div>

Uzyskaj ciąg między dwoma podciągami (zawiera więcej niż 1 znak)

function substrInBetween(whole_str, str1, str2){
   if (whole_str.indexOf(str1) === -1 || whole_str.indexOf(str2) === -1) {
       return undefined; // or ""
  }
  strlength1 = str1.length;
  return whole_str.substring(
                whole_str.indexOf(str1) + strlength1, 
                whole_str.indexOf(str2)
               );

   }

Uwaga: Używam indexOf()zamiast, lastIndexOf()więc sprawdzi po raz pierwszy te ciągi

Spróbuj tego, aby uzyskać podciąg między dwoma znakami za pomocą javascript.

        $("button").click(function(){
            var myStr = "MyLongString:StringIWant;";
            var subStr = myStr.match(":(.*);");
            alert(subStr[1]);
        });

Zaczerpnięte z @ Znajdź podciąg między dwoma znakami za pomocą jQuery

Korzystanie z jQuery :

get_between <- function(str, first_character, last_character) {
    new_str = str.match(first_character + "(.*)" + last_character)[1].trim()
    return(new_str)
    }

strunowy

my_string = 'and the thing that ! on the @ with the ^^ goes now' 

użycie :

get_between(my_string, 'that', 'now')

wynik :

"! on the @ with the ^^ goes

Stworzyłem małą funkcję, która może przechwytywać ciąg między, i może (opcjonalnie) pomijać kilka dopasowanych słów, aby pobrać określony indeks.

Ponadto ustawienie startna falseużyje początku łańcucha, a ustawienie endna falseużyje końca łańcucha.

ustawiony pos1na pozycję starttekstu, którego chcesz użyć, 1użyje pierwszego wystąpieniastart

pos2robi to samo co pos1, ale dla endi 1użyje pierwszego wystąpienia enddopiero po start, wystąpienia endwcześniej startsą ignorowane.

function getStringBetween(str, start=false, end=false, pos1=1, pos2=1){
  var newPos1 = 0;
  var newPos2 = str.length;

  if(start){
    var loops = pos1;
    var i = 0;
    while(loops > 0){
      if(i > str.length){
        break;
      }else if(str[i] == start[0]){
        var found = 0;
        for(var p = 0; p < start.length; p++){
          if(str[i+p] == start[p]){
            found++;
          }
        }
        if(found >= start.length){
          newPos1 = i + start.length;
          loops--;
        }
      }
      i++;
    }
  }

  if(end){
    var loops = pos2;
    var i = newPos1;
    while(loops > 0){
      if(i > str.length){
        break;
      }else if(str[i] == end[0]){
        var found = 0;
        for(var p = 0; p < end.length; p++){
          if(str[i+p] == end[p]){
            found++;
          }
        }
        if(found >= end.length){
          newPos2 = i;
          loops--;
        }
      }
      i++;
    }
  }

  var result = '';
  for(var i = newPos1; i < newPos2; i++){
    result += str[i];
  }
  return result;
}

To może być możliwe rozwiązanie

var str = 'RACK NO:Stock;PRODUCT TYPE:Stock Sale;PART N0:0035719061;INDEX NO:21A627 042;PART NAME:SPRING;';  
var newstr = str.split(':')[1].split(';')[0]; // return value as 'Stock'

console.log('stringvalue',newstr)