CODEWITHSUNDEEP
php
user12390548
user12390548

Reputation:

Should my PHP functions actively return the "right" type?

I have made various functions such as "get_current_balance_from_my_bank_account()". It technically returns a string, but it's always a full integer number (as a string) which has never caused problems when its return variable is used directly in calculations.

However, it feels wrong.

Should I be doing something like this?

return (int)$amount_as_a_string;

Instead of the current:

return $amount_as_a_string;

? Or is (int) some archaic/legacy way of doing this? Should I be using some other, better method?

Example of the context:

$my_balance = get_current_balance_from_my_bank_account();
$previous_balance = load_last_balance();

echo 'I have ' . format_money_prettily($my_balance - $previous_balance) . '!' . PHP_EOL;

Again, I rarely if ever run into issues with this because it understands the "real" type. It does still feel wrong that I'm technically returning and sending around strings which in theory could be causing problems sooner or later -- perhaps catastrophic ones in production!

Upvotes: 1

Views: 428

Answers (4)

Martin Dimitrov
Martin Dimitrov

Reputation: 1304

This will never be required in PHP, as it does the type conversion by itself. However you can do this if you want. This depends from project to project, but sometimes a decision is made for a certain project to use explicit types where possible. Also this is a good practice if you are working on a team where some of the people are comfortable with more strict languages.

In your case, depending on the number, there might be a good side in keeping it as a string, as if you convert it to int via casting and the number is bigger than the max_int_size, it will overflow.

As for the other question, casting as int (int) or (integer) is a perfectly good way to do it, even in newer versions. It is not a legacy way whatsoever. This does not mean there aren't other good ways to do that, though. You can also use something like intval() or settype(). In my opinion there isn't one right way to do it. You can decide for yourself on how to do that.

Upvotes: 0

lovelace
lovelace

Reputation: 1205

If you want to be more explicit about typing in PHP, have a look at the following from the manual:

default

By default, PHP will coerce values of the wrong type into the expected scalar type if possible. For example, a function that is given an integer for a parameter that expects a string will get a variable of type string.

Strict mode

It is possible to enable strict mode on a per-file basis. In strict mode, only a variable of exact type of the type declaration will be accepted, or a TypeError will be thrown. The only exception to this rule is that an integer may be given to a function expecting a float. Function calls from within internal functions will not be affected by the strict_types declaration.

To enable strict mode, the declare statement is used with the strict_types declaration:

<?php
declare(strict_types=1); // strict type declaration MUST be the very first statement in your script

function sum(int $a, int $b) {
    return $a + $b;
}

var_dump(sum(1, 2));
var_dump(sum(1.5, 2.5));
?>

output

int(3)

Fatal error: Uncaught TypeError: Argument 1 passed to sum() must be of the type integer, float given

Note: Enabling strict mode will also affect return type declarations.

source: php.net

Upvotes: 0

failedCoder
failedCoder

Reputation: 1424

I don't think that is something you have to worry to much, considering that php has automatic type conversion.

From the docs:

PHP does not require (or support) explicit type definition in variable declaration; a variable's type is determined by the context in which the variable is used.

Just because the function returns the right data type does not mean that the value is correct or what you expect.

If you want to make sure that the function returns ok value, validating it before returning it much more helpful than simply typecasting it to correct type.

Upvotes: 0

deceze
deceze

Reputation: 522016

PHP will implicitly type cast in many situations, but not all. Take for example this:

echo json_encode(['balance' => get_current_balance_from_my_bank_account()]);

Now your type propagates to some other system via JSON, where it may cause actual issues if that system isn't so lenient about types. You're making somebody else deal with your incorrect type.

So, yes, your function should always return the type that it claims it returns. PHP implicitly "helping" you when you don't stick to your own type declarations is just sweeping the problem in the rug, but the problem is still there and may eventually cause actual issues.

Upvotes: 2

Related Questions