Regular expression gives different results as variable and as literal

Question

In the Emacs *scratch* buffer, I get different results when I use the same regular expression as a variable compared to a literal:

(setq splitter-string "9:20")
"9:20"

(string-match "[0-9]?[0-9]:[0-9][0-9]" splitter-string)
0

(defvar org-clock-split-absolute-time-regexp "[0-9]?[0-9]:[0-9][0-9]"
  "Regular expression to match an absolute time to split at.")
org-clock-split-absolute-time-regexp

(string-match org-clock-split-absolute-time-regexp splitter-string)
nil

What is the difference between a variable and a literal for regular expressions?

Update: The problem stems from the inability to overwrite a variable defined with defvar, as below in the scratch buffer:

(defvar pattern "some pattern"
  "Some regular expression")
pattern

pattern
"some pattern"

(defvar pattern "[a-z]*"
  "Some regular expression")
pattern

pattern
"some pattern"

(string-match "[a-z]*" "abcdefg")
0

(string-match pattern "abcdefg")
nil

I would not do this in final code, but may do it in the scratch buffer during development. The problem is about defvar, and a duplicate of this question, and not about regular expressions (I knew about the different syntaxes with re-builder and suspected it was about that).

Answer 1

That's not what I see. They both return 0, for me, starting with emacs -Q (no init file).

If you haven't already, try starting Emacs with emacs -Q. If that works then bisect your init file to find the problem.

---

Updated after your update (which really poses a separate question -- you should pose only one question per post).

• You can evaluate a defvar by putting your cursor on it somewhere and using C-M-x.

• The reason that defvar doesn't do anything just by evaluating it normally, if the variable already has a value, is to allow you to use a defvar in your own code (e.g. init file) to override any defvar for the same variable that might get evaluated when loading some library after you have set the variable value.

See the Emacs manual, node Lisp Eval. It describes the behavior this way:

The eval-defun command is bound to C-M-x in Emacs Lisp mode. It evaluates the top-level Lisp expression containing or following point, and prints the value in the echo area. In this context, a top-level expression is referred to as a “defun”, but it need not be an actual defun (function definition). In particular, this command treats defvar expressions specially.

Normally, evaluating a defvar expression does nothing if the variable it defines already has a value. But this command unconditionally resets the variable to the initial value specified by the defvar; this is convenient for debugging Emacs Lisp programs. defcustom and defface expressions are treated similarly. Note that the other commands documented in this section do not have this special feature.