What is the point of interfaces in a weakly-typed language like PHP?

Question

I've never been able to figure this out. If your language doesn't type-check, what benefits do interfaces provide you?

Answer 1

Interfaces cause your program to fail earlier and more predictably when a subclass "forgets" to implement some abstract method in its parent class.

In PHP's traditional OOP, you had to rely on something like the following to issue a run-time error:

class Base_interface {
    function implement_me() { assert(false); }
}

class Child extends Base_interface {
}

With an interface, you get immediate feedback when one of your interface's subclasses doesn't implement such a method, at the time the subclass is declared rather than later during its use.

Answer 2

You get errors if you haven't added the required methods with the exact same signature.

Answer 3

Interfaces often used with unit-testing (test-driven design).

it also offers you more stable code. the interfaces are also used to support iterators (eg. support for foreach on objects) and comparators.

Answer 4

Taken from this link (sums it up nicely):

• Interfaces allow you to define/create a common structure for your classes – to set a standard for objects.
• Interfaces solves the problem of single inheritance – they allow you to inject ‘qualities’ from multiple sources.
• Interfaces provide a flexible base/root structure that you don’t get with classes.
• Interfaces are great when you have multiple coders working on a project ; you can set up a loose structure for programmers to follow and let them worry about the details.

Answer 5

I personally find interfacing a neat solution when building a DataAccess layer which has to support multiple DBMS's. Each DBMS implementation must implement the global DataAccess-interface with functions like Query, FetchAssoc, FetchRow, NumRows, TransactionStart, TransactionCommit, TransactionRollback etc. So when you're expanding your data-acccess posibilities you are forced to use a generic defined functionschema so you're application won't break at some point because you figured the function Query should now be named execQuery.

Interfacing helps you develop in the bigger picture :)

Answer 6

In my opinion, there's no point, no need and no sense. Things like interfaces, visibility modifiers or type hints are designed to enforce program "correctness" (in some sense) without actually running it. Since this is not possible in a dynamic language like php, these constructs are essentially useless. The only reason why they were added to php is make it look more like java, thus making the language more attractive for the "enterprise" market.

Forgot to add: uncommented downvoting sucks. ;//

Answer 7

It may be weakly typed, but there is type hinting for methods: function myFunc(MyInterface $interface) Also, interfaces do help with testing and decoupling code.

Answer 8

Type hinting in function/method signatures allows you to have much more control about the way a class interfaces with it's environment.

If you'd just hope that a user of your class will only use the correct objects as method parameters, you'll probably run into trouble. To prevent this, you'd have to implement complicated checks and filters that would just bloat your code and definitely have would lower your codes performance.

Type hinting gives you a tool to ensure compatibility without any bloated, hand written checks. It also allows your classes to tell the world what they can do and where they'll fit in.

Especially in complex frameworks like the Zend Framework, interfaces make your live much easier because they tell you what to expect from a class and because you know what methods to implement to be compatible to something.

Answer 9

Types serve three distinct functions:

• design
• documentation
• actual type checking

The first two don't require any form of type checking at all. So, even if PHP did no checking of interfaces, they would still be useful just for those two reasons.

I, for example, always think about my interfaces when I'm doing Ruby, despite the fact that Ruby doesn't have interfaces. And I often wish I could have some way of recording those design decisions in the source code.

On the other hand, I have seen plenty of Java code that used interfaces, but clearly the author never thought about them. In fact, in one case, one could see from the indentation, whitespace and some leftover comments in the interface that the author had actually just copied and pasted the class definition and deleted all method bodies.

Now to the third point: PHP actually does type check interfaces. Just because it type checks them at runtime doesn't mean it doesn't type check them at all.

And, in fact, it doesn't even check them at runtime, it checks them at load time, which happens before runtime. And isn't "type checking doesn't happen at runtime but before that" pretty much the very definition of static type checking?