How to make a function parameter optional for both an array and a string using the same variable

I want to have a variable that is passed to my function as either an array or a string and have them optional. Here is the sample function:

function myFunction(string $msg = '' || array $msg = []) { // This is line 9
	if(is_string($msg)) {
		echo "I'm a string";
	} else if (is_array($msg)){
		echo "I'm an array";
	}
}

Is this possible? I can't find anything that specifically shows this. When I try to run this function on a test page I get the following error:

> Parse error: syntax error, unexpected variable "$msg", expecting "("
> in /Path/To/My/File/test.php on line
> 9

I have looked at the php manual for function arguments: https://www.php.net/manual/en/functions.arguments.php and it states:

> Information may be passed to functions via the argument list, which is
> a comma-delimited list of expressions. The arguments are evaluated
> from left to right, before the function is actually called (eager
> evaluation).

So why wouldn't what I wrote work?

EDIT... Here is the actual method that I'm using.

public function flash(string|array $name = '', string|array $message = '', string $type = '') {
	if (!empty($name) && !empty($message) && $type !== '') {
		// create a flash message
		$this->createFlashMessage($name, $message, $type);
	} elseif ($name !== '' && $message === '' && $type === '') {
		// display a flash message
		return $this->displayFlashMessage($name);
	} elseif ($name === '' && $message === '' && $type === '') {
		// display all flash message
		return $this->displayAllFlashMessages();
	}
}

The first paramter takes a name, like error_msg and it will assign it to a

> $_SESSION[FLASH_MESSAGE][$name]

$name being the 'error_msg'. It works fine for single instances. But I have run across a situation while uploading image files if there are multiple errors with multiple uploads on the same file input field,

<input type="file" name="upload[]" multiple>

When I call the $load = $upload->uploadFile method it can either return a string with the file names ready to input into the database. The string is a comma deliminated list or uploadFile will return an array with the errors:

> $upload = ['server_error => ['message' => 'Error message here', 'type' => 'FLASH_ERROR']];

But in the instance where there are multiple errors on the same upload, then:

> $upload = ['server_error' => [['message' => 'First error message', 'type' => 'FLASH_ERROR'],['message' => 'Second Error message', 'type' => 'FLASH_MESSAGE']]];

But that is why I was needing to be able to pass either an array, string or nothing... on a side note, my brackets may or may not be properly on here I'm still trying to switch over to using the brackets rather than using array(array())

It is posible, but the default value must be one of the types in your union type (Available since PHP 8.0):

function myFunction(string|array $msg = [])

//OR

function myFunction(string|array $msg = '')

1. Composite Types: https://www.php.net/manual/en/language.types.declarations.php#language.types.declarations.composite
2. Nullable Types: https://www.php.net/manual/en/language.types.declarations.php#language.types.declarations.nullable

function myFunction(string|array $msg = NULL) {
    if( is_null($msg) ) {
        // do a default thing?
    }
    var_dump($msg);
}

myfunction();
myfunction('foo');
myfunction(['foo']);

Output:

NULL
string(3) "foo"
array(1) {
  [0]=>
  string(3) "foo"
}

Note: Composite Types are only available in PHP>=8. To accomplish this in PHP<8 you would have to omit the type declaration completely, and implement the check yourself. Eg:

function myFunction($msg = NULL) {
    if( ! in_array(gettype($msg), ['string', 'array', 'NULL']) ) {
        throw new \Exception('Parameter msg not of an acceptable type.');
    }
    var_dump($msg);
}

Though if you're trying to accommodate "one or more" in a simplified manner I would suggest something like the following instead:

function handleOne(string $msg) {
    echo $msg . PHP_EOL;
}

function handleMany(array $msgs) {
    foreach( $msgs as $msg ) {
        handleOne($msg);
    }
}

handleOne('first');
handleMany(['second', 'third']);

Which has the additional benefit of ensuring that all the array members are strings, along with being much easier to maintain.

A completion to the previous answers can be the casting to array of the parameter so you can handle it in a single way:

function myFunction(string|array $msg = []) 
{
   foreach ((array)$msg as $m) {
     // manage $msg(s)
   }
}

I am noticing multiple design choices that are leading to headaches and future headaches.

1. I am hoping that flash() doesn't make circular calls create a flash message. There is a code smells that flash() conditionally returns. It seems that this method is not obeying the "single-responsibility" principle in SOLID design.

2. While as other have said already, you can use union types in your method signature, the looseness of the input data results in your method(s) needing to awkwardly accommodate it.

3. !empty($message) is an unreasonable check. $message is never passed into the method, so it will always evaluate as false -- therefore $this->createFlashMessage($name, $message, $type); will never possibly be executed.

In my applications, if an incoming value is expected to be an array (or iterable), I do not allow the parameter to be a non-array type (or non-iterable). Either the array is empty or it is not, but either way, the data can be directly/unconditionally passed into a loop/iterator. In EXTREMELY rare/desperate situations, I may permit a nullable array type with ?array but this is not preferred.

It seems to me that flash() is a flash router/handler, perhaps that should be semantically conveyed in the method name: flashRouter().

I cannot offer complete advice on your script, but from what I gather, displayAllFlashMessages() is built to accept no arguments and will happily process any number of flash messages. I would ditch this flash() method and send all requests to displayAllFlashMessages() and ensure that all calls of that function deliver the data as an array. If those $name and type variables are relevant, pass them to displayAllFlashMessages().