I need to extract Data from a single line of json-data which is inbetween two variables (Powershell)

As you've found, some character literals can't be used as-is in a regex pattern because they carry special meaning - we call these meta-characters.

In order to match the corresponding character literal in an input string, we need to escape it with \ -

• to match a literal (, we use the escape sequence \(,
• for a literal }, we use \}, and so on...

Fortunately, you don't need to know or remember which ones are meta-characters or escapable sequences - we can use Regex.Escape() to escape all the special character literals in a given pattern string:

$prefix = [regex]::Escape('DeviceAddresses":[{"Id":')
$capture = '(.*?)'
$suffix = [regex]::Escape(',"')
$devicePattern = "${prefix}${capture}${suffix}"

You also don't need to call [regex]::Match directly, PowerShell will populate the automatic $Matches variable with match groups whenever a scalar -match succeeds:

if($changeduserdata -match $devicePattern){
  $deviceid = $Matches[1]
} else {
  Write-Error 'DeviceID not found'
}

For reference, the following ASCII literals needs to be escaped in .NET's regex grammar:

$ ( ) * + . ? [ \ ^ { |

Additionally, # and (regular space character) needs to be escaped and a number of other whitespace characters have to be translated to their respective escape sequences to make patterns safe for use with the IgnorePatternWhitespace option (this is not applicable to your current scenario):

\u0009 => '\t'   # Tab
\u000A => '\n'   # Line Feed
\u000C => '\f'   # Form Feed
\u000D => '\r'   # Carriage Return

... all of which Regex.Escape() takes into account for you :)

To complement Mathias R. Jessen's helpful answer:

Generally, note that JSON data is much easier to work with - and processed more robustly - if you parse it into objects whose properties you can access - see the bottom section.

As for your regex attempt:

• Note: The following also applies to all PowerShell-native regex features, such as the -match, -replace, and -split operators, the switch statement, and the Select-String cmdlet.

• Mathias' answer uses [regex]::Escape() to escape the parts of the regex pattern to be used verbatim by the regex engine.

  • This is unequivocally the best approach if those verbatim parts aren't known in advance - e.g., when provided via a variable or expression, or passed as an argument.

• However, in a regex pattern that is specified as a string literal it is often easier to individually \-escape the regex metacharacters, i.e. those characters that would otherwise have special meaning to the regex engine.

  • The list of characters that need escaping is (it can be inferred from the .NET Regular-Expression Quick Reference):
    • \ ( ) | . * + ? ^ $ [ {
    • If you enable the IgnorePatternWhiteSpace option (which you can do inline with
      (?x), at the start of a pattern), you'll additionally have to \-escape:
      • #
      • significant whitespace characters (those you actually want matched) specified verbatim (e.g., ' ', or via string interpolation,"`t"); this does not apply to those specified via escape sequences (e.g., \t or \n).

Therefore, the solution could be simplified to:

# Sample JSON
$changeduserdata = '{"DeviceAddresses":[{"Id": 42,"More": "stuff"}]}'

# Note how [ and { are \-escaped
$deviceId = if ($changeduserdata -match 'DeviceAddresses":\[\{"Id":(.*?),"') {
  $Matches[1]
}

Using ConvertFrom-Json to properly parse JSON into objects is both more robust and more convenient, as it allows property access (dot notation) to extract the value of interest:

# Sample JSON
$changeduserdata = '{"DeviceAddresses":[{"Id": 42,"More": "stuff"}]}'

# Convert to an object ([pscustomobject]) and drill down to the property
# of interest; note that the value of .DeviceAddresses is an *array* ([...]).
$deviceId = (ConvertFrom-Json $changeduserdata).DeviceAddresses[0].Id  # -> 42