session_start - Clases de PHP: cuándo usar:: vs.->?

session_start php ejemplos

Question

Entiendo que hay dos formas de acceder a una clase de PHP: "::" y "->". En algún momento, uno parece funcionar para mí, mientras que el otro no, y no entiendo por qué.

¿Cuáles son los beneficios de cada uno y cuál es la situación correcta para usar?

Answer 1

Cuando declara una clase, es por defecto ''estática''. Puede acceder a cualquier método en esa clase utilizando el operador :: y en cualquier ámbito. Esto significa que si creo una clase lib, puedo acceder a ella donde quiera y no es necesario que esté globalizada:

class lib
{
static function foo()
{
echo "hi";
}
}
lib::foo(); // prints hi

Ahora, cuando creas una instancia de esta clase usando la new palabra clave, usas -> para acceder a métodos y valores, porque te estás refiriendo a esa instancia específica de la clase. Puedes pensar en -> como inside of . (Nota, debes eliminar la palabra clave estática) IE:

class lib
{
function foo()
{
echo "hi";
}
}
$class = new lib;
$class->foo(); // I am accessing the foo() method INSIDE of the $class instance of lib.

Answer 2

El símbolo "::" es para acceder a los métodos / propiedades de un objeto que se han declarado con la palabra clave estática, "->" es para acceder a los métodos / propiedades de un objeto que representan métodos / propiedades de instancia.

Answer 3

Php puede ser confuso en este sentido, debe leer this .

Lo que también es confuso es que puede llamar a funciones no estáticas con el símbolo ::. Esto es muy extraño cuando vienes de Java. Y ciertamente me sorprendió cuando lo vi por primera vez.

Por ejemplo:

class Car
{
public $name = "Herbie <br/>";
public function drive()
{
echo "driving <br/>";
}
public static function gas()
{
echo "pedal to the metal<br/>";
}
}
Car::drive(); //will work
Car::gas(); //will work
$car = new Car();
$car->drive(); // will work
$car->gas(); //will work
echo $car->name; // will work
echo Car::$name; // wont work error

Como puedes ver estática es muy floja en php. Y puede llamar a cualquier función con los símbolos -> y ::. Pero hay una diferencia cuando llama con :: no hay $ esta referencia a una instancia. Vea el ejemplo # 1 en el this .

Answer 4

Sourcing WikiPedia - Clase

En la programación orientada a objetos, una clase es una construcción de lenguaje de programación que se utiliza como modelo para crear objetos. Este plan describe el estado y el comportamiento que comparten todos los objetos creados. Un objeto creado por una clase es una instancia de la clase, y la clase que creó esa instancia puede considerarse como el tipo de ese objeto, por ejemplo, un tipo de un objeto creado por una clase de "Fruto" sería "Fruto".

El operador :: accede a los métodos y propiedades de clase que se definen en php usando la palabra clave static . También se accede a la clase const usando ::

El operador -> accede a los métodos y propiedades de una instancia de la clase.

Si la función opera en una instancia, estará usando -> . Si opera en la propia clase, estarás usando ::

Otro uso de :: sería cuando desea llamar a parent funciones parent . Si una clase hereda a otra, puede anular los métodos de la clase primaria, luego llamarlos usando parent::function()

Answer 5

También se debe tener en cuenta que cada función estática también se puede llamar utilizando una instancia de la clase, pero no al revés.

Así que esto funciona:

class Foo
{
public static function bar(){}
}
$f = new Foo();
$f->bar(); //works
Foo::bar(); //works

Y esto no:

class Foo
{
protected $test="fddf";
public function bar(){ echo $this->test; }
}
$f = new Foo();
$f->bar(); //works
Foo::bar(); //fails because $this->test can''t be accessed from a static call

Por supuesto, debe limitarse a llamar métodos estáticos de forma estática, ya que crear instancias de una instancia no solo cuesta memoria, sino que tampoco tiene mucho sentido.

Esta explicación fue principalmente para ilustrar por qué funcionó para usted algunas de las veces.

Answer 6

:: se utiliza para acceder a una propiedad estática de clase. Y -> se usa para acceder a una propiedad de instancia de clase (Objeto).

Considere esta clase de producto que tiene dos funciones para recuperar detalles del producto. Una función getProductDetails pertenece a la instancia de una clase, mientras que la otra getProductDetailsStatic pertenece solo a la clase.

class Product {
protected $product_id;
public function __construct($product_id) {
$this->product_id = $product_id;
}
public function getProductDetails() {
$sql = "select * from products where product_id= $this->product_id ";
return Database::execute($sql);
}
public static function getProductDetailsStatic($product_id) {
$sql = "select * from products where product_id= $product_id ";
return Database::execute($sql);
}
}

Consigamos productos:

$product = new Product(''129033''); // passing product id to constructor
var_dump( $product->getProductDetails() ); // would get me product details
var_dump( Product::getProductDetailsStatic(''129033'') ); // would also get me product details

¿Cuándo usar Static properties ?

Considere esta clase que puede no requerir una instanciación:

class Helper {
static function bin2hex($string = '''') {
}
static function encryptData($data = '''') {
}
static function string2Url($string = '''') {
}
static function generateRandomString() {
}
}

Answer 7

En pocas palabras, :: es para las propiedades de nivel de clase , y -> es para las propiedades de nivel de objeto .

Si la propiedad pertenece a la clase, use ::

Si la propiedad pertenece a una instancia de la clase , use ->

class Tester
{
public $foo;
const BLAH;
public static function bar(){}
}
$t = new Tester;
$t->foo;
Tester::bar();
Tester::BLAH;