accidental assignment in a condition php

Create Account

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 473,372 software developers and data experts.

Daniel Opitz - Blog

Developer, trainer, open source contributor.

PHPStan is a great tool for catching common mistakes and bugs in your PHP code, but sometimes you may need to create your own custom rules to catch specific issues. One common issue that can be hard to catch is accidental assignments in conditionals. In this post, I will show you how to create a custom rule in PHPStan to catch this issue.

First, let’s take a look at an example of an accidental assignment in a conditional:

In this example, the developer probably meant to check if getValue() returns a boolean value, but instead they accidentally assigned the return value of getValue() to $x . This can cause unexpected behavior in the code and be hard to track down.

To catch this issue, we can create a custom rule in PHPStan that checks for assignments in conditional statements and raises an error if one is found. Here’s an example implementation of the rule:

File: src/Rules/AssignmentInConditionRule.php

This class implements the Rule interface, and the method getNodeType() returns the type of node that the rule should be applied to, in this case it’s Node\Stmt\If_ which is a node that represents an if statement.

The processNode() method gets called by PHPStan for each Node\Stmt\If_ it encounters.

It finds the first instance of Assign node within the If condition node, if it’s not found it returns an empty array, indicating that there’s no issue found.

If this condition does not meet, it means that there’s a conditional statement containing an assignment, so it raises an error with a message indicating that the assignment is not allowed.

The AssignmentInConditionRule class contains a private property $nodeFinder which is an instance of PhpParser\NodeFinder class, this class is used to find specific nodes in a PHP syntax tree generated by the PhpParser library.

To use this PHPStan rule, you need to include the class in your PHPStan configuration file phpstan.neon :

Once enabled, PHPStan will raise an error if it finds an assignment in a conditional statement, indicating that it may be an accidental assignment.

Please keep in mind that this is a basic example, you may need to adjust the implementation of your rule based on your specific needs.

In conclusion, creating custom rules in PHPStan can be a great way to catch specific issues in your code that might be hard to track down otherwise. With a bit of PHP knowledge and the right tools, you can create your own rules to catch common mistakes and bugs in your code, and make your development process more efficient and effective.

Update: You can find the source code on GitHub: odan/phpstan-rules .

Conditional Operators

Conditional Assignment Operator in PHP is a shorthand operator that allow developers to assign values to variables based on certain conditions.

In this article, we will explore how the various Conditional Assignment Operators in PHP simplify code and make it more readable.

Let’s begin with the ternary operator.

Ternary Operator Syntax

The Conditional Operator in PHP, also known as the Ternary Operator, assigns values to variables based on a certain condition. It takes three operands: the condition, the value to be assigned if the condition is true, and the value to be assigned if the condition is false.

Here’s an example:

In this example, the condition is $score >= 60 . If this condition is true, the value of $result is “Pass”. Otherwise, the value of $result is “Fail”.

To learn more, visit the PHP ternary operator tutorial . Let’s now explore the section below to delve into the Null Coalescing Operator in PHP.

The Null Coalescing Operator (??)

The Null Coalescing Operator, also known as the Null Coalescing Assignment Operator, assigns a default value to a variable if it is null. The operator has two operands: the variable and the default value it assigns if the variable is null. Here’s an example:

So, In this example, if the $_GET['name'] variable is null, the value of $name is “Guest”. Otherwise, the value of $name is the value of $_GET['name'] .

Here’s another pattern utilizing it with the assignment operator. Let’s proceed.

The Null Coalescing Assignment Operator (??=)

The Null Coalescing Operator with Assignment, also known as the Null Coalescing Assignment Operator, assigns a default value to a variable if it is null. The operator has two operands: the variable and the default value it assigns if the variable is null. Here’s an example:

So, the value of $name is null. The Null Coalescing Assignment Operator assigns the value “Guest” to $name. Therefore, the output of the echo statement is “Welcome,”Guest!”.

Moving into the following section, you’ll learn how to use the Elvis operator in PHP.

The Elvis Operator (?:)

In another hand, The Elvis Operator is a shorthand version of the Ternary Operator. Which assigns a default value to a variable if it is null. It takes two operands: the variable and the default value to be assigned if the variable is null. Here’s an example:

In this example, if the $_GET['name'] variable is null, the value“Guest” $name s “Guest”. Otherwise, the value of $name is the value of $_GET['name'] .

Let’s summarize it.

Wrapping Up

The Conditional Assignment Operators in PHP provide developers with powerful tools to simplify code and make it more readable. You can use these operators to assign values to variables based on certain conditions, assign default values to variables if they are null, and perform shorthand versions of conditional statements. By using these operators, developers can write more efficient and elegant code.

Did you find this article helpful?

Sorry about that. How can we improve it ?

Facebook -->
Twitter -->
Linked In -->
Install PHP
Hello World
PHP Constant
PHP Comments

PHP Functions

Parameters and Arguments
Anonymous Functions
Variable Function
Arrow Functions
Variadic Functions
Named Arguments
Callable Vs Callback
Variable Scope

Control Structures

If-else Block
Break Statement

PHP Operators

Operator Precedence
PHP Arithmetic Operators
Assignment Operators
PHP Bitwise Operators
PHP Comparison Operators
PHP Increment and Decrement Operator
PHP Logical Operators
PHP String Operators
Array Operators
Ternary Operator
PHP Enumerable
PHP NOT Operator
PHP OR Operator
PHP Spaceship Operator
AND Operator
Exclusive OR
Spread Operator
Null Coalescing Operator

Data Format and Types

PHP Data Types
PHP Type Juggling
PHP Type Casting
PHP strict_types
Type Hinting
PHP Boolean Type
PHP Iterable
PHP Resource
Associative Arrays
Multidimensional Array

String and Patterns

Remove the Last Char

Make WordPress Core

The WordPress core Core Core is the set of software required to run WordPress. The Core Development Team builds WordPress. development team builds WordPress! Follow this site for general updates, status reports, and the occasional code debate. There’s lots of ways to contribute:

Found a bug bug A bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority. ? Create a ticket in the bug tracker.
Want to contribute? Get started quickly with tickets marked as good first bugs for new contributors or join a bug scrub . There’s more on the reports page , like patches needing testing , and on feature projects page .
Other questions? Here is a detailed handbook for contributors , complete with tutorials.

Communication

Core uses Slack for real-time communication. Contributors live all over the world, so there are discussions happening at all hours of the day.

Core development meetings are every Wednesday at 20:00 UTC in the #core channel on Slack . Anyone can join and participate or listen in!

Proposal: Disallow assignments in conditions and remove the Yoda condition requirement for PHP

After discussion with several core Core Core is the set of software required to run WordPress. The Core Development Team builds WordPress. committers and WordPress leads, the title and the contents of the text were changed to clarify that this is a proposal and not a decision set in stone.

This proposal is the continuation of the long discussion on the WordPress Coding Standards (WPCS) repo .

Yoda conditions (or Yoda notation) is the programming style where the parts of an expression in the condition are reversed from the ‘typical’ order.

In a large part of the world, the natural reading order is left to right (LTR). This is what most programming languages adhere to. That means the variable assignments or echo/print statements are written with the variable first:

With the same idea in mind, conditions can also be written left to right, like:

With Yoda conditions applied, the above condition would be written as:

The idea behind it is that writing the value on the left side of the condition will prevent accidentally assigning the value to the variable since assignments can’t be made to values.

While seemingly helpful at first glance, the obvious problem with them is the decreased readability of code , especially for people with reading disabilities such as dyslexia.

How we got here

When the handbook rule about Yoda conditions was introduced there was barely any static analysis tooling available in the PHP PHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 5.6.20 or higher world. The only ‘foolproof’ way to prevent accidental assignment in conditions was to invert the order of the value being checked and the variable.

Automated checking for assignments in conditions via PHP_CodeSniffer ( PHPCS PHP Code Sniffer PHP Code Sniffer, a popular tool for analyzing code quality. The WordPress Coding Standards rely on PHPCS. ), the underlying tooling for WPCS WPCS The collection of PHP_CodeSniffer rules (sniffs) used to format and validate PHP code developed for WordPress according to the WordPress Coding Standards. May also be an acronym referring to the Accessibility, PHP, JavaScript, CSS, HTML, etc. coding standards as published in the WordPress Coding Standards Handbook . , became available in 2017. Moreover, the current sniff sniff A module for PHP Code Sniffer that analyzes code for a specific problem. Multiple stiffs are combined to create a PHPCS standard. The term is named because it detects code smells , similar to how a dog would "sniff" out food. enforcing Yoda condition in the WPCS doesn’t protect against accidental assignments in conditions.

Today there is tooling in place that can help with identifying assignments in conditions, making the Yoda rules obsolete.

Keep in mind that strict comparisons ( === ) are already strongly encouraged and a part of the WordPress-Core ruleset (warning), making accidental assignments even less likely.

A thorough analysis was made by Lucas Bustamante in the WPCS ticket ticket Created for both bug reports and feature development on the bug tracker. on the impact this could have on the plugins in the WordPress directory. The analysis showed that Yoda conditions are used in 18.02% of the plugins, so the majority of plugin Plugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party developers are using non-Yoda conditions .

What to do next?

The discussion in the WPCS ticket is long and opinionated, but comes down to these points:

Disallow Yoda condition

Drop the handbook rule that requires Yoda conditions and instead explicitly disallow using them.

Remove Yoda condition as a requirement

Discourage, but don’t disallow Yoda conditions. Just don’t report if the code is or is not using Yoda conditions. The rule would also be dropped from the handbook.

In both cases, assignments in conditions will still be checked for and forbidden .

Impact on the Core code

Disallowing Yoda conditions for WordPress Core would mean that all existing patches on open tickets for Core would need to be revisited and fixed accordingly, which could burden the contributors.

Running the same analysis as Lucas did for plugins, over the WordPress Core, there were 5427 Yoda conditions, and 312 non-Yoda conditions.

Luckily, these are violations that can be automatically fixed using phpcbf tool, but care should be taken to check if all the violations were correctly fixed.

If Yoda conditions are discouraged (option 2), and the existing Yoda conditions in the Core code remain, that would mean less work for the Core contributors Core Contributors Core contributors are those who have worked on a release of WordPress, by creating the functions or finding and patching bugs. These contributions are done through Trac. https://core.trac.wordpress.org. , but also would add lots of inconsistencies in the Core code (mixed Yoda and non-Yoda conditions).

The chosen way forward is to remove the Yoda condition as a requirement (remove it from the handbook) but not disallow it for the time being.

For WPCS, that would mean the removal of the Yoda conditions requirement (and sniff) in WPCS 3.0, with a notice that non-Yoda conditions will start to be required in WPCS 4.0 version.

Work is currently actively ongoing to prepare for the WPCS 3.0.0 release. There will be a minimum of six months between the 3.0.0 and the 4.0.0 release to allow time for Core and other projects to adjust.

Once WPCS 4.0.0 version is released, a one-time-only auto-fix of all the remaining Yoda conditions in Core will be made, and any patches to the Core which go in after that will have to use non-Yoda.

How to enforce the non-Yoda conditions in your code

If you are a WordPress plugin or theme developer, and you’d like to enforce non-Yoda conditions in your code, you can use the Generic.ControlStructures.DisallowYodaConditions sniff. In your phpcs.xml.dist file you should add the following sniff:

If you want to change the Yoda conditions to non-Yoda conditions, use the phpcbf tool (part of PHPCS) with the Slevomat coding standards . Specifically, the SlevomatCodingStandard.ControlStructures.DisallowYodaComparison sniff that has the fixer for the Yoda conditions.

Props to Juliette Reinders Folmer and Gary Jones for the proofreading and adding valuable feedback on the text. Also, a big props to Lucas Bustamante for the impact analysis on WordPress plugins.

# codingstandards , # php , # wpcs

Introduction to the PHP if statement

The if statement allows you to execute a statement if an expression evaluates to true . The following shows the syntax of the if statement:

In this syntax, PHP evaluates the expression first. If the expression evaluates to true , PHP executes the statement . In case the expression evaluates to false , PHP ignores the statement .

The following flowchart illustrates how the if statement works:

The following example uses the if statement to display a message if the $is_admin variable sets to true :

Since $is_admin is true , the script outputs the following message:

Curly braces

If you want to execute multiple statements in the if block, you can use curly braces to group multiple statements like this:

The following example uses the if statement that executes multiple statements:

In this example, the if statement displays a message and sets the $can_edit variable to true if the $is_admin variable is true .

It’s a good practice to always use curly braces with the if statement even though it has a single statement to execute like this:

In addition, you can use spaces between the expression and curly braces to make the code more readable.

Nesting if statements

It’s possible to nest an if statement inside another if statement as follows:

The following example shows how to nest an if statement in another if statement:

Embed if statement in HTML

To embed an if statement in an HTML document, you can use the above syntax. However, PHP provides a better syntax that allows you to mix the if statement with HTML nicely:

The following example uses the if statement that shows the edit link if the $is_admin is true :

Since the $is_admin is true , the script shows the Edit link. If you change the value of the $is_admin to false , you won’t see the Edit link in the output.

A common mistake with the PHP if statement

A common mistake that you may have is to use the wrong operator in the if statement. For example:

This script shows a message if the $checke d is 'off' . However, the expression in the if statement is an assignment, not a comparison:

This expression assigns the literal string 'off' to the $checked variable and returns that variable. It doesn’t compare the value of the $checked variable with the 'off' value. Therefore, the expression always evaluates to true , which is not correct.

To avoid this error, you can place the value first before the comparison operator and the variable after the comparison operator like this:

If you accidentally use the assignment operator (=), PHP will raise a syntax error instead:

The if statement executes a statement if a condition evaluates to true .
Always use curly braces even if you have a single statement to execute in the if statement. It makes the code more obvious.
Do use the pattern if ( value == $variable_name ) {} to avoid possible mistakes.

More Tips for Defensive Programming in PHP

Share this article

Fail Fast, and Loudly

Input validation, preventing accidental assignment in comparisons, dealing with try/catch and exceptions, transactions.

The general definition of defensive programming (as seen in Part 1, an overview piece on Defensive Programming in PHP ) being used here is thus:

Defensive programming, simply put, is programming with the intent to anticipate likely failure points. The goal is to circumvent those likely problems before they occur.

This definition is a wide one. Many people argue against defensive programming, but this is often because of the types of methods they have seen espoused by some as defensive programming. Defensive programming should not be viewed as a way to avoid test driven development or as a way to simply compensate for failures and move on.

“Fail Fast” should not be seen as a counter to defensive programming. It all falls under the same umbrella. What are these methods, if not ways to anticipate that your program may fail, and either prevent those, or else ways in which to handle those failures appropriately?

Simply put, failing fast and loudly means that when an error occurs, it will do so as early as possible, and alert whomever it should alert, as opposed to silently continuing on in an error state that may cause more issues. Here is an excellent article on fail-fast style development. The premise of fail-fast methodology is to fail when acquiring input that might later compromise the program (or, more generally, to enter a failure state as soon as any problems could possibly be detected, rather than allowing bad data to travel and a program to run un-checked, or worse, bad data to be stored somewhere). This is most useful when dealing with user input, or dealing with input that is arriving from outside the script, module, or even out of your system via an API. An example of where this could be employed would be a check for invalid values or data types passed into functions.

One mistake that some programmers make with fail-fast methodology is to simply throw Exceptions and errors out to the user without making proper provisions for handling them. You don’t want normal users to be worried or confused by your error messaging. And more importantly, you don’t want users with malicious intent learning things from the information displayed to them. Display a helpful message to the user, log your errors, and perform any other tasks that need to be a result of that exception. You don’t want to just fail fast , you also want to be loud ( know there’s a problem, right away) and secure (don’t let your poor exception handling or complete lack thereof cause even more security issues).

There are many methods by which to validate user input safely.

Typecasting is an interesting way to “validate” user input. Sometimes it goes a bit like this:

Instead of using another method to avoid cross-site scripting attacks, the value is simply being captured, typecast, and assigned. This only works when you have an expected type, and any value of that type is safe (Otherwise, you’d need to also check for appropriate int values). The problem with this approach, that I see (in most situations) is that you aren’t really checking the input, you’re just forcing it to become what it should be. This could have unforeseen consequences. Instead, a better approach might be to check for appropriate values using filter_input() . Here is a great article on that subject. Basically, that comes out like this:

There are many benefits to using the native filter_input function in modern PHP, and you can read more about them in the aforementioned article or on php.net .

This is an easy, and often noted, tenet of defensive programming. A simple change in the way that you do your comparisons can have great effects. Consider the following:

This is a relatively normal comparison, yes? However, what happens if you accidentally use the “=” instead of “==” (or, in most cases, the even better “===” )? A simple slip of the finger on the keyboard? Absentmindedness, maybe? All of a sudden, your comparison now reads true, all of the time, in all cases. Unless you have a good IDE warning you about this, how long will it take you to find out? In some cases, this could be a silent error for some time. However, there’s an extremely simple way to prevent this:

Now, if you accidentally use one equals sign, the error will not be silent. Obviously, this may not occur often, it may be mitigated by your testing, and it’s not useful in all cases, especially when doing variable to variable comparisons. But it’s still not a bad idea if this tends to happen to you.

try/catch statements are another hot topic among PHP developers. Let’s first get a quick look at what we’re talking about.

A well known tool of defensive programming is the try/catch statement and the Exception class. These are excellent for catching and logging errors, when used correctly. A good programmer will employ try/catch statements to anticipate possible errors or other situations that might disrupt the normal flow. When those Exceptions occur, they must be handled in an appropriate way. The user of the application, where required, should get a reasonable error message that is as useful as it can be without divulging sensitive information. The administrator(s) of the application should receive detailed alerts and/or logs. Exceptions that are mishandled, or ignored, ignore the “Fail Loudly” advice, and may allow the program to continue in essentially a silent error state for some time, which is not good for anyone involved.

For a bit more on exceptions in PHP, see here and here .

Transactions are a feature of databases that allow queries to be grouped together, so that if one query fails, all of them fail. This is an implementation of ACID, about which you can read more here . The idea is that grouping multiple queries together into one process can sometimes be a safer and more stable solution, especially when the queries depend on each other. PHP developers often completely ignore transactions, or assume that they are unnecessary, but when interacting with databases, a little bit of defensive programming can go a long way. Transactions are discussed in more depth in this excellent post , but in a nutshell, transactions allow you to run your MySQL updates, and then check the results before actually committing the results. If you are using PDO (you should be) , you may use PDO methods to begin a transaction, commit the results, as well as roll back. In addition to the aforementioned overview of transactions, delve into them further with this in-depth guide .

Here’s a quick example of what the use of transactions in PDO might look like:

Again, these are just general tips. Obviously, each of them has their uses and each has notable situations where it would not be used. However, if you take concepts like these and work them into your daily development regimes, it can make you more efficient at what you do. And while this is generally a topic that is more applicable to developers who are currently learning PHP, it’s a good refresher on practices for everyone.

If only a single thing is taken away from this, especially by newer developers, it is that you should program defensively – plan for the possibility of mistakes and errors. Handle them appropriately. Don’t allow silent errors to progress. Fail fast. Test your code. By building robust applications that test for and resolve issues, and anticipate and handle future ones, you are making your applications more dependable, and hopefully assisting in the creation of a better user experience from behind the scenes.

Jeff works for a startup as a technical writer, does contract writing and web development, and loves tinkering with new projects and ideas. In addition to being glued to a computer for a good part of his day, Jeff is also a husband, father, tech nerd, book nerd, and gamer.

PhpStorm 2024.1 Help

Code inspection: assignment in condition.

Reports the assignments that are used in conditional expressions.

Suppress an inspection in the editor

Click the arrow next to the inspection you want to suppress and select the necessary suppress action.

Language Reference

Assignment Operators

The basic assignment operator is "=". Your first inclination might be to think of this as "equal to". Don't. It really means that the left operand gets set to the value of the expression on the right (that is, "gets set to").

The value of an assignment expression is the value assigned. That is, the value of " $a = 3 " is 3. This allows you to do some tricky things: <?php $a = ( $b = 4 ) + 5 ; // $a is equal to 9 now, and $b has been set to 4. ?>

In addition to the basic assignment operator, there are "combined operators" for all of the binary arithmetic , array union and string operators that allow you to use a value in an expression and then set its value to the result of that expression. For example: <?php $a = 3 ; $a += 5 ; // sets $a to 8, as if we had said: $a = $a + 5; $b = "Hello " ; $b .= "There!" ; // sets $b to "Hello There!", just like $b = $b . "There!"; ?>

Note that the assignment copies the original variable to the new one (assignment by value), so changes to one will not affect the other. This may also have relevance if you need to copy something like a large array inside a tight loop.

An exception to the usual assignment by value behaviour within PHP occurs with object s, which are assigned by reference. Objects may be explicitly copied via the clone keyword.

Assignment by Reference

Assignment by reference is also supported, using the " $var = &$othervar; " syntax. Assignment by reference means that both variables end up pointing at the same data, and nothing is copied anywhere.

Example #1 Assigning by reference

The new operator returns a reference automatically, as such assigning the result of new by reference is an error.

The above example will output:

More information on references and their potential uses can be found in the References Explained section of the manual.

Arithmetic Assignment Operators

Bitwise assignment operators, other assignment operators.

arithmetic operators
bitwise operators
null coalescing operator

User Contributed Notes 4 notes

What are the conditional assignment operators in PHP?

Free System Design Interview Course

Many candidates are rejected or down-leveled due to poor performance in their System Design Interview. Stand out in System Design Interviews and get hired in 2024 with this popular free course.

Introduction

Operators in PHP are signs and symbols which are used to indicate that a particular operation should be performed on an operand in an expression. Operands are the operation objects, or targets. An expression contains operands and operators arranged in a logical manner.

In PHP, there are numerous operators, which are grouped into the following categories:

Logical operators

String operators

Array operators

Arithmetic operators

Assignment operators

Comparison operators

Increment/Decrement

Conditional assignment operators

Some examples of these operators are:

- Subtraction
* Multiplication
-- and so much more.

What are conditional assignment operators?

Conditional assignment operators , as the name implies, assign values to operands based on the outcome of a certain condition. If the condition is true , the value is assigned. If the condition is false , the value is not assigned.

There are two types of conditional assignment operators: tenary operators and null coalescing operators .

1. Tenary operators ?:

Basic syntax.

Where expr1 , expr2 , and expr3 are either expressions or variables.

From the syntax, the value of ＄y will be evaluated. This value of ＄y is evaluated to expr2 if expr1 = TRUE . The value of $y is expr3 if expr1 = FALSE .

2. Null coalescing operators ??

The ?? operator was introduced in PHP 7 and is basically used to check for a NULL condition before assignment of values.

Where varexp1 and varexp2 are either expressions or variables.

The value of ＄z is varexp1 if and only if varexp1 exists, and is not NULL. If varexp1 does not exist or is NULL, the value of ＄z is varexp2 .

Let’s use some code snippets to paint a more vivid description of these operators.

Explanation

In the code above, the new value of ＄y and ＄z is set based on the evaluation result of expr1 and varexp1 , respectively.

RELATED TAGS

CONTRIBUTOR

Learn in-demand tech skills in half the time

Mock Interview

Skill Paths

Assessments

Learn to Code

Tech Interview Prep

Generative AI

Data Science

Machine Learning

GitHub Students Scholarship

Early Access Courses

For Individuals

Try for Free

Gift a Subscription

Become an Author

Become an Affiliate

Earn Referral Credits

Cheatsheets

Frequently Asked Questions

Cookie Policy

Business Terms of Service

Data Processing Agreement

Search code, repositories, users, issues, pull requests...

Provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

Notifications

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement . We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Core: Ban Yoda conditions, loose comparisons and assignments in conditions #1624

jrfnl commented Jan 13, 2019 • edited

👍 39 reactions
👎 2 reactions

pento commented Jan 14, 2019

Sorry, something went wrong.

jrfnl commented Jan 14, 2019

👍 1 reaction

GaryJones commented Jan 14, 2019

2ndkauboy commented Jan 23, 2019

👎 4 reactions

jrfnl commented Jan 23, 2019

NielsdeBlaauw commented Feb 17, 2019

JJJ commented Mar 4, 2019

👍 10 reactions
👎 10 reactions

GaryJones commented Mar 4, 2019

👍 7 reactions
😄 2 reactions

JPry commented Mar 5, 2019

😕 1 reaction

pento commented Mar 8, 2019

👍 3 reactions

jrfnl commented Mar 8, 2019 • edited

Garyjones commented mar 8, 2019 • edited by jrfnl, pento commented mar 25, 2019, jrfnl commented mar 25, 2019.

curtisbelt commented Jan 2, 2020

Pento commented jan 6, 2020.

👍 4 reactions

ggedde commented Aug 21, 2020

Luc45 commented Nov 21, 2020 • edited

mitogh commented Feb 14, 2022

sirbrillig commented Feb 15, 2022

Mitogh commented feb 15, 2022, jrfnl commented feb 15, 2022.

👍 2 reactions
😄 5 reactions

andronocean commented Apr 8, 2022

Luc45 commented apr 8, 2022 • edited, jrfnl commented may 5, 2022, luc45 commented may 5, 2022 • edited.

👀 2 reactions

Luc45 commented May 5, 2022

Luc45 commented may 18, 2022 • edited, 2ndkauboy commented may 18, 2022, luc45 commented may 20, 2022 • edited, jrfnl commented may 20, 2022, 2ndkauboy commented may 20, 2022, luc45 commented may 21, 2022 • edited, luc45 commented may 22, 2022 • edited, 2ndkauboy commented may 22, 2022.

dingo-d commented May 23, 2022

2ndkauboy commented may 23, 2022, luc45 commented may 23, 2022 • edited, jrfnl commented may 23, 2022, 2ndkauboy commented may 23, 2022 • edited, dingo-d commented may 24, 2022 • edited, dingo-d commented jun 14, 2022.

🎉 5 reactions

jrfnl commented Jun 15, 2022

👍 6 reactions

dingo-d commented Dec 9, 2022

👎 1 reaction
😕 4 reactions

No branches or pull requests

PHP Tutorial

Php advanced, mysql database, php examples, php reference, php operators.

Operators are used to perform operations on variables and values.

PHP divides the operators in the following groups:

Arithmetic operators
Assignment operators
Comparison operators
Increment/Decrement operators
Logical operators
String operators
Array operators
Conditional assignment operators

PHP Arithmetic Operators

The PHP arithmetic operators are used with numeric values to perform common arithmetical operations, such as addition, subtraction, multiplication etc.

PHP Assignment Operators

The PHP assignment operators are used with numeric values to write a value to a variable.

The basic assignment operator in PHP is "=". It means that the left operand gets set to the value of the assignment expression on the right.

PHP Comparison Operators

The PHP comparison operators are used to compare two values (number or string):

PHP Increment / Decrement Operators

The PHP increment operators are used to increment a variable's value.

The PHP decrement operators are used to decrement a variable's value.

PHP Logical Operators

The PHP logical operators are used to combine conditional statements.

PHP String Operators

PHP has two operators that are specially designed for strings.

PHP Array Operators

The PHP array operators are used to compare arrays.

PHP Conditional Assignment Operators

The PHP conditional assignment operators are used to set a value depending on conditions:

PHP Exercises

Test yourself with exercises.

Multiply 10 with 5 , and output the result.

Start the Exercise

COLOR PICKER

Report Error

If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:

[email protected]