Какие типы значения может вернуть функция инструкцией return php

Значения возвращаются при помощи необязательного оператора возврата.
Возвращаемые значения могут быть любого типа, в том числе это могут
быть массивы и объекты. Возврат приводит к завершению выполнения функции и передаче
управления обратно к той строке кода, в которой данная функция была
вызвана. Для получения более детальной информации ознакомьтесь с описанием
return.

Замечание:

Если конструкция return не указана, то функция вернет
значение NULL.

int(3)

Fatal error: Uncaught TypeError: Return value of sum() must be of the type integer, float returned in - on line 5 in -:5
Stack trace:
#0 -(9): sum(1, 2.5)
#1 {main}
  thrown in - on line 5

Вернуться к: Функции

Return types in PHP refer to the type of data returned by a function in PHP. In strongly typed languages like JAVA, every function must have a return type but it is optional in PHP as it is a loosely typed programming language. It is a good practice to include return types as it reduces ambiguity, limits error and improves code quality.

We will be looking into several return types in PHP. Without any further ado, let’s dive in.

Prerequisite

• PHP version 8

• Basic knowledge of PHP

To enforce return type in PHP functions, we need to include a simple declaration at the top of the file.

declare(strict_types=1);

This is a PHP directive that enforces strict typing. It is used to ensure that only values of the expected data type are passed to a function or method.

When strict_types is set to 1, PHP will require that function arguments are of the correct data type. If an argument is of the wrong type, PHP will throw a TypeError instead of attempting to convert the argument to the expected type.

With this in place, we can be rest assured PHP is not doing any type conversion that we may not be aware of when incorrect types are used.

The type of data we want the function or method to return is declared by putting a colon and the type between the closing parenthesis and the opening curly bracket.

int

int return type represents integers in PHP. They are positive or negative whole numbers without decimals, int can also be zero.

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

echo addition(12, 20);

In class example:

class Arithmetic {
  public function __construct(public int $a, public  int $b) {}

  public function addition(): int {
    $sum = $this->a + $this->b;
    return $sum;
  }
}

echo (new Arithmetic(12, 20))->addition();

string

The string is a return type used to represent text. It can contain any sequence of characters, including letters, numbers, symbols, and whitespace.

Strings can be declared using a single or double quote.

function greeting(): string {
 return "Good day fellow!";
}

echo greeting();

class Greeting {
  public function __construct(public string $message) {}

  public function greeting(): string {
    return $this->message;
  }
}

echo (new Greeting("Good day fellow!"))->greeting();

float

Float is a return type used to represent numbers with a decimal point. Floats are also known as «floating point numbers» or «doubles».

function price(): float {
  return 10.56;
}

echo price();

class Socks {
  public function price(): float {
    return 10.56;
  }
}

(new Socks())->price();

Floats can be negatives too.

function price(): float {
  return -1.78;
}

echo price();

class Socks {
  public function price(): float {
    return -1.78;
  }
}

(new Socks())->price();

bool

bool, short for «boolean», is a return type used to represent logical values. A bool variable can only have two possible values: true or false.

It is important to note that PHP returns 1 for true and nothing for false.

function isComplete(): bool {
  return true;
}

echo isComplete();


function isAdult(int $age): bool {
  return $age >= 18;
}

echo isAdult(10);

class Task {
  public function isComplete(): bool {
    return true;
  }
}

class Person {
   public function isAdult(int $age): bool {
    return $age >= 18;
  }
}

echo (new Task)->isComplete();
echo (new Person)->isAdult(2);

array

The array is a return used when a method or function is expected to return an array. PHP has index, associative and multidimensional arrays, any of these can be returned when an array return value is used.

function playlist(): array {
  return ['Diced Pineapple', 'Formation', 'Thinking Out Loud'];
}

print_r(playlist());

function user(): array {
  return ['name' => 'John', 'age' => 25, 'location' => 'New York'];
}

print_r(user());

class Playlist {
  public function music(): array {
    return ['Diced Pineapple', 'Formation', 'Thinking Out Loud'];
  }

  public function user(): array {
    return ['name' => 'John', 'age' => 25, 'location' => 'New York'];
  }
}

print_r(
  (new Playlist)->music()
);

print_r(
  (new Playlist)->user()
);

void

In the case we do not wish to return anything, the void is the goto return type. It simply means nothing will be returned.

function earth(): void {
  $title = "This planet supports life";
  $age_in_years = 4_800_000_000;
}

earth();

class Planet {
  public function earth(): void {
    $title = "This planet supports life";
    $age_in_years = 4_800_000_000;
  }
}

(new Planet)->earth();

mixed

A mixed return type is used to indicate that a function or method may return different data types, depending on the input or the logic within the function. This is helpful when you cannot determine the exact return type ahead of time, or when the return type is dependent on a complex set of conditions.

function randomType(): mixed {

    $value;

    switch(rand(1, 5)) {

      case 1: $value = "Good day fellow!";
      break;
      case 2: $value = 10.22;
      break;
      case 3: $value = true;
      break;
      case 4: $value = ['Sport', 'Movies'];
      break;
      default: $value = 100;
      break;

    }

    return $value;
}

echo randomType();

class RandomType {
  public function value(): mixed {

    $value;

    switch(rand(1, 5)) {

      case 1: $value = "Good day fellow!";
      break;
      case 2: $value = 10.22;
      break;
      case 3: $value = true;
      break;
      case 4: $value = ['Sport', 'Movies'];
      break;
      default: $value = 100;
      break;

    }

    return $value;

  }
}


echo (new Randomtype)->value();

callable

The callable return type in PHP allows a function to indicate that it returns a callable or a function reference that can be called later.

function getMultiplier(int $factor): callable {
    return function (int $number) use ($factor) {
        return $number * $factor;
    };
}

$multiplyByTwo = getMultiplier(2);
echo $multiplyByTwo(5); 


$multiplyByThree = getMultiplier(3);
echo $multiplyByThree(6);

class Multiplier {

    public function __construct(public int $factor) {}

    public function getMultiplier(): callable {
        return function (int $number) {
            return $number * $this->factor;
        };
    }
}

$multiplyByTwo = (new Multiplier(2))->getMultiplier();
echo $multiplyByTwo(5);

$multiplyByThree = (new Multiplier(3))->getMultiplier();
echo $multiplyByThree(6);

resource

The resource return type is used to indicate that a function or method returns a resource type. Resource type is a special data type that represents an external resource, such as a file, a database connection or a network socket.

function openFile(string $filename): resource {

  $file = fopen($filename, "r");

  if (!$file) {
    throw new Exception("Failed to open file: $filename");
  }

  return $file;

}

class FileHandler {

  public function openFile(string $filename): resource {

    $file = fopen($filename, "r");

    if (!$file) {

      throw new Exception("Failed to open file: $filename");

    }

    return $file;

  }

}

class

Classes can also be a return type. In this example, the Zoo class has a method called getAnimal() that returns an object of the Animal class. The return type of this method is specified as Animal using the :Animal syntax after the method signature. This means the return type will be a type of Animal class or any of its subclasses.

class Animal {
  public function __construct(public string $name, public int $age) {}
}

function getAnimal(): Animal {
    return new Animal("Leo", 5);
}

print_r(getAnimal());

class Animal {
  public function __construct(public string $name, public int $age) {}
}

class Zoo {
  public function getAnimal(): Animal {
    return new Animal("Leo", 5);
  }
}

print_r((new Zoo())->getAnimal());

object

The object return type is similar to the :class return type but the major difference is, it will return instances of any class and not a particular class.

class Address {
  public function __construct(public string $street, public string $city, public string $state) {}
}

class Person {
  public function __construct(public string $name, public Address $address) {}

  public function getAddress(): object {
    return $this->address;
  }
}

$address = new Address("123 Main St", "Anytown", "CA");
$person = new Person("John Doe", $address);
$addressObj = $person->getAddress();

Note that since the return type of getAddress() is specified as :object, the returned value can be an instance of any class, not just Address.

union

What if we can not tell the actual type a class should return or do we want to intentionally make the return type for any class dynamic?

PHP allows us to include additional return types using the union type, this allows us to include alternate types by separating them with a pipe |.

function price(): int | float {
  return 10;
}

function price(): int | float {
  return 10.4;
}

class Socks {
  public function price(): int | float {
    return 10;
  }
}

(new Socks)->price();

class Socks {
  public function price(): int | float {
    return 10.4;
  }
}

(new Socks)->price();

The optional type can have as many as possible types separated by a pipe, this feature should not be abused.

What If We Want a Null Value Returned

To return a null type, we need to add ? in front of the return type.

function hello(): ?string {
  return null;
}

hello();

In this case, the return type of the function can be either a string or null. No exception will be thrown.

class Optional {

  public function hello(): ?string {
    return null;
  }

  public function number(): ?int {
    return null;
  }

  public function price(): ?float {
    return null;
  }
}

echo (new Optional)->hello();
echo (new Optional)->number();
echo (new Optional)->price();

Conclusion

Return types are an important feature in PHP that allows developers to specify the type of value that a function should return. By declaring a return type, PHP can ensure that the value returned by a function is of the expected type, which can help prevent errors and improve code quality.

In PHP 7 and later versions, developers can use several different types of return types, including scalar types like int, float, and string, as well as compound types like array and callable. Additionally, PHP 8 introduced new return types, including union types and mixed types, which provide even more flexibility for developers.

Type declarations in PHP can be used not only for return types but also for parameter types and class properties. Type declarations can help prevent type errors, improve code readability, and make code easier to maintain.

Время на прочтение
5 мин

Количество просмотров 42K

Каждый мажорный релиз PHP добавляет ряд новых возможностей, некоторые из которых действительно имеют значение. Для PHP 5.3 — это были пространства имен и анонимные функции. Для PHP 5.4 — трейты. Для PHP 5.5 — генераторы. Для 5.6 — списки аргументов переменной длины.

PHP 7 имеет большое количество новшеств и улучшений, делающих жизнь разработчика легче. Но я считаю, что самым важным и долгосрочным изменением является работа с типами. Совокупность новых фич изменит взгляд на PHP разработку в лучшую сторону.

Почему поддержка строгой типизации так важна? Она предоставляет программе — компилятору или рантайму и другим разработчикам ценную информацию о том, что вы пытались сделать, без необходимости исполнять код. Это дает три типа преимуществ:

1. Становится намного легче сообщать другим разработчикам цель кода. Это практически как документация, только лучше!
2. Строгая типизация дает коду узкую направленность поведения, что способствует повышению изоляции.
3. Программа читает и понимает строгую типизацию точно также как человек, появляется возможность анализировать код и находить ошибки за вас… прежде чем вы его исполните!

В подавляющем большинстве случаев, явно типизированный код будет легче понять, он лучше структурирован и имеет меньше ошибок, чем слабо типизированный. Только в небольшом проценте случаев строгая типизация доставляет больше проблем, чем пользы, но не беспокойтесь, в PHP проверка типов все еще является опциональной, также как и раньше. Но на самом деле, ее стоит использовать всегда.

Возвращаемые типы

Первым дополнением к уже существующей системе типизации будет поддержка возвращаемых типов. Теперь можно указывать в функциях и методах тип возвращаемого значения в явном виде. Рассмотрим следующий пример:

class Address {

  protected $street;
  protected $city;
  protected $state;
  protected $zip;

  public function __construct($street, $city, $state, $zip) {
    $this->street = $street;
    $this->city = $city;
    $this->state = $state;
    $this->zip = $zip;
  }

  public function getStreet() { return $this->street; }
  public function getCity() { return $this->city; }
  public function getState() { return $this->state; }
  public function getZip() { return $this->zip; }

}

class Employee {
  protected $address;

  public function __construct(Address $address) {
    $this->address = $address;
  }

  public function getAddress() : Address {
    return $this->address;
  }
}

$a = new Address('123 Main St.', 'Chicago', 'IL', '60614');
$e = new Employee($a);

print $e->getAddress()->getStreet() . PHP_EOL;
// Prints 123 Main St.

В этом довольно приземленном примере у нас есть объект Employee, который имеет только одно свойство, содержащее переданный нами почтовый адрес. Обратите внимание на метод getAddress(). После параметров функции у нас есть двоеточие и тип. Он является единственным типом, который может принимать возвращаемое значение.

Постфиксный синтаксис для возвращаемых типов может показаться странным для разработчиков, привыкших к C/C++ или Java. Однако, на практике подход с префиксным объявлением не подходит для PHP, т.к. перед именем функции может идти множество ключевых слов. Во избежание проблем с парсером PHP выбрал путь схожий с Go, Rust и Scala.

При возврате любого другого типа методом getAddress() PHP будет выбрасывать исключение TypeError. Даже null не будет удовлетворять требованиям типа. Это позволяет нам с абсолютной уверенностью обращаться в print к методом объекта Address. Мы точно будем знать, что действительно вернется объект именно этого типа, не null, не false, не строка или какой-то другой объект. Именно этим обеспечивается безопасность работы и отсутствие необходимости в дополнительных проверках, что в свою очередь делает наш собственный код чище. Даже если что-то пойдет не так, PHP обязательно предупредит нас.

Но что делать, если у нас менее тривиальный случай и необходимо обрабатывать ситуации, когда нет объекта Address? Введем EmployeeRepository, логика которого позволяет не иметь записей. Сначала мы добавим классу Employee поле ID:

class Employee {

    protected $id;
    protected $address;

    public function __construct($id, Address $address) {

        $this->id = $id;
        $this->address = $address;

    }

    public function getAddress() : Address {
        return $this->address;
    }

}

А теперь создадим наш репозиторий. (В качестве заглушки добавим фиктивные данные прямо в конструктор, но на практике, конечно же, необходимо иметь источник данных для нашего репозитория).

class EmployeeRepository {

    private $data = [];
    public function __construct() {

        $this->data[123] = new Employee(123, new Address('123 Main St.', 'Chicago', 'IL', '60614'));
        $this->data[456] = new Employee(456, new Address('45 Hull St', 'Boston', 'MA', '02113'));

    }

    public function findById($id) : Employee {
        return $this->data[$id];
    }

}

$r = new EmployeeRepository();

print $r->findById(123)->getAddress()->getStreet() . PHP_EOL;

Большинство читателей быстро заметит, что `findById()` имеет баг, т.к. в случае, если мы попросим несуществующий идентификатор сотрудника PHP будет возвращать `null` и наш вызов `getAddress()` умрет с ошибкой «method called on non-object». Но на самом деле ошибка не там. Она заключается в том, что `findById()` должен возвращать сотрудника. Мы указываем возвращаемый тип `Employee`, чтобы было ясно чья это ошибка.

Что же делать, если действительно нет такого сотрудника? Есть два варианта: первый — исключение; если мы не можем вернуть то, что мы обещаем — это повод для особой обработки за пределами нормального течения кода. Другой — указание интерфейса, имплементация которого и будет возвращена (в том числе и «пустая»). Таким образом, оставшаяся часть кода будет работать и мы сможем контролировать происходящее в «пустых» случаях.

Выбор подхода зависит от варианта использования и также определяется рамками недопустимости последствий в случае невозвращения правильного типа. В случае репозитория, я бы поспорил с выбором в пользу исключений, поскольку шансы попасть именно в такую ситуацию минимальны, а работа через исключения является довольно дорогостоящей по производительности. Если бы мы имели дело со скалярной переменной, то обработка «пустого значения» было бы приемлемым выбором. Модифицируем наш код соответственно (для краткости показаны только измененные части):

interface AddressInterface {

    public function getStreet();
    public function getCity();
    public function getState();
    public function getZip();

}

class EmptyAddress implements AddressInterface {

    public function getStreet() { return ''; }
    public function getCity() { return ''; }
    public function getState() { return ''; }
    public function getZip() { return ''; }

}

class Address implements AddressInterface {

    // ...

}

class Employee {

    // ...

    public function getAddress() : AddressInterface {

        return $this->address;

    }

}

class EmployeeRepository {

    // ...

    public function findById($id) : Employee {

        if (!isset($this->data[$id])) {
            throw new InvalidArgumentException('No such Employee: ' . $id);
        }
        return $this->data[$id];
    }

}

try {
    print $r->findById(123)->getAddress()->getStreet() . PHP_EOL;
    print $r->findById(789)->getAddress()->getStreet() . PHP_EOL;
} catch (InvalidArgumentException $e) {
    print $e->getMessage() . PHP_EOL;
}

/* 
 * Prints:
 * 123 Main St.
 * No such Employee: 789
 */

Теперь getStreet() будет отдавать хорошее пустое значение.

Одно важное примечание о возвращаемых типах: при наследовании тип не может быть изменен, даже нельзя сделать его более конкретным (подклассом, например). Причина в особенностях ленивой загрузки PHP.

Возвращаемые типы являются большой, но далеко не единственной новой особенностью, расширяющей систему типов PHP. Во второй части мы рассмотрим другое, пожалуй даже более важное изменение: декларирование скалярных типов.

Последнее обновление: 11.03.2021

Функция может возвращать некоторое значение — число, строку и т.д., то есть некоторый результат.
Для возвращения значения в функции применяется оператор return, после которого указывается возвращаемое значение.

Например, получим из функции сумму двух чисел:

<?php
function add($a, $b)
{
    return $a + $b;
}

$result = add(5, 6);
echo $result;			// 11
?>

Функция add() принимает два параметра и возвращает сумму их значений.

return $a + $b;

Поскольку функция возвращает значение, мы его можем присвоить переменной:

$result = add(5, 6);

Либо использовать напрямую:

echo add(4, 8);

Если после инструкции return в функции идут другие инструкции, то они не будут выполняться:

function add($a, $b)
{
	$sum = $a + $b;
    return $sum;		// завершение функции
	echo "sum = $sum";	// эта строка не будут выполняться
}

В реальности даже если функция не использует оператор return, она все равно возвращает значение, только в этом случае это значение — null:

<?php
function add($a, $b)
{
	$sum = $a + $b;
	echo "sum = $sum<br />";
}

$result = add(5, 6);

if($result === null)
	echo "result равен null";
else
	echo "result не равен null";
?>