Question

我有一个字符串：

"super exemple of string key : text I want to keep - end of my string"

我想保留"key : "和" - "之间的字符串。我怎样才能做到这一点？我必须使用正则表达式，还是可以用其他方式进行？

Answer 1

也许，一个好方法就是删除子串：

String St = "super exemple of string key : text I want to keep - end of my string";

int pFrom = St.IndexOf("key : ") + "key : ".Length;
int pTo = St.LastIndexOf(" - ");

String result = St.Substring(pFrom, pTo - pFrom);

Answer 2

string input = "super exemple of string key : text I want to keep - end of my string";
var match = Regex.Match(input, @"key : (.+?)-").Groups[1].Value;

或仅使用字符串操作

var start = input.IndexOf("key : ") + 6;
var match2 = input.Substring(start, input.IndexOf("-") - start);

Answer 3

你可以在没有正则表达式的情况下完成

 input.Split(new string[] {"key :"},StringSplitOptions.None)[1]
      .Split('-')[0]
      .Trim();

Answer 4

根据您希望实现的强大/灵活程度，这实际上有点棘手。这是我使用的实现：

public static class StringExtensions {
    /// <summary>
    /// takes a substring between two anchor strings (or the end of the string if that anchor is null)
    /// </summary>
    /// <param name="this">a string</param>
    /// <param name="from">an optional string to search after</param>
    /// <param name="until">an optional string to search before</param>
    /// <param name="comparison">an optional comparison for the search</param>
    /// <returns>a substring based on the search</returns>
    public static string Substring(this string @this, string from = null, string until = null, StringComparison comparison = StringComparison.InvariantCulture)
    {
        var fromLength = (from ?? string.Empty).Length;
        var startIndex = !string.IsNullOrEmpty(from) 
            ? @this.IndexOf(from, comparison) + fromLength
            : 0;

        if (startIndex < fromLength) { throw new ArgumentException("from: Failed to find an instance of the first anchor"); }

            var endIndex = !string.IsNullOrEmpty(until) 
            ? @this.IndexOf(until, startIndex, comparison) 
            : @this.Length;

        if (endIndex < 0) { throw new ArgumentException("until: Failed to find an instance of the last anchor"); }

        var subString = @this.Substring(startIndex, endIndex - startIndex);
        return subString;
    }
}

// usage:
var between = "a - to keep x more stuff".Substring(from: "-", until: "x");
// returns " to keep "

Answer 5

正则表达式在这里过度。

查看Substring和IndexOf - 前者获取给定字符串的部分，索引和长度，第二个用于查找内部字符串/字符的索引。

Answer 6

以下是我如何做到这一点的方式

   public string Between(string STR , string FirstString, string LastString)
    {       
        string FinalString;     
        int Pos1 = STR.IndexOf(FirstString) + FirstString.Length;
        int Pos2 = STR.IndexOf(LastString);
        FinalString = STR.Substring(Pos1, Pos2 - Pos1);
        return FinalString;
    }

Answer 7

我认为这有效：

   static void Main(string[] args)
    {
        String text = "One=1,Two=2,ThreeFour=34";

        Console.WriteLine(betweenStrings(text, "One=", ",")); // 1
        Console.WriteLine(betweenStrings(text, "Two=", ",")); // 2
        Console.WriteLine(betweenStrings(text, "ThreeFour=", "")); // 34

        Console.ReadKey();

    }

    public static String betweenStrings(String text, String start, String end)
    {
        int p1 = text.IndexOf(start) + start.Length;
        int p2 = text.IndexOf(end, p1);

        if (end == "") return (text.Substring(p1));
        else return text.Substring(p1, p2 - p1);                      
    }

Answer 8

 string str="super exemple of string key : text I want to keep - end of my string";
        int startIndex = str.IndexOf("key") + "key".Length;
        int endIndex = str.IndexOf("-");
        string newString = str.Substring(startIndex, endIndex - startIndex);

Answer 9

正在运行的LINQ解决方案：

string str = "super exemple of string key : text I want to keep - end of my string";
string res = new string(str.SkipWhile(c => c != ':')
                           .Skip(1)
                           .TakeWhile(c => c != '-')
                           .ToArray()).Trim();
Console.WriteLine(res); // text I want to keep

Answer 10

或者，使用正则表达式。

using System.Text.RegularExpressions;

...

var value =
    Regex.Match(
        "super exemple of string key : text I want to keep - end of my string",
        "key : (.*) - ")
    .Groups[1].Value;

使用running example。

你可以决定它是否过度。

或

作为未经验证的扩展方法

using System.Text.RegularExpressions;

public class Test
{
    public static void Main()
    {
        var value =
                "super exemple of string key : text I want to keep - end of my string"
                    .Between(
                        "key : ",
                        " - ");

        Console.WriteLine(value);
    }
}

public static class Ext
{
    static string Between(this string source, string left, string right)
    {
        return Regex.Match(
                source,
                string.Format("{0}(.*){1}", left, right))
            .Groups[1].Value;
    }
}

Answer 11

由于:和-是唯一的，您可以使用：

string input;
string output;
input = "super example of string key : text I want to keep - end of my string";
output = input.Split(new char[] { ':', '-' })[1];

Answer 12

您可以使用以下扩展方法：

public static string GetStringBetween(this string token, string first, string second)
    {            
        if (!token.Contains(first)) return "";

        var afterFirst = token.Split(new[] { first }, StringSplitOptions.None)[1];

        if (!afterFirst.Contains(second)) return "";

        var result = afterFirst.Split(new[] { second }, StringSplitOptions.None)[0];

        return result;
    }

用法是：

var token = "super exemple of string key : text I want to keep - end of my string";
var keyValue = token.GetStringBetween("key : ", " - ");

Answer 13

var matches = Regex.Matches(input, @"(?<=key :)(.+?)(?=-)");

这只返回“key：”和下面出现的“ - ”

之间的值

Answer 14

你已经有了一些很好的答案，我意识到我提供的代码远非最有效和最干净的代码。但是，我认为它可能对教育目的有用。我们可以整天使用预先构建的类和库。但是，如果不了解内部运作，我们只是模仿和重复，永远不会学到任何东西。这段代码比其他一些代码更有基础或“处女”：

char startDelimiter = ':';
char endDelimiter = '-';

Boolean collect = false;

string parsedString = "";

foreach (char c in originalString)
{
    if (c == startDelimiter)
         collect = true;

    if (c == endDelimiter)
         collect = false;

    if (collect == true && c != startDelimiter)
         parsedString += c;
}

您最终得到了分配给parsedString变量的所需字符串。请记住，它还将捕获前进和前面的空格。请记住，字符串只是一个字符数组，可以像其他带索引等的数组一样进行操作。

小心。

Answer 15

我使用了Vijay Singh Rana的代码片段，基本上可以完成工作。但是如果firstString已经包含lastString，则会引起问题。我想要的是从JSON响应（未加载JSON解析器）中提取access_token。我的firstString是\"access_token\": \"，我的“ lastString”是\"。我最后做了一些修改

string Between(string str, string firstString, string lastString)
{       
    string finalString;     
    int pos1 = str.IndexOf(firstString) + firstString.Length;
    int pos2 = str.Substring(pos1).IndexOf(lastString) + pos1;
    finalString = str.Substring(pos1, pos2 - pos1);
    return finalString;
}

Answer 16

  private string gettxtbettwen(string txt, string first, string last)
    {

        StringBuilder sb = new StringBuilder(txt);
        int pos1 = txt.IndexOf(first)  + first.Length;
        int len = (txt.Length ) - pos1;

        string reminder = txt.Substring(pos1, len);


        int pos2 = reminder.IndexOf(last) - last.Length +1;


       



        return reminder.Substring(0, pos2); 



    }

Answer 17

如果要处理子字符串对的多次出现，没有RegEx将不容易：

Regex.Matches(input ?? String.Empty, "(?=key : )(.*)(?<= - )", RegexOptions.Singleline);

input ?? String.Empty避免了参数null异常

?=保留第一个子字符串，?<=保留第二个子字符串

RegexOptions.Singleline允许在子字符串对之间使用换行符

如果子字符串的顺序和出现次数无关紧要，则可以选择以下方法之一：

var parts = input?.Split(new string[] { "key : ", " - " }, StringSplitOptions.None);
string result = parts?.Length >= 3 ? result[1] : input;

至少，如果没有子字符串或单个子字符串匹配，则通过返回原始字符串来避免大多数异常。

Answer 18

    public static string ExtractBetweenTwoStrings(string FullText, string StartString, string EndString, bool IncludeStartString, bool IncludeEndString)
    {
        try { int Pos1 = FullText.IndexOf(StartString) + StartString.Length; int Pos2 = FullText.IndexOf(EndString, Pos1); return ((IncludeStartString) ? StartString : "") 
                + FullText.Substring(Pos1, Pos2 - Pos1) + ((IncludeEndString) ? EndString : ""); } catch (Exception ex) { return ex.ToString(); } //return ""; }
    }

归功于：https://www.c-sharpcorner.com/blogs/how-to-extract-a-string-lies-between-two-strings-in-c-sharpnet1

Answer 19

这里是扩展方法，以防有人对保留开始和结束文本感兴趣。

public static string SubstringBetween(this string text, string start, string end, bool keepStartEndText = false)
    {
        var startIndex = text.IndexOf(start);
        var endIndex = text.LastIndexOf(end);

        if (keepStartEndText)
            return text.Substring(startIndex, (endIndex + end.Length) - startIndex);
        else
            return text.Substring(startIndex + start.Length, endIndex - (startIndex + start.Length));
    }

Answer 20

这是;

 /// <summary>
    /// 
    /// </summary>
    /// <param name="line"></param>
    /// <param name="begin_tag"></param>
    /// <param name="end_tag"></param>
    /// <param name="lastIndexOfEndTag"></param>
    /// <returns></returns>
    private string getBetween(string line, string begin_tag, string end_tag, bool lastIndexOfEndTag = false, bool returnNullIfTagsNotExists = false)
    {
        if (!string.IsNullOrEmpty(line) && !string.IsNullOrEmpty(begin_tag) && !string.IsNullOrEmpty(end_tag))
        {
            //          1         2         3         4         5         6         7
            //0123456789012345678901234567890123456789012345678901234567890123456789012
            //StdErrorData:   Duration: 01:59:54.88, start: 0.000000, bitrate: 557 kb/s
            int startIndex = line.IndexOf(begin_tag);
            if (startIndex >= 0)
            {
                startIndex += begin_tag.Length;
            }
            else
            {
                if (returnNullIfTagsNotExists)
                {
                    return null;
                }
                else
                {
                    startIndex = 0;
                }
            }
            int endIndex = lastIndexOfEndTag ?
                line.LastIndexOf(end_tag, startIndex)
                : line.IndexOf(end_tag, startIndex);
            if (endIndex > startIndex)
            {
                return line.Substring(startIndex, endIndex - startIndex);
            }
            else
            {
                if (returnNullIfTagsNotExists)
                {
                    return null;
                }
                else
                {
                    return line.Substring(startIndex);
                }
            }
        }
        return null;
    }

测试；

string r = getBetween("StdErrorData:   Duration: 01:59:54.88, start: 0.000000, bitrate: 557 kb/s", "Duration:", ",");
Console.WriteLine($"<{r}>");
//< 01:59:54.88>

Answer 21

getStringBetween(startStr, endStr, fullStr) {
    string startIndex = fullStr.indexOf(startStr);
    string endIndex= fullStr.indexOf(endStr);
    return fullStr.substring(startIndex + startStr.length, endIndex);
}

Answer 22

当用单个例子陈述问题时，不可避免地会出现歧义。这个问题也不例外。

对于问题中给出的示例，所需的字符串很清楚：

super example of string key : text I want to keep - end of my string
                              ^^^^^^^^^^^^^^^^^^^

但是，此字符串只是要识别其某些子字符串的字符串和边界字符串的示例。我将考虑具有通用边界字符串的通用字符串，如下所示。

abc FF def PP ghi,PP jkl,FF mno PP pqr FF,stu FF vwx,PP yza
             ^^^^^^^^^^^^         ^^^^^

PP是前面的字符串，FF是后面的字符串，派对帽指示要匹配的子字符串。（在问题key : 中给出的示例是前面的字符串，-是后面的字符串。）我假设PP和FF在单词之前和之后边界（这样PPA和FF8不匹配。

派对帽所反映的我的假设如下：

第一个子字符串PP之前可以有一个（或多个）FF子字符串，如果存在，则将其忽略；
如果在遇到PP之前，PP之后是一个或多个FF，则后面的PP是前面和后面的字符串之间的子字符串的一部分；
如果在遇到PP之前FF之后是一个或多个PP，则FF之后的第一个PP被认为是以下对象字符串。

请注意，这里的许多答案仅处理以下形式的字符串

abc PP def FF ghi
      ^^^^^

或

abc PP def FF ghi PP jkl FF mno
      ^^^^^         ^^^^^

一个人可以使用正则表达式，代码结构或两者的组合来标识感兴趣的子字符串。我没有判断哪种方法最好。我将只介绍以下与感兴趣的子字符串匹配的正则表达式。

(?<=\bPP\b)(?:(?!\bFF\b).)*(?=\bFF\b)

Start your engine! ¹

我使用PCRE（PHP）regex引擎对此进行了测试，但是由于该regex一点都不陌生，因此我确信它可以与.NET regex引擎一起使用（功能非常强大）。

正则表达式引擎执行以下操作：

(?<=          : begin a positive lookbehind
  \bPP\b      : match 'PP'
)             : end positive lookbehind
(?:           : begin a non-capture group
  (?!         : begin a negative lookahead
    \bFF\b    : match 'FF'
  )           : end negative lookahead
  .           : match any character
)             : end non-capture group
*             : execute non-capture group 0+ times
(?=           : begin positive lookahead
   \bFF\b     : match 'FF'
)             : end positive lookahead

这项技术，是在前面的字符串之后，一次匹配一个字符，直到该字符为F，之后是F（或更普遍的是，该字符就是构成字符串的字符串）后面的字符串）称为Tempered Greedy Token Solution。

很自然，如果我改变了上面的假设，则必须修改正则表达式（如果可能的话）。

^{1。四处移动光标以获取详细说明。}

Answer 23

也许是这样

private static string Between(string text, string from, string to)
{
    return text[(text.IndexOf(from)+from.Length)..text.IndexOf(to, text.IndexOf(from))];
}

Answer 24

使用dotnetcore 3.0，您可以

var s = "header-THE_TARGET_STRING.7z";
var from = s.IndexOf("-") + "-".Length;
var to = s.IndexOf(".7z");
var versionString = f[from..to];  // THE_TARGET_STRING

Answer 25

如果您正在寻找1行解决方案，就是这样：

s.Substring(s.IndexOf("eT") + "eT".Length).Split("97".ToCharArray()).First()

整个1行解决方案，带有System.Linq：

using System;
using System.Linq;

class OneLiner
{
    static void Main()
    {
        string s = "TextHereTisImortant973End"; //Between "eT" and "97"
        Console.WriteLine(s.Substring(s.IndexOf("eT") + "eT".Length)
                           .Split("97".ToCharArray()).First());
    }
}

Answer 26

我总是说没有什么是不可能的：

string value =  "super exemple of string key : text I want to keep - end of my string";
Regex regex = new Regex(@"(key \: (.*?) _ )");
Match match = regex.Match(value);
if (match.Success)
{
    Messagebox.Show(match.Value);
}

请记住，应该添加System.Text.RegularExpressions的引用

希望我帮助过。

获取字符串中两个字符串之间的字符串

26 个答案:

或