I'll explain in english what I need.

That can be useful but it's fuzzy. Far better to write tests which may or may not work. See How to ask better questions using Test::More and sample data

If you can negate the logic then (from your fuzzy description) I think it should be quite simple:

use strict;
use warnings;

use Test::More;

my @good = qw/PKG_CONFIG_PATH  XDG_DATA_DIRS/;
my @bad = qw/XDG_SEAT_PATH XDG_SESSION_PATH/;

plan tests => @good + @bad;

my $re = qr/^XDG.*PATH$/;

for my $str (@good) {
    unlike $str, $re, "good $str does not match";
}

for my $str (@bad) {
    like $str, $re, "bad $str matches";
}
[download]

hippo suggested:

See How to ask better questions using Test::More and sample data

Huh, I never thought of anything like that for writing-up questions for PMo. Very good suggestion, I'll try that mode in the future.

    – Soren

Aug 22, 2025 at 20:41 UTC

/^(?<!XDG_) [_A-Z0-9]+ _PATH$/x does not make sense to me, you are trying to look before the beginning of the string.

How about:

#!/usr/bin/perl

use strict; # https://perlmonks.org/?node_id=11166082
use warnings;

my @patterns = qw/PKG_CONFIG_PATH XDG_DATA_DIRS XDG_SEAT_PATH XDG_SESS
+ION_PATH/;

my $re = qr/^(?!XDG_ [_A-Z0-0]+ _PATH$)/x;

for ( @patterns )
  {
  print /$re/ ? "   match" : "no match", " $_\n";
  }
[download]

Outputs:

   match PKG_CONFIG_PATH
   match XDG_DATA_DIRS
no match XDG_SEAT_PATH
no match XDG_SESSION_PATH
[download]

That will also match "bob", which doesn't sound desired.

It correctly performs on all the provided test cases. It's not my problem if an inadequate number of test cases are provided :)

/^[_A-Z0-9]+$(?<!^XDG_.*_PATH)/
[download]

/^(?!XDG_.*_PATH$)[_A-Z0-9]+$/
[download]

/^[_A-Z0-9]+$/ && ! /^XDG_.*_PATH$/
[download]

If perl supported variable length lookbehind, you could use a lookbehind at the end:

Just a data point but Perl has limited variable length lookbehind as an experimental feature since version 5.30, with support for up to 255 characters. https://perldoc.perl.org/perlexperiment#(Limited)-Variable-length-look-behind

See also https://perldoc.perl.org/perl5360delta#Variable-length-lookbehind-is-mostly-no-longer-considered-experimental

I do wish it could work in even more cases, like where the beginning point is known (e.g. (?<=\A...) or with \G) or something like (?<=...\1...) where the length is known when running that part of the regex even if not when compiling it.

Note that I kept your $ but I hate it, because without /m it is rarely used to intentionally do what it actually does (match either the end of the string or before a newline at the end of a string). If your data has no newlines, use \z (match only at the end of the string). If your data ends with newlines, use \n (or \n\z if your string may have internal newlines that should not match). Then your code doesn't mislead about what the data looks like.

It's weird. I lost some good habits when I took my 10-year break from programming, and using \z instead of $ in regexen is one of them. Since you pointed it out, I think my fingers will do the right thing from now on. In this case it wouldn't matter because my strings are all keys from %ENV and would never contain an embedded newline. But regaining (and retaining) good coding habits is important.

    – Soren

never