Why should I even use Laravel?

Because it is a super clean, easy to use PHP framework. My personal experience (this is subjective) told me that it is way easier to understand than the whole Symfony framework (Laravel is built on Symfony) or the Zend Frameworks. Symfony and Zend are both great frameworks, for sure, but Laravel offers you simplicity.

Laravel enables you to use best practice coding techniques for object-oriented programming. It comes with a powerful set of features for building solid web applications and assists you with solving common as well as complex problems.

Why shall Laravel be used with the newest PHP version (best will be the upcoming PHP 7.4)?

Laravel makes heavy use of modern features within the PHP language. It is completely object oriented and uses e.g. typed input parameters which came with PHP 7.

The real great thing about PHP 7.4 is that it offers typed properties, covariant returns (more generic in subclass) and contravariant input parameters (more specific in subclass). This is extremely powerful (you should read more about it)!

What is Dependency Injection?

Definition (Wikipedia): “In software engineering, dependency injection is a technique whereby one object supplies the dependencies of another object. A “dependency” is an object that can be used, for example a service. Instead of a client specifying which service it will use, something tells the client what service to use. The “injection” refers to the passing of a dependency (a service) into the object (a client) that would use it. The service is made part of the client’s state. Passing the service to the client, rather than allowing a client to build or find the service, is the fundamental requirement of the pattern.

The intent behind dependency injection is to achieve Separation of Concerns of construction and use of objects. This can increase readability and code reuse.

Dependency injection is one form of the broader technique of inversion of control. The client delegates the responsibility of providing its dependencies to external code (the injector). The client is not allowed to call the injector code; it is the injecting code that constructs the services and calls the client to inject them. This means the client code does not need to know about the injecting code, how to construct the services or even which actual services it is using; the client only needs to know about the intrinsic interfaces of the services because these define how the client may use the services. This separates the responsibilities of use and construction.”

That means that an object either is provided with another required object within its constructor or it just specifies some interface which is used for type hinting in constructors or methods.

The purpose of this is to get rid of dependencies and to achieve loose coupling (and high cohesion).

What is a Service Container and what is the Laravel Service Container doing?

A Service Container (or dependency injection container) is simply a PHP object that manages the instantiation of services (i.e. objects). The Service Container in Laravel is a Dependency Injection Container and a Registry for the application. The advantages of using a Service Container over creating manually your objects are.

It is often called with App::bind App:make etc.

The service provider is creating concrete classes automatically when required.

Class dependencies can be managed on object creation and it is used as a registry.

Laravel does this with binding certain services to the App:

$this->app->bind('FooService', \App\Services\FooService::class);

Essentially we are telling Laravel: “Hey store this object in your bag of tricks and label it as FooService”. Remember to always bind your services within the register method of your service providers.

There are also events in the service container where somebody can register to.

What is a Service Provider?

Core part of a Laravel application, resides in Providers directory. Has usually a special purpose like e.g. Authentication, Translation, ….

Service providers are usually registered on application bootstrap. All service providers are registered in app/config.php.

A service provider has a register and a boot method. The register method is called early and is for registering with the Service Container, the boot method is called after all Services has been registered and therefore you can use all Service Container within it.

What is „type hinting“?

Methods / functions with typed input parameters (optional in PHP).

What is (dynamic) binding in Laravel?

Laravel usually means binding a service provider to the service container. Almost all service container bindings will be registered within service providers.

What is middleware?

A layer between a client request from the frontend and a resource (data) in the backend. Therefore the logical part oft he backend which glues certain programs / part of a program together. It simplifies backend resource requests.

Middleware also serves the purpose of load balancing (distributing requests), concurrency, securring the backend,  …

Laravel offers many Middleware objects. One middleware for instance is for authentication, but you can also use middleware for certain headers for instance.

What is a Facade?

A Facade is a programming design pattern. It usually offers a simplified standardized interface to a certain set of sub-systems.

In Laravel: Facades provide a “static” interface to classes that are available in the application’s service container. Laravel ships with many facades which provide access to almost all of Laravel’s features. Laravel facades serve as “static proxies” to underlying classes in the service container, providing the benefit of a terse, expressive syntax while maintaining more testability and flexibility than traditional static methods.

Examples for Facades in Laravel are calls to App::, Auth::, DB::, Cookie:: …

Facades can be useful because they are not required in class constructors, but they can also make an application complicated to maintain in case they get to large.

What is a Contract in Laravel?

Laravel’s Contracts are a set of interfaces that define the core services provided by the framework. The Illuminate\Contracts\Queue\Queue contract i.e. defines the methods needed for queueing jobs, while the Illuminate\Contracts\Mail\Mailer contract defines the methods needed for sending e-mail.

Contracts are often imported with the use keyword and used (e.g. in the constructor or some method). It is easy to write alternative Contract implementations and therefore they can be replaced easily.

What is PHP artisan?

PHP artisan is command line tool that makes your life easier. In fact, very much easier while working with Laravel. If you know about any MVC framework, you would know what I’m about to say, it can create models, controllers, seeders, migrations and many other things with minimum (or maximum) boilerplate code. It can also start a server and can do many other things.

How is routing working in Laravel?

Usually defined in routes/web.php (for API routs for instance routes/api.php is used). Basically defined with the Route Facade which offers the common HTTP methods and a callback function. Routes have certain rules for parameters (also wildcard), can be grouped, …

What are Controllers in Laravel?

Handling all requests within route files can be clumsy. Controllers can do the most important calls to the model/business layer and return everything properly.

What is the Request/Response object doing?

The service container can automatically inject Request/Response objects (e.g. into a certain Controller). It contains info like e.g. input parameters, cookies, and does some sanitation on it.

Routes and Controllers usually should return response objects or views. You can add headers and cookies, create downloads, define the output, …

How are views in Laravel working?

In most projects Blade is used as a template engine. The views are built with html and contain output injected by Blade.

How is validation in Laravel working?

Laravel has a powerful set of validation rules which can be performed on inputs (e.g. in Controllers).

How is Laravel to databases?

Laravel usually uses the Eloquent ORM mapper. It simplifies database communication and SQL statements with certain methods. It offers a query builder which simplifies queries.

How are migrations and seeding working in Laravel?

Migrations are like version control for your database, allowing your team to easily modify and share the application’s database schema. Migrations are typically paired with Laravel’s schema builder to easily build your application’s database schema. If you have ever had to tell a teammate to manually add a column to their local database schema, you’ve faced the problem that database migrations solve.

The Laravel Schema facade provides database agnostic support for creating and manipulating tables across all of Laravel’s supported database systems.

Laravel has a Seeder for seeding applications with defined or random data which is really helpful during development.

Be free to critizise this tutorial. Improvement ideas are always welcome! 😉 

Notice: Undefined index: not_set in /home/.sites/../../../…php on line 1

It happens if accessing the key of an array which does not exist.

There is a very similar problem with PHP objects: If you access a property of an object in PHP you just get an empty string ever knowing if the property even existed. PHP does not even throw notices in this case.

Some examples:

//
$array = array("a","b","c");
echo $array[2]; // returns "c"
echo $array[3]; // returns nothing, notice undefined index

//
$_POST["my_field"]; // returns the value if submitted, or a notice if that value was not submitted

//
$obj = new stdClass();
$obj->a = "12";
$obj->b = "whatever";

echo $obj->a; // outputs string "12"
echo $obj->c; // outputs nothing, not even a notice just empty string

In order to enable save and good programming with PHP experienced PHP developers check for type safety and save array key accesses within their applications which usually requires a lot of extra work. PHP provides some operators and methods which check for the existence of keys and properties as well as for their type safety.

Example: Check if the user has submitted the value “yes” for the field “update” from a form and the array $_POST at key update contains a string value of yes.

if(isset($_POST['update']) && $_POST['update'] === "yes")) {

}

Quite a lot of text to write right? There are a lot of native PHP methods which check for existence like isset(), property_exists(), array_key_exists() and more. Furthermore there are a lot of methods which check for type safety like is_int, is_bool etc. as well as the operators with the additional = like ===, !==.

However some time ago I somehow got annoyed by this behaviour of PHP especially. I developed a method which is especially useful in case a developer knows that a variable might not be populated and wants to set an adequate default value for this case. Furthermore I guarantees a type safe result for key/property access.

Just check out the following function and you may find it helpful, too:

/**
 * Constats representing the primitive types.
 */
class Primitive {
    const STR = 0;
    const INT = 1;
    const BOOL = 2;
    const FLOAT = 3;
}

/**
 * In case you are unsure if an array key/object property exists and you want to get a (possibly typesafe) defined result.
 * 
 * @param $var array/object: An array or object with the possible key/property
 * @param $key array/string: The key. For a multidimensional associative array, you can pass an array.
 * @param $empty: If the key does not exist, this value is returned.
 * @param $primitive: The type of the given variable (-1 for ignoring this feature).
 * 
 * @return The (sanitized) value at the position key or the given default value if nothing found.
 */
function resempty(&$var,$key,$empty="",$primitive=-1) {
    
    $tcast = function($var,$primitive) {
        switch(true):
            case $primitive === Primitive::STR:
                $var = strval($var);
                break;
            case $primitive === Primitive::INT:
                $var = intval($var);
                break;
            case $primitive === Primitive::BOOL:
                $var = boolval($var);
                break;
            case $primitive === Primitive::FLOAT:
                $var = floatval($var);
                break;
        endswitch;
        return $var;
    };

    
    if(is_object($var)) {
        if(is_array($key)) {
            $tpclass = $var;
            $dimensions = count($key);
            for($i=0;$i<$dimensions;$i++) {
                if(property_exists($tpclass,$key[$i])) {
                    if($i === $dimensions-1) {
                        return $tcast($tpclass->$key[$i],$primitive);
                    } else {
                        $tpclass = $tpclass->$key[$i];
                    }
                } else {
                    return $tcast($empty,$primitive);
                }
            }
            return $tcast($empty,$primitive);
        }

        if(property_exists($var,$key)) {
            return $tcast($var->$key,$primitive);
        }
    } else if(is_array($var)) {
        if(is_array($key)) {
            $tpar = $var;
            $dimensions = count($key);
            for($i=0;$i<$dimensions;$i++) {
                if(array_key_exists($key[$i],$tpar)) {
                    if($i === $dimensions-1) {
                        return $tcast($tpar[$key[$i]],$primitive);
                    } else {
                        $tpar = $tcast($tpar[$key[$i]],$primitive);
                    }
                } else {
                    return $tcast($empty,$primitive);
                }
            }
            return $tcast($empty,$primitive);
        }

        if(array_key_exists($key,$var)) {
            return $tcast($var[$key],$primitive);
        }
    }
    return $tcast($empty,$primitive);
}

// Examples:
resempty($array,"key"); // returns the value at postion "key" if set, otherwise empty string
resempty($obj,"key",-1,Primitive::INT); // returns an integer value, -1 in case the property of the object is not set, otherwise the integer value of the object at this place

Be free to tell me if you find this useful or if you have improvement suggestions.

However the development team “Chuck Norris” from Silicon Valley has created some sophisticated interpreter which can convert the source code of all your PHP projects into COBOL  which is considered to be the future web programming language of choice. Instead of complicated variable assignments like

$a = $b;

you can write

MOVE b TO a

now, which looks way more plausible, right? Well after all I think this is a step in the correct direction and the PHP working group has made the correct decision. Do you agree?

/** Calculate middle european summertime */
function utc_to_local_time($timestamp,$offset=0,$summertime=true) { 
	 $year = strftime("%Y", $timestamp); 
	$timestamp += (3600*intval($offset)); // add local offset
	
	// Calculate beginning and end of Summertime
	$initTime = mktime(2,0,0,3,31-date('w', mktime(2,0,0,3,31,$year)),$year); 
	$endTime = mktime(2,0,0,10,31-date('w', mktime(2,0,0,10,31,$year)),$year); 

    // Check if summertime, return adequatly
    if (($timestamp > $initTime && $timestamp < $endTime) && $summertime) { 
        return ($timestamp + 3600); 
    } else { 
        return ($timestamp); 
    } 
}

// example: Austria time
echo date("d.m.Y, H:i",utc_to_local_time($utc_time,1);

Case example

Imagine you have a blog with a dynamic number of articles, while the current number of articles is 37. You want to create an article overview yourself, with the following conditions:
1. The maximum number of articles on an overview page is 10
2. A navigation to navigate to the next and previous 10 articles is required
The result will be, that you need to have four pages:
page 1: article 1-10,
page 2: article 11-20,
page 3: article 21-30,
page 4: article 30-37

Knowing the result, it is easy to develop a navigation between these pages: You just need to know the number of articles to show on each page (usually decided when coding the script), the page you are currently on (usually passed via Post- or Get- paramters and the number of all results you have to display (usually from counting the SQL results).
But how can this result always be calculated dynamically?

The script

The following script shows the basic implementation of the page results algorithm in PHP:

/*** The three paramters ***/
// Make a query to get all your results (like posts, images, whatever)
$resultsOverall = 0;
 
// Results per page (the number of results per page to be shown)
$resultsPerPage = 10;
 
// Page number (the current page number, usually $_REQUEST['pageNumber'] or something similar)
$pageNumber = 1; 
 
if(isset($_REQUEST["pageNumber"]) && $_REQUEST["pageNumber"] > 1) {
	$pageNumber = $_REQUEST["pageNumber"];
}
 
 
/**** The logic ****/
// determine the first result to show
$resultsFrom = ($pageNumber*$resultsPerPage-$resultsPerPage+1);
 
// determine the last result to show
$resultsTo = ($resultsFrom-1)+$resultsPerPage;
 
if($resultsTo > $resultsOverall) {
	$resultsTo = $resultsOverall;
}
 
// determine number of Pages (for example to show in a navigation)
$allPages = ceil($resultsOverall / $resultsPerPage);

Save $_POST or some other array to a hidden field by converting it to the JSON-format. Use URL-encode to make sure that there will be no encoding problems.

Decode the hidden-fields’ value on the server-side. Replace the $_POST variables depending on your needs or take the new ones.

// We save previous POST values in the 'post_saver', to provide page navigation and so on
if(strlen($_POST['post_saver'])>0) {

	$previous_post_object = json_decode(urldecode($_POST['post_saver']));
	unset($_POST['post_saver']);
	
	foreach($previous_post_object as $pkey=>$pval) {
		if(strlen($_POST[$pkey]) <= 0) {
			$_POST[$pkey] = $pval;
		}
	}
}