Home / Questions / 202779
Accepted
jmrufo
Asked: 2020-10-09 03:48:05 +0800 CST 2020-10-09 03:48:05 +0800 CST

Get static property value from php file

  • 772

I debut in this community with the following doubt that I do not finish seeing.

If I create a class in which I establish some properties and methods of type static, how can I later retrieve the value of those properties from another file?

Example:

final class website {

    public static $valor;

    private function __construct() {

    }

    public static function setValor($x) {
        self::$valor= $x;        
    }

    public static function getValor() {
        return self::$valor;
    }
}

If I try to do this from another .php file the result I get is null.

website::getValor();

Can someone give me an idea?

Thank you

php

1 Answers

  1. Best Answer

    The reason for the error

    It returns you NULLbecause when you do:

    website::getValor();

    At that time the $valorclass member has no data. In fact, usually a property declared as staticshould be declared with some default value (we'll see why later).

    If you do this for example:

    website::setValor(1);

    And then:

    echo website::getValor();

    You will see a 1, because the class property has acquired a value that it did not have before.

    Or if you declare it with a default value, you will see that value when you invoke it:

    public static $valor=0;

    What is a property or member for static? When should I declare static?

    You have to be careful when declaring a member staticin a class.

    From the outset it must be said that the use of static members (as well as the declaration of global variables), is considered a bad practice . Although this does not mean that you have to see the devil when we see a static. There are cases in which they could be convenient and we will see it with some practical examples.

    The peculiarity of the properties declared staticin a class is that they belong to the class itself, and not the instance of the class . That means that we can make use of them without having to create a new instance of that class. That's why we can access it just by doing:Clase::$miembroEstatico;

    The question then is: when is this justified? That is, in what cases would it be better to have a property of the class that you can access without needing to instantiate that class?

    A very common case is when we need a counter in the class for whatever. That property can be declared as static.

    Usually those static properties exist in utility classes which we make use of in many parts of the program.

    Let's consider a class Utilswhere for whatever reason we need to, among other things, keep a counter:

    class Utils 
{
  static public $contador = 0;

  static public function addValue($value)
  {
    self::$contador+= $value;
  }
}

    If in various parts of the program we need to modify/obtain said counter, both a property and a member are justified in that class staticto handle that situation.

    Imagine several parts of the program:

    /*Necesitamos valor inicial del contador*/
echo Utils::$contador.PHP_EOL;

/*Necesitamos agregar 1*/
Utils::addValue(1);
echo Utils::$contador.PHP_EOL;

/*Necesitamos agregar 5*/
Utils::addValue(5);
echo Utils::$contador.PHP_EOL;

/*Necesitamos agregar 9*/
Utils::addValue(9);
echo Utils::$contador.PHP_EOL;

    The information that will be obtained in each case will be:

    0
1
6
15

    Another very common example where a static method would be justified in this case would be that you would need Utilsa method in your class to format content.

    This is something that I use in an application in which, for reasons that are not relevant now, I handle certain information saved with symbols that are later replaced by another type of content.

    In the database the content is more or less fixed, but certain symbols are added according to variable parameters such as the day of the week, the month we are in, etc.

    In that case the class Utilscould have a static method that we will call formatText, which will receive the text as it is constructed and make modifications to it by changing the symbols with a pre-established contract.

    public static function formatText($sTexto, $nTiempo=null) 
{

    $sTexto = str_replace("_", self::NBSP_SALMOS, $sTexto);
    $sTexto = str_replace("§", self::BRS, $sTexto);
    $sTexto = str_replace("~", self::BR, $sTexto);
    $sTexto = str_replace("¦", self::NBSP_4, $sTexto);
    $sTexto = str_replace("⊣", self::BR . self::NBSP_4, $sTexto);
    $sTexto = str_replace("≠", self::PRECES_R, $sTexto);
    $sTexto = str_replace("∞", self::PRECES_IL, $sTexto);
    $sTexto = str_replace("℟", '<font color="#d50000">℟.</font>', $sTexto);
    $sTexto = str_replace("℣", '<font color="#d50000">℣.</font>', $sTexto);
    return $sTexto;
}

    The method is longer and does more complex things with the parameter $nTiempowhen required.

    Another interesting and possible candidate staticmethod would be a method where you show, for example, the Copyright or the license under which you share some content.

    public static function getCopyRight ($inicio) 
{
    $str='<div class="attribution"><a rel="license" href="http://creativecommons.org/licenses/by-nc/4.0/"></a><br />El contenido de este sitio está bajo una <a rel="license" href="http://creativecommons.org/licenses/by-nc/4.0/">licencia de Creative Commons Reconocimiento-NoComercial 4.0 Internacional.</a><br>Significa que se podrá utilizar y compartir, sin fines comerciales.<br>Si aquí es compartido contenido bajo derechos de autor, y el mismo manifiesta su desacuerdo, dicho contenido será retirado.';

    $str.='<br>&copy '.$inicio.'-'.date("Y").' Nombre Autor | deiverbum.org<br /><br /><img alt="Licencia de Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc/4.0/88x31.png" /></div>';
    return $str;

}

    It should be said that all this is declared within the same class Utils, which, as its name indicates, is a utility class that is very helpful in large programs to have things that we repeat very often in one place. Also, this gives you the ability to change anything that needs to be updated in one place.

    Another very important aspect: do not confuse the usefulness of a static member with a constant

    An error that can be made, especially starting out, is to confuse staticwith const. Is not the same. A constant is a value that will never change . A clear example of a constant would be the PI, which, until proven otherwise, must always be: 3.14.

    To better understand the difference, you can read this Stackoverflow answer in English , if you don't understand it, you can also ask your questions here in the Spanish-speaking community.

    Other things to consider

    You have to take into account what @Marcos says in his comment. A getter/setter is not justified if it $valoris declared public, since it could be obtained (get) and modify (set) directly, without going through those methods, as shown above.

    This usually happens when we don't fully understand in which cases to use a property staticand when not. I think that with the explanations given it is clearer :)

    NOTE ON NAMING CONVENTION:

    You should apply an appropriate naming convention . For example, class names should generally begin with all uppercase words. Maybe your class should be called: WebSite. This is not a reason for error, but it creates difficulties when analyzing the code by other programmers and by yourself in the future, to the extent that the program grows and you incorporate new elements into it.

    Links:

    For more details, you can refer to the following articles:

    • 2