What I would like to do is something like this:
$method_result = new Obj()->method();
Instead of having to do:
$obj = new Obj();
$method_result = $obj->method();
The result doesn't actually matter to me in my specific case. But, is there a way to do this?
Background: You asked for a "simple explanation" which suggests:
Short No-Jargon Answer:
Long No-Jargon Answer:
Procedural vs OOP is just one aspect of a fundamental issue of computer programming: how to make your code easy to understand and a piece of cake to professionally maintain. You can actually write "Procedural" code that follows some of the principles of OOP, so the two are not necessarily opposites.
Your understanding will really grow once you learn other object-oriented programming languages, among which, PHP is a "new kid on the block".
Here is a quick overview of what you will learn as you build experience:
You can write PHP source code that does useful tasks
You can organize useful tasks into "chunks" of code
You can think of "chunks" of code independently of the individual files where they are saved
Sometimes those "chunks" of code will behave differently based on parameters you pass in
Chunks of code that accept parameters are called "Functions"
Functions can be "chunked" together, and there are different ways of doing this:
OOP is a special way of "chunking" Functions together into a "Class"
A Class is just another level of "chunking" code together so that you can treat it as a unified whole
A Class can be thought of as a "chunking" of methods and properties
A Class is useful because it allows you to organize your code at a very high level in a way that makes it easy for you to understand, use, and maintain.
When someone has written a lot of functions, and organized them into a lot of Classes, and gotten those to work together in some cool way, they package the whole thing together and call it a "Framework".
A Framework is just the next-highest level of "chunking" (including coding style and conventions) that one or more people agree on because they like the way the code is organized and it suits their working style, preferences, values, plans for world domination, etc.
In a lot of scenarios, procedural programming is just fine. Using OO for the sake of using it is useless, especially if you're just going to end up with POD objects (plain-old-data).
The power of OO comes mainly from inheritance and polymorphism. If you use classes, but never use either of those two concepts, you probably don't need to be using a class in the first place.
One of the nicest places IMO that OO shines in, is allowing you to get rid of switch-on-type code. Consider:
function drive($the_car){
switch($the_car){
case 'ferrari':
$all_cars->run_ferrari_code();
break;
case 'mazerati':
$all_cars->run_mazerati_code();
break;
case 'bentley':
$all_cars->run_bentley_code();
break;
}
}
with its OO alternative:
function drive($the_car){
$the_car->drive();
}
Polymorphism will allow the proper type of "driving" to happen, based on runtime information.
Notes on polymorphism:
The second example here has some premisses: That is that all car classes will either extend an abstract class or implement an interface.
Both allow you to force extending or implementing classes to define a specific function, such as drive(). This is very powerful as it allows you to drive() all cars without having to know which one you're driving; that is because they're extending an abstract class containing the drive() method or implementing an interface forcing the drive() method to be defined.
So as long as you make sure that all your specific cars either extend the abstract class car or implement an interface such as canBeDriven (both of which must declare the drive() method) you can just call the drive() method on an object which you know is a car (but not what type of car) without fear of it not being defined, as PHP will throw fatal errors at you until you define those methods in your specific car classes.
Put this code in your ruleset.xml file:
<rule ref="PSR2">
<exclude name="Squiz.Functions.MultiLineFunctionDeclaration.BraceOnSameLine" />
</rule>
<rule ref="Generic.Functions.OpeningFunctionBraceKernighanRitchie" />
That will include the PSR2 standard, but exclude the specific message about the brace needing to be on the same line. Then, it includes the Generic sniff that forces method and function braces to be on the following line.
With that change, this code:
<?php
namespace Test;
class Foo
{
public function bar() {
}
}
Will produce no errors, but running PSR2 directly over it produces one error:
FILE: temp.php
----------------------------------------------------------------------
FOUND 1 ERROR AFFECTING 1 LINE
----------------------------------------------------------------------
6 | ERROR | [x] Opening brace should be on a new line
----------------------------------------------------------------------
PHPCBF CAN FIX THE 1 MARKED SNIFF VIOLATIONS AUTOMATICALLY
----------------------------------------------------------------------
Don't bind the client socket. Only the server port is important.
On the server side, just keep the listening socket listening. When the listening socket accepts a connection, it returns a new socket that represents that connection. When you detect a loss of connection, close the corresponding connection socket but leave the listening socket running.
On a side note, IMO the best way to detect a loss of connection is to periodically send data (in both directions).
I have a TCP/IP .NET FAQ on my blog. It is .NET, but the general concepts apply to any TCP/IP scenario.
The feature you have asked for is available from PHP 5.4. Here is the list of new features in PHP 5.4:
http://php.net/manual/en/migration54.new-features.php
And the relevant part from the new features list: