A long while back, I blogged that the CALLER scope in ColdFusion custom tags acts a sort of struct with special behavior. In that post, I demonstrated that compound variable paths could be used as keys to the CALLER scope:
- <cfset CALLER[ "REQUEST.Foo.Bar" ] = objValue />
This call would store objValue into the Bar key of the Foo struct located in the REQUEST scope. In a traditional struct call, this would store objValue into the "REQUEST.Foo.Bar" key of the CALLER scope; but, like I said, CALLER has this special (and tremendously useful) behavior. In a different post, I even demonstrated that you could get variables out of the CALLER scope in a the same manner.
Anyway, where I'm going with this is that just this morning, I tried for the first time to use StructKeyExists() on the CALLER scope. It's one thing for an object in ColdFusion to overload the its array and struct operators, but it's another thing to have complete struct functionlaity. As it turns out, StructKeyExists() works with exactly the same sort of special behavior:
- <cfif StructKeyExists( CALLER, "REQUEST.Foo.Bar" )>
This does not check to see if the key "REQUEST.Foo.Bar" exists in CALLER (as it would in a normal struct call); this checks to see if the Bar key exists in the Foo struct located within the REQUEST scope of the CALLER scope.
Looking For A New Job?
- Lead Programmer 7+ Years Experience- ColdFusion/Expert Web Designer at AtPrime Media Services
- Senior Developer at Quality Bicycle Products
- ColdFusion Developer at WRIS Web Services
- Coldfusion Developer at Cavulus
- Web Developer at Townsend Communications, Inc.
Doesn't the Request scope exist in the custom tag on its own, regardless of the Caller scope? In other words:
If StructKeyExists(Caller, "Request.foo.bar") then StructKeyExists(Request, "foo.bar") also, right?
Maybe it's not totally relevant to the post, but just curious since Request is also a scope with its own behavior, such as being available across all templates in the request, much like a session struct.
That is totally true. In fact, I used the VARIABLES scope when I first wrote the code. The VARIABLES scope might have been a better demonstration since both the calling page the custom tag have their own VARIABLES scope.
But, at the last minute, I decided to change the example to use the REQUEST scope.
I haven't tested it, but I think there's a small problem with that last example where structKeyExists(caller,"request.foo.bar") and structKeyExists(request,"foo.bar") would both return the same value. That would be true if the request scope also has that same special behavior that the caller scope has... I haven't tried it, so I can't say for certain, but I *think* that structKeyExists(request,"foo.bar") will look for the key "foo.bar" rather than looking for the key "bar" in the structure "foo". Personally I'm not so sure I like that behavior from the caller scope -- I think it has more potential to lead to confusion than it has really potential to help (as in the example here). YMMV of course.