Regex capturing empty string along with the expected groups, want it to not to capture empty string

Question

I built a regex to capture the value from the pattern, where pattern is to identify the json and fetch value from it. But along with the expected groups, it is also capturing the empty strings in the group.

Regex: (?<=((?i)(finInstKey)":)["]?)(.*?)(?=["|,|}])|(?<="((?i)finInstKey","value":)["]?)(.*?)(?=["|,|}])

input:

{"finInstKey":500},{"name":"finInstKey","value":12345678900987654321}
{finInstKey":"500"},{"name":"finInstKey","value":"12345678900987654321"}

for these inputs, input 2 also captures the empty string along with the expected values.

actual output:

500
12345678900987654321

500

12345678900987654321

expected output:

500
12345678900987654321
500
12345678900987654321

As of now, I have handled it manually in the Java code, but it would be nice if regex won't capture the empty strings. what changes should I make in the regex to get expected output.

Mainly, I want this to replaceAll groups with masked value "****".

My piece of code:

public class RegexTester {
    private static final String regex = "(?<=((?i)(%s)\":)[\"]?)(.*?)(?=[\"|,|}])|(?<=\"((?i)%s\",\"value\":)[\"]?)(.*?)(?=[\"|,|}])";

    public static void main(String[] args) {
        String field = "finInstKey";
        String input = "{\"finInstKey\":500},{\"name\":\"finInstKey\",\"value\":12345678900987654321}{finInstKey\":\"500\"},{\"name\":\"finInstKey\",\"value\":\"12345678900987654321\"}";
        try {
            Pattern pattern = Pattern.compile(String.format(regex, field, field));
            Matcher matcher = pattern.matcher(input);
//            System.out.println(matcher.replaceAll("****"));
            while (matcher.find()) {
                System.out.println(matcher.group());
            }
        } catch (Exception e) {
            System.err.println(e);
        }

    }

}

@Reilas no, it can be a string as well. and here I have provided finInstKey as static json key. In code, there will be a dynamic key name. — Thakur Sahab, Jul 20 '23 at 05:44
[this answer](https://stackoverflow.com/a/1732454/8681) is about HTML instead of JSON, but it applies here none the less. — Jorn, Jul 20 '23 at 08:20

score 3 · Answer 1 · answered Jul 20 '23 at 05:48

3

It'd probably be easier using a JSON parsing library to parse JSON, instead of regex. Try the .fromJSON method from https://github.com/google/gson

If you insist on using regex, maybe look into the + symbol in regex, it means "match one or more". Regex is pretty difficult to read when it gets complicated like you have there.

answered Jul 20 '23 at 05:48

linden wells

69
3

1

Thanks, but I have to use the regex to capture the json property values, and mask them and print the logs. I tried to do the same using jackson library but the performance was not close to the regex and patterns. So chose, regex for this task. – Thakur Sahab Jul 20 '23 at 06:01
2

@ThakurSahab That decision will come back to bite you. For example, when you have to change your regex *again* to parse a slightly different object. Performance isn't everything, development speed matters as well. – Jorn Jul 20 '23 at 08:18

I_Al-thamary · Answer 2 · 2023-07-20T06:29:11.157

0

The finInstKey key is not enclosed in quotes leading to empty matches. By changing the pattern to "finInstKey" you will allow it to match this input and correctly extract the value.

Use it like

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) {
        String field = "finInstKey";
        String regex = "\"?" + field + "\"?(\\s*:\\s*\"?([^\",}]*)\"?|\",\"value\"\\s*:\\s*\"?([^\",}]*)\"?)";

        String input = "{\"finInstKey\":500},{\"name\":\"finInstKey\",\"value\":12345678900987654321}{finInstKey:\"500\"},{\"name\":\"finInstKey\",\"value\":\"12345678900987654321\"}";

        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(input);

        while (matcher.find()) {
            if (matcher.group(2) != null) {
                System.out.println(matcher.group(2));
            } else {
                System.out.println(matcher.group(3));
            }
        }
    }
}

here is the code

edited Jul 20 '23 at 06:29

answered Jul 20 '23 at 05:45

I_Al-thamary

3,385
2
24
37

Thanks, But it is not giving me the expected output. In fact, this regex is not capturing all the expected groups. – Thakur Sahab Jul 20 '23 at 05:57
@ThakurSahab I have updated the code with your input. – I_Al-thamary Jul 20 '23 at 06:27
I have recently updated my question, and pasted my sample code. can you please take a look so that you may get familiar with what exactly I want to do. – Thakur Sahab Jul 20 '23 at 06:45
@ThakurSahab The code is after your update. – I_Al-thamary Jul 20 '23 at 07:10

Reilas · Answer 3 · 2023-07-20T06:24:38.337

You can use the following pattern. The capture groups are 2 and 3.
It's not easy to determine the end of the value, considering a text value may contain any of the possible delimiters.
Assure that your data will conform; this implies that it's just a series of numbers.

(?si)(\"finInstKey\")\s*:\s*\"?(.+?)\b.+?\"name\"\s*:\s*\1\s*,\s*\"value\"\s*:\s*\"?(.+?)\b

Although, I recommend just using a JSON parsing module, Gson by Google works well.

You're JSON strings are actually arrays, so just place each within square brackets.

[
  {
    "finInstKey": 500
  },
  {
    "name": "finInstKey",
    "value": 12345678900987654321
  }
]

Note that your second example has a missing quotation mark for the finInstKey key.

[
  {
    "finInstKey": "500"
  },
  {
    "name": "finInstKey",
    "value": "12345678900987654321"
  }
]

With Gson you can utilize the JsonParser class to parse the values.

String stringA = "[\n" +
    "  {\n" +
    "    \"finInstKey\": 500\n" +
    "  },\n" +
    "  {\n" +
    "    \"name\": \"finInstKey\",\n" +
    "    \"value\": 12345678900987654321\n" +
    "  }\n" +
    "]";
String stringB = "[\n" +
    "  {\n" +
    "    \"finInstKey\": \"500\"\n" +
    "  },\n" +
    "  {\n" +
    "    \"name\": \"finInstKey\",\n" +
    "    \"value\": \"12345678900987654321\"\n" +
    "  }\n" +
    "]";

JsonArray arrayA = JsonParser.parseString(stringA).getAsJsonArray();
JsonObject objectA1 = arrayA.get(0).getAsJsonObject();
JsonElement elementA1 = objectA1.get("finInstKey");
int finInstKeyA = elementA1.getAsInt();
JsonObject objectA2 = arrayA.get(1).getAsJsonObject();
JsonElement elementA2 = objectA2.get("value");
BigInteger valueA = elementA2.getAsBigInteger();
System.out.println("finInstKeyA = " + finInstKeyA);
System.out.println("valueA = " + valueA);

JsonArray arrayB = JsonParser.parseString(stringB).getAsJsonArray();
JsonObject objectB1 = arrayB.get(0).getAsJsonObject();
JsonElement elementB1 = objectB1.get("finInstKey");
String finInstKeyB = elementB1.getAsString();
JsonObject objectB2 = arrayB.get(1).getAsJsonObject();
JsonElement elementB2 = objectB2.get("value");
String valueB = elementB2.getAsString();
System.out.println("finInstKeyB = " + finInstKeyB);
System.out.println("valueB = " + valueB);

Output

finInstKeyA = 500
valueA = 12345678900987654321
finInstKeyB = 500
valueB = 12345678900987654321

I actually used jackson library before switching to Pattern and Matcher. The reason I chose to move to regex is the performance, regex performs way better than these libraries. — Thakur Sahab, Jul 20 '23 at 06:11
@ThakurSahab, I've updated the answer with a working pattern. — Reilas, Jul 20 '23 at 06:19
I have recently updated my question, and pasted my sample code. can you please take a look so that you may get familiar with what exactly I want to do. — Thakur Sahab, Jul 20 '23 at 06:58
changing to (.+?) did helped me in not capturing the empty string but is capturing double quotes (") along with the value, like. "500 — Thakur Sahab, Jul 21 '23 at 07:26

score 0 · Answer 4 · answered Jul 20 '23 at 10:04

I think you use not correct regexp.

public static List<String> getData(String str, String field) {
    String regex = "(?:\"?" + field + "\"?:\"?(\\d+)\"?)|(?:\"name\":\""
            + field + "\",\"value\":\"?(\\d+)\"?)";
    Matcher matcher = Pattern.compile(regex).matcher(str);
    List<String> data = new ArrayList<>();

    while (matcher.find()) {
        data.add(Optional.ofNullable(matcher.group(1))
                         .orElseGet(() -> matcher.group(2)));
    }

    return data;
}

Output:

500
12345678900987654321
500
12345678900987654321

P.S. I think parsing json with regexpis a strategically bad idea. I recommend you to use any Json parser (Jackson, Gson, ...)

Regex capturing empty string along with the expected groups, want it to not to capture empty string

4 Answers4