stas Fri Aug 17 21:53:59 2007 UTC Modified files: /php-src README.namespaces Log: some rewording and typofixing http://cvs.php.net/viewvc.cgi/php-src/README.namespaces?r1=1.5&r2=1.6&diff_format=u Index: php-src/README.namespaces diff -u php-src/README.namespaces:1.5 php-src/README.namespaces:1.6 --- php-src/README.namespaces:1.5 Fri Aug 17 17:12:28 2007 +++ php-src/README.namespaces Fri Aug 17 21:53:58 2007 @@ -22,11 +22,11 @@ Namespace definition does the following: All class and function names inside are automatically prefixed with namespace name. Inside namespace, local name always takes precedence over -global name. Several files may be included into the same namespace. +global name. Several files may be using the same namespace. The namespace declaration statement must be the very first statement in -file. The only exception is "declare" statement that can be used before. +the file. The only exception is "declare" statement that can be used before. -Every class and function from namespace can be referred to by the full name +Every class and function in a namespace can be referred to by the full name - e.g. Zend::DB::Connection or Zend::DB::connect - at any time. <?php @@ -41,6 +41,7 @@ require 'Zend/Db/Connection.php'; import Zend::DB; import Zend::DB::Connection as DbConnection; + $x = new Zend::DB::Connection(); $y = new DB::connection(); $z = new DbConnection(); @@ -50,20 +51,23 @@ import statement only defines name aliasing. It may create name alias for namespace or class. The simple form of statement "import A::B::C::D;" is equivalent to "import A::B::C::D as D;". Import statement can be used at any -time in global scope (not inside function/class) and takes effect from the -point of definition down to the end of file. It is recommended however to +time in the global scope (not inside function/class) and takes effect from +the point of definition down to the end of file. It is recommended however to place imports at the beginning of the file. Import statements have effect -only on file where they are written. +only on the file where they appear. The special "empty" namespace (:: prefix) is useful as explicit global namespace qualification. All class and function names started from :: -interpreted as global. <?php namespace A::B::C; +interpreted as global. + +<?php +namespace A::B::C; $con = ::mysql_connect(...); ?> -A special constant __NAMESPACE__ indicates the current namespace. It can be -used to construct fully-qualified names to pass them as callbacks. +A special constant __NAMESPACE__ contains the name of the current namespace. +It can be used to construct fully-qualified names to pass them as callbacks. <?php namespace A::B::C; @@ -74,37 +78,37 @@ set_error_handler(__NAMESPACE__ . "::foo"); ?> -In global namespace __NAMESPACE__ constant has value of empty string. +In global namespace __NAMESPACE__ constant has the value of empty string. -Names inside namespace are resolved according to the following rules. +Names inside namespace are resolved according to the following rules: 1) all qualified names are translated during compilation according to -current import rules. So if we have "import A::B::C;" and then "C::D::e();" -it is translated to "A::B::C::D::e()" +current import rules. So if we have "import A::B::C" and then "C::D::e()" +it is translated to "A::B::C::D::e()". 2) unqualified class names translated during compilation according to -current import rules. So if we have "import A::B::C;" and then "new C();" it -is translated to "new A::B::C()" - -3) calls to unqualified functions that are defined in current namespace -interpreted as calls to corresponding functions -4) calls to unqualified functions that are not defined in current namespace -are resolved in run-time. The call to function foo() inside namespace (A::B) -first tries to find and call function from current namespace A::B::foo() and -if it doesn't exist PHP tries to call internal function foo(). Note that -using foo() in namespace you can call only internal PHP functions, however -using ::foo() you are able to call any function from global namespace. +current import rules. So if we have "import A::B::C" and then "new C()" it +is translated to "new A::B::C()". +3) inside namespace, calls to unqualified functions that are defined in +current namespace (and are known at the time the call is parsed) are +interpreted as calls to these namespace functions. +4) inside namespace, calls to unqualified functions that are not defined +in current namespace are resolved at run-time. The call to function foo() +inside namespace (A::B) first tries to find and call function from current +namespace A::B::foo() and if it doesn't exist PHP tries to call internal +function foo(). Note that using foo() inside namespace you can call only +internal PHP functions, however using ::foo() you are able to call any +function from the global namespace. 5) unqualified class names are resolved at run-time. E.q. "new Exception()" -first tries to use (end even __autoload()) class from current namespace and -in case of failure uses internal PHP class. Note that using "new A" in -namespace you can call only create class from this namespace or -internal PHP class, however using "new ::A" you are able to create any class -from global namespace +first tries to use (and autoload) class from current namespace and in case +of failure uses internal PHP class. Note that using "new A" in namespace +you can only create class from this namespace or internal PHP class, however +using "new ::A" you are able to create any class from the global namespace. 6) Calls to qualified functions are resolved at run-time. Call to -"A::B::foo()" first tries to call function foo() from namespace "A::B", then -it tries to find class "A::B (__autoload() it if necessary) and call its +A::B::foo() first tries to call function foo() from namespace A::B, then +it tries to find class A::B (__autoload() it if necessary) and call its static method foo() 7) qualified class names are interpreted as class from corresponding -namespace. So "new A::B::C()" creates class "C" from namespace "A::B". +namespace. So "new A::B::C()" refers to class C from namespace A::B. Examples -------- @@ -123,7 +127,7 @@ ?> <?php -namespcae A; +namespace A; new A(); // first tries to create object of class "A" from namespace "A" (A::A) // then creates object of internal class "A" ?> @@ -150,27 +154,21 @@ TODO ==== -* Rename namespaces to packages? - * Support for namespace constants? -* support for "import ns::*"? - * performance problems - - calls to internal functions in namespaces are slower, because PHP first - lools for such function in current namespace - + looks for such function in current namespace - calls to static methods are slower, because PHP first tries to look for corresponding function in namespace -* Extend the Reflection API - - * Add ReflectionPackage class - +* Extend the Reflection API? + * Add ReflectionNamespace class + getName() + getClasses() + getFunctions() + getFiles() - * Add getNamespace() methods to ReflectionClass and ReflectionFunction + +* Rename namespaces to packages? +
-- PHP CVS Mailing List (http://www.php.net/) To unsubscribe, visit: http://www.php.net/unsub.php