PHP 5: const เทียบกับคงที่

ใน PHP 5 อะไรคือความแตกต่างระหว่างการใช้constและstatic?

แต่ละคนมีความเหมาะสมเมื่อใด และสิ่งที่มีบทบาทไม่public, protectedและprivateเล่น - ถ้ามี?

ในบริบทของคลาสตัวแปรแบบสแตติกอยู่ในขอบเขตคลาส (ไม่ใช่วัตถุ) แต่แตกต่างจาก const ค่าที่สามารถเปลี่ยนแปลงได้

class ClassName {
    static $my_var = 10;  /* defaults to public unless otherwise specified */
    const MY_CONST = 5;
}
echo ClassName::$my_var;   // returns 10
echo ClassName::MY_CONST;  // returns 5
ClassName::$my_var = 20;   // now equals 20
ClassName::MY_CONST = 20;  // error! won't work.

สาธารณะได้รับการคุ้มครองและเป็นส่วนตัวไม่เกี่ยวข้องในแง่ของ consts (ซึ่งเป็นสาธารณะเสมอ); มีประโยชน์สำหรับตัวแปรคลาสรวมถึงตัวแปรแบบคงที่เท่านั้น

• ตัวแปรสาธารณะคงที่สามารถเข้าถึงได้ทุกที่ผ่าน ClassName :: $ ตัวแปร
• การป้องกันตัวแปรคงที่สามารถเข้าถึงได้โดยการกำหนดระดับหรือการขยายชั้นเรียนผ่าน ClassName :: $ ตัวแปร
• ตัวแปรสแตติกส่วนตัวสามารถเข้าถึงได้โดยคลาสที่กำหนดผ่าน ClassName :: $ variable

แก้ไข: มันเป็นสิ่งสำคัญที่จะต้องทราบว่าPHP 7.1.0 แนะนำการสนับสนุนสำหรับการระบุการแสดงผลของค่าคงที่ในชั้นเรียน

จุดสุดท้ายที่ควรทำก็คือ const จะเป็นแบบสแตติกและเป็นแบบสาธารณะเสมอ ซึ่งหมายความว่าคุณสามารถเข้าถึง const จากภายในชั้นเรียนดังนี้

class MyClass
{
     const MYCONST = true;
     public function test()
     {
          echo self::MYCONST;
     }
}

จากนอกชั้นเรียนคุณจะสามารถเข้าถึงได้เช่นนี้:

echo MyClass::MYCONST;

คงเป็นเพียงคงที่คือคุณไม่สามารถเปลี่ยนค่าของตนหลังจากที่ประกาศ

ตัวแปรสแตติกสามารถเข้าถึงได้โดยไม่ต้องสร้างอินสแตนซ์ของคลาสและใช้ร่วมกันระหว่างอินสแตนซ์ทั้งหมดของคลาส

นอกจากนี้ยังสามารถมีตัวแปรโลคัลสแตติกในฟังก์ชันที่ประกาศเพียงครั้งเดียว (ในการประมวลผลครั้งแรกของฟังก์ชัน) และสามารถเก็บค่าไว้ระหว่างการเรียกใช้ฟังก์ชันตัวอย่าง:

function foo()
{
   static $numOfCalls = 0;
   $numOfCalls++;
   print("this function has been executed " . $numOfCalls . " times");
}

เมื่อพูดถึงการสืบทอดคลาสคุณสามารถแยกความแตกต่างระหว่างค่าคงที่หรือตัวแปรในขอบเขตที่แตกต่างกันโดยใช้selfและstaticคำสำคัญ ตรวจสอบตัวอย่างนี้ซึ่งแสดงวิธีเข้าถึงสิ่งต่าง ๆ :

class Person
{
    static $type = 'person';

    const TYPE = 'person';

    static public function getType(){
        var_dump(self::TYPE);
        var_dump(static::TYPE);

        var_dump(self::$type);
        var_dump(static::$type);
    }
}

class Pirate extends Person
{
    static $type = 'pirate';

    const TYPE = 'pirate';
}

แล้วทำ:

$pirate = new Pirate();
$pirate::getType();

หรือ:

Pirate::getType();

เอาท์พุท:

string(6) "person" 
string(6) "pirate" 
string(6) "person" 
string(6) "pirate"

กล่าวอีกนัยหนึ่งself::หมายถึงคุณสมบัติสแตติกและค่าคงที่จากขอบเขตเดียวกันกับที่มันถูกเรียก (ในกรณีนี้คือPersonซูเปอร์คลาส) ในขณะที่static::จะเข้าถึงคุณสมบัติและค่าคงที่จากขอบเขตในเวลาทำงาน (ดังนั้นในกรณีนี้ในPirateคลาสย่อย)

อ่านข้อมูลเพิ่มเติมเกี่ยวกับการคงปลายผูกพันที่นี่ใน php.net
นอกจากนี้ตรวจสอบคำตอบกับคำถามอีกที่นี่และที่นี่

การประกาศเมธอดหรือคุณสมบัติคลาสเป็นแบบสแตติกทำให้สามารถเข้าถึงได้โดยไม่ต้องใช้อินสแตนซ์ของคลาส

ค่าคงที่คลาสนั้นเหมือนกับค่าคงที่ปกติไม่สามารถเปลี่ยนแปลงได้ในขณะใช้งานจริง นี่เป็นเหตุผลเดียวที่คุณจะใช้ const สำหรับ

ส่วนตัวเป็นสาธารณะและได้รับการป้องกันคือตัวดัดแปลงการเข้าถึงที่อธิบายว่าใครสามารถเข้าถึงพารามิเตอร์ / วิธีการใด

สาธารณะหมายความว่าวัตถุอื่น ๆ ทั้งหมดเข้าถึงได้ ส่วนตัวหมายถึงเฉพาะคลาสที่สร้างอินสแตนซ์เท่านั้นที่เข้าถึงได้ การป้องกันหมายถึงคลาสที่สร้างอินสแตนซ์และคลาสที่ได้รับเข้าถึง

นี่คือสิ่งที่ฉันเรียนรู้เกี่ยวกับสมาชิกแบบคงที่ตัวแปรคงที่และตัวดัดแปลงการเข้าถึง (ส่วนตัวสาธารณะและได้รับการป้องกัน) คงที่

คำนิยาม

เช่นเดียวกับชื่อที่บอกว่าค่าของตัวแปรคงที่ไม่สามารถเปลี่ยนแปลงได้ค่าคงที่แตกต่างจากตัวแปรปกติที่คุณไม่ได้ใช้สัญลักษณ์ $ เพื่อประกาศหรือใช้พวกมัน

ค่าจะต้องเป็นนิพจน์ค่าคงที่ไม่ใช่ (ตัวอย่าง) ตัวแปรคุณสมบัติผลลัพธ์ของการดำเนินการทางคณิตศาสตร์หรือการเรียกใช้ฟังก์ชัน

หมายเหตุ: ค่าของตัวแปรไม่สามารถเป็นคำหลัก (เช่นตัวเองผู้ปกครองและคงที่)

ประกาศค่าคงที่ใน PHP

<?php
class constantExample{

   const CONSTANT = 'constant value'; //constant

 }
?>

ขอบเขตของค่าคงที่เป็นระดับโลกและสามารถเข้าถึงได้โดยใช้คำหลักด้วยตนเอง

<?php
class MyClass
{
    const CONSTANT = 'constant value';

    function showConstant() {
        echo  self::CONSTANT . "\n";
    }
}

echo MyClass::CONSTANT . "\n";

$classname = "MyClass";
echo $classname::CONSTANT . "\n"; // As of PHP 5.3.0

$class = new MyClass();
$class->showConstant();

echo $class::CONSTANT."\n"; // As of PHP 5.3.0

?>

คงที่

คำนิยาม

คำหลักคงที่สามารถใช้สำหรับการประกาศคลาสฟังก์ชั่นสมาชิกหรือตัวแปรสมาชิกแบบคงที่ในระดับโลกสามารถเข้าถึงได้โดยใช้คำหลักด้วยตนเองเช่นกันการประกาศคุณสมบัติหรือวิธีการเรียนแบบคงที่ทำให้พวกเขาสามารถเข้าถึงได้โดยไม่ต้องใช้อินสแตนซ์ . คุณสมบัติที่ประกาศเป็นแบบคงที่ไม่สามารถเข้าถึงได้ด้วยวัตถุคลาส instantiated (แม้ว่าวิธีการแบบคงที่สามารถ) หากไม่มีการประกาศการเปิดเผย (สาธารณะ, ส่วนตัว, การป้องกัน) แล้วคุณสมบัติหรือวิธีการจะถูกปฏิบัติเสมือนว่าประกาศเป็นสาธารณะเพราะวิธีการคงที่จะสามารถเรียกได้โดยไม่ต้องสร้างอินสแตนซ์ของวัตถุ

หมายเหตุ: ตัวแปรหลอกนี้ไม่สามารถใช้ได้ภายในวิธีการประกาศเป็นแบบคงที่คุณสมบัติแบบคงที่ไม่สามารถเข้าถึงผ่านวัตถุโดยใช้ตัวดำเนินการลูกศร ->

ตั้งแต่ PHP 5.3.0 เป็นไปได้ที่จะอ้างอิงคลาสโดยใช้ตัวแปร ค่าของตัวแปร> ไม่สามารถเป็นคำหลัก (เช่นตัวเอง, ผู้ปกครองและคงที่)

ตัวอย่างคุณสมบัติแบบคงที่

<?php
class Foo
{
    public static $my_static = 'foo'; //static variable 

    public static function staticValue() { //static function example
        return self::$my_static;  //return the static variable declared globally
    }
}

?>

ตัวอย่างการเข้าถึงคุณสมบัติและฟังก์ชั่นคงที่

 <?php
     print Foo::$my_static . "\n";

    $foo = new Foo();
    print $foo->staticValue() . "\n";
    print $foo->my_static . "\n";      // Undefined "Property" my_static 

    print $foo::$my_static . "\n";
    $classname = 'Foo';
    print $classname::$my_static . "\n"; // As of PHP 5.3.0

    print Bar::$my_static . "\n";
    $bar = new Bar();
    print $bar->fooStatic() . "\n";

 ?>

สาธารณะเป็นส่วนตัวได้รับการป้องกัน (ตัวดัดแปลงการเข้าถึง AKA)

ก่อนที่จะอ่านคำจำกัดความด้านล่างให้อ่านบทความนี้เกี่ยวกับ Encapsulation ซึ่งจะช่วยให้คุณเข้าใจแนวคิดที่ลึกซึ้งยิ่งขึ้น

ลิงก์ 1 วิกิพีเดีย

บทเรียนชี้ลิงค์เกี่ยวกับการห่อหุ้ม

คำนิยาม

การใช้คำหลักส่วนตัวสาธารณะป้องกันคุณสามารถควบคุมการเข้าถึงสมาชิกในชั้นเรียน สมาชิกชั้นประกาศสาธารณะสามารถเข้าถึงได้ทุกที่ สมาชิกที่ประกาศว่าได้รับการป้องกันสามารถเข้าถึงได้เฉพาะในชั้นเรียนของตัวเองและโดยการสืบทอดและชั้นผู้ปกครอง สมาชิกที่ประกาศเป็นส่วนตัวสามารถเข้าถึงได้โดยคลาสที่กำหนดสมาชิกเท่านั้น

ตัวอย่าง

 <?php 
class Example{
 public $variable = 'value'; // variable declared as public 
 protected $variable = 'value' //variable declared as protected
 private $variable = 'value'  //variable declared as private

 public function functionName() {  //public function
 //statements
 }

 protected function functionName() {  //protected function
 //statements
 }
  private function functionName() {  //private function
   //statements
   }

} 
 ?> 

การเข้าถึงตัวอย่างสาธารณะสมาชิกส่วนตัวและการป้องกัน

ตัวแปรสาธารณะสามารถเข้าถึงและแก้ไขได้จากนอกชั้นเรียนหรือภายในชั้นเรียน แต่คุณสามารถเข้าถึงตัวแปรและฟังก์ชั่นส่วนตัวและการป้องกันจากภายในชั้นเรียนเท่านั้นคุณไม่สามารถแก้ไขค่าของการป้องกันหรือสมาชิกสาธารณะนอกชั้นเรียน

  <?php 
  class Example{
    public $pbVariable = 'value'; 
    protected $protVariable = 'value'; 
    private $privVariable = 'value';
    public function publicFun(){

     echo $this->$pbVariable;  //public variable 
     echo $this->$protVariable;  //protected variable
     echo $this->privVariable; //private variable
    }

   private function PrivateFun(){

 //some statements
  }
  protected function ProtectedFun(){

 //some statements
  }

  }


 $inst = new Example();
 $inst->pbVariable = 'AnotherVariable'; //public variable modifed from outside
 echo $inst->pbVariable;   //print the value of the public variable

 $inst->protVariable = 'var'; //you can't do this with protected variable
 echo $inst->privVariable; // This statement won't work , because variable is limited to private

 $inst->publicFun(); // this will print the values inside the function, Because the function is declared as a public function

 $inst->PrivateFun();   //this one won't work (private)
 $inst->ProtectedFun();  //this one won't work as well (protected)

  ?>

สำหรับข้อมูลเพิ่มเติมโปรดอ่านเอกสาร php นี้เกี่ยวกับการมองเห็น Php Doc

ข้อมูลอ้างอิง: php.net

ฉันหวังว่าคุณจะเข้าใจแนวคิด ขอบคุณที่อ่าน :) :) ขอให้มีความสุข

เพื่อสรุปเกี่ยวกับ @Matt คำตอบที่ดี:

• หากคุณสมบัติที่คุณต้องการไม่ควรเปลี่ยนแปลงค่าคงที่คือตัวเลือกที่เหมาะสม

• หากคุณสมบัติที่คุณต้องการได้รับอนุญาตให้เปลี่ยนให้ใช้แบบคงที่แทน

ตัวอย่าง:

class User{
    private static $PASSWORD_SALT = "ASD!@~#asd1";
    ...
}

class Product{
    const INTEREST = 0.10;
    ...
}

แก้ไข: มันเป็นสิ่งสำคัญที่จะต้องทราบว่าPHP 7.1.0 แนะนำการสนับสนุนสำหรับการระบุการแสดงผลของค่าคงที่ในชั้นเรียน