Php load all classes in namespace

Autoloading Classes with Namespaces in PHP

Most of the developers working with OOP(Object Oriented Programming) tends to save each class definition in a separate file. In this case, developers face a big problem. They have to include lots of files at the beginning of the document. Let’s consider the following example.

Consider you are going to use several classes that are saved in separated files in your root directory.

Then create index.html in your root directory and add following code

You’ll get the above error because any programming language doesn’t find class files and include them by itself. So, you have to include all the class files before you call the class. (Usually it’s included at the beginning of the document)

But, when including files developers face below shown problem. If they use 10 classes they have to include all the class files at the beginning.

When your project grows day-by-day it may need to include 100 class files in a document. How can a developer do that in lot of documents without making a mistake? It’s impossible! To solve this problem the autoload function comes!

Autoloading

Mainly there are two ways to define a autoload function.

This will register autoload function and will try to load class files

 ); $dog = new dog(); $cat = new cat(); // static_methods below echo cow::getToken(); echo fox::$name; 

Step By Step.

• First we define the autoload function with spl_autoload_register function.
  • When a new class called the callback function triggers.
  • Then, PHP sends the class’s name as a parameter or the function and we have used it as $className
  • Then, we can use following functions to include the class file
    1. require
    2. require_once
    3. include
    4. include_once
  • All of those functions have their own pros and cons. The best one to use when autoloading is include_once
  • It won’t stop the execution if an error occurs. Also, it won’t include the same file twice. Therefore it’s used widely by developers to include class files.
  • Did you notice something unusual in the code? Nevermind! In PHP include_once ‘class.php’ is same as include_once(‘class.php’) . Use anything you like.
  • Finally we add the .php extension and include it.

  Think about the time the code new dog(); is executed. Then PHP calls the callback function. «dog» is sent as the parameter ($className). Then «dog.php» is included.

  How To Organize Your Classes Like a PRO

  How does an experienced programmer organize their class files? They use some simple tricks. Here is a simple and powerful file structure

   / ajax inc class class1.php class2.php class3.php css js images 

  Simply, save all the class files in a folder in the root («class» is recommended as the folder name).
  Then create your powerful autoload function.

  Explained.

  • Here we create an autoload function as we discussed previously. (But this function has more advantages than the previous one)
  • $_SERVER[‘DOCUMENT_ROOT’] (string) holds the path of the root folder in the server computer. This variable is set by the server when the page is requested. However, by using this trick you can use class files with any document in any sub folder.
  • As an example, think that you are using class1 in the file /ajax/update.php . When you trigger the class, the class name is added to the $className variable in the spl_autoload_function . If we use previous function (mentioned in the first part of this tutorial) it will include a file relative to the current folder, /ajax/class/class1.php . By using $_SERVER[‘DOCUMENT_ROOT’] it will include something like /web/www/public_html/class/class1.php which is an absolute path.

  Important! You must save the class files with the name of the class. Otherwise this trick won’t work.

  Autoloading Namespaces

  When a website becomes larger, it’s harder to keep all the class files in a same directory. Also we have to use very long names for files and classes, such as animal_dog_dog1_addName . It is a really bad practice. Namespaces are introduced to prevent this problem. Let’s see how it works!

  By using namespaces you can save your classes in sub folders. The file of the class name can be saved in /class/dog as well as /class/cat. Here is the file structure.

   class animals dog.php cat.php goat.php birds owl.php peacock.php pets dog.php cat.php mainClass1.php mainClass2.php mainClass3.php 

  In above file structure you can understand, different files with the same name can be saved in different locations (folders). Namespaces are based on this simple logic. Now the problem is how to autoload them? Here is how namespaces are called with PHP.

   ); $dog = new animal\dog(); $cat = new animal\cat(); // static functions animal\cat::name(); animal\cat::appearance(); 

  Step By Step.

  • First we defines the autoload function as we discussed earlier.
  • «animal\dog» will be as the $className parameter to the autoload function.
  • So, it will include /your_document_root/class/animal\dog.php . (See the back slash)
  • This autoloading function will work fine on Windows OS. But the «\» will cause errors in other operating systems.
  • Therefore we have to upgrade our autoloading function.

  Explained.

  • We have added str_replace function here
  • It matches «\» (back slash).
  • Then replaces it with the value of DIRECTORY_SEPARATOR constant. (This is a PRE-DEFINED-CONSTANT which hold a string, the directory separator according to the operating system)
  • This piece of code replaces \ to / if necessary.

  At The End

  • Always name the class file with the name of the class.
  • Use namespaces when necessary. (When the class files need to be stored in separate folders)
  • Create a powerful autoload function as we discussed above, which supports normal classes as well as namespaces.
  • It is a bad practice to add spl_autoload_register in all the php scripts. So, create a file called autoload.php and save it in the root directory (or in a directory you have include files).
  • Then you just have to include autoload.php in a php script to register the autoload function. ( include_once $_SERVER[‘DOCUMENT_ROOT’] . ‘/autoload.php’ )

  If you have any questions comment below. We are always here to help you.

  Источник

  Autoloading Classes

  The PHP autoloading feature allows you to load class files automatically in your program. PHP calls an autoloader function when you reference a class, and the autoloader function tries to figure out which file that class is in.

  

  What is autoloading

  Autoloading is the process of automatically loading PHP classes without explicitly loading them with the require() , require_once() , include() , or include_once() functions.

  1. Each class must be defined in a separate file.
  2. Name your class files the same as your classes. The class Views would be placed in Views.php , a class called Users would be stored in Users.php and so on.

  When you use the statement new ClassName() , if the class ClassName doesn’t exist (because it hasn’t been included), PHP trigger an autoloader that can then load the file ClassName.php , and the rest of the script will continue as normal without requiring to manually write the line require ‘ClassName.php’; .

  What is autoloader

  An autoloader is a function that takes a class name as an argument and then includes the file that contains the corresponding class. The following example demonstrates how you can make an autoloader function to load classes:

  Why use an autoloader

  How often have you seen code like this at the top of your PHP files?

  All too often, right? The require() , require_once() , include() , and include_once() functions load an external PHP file into the current script, and they work wonderfully if you have only a few PHP scripts.

  However, what if you need to include a hundred PHP scripts? The require() and include() functions do not scale well, and this is why PHP autoloaders are important. An autoloader is a strategy for finding a PHP class, interface, or trait and loading it into the PHP interpreter on-demand at run-time, without explicitly including files.

  __autoload() magic function

  Note: The usage of __autoload function is not recommended, it has been DEPRECATED as of PHP 7.2.0, and REMOVED as of PHP 8.0.0.

  __autoload() , a magic function, is automatically invoked by the PHP when we instantiate a class that has not already been loaded. For example:

   $object = new myClass(); # Loads the class stored in "/classes/myClass.php"

  As of PHP 7.2.0 the __autoload() function has been deprecated and removed since PHP 8.0.0. Now it is recommended to use the spl_autoload_register for that purpose instead.

  spl_autoload_register()

  PHP 5.1.2 introduced the more flexible spl_autoload_register() function in its SPL library which allows you to register multiple autoloader functions.

  Example: spl_autoload_register() as a replacement for the __autoload() function:

  ); $object = new Home(); # Loads the class "/classes/Home.php" $object = new Template(); # Loads the class "/classes/Template.php"

  Registering multiple autoloader functions for each namespace

  The spl_autoload_register() allows to create an autoload chain, a series of functions that can be called to try and load a class or interface:

  ); spl_autoload_register(function ($class) < // for Views namespace require 'path/to/views/classname.php'; >);

  Example: autoloader.php , following is the expanded version of the above code:

   >); # Registering autoloader for BrainBell namespace spl_autoload_register(function ($class) < $prefix = 'BrainBell\\'; $base_dir = __DIR__ . '/classes/brainbell/'; $len = strlen($prefix); if (strncmp($prefix, $class, $len) !== 0) < return; >$relative_class = substr($class, $len); $file = $base_dir . str_replace('\\', '/', $relative_class) . '.php'; if (file_exists($file)) < require $file; >>);

  To see if the above autoloader is working properly, create two classes BrainBell\Template and Views\Template and save them in the directory classes/brainbell/ and classes/views/ respectively.

  The classes/brainbell/Template.php file:

  message = __ClASS__; > function getMessage() < return $this->message; > function getPath() < return __DIR__; >>

  The classes/view/Template.php file:

  # File name: classes/view/Template.php namespace Views; class Template < private $message; function __construct() < $this->message = __ClASS__; > function getMessage() < return $this->message; > function getPath() < return __DIR__; >>

  Next, include the autoloader.php in the script and reference the above classes:

  getMessage().'
  '; # BrainBell\Template echo $class->getPath().'
  '; # D:\xampp\htdocs\classes\brainbell // Loading classes from Views namespace $class = new Views\Template(); echo $class->getMessage().'
  '; # Views\Template echo $class->getPath(); # D:\xampp\htdocs\classes\views

  Autoloading classes based on namespace structure

  PHP can autoload classes without needing an autoloader function if the directory structure containing the classes matches the namespaces of the classes.

  In the following example, the spl_autoload_register() tries to figure out the class files relative to the current directory path. So if your script ( example.php ) is saved in the www directory, it tries to load the views\home() class from the www/views/home.php path:

  1. Create directories/folders on your document root: classes , views and models .
  2. Create two PHP files in each folder: home.php and all.php .
  3. Create classes by writing the following code in each file:

  classes/home.php

  classes/all.php

  models/home.php

  models/all.php

  views/home.php

  classes/all.php

  get() . 
  ; $home = new views\home(); echo $home->get(). 
  ; $home = new models\home(); echo $home->get(). 
  ; $all = new classes\all(); echo $all->get(). 
  ; $all = new views\all(); echo $all->get(). 
  ; $all = new models\all(); echo $all->get(); /*Output: classes/home.php views/home.php models/home.php classes/all.php views/all.php models/all.php*/

  You can see all classes loaded without using the include or require keywords. Since PHP 5.3 , you can use spl_autoload_register() with namespaces, which means that you can organize your project and autoload your PHP classes without the require or include keyword.

  PHP OOP Tutorials:

  Источник

  Читайте также:  Java clear list util