Rest Operator Doesn't Work With Only One Argument In Adobe ColdFusion

@BenNadel

Hey Ben

This is very interesting.
I actually never knew that Coldfusion had a rest operator. Does Lucee have this, as well?

And why would you use this, over the arguments struct? Maybe, if you want to guarantee the order of the arguments, which an array will do and a struct won't?

And one last question, does Coldfusion have a spread operator?

@Ben Nadel,

This is fabulous information. 🙂

I never realised that Coldfusion had destructuring, either. I actually really like
destructuring, which I use a lot, when writing JavaScript.
It's a little surprising that Lucee doesn't contain these kinds of constructs, considering Lucee is all about modernisation.

I may check to see if Lucee 6 has:

1. Rest/spread operator
2. Destructuring

@Ben Nadel,

Hmmmm. Now you've got me. 🤩
I mean I use destructuring mainly, in JavaScript, to extract key/value pairs into individual variables.
This kind of thing was used in React, a lot when using hooks, like:

import { useState } from 'react'

function Example() {
	// Declare a new state variable, which we'll call "count"
	const [count, setCount] = useState(0)

	return (
		<div>
			<p>You clicked {count} times</p>
			<button onClick={() => setCount(count + 1)}>Click me</button>
		</div>
	)
}

As far as a use case goes, let's say you've got a huge object [struct in CF], destructuring helps to make code more readable. It clarifies which keys in an object, are the main players, as it were.
It is declarative.

I actually use it a lot when I am designing REST API applications in NodeJs.
It is great to take a massive JSON object, passed into a route handler, and explicitly tell the method what variables are required from the object.

And I can actually see this working in component methods, as well, when passing structs or arrays as arguments
Like when we used to add our var scoped variables, at the top of a method, to set out our stall, so to speak.

I generally use the local scope now.
But, we could do something like:

public struct function myMethod(struct myStruct = {}) {
   var { key1, key2 } = arguments.myStruct;
    return {
        key1,
        key2
    };
}

WriteDump( var = myMethod({
    key1: 'foo',
    key2: 'bar'
}) );

And the other great thing about this, is that it bypasses the problem with Coldfusion, whereby you cannot assign multiple vars, in a single declaration, like:

var key1 = arguments.myStruct.key1, key2 = arguments.myStruct.key2;

And I might be a good way of unpacking an argument collection like:

public struct function myMethod() {
   var { arg1, arg2 } = arguments;
    return {
        arg1,
        arg2
    };
}

WriteDump( var = myMethod( argumentCollection = { 
    arg1: {
        key1: 'foo',
        key2: 'bar'
    },
    arg2: {
        key3: 'foo',
        key4: 'bar'
    }
}) );

This could be for the purists who prefer not to have to prefix their args with the arguments scope, which although isn't necessary, is something I feel I should do, to make things clear to other Devs, in the team.
Doing it, the above way, makes it clear to other Devs, whilst still scoping the variables correctly.
But, others might think this is overkill?

Here is quite a nice article on Coldfusion destructuring

https://www.bockensm.com/2022/10/11/scoping-destructured-variables/

@Ben Nadel,

Yes. Functional React seems like a reaction to me.
It's like trying to place a square peg into a round hole.
Class component based React made far more sense, to me, and this is borne out by the amount of hooks, the core team has had to build, to patch all the problems that functional React, has created.
And, I'm definitely with you on the conciseness of using matching Struct key/value names. I use this all time in JavaScript.
Saves a bit of space and improves readability. 🙂