Should one use strongly typed coding concepts when working with a loose type language?

Question

For example, in PHP or other loose type languages, I can have some code like this:

/* PSEUDOCODE based on PHP */
$selection = $this->getSelection($id);

/* Below code will not work in a strict language */
if (is_array($selection))
    show_template($selection);//forwards *array* results to the view script
else 
    print $selection; //prints the *string* notice message

/* Returns either array or string */
/* return param doubles as a business-payload or error message */
function getSelection($id)
{
    $result = $db->getResultsById($id);
    if ($result) return $result;//array
    else return "No results";//string
}

Because I can do this in PHP and similar languages, does it mean that I should?

An alternative can be forcing myself to code in a similar was as I would for example, in C++, to where I'd redesign the code or create data structures to where it would maintain its type. But should I do that?

Answer 1

The fact that PHP is not strongly typed is both a gift and a curse. It's great for when you want to be able to handle multiple types, but can also lead to some buggy code if not handled correctly. Personally, I use 'strong typing' in PHP wherever possible in order to avoid errors (and it looks cleaner and is usually easier to read/understand). Even so, PHP can and usually does conversions automatically whenever and wherever it can (see below), this is where the 'curse' comes in.

function foo(string $string) : int{
    //$string will be cast as string if possible, return value is cast as int if possible
    return $string;
}

echo foo(1);

Output:

1

Unfortunately, the only real way to enforce type (without using declare(strict_types=1);) is by type-checking;

function foo($string){
    if(is_string($string) && is_numeric($string)){
        return (int)$string;
    }else{
        return null;
    }
}

var_dump(foo(1));
echo '<br>';
echo foo('1');

Output:

NULL
1

Alternatively, you can tell PHP to use strict types;

declare(strict_types=1);

...but then of course you lose some of the benefits of a loosely typed language. At the end of the day, it's up to you!