【发布时间】：2013-01-29 20:12:46
【问题描述】：
我正在尝试从一个较大的字符串中提取一个字符串，它可以获取: 和; 之间的所有内容
当前
Str = 'MyLongString:StringIWant;'
期望的输出
newStr = 'StringIWant'
【问题讨论】：
标签： javascript regex string substring
【发布时间】：2013-01-29 20:12:46
【问题描述】：
你可以试试这个
var mySubString = str.substring(
str.indexOf(":") + 1,
str.lastIndexOf(";")
);
【讨论】：
-
简单的解决方案，但很方便，特别是如果您想避免使用正则表达式。
-
有谁知道我会如何在我的起始字符串和结束字符串之间每次出现子字符串时执行此操作？
-
这并没有涵盖许多其他情况（我认为当解决方案过于具体时它不是那么有用）。请参阅 tsds 的答案，它涵盖了更多情况。
你也可以试试这个：
var str = 'one:two;three';
str.split(':').pop().split(';')[0]; // returns 'two'
【讨论】：
-
这应该是选择的答案，因为它涵盖了许多其他情况，例如：有多个字符而不是只有一个；寻找下一个事件；这解决了我的需求，而投票最多的答案没有。我不得不从 URL 中提取版本：somewhere.com/something/version_1.2.3/somethingElse/page，这就像一个魅力。
-
这有一个挫折.. 如果没有 : 也没有 ;返回整个 str :)
-
呸！我仍然可以让我的 lambda 不戴手镯。
-
非常适合 URL
使用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]);
【讨论】：
-
我想要的字符串在 [ ] 之间，这不起作用...例如：'MyLongString[StringIWant]'.split(/[[]]/);
-
@Philippe 对于您的用例，请使用此正则表达式
\[(.*?)\]---> 简而言之，您需要转义方括号，因为 [ ] 表示正则表达式中的字符类。
@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]
【讨论】：
-
获取
RangeError: Maximum call stack size exceeded异常。 -
很好的答案。这正是我所需要的。
-
获取
this.string = this.string.replace(removal, ""); RangeError: Maximum call stack size exceeded -
这是唯一的递归答案，很好。
var s = 'MyLongString:StringIWant;';
/:([^;]+);/.exec(s)[1]; // StringIWant
【讨论】：
-
的目的是什么；在 [^;]
-
翻译为：“/”开始模式。将 ":" 与 "[]" 匹配任何 "^;"不是分号“+”反复找一个“；”分号和“/”结束模式。
我喜欢这种方法：
var str = 'MyLongString:StringIWant;';
var tmpStr = str.match(":(.*);");
var newStr = tmpStr[1];
//newStr now contains 'StringIWant'
【讨论】：
-
我在 SharePoint 2013 Webpart 中对此进行了测试，如果这对未来的任何人有帮助的话，效果很好！
-
如果你想要的字符串在 "(" 和 ")" 之间，这可能不起作用
您可以使用高阶函数返回提取器的“编译”版本，这样会更快。
使用正则表达式，并在闭包中编译一次正则表达式，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 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
【讨论】：
-
这是 2 个字符之间的字符串的绝佳解决方案
-
简单解决方案
我使用@tsds 方式，但只使用拆分功能。
var str = 'one:two;three';
str.split(':')[1].split(';')[0] // returns 'two'
注意：如果字符串中没有“:”，访问数组的'1'索引会抛出错误！ str.split(':')[1]
因此，如果存在不确定性，@tsds 方式更安全
str.split(':').pop().split(';')[0]
【讨论】：
你也可以用这个...
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");
// " - 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,'"')">Click</button>
</div>
</div>【讨论】：
这可能是可能的解决方案
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)
【讨论】：
获取两个子字符串之间的字符串（包含多于1个字符）
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)
);
}
注意我使用indexOf() 而不是lastIndexOf() 所以它会检查这些字符串的第一次出现
【讨论】：
-
不错且可读性强的函数。但是
strlength1变量的目的是什么？该值应改为内联使用。也不清楚您使用的是哪个case style。strlength1- 没有风格，whole_str- 蛇盒。
使用“get_between”实用函数：
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
【讨论】：
尝试使用javascript获取两个字符之间的子字符串。
$("button").click(function(){
var myStr = "MyLongString:StringIWant;";
var subStr = myStr.match(":(.*);");
alert(subStr[1]);
});
【讨论】：
我制作的一个小函数可以抓取中间的字符串，并且可以（可选）跳过一些匹配的单词来抓取特定的索引。
另外，将start 设置为false 将使用字符串的开头，将end 设置为false 将使用字符串的结尾。
将pos1设置为您要使用的start文本的位置，1将使用start的第一次出现
pos2 与pos1 做同样的事情，但对于end，1 将仅在start 之后使用end 的第一次出现，end 在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 out = []; 'MyLongString:StringIWant;'
.replace(/(:)\w+(;)+/g, (e) => {
out.push(e.replace(':', '').replace(';', ''))
return e;
});
console.log(out[0])
【讨论】：
上面的代码适用于简单的示例，但可以帮助... 使用打字稿。
参数
-
sentence: 你想得到的字符串 -
first：起始字符（对于初始示例，它将是:） -
last：您的角色的最后一个字符（对于初始示例，它将是;）
输出
字符串数组 (string[])。如果sentence 中没有好的部分，则返回[]。
代码
function getParts(sentence: string, first: string, last: string): string[] {
let goodParts: string[] = [];
const allParts = sentence.split(first);
allParts.forEach((part: string) => {
if (part.indexOf(last) > -1) {
const goodOne = (part.split(last))[0];
goodParts = goodParts.concat(goodOne);
}
});
return goodParts;
}
示例
const origin = "wrongString1:rightString1;wrongString2:rightString2;wrongString3:rightString3;wrongString4:rightString4;";
const result = getParts(origin, ':', ';');
console.log(result);
// ["rightString1", "rightString2", "rightString3", "rightString4"]
【讨论】：
如果您想从字符串中提取出现在两个分隔符（不同或相同）之间的所有子字符串，您可以使用此函数。它返回一个包含所有找到的子字符串的数组：
function get_substrings_between(str, startDelimiter, endDelimiter)
{
var contents = [];
var startDelimiterLength = startDelimiter.length;
var endDelimiterLength = endDelimiter.length;
var startFrom = contentStart = contentEnd = 0;
while(false !== (contentStart = strpos(str, startDelimiter, startFrom)))
{
contentStart += startDelimiterLength;
contentEnd = strpos(str, endDelimiter, contentStart);
if(false === contentEnd)
{
break;
}
contents.push( str.substr(contentStart, contentEnd - contentStart) );
startFrom = contentEnd + endDelimiterLength;
}
return contents;
}
// https://stackoverflow.com/a/3978237/1066234
function strpos(haystack, needle, offset)
{
var i = (haystack+'').indexOf(needle, (offset || 0));
return i === -1 ? false : i;
}
// Example usage
var string = "We want to extract all infos (essential ones) from within the brackets (this should be fun).";
var extracted = get_substrings_between(string, '(', ')');
console.log(extracted);
// output: (2) ["essential ones", "this should be fun"]
最初来自 raina77ow 的 PHP，移植到 Javascript。
【讨论】：
var str = '[basic_salary]+100/[basic_salary]';
var arr = str.split('');
var myArr = [];
for(var i=0;i<arr.length;i++){
if(arr[i] == '['){
var a = '';
for(var j=i+1;j<arr.length;j++){
if(arr[j] == ']'){
var i = j-1;
break;
}else{
a += arr[j];
}
}
myArr.push(a);
}
var operatorsArr = ['+','-','*','/','%'];
if(operatorsArr.includes(arr[i])){
myArr.push(arr[i]);
}
var numbArr = ['0','1','2','3','4','5','6','7','8','9'];
if(numbArr.includes(arr[i])){
var a = '';
for(var j=i;j<arr.length;j++){
if(numbArr.includes(arr[j])){
a += arr[j];
}else{
var i = j-1;
break;
}
}
myArr.push(a);
}
}
myArr = ["basic_salary", "+", "100", "/", "basic_salary"]
【讨论】：
你可以使用这个功能-
function getStringInBetween(string, start , end) {
// start and end will be excluded
var indexOfStart = string.indexOf(start)
indexOfStart = indexOfStart + start.length;
var newString = string.slice(indexOfStart)
var indexOfEnd = newString.indexOf(end)
return newString.slice(0, indexOfEnd)
}
前-
let string = "<div class = 'mice'> I know how to code </div>"
let start = "<div class = 'mice'> "
let end = " </div>"
//then, getStringInBetween(string, start, end) returns "I know how to code"
【讨论】：
这是我刚做的。
请注意，如果在start 之后没有找到end，该函数将返回start 之后的所有内容。它还期望 start 和 end 只出现一次，如果有多个 - 它只会考虑第一个。
许可：公共领域
/**
* Extracts a string from `source` that is placed between `start` and `end`. The function
* considers only one instance of start and before, or the first instance and does not support
* multiple occurences otherwise. If end string is not found, it will return everything after
* `start` to the end of the string.
*/
export function stringBetween(source, start, end) {
if (source.indexOf(start) === -1) {
return null;
}
const sourceSplitByStartString = source.split(start);
// Note: If start string is the very first occurence in source string, the result will be an
// array where the first item is an empty string and the next item is of interest.
if (
sourceSplitByStartString.length === 1
|| sourceSplitByStartString[1] === ''
) {
// It means that start is either the entire string or is at the very end of the string, so there
// is not anything between
return '';
}
const afterStart = sourceSplitByStartString[1];
// If the after separator is not found, return everything after the start separator to the end
// of the string
if (afterStart.indexOf(end) === -1) {
return afterStart;
}
const afterStartSplitByEnd = afterStart.split(end);
if (afterStartSplitByEnd[0] === '') {
return '';
}
return afterStartSplitByEnd[0];
}
测试：
import { stringBetween } from './string';
describe('string utlities', () => {
describe('stringBetween', () => {
it('Extracts a substring between 2 other substrings', () => {
const sample1 = stringBetween('Black cat climbed the tree fast.', 'cat ', ' the tree');
expect(sample1).toBe('climbed');
const sample2 = stringBetween('Black cat climbed the tree fast.', 'Black ', ' fast.');
expect(sample2).toBe('cat climbed the tree');
});
it('extracts everything after start if end is not found', () => {
const sample2 = stringBetween('Black cat climbed the tree fast.', 'Black ', 'not-there');
expect(sample2).toBe('cat climbed the tree fast.');
});
it('returns empty string if start string occurs at the end', () => {
const sample = stringBetween('Black cat climbed the tree fast.', 'fast.', 'climbed');
expect(sample).toBe('');
});
it('returns empty string if start string is the entire string', () => {
const sample = stringBetween('Black cat', 'Black cat', 'climbed');
expect(sample).toBe('');
});
it('returns empty string if there is not anything between start and end', () => {
const sample = stringBetween('Black cat climbed the tree fast.', 'climbed ', 'the tree');
expect(sample).toBe('');
});
it('returns null if start string does not exist in the source string', () => {
const sample = stringBetween('Black cat climbed the tree fast.', 'not-there ', 'the tree');
expect(sample).toBe(null);
});
});
});
【讨论】：
以下函数获取第一个匹配项
function getStringBetween(x: string, start: string, end: string) {
const regex = new RegExp(`${start}(.*?)${end}`)
if (regex.test(x)) {
return regex.exec(x)![1]
} else return undefined
}
笑话测试
test("getStringBetween", () => {
const result = getStringBetween("<em> Jai Ram</em>", "<em>", "</em>")
expect(result).toEqual(" Jai Ram")
const result1 = getStringBetween(
"hare Jai Ram hare hare hare",
"hare",
"hare"
)
expect(result1).toEqual(" Jai Ram ")
})
【讨论】：