PHP – What is OOP
PHP – What is OOP
In PHP, OOP stands for Object-Oriented Programming. It is a programming paradigm that focuses on the use of objects and classes to represent and manipulate data and behavior.
In object-oriented programming, a class is a blueprint for creating objects, which are instances of the class. Each object has its own state (represented by instance variables) and behavior (represented by methods).
Object-oriented programming provides several benefits over procedural programming, including encapsulation, inheritance, and polymorphism. Encapsulation allows you to hide the implementation details of a class from other code, which makes it easier to maintain and modify. Inheritance allows you to create new classes that inherit the properties and methods of existing classes, which can save time and improve code reuse. Polymorphism allows you to use a single interface to represent multiple types of objects, which can make your code more flexible and easier to extend.
PHP has strong support for object-oriented programming, with features like classes, objects, inheritance, interfaces, and traits. By using these features, you can write code that is more modular, reusable, and maintainable.
PHP OOP – Classes and Objects:
In PHP OOP, a class is a blueprint or template for creating objects, while an object is an instance of a class. Here’s an example of how to define a class in PHP:
class Car {
// properties
public $make;
public $model;
public $year;
// methods
public function start() {
echo "The car has started.";
}
public function stop() {
echo "The car has stopped.";
}
}
In the example above, we have defined a Car class with three properties ($make, $model, and $year) and two methods (start() and stop()).
To create an object of the Car class, we use the new keyword:
$myCar = new Car();
Now $myCar is an object of the Car class. We can access its properties and methods using the arrow (->) operator:
$myCar->make = "Toyota";
$myCar->model = "Corolla";
$myCar->year = 2022;
$myCar->start(); // output: The car has started.
$myCar->stop(); // output: The car has stopped.
We can create multiple objects of the same class, each with its own state:
$yourCar = new Car();
$yourCar->make = "Honda";
$yourCar->model = "Civic";
$yourCar->year = 2023;
$herCar = new Car();
$herCar->make = "Ford";
$herCar->model = "Mustang";
$herCar->year = 2021;
In summary, classes define the properties and methods of objects, while objects are instances of classes that can be created and manipulated in code.
PHP – The $this Keyword:
In PHP, the $this keyword refers to the current object within a class method. It allows you to access the object’s properties and methods from within the class itself.
For example, let’s say we have a Person class with a name property and a sayHello() method:
class Person {
public $name;
public function sayHello() {
echo "Hello, my name is " . $this->name;
}
}
In the sayHello() method, we use $this->name to access the name property of the current object. We can create a Person object and set its name property, then call the sayHello() method:
$person = new Person();
$person->name = "John";
$person->sayHello(); // output: Hello, my name is John
Without using $this, we would not be able to access the name property within the sayHello() method.
Note that $this can only be used within a class method. If you try to use it outside of a class, you will get a syntax error.
PHP OOP – Constructor:
In PHP, a constructor is a special method that gets called automatically when an object of a class is created. The purpose of a constructor is to initialize the object’s properties with default values or values provided by the user.
In PHP, the constructor method is always named __construct(). Here’s an example of a Person class with a constructor:
class Person {
public $name;
public $age;
public function __construct($name, $age) {
$this->name = $name;
$this->age = $age;
}
public function sayHello() {
echo "Hello, my name is " . $this->name . " and I am " . $this->age . " years old.";
}
}
In the __construct() method, we take two parameters ($name and $age) and use them to initialize the name and age properties of the object using $this->name and $this->age.
Now, when we create a Person object, we need to pass in values for $name and $age:
$person = new Person("John", 30);
$person->sayHello(); // output: Hello, my name is John and I am 30 years old.
The constructor is called automatically when we create the Person object using new Person(“John”, 30). We don’t need to call the constructor explicitly.
Constructors can be used to set default values for properties or to perform any necessary initialization when an object is created. They are an important part of object-oriented programming and can help make your code more modular and maintainable.
PHP OOP – Destructor:
In PHP, a destructor is a special method that gets called automatically when an object of a class is destroyed or goes out of scope. The purpose of a destructor is to perform any necessary cleanup operations, such as releasing resources or closing open files.
In PHP, the destructor method is always named __destruct(). Here’s an example of a Person class with a destructor:
class Person {
public $name;
public function __construct($name) {
$this->name = $name;
}
public function sayHello() {
echo "Hello, my name is " . $this->name;
}
public function __destruct() {
echo "Object destroyed.";
}
}
In the __destruct() method, we simply echo out a message to indicate that the object has been destroyed.
Now, when we create a Person object and then destroy it, the destructor will be called automatically:
$person = new Person("John");
$person->sayHello(); // output: Hello, my name is John
unset($person); // output: Object destroyed.
The unset() function is used to destroy the $person object explicitly. When the object is destroyed, the __destruct() method is called automatically and echoes out “Object destroyed.”
Destructors can be used to release resources, such as database connections or file handles, when an object is no longer needed. They are an important part of object-oriented programming and can help make your code more robust and secure.
PHP OOP – Access Modifiers:
In PHP, access modifiers are used to control the visibility of properties and methods of a class. There are three access modifiers in PHP:
- public: A public property or method can be accessed from anywhere, both within and outside the class.
- private: A private property or method can only be accessed from within the class that defines it. It cannot be accessed from outside the class or from a subclass.
- protected: A protected property or method can be accessed from within the class that defines it and from subclasses. It cannot be accessed from outside the class.
Here’s an example of a Person class with public, private, and protected properties:
class Person {
public $name; // public property
private $age; // private property
protected $gender; // protected property
public function __construct($name, $age, $gender) {
$this->name = $name;
$this->age = $age;
$this->gender = $gender;
}
public function sayHello() { // public method
echo "Hello, my name is " . $this->name;
}
private function getAge() { // private method
return $this->age;
}
protected function getGender() { // protected method
return $this->gender;
}
}
In this example, the name property is public, which means it can be accessed from anywhere. The age property is private, which means it can only be accessed from within the Person class. The gender property is protected, which means it can be accessed from within the Person class and from any subclasses of Person.
The sayHello() method is public, which means it can be called from anywhere. The getAge() method is private, which means it can only be called from within the Person class. The getGender() method is protected, which means it can be called from within the Person class and from any subclasses of Person.
Using access modifiers helps to enforce encapsulation, which is the principle of keeping the implementation details of a class hidden from other code. This can help to make your code more secure and easier to maintain.
PHP OOP – Inheritance:
In PHP, inheritance is a mechanism that allows a class to inherit properties and methods from another class, known as the parent or base class. The class that inherits from the parent class is known as the child or derived class.
To define a class that inherits from another class in PHP, you use the extends keyword. Here’s an example:
class Animal {
public $name;
public function __construct($name) {
$this->name = $name;
}
public function eat() {
echo "The animal is eating.";
}
}
class Dog extends Animal {
public function bark() {
echo "The dog is barking.";
}
}
$dog = new Dog("Fido");
echo $dog->name; // output: Fido
$dog->eat(); // output: The animal is eating.
$dog->bark(); // output: The dog is barking.
In this example, the Dog class inherits from the Animal class using the extends keyword. This means that the Dog class has access to all the public and protected properties and methods of the Animal class.
The Dog class also defines a new public method called bark(), which is not present in the Animal class. When we create a new Dog object and call the bark() method, it outputs “The dog is barking.”
Inheritance allows you to reuse code from existing classes and create more specialized classes that inherit the properties and methods of a more general class. This can make your code more efficient and easier to maintain. However, it’s important to use inheritance judiciously and not create overly complex inheritance hierarchies, which can make code difficult to understand and maintain.
PHP – Inheritance and the Protected Access Modifier:
In PHP, the protected access modifier is often used in conjunction with inheritance. When a property or method is marked as protected, it can be accessed by the class that defines it and any subclasses that inherit from it.
Here’s an example:
class Animal {
protected $name;
public function __construct($name) {
$this->name = $name;
}
public function eat() {
echo "The animal is eating.";
}
}
class Dog extends Animal {
public function bark() {
echo "The dog is barking.";
}
public function getName() {
return $this->name;
}
}
$dog = new Dog("Fido");
echo $dog->getName(); // output: Fido
$dog->eat(); // output: The animal is eating.
$dog->name = "Rufus"; // error: Cannot access protected property Animal::$name
In this example, the Animal class has a protected property called $name. This means that it can be accessed by the Animal class itself and any subclasses that inherit from it. The Dog class is a subclass of Animal, so it can access the $name property using the $this keyword inside its own methods.
The Dog class also defines a new public method called getName(), which returns the value of the $name property. When we create a new Dog object and call the getName() method, it outputs “Fido”.
However, when we try to directly access the $name property from outside the class using the object instance, as in $dog->name = “Rufus”, we get an error message: “Cannot access protected property Animal::$name”. This is because the $name property is marked as protected, so it can only be accessed from within the Animal class and its subclasses.
Using the protected access modifier can help to ensure that the properties and methods of a class are only accessible in a controlled way. This can help to prevent unintended changes to the internal state of an object and make your code more secure and easier to maintain.
PHP – Overriding Inherited Methods:
In PHP, when a subclass inherits a method from its parent class, it can override the method by providing its own implementation of the method with the same name and signature.
Here’s an example:
class Animal {
public function move() {
echo "The animal is moving.";
}
}
class Dog extends Animal {
public function move() {
echo "The dog is running.";
}
}
$dog = new Dog();
$dog->move(); // output: The dog is running.
In this example, the Dog class inherits the move() method from its parent class, Animal. However, the Dog class overrides the method by providing its own
implementation of the method that outputs “The dog is running.” When we create a new Dog object and call the move() method, it outputs “The dog is running.”
When a method is overridden, the new implementation of the method completely replaces the old one. This means that any calls to the method from within the subclass will use the new implementation, even if the call is made from within the superclass or from outside the class.
It’s important to note that when overriding a method, the signature of the new method must match the signature of the original method. This means that the name and parameters of the new method must be the same as those of the original method. If the signature of the new method is different, it will be treated as a completely new method and will not override the original method.
Overriding methods allows you to customize the behavior of a class to suit your specific needs. This can be particularly useful when working with complex object hierarchies, where different subclasses may need to behave differently in certain situations.
PHP – The final Keyword:
In PHP, the final keyword can be used to prevent a method or class from being overridden by any subclasses. When a method or class is marked as final, it cannot be modified or extended in any way.
Here’s an example:
class Animal {
final public function move() {
echo "The animal is moving.";
}
}
class Dog extends Animal {
// This will generate an error because move() is final and cannot be overridden
public function move() {
echo "The dog is running.";
}
}
In this example, the move() method of the Animal class is marked as final. This means that it cannot be overridden by any subclasses, including the Dog class. When we try to define a new implementation of the move() method in the Dog class, we get an error message stating that the method cannot be overridden.
Similarly, the final keyword can also be used to prevent a class from being extended by any subclasses. When a class is marked as final, it cannot be inherited by any other class.
Here’s an example:
final class Animal {
public function move() {
echo "The animal is moving.";
}
}
// This will generate an error because Animal is final and cannot be extended
class Dog extends Animal {
public function bark() {
echo "The dog is barking.";
}
}
In this example, the Animal class is marked as final. This means that it cannot be extended by any other class, including the Dog class. When we try to define a new subclass of Animal called Dog, we get an error message stating that the class cannot be extended.
The final keyword can be useful when you want to ensure that certain methods or classes are not modified or extended in any way. This can help to prevent unintended changes to the behavior of your code and make it more secure and easier to maintain. However, it’s important to use the final keyword judiciously and only when necessary, as it can limit the flexibility of your code and make it harder to extend or modify in the future.
PHP OOP – Class Constants:
In PHP, class constants are values that are associated with a class and are shared by all instances of that class. Class constants are similar to class variables, but they are read-only and cannot be modified once they are defined.
Here’s an example:
class Animal {
const TYPE = "mammal";
}
echo Animal::TYPE; // output: mammal
In this example, the Animal class defines a class constant called TYPE, which has a value of “mammal”. We can access the value of the constant using the :: operator, like this: Animal::TYPE. When we run this code, it outputs “mammal”.
Class constants are defined using the const keyword, followed by the name of the constant and its value. Class constants are typically named using all uppercase letters to distinguish them from other class members.
Class constants can be useful for defining values that are associated with a class and do not change during the lifetime of the program. For example, you might use a class constant to define a default value or a limit for a particular property of the class.
Class constants can also be inherited by subclasses, and they can be accessed using the parent:: keyword, like this:
class Dog extends Animal {
const SOUND = "bark";
}
echo Dog::TYPE; // output: mammal
echo Dog::SOUND; // output: bark
In this example, the Dog class inherits the TYPE constant from its parent class, Animal. The Dog class also defines its own constant called SOUND, which has a value of “bark”. We can access both constants using the :: operator, like this: Dog::TYPE and Dog::SOUND. When we run this code, it outputs “mammal” and “bark”, respectively.
Using class constants can make your code more organized and easier to read, especially if you have a large number of values that are associated with a particular class. By defining these values as constants, you can ensure that they are not modified accidentally and that they are consistent across all instances of the class.
PHP OOP – Abstract Classes:
In PHP, an abstract class is a class that cannot be instantiated on its own, but can be used as a base class for other classes. An abstract class is designed to be extended by other classes, which can provide their own implementation of the abstract class’s methods.
Here’s an example:
abstract class Animal {
abstract public function makeSound();
}
class Dog extends Animal {
public function makeSound() {
echo "Woof!";
}
}
$dog = new Dog();
$dog->makeSound(); // output: Woof!
In this example, the Animal class is defined as an abstract class, with an abstract method called makeSound(). An abstract method is a method that is declared but does not provide an implementation. This means that any subclass that extends the Animal class must provide its own implementation of the makeSound() method.
The Dog class is defined as a subclass of the Animal class, and it provides its own implementation of the makeSound() method, which outputs “Woof!”.
When we create a new instance of the Dog class and call its makeSound() method, it outputs “Woof!”.
Abstract classes can be useful for defining a common interface or behavior that is shared by a group of related classes. By defining an abstract class, you can ensure that all subclasses of that class provide their own implementation of certain methods or behavior, which can help to make your code more organized and easier to maintain.
It’s important to note that abstract classes cannot be instantiated on their own, and any abstract methods in the class must be implemented by any subclasses that extend it. If a subclass fails to provide an implementation of an abstract method, it will generate an error at runtime.
PHP OOP – Interfaces:
In PHP, an interface is a set of methods that a class can implement to define a specific behavior. An interface defines a contract that the implementing class must follow, which means that any class that implements an interface must provide an implementation for all of its methods.
Here’s an example:
interface Animal {
public function makeSound();
}
class Dog implements Animal {
public function makeSound() {
echo "Woof!";
}
}
$dog = new Dog();
$dog->makeSound(); // output: Woof!
In this example, we define an interface called Animal that contains a single method called makeSound(). We then define a class called Dog that implements the Animal interface and provides its own implementation of the makeSound() method, which outputs “Woof!”.
When we create a new instance of the Dog class and call its makeSound() method, it outputs “Woof!”.
Interfaces can be useful for defining a specific set of behavior or functionality that a class must provide. By defining an interface, you can ensure that any class that implements that interface provides a consistent set of methods that can be used in a standardized way.
It’s important to note that an interface only defines a set of methods that a class must implement, but it does not provide any implementation itself. This means that any class that implements an interface must provide its own implementation of all of the methods defined in the interface.
Additionally, a class can implement multiple interfaces, which can be useful for defining more complex sets of behavior or functionality.
PHP – Interfaces vs. Abstract Classes:
Here are some examples that illustrate the differences between interfaces and abstract classes in PHP:
Example of an interface
interface Animal {
public function makeSound();
}
class Dog implements Animal {
public function makeSound() {
echo "Woof!";
}
}
class Cat implements Animal {
public function makeSound() {
echo "Meow!";
}
}
In this example, we define an interface called Animal that contains a single method called makeSound(). We then define two classes, Dog and Cat, that both implement the Animal interface and provide their own implementation of the makeSound() method. By implementing the Animal interface, we can ensure that both the Dog and Cat classes provide a consistent set of methods that can be used in a standardized way.
Example of an abstract class
abstract class Animal {
abstract public function makeSound();
public function eat() {
echo "The animal is eating.";
}
}
class Dog extends Animal {
public function makeSound() {
echo "Woof!";
}
}
class Cat extends Animal {
public function makeSound() {
echo "Meow!";
}
}
In this example, we define an abstract class called Animal that contains an abstract method called makeSound() and a non-abstract method called eat(). We then define two classes, Dog and Cat, that both extend the Animal abstract class and provide their own implementation of the makeSound() method. By extending the Animal abstract class, we can provide a common set of behavior that is shared among both the Dog and Cat classes, while still allowing each class to provide its own implementation of the makeSound() method.
Comparison of interfaces and abstract classes
Here are some key differences between interfaces and abstract classes based on the examples above:
- Implementation: An interface only defines the method signatures and does not provide any implementation, while an abstract class can provide implementation details for some or all of its methods.
- Inheritance: A class can only extend a single abstract class, but can implement multiple interfaces.
- Accessibility: Abstract classes can have public, protected, and private methods and properties, while all methods in an interface must be public.
- Purpose: Abstract classes are typically used when there is a common set of behavior that needs to be shared among multiple subclasses, while interfaces are typically used to define a specific set of functionality that a class must provide.
- Extensibility: Abstract classes can be extended by subclasses, but interfaces cannot be extended.
In general, if you need to provide a common set of behavior that is shared among multiple subclasses, an abstract class may be a better choice. If you need to define a specific set of methods that a class must implement, an interface may be a better choice.
PHP OOP – Traits:
A trait is a mechanism in PHP that allows you to reuse code in multiple classes without using inheritance. Traits provide a way to group functionality that can be reused across multiple classes, allowing you to avoid duplicating code in each class.
Here’s an example:
trait Greeting {
public function sayHello() {
echo "Hello!";
}
}
class Person {
use Greeting;
}
class Animal {
use Greeting;
}
In this example, we define a trait called Greeting that contains a single method called sayHello(). We then define two classes, Person and Animal, that both use the Greeting trait. By using the Greeting trait, we can reuse the sayHello() method in both the Person and Animal classes without having to duplicate the code in each class.
You can also define multiple traits that a class can use:
trait Greeting {
public function sayHello() {
echo "Hello!";
}
}
trait Farewell {
public function sayGoodbye() {
echo "Goodbye!";
}
}
class Person {
use Greeting, Farewell;
}
In this example, we define two traits, Greeting and Farewell, each containing a single method. We then define a class called Person that uses both the Greeting and Farewell traits. This allows the Person class to use both the sayHello() and sayGoodbye() methods without having to define them itself.
Traits can also have properties and constants:
trait Greeting {
public $message = "Hello!";
const GREETING = "Welcome!";
public function sayHello() {
echo $this->message;
}
}
In this example, we add a property called $message and a constant called GREETING to the Greeting trait. We then modify the sayHello() method to use the $message property. When a class uses the Greeting trait, it can access the $message property and the GREETING constant as well.
One important thing to keep in mind when using traits is to avoid conflicts between method names and properties when using multiple traits. For example, if two traits have a method with the same name, you will get a fatal error. You can resolve this issue by using the as keyword to give each method a unique name:
trait Greeting {
public function sayHello() {
echo "Hello!";
}
}
trait Farewell {
public function sayHello() {
echo "Goodbye!";
}
}
class Person {
use Greeting, Farewell {
Greeting::sayHello insteadof Farewell;
Farewell::sayHello as sayGoodbye;
}
}
In this example, we define two traits, Greeting and Farewell, each containing a method called sayHello(). We then define a class called Person that uses both the Greeting and Farewell traits. We resolve the conflict between the two sayHello() methods by using the insteadof keyword to choose the sayHello() method from the Greeting trait and using the as keyword to rename the sayHello() method from the Farewell trait to sayGoodbye().
PHP OOP – Static Methods:
Static methods are methods in PHP that belong to a class rather than an instance of that class. This means that you can call the method directly on the class itself, without needing to create an object first.
Here’s an example:
class MyClass {
public static function myStaticMethod() {
echo "This is a static method.";
}
}
// Call the static method on the class itself
MyClass::myStaticMethod();
In this example, we define a class called MyClass with a single static method called myStaticMethod(). We then call the static method directly on the MyClass class using the double-colon :: operator. This outputs the message “This is a static method.”.
One benefit of using static methods is that they can be called without needing to create an instance of the class. This can be useful for utility functions or other operations that don’t require access to the state of a specific object.
Static methods can also access static properties and constants defined in the class:
class MyClass {
public static $myStaticProperty = "Hello!";
const MY_CONSTANT = "World!";
public static function myStaticMethod() {
echo self::$myStaticProperty . " " . self::MY_CONSTANT;
}
}
// Call the static method and access the static property and constant
MyClass::myStaticMethod(); // Outputs "Hello! World!"
In this example, we define a static property called $myStaticProperty and a constant called MY_CONSTANT in the MyClass class. We then modify the myStaticMethod() method to access these static properties. When we call the myStaticMethod() method on the MyClass class, we can access both the static property and the constant.
One thing to keep in mind when using static methods is that they cannot access non-static properties or methods of the class. If you need to access non-static properties or methods, you’ll need to create an instance of the class first.
Static methods can be useful in many situations, such as for creating utility classes with static methods that perform common tasks, or for creating singleton classes that ensure that only one instance of the class is created.
PHP OOP – Static Properties:
In PHP, a static property is a property that belongs to the class itself, rather than an instance of the class. This means that you can access the property directly on the class, without needing to create an object instance.
To define a static property, you use the static keyword inside the class definition, like this:
class MyClass {
public static $myStaticProperty = "Hello, world!";
}
In this example, we define a class called MyClass with a single static property called $myStaticProperty. This property can be accessed directly on the class without creating an instance of the class
echo MyClass::$myStaticProperty; // Outputs "Hello, world!"
You can also modify the value of a static property directly on the class:
MyClass::$myStaticProperty = "Goodbye, world!";
echo MyClass::$myStaticProperty; // Outputs "Goodbye, world!"
One thing to keep in mind when using static properties is that they are shared among all instances of the class. This means that if you modify a static property on one instance of the class, the change will be reflected in all other instances of the class. For example:
class MyClass {
public static $myStaticProperty = "Hello, world!";
}
$obj1 = new MyClass();
$obj2 = new MyClass();
$obj1::$myStaticProperty = "Goodbye, world!";
echo $obj2::$myStaticProperty; // Outputs "Goodbye, world!"
In this example, we create two instances of the MyClass class ($obj1 and $obj2). We then modify the value of the static property $myStaticProperty on $obj1, and output the value of the same property on $obj2. Since the property is static, the change made to $myStaticProperty on $obj1 is reflected in $obj2.
Static properties can be useful for storing information that is shared among all instances of a class, or for creating counters or other shared state information. However, you should use them carefully, as changes made to a static property can have unexpected side effects in other parts of your program.
In this example, we create two instances of the MyClass class ($obj1 and $obj2). We then modify the value of the static property $myStaticProperty on $obj1, and output the value of the same property on $obj2. Since the property is static, the change made to $myStaticProperty on $obj1 is reflected in $obj2.
Static properties can be useful for storing information that is shared among all instances of a class, or for creating counters or other shared state information. However, you should use them carefully, as changes made to a static property can have unexpected side effects in other parts of your program.
namespace MyNamespace;
class MyClass {
// ...
}
function myFunction() {
// ...
}
In this example, we define a namespace called MyNamespace that contains a class called MyClass and a function called myFunction. To use these items outside of the namespace, you need to prefix them with the namespace name:
$obj = new MyNamespace\MyClass();
MyNamespace\myFunction();
You can also define sub-namespaces within a namespace:
namespace MyNamespace\SubNamespace;
class MySubClass {
// ...
}
In this example, we define a sub-namespace called SubNamespace within the MyNamespace namespace, and we define a class called MySubClass within that sub-namespace. To use this class, you need to prefix it with both the namespace and sub-namespace names:
$obj = new MyNamespace\SubNamespace\MySubClass();
PHP also has a special namespace called the global namespace, which is the namespace that your code resides in if you don’t explicitly define a namespace. You can access global namespace items using a backslash (\) prefix:
$obj = new \MyClass(); // creates an instance of the MyClass class in the global namespace
Namespaces can be useful for organizing large codebases, preventing naming conflicts, and making it easier to reuse code across different projects or libraries.
PHP Iterables:
In PHP, an iterable is any value that can be looped over using a foreach loop. This includes arrays, objects that implement the Traversable interface (such as ArrayObject or IteratorAggregate), and some other types of objects that can be treated as arrays.
The iterable type hint was introduced in PHP 7.1 as a way of indicating that a function or method expects an iterable argument. For example:
function printIterable(iterable $myIterable) {
foreach ($myIterable as $item) {
echo $item;
}
}
In this example, the printIterable function takes an iterable argument called $myIterable and loops over it using a foreach loop.
The iterable type hint can also be used as a return type, to indicate that a function or method returns an iterable value:
function getIterable(): iterable {
return [1, 2, 3];
}
In this example, the getIterable function returns an array, which is an iterable value.
Iterables can be useful for writing flexible and reusable code, because they allow you to accept a wide variety of input values without making assumptions about their specific type or structure. By using the iterable type hint, you can indicate that a function or method works with any iterable value, which makes your code more generic and easier to reuse.