php - mágicos - ¿Cuál es la diferencia entre isset() y__isset()?
public function__ get (7)
¿Cuáles son las diferencias entre las funciones php comunes y las funciones mágicas en php?
Las funciones comunes de PHP están declaradas y son accesibles con entradas y resultados esperados, pero deben llamarse. En contraste, las funciones mágicas están definidas en PHP, pero cuando se definen en una clase, se llamarán automáticamente. Por ejemplo, el isset() es una función de PHP
Determine si una variable está establecida y no es NULL
Pero __isset () es una sobrecarga de propiedad de una clase.
La sobrecarga en PHP proporciona medios para "crear" propiedades y métodos dinámicamente. Estas entidades dinámicas se procesan a través de métodos mágicos que se pueden establecer en una clase para varios tipos de acción. Los métodos de sobrecarga se invocan al interactuar con propiedades o métodos que no se han declarado o no están visibles en el alcance actual.
Se llamará mágicamente detrás de la escena como se describe anteriormente si se declara en la clase. Vamos a experimentar la sobrecarga de propiedades de clase PHP.
<?php
class PropertyTest
{
/** Location for overloaded data. */
private $data = array();
/** Overloading not used on declared properties. */
public $declared = 1;
/** Overloading only used on this when accessed outside the class. */
private $hidden = 2;
public function __set($name, $value)
{
echo "Setting ''$name'' to ''$value''/n";
$this->data[$name] = $value;
}
public function __get($name)
{
echo "Getting ''$name''/n";
if (array_key_exists($name, $this->data)) {
return $this->data[$name];
}
$trace = debug_backtrace();
trigger_error(
''Undefined property via __get(): '' . $name .
'' in '' . $trace[0][''file''] .
'' on line '' . $trace[0][''line''],
E_USER_NOTICE);
return null;
}
/* As of PHP 5.1.0 */
public function __isset($name)
{
echo "Is ''$name'' set?/n";
return isset($this->data[$name]);
}
/** As of PHP 5.1.0 */
public function __unset($name)
{
echo "Unsetting ''$name''/n";
unset($this->data[$name]);
}
/** Not a magic method, just here for example. */
public function getHidden()
{
return $this->hidden;
}
}
echo "<pre>/n";
$obj = new PropertyTest;
//__set() is called when ''a'' property is not visible outside of class
$obj->a = 1;
//__get() is called when ''a'' property is not visible outside of class
echo "a: ".$obj->a . "/n/n";
//__isset() is called when ''a'' property is not visible outside of class
var_dump(isset($obj->a));
unset($obj->a);
//__isset() is called when ''a'' property is not visible outside of class
var_dump(isset($obj->a));
echo "/n";
//__isset() is not called as ''declared'' property is visible outside of class
var_dump(isset($obj->declared));
//__get() is not called as ''declared'' property is visible outside of class
echo "declared: ". $obj->declared . "/n/n";
//__set() is not called as ''declared'' property is visible outside of class
$obj->declared = 3;
//__get() is not called as ''declared'' property is visible outside of class
echo "declared: ". $obj->declared . "/n/n";
//__isset() is called as ''hidden'' property is not visible outside of class
var_dump(isset($obj->hidden));
echo "Let''s experiment with the private property named ''hidden'':/n";
echo "Privates are visible inside the class, so __get() not used.../n";
echo $obj->getHidden() . "/n";
echo "Privates not visible outside of class, so __get() is used.../n";
var_dump($obj->hidden);
?>
El código de arriba saldrá
Setting ''a'' to ''1''
Getting ''a''
a: 1
Is ''a'' set?
bool(true)
Unsetting ''a''
Is ''a'' set?
bool(false)
bool(true)
declared: 1
declared: 3
Is ''hidden'' set?
bool(false)
Let''s experiment with the private property named ''hidden'':
Privates are visible inside the class, so __get() not used...
2
Privates not visible outside of class, so __get() is used...
Getting ''hidden''
NULL
Dice que la propiedad ''oculta'' no está establecida y muestra bool(false) pero que elimina el valor ''2'' más adelante porque la propiedad ''oculta'' no es visible fuera de la clase y llama a la función mágica __isset() pero tampoco lo es establecido en ''datos'' para que devuelva bool(false) . En la función getHidden() , aunque devuelve la propiedad privada del objeto ''oculta'', que es visible para las funciones internas del objeto. En el último var_dump($obj->hidden) llama __get() método __get() y devuelve NULL. Porque en el método __get() busca data[''hidden''] que es NULL .
Nota: el ejemplo aquí es de PHP Manuel: Sobrecarga con algunas modificaciones.
¡Espero que esto ayude!
Necesito saber acerca de la función mágica __isset() y la función normal isset() . En realidad, ¿cuál es la diferencia real entre php language construct isset() y php magic method __isset() ? Cuando lo __isset() Google me dijeron que __isset() es una función mágica. ¿Cuáles son las diferencias entre las funciones php comunes y las funciones mágicas en php?
isset()
Es un constructo de lenguaje que verifica la inicialización de variables o propiedades de clase:
$a = 10;
isset($a); // true
isset($a, $b); // false
class Test
{
public $prop = 10;
}
$obj = new Test;
isset($obj->prop); // true
__isset()
Es un método mágico que se invoca cuando isset() o empty() comprueban propiedad de clase inexistente o inaccesible:
class Test
{
public function __isset($name) {
echo "Non-existent property ''$name''";
}
}
$obj = new Test;
isset($obj->prop); // prints "Non-existent property ''prop''" and return false
Diferencia:
isset() __isset()
Language construct | Magic method | Always return bool | Result depends on custom logic* | Must be invoked in code | Called automatically by event | Unlimited number of parameters | Has only one parameter | Can be used in any scope | Must be defined as method** | Is a reserved keyword | Not a reserved keyword | Can''t be redefined (Parse error) | Can be redefined in extended class***
__isset() resultado de __isset() todos modos se convertirá automáticamente como bool .
En realidad, puedes definir la función personalizada __isset() pero no tiene nada que ver con el método mágico.
Vea este ejemplo .
Metodos magicos
A diferencia de las funciones comunes, se pueden definir solo en el alcance de la clase e invocarse automáticamente en eventos específicos como: invocación de métodos inaccesibles, serialización de clases, cuando se utiliza unset() en propiedades inaccesibles y así sucesivamente. Véase también esta documentación oficial: Overloading .
En primer lugar, permítame decirle lo que hace la función isset (). La función isset () verifica si el valor se ha establecido o si es nulo. La función _ isset () es un método mágico en PHP. Cualquier función con una "_ " al principio es un método mágico en PHP. Ahora, se invoca a __isset () llamando a isset () o empty () en propiedades inaccesibles, con eso me refiero a aquellas propiedades que no se han definido en la clase y se están definiendo explícitamente en el tiempo de ejecución. Aquí hay una pieza de código que debería hacerte entender mejor:
<?php
class PropertyTest
{
/** Location for overloaded data. */
private $data = array();
/** Overloading not used on declared properties. */
public $declared = 1;
/** Overloading only used on this when accessed outside the class. */
private $hidden = 2;
public function __set($name, $value)
{
echo "Setting ''$name'' to ''$value''/n";
$this->data[$name] = $value;
}
public function __get($name)
{
echo "Getting ''$name''/n";
if (array_key_exists($name, $this->data)) {
return $this->data[$name];
}
$trace = debug_backtrace();
trigger_error(
''Undefined property via __get(): '' . $name .
'' in '' . $trace[0][''file''] .
'' on line '' . $trace[0][''line''],
E_USER_NOTICE);
return null;
}
/** As of PHP 5.1.0 */
public function __isset($name)
{
echo "Is ''$name'' set?/n";
return isset($this->data[$name]);
}
/** As of PHP 5.1.0 */
public function __unset($name)
{
echo "Unsetting ''$name''/n";
unset($this->data[$name]);
}
/** Not a magic method, just here for example. */
public function getHidden()
{
return $this->hidden;
}
}
echo "<pre>/n";
$obj = new PropertyTest;
$obj->a = 1;
echo $obj->a . "/n/n";
var_dump(isset($obj->a));
unset($obj->a);
var_dump(isset($obj->a));
echo "/n";
echo $obj->declared . "/n/n";
echo "Let''s experiment with the private property named ''hidden'':/n";
echo "Privates are visible inside the class, so __get() not used.../n";
echo $obj->getHidden() . "/n";
echo "Privates not visible outside of class, so __get() is used.../n";
echo $obj->hidden . "/n";
?>
Las funciones mágicas se invocan (activan) automáticamente cuando algo sucede. Las funciones normales tienen que ser invocadas específicamente por su código php.
En su caso: __isset () se invocará automáticamente cuando tenga un isset () que está tratando de obtener una propiedad no accesible.
Ejemplo:
root@folgore:/tmp/php# cat a.php
<?php
class a {
private $att1;
public $att2;
function __isset($field) {
echo "__isset invoked for $field/n";
}
}
$obj=new a();
// __isset will be triggered:
isset($obj->att1);
// __isset will not be triggered:
isset($obj->att2);
root@folgore:/tmp/php# php a.php
__isset invoked for att1
__isset es el método mágico. Los métodos mágicos son los métodos llamados internamente.
Considere el siguiente código
<?php
// Declare a simple class
class TestClass
{
public $foo;
public function __construct($foo)
{
$this->foo = $foo;
}
public function __toString()
{
return $this->foo;
}
}
$class = new TestClass(''Hello'');
echo $class;
?>
aquí _ toString es un método mágico pero no lo llamarás. Cuando la línea echo $ class; es ejecutado. PHP sabe que ahora debería tratar el objeto $ class como una cadena y tratar cualquier objeto como el método de llamada de cadena _toString, si se implementa en esa clase.
Todos los métodos mágicos se llaman así de manera indirecta.
Otro ejemplo como sigue
<?php
class CallableClass
{
public function __invoke($x)
{
var_dump($x);
}
}
$obj = new CallableClass;
$obj(5);
var_dump(is_callable($obj));
?>
De manera similar, en el código anterior, var_dump (is_callable ($ obj)); invoca __invoke magic method indirectamente.
en palabras simples, __isset () ayuda a isset () a trabajar sobre vars protegidos / privados en clase .
Ejemplo:
class test
{
public $x = array();
}
en la clase anterior puedes hacer esto isset($test->x[''key'']) ya que $x es público
pero aquí
class test
{
protected $x = array();
function __isset($key)
{
return isset($this->x[$key]);
}
}
$x está protegido y no puede acceder a él, por lo que creamos __isset() para ayudarnos a usar isset($x[''key''])
puedes decir que __isset() es solo un puente para isset()
isset() es para las variables y __isset() es para las propiedades de una clase.