Common Uses of PHP
PHP performs system functions, i.e. from files on a system it can create, open, read, write, and close them.
PHP can handle forms, i.e. gather data from files, save data to a file, through email you can send data, return data to the user.
You add, delete and modify elements within your database through PHP.
Access cookies variables and set cookies.
Using PHP, you can restrict users to access some pages of your website.
It can encrypt data.
Features of PHP
Cross Platform Compatibility – It is used to create the desktop application by using advanced PHP features.
Variables – PHP allows changing the variable name dynamically by using variable variables.
Magic Method – PHP has built in methods starts with __ (double underscore). These methods can’t be called directly. Rather, it will be called on the event basis. For example, __clone() will be called, when the clone keyword is used.
Extended Regular Expression – PHP provides REGEX methods with extensive parsing and pattern matching mechanism with remarkable speed.
Why Do We Use PHP?
PHP stands for Hypertext Preprocessor and is a server-side programming language. There are many reasons to use PHP for server-side programming, firstly it is a free language with no licensing fees so the cost of using it is minimal. A good benefit of using PHP is that it can interact with many different database languages including MySQL. We work with MySQL at Blue line media since this is also a free language so it makes sense to use PHP. Both PHP and MySQL are compatible with an Apache server which is also free to license. PHP can also run on Windows, Linux and Unix servers.
Due to all these languages being free it is cheap and easy to setup and create a website using PHP.
PHP also has very good online documentation with a good framework of functions in place. This makes the language relatively easy to learn and very well supported online. There are countless forums and tutorials on various PHP methods and problems so it is usually very easy to find help if you need it.
PHP Latest Version
Why 7 and not 6? Let’s just say, unicode didn’t go so well. As with many projects, requirements were not well defined and people couldn’t agree on things, so the project ground to a halt. Besides unicode, for encoding special and international characters, almost all the features being discussed for PHP 6 were eventually implemented in PHP 5.3 and later, so we really didn’t miss anything else. Through it all, many things were learned and a new process for feature requests was put in place. When the feature set for a major release was accepted, it was decided, to avoid confusion with a dead project, and to skip to version 7 for the latest release.
So what makes PHP 7 so special?
Speed:-
The developers worked very hard to refactor the PHP codebase in order to reduce memory consumption and increase performance. And they certainly succeeded.
Benchmarks for PHP 7 consistently show speeds twice as fast as PHP 5.6 and many times even faster! Although these results are not guaranteed for your project, the benchmarks were tested against major projects, Drupal and WordPress, so these numbers don’t come from abstract performance tests.
With statistics that show 25% of the web being run on WordPress, this is a great thing for everyone.
Type Declarations:- Type declarations simply means specifying which type of variable is being set instead of allowing PHP to set this automatically. PHP is considered to be a weak typed language. In essence, this means that PHP does not require you to declare data types. Variables still have data types associated with them but you can do radical things like adding a string to an integer without resulting in an error. Type declarations can help you define what should occur so that you get the expected results. This can also make your code easier to read. We’ll look at some specific examples shortly.
Since PHP 5, you can use type hinting to specify the expected data type of an argument in a function declaration, but only in the declaration. When you call the function, PHP will check whether or not the arguments are of the specified type. If not, the run-time will raise an error and execution will be halted. Besides only being used in function declarations, we were also limited to basically 2 types. A class name or an array.
Here’s an example:
function enroll(Student $student, array $classes) {
foreach ($classes as $class) {
echo "Enrolling " . $student->name . " in " . $class;
}
}
enroll("name",array("class 1", "class 2")); // Catchable fatal error: Argument 1 passed to enroll() must be an instance of Student, string given
enroll($student,"class"); // Catchable fatal error: Argument 2 passed to enroll() must be of the type array, string given
enroll($student, array("class 1", "class 2"));
If we were to create a function for enrolling students, we could require that the first argument be an object of the student class and the second argument to be an array of classes. If we tried to pass just the name instead of an object we would get a fatal error. If we were to pass a single class instead of an array, we would also get an error. We are required to pass a student object and an array.
function stringTest(string $string) {
echo $string;
}
stringTest("definitely a string");
If we were to try to check for a scalar variable such as a string, PHP 5 expects it to be an object of the class string, not the variable type string. This means you’ll get a Fatal error: Argument 1 passed to stringTest() must be an instance of string, string given.
Scalar Type Hints:- With PHP 7 we now have added Scalar types. Specifically: int, float, string, and bool.
By adding scalar type hints and enabling strict requirements, it is hoped that more correct and self-documenting PHP programs can be written. It also gives you more control over your code and can make the code easier to read.
By default, scalar type-declarations are non-strict, which means they will attempt to change the original type to match the type specified by the type-declaration. In other words, if you pass a string that starts with a number into a function that requires a float, it will grab the number from the beginning and remove everything else. Passing a float into a function that requires an int will become int(1).
Return Type Declarations
PHP 7 also supports Return Type Declarations which support all the same types as arguments. To specify the return type, we add a colon and then the type right before the opening curly bracket.
function getTotal(float $a, float $b) : float {
If we specify the return type of float, it will work exactly like it has been in the previous 2 examples since the type being returned was already a float. Adding the return type allows you to to be sure your function returns what is expected as well as making it easy to see upfront how the function works.
Non-strict int
If we specify the return type as int without strict types set, everything will work the same as it did without a return type, the only difference is that it will force the return to be an int. In the third call the return value will truncate to 3 because the floating point will be dropped
Strict int
If we turn strict types on, we’ll get a Fatal error: Uncaught TypeError: Return value of getTotal() must be of the type integer, float returned. In this case we’ll need to specifically cast our return value as an int. This will then return the truncated value.
declare(strict_types=1);
function getTotal(float $a, float $b) : int {
// return $a + $b;
// Fatal error: Uncaught TypeError: Return value of getTotal() must be of the type integer, float returned
return (int)($a + $b); // truncate float like non-strict
}
getTotal(2.5, 1); // changes int(1) to float(1.0) and returns int(3)
Why?
The new Type Declarations can make code easier to read and forces things to be used in the way they were intended. Some people prefer to use unit testing to check for intended use instead. Having automated tests for your code is highly recommended, but you can use both unit tests and Type Declarations. Either way, PHP does not require you to declare types but it can definitely make code easier to read. You can see right at the start of a function, what is required and what is returned.
Error Handling The next feature we going to cover are the changes to Error Handling. Handling fatal errors in the past has been next to impossible in PHP. A fatal error would not invoke the error handler and would simply stop your script. On a production server, this usually means showing a blank white screen, which confuses the user and causes your credibility to drop. It can also cause issues with resources that were never closed properly and are still in use or even locked.
In PHP 7, an exception will be thrown when a fatal and recoverable error occurs, rather than just stopping the script. Fatal errors still exist for certain conditions, such as running out of memory, and still behave as before by immediately stopping the script. An uncaught exception will also continue to be a fatal error in PHP 7. This means if an exception thrown from an error that was fatal in PHP 5 goes uncaught, it will still be a fatal error in PHP 7.
I want to point out that other types of errors such as warnings and notices remain unchanged in PHP 7. Only fatal and recoverable errors throw exceptions.
In PHP 7, Error and Exception both implement the new Throwable class. What that means is that they basically work the same way. And also, you can now use Throwable in try/catch blocks to catch both Exception and Error objects. Remember that it is better practice to catch more specific exception classes and handle each accordingly. However, some situations warrant catching any exception (such as for logging or framework error handling). In PHP 7, these catch-all blocks should catch Throwable instead of Exception.
The Throwable interface is implemented by both Exception and Error. Under Error, we now have some more specific error. TypeError, ParseError, A couple arithmetic errors and an AssertionError.
Throwable Interface:- If Throwable was defined in PHP 7 code, it would look like this
interface Throwable
{
public function getMessage(): string;
public function getCode(): int;
public function getFile(): string;
public function getLine(): int;
public function getTrace(): array;
public function getTraceAsString(): string;
public function getPrevious(): Throwable;
public function __toString(): string;
}
If you’ve worked with Exceptions at all, this interface should look familiar. Throwable specifies methods nearly identical to those of Exception. The only difference is that Throwable::getPrevious() can return any instance of Throwable instead of just an Exception.
To catch any exception in PHP 5.x and 7 with the same code, you would need to add a catch block for Exception AFTER catching Throwable first. Once PHP 5.x support is no longer needed, the block catching Exception can be removed.
Virtually all errors in PHP 5 that were fatal, now throw instances of Error in PHP
Type Errors:- A TypeError instance is thrown when a function argument or return value does not match a type declaration. In this function, we’ve specified that the argument should be an int, but we’re passing in strings that can’t even be converted to ints. So the code is going to throw a TypeError.
function add(int $left, int $right) {
return $left + $right;
}
try {
echo add('left','right');
} catch (\TypeError $e) {
// Log error and end gracefully
echo $e->getMessage(), "\n";
// Argument 1 passed to add() must be of the type integer, string given
}
This could be used for adding shipping and handling to a shopping cart. If we passed a string with the shipping carrier name, instead of the shipping cost, our Parse Errors final total would be wrong and we would chance losing money on the sale.
Parse Errors:- A ParseError is thrown when an included/required file or eval()’d code contains a syntax error. In the first try we’ll get a ParseError because we called the undefined function var_dup instead of var_dump. In the second try, we’ll get a ParseError because the required file has a syntax error.
try {
$result = eval("var_dup(1);");
} catch (\Error $e) {
echo $e->getMessage(), "\n";
//Call to undefined function var_dup()
}
try {
require 'file-with-parse-error.php';
} catch (ParseError $e) {
echo $e->getMessage(), "\n";
//syntax error, unexpected end of file, expecting ',' or ';'
}
Let’s say we check if a user is logged in, and if so, we want to include a file that contains a set of navigation links, or a special offer. If there is an issue with that include file, catching the ParseError will allow us to notify someone that that file needs to be fixed. Without catching the ParseError, the user may not even know they are missing something.
New Operators
Spaceship Operator
PHP 7 also brings us some new operators. The first one we’re going to explore is the spaceship operator. With a name like that, who doesn’t want to use it? The spaceship operator, or Combined Comparison Operator, is a nice addition to the language, complementing the greater-than and less-than operators.
The spaceship operator is put together using three individual operators, less than, equal, and greater than. Essentially what it does is check the each operator individually. First, less than. If the value on the left is less than the value on the right, the spaceship operator will return -1. If not, it will move on to test if the value on the left is EQUAL to the value on the right. If so, it will return 0. If not it will move on to the final test. If the value on the left is GREATER THAN the value on the right. Which, if the other 2 haven’t passed, this one must be true. And it will return 1.
The most common usage for this operator is in sorting.
Null Coalesce Operator
Another new operator, the Null Coalesce Operator, is effectively the fabled if-set-or. It will return the left operand if it is not NULL, otherwise it will return the right. The important thing is that it will not raise a notice if the left operand is a non-existent variable.
$name = $firstName ?? "Guest";
For example, name equals the variable firstName, double question marks, the string “Guest”.
If the variable firstName is set and is not null, it will assign that value to the variable name. Or else it will assign “Guest” the variable name.
Before PHP 7, you could write something like
if (!empty($firstName)) $name = $firstName;
else $name = "Guest";
What makes this even more powerful, is that you can stack these! This operation will check each item from left to right and when if finds one that is not null it will use that value.
$name = $firstName?? $username ?? $placeholder ?? “Guest”;
This operator looks explicitly for null or does not exist. It will pick up an empty string.
What is Easy User-land CSPRNG?
User-land refers to an application space that is external to the kernel and is protected by privilege separation, API for an easy to use and reliable Cryptographically Secure Pseudo Random Number Generator in PHP.
Essentially secure way of generating random data. There are random number generators in PHP, rand() for instance, but none of the options in version 5 are very secure. In PHP 7, they put together a system interface to the operating system’s random number generator. Because we can now use the operating system’s random number generator, if that gets hacked we have bigger problems. It probably means your entire system is compromised and there is a flaw in the operating system itself.
Secure random numbers are especially useful when generating random passwords or password salt.
What does this look like for you as a developer? You now have 2 new functions to use: random_int and random_bytes.
Random Bytes:- When using random_bytes, you supply a single argument, length, which is the length of the random string that should be returned in bytes. random_bytes then return a string containing the requested number of cryptographically secure random bytes. If we combine this with something like bin2hex, we can get the hexadecimal representation.
$bytes = random_bytes(5); // length in bytes
var_dump(bin2hex($bytes));
// output similar to: string(10) "385e33f741"
These are bytes not integers. If you are looking to return a random number, or integer, you should use the random_int function.
Random Int When using random_int you supply 2 arguments, min and max. This is the minimum and maximum numbers you want to use.
For example:
random_int(1,20);
Would return a random number between 1 and 20, including the possibility of 1 and 20.
If you are using the rand function for anything even remotely secure, you’ll want to change the rand function to random_int.
Is PHP Scope Is Better Than Other Web Development Programming?
Php has good career opportunity, before few years ago big MNC companies like, Infosys, Wipro, TCS prefer to hire Java programmers and there was very low recruitment of people with profile of php.
But now lot’s of big companies come with php projects and increase the recruitment in this field as compare to Java and Dot net programmers. You may also check the growth of php
When it comes to variety, php developers works on Most of popular are based on its frameworks and CMS and they all are very valuable and most demanded from eCommerce to blogging industry. That’s right only php will not work fine, you must have good knowledge of php frameworks like, Zend, Laravel, Nette, Symfony2 and others.
Most of Popular Online Portals Are Based On PHP
That’s right most of popular sites like Facebook, Yahoo, flicker, Digg, Delicious and many more. Know why I am adding this point.
I am just tell you one thing, that there are lots of small and popular online web applications based on php are running online and they all are managed and addons by php developers. Means you have lots of opportunity to work with your dream companies
Build Career with PHP Freelancing Services
There is multiple scope with php, you are not limited to jobs only for earning money. After getting good experience in this field you can start your own php based services as a full time freelancer or part time with your regular jobs. You can take them projects from online bidding sites like, Upwork, Elance and others.
Everything you have to do is, after completing your office time spend your time on build beautiful profile on online bidding sites and bid on relevant projects you can complete and perform the task in free time after office work and can earn a lot.
Conclusion: - At last I just want to say only one thing, that if you need to build your career in any programming language, php is most demanded today. But go with your interest, choose the career with your personal needs and do hard work.
PHP Frameworks
PHP is one of the most favored server-side scripting languages known for its simplicity, PHP frameworks complement PHP, by providing developers with some pre-built modules, a platform to create robust, reusable components, and by enabling faster development cycles.
PHP frameworks give the users a basic structure, with some pre-built modules to develop robust web applications faster. These frameworks enforce coding standards and development guidelines hence standardizing the process and stabilizing the product.
PHP frameworks use Model View Controller(MVC) architecture, where the development of the business logic is independent of both the underlying data and the overlaying presentation view. MVC helps developers to focus on their specific areas without worrying if their code will adversely be affecting the development of the other modules or not. This breaking up of the development process into independent modules increases the speed of the entire development process and improves the stability and quality of the product.
Advantages of Using Frameworks
Rapid development using the libraries and tools provided by the framework
Easy to upgrade and maintain the developed applications
Excellent community support
Security features such as Input filtering and Output encoding
There are a wide variety of PHP frameworks, many of them are open source frameworks. The most popular open-source PHP frameworks are:
Laravel
As far as frameworks go, Laravel takes the cake with the most number of personal and professional users.
Symfony
One of the older players, Symfony is considered to be a stable base for many other newer frameworks including Laravel. The quick adaptability and widely used documentation of Symfony makes it one of the most dependable PHP frameworks.
CodeIgniter
A simple, powerful PHP framework, CodeIgniter is known for its flexibility and hassle-free installation. CodeIgniter is supposed to have an easy learning curve thus making it the best choice for beginners.
CakePHP
One of the oldest frameworks, CakePHP has retained its strong user base and has continued to grow. It also boasts of an impressive portfolio consisting of brands such as BMW and Express.
Zend Framework
Zend is considered to be a very stable and robust framework recommended for big, enterprise-level projects. It has a wide variety of features which facilitates the development of quality applications for enterprise clients.