QuackFuzed [ Ramblings of a Con..ColdFuzed Mind ]

One final comment. Since you have your regex set to "[A-Z]+" it is only checking for caps. So even if you changed the 0 to an o, it would fail. You'd have to have the string set to PASSWORD for it to work, either that or modify your regex to include the range of a-z also.

Thanks guys for your comments, but I have to disagree with you. If I were testing for the entire string to consist of UPPER case, I'd write A[A-Z]+. That regex indicates that the match be from the beginning (A) to the end () of the string. Instead, all I'm looking for is one single occurrence of an UPPER case letter, which reFind() correctly indicates.

Shaun, maybe I'm an idiot and just can't "see" what you're saying, but even the link you provided correctly indicates the 7th position. You keep saying that isValid() is testing the entire string, and that may well be, but that is *not* what the regex translates to. The regex "[A-Z]+" will match _anywhere_ within the string. The regex "A[A-Z]+" will match only if it's the entire string. That behavior is the same in JavaScript, perl, and every other language I've played in. It even works that way in ColdFusion, with reFind() and reFindNoCase(). Just not in isValid(). Surely Adobe didn't intend for all the regex you've written in your life to go out the window with isValid() and the rules have all changed?

Shaun, I just ran a few more tests, and, as you suggested, isValid() requires that the entire string match the regex. I have two major problems with that:

1. The documentation simply does not state that.

2. That behavior is the stupidest thing on the planet. WTF is the point of writing regex if the function is going to override what you write? And forcing the entire string to match from start to finish when the regex only calls for a one (or more) characters is absolutely asinine.

Shaun, I get what you're saying, and that's cool. My issue with that is that, as I stated above, isValid() is actually changing the meaning of the regex that you're writing, and it is undocumented behavior. IMO, you'd be far better off writing...

if ( reFind("A[a-zA-Z]{1}[0-9]{2}[a-zA-Z]{1}[0-9]{2}", form.IMGCode) EQ 1 ) { return true }

and

if ( reFind("A^20[0-9]{2}", form[variables.FN]) EQ 1 ) { return true }

Relying on what amounts to bullshit behavior from isValid() will cause you problems if you move that to any other language, or even to reFind()/reFindNoCase(). For example, try this at the JavaScript site you linked to...

regex: [a-zA-Z]{1}[0-9]{2}[a-zA-Z]{1}[0-9]{2}

string: 8888a99A99zzzzzzzzzzzzzzzzzzzzzzzzzzzz

You'll correctly get a match. Now then, try the following...

regex: ^[a-zA-Z]{1}[0-9]{2}[a-zA-Z]{1}[0-9]{2}$

string: 8888a99A99zzzzzzzzzzzzzzzzzzzzzzzzzzzz

You will *not* get a match on that one, because the regex indicates that it must be the full string.

Brad, I *think* I can bring myself to accept "the parameter" being their lame-ass attempt to indicate that isValid() is going to change the behavior of the regex that you write. But it still does not change the fact that the function *is* changing what you wrote to mean something else.

As far as the reFind()/reFindNoCase() portion of your comment goes, it seems that you are suggesting that they should not be used for matching an entire string. If that's the case, I do not agree.

You certainly *could* use refind to match an entire string, but that is not its primary purpose. Its primary purpose is to tell you where in a string a substring can be found. That’s why the function returns an integer which is the location in the string that the substring exists, not a boolean. If I wanted to match an entire string I would probably just use isvalid for that. Either that or modify my regex into refind to start with ^ and end with $.

I can see your confusion since isvalid basically does the same thing as ^[A-Z]+$ when all you typed in was [A-Z]+ but the context of the function and what the docs describe as its behavior determine exactly what it is going to do with your regular expression.

I wouldn’t say the function is “changing” your regex. Your regex is simply a pattern, and the function can look for the pattern however and wherever it pleases based on its requirements.