No PHP 5, qual é a diferença entre usar conste static?
Quando cada um é apropriado? E qual o papel que public, protectede privatejogar - se for o caso?
No PHP 5, qual é a diferença entre usar conste static?
Quando cada um é apropriado? E qual o papel que public, protectede privatejogar - se for o caso?
Respostas:
No contexto de uma classe, variáveis estáticas estão no escopo da classe (não no objeto), mas, diferentemente de uma const, seus valores podem ser alterados.
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.Público, protegido e privado são irrelevantes em termos de consts (que são sempre públicos); eles são úteis apenas para variáveis de classe, incluindo variável estática.
Edit: É importante notar que o PHP 7.1.0 introduziu suporte para especificar a visibilidade das constantes da classe .
$? static $my_var = 10;na definição
staticvariáveis são muito úteis em singletons e funções recursivas também. Porque você PODE alterar o valor, mas a variável será inicializada apenas uma vez. Consulte stackoverflow.com/questions/203336/… para obter mais explicações sobre como criar um singleton. Para mim, essas são algumas situações em que prefiro variáveis estáticas.
Um último ponto que deve ser destacado é que uma const é sempre estática e pública. Isso significa que você pode acessar o const de dentro da classe da seguinte maneira:
class MyClass
{
const MYCONST = true;
public function test()
{
echo self::MYCONST;
}
}De fora da classe, você o acessaria assim:
echo MyClass::MYCONST;Constante é apenas uma constante, ou seja, você não pode alterar seu valor após a declaração.
A variável estática é acessível sem criar uma instância de uma classe e, portanto, compartilhada entre todas as instâncias de uma classe.
Além disso, pode haver uma variável local estática em uma função que é declarada apenas uma vez (na primeira execução de uma função) e pode armazenar seu valor entre chamadas de função, por exemplo:
function foo()
{
static $numOfCalls = 0;
$numOfCalls++;
print("this function has been executed " . $numOfCalls . " times");
}Ao falar sobre herança de classe, é possível diferenciar entre a constante ou a variável em diferentes escopos usando selfe staticpalavras-chave. Verifique este exemplo que ilustra como acessar o que:
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';
}E então faça:
$pirate = new Pirate();
$pirate::getType();ou:
Pirate::getType();Resultado:
string(6) "person"
string(6) "pirate"
string(6) "person"
string(6) "pirate"Em outras palavras, self::refere-se à propriedade estática e constante do mesmo escopo em que está sendo chamada (neste caso, a Personsuperclasse), enquanto static::acessará a propriedade e a constante do escopo em tempo de execução (nesse caso, na Piratesubclasse).
Leia mais sobre ligação estática tardia aqui no php.net .
Verifique também a resposta em outra pergunta aqui e aqui .
Declarar um método ou propriedade de classe como estático os torna acessíveis sem a necessidade de uma instanciação da classe.
Uma constante de classe é como uma constante normal, não pode ser alterada em tempo de execução. Este também é o único motivo pelo qual você utilizará o const.
Privado, público e protegido são modificadores de acesso que descrevem quem pode acessar qual parâmetro / método.
Público significa que todos os outros objetos obtêm acesso. Privado significa que somente a classe instanciada obtém acesso. Protegido significa que a classe instanciada e as classes derivadas obtêm acesso.
Aqui estão as coisas que aprendi até agora sobre membros estáticos, variáveis constantes e modificadores de acesso (privado, público e protegido). Constante
Definição
Como o nome diz, os valores de uma variável constante não podem ser alterados. As constantes diferem das variáveis normais, pois você não usa o símbolo $ para declará-las ou usá-las.
O valor deve ser uma expressão constante, não (por exemplo) uma variável, uma propriedade, o resultado de uma operação matemática ou uma chamada de função.
Nota: O valor da variável não pode ser uma palavra-chave (por exemplo, auto, pai e estática).
Declarando uma constante em php
<?php
class constantExample{
const CONSTANT = 'constant value'; //constant
}
?>O escopo da Constant é global e pode ser acessado usando uma palavra-chave self
<?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
?>Estático
Definição
A palavra-chave estática pode ser usada para declarar uma classe, função-membro ou variável. Os membros estáticos de uma classe são globais também podem ser acessados usando uma palavra-chave própria. Declarar propriedades ou métodos de classe como estáticos os torna acessíveis sem a necessidade de uma instanciação da classe . Uma propriedade declarada como estática não pode ser acessada com um objeto de classe instanciado (embora um método estático possa). Se nenhuma declaração de visibilidade (pública, privada, protegida) for usada, a propriedade ou o método será tratado como se fosse declarado como público.Porque os métodos estáticos podem ser chamados sem uma instância do objeto criado.
Nota: a pseudo-variável $ this não está disponível dentro do método declarado como static. As propriedades estáticas não podem ser acessadas através do objeto usando o operador de seta ->
A partir do PHP 5.3.0, é possível referenciar a classe usando uma variável. O valor da variável> não pode ser uma palavra-chave (por exemplo, auto, pai e estática).
Exemplo de propriedade estática
<?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
}
}
?>Acessando propriedades estáticas e exemplo de funções
<?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";
?>Público, privado, protegido (modificadores de acesso AKA)
Antes de ler a definição abaixo, leia este artigo sobre Encapsulamento. Isso ajudará você a entender o conceito mais profundamente
Tutoriais apontam link sobre encapsulamento
Definição
Usando palavras-chave privadas, públicas e protegidas, você pode controlar o acesso aos membros de uma classe. Os membros da classe declarados públicos podem ser acessados em qualquer lugar. Os membros declarados protegidos podem ser acessados apenas dentro da própria classe e pelas classes herdada e pai. Os membros declarados como privados podem ser acessados apenas pela classe que define o membro.
Exemplo
<?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
}
}
?> Acessando o exemplo de membros públicos, privados e protegidos
As variáveis públicas podem ser acessadas e modificadas de fora da classe ou dentro da classe. Mas você pode acessar as variáveis e funções privadas e protegidas apenas de dentro da classe. Você não pode modificar o valor de membros protegidos ou públicos fora da classe.
<?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)
?>Para obter mais informações, leia esta documentação php sobre visibilidade Visibility Php Doc.
Referências: php.net
Espero que você tenha entendido o conceito. Obrigado pela leitura :) :) Tenha uma boa
Então, para recapitular a ótima resposta do @Matt:
se a propriedade que você precisa não deve ser alterada, uma constante é a escolha certa
se a propriedade necessária for alterada, use static em vez disso
Exemplo:
class User{
private static $PASSWORD_SALT = "ASD!@~#asd1";
...
}
class Product{
const INTEREST = 0.10;
...
}Edit: É importante notar que o PHP 7.1.0 introduziu suporte para especificar a visibilidade das constantes da classe .
self::$variablevariáveis estáticas e estáticas protegidas, pois prefiro manter o nome da classe mencionado apenas uma vez dentro de si, que está no início da classe.