Regex để tách một chuỗi bằng cách sử dụng dấu cách khi không được bao quanh bởi dấu ngoặc kép hoặc đơn

Tôi mới sử dụng cụm từ thông dụng và rất mong sự giúp đỡ của bạn. Tôi đang cố gắng tập hợp một biểu thức sẽ chia chuỗi ví dụ bằng cách sử dụng tất cả các khoảng trắng không được bao quanh bởi dấu ngoặc kép hoặc đơn. Nỗ lực cuối cùng của tôi trông như thế này: (?!")và không hiệu quả. Nó tách ra trên không gian trước khi trích dẫn.

Ví dụ đầu vào:

This is a string that "will be" highlighted when your 'regular expression' matches something.

Sản phẩm chất lượng:

This
is
a
string
that
will be
highlighted
when
your
regular expression
matches
something.

Lưu ý điều đó "will be"và 'regular expression'giữ lại khoảng cách giữa các từ.

Tôi không hiểu tại sao tất cả những người khác lại đề xuất các biểu thức chính quy phức tạp hoặc mã dài như vậy. Về cơ bản, bạn muốn lấy hai loại thứ từ chuỗi của mình: chuỗi ký tự không phải là dấu cách hoặc dấu ngoặc kép và chuỗi ký tự bắt đầu và kết thúc bằng dấu ngoặc kép, không có dấu ngoặc kép ở giữa, đối với hai loại dấu ngoặc kép. Bạn có thể dễ dàng đối sánh những thứ đó với biểu thức chính quy này:

[^\s"']+|"([^"]*)"|'([^']*)'

Tôi đã thêm các nhóm chụp vì bạn không muốn các trích dẫn trong danh sách.

Mã Java này xây dựng danh sách, thêm nhóm thu thập nếu nó phù hợp để loại trừ các dấu ngoặc kép và thêm đối sánh regex tổng thể nếu nhóm thu thập không khớp (một từ chưa được trích dẫn đã khớp).

List<String> matchList = new ArrayList<String>();
Pattern regex = Pattern.compile("[^\\s\"']+|\"([^\"]*)\"|'([^']*)'");
Matcher regexMatcher = regex.matcher(subjectString);
while (regexMatcher.find()) {
    if (regexMatcher.group(1) != null) {
        // Add double-quoted string without the quotes
        matchList.add(regexMatcher.group(1));
    } else if (regexMatcher.group(2) != null) {
        // Add single-quoted string without the quotes
        matchList.add(regexMatcher.group(2));
    } else {
        // Add unquoted word
        matchList.add(regexMatcher.group());
    }
} 

Nếu bạn không phiền khi có các dấu ngoặc kép trong danh sách trả về, bạn có thể sử dụng mã đơn giản hơn nhiều:

List<String> matchList = new ArrayList<String>();
Pattern regex = Pattern.compile("[^\\s\"']+|\"[^\"]*\"|'[^']*'");
Matcher regexMatcher = regex.matcher(subjectString);
while (regexMatcher.find()) {
    matchList.add(regexMatcher.group());
} 

Có một số câu hỏi trên StackOverflow bao gồm cùng một câu hỏi này trong các ngữ cảnh khác nhau bằng cách sử dụng cụm từ thông dụng. Ví dụ:

• chuỗi phân tích cú pháp: trích xuất các từ và cụm từ
• Cách tốt nhất để phân tích cú pháp Văn bản được phân tách bằng dấu cách

CẬP NHẬT : Mẫu regex để xử lý các chuỗi được trích dẫn đơn và kép. Tham khảo: Làm cách nào tôi có thể tách trên một chuỗi ngoại trừ khi bên trong dấu ngoặc kép?

m/('.*?'|".*?"|\S+)/g 

Đã kiểm tra điều này bằng một đoạn mã Perl nhanh và kết quả như được tái tạo bên dưới. Cũng hoạt động đối với các chuỗi trống hoặc chuỗi chỉ có khoảng trắng nếu chúng nằm giữa các dấu ngoặc kép (không chắc liệu đó có phải là mong muốn hay không).

This
is
a
string
that
"will be"
highlighted
when
your
'regular expression'
matches
something.

Lưu ý rằng điều này không bao gồm chính các ký tự trích dẫn trong các giá trị phù hợp, mặc dù bạn có thể loại bỏ điều đó bằng một chuỗi thay thế hoặc sửa đổi regex để không bao gồm chúng. Tôi sẽ để nó như một bài tập cho người đọc hoặc một người đăng khác vào lúc này, vì 2 giờ sáng là quá muộn để làm rối với các cụm từ thông dụng nữa;)

Nếu bạn muốn cho phép dấu ngoặc kép bên trong chuỗi, bạn có thể sử dụng một cái gì đó như sau:

(?:(['"])(.*?)(?<!\\)(?>\\\\)*\1|([^\s]+))

Chuỗi được trích dẫn sẽ là nhóm 2, các từ đơn lẻ không được trích dẫn sẽ là nhóm 3.

Bạn có thể thử nó trên nhiều chuỗi khác nhau tại đây: http://www.fileformat.info/tool/regex.htm hoặc http://gskinner.com/RegExr/

Regex từ Jan Goyvaerts là giải pháp tốt nhất mà tôi tìm thấy cho đến nay, nhưng cũng tạo ra các kết quả trống (null) mà anh ấy loại trừ trong chương trình của mình. Các kết quả phù hợp trống này cũng xuất hiện từ trình kiểm tra regex (ví dụ: rubular.com). Nếu bạn xoay vòng tìm kiếm (trước tiên hãy tìm các phần được trích dẫn và hơn là các từ được phân tách bằng dấu cách) thì bạn có thể thực hiện ngay một lần với:

("[^"]*"|'[^']*'|[\S]+)+

(?<!\G".{0,99999})\s|(?<=\G".{0,99999}")\s

Điều này sẽ khớp với các khoảng trắng không được bao quanh bởi dấu ngoặc kép. Tôi phải sử dụng min, max {0,99999} vì Java không hỗ trợ * và + trong lookbehind.

Có lẽ sẽ dễ dàng hơn để tìm kiếm chuỗi, lấy từng phần, so với chia nhỏ.

Lý do là, bạn có thể phân chia nó ở các khoảng trắng trước và sau "will be". Nhưng, tôi không thể nghĩ ra bất kỳ cách nào để chỉ định bỏ qua khoảng trống giữa bên trong phần tách.

(không phải Java thực tế)

string = "This is a string that \"will be\" highlighted when your 'regular expression' matches something.";

regex = "\"(\\\"|(?!\\\").)+\"|[^ ]+"; // search for a quoted or non-spaced group
final = new Array();

while (string.length > 0) {
    string = string.trim();
    if (Regex(regex).test(string)) {
        final.push(Regex(regex).match(string)[0]);
        string = string.replace(regex, ""); // progress to next "word"
    }
}

Ngoài ra, việc ghi lại các trích dẫn đơn lẻ có thể dẫn đến các vấn đề:

"Foo's Bar 'n Grill"

//=>

"Foo"
"s Bar "
"n"
"Grill"

String.split()không hữu ích ở đây vì không có cách nào để phân biệt giữa các khoảng trắng bên trong dấu ngoặc kép (không tách) và các khoảng trắng bên ngoài (tách). Matcher.lookingAt()có lẽ là những gì bạn cần:

String str = "This is a string that \"will be\" highlighted when your 'regular expression' matches something.";
str = str + " "; // add trailing space
int len = str.length();
Matcher m = Pattern.compile("((\"[^\"]+?\")|('[^']+?')|([^\\s]+?))\\s++").matcher(str);

for (int i = 0; i < len; i++)
{
    m.region(i, len);

    if (m.lookingAt())
    {
        String s = m.group(1);

        if ((s.startsWith("\"") && s.endsWith("\"")) ||
            (s.startsWith("'") && s.endsWith("'")))
        {
            s = s.substring(1, s.length() - 1);
        }

        System.out.println(i + ": \"" + s + "\"");
        i += (m.group(0).length() - 1);
    }
}

tạo ra kết quả sau:

0: "This"
5: "is"
8: "a"
10: "string"
17: "that"
22: "will be"
32: "highlighted"
44: "when"
49: "your"
54: "regular expression"
75: "matches"
83: "something."

Tôi thích cách tiếp cận của Marcus, tuy nhiên, tôi đã sửa đổi nó để tôi có thể cho phép văn bản gần dấu ngoặc kép và hỗ trợ cả ký tự "và 'trích dẫn. Ví dụ: tôi cần một =" một số giá trị "để không chia nó thành [a =," một số giá trị "].

(?<!\\G\\S{0,99999}[\"'].{0,99999})\\s|(?<=\\G\\S{0,99999}\".{0,99999}\"\\S{0,99999})\\s|(?<=\\G\\S{0,99999}'.{0,99999}'\\S{0,99999})\\s"

Cách tiếp cận của Jan rất tuyệt nhưng đây là một cách khác cho kỷ lục.

Nếu bạn thực sự muốn tách như đã đề cập trong tiêu đề, giữ các dấu ngoặc kép trong "will be"và 'regular expression', thì bạn có thể sử dụng phương pháp này thẳng ra khỏi Khớp (hoặc thay thế) một mẫu ngoại trừ trong các tình huống s1, s2, s3, v.v.

Các regex:

'[^']*'|\"[^\"]*\"|( )

Hai lần thay thế bên trái khớp hoàn thành 'quoted strings'và "double-quoted strings". Chúng tôi sẽ bỏ qua những trận đấu này. Bên phải đối sánh và chiếm khoảng trắng với Nhóm 1 và chúng tôi biết chúng là khoảng trắng bên phải vì chúng không khớp với các biểu thức ở bên trái. Chúng tôi thay thế những cái đó bằng SplitHeresau đó tách ra SplitHere. Một lần nữa, đây là trường hợp phân chia thực sự mà bạn muốn "will be", không phải will be.

Đây là một triển khai hoạt động đầy đủ (xem kết quả trên bản demo trực tuyến ).

import java.util.*;
import java.io.*;
import java.util.regex.*;
import java.util.List;

class Program {
public static void main (String[] args) throws java.lang.Exception  {

String subject = "This is a string that \"will be\" highlighted when your 'regular expression' matches something.";
Pattern regex = Pattern.compile("\'[^']*'|\"[^\"]*\"|( )");
Matcher m = regex.matcher(subject);
StringBuffer b= new StringBuffer();
while (m.find()) {
    if(m.group(1) != null) m.appendReplacement(b, "SplitHere");
    else m.appendReplacement(b, m.group(0));
}
m.appendTail(b);
String replaced = b.toString();
String[] splits = replaced.split("SplitHere");
for (String split : splits) System.out.println(split);
} // end main
} // end Program

Nếu bạn đang sử dụng c #, bạn có thể sử dụng

string input= "This is a string that \"will be\" highlighted when your 'regular expression' matches <something random>";

List<string> list1 = 
                Regex.Matches(input, @"(?<match>\w+)|\""(?<match>[\w\s]*)""|'(?<match>[\w\s]*)'|<(?<match>[\w\s]*)>").Cast<Match>().Select(m => m.Groups["match"].Value).ToList();

foreach(var v in list1)
   Console.WriteLine(v);

Tôi đã thêm cụ thể " | <(? [\ W \ s] *)> " để làm nổi bật rằng bạn có thể chỉ định bất kỳ ký tự nào cho các cụm từ nhóm. (Trong trường hợp này, tôi đang sử dụng <> để nhóm.

Đầu ra là:

This
is
a
string
that
will be
highlighted
when
your
regular expression 
matches
something random

Tôi hoàn toàn chắc chắn rằng điều này là không thể nếu chỉ sử dụng biểu thức chính quy. Kiểm tra xem có thứ gì đó được chứa bên trong một số thẻ khác hay không là một thao tác phân tích cú pháp. Điều này có vẻ giống như vấn đề tương tự khi cố gắng phân tích cú pháp XML bằng regex - nó không thể được thực hiện chính xác. Bạn có thể có được kết quả mong muốn của mình bằng cách liên tục áp dụng một regex không tham lam, không toàn cục phù hợp với các chuỗi được trích dẫn, sau đó khi bạn không thể tìm thấy bất kỳ thứ gì khác, hãy chia nó tại các khoảng trắng ... có một số các vấn đề, bao gồm theo dõi thứ tự ban đầu của tất cả các chuỗi con. Đặt cược tốt nhất của bạn là chỉ cần viết một hàm thực sự đơn giản lặp lại chuỗi và lấy ra các mã thông báo bạn muốn.

Một vài chỉnh sửa hy vọng hữu ích về câu trả lời được chấp nhận của Jan:

(['"])((?:\\\1|.)+?)\1|([^\s"']+)

• Cho phép các dấu ngoặc kép thoát trong các chuỗi được trích dẫn
• Tránh lặp lại mẫu cho dấu ngoặc kép và đơn; điều này cũng đơn giản hóa việc thêm nhiều ký hiệu trích dẫn hơn nếu cần (với chi phí của một nhóm chụp ảnh khác)

Bạn cũng có thể thử điều này:

    String str = "This is a string that \"will be\" highlighted when your 'regular expression' matches something";
    String ss[] = str.split("\"|\'");
    for (int i = 0; i < ss.length; i++) {
        if ((i % 2) == 0) {//even
            String[] part1 = ss[i].split(" ");
            for (String pp1 : part1) {
                System.out.println("" + pp1);
            }
        } else {//odd
            System.out.println("" + ss[i]);
        }
    }

Phần sau trả về một mảng đối số. Đối số là biến 'lệnh' phân chia trên khoảng trắng, trừ khi được bao gồm trong dấu ngoặc kép hoặc đơn. Các kết quả phù hợp sau đó được sửa đổi để loại bỏ dấu ngoặc kép và đơn.

using System.Text.RegularExpressions;

var args = Regex.Matches(command, "[^\\s\"']+|\"([^\"]*)\"|'([^']*)'").Cast<Match>
().Select(iMatch => iMatch.Value.Replace("\"", "").Replace("'", "")).ToArray();

Một lớp lót đầu tiên sử dụng String.split ()

String s = "This is a string that \"will be\" highlighted when your 'regular expression' matches something.";
String[] split = s.split( "(?<!(\"|').{0,255}) | (?!.*\\1.*)" );

[This, is, a, string, that, "will be", highlighted, when, your, 'regular expression', matches, something.]

không tách ở khoảng trống, nếu khoảng trống được bao quanh bởi dấu nháy đơn hoặc dấu ngoặc kép thì
tách ở khoảng trống khi 255 ký tự ở bên trái và tất cả các ký tự ở bên phải của khoảng trống không phải là dấu nháy đơn hoặc dấu ngoặc kép

phỏng theo bài gốc (chỉ xử lý dấu ngoặc kép)