Delicious Bookmark this on Delicious Share on Facebook SlashdotSlashdot It! Digg! Digg



PHP : Language Reference : Constants : Magic constants

Magic constants

PHP provides a large number of predefined constants to any script which it runs. Many of these constants, however, are created by various extensions, and will only be present when those extensions are available, either via dynamic loading or because they have been compiled in.

There are five magical constants that change depending on where they are used. For example, the value of __LINE__ depends on the line that it's used on in your script. These special constants are case-insensitive and are as follows:

Table 4.1. A few "magical" PHP constants

Name Description
__LINE__ The current line number of the file.
__FILE__ The full path and filename of the file. If used inside an include, the name of the included file is returned. Since PHP 4.0.2, __FILE__ always contains an absolute path whereas in older versions it contained relative path under some circumstances.
__FUNCTION__ The function name. (Added in PHP 4.3.0) As of PHP 5 this constant returns the function name as it was declared (case-sensitive). In PHP 4 its value is always lowercased.
__CLASS__ The class name. (Added in PHP 4.3.0) As of PHP 5 this constant returns the class name as it was declared (case-sensitive). In PHP 4 its value is always lowercased.
__METHOD__ The class method name. (Added in PHP 5.0.0) The method name is returned as it was declared (case-sensitive).


See also get_class(), get_object_vars(), file_exists() and function_exists().

Code Examples / Notes » language.constants.predefined

hixon
You can use the following in files that you want to include, but not run directly.  The script will exit if it's run as the top-level script, but will not exit if it's included from another script.  Of course this won't work in the command line mode.
if (realpath(__FILE__) == realpath($_SERVER['SCRIPT_FILENAME'])) {
 exit;
}

warhog
There is another magic constant not mentioned above: __COMPILER_HALT_OFFSET__ - contains where the compiler halted - see http://www.php.net/manual/function.halt-compiler.php for further information.

tomek perlak tomekperlak
The __CLASS__ magic constant nicely complements the get_class() function.
Sometimes you need to know both:
- name of the inherited class
- name of the class actually executed
Here's an example that shows the possible solution:
<?php
class base_class
{
function say_a()
{
   echo "'a' - said the " . __CLASS__ . "<br/>";
}
function say_b()
{
   echo "'b' - said the " . get_class($this) . "<br/>";
}
}
class derived_class extends base_class
{
function say_a()
{
parent::say_a();
   echo "'a' - said the " . __CLASS__ . "<br/>";
}
function say_b()
{
parent::say_b();
   echo "'b' - said the " . get_class($this) . "<br/>";
}
}
$obj_b = new derived_class();
$obj_b->say_a();
echo "<br/>";
$obj_b->say_b();
?>
The output should look roughly like this:
'a' - said the base_class
'a' - said the derived_class
'b' - said the derived_class
'b' - said the derived_class

kop
The keywords TRUE and FALSE (case insensitive), which represent their respective boolean values, are worth noting here.

vijaykoul_007
the difference between
__FUNCTION__ and __METHOD__ as in PHP 5.0.4 is that
__FUNCTION__ returns only the name of the function
while as __METHOD__ returns the name of the class alongwith the name of the function
class trick
{
     function doit()
     {
               echo __FUNCTION__;
     }
     function doitagain()
     {
               echo __METHOD__;
     }
}
$obj=new trick();
$obj->doit();
output will be ----  doit
$obj->doitagain();
output will be ----- trick::doitagain

csaba
Sometimes you might want to know whether a script is the top level script or whether it has been included.  That could be useful if you want to reuse the routines in another script, but you don't want to separate them out.  Here's a way that seems to be working for me (for both Apache2 module and CLI versions of PHP) on my Win XP Pro system.
By the way, if __FILE__ is within a function call, its value corresponds to the file it was defined in and not the file that it was called from.  Also, I used $script and strtolower instead of realpath because if the script is deleted after inclusion but before realpath is called (which could happen if the test is deferred), then realpath would return empty since it requires an extant file or directory.
Csaba Gabor from Vienna
<?php
if (amIincluded()) return;    // if we're included we only want function defs
function amIincluded() {
//    returns true/false depending on whether the currently
//    executing script is included or not
//    Don't put this function in an include file (duh)!
   $webP = !!$_SERVER['REQUEST_METHOD']; // a web request?
   $script = preg_replace('/\//',DIRECTORY_SEPARATOR,
                          $_SERVER['SCRIPT_FILENAME']);
   return ($webP) ? (strtolower(__FILE__)!=strtolower($script)) :
  !array_key_exists("_REQUEST", $GLOBALS);
}
?>

ulrik
note that __FUNCTION__ define gives the the function name in lowercase

claude
Note that __CLASS__ contains the class it is called in; in lowercase. So the code:
class A
{
function showclass()
{
echo __CLASS__;
}
}
class B extends A
{
}
$a = new A();
$b = new B();
$a->showclass();
$b->showclass();
A::showclass();
B::showclass();
results in "aaaa";

karl __at__ streetlampsoftware__dot__com
Note that the magic constants cannot be included in quoted strings.
For instance,
echo "This is the filename: __FILE__";
will return exactly what's typed above.
echo "This is the filename: {__FILE__}";
will also return what's typed above.
The only way to get magic constants to parse in strings is to concatenate them into strings:
echo "This is the filename: ".__FILE__;

warhog
just to read out the filename of the currently proceeded file use
<?php basename(__FILE__); ?>

php
In response to stangelanda at gmail dot com, (who suggested a possible fix to get the actual class name of the object, when being called statically).
in PHP5, this fix no longer works.  
Here is some example code:
<?php
 function get_class_static() {
   $bt = debug_backtrace();
   $name = $bt[1]['class'];
   return $name;
 }
 class foo {
   function printClassName() {
     print(get_class_static() . "
");
    }
 }
 class bar extends foo {
 }
$f = new foo();
$b = new bar();
$f->printClassName();
$b->printClassName();
?>
In PHP4, it outputs
 foo
 bar
as you described.
However, in PHP5, due to the way the debug_backtrace() function has been modified (see http://bugs.php.net/bug.php?id=30828) the output is now
 foo
 foo
I have yet to figure out a way to get the original output in PHP5.  Any suggestions would be very useful, and if I find an answer I'll post it here.

lm arobase bible point ch
in reply to x123 at bestof dash inter:
I believe, this is not a bug, but a feature.
__FILE__ returns the name of the include file, while $PHP_SELF returns the relative name of the main file.
It is then easy to get the file name only with substr(strrchr($PHP_SELF,'/'),1)

php
Further to my previous note, the 'object' element of the array can be used to get the parent object.  So changing the get_class_static() function to the following will make the code behave as expected:
<?php
function get_class_static() {
$bt = debug_backtrace();

if (isset($bt[1]['object']))
return get_class($bt[1]['object']);
else
return $bt[1]['class'];
}
?>
HOWEVER, it still fails when being called statically.  Changing the last two lines of my previous example to
<?php
 foo::printClassName();
 bar::printClassName();
?>
...still gives the same problematic result in PHP5, but in this case the 'object' property is not set, so that technique is unavailable.

stangelanda
claude noted that __CLASS__ always contains the class that it is called in, if you would rather have the class that called the method use get_class($this) instead.  However this only works with instances, not when called statically.
<?php
 class A {
    function showclass() {
        echo get_class($this);
    }
 }
 class B extends A {}
 $a = new A();
 $b = new B();
 $a->showclass();
 $b->showclass();
 A::showclass();
 B::showclass();
 //results in "a", "b", false, false
?>
I tried keeping track of the class manually within the properties, but the following doesn't work either:
<?php
 class A {
    var $class = __CLASS__;
    function showclass() {
        echo $this->class;
    }
 }
 class B extends A {
    var $class = __CLASS__;
 }
 //results in "a", "b", NULL, NULL
?>
The best solution I could come up with was using debug_backtrace.  I assume there is a better way somehow, but I can't find it.  However the following works:
<?php
 class A {
    function showclass() {
       $backtrace = debug_backtrace();
   echo $backtrace[0]['class'];
    }
 }
 class B extends A {}
 //results in "a", "b", "a", "b"
?>

darwin
As of version 4.0.6, there is also a handy predefined DIRECTORY_SEPARATOR constant which you can use to make you scripts more portatable between OS's with different directory structures.

Change Language


Follow Navioo On Twitter
Syntax
Magic constants
Terms of Service Privacy Policy Sitemap

©2024 -EPSILONSYS SOFTWARE inc

Other EPSILONSYS SOFTWARE Web Sites : Programming Resources | News Headline | Free local classifieds

eXTReMe Tracker