PHP 5: const vs static

Di PHP 5, apa perbedaan antara menggunakan constdan static?

Kapan masing-masing sesuai? Dan peran apa public, protecteddan privatebermain - jika ada?

Dalam konteks suatu kelas, variabel statis berada pada ruang lingkup kelas (bukan objek), tetapi tidak seperti konst, nilai-nilai mereka dapat diubah.

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.

Publik, dilindungi, dan pribadi tidak relevan dalam hal konst (yang selalu publik); mereka hanya berguna untuk variabel kelas, termasuk variabel statis.

• variabel statis publik dapat diakses di mana saja melalui ClassName :: $ variabel.
• variabel statis terproteksi dapat diakses oleh kelas yang mendefinisikan atau memperluas kelas melalui ClassName :: $ variabel.
• variabel statis pribadi hanya dapat diakses oleh kelas yang mendefinisikan melalui ClassName :: $ variabel.

Sunting: Penting untuk dicatat bahwa PHP 7.1.0 memperkenalkan dukungan untuk menentukan visibilitas konstanta kelas .

Satu hal terakhir yang harus dibuat adalah bahwa konst selalu statis dan publik. Ini berarti bahwa Anda dapat mengakses const dari dalam kelas seperti:

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

Dari luar kelas Anda akan mengaksesnya seperti ini:

echo MyClass::MYCONST;

Constant adalah konstanta, yaitu Anda tidak dapat mengubah nilainya setelah mendeklarasikan.

Variabel statis dapat diakses tanpa membuat instance kelas dan oleh karena itu dibagi antara semua instance kelas.

Juga, mungkin ada variabel lokal statis dalam suatu fungsi yang dideklarasikan hanya sekali (pada eksekusi pertama fungsi) dan dapat menyimpan nilainya antara panggilan fungsi, contoh:

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

Ketika berbicara tentang pewarisan kelas, Anda dapat membedakan antara konstanta atau variabel dalam cakupan yang berbeda dengan menggunakan selfdan statickata-kata kunci. Lihat contoh ini yang menggambarkan cara mengakses apa:

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';
}

Dan kemudian lakukan:

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

atau:

Pirate::getType();

Keluaran:

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

Dengan kata lain self::mengacu pada properti statis dan konstan dari lingkup yang sama di mana ia disebut (dalam hal ini Personsuperclass), sementara static::akan mengakses properti dan konstan dari ruang lingkup dalam jangka waktu (jadi dalam kasus ini dalam Piratesubkelas).

Baca lebih lanjut tentang pengikatan statis akhir di sini di php.net .
Periksa juga jawaban atas pertanyaan lain di sini dan di sini .

Mendeklarasikan metode atau properti kelas sebagai statis membuat mereka dapat diakses tanpa perlu instantiasi kelas.

Konstanta kelas sama seperti konstanta normal, konstanta tidak dapat diubah saat runtime. Ini juga satu-satunya alasan Anda menggunakan const.

Pribadi, publik, dan terlindungi adalah pengubah akses yang menjelaskan siapa yang dapat mengakses parameter / metode mana.

Publik berarti semua objek lain mendapat akses. Pribadi berarti bahwa hanya kelas instantiated yang mendapatkan akses. Dilindungi berarti bahwa kelas instantiated dan kelas turunan mendapat akses.

Inilah hal-hal yang saya pelajari sejauh ini tentang anggota statis, variabel konstan dan pengubah akses (pribadi, publik, dan terlindungi). Konstan

Definisi

Seperti namanya, nilai variabel konstan tidak dapat diubah. Konstanta berbeda dari variabel normal karena Anda tidak menggunakan simbol $ untuk mendeklarasikan atau menggunakannya.

Nilai harus berupa ekspresi konstan, bukan (misalnya) variabel, properti, hasil operasi matematika, atau pemanggilan fungsi.

Catatan: Nilai variabel tidak boleh berupa kata kunci (mis. Mandiri, orang tua, dan statis).

Menyatakan konstanta dalam php

<?php
class constantExample{

   const CONSTANT = 'constant value'; //constant

 }
?>

Lingkup Constant bersifat global dan dapat diakses menggunakan kata kunci mandiri

<?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

?>

Statis

Definisi

Kata kunci statis dapat digunakan untuk mendeklarasikan kelas, fungsi anggota, atau variabel. Anggota statis dalam suatu kelas bersifat global dapat diakses menggunakan kata kunci mandiri juga. Mendeklarasikan properti atau metode kelas sebagai statis membuat mereka dapat diakses tanpa memerlukan instantiasi kelas. . Properti yang dideklarasikan sebagai statis tidak dapat diakses dengan objek kelas yang dipakai (meskipun metode statis bisa). Jika tidak ada pernyataan visibilitas (publik, pribadi, dilindungi) yang digunakan, maka properti atau metode akan diperlakukan seolah-olah dinyatakan sebagai publik. Karena metode statis dapat dipanggil tanpa turunan dari objek yang dibuat.

Catatan: variabel pseudo $ this tidak tersedia di dalam metode yang dinyatakan statis. Properti statis tidak dapat diakses melalui objek menggunakan operator panah ->

Pada PHP 5.3.0, dimungkinkan untuk mereferensikan kelas menggunakan variabel. Nilai> variabel tidak boleh berupa kata kunci (mis. Mandiri, orang tua, dan statis).

Contoh properti statis

<?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
    }
}

?>

Mengakses contoh properti dan fungsi statis

 <?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";

 ?>

Publik, pribadi, dilindungi (pengubah akses AKA)

Sebelum membaca definisi di bawah ini, bacalah Artikel tentang Enkapsulasi ini. Ini akan membantu Anda memahami konsep ini lebih dalam

Tautan 1 wikipedia

Tautan titik tutorial tentang enkapsulasi

Definisi

Menggunakan kata kunci pribadi, publik, dan terlindungi Anda dapat mengontrol akses ke anggota di kelas. Anggota kelas menyatakan publik dapat diakses di mana saja. Anggota yang dinyatakan dilindungi hanya dapat diakses di dalam kelas itu sendiri dan oleh kelas yang diwarisi dan orang tua. Anggota yang dideklarasikan sebagai pribadi hanya dapat diakses oleh kelas yang mendefinisikan anggota.

Contoh

 <?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
   }

} 
 ?> 

Mengakses contoh publik, pribadi dan anggota yang dilindungi

Variabel publik dapat diakses dan dimodifikasi dari luar kelas atau di dalam kelas. Tetapi Anda dapat mengakses variabel dan fungsi pribadi dan yang dilindungi hanya dari dalam kelas, Anda tidak dapat mengubah nilai anggota yang dilindungi atau Publik di luar kelas.

  <?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)

  ?>

Untuk info lebih lanjut baca dokumentasi php ini tentang visibilitas Visibilitas Php Doc

Referensi: php.net

Saya harap Anda mengerti konsepnya. Terima kasih telah membaca :) :) Selamat mencoba

Jadi, rekap pada @Matt jawaban yang bagus:

• jika properti yang Anda butuhkan tidak boleh diubah, maka konstanta adalah pilihan yang tepat

• jika properti yang Anda butuhkan diizinkan untuk diubah, gunakan yang statis

Contoh:

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

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

Sunting: Penting untuk dicatat bahwa PHP 7.1.0 memperkenalkan dukungan untuk menentukan visibilitas konstanta kelas .