Call Us Today! (443) 500-7624
Programming is part of developing websites, and when you use Drupal to develop your website, it would be a very good idea, to learn programming. In today’s article we are going to talk about Object-Oriented in PHP (OOP PHP or OO-PHP) in Drupal 8; which is a system of writing code, where developers are required to structure their code into reusable chunks of code.
An object is a piece of code that does something for an application, for example, a wheel is part of the car and does something for the car, so that the car is usable; however, the wheel is not the car it just forms part of the car. Well objects function the same way, in the sense that they do something for the application, such connecting to a database or calling a service to perform an operation for the application.
Complex applications such as Drupal, are better organized into classes or modular code. Classes can be used throughout a system, to keep things in order and well maintained. In order to understand how to implement custom functionality, the architecture of modules, and the various forms they can take, developers should have a solid understanding of OOP PHP.
In Drupal 8 for example, OOP PHP is used heavily in its code base, because it provides so many benefits, such as maintainability and scalability. In the modern OO-PHP developers have at their disposal, things such as encapsulation, inheritance, interface, OO-PHP and design patterns, that developers can use to improve their skill.
OO-PHP can better serve Drupal 8 to be a better tool for its users, so that developers can build better websites. Hopefully you already know PHP, because our discussion is focused more on Drupal 8 and all the technologies it has in order to better serve its users.
We are going to talk now about YAML. The human-readable data serialization format, known as YAML, is heavily used in Drupal 8; therefore, if you’d like to use Drupal 8, you’d have to know and understand YAML syntax.
YAML stands for YAML Ain’t Markup Language, although many people confuse this technology with a markup language. YAML is supported by many programming languages, it is similar to JSON, because it is a superset of JSON, which means that you can use JSON type syntax to write your YAML files.
It makes sense for th Drupal 8 project to use YAML, because Symphony already uses it, and Drupal 8 is built on top of Symphony. All YAML files are represented as key, separator and the value, like this (name: Joe Shindelar). New lines and tabbed characters are syntactically important, and it can support different data types, such as string, int, float, Boolean, null and UNIX timestamp. Compound data types or collections are also supported in YAML, this is an associative array or a list. It is also important that you keep your indentation correct in a YAML file, so that it can be utilized by Drupal.
Another important component of Drupal 8 is Symphony, which is written in PHP as an application framework that is used to build website applications. Reusable components are part of the Symphony framework, which are used by Drupal 8 core library. In Symphony there is a buzz word known as Bundles, which is a folder, where we put code, such as a feature that can do some registration validation stuff. Bundles can be used to put anything, such as PHP code, configuration files, templates, CSS files and other people’s bundles.
Another very important component in Drupal 8, is Twig, which is the default template engine used in Drupal 8. As developers using Drupal 8, you’d need to know twig to make changes, to the output of your Drupal website pages.
The PHP templating for Drupal 8, is used to output PHP variables inside HTML, by using double curly braces. So you’d set up your variable in your PHP file, then when you are ready to print it on your Twig template, then you would follow this syntax {{ variable_name }}, you can also use the {{% %}} to do something such as a for loop or a conditional statement, and if you want to comment something our you would use {{# #}}.
Thank you for reading this article!!!
\Drupal\Component\Plugin\PluginManagerInterface,Implements all plugin managers, and this piece of code extends these three pieces of code, which are the basis for any new plugin manager.
\Drupal\Component\Plugin\Discovery\DiscoveryInterface, \Drupal\Component\Plugin\Factory\FactoryInterface and, \Drupal\Component\Plugin\Mapper\MapperInterface.The plugin.manager.* a piece of code is used to generate plugin manager services and from the service container, a copy of the plugin manager can be requested. Example:
$example_manager = \Drupal::service('plugin.manager.example');Once a developer has identified the plugin manager needed, to complete a task, then that developer has to start, by locating the name of the plugin manager service he/she needs. The controller will be the place where, a developer can inject their plugin manager services, and this is the Drupal way of doing things. The code below is a controller file, located under custom_module/src/Controller, it is very important that you get those names and file directory correct, for Drupal to recognize your controller and plugin.
<?php namespace Drupal\plugin_type_example\Controller; use Drupal\Core\Controller\ControllerBase; use Drupal\plugin_type_example\SandwichPluginManager; use Symfony\Component\DependencyInjection\ContainerInterface; /** * Controller for our example pages. */ class PluginTypeExampleController extends ControllerBase { /** * The sandwich plugin manager. * * We use this to get all of the sandwich plugins. * * @var \Drupal\plugin_type_example\SandwichPluginManager */ protected $sandwichManager; /** * Constructor. * * @param \Drupal\plugin_type_example\SandwichPluginManager $sandwich_manager * The sandwich plugin manager service. We're injecting this service so that * we can use it to access the sandwich plugins. */ public function __construct(SandwichPluginManager $sandwich_manager) { $this->sandwichManager = $sandwich_manager; } /** * {@inheritdoc} * * Override the parent method so that we can inject our sandwich plugin * manager service into the controller. * * For more about how dependency injection works read https://www.drupal.org/node/2133171 */ public static function create(ContainerInterface $container) { // Inject the plugin.manager.sandwich service that represents our plugin // manager as defined in the plugin_type_example.services.yml file. return new static($container->get('plugin.manager.sandwich')); } }All defined plugins have information that can aid our application development to move forward faster. All that information from defined plugins is available to developers when they can make calls to the getDefinitions method. Enabled modules, can be used to locate all plugin definitions of the type in question, through the discovery handler . When the discovery handler is not used to retrieve data, then the DefaultPluginManager is used to retrieve the data from the cache if the data is available there. A good example of is in the code below, watch how the definitions of a plugin can be obtained in the code.
// Get the list of all the sandwich plugins defined on the system from the // plugin manager. Note that at this point, what we have is *definitions* of // plugins, not the plugins themselves. $sandwich_plugin_definitions = $this->sandwichManager->getDefinitions(); // Let's output a list of the plugin definitions we now have. $items = array(); foreach ($sandwich_plugin_definitions as $sandwich_plugin_definition) { // Here we use various properties from the plugin definition. These values // are defined in the annotation at the top of the plugin class: see // \Drupal\plugin_type_example\Plugin\Sandwich\ExampleHamSandwich. $items[] = t("@id (calories: @calories, description: @description )", array( '@id' => $sandwich_plugin_definition['id'], '@calories' => $sandwich_plugin_definition['calories'], '@description' => $sandwich_plugin_definition['description'], )); } // Add our list to the render array. $build['plugin_definitions'] = array( '#theme' => 'item_list', '#title' => 'Sandwich plugin definitions', '#items' => $items, );When a list of plugin types is desired by a developer he/she may want to use the method above to accomplish this task. The unique ID of a plugin can be utilized in order to retrieve the definition of the plugin in question, calling the getDefinition($plugin_id) method. // If we want just a single plugin definition, we can use getDefinition(). // This requires us to know the ID of the plugin we want. This is set in the // annotation on the plugin class: see \Drupal\plugin_type_example\Plugin\Sandwich\ExampleHamSandwich. $ham_sandwich_plugin_definition = $this->sandwichManager->getDefinition('meatball_sandwich'); In order to instantiate and use an individual plugin object, the createInstance($plugin_id) method can be used. It is not good practice to instantiate a plugin object directly, instead, the plugin manager should be used to do so. Understanding how instances of a plugin are created requires that you see it in action, in the code below.
// To get an instance of a plugin, we call createInstance() on the plugin // manager, passing the ID of the plugin we want to load. Let's output a // list of the plugins by loading an instance of each plugin definition and // collecting the description from each. $items = array(); // The array of plugin definitions is keyed by plugin id, so we can just use // that to load our plugin instances. $sandwich_plugin_definitions = $this->sandwichManager->getDefinitions(); foreach ($sandwich_plugin_definitions as $plugin_id => $sandwich_plugin_definition) { // We now have a plugin instance. From here on it can be treated just as // any other object; have its properties examined, methods called, etc. $plugin = $this->sandwichManager->createInstance($plugin_id); $items[] = $plugin->description(); }All the code on this tutorial was taken from Drupalize.me. Thank you for reading this article!!!
Phone: (443) 500-7624
Email: admin@kinginfolife.com
Address: Baltimore, MD 21206
All Rights Reserved | KING INFO LIFE