PHP OOP හි ට්‍රයිට් ක්‍රමවල ගැටුම් විසඳීම

එක් පන්තියකට ට්‍රයිට් කිහිපයක් භාවිතා කළ හැකි බැවින්, ට්‍රයිට් දෙකකට සමාන නම් ඇති ක්‍රම ඇති විට ගැටලුවක් ඇති විය හැකිය.

මෙම අවස්ථාවේදී PHP දෝෂයක් ලබා දෙනු ඇත. සිදුවීම නිවැරදි කිරීම සඳහා, නම් ගැටලුව පැහැදිලිව විසඳිය යුතුය. එය කරන්නේ කෙසේදැයි ප්‍රායෝගිකව බලමු.

අප සතුව සමාන method ක්‍රමයක් ඇති ට්‍රයිට් දෙකක් ඇතැයි සිතමු:

php<?php
  trait Trait1
  {
    private function method()
    {
      return 1;
    }
  }
  
  trait Trait2
  {
    private function method()
    {
      return 2;
    }
  }
?>

අප සතුව Test පන්තියක් ද ඇතැයි සිතමු, එය අපගේ ට්‍රයිට් දෙකම භාවිතා කරයි. අපගේ පන්තියට ට්‍රයිට් දෙකම සරලව සම්බන්ධ කළහොත්, PHP දෝෂයක් ලබා දෙනු ඇත, මන්ද ට්‍රයිට්වලට ගැලපෙන ක්‍රම ඇත:

php<?php
  // මෙම කේතය දෝෂයක් ලබා දෙනු ඇත!
  class Test
  {
    use Trait1, Trait2; // ට්‍රයිට් සම්බන්ධ කරන්න
  }
?>

අපගේ ට්‍රයිට් වල නම් ගැටලුව විසඳා ගනිමු. මේ සඳහා විශේෂ ක්‍රියාකරුවෙක් insteadof පවතී. මෙම ක්‍රියාකරු භාවිතයෙන් අපි Trait2 ට්‍රයිටයේ එම ක්‍රමය වෙනුවට Trait1 ට්‍රයිටයේ method ක්‍රමය භාවිතා කරමු:

php<?php
  class Test
  {
    use Trait1, Trait2 {
      Trait1::method insteadof Trait2;
    }
  }
  
  new Test;
?>

ඔබට පෙනෙන පරිදි, වාක්‍ය රීතිය මෙසේය: මුලින්ම ට්‍රයිට් නම, ඊළඟට කොලන් දෙක, ඊළඟට ක්‍රමයේ නම, ඊළඟට අපගේ ක්‍රියාකරු insteadof සහ දෙවන ට්‍රයිට් නම.

අපි පරීක්ෂා කර බලමු:

php<?php
  class Test
  {
    use Trait1, Trait2 {
      Trait1::method insteadof Trait2;
    }
    
    public function __construct()
    {
      echo $this->method(); // 1 පෙන්වනු ඇත, මන්ද මෙය පළමු ට්‍රයිට් ක්‍රමයයි
    }
  }
  
  new Test;
?>

එබැවින්, අපගේ පන්තියේ අපි පවසා ඇත්තේ method ක්‍රමය භාවිතා කරන්නේ නම්, එය පළමු ට්‍රයිට් වලින් ගත යුතු බවයි. අනෙක් ආකාරයෙන් - දෙවන ට්‍රයිට් ක්‍රමය ගත හැකිය:

php<?php
  class Test
  {
    use Trait1, Trait2 {
      Trait2::method insteadof Trait1;
    }
    
    public function __construct()
    {
      echo $this->method(); // 2 පෙන්වනු ඇත, මන්ද මෙය දෙවන ට්‍රයිට් ක්‍රමයයි
    }
  }
  
  new Test;
?>

කෙසේ වෙතත්, අපි එක් ට්‍රයිට් ක්‍රමයක් භාවිතා කරන බව දක්වන්නේ නම්, දෙවන ට්‍රයිට් ක්‍රමය ලබා ගත නොහැකිය. දෙවන ට්‍රයිට් ක්‍රමය භාවිතා කළ හැකිය, එය නැවත නම් කිරීමෙන් as යන යෙදුම භාවිතා කරමින්, මේ ආකාරයට:

php<?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<?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<?php
  // මෙම පන්තිය දෝෂයක් ලබා දෙනු ඇත:
  class Test
  {
    use Trait1, Trait2 {
      Trait1::method as method1;
      Trait2::method as method2;
    }
    
    public function __construct()
    {
      echo $this->method1() + $this->method2();
    }
  }
  
  new Test;
?>