使用javascript获取两个字符之间的子字符串

我试图从一个较大的字符串中提取一个字符串，使它在'：'和';'之间得到一切。

当前

Str = 'MyLongString:StringIWant;'

期望的输出

newStr = 'StringIWant'

你可以试试这个

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

您也可以尝试以下操作：

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

用 split()

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

arrStr将包含所有以:或分隔的字符串，;
因此通过访问每个字符串for-loop

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

@Babasaheb Gosavi如果出现一次子字符串（“：”和“;”），则答案是完美的。但是一旦发生多次，可能会有些棘手。

我想出的用于多个项目的最佳解决方案是在一个对象内部使用四种方法。

• 第一种方法：实际上是从两个字符串之间获取一个子字符串（但是只会找到一个结果）。
• 第二种方法：将删除（可能是）最近发现的结果以及其前后的子字符串。
• 第三种方法：将在字符串上递归执行上述两种方法。
• 第四种方法：将应用第三种方法并返回结果。

码

如此多的讨论，让我们看一下代码：

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

如何使用？

例：

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

我喜欢这种方法：

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

我使用@tsds方式，但仅使用split功能。

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

温馨提示：如果therre在访问数组索引为'1'的字符串中不为“：”，则会抛出错误！str.split（'：'）[1]

因此，如果存在不确定性，@ tsds方式会更安全

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

您可以使用更高阶的函数来返回提取器的“已编译”版本，这样可以更快。

使用正则表达式，并在关闭时编译一次正则表达式，Javascript的匹配项将返回所有匹配项。

这样，我们仅需删除用作标记的内容（即：）{{，就可以在切片中使用字符串长度了。

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

编译一次并多次使用...

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

还是一次性使用...

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

还要看一下Javascript的replace函数，但是要使用一个函数作为替换参数（例如，如果您正在使用小型模板引擎（字符串插值），则可以这样做... lodash.get可能对获取想要的值也很有帮助。用。。。来代替 ？ ...

我的回答太长，但可能会对某人有所帮助！

您也可以使用此...

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>

在子字符串之间获取字符串（包含多个1个字符）

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

   }

请注意，我使用indexOf()代替，lastIndexOf()因此它将检查这些字符串的首次出现

尝试使用javascript在两个字符之间获取子字符串。

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

取自@ 使用jQuery查找两个字符之间的子字符串

使用jQuery：

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

串

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

用法：

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

结果：

"! on the @ with the ^^ goes

我制作的一个小函数可以捕获之间的字符串，并且可以（可选）跳过多个匹配的单词以捕获特定的索引。

另外，设置start为false将使用字符串的开头，设置end为false将使用字符串的结尾。

设置pos1为start要使用的文本的位置，1将使用第一个出现的start

pos2与的功能相同pos1，但对于end，1将end仅使用after之后的第一次start出现，endbefore的出现会start被忽略。

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

这可能是解决方案

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)