PHP looks simple when you first start using it.
You write some code, refresh the page, and hopefully everything works. 😄 But after working with PHP for a while, you start discovering small behaviors that are not always obvious.
Some of them can cause confusing bugs, while others can make your code shorter and cleaner.
In this article, let's look at some useful PHP tricks and behaviors that every PHP developer should know.
- and Are Not the Same This is probably one of the most important PHP details to understand.
PHP has two common comparison operators: The first one compares values, while the second one compares both value and type.
For example: Output: PHP considers the values equal after type conversion.
But: Output: Why?
Because: is an integer, while: is a string.
My recommendation In most cases, prefer and .
It makes your code more predictable and can prevent unexpected type conversions.
2.
The Weirdness of , , and PHP has several values that can behave like in certain situations.
For example: The same kind of behavior can happen with: This can become a problem if you are checking whether a value actually exists.
For example: Maybe is actually a valid value in your application.
In situations like this, be more specific: Don't just ask PHP whether something is "truthy" when you actually care about a specific value.
3.
The Null Coalescing Operator This little operator is incredibly useful.
Imagine you want to get a username from an array: If doesn't exist, PHP can complain about an undefined array key.
Instead, you can use: Now PHP basically says: "If exists, use it.
Otherwise, use ." For example: If the URL doesn't contain a username, the result will be: You can also chain it: This is one of those small PHP features that you will probably use all the time.
4.
Is Different From These two operators can look similar, but they have different purposes.
Null coalescing This mainly checks whether the value exists and is not .
Ternary This checks whether the value is truthy.
That means values such as , , or can produce different results.
There is also a shorter ternary syntax: So don't automatically replace one with the other.
Understand what you actually want to check.
5.
You Can Swap Variables Without a Temporary Variable In some languages, you might write: In PHP, you can use array destructuring: For example: Now: It's a small trick, but it can make certain code much cleaner.
6.
Can Make Repetitive Code Cleaner Suppose you have: And you want to double every number.
You could use a loop: Or you can use: Now contains: This can be especially useful when transforming data from an API, database, or another source.
7.
You Can Use Instead of a Huge Modern PHP gives us .
Instead of: You can write: This is shorter and easier to read.
One important detail: uses strict comparison.
So types matter.
That's another reason understanding is important.
8.
PHP Strings Can Behave Differently With and Here's a classic beginner mistake.
If you want to concatenate strings in PHP, use: For example: Output: Don't use: The operator is for arithmetic.
The operator is for string concatenation.
This is a small difference, but forgetting it can lead to very confusing results.
9.
Has a Surprising Behavior Consider: You might expect to be considered a real string.
But PHP considers empty for the purposes of .
This is why you should be careful when using: If is a valid value in your application, a simple check may not express what you actually mean.
Sometimes an explicit check is much clearer: The more precise your condition is, the fewer surprises you'll have later. - and Are Different This is another useful one when working with arrays.
Suppose: Now: returns: Why?
Because returns false when the value is .
But: returns: The key actually exists.
Its value is simply .
So remember: asks: "Does this value exist and is it not null?" While: asks: "Does this key exist in the array?" That difference can matter a lot when processing API responses or database data.
Bonus Trick: The Spread Operator You can use to unpack arrays.
For example: Result: You can also use it when passing arguments to functions.
Output: Pretty handy, right?
One More Important Tip: Don't Make PHP "Magic" PHP gives us a lot of shortcuts.
That's great, but shortcuts should make code easier to understand, not harder.
For example, this: is great when you understand what it does.
But if you start combining many operators into one giant expression: you may save a few lines but make your future self very unhappy. 😅 Sometimes this is better: Readable code is usually better than clever code.
Final Thoughts PHP has many small features that look simple but can behave differently than you might expect.
The most useful ones to remember from this article are: Prefer when you need strict comparison.
Be careful with PHP's truthy and falsy values.
Use when you need a fallback for missing or values.
Remember that concatenates strings.
Understand the difference between and .
Use when it makes conditional logic cleaner.
Don't be afraid to use and the spread operator.
Avoid clever code when a simple solution is easier to understand.
And honestly, these little details are often what separate "I can write PHP" from "I can maintain a PHP project without constantly fighting weird bugs." 😄 If you're looking for more programming resources and developer-focused content, you can also check out CodeCan.net for more useful development resources.
What is your favorite PHP trick or "weird PHP behavior"?
Share it in the comments.
I'd love to see which ones have surprised other PHP developers.