PHP: definisce la costante all'interno di una classe

Come posso definire una costante all'interno di una classe e renderla visibile solo quando viene chiamata in un contesto di classe?

....qualcosa di simile a Foo::app()->MYCONSTANT;

(e se chiamato piace MYCONSTANTessere ignorato)

Vedere Costanti di classe :

class MyClass
{
    const MYCONSTANT = 'constant value';

    function showConstant() {
        echo  self::MYCONSTANT. "\n";
    }
}

echo MyClass::MYCONSTANT. "\n";

$classname = "MyClass";
echo $classname::MYCONSTANT. "\n"; // As of PHP 5.3.0

$class = new MyClass();
$class->showConstant();

echo $class::MYCONSTANT."\n"; // As of PHP 5.3.0

In questo caso, l'eco MYCONSTANTda solo solleverebbe un avviso su una costante non definita e produrrebbe il nome della costante convertito in una stringa:"MYCONSTANT" .

EDIT - Forse quello che stai cercando sono queste proprietà / variabili statiche :

class MyClass
{
    private static $staticVariable = null;

    public static function showStaticVariable($value = null)
    {
        if ((is_null(self::$staticVariable) === true) && (isset($value) === true))
        {
            self::$staticVariable = $value;
        }

        return self::$staticVariable;
    }
}

MyClass::showStaticVariable(); // null
MyClass::showStaticVariable('constant value'); // "constant value"
MyClass::showStaticVariable('other constant value?'); // "constant value"
MyClass::showStaticVariable(); // "constant value"

Questa è una vecchia domanda, ma ora su PHP 7.1 puoi definire una visibilità costante.

ESEMPIO

<?php
class Foo {
    // As of PHP 7.1.0
    public const BAR = 'bar';
    private const BAZ = 'baz';
}
echo Foo::BAR . PHP_EOL;
echo Foo::BAZ . PHP_EOL;
?>

Risultato dell'esempio precedente in PHP 7.1:

bar

Errore irreversibile: errore non rilevato: impossibile accedere a const privato Foo :: BAZ in ...

Nota: a partire da PHP 7.1.0, i modificatori di visibilità sono consentiti per le costanti di classe.

Maggiori info qui

class Foo {
    const BAR = 'baz';
}

echo Foo::BAR;

Questo è l'unico modo per creare costanti di classe . Queste costanti sono sempre accessibili a livello globale tramite Foo::BAR, ma non sono accessibili solo tramiteBAR .

Per ottenere una sintassi simile Foo::baz()->BAR, è necessario restituire un oggetto dalla funzione baz()di classe Fooche ha una proprietà BAR . Non è una costante però. Qualsiasi costante definita è sempre accessibile a livello globale da qualsiasi luogo e non può essere limitata ai risultati della chiamata di funzione.

Questa è una domanda piuttosto vecchia, ma forse questa risposta può ancora aiutare qualcun altro.

È possibile emulare una costante pubblica limitata all'interno di un ambito di classe applicando la parola chiave final a un metodo che restituisce un valore predefinito, come questo:

class Foo {

    // This is a private constant
    final public MYCONSTANT()
    {
        return 'MYCONSTANT_VALUE';
    }
}

La parola chiave finale su un metodo impedisce a una classe in estensione di ridefinire il metodo. È inoltre possibile inserire la parola chiave finale davanti alla dichiarazione della classe, nel qual caso la parola chiave impedisce l'ereditarietà della classe.

Per ottenere quasi esattamente ciò che Alex stava cercando, è possibile utilizzare il seguente codice:

final class Constants {

    public MYCONSTANT()
    {
        return 'MYCONSTANT_VALUE';
    }
}

class Foo {

    static public app()
    {
        return new Constants();
    }
}

Il valore della costante emulato sarebbe accessibile in questo modo:

Foo::app()->MYCONSTANT();

Puoi definire una costante di classe in php. Ma la tua costante di classe sarebbe accessibile anche da qualsiasi istanza di oggetto. Questa è la funzionalità di php. Tuttavia, a partire da php7.1 , puoi definire le costanti di classe con i modificatori di accesso ( public, privateoprotected ).

Una soluzione potrebbe essere quella di definire la tua costante come privateo protectede quindi renderla leggibile tramite astatic function . Questa funzione dovrebbe restituire i valori costanti solo se chiamata dal contesto statico.

Puoi anche creare questa funzione statica nella tua classe genitore ed ereditare semplicemente questa classe genitore su tutte le altre classi per renderla una funzionalità predefinita.

Crediti: http://dwellupper.io/post/48/defining-class-constants-in-php