In computer science, polymorphism describes the idea you can entry objects of various sorts by the identical interface. In less complicated phrases, it may be outlined as having a distant management with a single button that does various things relying on what you’re pointing it at.

In this article, we are going to examine a code with out the idea of polymorphism after which talk about how making use of the idea of polymorphism could make the code higher. Nicely first take a look at the next code with out polymorphism and attempt to perceive what are the issues with this code:

<?php
class Product {
protected $identify;
protected $worth;
public operate __construct($identify, $worth) 
$this->identify = $identify;
$this->worth = $worth;

public operate displayDetails($kind, $additional) {
if ($kind == "clothing") {
echo "Clothing: {$this->name}, Size: {$extra}, Price: {$this->price}\n";
} elseif ($kind == "electronics") {
echo "Electronics: {$this->name}, Brand: {$extra}, Price: {$this->price}\n";
}
}
}
// Create new product objects
$product_cloth = new Product("T-Shirt", 19.99);
$product_electronics = new Product("iPhone15", 199.99);
// Show particulars for clothes with measurement XL
$product->displayDetails("clothing", "XL");
// Show particulars for electronics with model iPhone
$product->displayDetails("electronics", "iPhone");
?>

Now, there are a number of issues with this code. To begin with, if we wish to add one other product kind, let’s say guide we might want to add yet another if situation within the product class. Nonetheless, a category ought to be capable to be prolonged flexibly with out modifying the category itself.

One other drawback with this code is, for instance, identify and worth are widespread params for each electronics kind of merchandise and clothes kind of merchandise. However for instance, there may be some unusual attribute for various kinds of merchandise, which on this case was applied by including one other param named additional . But when there are 10 such attributes, you possibly can simply guess how messy the code shall be.

So, to do away with such issues, we will rewrite the code utilizing the idea of polymorphism like this:

<?php
class Product {
protected $identify;
protected $worth;

public operate __construct($identify, $worth) 
$this->identify = $identify;
$this->worth = $worth;

public operate displayDetails() {
echo "Product: {$this->name}, Price: {$this->price}\n";
}
}
class Guide extends Product {
non-public $creator;

public operate __construct($identify, $worth, $creator) 
guardian::__construct($identify, $worth);
$this->creator = $creator;

public operate displayDetails() {
echo "Book: {$this->name}, Author: {$this->author}, Price: {$this->price}\n";
}
}

class Electronics extends Product {
non-public $model;
public operate __construct($identify, $worth, $model) 
guardian::__construct($identify, $worth);
$this->model = $model;

public operate displayDetails() {
echo "Electronics: {$this->name}, Brand: {$this->brand}, Price: {$this->price}\n";
}
}

class Clothes extends Product {
non-public $measurement;

public operate __construct($identify, $worth, $measurement)

public operate displayDetails() {
echo "Clothing: {$this->name}, Size: {$this->size}, Price: {$this->price}\n";
}
}

// Operate to show product particulars
operate displayProductDetails(Product $product) {
$product->displayDetails();
}

// Creating objects
$guide = new Guide("The Great Gatsby", 15.99, "F. Scott Fitzgerald");
$electronics = new Electronics("Smartphone", 499.99, "Samsung");
$clothes = new Clothes("T-Shirt", 19.99, "M");

// Displaying particulars utilizing polymorphism
displayProductDetails($guide);
displayProductDetails($electronics);
displayProductDetails($clothes);
?>

The benefit of this code is, to start with, you possibly can maintain including extra varieties of merchandise simply by extending the Product class.

Then, for various kinds of merchandise, you possibly can add any attributes with out affecting the guardian class. Simply overriding the displayDetails() operate and implementing it as wanted will do it.

Additionally if you happen to take a look at the `displayProductDetails` operate, you possibly can see that we will deal with all of the various kinds of merchandise the identical approach. we will name the identical operate nevertheless it provides various kinds of outcomes for various kinds of merchandise.

Static polymorphism, often known as compile-time polymorphism, happens when the strategy to be invoked is decided at compile time. In PHP, technique overloading is a type of static polymorphism. Methodology overloading permits a category to have a number of strategies with the identical identify however with completely different parameters or argument lists.

Right here’s an instance of technique overloading in PHP:

<?php
class MathOperations {
// Methodology so as to add two numbers
public operate add($num1, $num2) {
return $num1 + $num2;
}
// Methodology overloading so as to add three numbers
public operate add($num1, $num2, $num3) {
return $num1 + $num2 + $num3;
}
}
$math = new MathOperations();
echo $math->add(2, 3) . "\n";         // Output: 5
echo $math->add(2, 3, 4) . "\n";      // Output: 9
?>

Within the above instance, the MathOperations class has two add() strategies. The primary one takes two parameters, and the second takes three parameters. The PHP interpreter decides which technique to name primarily based on the variety of arguments supplied throughout the operate name. That is decided at compile time.

Dynamic polymorphism, often known as runtime polymorphism, happens when the strategy to be invoked is decided at runtime. In PHP, technique overriding in subclass is a type of dynamic polymorphism. Methodology overriding permits a subclass to offer a particular implementation of a technique that’s already outlined in its superclass. The primary polymorphism instance which was given on this article is an instance of dynamic polymorphism.

So, that’s it. From this dialogue we noticed how the idea of polymorphism elevated the code’s high quality by giving higher abstraction, lowering code duplication and enhancing flexibility and extensibility of the the category. This makes it simpler so as to add new varieties of objects or modify current ones with out having to alter plenty of code. Completely happy coding!

They’re tremendous helpful for organizing data and performing operations on it. 📦

Now, you is perhaps questioning, “Why do I need to convert PHP arrays to JavaScript arrays?” Effectively, think about this: You’ve bought a bunch of knowledge saved in PHP arrays on the server, however you need to show it dynamically on an online web page utilizing JavaScript.

That’s the place the conversion turns out to be useful! By changing PHP arrays to JavaScript arrays, you’ll be able to seamlessly switch information between your server-side and client-side code. 🔄

Now, let’s get into the nitty-gritty of truly changing these PHP arrays into JavaScript arrays. Fortunately, there are a couple of completely different strategies we are able to use to perform this activity. Let’s discover a few of them collectively! 🕵️‍♂️

Utilizing JSON Encoding and Decoding

One of many easiest methods to transform PHP arrays to JavaScript arrays is by utilizing JSON encoding and decoding. JSON (JavaScript Object Notation) is a light-weight information interchange format that’s extensively supported in each PHP and JavaScript. Right here’s how you are able to do it:

// Outline a PHP array
$phpArray = array('apple', 'banana', 'cherry');
// Encode the PHP array right into a JSON string
$jsonString = json_encode($phpArray);
// Output the JSON string
echo $jsonString;

And on the JavaScript aspect, you’ll be able to decode the JSON string again right into a JavaScript array like this:

// Outline a JavaScript variable to carry the JSON string
var jsonString = '<?php echo $jsonString; ?>';
// Parse the JSON string right into a JavaScript array
var jsArray = JSON.parse(jsonString);
// Output the JavaScript array
console.log(jsArray);

Voila! Your PHP array has now been transformed right into a JavaScript array utilizing JSON encoding and decoding.