Be part of JetBrains PHPverse 2026 on June 9 – a free online event bringing PHP devs worldwide together.
While coding, i just wonder why this work ?
class FetchService
{
public function getById($id)
{
if (true) {
// Read be careful, i'm not passing array
$this->exitBrowser("[%s] 🔔 id is invalid format (%s)",
now()->toTimeString(),
$id,
);
}
}
public function exitBrowser(...$params)
{
$this->dddd(...$params);
$this->browser->quit();
$this->browser->stop();
}
public function dddd(...$params)
{
dump(sprintf(...$params));
}
}
$fetch = new FetchService();
$fetch->getById('something wrong');
//result
[21:00:00] 🔔 id is invalid format (something wrong)
Why keep passing ...$params and this sprintf(...$params) work?
The ... operator (called rest or splat in other languages) can be used for variadic functions, i.e. where the function can accept variable numbers of arguments.
It is also usable as a spread operator to unpack arrays or traversables into function parameters, or spread into other arrays, e.g.
$parts = ['apple', 'pear'];
$fruits = ['banana', 'orange', ...$parts, 'watermelon'];
https://www.php.net/manual/en/functions.arguments.php#functions.variable-arg-list
@tykus But $params is array and sprintf() first param accept string only
@newbie360 yes, I explained that the spread operation unpacks arrays or traversables into function parameters. The exitBrowser function is passed three parameters:
"[%s] 🔔 id is invalid format (%s)"
now()->toTimeString()
$id
In the function's signature, they are packed into the $params array. However, they are then unpacked again (using ...) whenever you call sprintf
@tykus If i add a line before sprintf(), it is array
public function dddd(...$params)
{
dump(...$params); // this return array
dump(sprintf(...$params));
}
so WHEN it auto unpack ?
@newbie360 it unpacks here sprintf(...$params) so equivalent of:
sprintf("[%s] 🔔 id is invalid format (%s)", now()->toTimeString(), $id)
@tykus OK, so dddd(...$params) is receive '....., ....., ......' or array ?
@newbie360 same as above... you unpack an array $params into dddd, equivalent of:
dddd("[%s] 🔔 id is invalid format (%s)", now()->toTimeString(), $id)
TBH I don't see the need for dddd in the context above; it is just a wrapper around dump(sprintf()) - it adds nothing...
@tykus I use this very long time ago
public function something($params)
{
$params = is_array($params) ? $params : func_get_args();
}
could i use ...$params instead ?
Edit: the dddd() just a wrapper, but use anywhere to dump in console, the exitBrowser() is for close the browser
@newbie360 essentially, yes. Just be aware that $params will always be an array whenever the function is variadic
may be i give the best answer to the first reply.
@tykus OK thanks
@amitsolanki24_ your reply very detail, actually i know what is ...$params, but i just wonder why it can auto unpack, good day
#AI deep description
The `...$params` syntax is called the "splat" or "variadic" operator in PHP, which allows you to pass an arbitrary number of arguments to a function. Here's what's happening in your code:
### Key Concepts:
1. **Variadic Functions (`...$params`)**:
- In both the `exitBrowser` and `dddd` methods, `...$params` is used to collect any number of arguments passed to the method. These arguments are gathered into an array.
- When you call `exitBrowser("[%s] 🔔 id is invalid format (%s)", now()->toTimeString(), $id);`, the arguments are passed into `exitBrowser` as an array:
```php
[
"[%s] 🔔 id is invalid format (%s)",
now()->toTimeString(),
$id
]
```
2. **Passing Arguments to `sprintf`**:
- The `dddd` method uses `sprintf(...$params)` where `...$params` "unpacks" the array of arguments into individual parameters for `sprintf`. It is equivalent to calling:
```php
sprintf("[%s] 🔔 id is invalid format (%s)", "21:00:00", "something wrong");
```
- The `sprintf` function takes a format string as the first argument, followed by values to replace the placeholders (`%s` in this case). It formats the string accordingly.
3. **Why It Works**:
- The variadic operator (`...`) in the `dddd` method allows you to pass all collected arguments (`$params`) to `sprintf` dynamically.
- Without `...`, you would need to manually pass each argument, which is less flexible for handling an arbitrary number of inputs.
### Summary:
- `...$params` in the method signature collects arguments into an array.
- `sprintf(...$params)` unpacks the array back into separate arguments for `sprintf`, which processes the format string and its values.
I hope you can easily understand.
Please or to participate in this conversation.