How can I test whether a regex matches anywhere or matches the whole string?

The difference is whether the match may be a substring. If the pattern is [0-9]+, it describes one or more ASCII digits. Searching for that pattern can succeed on order-507 because the text contains 507. Requiring a whole-string match should accept 507 but reject order-507.

That distinction is useful when choosing what your code is meant to do: finding a digit sequence in a sentence is different from checking that an input consists only of digits. A match result alone doesn’t tell you which task was intended; the method and pattern together do.

With Python’s re module, use search() when a match may occur anywhere in the string, and fullmatch() when the entire string must match the pattern. [S1]

import re

pattern = r"[0-9]+"

print(bool(re.search(pattern, "order-507")))    # True
print(bool(re.fullmatch(pattern, "order-507"))) # False
print(bool(re.fullmatch(pattern, "507")))       # True

Here, the first result means “there is a digit sequence somewhere,” not “the whole input is digits.” fullmatch() makes the whole-input requirement explicit, which is often easier to read than adding boundary markers to a pattern. These examples use Python’s re API; they aren’t JavaScript syntax.

RegExp.prototype.test() reports whether the regex finds a match in the string, so it is search-style by itself. For an ordinary single-line whole-string check, put ^ at the start and $ at the end of the pattern. [S2]

const containsDigits = /[0-9]+/.test("order-507");
const onlyDigits = /^[0-9]+$/.test("order-507");
const onlyDigitsInFullInput = /^[0-9]+$/.test("507");

console.log(containsDigits);           // true
console.log(onlyDigits);               // false
console.log(onlyDigitsInFullInput);    // true

The first expression looks for a digit run anywhere. The anchored expression is intended for an ordinary single-line input that must fit the digit pattern. JavaScript’s m flag changes how ^ and $ relate to line boundaries, so don’t assume the example handles every multiline requirement. [S2]

First state the requirement in plain language: “find a digit sequence somewhere” or “the entire input must contain only ASCII digits.” Then choose the method that matches it: Python search() for finding and fullmatch() for whole-input matching; in JavaScript, .test() searches unless the pattern is anchored for the intended whole-input check. [S1] [S2]

Try both a clearly acceptable string and a near miss. For the digit example, 507 should pass the whole-input check, while order-507 should not. If spaces, signs, decimals, or line breaks should be allowed, decide that separately and adjust the rule; [0-9]+ alone doesn’t specify those allowances.

One more JavaScript detail: global or sticky regexes are stateful across repeated .test() calls because they use lastIndex. Avoid those flags for a simple repeated yes/no check unless you deliberately handle that behavior. [S2] These examples illustrate matching behavior; they don’t establish that a particular pattern is suitable for every application.