Explore topic-wise InterviewSolutions in .

Below are the list of APPLICATION Events in Phalcon:

• Event Name--TRIGGERED
• BOOT--Executed when the application handles its first REQUEST
• beforeStartModule--Before initialize a module, only when MODULES are registered
• afterStartModule--After initialize a module, only when modules are registered
• beforeHandleRequest--Before execute the dispatch loop
• afterHandleRequest-- After execute the dispatch loop

Below are the list of Application Events in Phalcon:

Single Module Application: Single MVC applications consist of one module only. Namespaces can be USED but are not necessary.

Multi Module Application: A multi-module application USES the same DOCUMENT root for more than one module.

Single Module Application: Single MVC applications consist of one module only. Namespaces can be used but are not necessary.

Multi Module Application: A multi-module application uses the same document root for more than one module.

ODM (Object-Document Mapper) OFFERS a CRUD functionality, EVENTS, validations AMONG other services in Phalcon.

ODM (Object-Document Mapper) offers a CRUD functionality, events, validations among other services in Phalcon.

If a SERVICE container (DI) is available for Volt, you can use the services by only ACCESSING the name of the service in the template:

{# Inject the 'flash' service #}
<DIV id="messages">{{ flash.output() }}</div>
{# Inject the 'security' service #}

If a service container (DI) is available for Volt, you can use the services by only accessing the name of the service in the template:

{# Inject the 'flash' service #}
<div id="messages">{{ flash.output() }}</div>
{# Inject the 'security' service #}

Phalcon USES a powerful and fast templating engine called Volt.

Volt is an ultra-fast and designer FRIENDLY templating language written in C for PHP. It PROVIDES you a set of helpers to write views in an easy way. Volt is highly INTEGRATED with other components of Phalcon, just as you can use it as a stand-alone component in your APPLICATIONS.

Phalcon uses a powerful and fast templating engine called Volt.

Volt is an ultra-fast and designer friendly templating language written in C for PHP. It provides you a set of helpers to write views in an easy way. Volt is highly integrated with other components of Phalcon, just as you can use it as a stand-alone component in your applications.

The setVar() method is used to pass data from CONTROLLER to view TEMPLATE in Phalcon.

USAGE:- $this->view->setVar("username", $USER->username);

The setVar() method is used to pass data from controller to view template in Phalcon.

Usage:- $this->view->setVar("username", $user->username);

Zephir – ZE(nd ENGINE) Ph(p) I(nt)r(mediate) – is a high level language that eases the creation and maintainability of extensions for PHP. Zephir extensions are exported to C CODE that can be compiled and optimized by MAJOR C compilers such as gcc/clang/vc++. Functionality is EXPOSED to the PHP language

Zephir – Ze(nd Engine) Ph(p) I(nt)r(mediate) – is a high level language that eases the creation and maintainability of extensions for PHP. Zephir extensions are exported to C code that can be compiled and optimized by major C compilers such as gcc/clang/vc++. Functionality is exposed to the PHP language

Phalcon offers the object-oriented CLASSES, necessary to implement the Model, View, Controller architecture (often referred to as MVC) in your application. This design pattern is widely used by other web FRAMEWORKS and DESKTOP applications.

MVC benefits include:

• Isolation of business logic from the user interface and the database layer
• Making it clear where different types of code belong for easier maintenance

If you decide to use MVC, every request to your application resources will be managed by the MVC architecture. Phalcon classes are written in C LANGUAGE, offering a high performance approach of this pattern in a PHP based application.

Models: A model represents the information (data) of the application and the rules to manipulate that data. Models are primarily used for managing the rules of interaction with a corresponding database table. In most cases, each table in your database will correspond to one model in your application. The bulk of your application’s business logic will be concentrated in the models. Learn more

Views: Views represent the user interface of your application. Views are often HTML files with embedded PHP code that perform tasks related solely to the presentation of the data. Views handle the job of providing data to the web browser or other tool that is used to make requests from your application. Learn more

Controllers: The controllers provide the “flow” between models and views. Controllers are responsible for processing the incoming requests from the web browser, interrogating the models for data, and passing that data on to the views for presentation. 

Phalcon offers the object-oriented classes, necessary to implement the Model, View, Controller architecture (often referred to as MVC) in your application. This design pattern is widely used by other web frameworks and desktop applications.

MVC benefits include:

If you decide to use MVC, every request to your application resources will be managed by the MVC architecture. Phalcon classes are written in C language, offering a high performance approach of this pattern in a PHP based application.

Models: A model represents the information (data) of the application and the rules to manipulate that data. Models are primarily used for managing the rules of interaction with a corresponding database table. In most cases, each table in your database will correspond to one model in your application. The bulk of your application’s business logic will be concentrated in the models. Learn more

Views: Views represent the user interface of your application. Views are often HTML files with embedded PHP code that perform tasks related solely to the presentation of the data. Views handle the job of providing data to the web browser or other tool that is used to make requests from your application. Learn more

Controllers: The controllers provide the “flow” between models and views. Controllers are responsible for processing the incoming requests from the web browser, interrogating the models for data, and passing that data on to the views for presentation. 

tokens USE SESSIONS, so if you increate your SESSION it will INCREASE the totken time ASWELL.

tokens use sessions, so if you increate your session it will increase the totken time aswell.

Starting the Session: Some APPLICATIONS are session-intensive, almost any action that performs requires access to session data. There are others who access session data casually. Thanks to the service container, we can ENSURE that the session is accessed only when it’s clearly needed:

<?php

use PhalconSessionAdapterFiles as Session;

// Start the session the FIRST TIME when some component request the session service
$di-&GT;setShared(
"session",
function () {
$session = new Session();

$session->start();

return $session;
}
);

Storing/Retrieving data in Session: From a controller, a view or any other component that extends PhalconDiInjectable you can access the session service and store items and retrieve them in the following way:

<?php

use PhalconMvcController;

class UserController extends Controller
{
public function indexAction()
{
// Set a session variable
$this->session->set("user-name", "Michael");
}

public function welcomeAction()
{
// Check if the variable is defined
if ($this->session->has("user-name")) {
// Retrieve its value
$name = $this->session->get("user-name");
}
}

}

Removing/Destroying Sessions: It’s also possible remove specific variables or destroy the whole session:

<?php
use PhalconMvcController;

class UserController extends Controller
{
public function removeAction()
{
// Remove a session variable
$this->session->remove("user-name");
}

public function logoutAction()
{
// Destroy the whole session
$this->session->destroy();
}
}

Starting the Session: Some applications are session-intensive, almost any action that performs requires access to session data. There are others who access session data casually. Thanks to the service container, we can ensure that the session is accessed only when it’s clearly needed:

<?php

use PhalconSessionAdapterFiles as Session;

// Start the session the first time when some component request the session service
$di->setShared(
"session",
function () {
$session = new Session();

$session->start();

return $session;
}
);

Storing/Retrieving data in Session: From a controller, a view or any other component that extends PhalconDiInjectable you can access the session service and store items and retrieve them in the following way:

<?php

use PhalconMvcController;

class UserController extends Controller
{
public function indexAction()
{
// Set a session variable
$this->session->set("user-name", "Michael");
}

public function welcomeAction()
{
// Check if the variable is defined
if ($this->session->has("user-name")) {
// Retrieve its value
$name = $this->session->get("user-name");
}
}

}

Removing/Destroying Sessions: It’s also possible remove specific variables or destroy the whole session:

<?php
use PhalconMvcController;

class UserController extends Controller
{
public function removeAction()
{
// Remove a session variable
$this->session->remove("user-name");
}

public function logoutAction()
{
// Destroy the whole session
$this->session->destroy();
}
}

Phalcon encapsulates the specific details of each database ENGINE in DIALECTS. Those provide common functions and SQL GENERATOR to the adapters.

Class---Description

PhalconDbDialectMysql--SQL specific DIALECT for MySQL database SYSTEM

PhalconDbDialectPostgresql--SQL specific dialect for PostgreSQL database system

PhalconDbDialectSqlite--SQL specific dialect for SQLite database system

Phalcon encapsulates the specific details of each database engine in dialects. Those provide common functions and SQL generator to the adapters.

Class---Description

PhalconDbDialectMysql--SQL specific dialect for MySQL database system

PhalconDbDialectPostgresql--SQL specific dialect for PostgreSQL database system

PhalconDbDialectSqlite--SQL specific dialect for SQLite database system

PhalconValidation is an independent validation component that validates an ARBITRARY set of data. This component can be used to implement validation RULES on data OBJECTS that do not belong to a MODEL or collection.

The following example shows its basic usage:

<?php
use PhalconValidation;
use PhalconValidationValidatorEmail;
use PhalconValidationValidatorPresenceOf;
$validation = new Validation();
$validation->add(
"name",
new PresenceOf(
[
"message" => "The name is required",
]
)
);
$validation->add(
"EMAIL",
new PresenceOf(
[
"message" => "The e-mail is required",
]
)
);
$validation->add(
"email",
new Email(
[
"message" => "The e-mail is not valid",
]
)
);
$messages = $validation->validate($_POST);
if (count($messages)) {
foreach ($messages as $message) {
echo $message, "<br>";
}
}

PhalconValidation is an independent validation component that validates an arbitrary set of data. This component can be used to implement validation rules on data objects that do not belong to a model or collection.

The following example shows its basic usage:

<?php
use PhalconValidation;
use PhalconValidationValidatorEmail;
use PhalconValidationValidatorPresenceOf;
$validation = new Validation();
$validation->add(
"name",
new PresenceOf(
[
"message" => "The name is required",
]
)
);
$validation->add(
"email",
new PresenceOf(
[
"message" => "The e-mail is required",
]
)
);
$validation->add(
"email",
new Email(
[
"message" => "The e-mail is not valid",
]
)
);
$messages = $validation->validate($_POST);
if (count($messages)) {
foreach ($messages as $message) {
echo $message, "<br>";
}
}

The router component allows to define routes that are mapped to the controllers or handlers that should receive the request. A router parses a URI as per the information received.

Every router in the web application has two modes:

• MVC MODE
• Match-only mode

The first mode is IDEAL for working with MVC applications. Following is the SYNTAX to define a route in Phalcon.

$router = new Router();
// Define a route 

$router-&GT;add( 
"", 
[ 
"controller" => "", 
"ACTION" => "", 
] 
);

The router component allows to define routes that are mapped to the controllers or handlers that should receive the request. A router parses a URI as per the information received.

Every router in the web application has two modes:

The first mode is ideal for working with MVC applications. Following is the syntax to define a route in Phalcon.

$router = new Router();
// Define a route 

$router->add( 
"", 
[ 
"controller" => "", 
"action" => "", 
] 
);

Registering Namespaces:

If you’re organizing your code using namespaces, or using external libraries which do, the registerNamespaces() method provides the autoloading mechanism. It takes an associative ARRAY; the keys are namespace prefixes and their values are directories where the classes are located in. The namespace SEPARATOR will be replaced by the directory separator when the loader tries to find the classes. Always remember to add a trailing slash at the end of the paths.

Registering Directories:

The third option is to REGISTER directories, in which classes could be found. This option is not recommended in terms of performance, since Phalcon will need to perform a significant number of file stats on each folder, looking for the file with the same name as the class. It’s important to register the directories in relevance order. Remember always add a trailing slash at the end of the paths.

Registering Classes:

The last option is to register the class name and its path. This autoloader can be very useful when the folder convention of the project does not allow for easy retrieval of the file using the path and the class name. This is the fastest method of autoloading. However the more your application grows, the more classes/files need to be added to this autoloader, which will effectively make MAINTENANCE of the class list very cumbersome and it is not recommended.

Additional file extensions:

Some autoloading STRATEGIES such as “prefixes”, “namespaces” or “directories” automatically append the “php” extension at the end of the checked file. If you are using additional extensions you could set it with the method “setExtensions”.

Registering Namespaces:

If you’re organizing your code using namespaces, or using external libraries which do, the registerNamespaces() method provides the autoloading mechanism. It takes an associative array; the keys are namespace prefixes and their values are directories where the classes are located in. The namespace separator will be replaced by the directory separator when the loader tries to find the classes. Always remember to add a trailing slash at the end of the paths.

Registering Directories:

The third option is to register directories, in which classes could be found. This option is not recommended in terms of performance, since Phalcon will need to perform a significant number of file stats on each folder, looking for the file with the same name as the class. It’s important to register the directories in relevance order. Remember always add a trailing slash at the end of the paths.

Registering Classes:

The last option is to register the class name and its path. This autoloader can be very useful when the folder convention of the project does not allow for easy retrieval of the file using the path and the class name. This is the fastest method of autoloading. However the more your application grows, the more classes/files need to be added to this autoloader, which will effectively make maintenance of the class list very cumbersome and it is not recommended.

Additional file extensions:

Some autoloading strategies such as “prefixes”, “namespaces” or “directories” automatically append the “php” extension at the end of the checked file. If you are using additional extensions you could set it with the method “setExtensions”.

• app/config holds CONFIGURATION files that are used for the app. I use YAML for all static configuration that I don't want to keep in the database, usually registering them as services in the BOOTSTRAP.
• app/utilities is where I PUT helper CLASSES for my app. It has a DEDICATED namespace ("Utilities") which makes all of them easy to use.

First of all Phalcon is not LIKE any other php framework because it’s a php extension written in C. Php extension are .so files like extension=phalcon.so

Since it’s a php extension it’s always loaded if the extension is enabled in php.ini file, even with NOTHING build. And this going to make this perform fast.

The framework have no defined DIRECTORY STRUCTURE, so you can build your application in different pattern like multi-module, HMVC etc

First of all Phalcon is not like any other php framework because it’s a php extension written in C. Php extension are .so files like extension=phalcon.so

Since it’s a php extension it’s always loaded if the extension is enabled in php.ini file, even with nothing build. And this going to make this perform fast.

The framework have no defined directory structure, so you can build your application in different pattern like multi-module, HMVC etc

PhalconDi is a component implementing Dependency Injection and Location of services and it’s itself a container for them.

Since Phalcon is highly decoupled, PhalconDi is essential to integrate the different components of the framework. The DEVELOPER can also use this component to inject dependencies and manage global instances of the different classes used in the application.

Basically, this component implements the Inversion of Control pattern. Applying this, the objects do not receive their dependencies using setters or constructors, but REQUESTING a SERVICE dependency injector. This reduces the overall COMPLEXITY since there is only one way to get the required dependencies within a component.

Additionally, this pattern increases testability in the code, thus making it less prone to ERRORS.

PhalconDi is a component implementing Dependency Injection and Location of services and it’s itself a container for them.

Since Phalcon is highly decoupled, PhalconDi is essential to integrate the different components of the framework. The developer can also use this component to inject dependencies and manage global instances of the different classes used in the application.

Basically, this component implements the Inversion of Control pattern. Applying this, the objects do not receive their dependencies using setters or constructors, but requesting a service dependency injector. This reduces the overall complexity since there is only one way to get the required dependencies within a component.

Additionally, this pattern increases testability in the code, thus making it less prone to errors.

Phalcon is an OPEN source, full stack framework for PHP written as a C-extension, optimized for HIGH performance. You don't need to learn or USE the C language, since the functionality is EXPOSED as PHP classes ready for you to use.

Phalcon is an open source, full stack framework for PHP written as a C-extension, optimized for high performance. You don't need to learn or use the C language, since the functionality is exposed as PHP classes ready for you to use.