Holen Sie sich Teilzeichenfolge zwischen zwei Zeichen mit Javascript

Ich versuche, eine Zeichenfolge aus einer größeren Zeichenfolge zu extrahieren, in der alles zwischen einem ':' und einem ';' angezeigt wird.

Aktuell

Str = 'MyLongString:StringIWant;'

Gewünschte Ausgabe

newStr = 'StringIWant'

Sie können dies versuchen

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

Sie können dies auch versuchen:

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

Verwenden split()

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

arrStrenthält alle Zeichenfolgen, die durch :oder begrenzt sind. Greifen Sie ;
also auf jede Zeichenfolge zufor-loop

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

@Babasaheb Gosavi Die Antwort ist perfekt, wenn die Teilzeichenfolgen einmal vorkommen (":" und ";"). Sobald Sie jedoch mehrere Vorkommen haben, kann es etwas schwierig werden.

Die beste Lösung, die ich für die Arbeit an mehreren Projekten gefunden habe, ist die Verwendung von vier Methoden innerhalb eines Objekts.

• Erste Methode: Es wird tatsächlich ein Teilstring zwischen zwei Zeichenfolgen abgerufen (es wird jedoch nur ein Ergebnis gefunden).
• Zweite Methode: Entfernt das (potenzielle) zuletzt gefundene Ergebnis mit den Teilzeichenfolgen danach und davor.
• Dritte Methode: Führt die beiden oben genannten Methoden rekursiv für eine Zeichenfolge aus.
• Vierte Methode: Wendet die dritte Methode an und gibt das Ergebnis zurück.

Code

Also genug reden, sehen wir uns den Code an:

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

Wie benutzt man?

Beispiel:

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

Ich mag diese Methode:

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

Ich habe @tsds verwendet, aber nur mit der Split-Funktion.

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

Achtung: Wenn in der Zeichenfolge kein ":" enthalten ist, wird beim Zugriff auf den '1'-Index des Arrays ein Fehler ausgegeben! str.split (':') [1]

Daher ist @tsds Weg sicherer, wenn Unsicherheit besteht

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

Sie können eine Funktion höherer Ordnung verwenden, um eine 'kompilierte' Version Ihres Extraktors zurückzugeben. Auf diese Weise ist sie schneller.

Mit regulären Ausdrücken und dem einmaligen Kompilieren des regulären Ausdrucks in einem Abschluss gibt die Übereinstimmung von Javascript alle Übereinstimmungen zurück.

Dadurch müssen wir nur noch das entfernen, was wir als Marker verwendet haben (dh :), {{und wir können dafür die Stringlänge mit Slice verwenden.

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

Einmal kompilieren und mehrmals verwenden ...

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

Oder einmalige Verwendung ...

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

Schauen Sie sich auch die replaceFunktion von Javascript an , aber verwenden Sie eine Funktion für das Ersetzungsargument (Sie würden dies tun, wenn Sie beispielsweise eine Mini-Template-Engine (String-Interpolation) ausführen ... lodash.get könnte dann auch hilfreich sein, um die gewünschten Werte zu erhalten ersetzen mit ? ...

Meine Antwort ist zu lang, aber es könnte jemandem helfen!

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

Sie können auch dieses verwenden ...

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>

Zeichenfolge zwischen Teilzeichenfolgen abrufen (enthält mehr als 1 Zeichen)

function substrInBetween(whole_str, str1, str2){
  strlength1 = str1.length;
  return whole_str.substring(
                whole_str.indexOf(str1) + strlength1, 
                whole_str.indexOf(str2)
               );

   }

Hinweis Ich verwende indexOf()stattdessen lastIndexOf(), damit das erste Auftreten dieser Zeichenfolgen überprüft wird

Versuchen Sie dies, um mithilfe von Javascript eine Teilzeichenfolge zwischen zwei Zeichen abzurufen.

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

Entnommen aus @ Find Teilzeichenfolge zwischen den beiden Zeichen mit jQuery

Verwenden von jQuery :

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

Zeichenfolge

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

Verwendung :

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

Ergebnis :

"! on the @ with the ^^ goes

Eine kleine Funktion, die ich erstellt habe, um die Zeichenfolge zwischen zu erfassen und (optional) eine Anzahl übereinstimmender Wörter zu überspringen, um einen bestimmten Index abzurufen.

Bei Einstellung startauf falsewird außerdem der Anfang der Zeichenfolge und bei Einstellung endauf falsedas Ende der Zeichenfolge verwendet.

Wenn Sie pos1die Position des zu verwendenden startTextes festlegen , 1wird das erste Vorkommen von verwendetstart

pos2macht das Gleiche wie pos1, aber für endund 1wird das erste Auftreten von endnur nach verwenden start, Vorkommen von endvor startwerden ignoriert.

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

Dies könnte die mögliche Lösung sein

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)