Regular expression: match an incomplete search string - regex

Question

Is there a regular expression for matching a string that is not necessarily complete?
Example:
some other supercalifragilisticexpialidocious random things
and maybe supercalifragilistic meaningless padding
lorem superca ipsum dolor
I would like to match whichever left part of supercalifragilisticexpialidocious there is each time. There are not necessarily spaces around words.
The expected result would be to find:
supercalifragilisticexpialidocious
supercalifragilistic
superca
This is similar to matching the same character any number of times, but more universal.
Thank you!

Answer 1

I know this isn't a regex, but I think your objective can be accomplished better using code. Here's an example of a JavaScript function that matches as much of an input string as it can:
function matchMost(find, string){
for(var i = 0 ; i < find.length ; i++){
for(var j = find.length ; j > i ; j--){
if(string.indexOf(find.substring(i, j)) !== -1){
return find.substring(i, j);
}
}
}
return false;
}
For example, if you call matchMost("supercalifragilisticexpialidocious", "lorem superca ipsum dolor"), it will return the string "superca". If string doesn't contain a single character from find, the function will return false.
Here's a JS Fiddle where you can test this code: http://jsfiddle.net/n252eyw1/
UPDATE
This function matches as much of the left side of an input string as it can:
function matchMostLeft(find, string){
for(var j = find.length ; j > 0 ; j--){
if(string.indexOf(find.substring(0, j)) !== -1){
return find.substring(0, j);
}
}
return false;
}
JS Fiddle: http://jsfiddle.net/sjy312ae/

Answer 2

There is, but it's not tidy at all (and probably not very performant either). This regex matches at least 3 characters on the left side and up to supercal as written; the way to extend it should be fairly plain.
(?:sup(?:e(?:r(?:c(?:a(?:l)?)?)?)?)?)?
Paul's answer is likely far more useful in the general case.

Answer 3

Below is an alternative solution. It is similar to Paul's in that it uses indexOf rather than regular expressions. This also makes it equally case-sensitive. My approach should perform better in exceptional cases where Paul's solution would cause excessive calls to indexOf; typically when:
the needle is very long (worse than supercalifragilisticexpialidocious), and
you have a lot of separate texts to scan, and
the majority of texts either do not match, or contain only short matches.
If this is not the case with you, then please use Paul's solution, as it is clean, simple and readable.
function getLongestMatchingPrefix(needle, haystack) {
var len = 0;
var i = 0;
while (len < needle.length && (i = haystack.substring(i).indexOf(needle.substring(0, len + 1))) >= 0) {
while (++len < needle.length && haystack.substring(i, i + len + 1) == needle.substring(0, len + 1)) {}
}
return needle.substring(0, len);
}
Fiddle: http://jsfiddle.net/ov26msj5/