What does the "?:^" regular expression mean?

I am looking at this sub-expression (this is in JavaScript):

(?:^|.....)

I know that ? means "zero or one times" when it follows a character, but not sure what it means in this context.

From stackoverflow

• ?: Generally indicates making the group a non capture. You can do some research here.

  I'm almost positive any regex engine should but when I switch between engines I run into some quirks.

  Edit: This should be the case, non captures seems to work fine.

• You're probably seeing it in this context

  (?:...)
  

  It means that the group won't be captured or used for back-references.

  EDIT: To reflect your modified question:

  (?:^|....)
  

  means "match the beginning of the line or match ..." but don't capture the group or use it for back-references.

  Trampas Kirk : The caret is not part of the back reference expression.

  Daniel LeCheminant : @cynoclast: That's correct, but it was part of the question at the time of the answer (The question has since been modified)

  levik : Excellent - thank you. Unfortunately due to the characters in use, RegEx's are notoriously unsuited too googling :)

  Chase Seibert : In short, it's a performance optimization.

• (?:some stuff) means that you don't want to match the expression in the parentheses separately. Normally the pieces of a regexp grouped in parentheses are grouped and can be referenced individually (this is called using backreferences).

  See http://www.regular-expressions.info/brackets.html

• "(?:x) Matches 'x' but does not remember the match."

  https://developer.mozilla.org/en/Core_JavaScript_1.5_Guide/Regular_Expressions

• When working with groups, you often have several options that modify the behavior of the group:

  (foo)     // default behavior, matches "foo" and stores a back-reference
  (?:foo)   // non-capturing group: matches "foo", but doesn't store a back-ref
  (?i:foo)  // matches "foo" case-insensitively
  (?=foo)   // matches "foo", but does not advance the current position
            // ("positive zero-width look-ahead assertion")
  (?!foo)   // matches anything but "foo", and does not advance the position 
            // ("negative zero-width look-ahead assertion")
  

  to name a few.

  They all begin with "?", which is the way to indicate a group modifier. The question mark has nothing to do with optionality in this case.

  It simply says:

  (?:^foo)  // match "foo" at the start of the line, but do not store a back-ref
  

  Sometimes it's just overkill to store a back-reference to some part of the match that you are not going to use anyway. When the group is there only to make a complex expression atomic (e.g. it should either match or fail as a whole), storing a back-reference is an unnecessary waste of resources that can even slow down the regex a bit. And sometimes, you just want to be group 1 the first group relevant to you, instead of the first group in the regex.

• Short Answer

  It flags the (parenthetical) group as a non-capturing group.

  Details About This Particular Expression

  The notation for a non-capturing group is:

  (?:<expresson>)
  

  In the instance you presented, the caret (^) is part of the expression not part of the capturing group notation. And this instance it's not a special character either.

  It looks like they're using an 'or' operator (the pipe) with the caret. So they're looking to match something that is a caret or whatever was on the right of the pipe, but not capture the expression as a group (accomplished with the ?: in the beginning of the grouping characters.

  In General

  Non-capturing groups allow you to group an expression in a way that won't be back-refernceable, and will also increase performance of the expression.