Come si estrae una sottostringa da una stringa finché non si incontra il secondo spazio?

Question

Ho una stringa come questa:

"o1 1232.5467 1232.5467 1232.5467 1232.5467 1232.5467 1232.5467"

Come posso estrarre solo "o1 1232.5467"?

Il numero di caratteri da estrarre non è sempre lo stesso. Quindi, voglio estrarre solo fino a quando non si incontra il secondo spazio.

Answer 1

Utilizzare un'espressione regolare:.

Match m = Regex.Match(text, @"(.+? .+?) "); 
if (m.Success) { 
    do_something_with(m.Groups[1].Value); 
} 

Answer 2

Un approccio diretto potrebbe essere il seguente:

string[] tokens = str.Split(' '); 
string retVal = tokens[0] + " " + tokens[1]; 

Answer 3

Basta usare String.IndexOf due volte come in:

 string str = "My Test String"; 
    int index = str.IndexOf(' '); 
    index = str.IndexOf(' ', index + 1); 
    string result = str.Substring(0, index); 

Answer 4

Prendi la posizione del primo spazio:

int space1 = theString.IndexOf(' '); 

La posizione del n spazio ext dopo che:

int space2 = theString.IndexOf(' ', space1 + 1); 

ottenere la parte della stringa fino al secondo spazio:

string firstPart = theString.Substring(0, space2); 

Il codice sopra messo togehter in una battuta:

string firstPart = theString.Substring(0, theString.IndexOf(' ', theString.IndexOf(' ') + 1)); 

Answer 5

string[] parts = myString.Split(" "); 
string whatIWant = parts[0] + " "+ parts[1]; 

Answer 6

s.Substring(0, s.IndexOf(" ", s.IndexOf(" ") + 1)) 

Answer 7

string testString = "o1 1232.5467 1232.5467........."; 

string secondItem = testString.Split(new char[]{' '}, 3)[1]; 

Answer 8

Qualcosa di simile a questo:

int i = str.IndexOf(' '); 
i = str.IndexOf(' ', i + 1); 
return str.Substring(i); 

Answer 9

Ci sono modi più brevi di farlo, come altri hanno detto, ma si possono anche controllare ogni personaggio fino a quando si incontra un secondo spazio da soli, per poi tornare stringa corrispondente.

static string Extract(string str) 
{ 
    bool end = false; 
    int length = 0 ; 
    foreach (char c in str) 
    { 
     if (c == ' ' && end == false) 
     { 
      end = true; 
     } 
     else if (c == ' ' && end == true) 
     { 
      break; 
     } 

     length++; 
    } 

    return str.Substring(0, length); 
} 

Answer 10

Si potrebbe provare a trovare l'indice di "o1" prima. Quindi estrailo. Dopo questo, dividere la stringa con i caratteri "1232.5467":

 string test = "o1 1232.5467 1232.5467 1232.5467 1232.5467 1232.5467 1232.5467"; 
     string header = test.Substring(test.IndexOf("o1 "), "o1 ".Length); 
     test = test.Substring("o1 ".Length, test.Length - "o1 ".Length); 
     string[] content = test.Split(' '); 

Answer 11

consiglierei un'espressione regolare per questo dato che si occupa dei casi che si potrebbe non avere considerato.

var input = "o1 1232.5467 1232.5467 1232.5467 1232.5467 1232.5467 1232.5467"; 
var regex = new Regex(@"^(.*? .*?) "); 
var match = regex.Match(input); 
if (match.Success) 
{ 
    Console.WriteLine(string.Format("'{0}'", match.Groups[1].Value)); 
} 

Answer 12

: P

Solo una nota, penso che la maggior parte degli algoritmi qui solito controllare se si dispone di 2 o più spazi insieme, quindi potrebbe ottenere uno spazio come seconda parola.

Non so se è il modo migliore, ma ho avuto un po 'di divertimento linqing esso: P (la cosa buona è che permette di scegliere il numero di spazi/parole che si desidera prendere)

 var text = "a sdasdf ad a"; 
     int numSpaces = 2; 
     var result = text.TakeWhile(c => 
      { 
       if (c==' ') 
        numSpaces--; 

       if (numSpaces <= 0) 
        return false; 

       return true; 
      }); 
     text = new string(result.ToArray()); 

ho anche avuto @ risposta di ho e ha reso in un ciclo così si potrebbe ancora usarlo per quante più parole che vuoi: P

 string str = "My Test String hello world"; 
     int numberOfSpaces = 3; 
     int index = str.IndexOf(' ');  

     while (--numberOfSpaces>0) 
     { 
      index = str.IndexOf(' ', index + 1); 
     } 

     string result = str.Substring(0, index); 

Answer 13

stavo pensando a questo problema per il mio codice e, anche se Probabilmente finirò per usare qualcosa di più semplice/veloce, ecco un'altra soluzione Linq simile a una che @Francisco a dded.

Mi piace perché legge il più simile a ciò che effettivamente si vuole fare: "Prendere caratteri mentre la sottostringa risultante ha meno di 2 spazi".

string input = "o1 1232.5467 1232.5467 1232.5467 1232.5467 1232.5467 1232.5467"; 
var substring = input.TakeWhile((c0, index) => 
           input.Substring(0, index + 1).Count(c => c == ' ') < 2); 
string result = new String(substring.ToArray());