PHP OOP හි ට්රයිට් ක්රමවල ගැටුම් විසඳීම
එක් පන්තියකට ට්රයිට් කිහිපයක් භාවිතා කළ හැකි බැවින්, ට්රයිට් දෙකකට සමාන නම් ඇති ක්රම ඇති විට ගැටලුවක් ඇති විය හැකිය.
මෙම අවස්ථාවේදී PHP දෝෂයක් ලබා දෙනු ඇත. සිදුවීම නිවැරදි කිරීම සඳහා, නම් ගැටලුව පැහැදිලිව විසඳිය යුතුය. එය කරන්නේ කෙසේදැයි ප්රායෝගිකව බලමු.
අප සතුව සමාන method ක්රමයක් ඇති ට්රයිට් දෙකක් ඇතැයි සිතමු:
<?php
trait Trait1
{
private function method()
{
return 1;
}
}
trait Trait2
{
private function method()
{
return 2;
}
}
?>
අප සතුව Test පන්තියක් ද ඇතැයි සිතමු,
එය අපගේ ට්රයිට් දෙකම භාවිතා කරයි. අපගේ පන්තියට ට්රයිට් දෙකම සරලව සම්බන්ධ කළහොත්,
PHP දෝෂයක් ලබා දෙනු ඇත, මන්ද ට්රයිට්වලට
ගැලපෙන ක්රම ඇත:
<?php
// මෙම කේතය දෝෂයක් ලබා දෙනු ඇත!
class Test
{
use Trait1, Trait2; // ට්රයිට් සම්බන්ධ කරන්න
}
?>
අපගේ ට්රයිට් වල නම් ගැටලුව විසඳා ගනිමු.
මේ සඳහා විශේෂ ක්රියාකරුවෙක් insteadof පවතී.
මෙම ක්රියාකරු භාවිතයෙන්
අපි Trait2 ට්රයිටයේ එම ක්රමය වෙනුවට
Trait1 ට්රයිටයේ method ක්රමය භාවිතා කරමු:
<?php
class Test
{
use Trait1, Trait2 {
Trait1::method insteadof Trait2;
}
}
new Test;
?>
ඔබට පෙනෙන පරිදි, වාක්ය රීතිය මෙසේය: මුලින්ම
ට්රයිට් නම, ඊළඟට කොලන් දෙක, ඊළඟට ක්රමයේ නම, ඊළඟට අපගේ ක්රියාකරු insteadof
සහ දෙවන ට්රයිට් නම.
අපි පරීක්ෂා කර බලමු:
<?php
class Test
{
use Trait1, Trait2 {
Trait1::method insteadof Trait2;
}
public function __construct()
{
echo $this->method(); // 1 පෙන්වනු ඇත, මන්ද මෙය පළමු ට්රයිට් ක්රමයයි
}
}
new Test;
?>
එබැවින්, අපගේ පන්තියේ අපි පවසා ඇත්තේ
method ක්රමය භාවිතා කරන්නේ නම්, එය
පළමු ට්රයිට් වලින් ගත යුතු බවයි. අනෙක් ආකාරයෙන්
- දෙවන ට්රයිට් ක්රමය ගත හැකිය:
<?php
class Test
{
use Trait1, Trait2 {
Trait2::method insteadof Trait1;
}
public function __construct()
{
echo $this->method(); // 2 පෙන්වනු ඇත, මන්ද මෙය දෙවන ට්රයිට් ක්රමයයි
}
}
new Test;
?>
කෙසේ වෙතත්, අපි එක් ට්රයිට් ක්රමයක් භාවිතා කරන බව දක්වන්නේ නම්, දෙවන ට්රයිට් ක්රමය
ලබා ගත නොහැකිය. දෙවන ට්රයිට් ක්රමය
භාවිතා කළ හැකිය, එය නැවත නම් කිරීමෙන්
as යන යෙදුම භාවිතා කරමින්, මේ ආකාරයට:
<?php
class Test
{
use Trait1, Trait2 {
Trait1::method insteadof Trait2;
Trait2::method as method2;
}
public function __construct()
{
echo $this->method() + $this->method2(); // 3 පෙන්වනු ඇත
}
}
new Test;
?>
අවශ්ය නම් පළමු ට්රයිට් ක්රමයද නැවත නම් කළ හැකිය:
<?php
class Test
{
use Trait1, Trait2 {
Trait1::method insteadof Trait2;
Trait1::method as method1;
Trait2::method as method2;
}
public function __construct()
{
echo $this->method1() + $this->method2(); // 3 පෙන්වනු ඇත
}
}
new Test;
?>
as යන යෙදුම භාවිතා කිරීම
insteadof හරහා ප්රධාන ක්රමය නිර්වචනය නොකර
අවසර නැත, මෙය දෝෂයක් ලබා දෙනු ඇත:
<?php
// මෙම පන්තිය දෝෂයක් ලබා දෙනු ඇත:
class Test
{
use Trait1, Trait2 {
Trait1::method as method1;
Trait2::method as method2;
}
public function __construct()
{
echo $this->method1() + $this->method2();
}
}
new Test;
?>
Trait1,
Trait2 සහ Trait3 යන නම් වලින් ට්රයිට් 3 ක් සාදන්න.
පළමු
ට්රයිටයේ method ක්රමයක් තිබිය යුතු අතර, එය
1 ලබා දේ,
දෙවන ට්රයිටයේ - සමාන නමින් යුත්
ක්රමයක්, 2 ලබා දෙන,
තුන්වන
ට්රයිටයේ - සමාන නමින් යුත් ක්රමයක්,
3 ලබා දෙන.
අප විසින් සාදන ලද ට්රයිට් තුනම භාවිතා කරන
Test පන්තියක් සාදන්න. මෙම
පන්තිය තුළ getSum ක්රමයක් සාදන්න, එය
සම්බන්ධ කරන ලද ට්රයිට් ක්රමවල ප්රතිඵලවල එකතුව ලබා දේ.
