PhpStorm is the perfect solution for any web application development project or website you might be working on.
The IDE understands all the PHP language features for modern and legacy projects. It provides autocomplete suggestions, error prevention, and refactoring. Thanks to the Live Edit feature, you're able to see changes made in real-time.
Modern front-end technologies like HTML5 are supported too. This is good because it means you can enjoy cutting-edge functionality without worrying about breaking things by accident due to missing or incorrect syntax.
Symfony is an open-source PHP framework for web development that's widely used in many websites and web applications and provides a set of reusable PHP components that speeds up development. In fact, thousands of websites rely on Symphony to form the foundation of their web services and many of the leading PHP projects use Symfony components to build applications.
If you're using Symfony for web development or are interested in doing so, the Symphony Support plugin is definitely worth a look. It provides full Symfony framework and component support for IntelliJ. As such, it contains all the tools you need for Symfony development including templates, dependency injection, forms, routing, and more.
We couldn't create a list of plugins without mentioning ours. Duckly is here to make pair programming a breeze.
Duckly is a video chat tool built for developers with direct integration to the IDE so you can talk, share your code in real-time, and easily collaborate with your team. It enables remote developers to work as if they were side by side.
This plugin proves itself necessary by the day. With remote work becoming the norm throughout companies due to COVID-19, the ability to pair-program is interrupted by bad WiFi signals or background noise. Duckly provides the solution to that by allowing you and your team to share the same view while coding. Duckly is great for pair programming, code reviews, debugging sessions, and much more.
All the communication and the code-sharing sessions are P2P and encrypted, and only team members can join your calls. It never touches our servers.
Nowadays, it's just as important to document your code properly as it is to write clean, quality code. It's simple when you document your code properly, you or any other developer working with your code will always know what a class, method, or other structural element does. In PHP, you use DocBlocks to do this.
The PHP Annotations plugin makes this process easier as it provides PHP annotation support for IntelliJ. As such, it provides features like a Class import annotator, Class constants in DocTags, Auto alias import for annotation class, Goto for doc tags and property names, and so much more.
When developing PHP applications, it’s vital that you analyze your code early on in the development process to identify any issues or vulnerabilities. Sure, you can do this manually through code reviews, but you’ll typically use a static code analysis tool to make this process easier.
The PHP Inspections plugin gives you a static code analyzer for PHP in IntelliJ or PhpStorm. With the plugin, you’ll, for instance, be able to identify architecture-related issues, performance issues, security issues, and the plugin provides you with possible code construct simplifications.
In simple terms, the plugin contains all the tools you’ll need to create better code and, by implication, better applications.
If you want to extend IntelliJ’s PHP capabilities even further, you should definitely take a look at the PHP Toolbox plugin. We'd go as far as to say that this is an essential plugin if you're working with PHP in IntelliJ. It provides the “Method References” and “Type Provider” extracted from the Symfony plugin. In addition to these, it also implements some of the core functionality of PhpStorm into IntelliJ.
It also gives you more type hint variable completion variants, better callable arrays completion and navigation, global string navigation for class, method, and function syntax, and more.
.env files are extremely important to control the environment your application will be running in. In other words, they allow you to configure the environment for different stages of your application development process whether it's for staging, production, or your local environment. By configuring these files correctly, you'll ensure that your application runs as it should.
The .env Files Support plugin adds support for editing .env files to all IntelliJ-based IDEs. As such, it offers syntax highlighting, autocompletion of environment variables in .env files, Dockerfiles, and docker-compose.yml files, and the ability to go to specific declarations in your files through keyboard shortcuts.
.htaccess files are powerful configuration files that allow you to make configuration changes to your Apache servers without needing to make any changes to your server configuration files. They provide configuration directives which you place in a specific directory and these directives will then apply to that directory only.
So, just like writing code, you'll need the right tool to edit these configuration files. And here, the Apache Config plugin adds support for editing Apache configuration files to your IntelliJ-based IDE. As a result, you can expect the usual editing capabilities that your IDE offers when editing .htaccess files.
Nowadays, Docker is becoming increasingly popular because it allows developers to develop once and deploy everywhere. An added benefit of Docker is that it's light on resources compared to traditional virtual machines.
The Docker plugin provides IntelliJ with full integration with Docker. This means you can run containerized applications with Docker Compose and you’ll be downloading and building Docker images right from your IDE. It also enables you to create and run Docker containers from downloaded images or directly from a Dockerfile and you're able to use dedicated docker run configurations.
Simply put, this plugin gives you all the tools you need to deploy applications inside containers and test code in an environment similar to the one you'll use in production.
As a software developer, you’ll work with databases often. You’ll typically do this by using the specific database’s console or shell through the terminal or desktop application.
The Database Navigator plugin aims to make this easier. It adds extensive database management, development, and maintenance capabilities to IntelliJ and other IntelliJ-based IDEs.
As such, it provides both SQL and PL/SQL editors, advanced database connection management capabilities, script execution support, database object browsing, advanced navigation functionality, and more. Moreover, it supports most of the databases you’ll often work with including, MySQL, SQLite, PostgreSQL, and others.
One of the things many developers struggle with is regular expressions. And it's easy to see why, when you consider that they’re hard to read and sometimes hard to understand. More significantly, though, many developers struggle with writing regular expressions.
The RegexpTester plugin aims to make this easier as it allows you to experiment with Java regular expressions in a dynamic environment. In other words, you'll be able to write regular expressions and see instantly what their results are.
The plugin offers syntax highlighting for regular expressions and tooltips when you hover your mouse over a part of a regular expression. This, ultimately, makes it easier to not only write regular expressions but to test them as well.
Different developers have different preferences on how they like their code to be arranged. For instance, some don’t care much about the order of lines while others prefer to have it in a specific order, often alphabetically.
If you’re one of the last mentioned, then the Lines Sorter plugin is definitely for you. It adds a Sort Lines action in IntelliJ’s edit menu. So, you can just select the lines you want to sort, click on Sort Lines, and the lines of code will be sorted alphabetically.
As mentioned earlier, when developing applications, code quality is extremely important. Now, there are several tools that you can use to ensure good code quality. One of these is a static code analyzer or analysis tool. Fortunately, there are many static code analysis tools you can use when writing PHP code. These, for instance, include tools like PHPStan and Psalm.
The PHPStan/Psalm/Generics plugin brings these tools to IntelliJ. Its features include class-string parameter inspection, class-string template return type detection, PHPStan and Psalm Code quality reports directly in your IDE, and additional features for PHPStan, Psalm, and Generics.
As a developer, you know how important testing is in software development. For effective testing, however, you need the right tools. And when it comes to PHP, PHPUnit is probably the most popular unit testing framework available for the language.
The PHPUnit Enhancement plug-in provides smart autocomplete, code navigation, refactoring, and other features for the mocked class methods of PHPUnit, Prophecy, and Mockery. It has features like method autocomplete for class, abstract class and trait mock objects, highlighting of incorrect method usages, Prophecy and Mockery support, and more.
Still on the topic of saving time, one of the pain points of a developer is usually writing every single simple function or line every time. This issue is solved with Tabnine AI Code Completion!
You can see two gifs of code with and without Tabnine to see the difference this plugin brings. It predicts what you will potentially create according to your object or function. Now, instead of having to type console.log("hello world"), you can just start typing, and Tabnine will finish the job for you.
This is often one of the biggest disagreements between developers - what case should code be written in. Well, it depends on the specific language’s specifications and its naming conventions. Sometimes languages even require the use of different cases, so you’ll need to understand the difference and how to use them.
No matter the language or your preference, another important thing is that you apply your naming conventions consistently in your codebase. The CamelCase plugin ensures consistency by allowing you to switch easily between kebab-case, snake_case, PascalCase, camelCase, and more.
It’s no secret that cloud computing, and especially Amazon Web Services (AWS), is very popular, so you’ll often have to write applications built on AWS.
To make this easier, the AWS Toolkit contains all the tools you need for AWS application development. As such, it gives you the ability to create and deploy AWS serverless applications. You can also create, debug, change, or delete AWS Lambda functions and debug code in Amazon ECS clusters.
Keep in mind, though, these are just some of the functionalities it offers and there are many others available from its resource explorer to authentication, and the S3 explorer. Ultimately, if you’re developing serverless applications on AWS, the AWS Toolkit is certainly worth a look.
Whether you need to sort, increment, or decrement strings for purposes of your application or just based on your preferences, a string manipulation tool can be extremely helpful. And that’s where the String Manipulation plugin comes in.
It gives you a full suite of string manipulation tools that allow you to switch case, toggle between different cases, increment or decrement numbers, create sequences, sort lines, shuffle characters, do conversions, and more. Moreover, although these actions are available in your IntelliJ-based IDE’s Edit menu, the plugin allows you to set up your own keyboard shortcuts.
Ultimately, this plugin saves you time and will make you more efficient when writing code.
The Dummy Text Generator adds a random text generator to the main menu of IntelliJ. It allows you to create text in different genres from fake latin to science fiction and esoteric wisdom. You can then insert the created text at the caret or replace a selection of existing text.
Why do you need it? It’s simple, you’ll often need to use placeholder text in your applications, especially when developing web applications. This tool makes this process a lot simpler and quicker.
Let's face it, if you're dealing with data in your application, you’ll often use CSV files. The problem is that these files are a hassle to work with and edit. So, you'll often need to use a spreadsheet application like excel to open, view, edit, and export these files.
The CSV plugin makes it easier to work with CSV files because it implements CSV as a language in IntelliJ. As a result, it associates CSV and other associated file types with IntelliJ and gives you syntax definition, syntax highlighting, inspections, and other capabilities when working with CSV files.
This means no more switching between applications to view and edit files, which, in turn, means more efficiency.
When you import and export a lot of data in your applications, you’ll often use CSV files. The problem with these is that it's often difficult to figure out what data fits where. Even worse, not being able to easily see what type of data you're dealing with, it makes it more challenging to debug.
The Rainbow CSV plugin solves this problem. It does this by showing every column of data in a different color. This makes it easier to work with CSV files and visually work with the different types of data. The plugin supports different characters as delimiters and you're able to set custom column colors.
Let's face it, when coding, you'll deal with brackets upon brackets and even more brackets from round ones, to square ones and squiggly ones. Obviously, this can become complicated when trying to figure out which bracket closes which block of code.
Luckily, the Rainbow Brackets plugin solves this problem. By showing bracket pairs in specific colors, it makes it easier for you to see where a code block starts and where it ends. This eliminates confusion and allows you to save time when writing code.
Let's face it, bugs can be frustrating to find and solve. It's even more difficult for new developers working on a codebase for the first time. So, you’ll want to eliminate and avoid programming errors as far as possible.
The ESLint plugin helps you do this. It quickly analyzes your code to find programming errors, stylistic errors, and bugs. And when you find these errors and bugs easier, you'll be able to rectify them quickly and easily. Another bonus is that the plugin can fix many errors it finds automatically.
Also, you’re able to write your own rules that will work alongside the plugin’s built-in rules. Ultimately, you can customize the plugin based on your team's needs and you'll ensure that your code is always free of errors.
It often happens, especially with larger projects or larger development teams, that you end up with a messy code base with differing styles, indentations, and the like. This not only makes it difficult for new developers to start working on the project but also makes the project more challenging to maintain.
The Save Actions plugin solves this problem. With it, you'll be able to set configurable save actions that will be applied every time files are saved. So, every time a developer saves their work, you’ll be able to reformat, rearrange, compile or optimize your code.
This allows you to enforce a code style and code rules which makes your code cleaner, more uniform and easier to maintain.