What is the difference between static functions an

问题:

I need to have method to get something from a database, but I don't understand the difference between static and normal functions in PHP.

Example code

class Item {
    public static function getDetail($arg) {
        $detail = $this->findProductId($arg);   
        return $detail;
    }

    private function findProductId($id) {
        //find product_id in database where id = $arg
        //return detail of product
    }
}

and function outside of a class

function getDetail($arg) {
    $detail = findProductId($arg);
    return $detail;
}

If I use $item = Item::getDetail(15); and $item = getDetail(15); — they're the same.

1. What is the difference between static and function outside of a class?
2. If they are difference, How to use static function and function outside of a class? (I'd appreciate a really simple example.)
3. What are the performance properties between static and function outside of a class? Which is better?

回答1:

1) What is difference between static function and normal function

While they are functions, I'd prefer to call them methods of a given class. One is a static method and the other is an instance method.

Static Method: $item = Item::getDetail(15);

Instance Method: $item = getDetail(15);

(refer to FuzzyTree's correct syntax above in the comments, however.)

2) How to use static function and normal function (if you simple exemplify is good)

Static means you do not have to instantiate (declare an object reference). That is, you can simply use the method. So, in your example, while the answer may be the same, the way you called that method/function is different, as you noted above.

In Java, for example, you have the Math class. It does not require instantiation to use, and in fact you cannot that I know of because its constructor is private. You can simply use a method by referencing the class and the method name you wish to use,

Math.pow(d1, d2);  //no instantiation needed

in PHP this might be,

MyClass::pow(d1,d2); //no instantiation needed

Java: when to use static methods

3) Ask performance between static function and normal function. Which is better?

Better is a matter of your design. If you have to create an object every time you want to do the power of a number that will create more memoryusage than simply using the class directly. I do not have benchmark proof, but it seem logical since you are not handling the method the same way in memory. I do not think it will matter in real world unless you are doing a lot of complicated actions.

Performance of static methods vs instance methods

might also interest you.

回答2:

I'm assuming you're asking about the difference between a static method:

class Item {
    public static function getDetail($arg){}
}

And a function written outside of a class definition:

function getDetail($arg){}

Static methods should be used over functions written outside of a class for organizational reasons. In an application with many files, having Item::getDetails($arg) will give a hint of where that function is defined. Also, having just a function written outside of a class runs the risk of name collision, if you start writing many functions outside classes.

Especially if you are writing in the OOP style, you should be using static methods over functions outside of class definitions, but I think even in general, using static methods is the better way to go.

回答3:

1.Entire difference is, you don't get $this supplied inside the static function. If you try to use $this, you'll get a Fatal error: Static functions are associated with the class, not an instance of the class and You will get an E_strict warning in the second case.

2.Now static calling of non-static methods works but is deprecated. so use normal function.

3.Technically speaking Static methods and variables are useful when you want to share information between objects of a class, or want to represent something that's related to the class itself, not any particular object. For some reason, PHP allows you to call non-static and static methods interchangeably,So performance wise or in whatever way you may say just use a normal function.Static is not going to help you at all

回答4:

The difference between static and non static is that you can access a static method without having an instance of the class.

$item = getDetail(15); shouldn't work because detDetail is a method in a class and not a function.

Performance of Static Methods

There used to be a big penalty when calling a static method - but it's fixed in 5.4.0. See http://www.micro-optimization.com/global-function-vs-static-method

回答5:

The difference about static and non static functions is a big answer and we have to look at Object Oriented Programming (OOP) in general.

OOP in general, as you should know, is about Classes and Object, a class describe and creates objects based of it's description.

If you tell the class to contain the function "A" the object will have a callable function "A" who will have access to the objects parameters.

However if you tell the class to have a static function you tell the class to have a callable function WITHOUT instantiate an object.

Confusing? Can be at first and hard to understand why it's sometimes needed when you take your first OOP steps. Static functions is a good way to share info about classes without the need to make an object.

An analgy would be: Take the class Car and the object BMW. the objects functions is about THE BMW, a static functions is about cars in general.

As of performance, it's not about performance at all, it's about design patterns. So performance-wise there is nothing to gain if the functions is static or non static.

回答6:

From what the other guy said, if it uses more memory one way versus the other it will absolutely cause a performance difference. If you're using so much memory to the point of going into GC, it can cause queuing of processes due to backup, due to gc and take the whole system down potentially if it's an enterprise system with thousands of concurrent users. It may depend on the scale of the application.

We should never be of the opinion that a change in memory utilization is "minor". It's never minor in big systems...