Ben Nadel
On User Experience (UX) Design, JavaScript, ColdFusion, Node.js, Life, and Love.
Ben Nadel at cf.Objective() 2012 (Minneapolis, MN) with: Matt Graf and Nolan Erck
Ben Nadel at cf.Objective() 2012 (Minneapolis, MN) with: Matt Graf@spiraldev ) and Nolan Erck@southofshasta )

Strange Numericly Named CFInvokeArgument Behavior

By Ben Nadel on
Tags: ColdFusion

A while back, I was talking about Sean Corfield and closures and I had asked him how to send an unknown number of "nameless" arguments to a function. He had suggested just sending them over named, but using the argument index as their name. I thought this was a brilliant idea and tested. It works great, but in the middle of testing, I had a typeo that caused some whacky results.

Look what happens when I send over index-named arguments where the index-number does not line up with the actual argument index:

  • <cffunction
  • name="DumpArgs"
  • access="public"
  • returntype="void"
  • output="true"
  • hint="Does nothing but CFDump out the arguments.">
  • <!--- Dump out arguments. --->
  • <cfdump
  • var="#ARGUMENTS#"
  • label="ARGUMENTS Scope"
  • />
  • <!--- Return out. --->
  • <cfreturn />
  • </cffunction>
  • <!--- Invoke DumpArgs sending over index-named arguments. --->
  • <cfinvoke method="DumpArgs">
  • <cfinvokeargument name="1" value="Kim" />
  • <cfinvokeargument name="5" value="Jessie" />
  • <cfinvokeargument name="10" value="Samantha" />
  • </cfinvoke>
  • <cfinvoke method="DumpArgs">
  • <cfinvokeargument name="10" value="Samantha" />
  • <cfinvokeargument name="5" value="Jessie" />
  • <cfinvokeargument name="1" value="Kim" />
  • </cfinvoke>
  • <cfinvoke method="DumpArgs">
  • <cfinvokeargument name="1" value="Kim" />
  • <cfinvokeargument name="10" value="Samantha" />
  • <cfinvokeargument name="5" value="Jessie" />
  • </cfinvoke>

Notice that in the three different method invokes, we send the arguments in completely different orders. This gives us the following CFDumps:


CFInvokeArgument Arguments CFDump 1  


CFInvokeArgument Arguments CFDump 2  


CFInvokeArgument Arguments CFDump 3  

Notice that the "first" element seems to be ordering somewhat alphabetically based on the relationship of 1 and 10. I can't quite see the pattern. But then the second and third elements are always undefined struct elements. I wonder why it is not trying to order those in some sort of alpha way. Very confusing.

Looking For A New Job?

100% of job board revenue is donated to Kiva. Loans that change livesFind out more »

Reader Comments

Ah. I was quite befuddled myself, but couldn't quit until I figured it out. The cause for this behaviour is a combination of CF's universal variant datatype, and your use of syntactically invalid variable names.

CF variable names have to start with an alpha, underscore, or currency character. I'm not sure why, but the CF compiler apparently doesn't validate your variable names when you pass them in via cfinvokeargument (probably because it assumes you're calling named arguments that exist and have been validated within the function). So when the the arguments are passed in, it first creates an Arguments Array with three elements, and then tries to populate an Arguments Struct with the elements in the array: "1", "5" and "10", but when it tries to populate that struct, it calls Arguments["1"], but it can't tell the difference between that and Arguments[1], because internally, it's a variant either way. As such, Arguments["1"] returns the first element in the Arguments array, and Arguments["10"] is trying to return the 10th element in the Arguments array, which obviously doesn't exist.

If you change your <cfinvokeargument> tags to pass in "1", "2", and "3" instead, you'll find that all Argument structure values are populated, but in the order you passed them in, not according to the keys you specified.

Likewise, if you pass them in as "one", "ten" and "five" they will act as expected.

Another possible solution to your quandry would be to pass them in in array syntax, e.g.

<cfinvoke method="DumpArgs">
<cfinvokeargument name="args[3]" value="Kim" />
<cfinvokeargument name="args[2]" value="Jessie" />
<cfinvokeargument name="args[1]" value="Samantha" />

Don't know if that fits what you're trying to do, but it seems to get around the immediate problem.


actually you can pass argument names that are not syntactically valid variable names.

<cfinvokeargument name="another girl" value="Kim" />

will work as expected. And it should, too, because all strings can be keys of a struct. myVar['some invalid var name'] is a syntactically correct way to address a struct element (as is myVar['10'], if myVar is a struct and not an array). If numbers don't work with <cfinvokeargument>, I think it should be considered a bug.

However, if you want to pass in arguments without a name and address them in the order they were passed in, you can use the script syntax:




The only problem with calling DumpArgs() in that fashion is that I needed to have logic in which arguments were sent:

if (true){ 'Samantha', }
if (false){ 'Kim', }
if (true){ 'Nicki', }

Now, obviously, that is NOT working code. I was just showing you what I had in my mind. This type of logic can be accomplished using the CFInvoke and CFInovkeArgument tags as you can have CFIF statements in them.... I just didn't know how to label the "name" attribute of the argument tag. The index-based naming will take care of that now.... I just need an elegant way to increment the index number as a I use it.


Ahhh... I see.

Couldn't you simply use an array, conditionally append element, and then pass that array to the function?

Or, if you need single arguments within your function, could you use a struct with numeric keys and pass that struct in as argumentcollection?



I really like the Struct with numeric keys and then an argumentCollection... Very slick idea, you old dog! I will give that a shot.