Is _[___, a, ___]_ a regex-like syntax?

It's a good idea to examine the FullForm of things when trying to figure out pattern-matching:

FullForm[ _[___,a,___]_ ]
(*  Times[Blank[], Blank[][BlankNullSequence[],a,BlankNullSequence[]]]  *)

Since Blank[] and _ are the same, and BlankNullSequence[] and ___ are the same, the form can be written as the following, using * to indicate the head Times:

_ * _[___, a, ___]

It is probably clear that _[___, a, ___] matches any expression with any head and a as one of its arguments, like Power[x, a] in the test expression Times[Power[x, a], Power[y, b], Power[z, c]]. Probably less clear are the implications for pattern-matching because Times has the attributes Flat and Orderless. The test expression Times[Power[x, a], Power[y, b], Power[z, c]] is equivalent to

Times[ Times[Power[y, b], Power[z, c]], Power[x, a] ]

And therefore, the blank _ before the Times symbol * can match Times[Power[y, b], Power[z, c]] while the _[___, a, ___] after the Times symbol matches the other factor Power[x, a]. This is why one gets

MatchQ[Times[Power[x, a], Power[y, b], Power[z, c]], _[___, a, ___]_]
(*  True  *)

I'm sorry, but I'm very confused. You said,

MemberQ assumes a list, rather than simply a pattern ... as its second argument.

But then you give the example of MemberQ[{a, b}, a]. So, clearly you didn't write what you meant.

Then you ask for a pattern that works with MatchQ, but later you say that ContainsQ does what you want (but isn't built-in).

So, do you really need MatchQ? Why can't you use MemberQ just like ContainsQ? Maybe you should tell us more about the problem you're trying to solve rather than pre-constraining the discussion to specific symbols that you've already tried.

Sorry. I made multiple typos in the first paragraph of my original question. I should have said:

• MemberQ takes a list as its first argument. (Actually, this is not true. As Michael Rogers points out elsewhere on this page, MemberQ can take any head as its first argument, not just List.)
• MatchQ takes an expression as its first argument.

I'm trying to understand how to write a pattern representing the notion "any subexpression containing the symbol a anywhere."

If I have a string, I can write a string pattern (StringExpression) representing the notion "a string containing the character a" simply by writing ___ ~~ "a" ~~ ___. This string pattern can be used as the second argument to StringMatchQ:

StringMatchQ["abc", ___ ~~ "a" ~~ ___]
StringMatchQ["baac", ___ ~~ "a" ~~ ___]
StringMatchQ["xyz", ___ ~~ "a" ~~ ___]

(* OUTPUT: *)
(* True *)
(* True *)
(* False *)

But what is the analogue for the symbol a in a (general) pattern, rather than the character "a" in a string pattern? The following is obviously invalid syntax:

MatchQ[Times[Power[x, a], Power[y, b], Power[z, c]], ___ ~~ a ~~ ___]

(* OUTPUT: *)
(* False *)

Is there a way to write a pattern representing "any expression with a subexpression a anywhere" for use as the second argument to MatchQ? That's my question. Thanks to Michael Rogers's suggestion elsewhere on this page, it turns out that this does the trick:

MatchQ[Times[Power[x, a], Power[y, b], Power[z, c]], _[___, a, ___]_]

(* OUTPUT: *)
(* True *)

But I don't think I understand why. Is _[___, a, ___]_ a regex-like syntax?

Alternatively, I can obtain the result I want more simply using the resource function ContainsQ:

ResourceFunction["ContainsQ"][Times[Power[x, a], Power[y, b], Power[z, c]], a]

(* OUTPUT: *)
(* True *)

I can also obtain the result I want using MemberQ, though not directly (as far as I can tell) because a is in the exponent:

MemberQ[Times[Power[x, a], Power[y, b], Power[z, c]], a]
MemberQ[Times[Power[x, a], Power[y, b], Power[z, c]], Power[x, a]]

(* OUTPUT: *)
(* False *)
(* True *)

My observation is, ContainsQ is quite useful! So my follow-up question is, why didn't (or doesn't) Wolfram include ContainsQ as a built-in function? The answer is probably "because you can just use MatchQ in the way Michael Rogers suggested elsewhere on this page":

MatchQ[Times[Power[x, a], Power[y, b], Power[z, c]], _[___, a, ___]_]

(* OUTPUT: *)
(* True *)