Is PHP an interpreted language or a compiled language?

This article will introduce you to the language types of PHP. It has certain reference value. Friends in need can refer to it. I hope it will be helpful to everyone.

Compiled language

• Use a specialized compiler (similar to Visual Studio under Windows), target specific platforms (operation System) "translates" a certain high-level language source code into machine code (including machine instructions and operands) executed by the platform's hardware at one time, and packages it into an executable program (.exe) format that can be recognized by the platform. , this conversion process is called compilation. The compiled executable program can be separated from the development environment and run independently on a specific platform. After some programs are compiled, they may also need to link other compiled object codes, that is, assemble two or more object code modules to generate the final executable program. In this way, low-level code reuse is achieved.

• Compiled language code is compiled once and used repeatedly. In other words, the predecessors planted trees and the descendants enjoyed the shade.

• C, C, Objective-C, etc. are all compiled languages

##Interpreted languages

• Precompile the source program into an intermediate language before the program is run, and then the interpreter executes the intermediate language

• Every time a program in an interpreted language is executed, it needs to be compiled once, so Programs in interpreted languages ​​usually run less efficiently, and they cannot run independently of the interpreter.

• C#, PHP, Python, Java, etc. are all interpreted languages.

OK, through a simple understanding of the above concepts, you may have a general understanding of interpreted and compiled languages. Since the two share the world equally, let’s take a look at the advantages of each.

Compiled Language

Advantages

• One of the biggest advantages of compiled languages ​​is their execution speed. Programs written in C/C run 30%-70% faster than the same programs written in Java.

Compiled programs consume less memory than interpreted programs.

Disadvantages

• The downside - a compiler is much harder to write than an interpreter

• Compilation The debugger doesn't provide much help when debugging a program - how many times have you encountered a "null pointer exception" in your C code and spent hours trying to figure out where the error was in the code.

• Executable compiled code is much larger than the same interpreted code. For example, C/C .exe files are much larger than Java .class files with the same functionality.

• Compiled programs are platform-specific and therefore platform-dependent.

• Compiled programs do not support implementing security in the code - for example, a compiled program can access any area of ​​memory and do whatever it wants to your PC Thing (most viruses are written using compiled languages)

• Due to loose security and platform dependency, compiled languages ​​are not suitable for developing Internet or Web-based applications.

Interpreted language

Advantages

• Excellent debugging support. It only takes a few minutes for a PHP programmer to locate and fix a "null pointer exception" because the PHP running environment not only indicates the nature of the exception, but also gives the specific line number and function call sequence where the exception occurs (the famous stack trace information). Such convenience is not provided by compiled languages.

• The interpreter is easier to implement than the compiler

• Excellent platform independence

• High degree Security - this is urgently needed for Internet applications

• The size of the intermediate language code is much smaller than the compiled executable code

Disadvantages

• Take up more memory and CPU resources. This is because, in order to run a program written in an interpreted language, the associated interpreter must first be run. Interpreters are complex, intelligent, resource-intensive programs and they take up a lot of CPU cycles and memory.

• The running efficiency is much slower than compiled programs. The interpreter does a lot of code optimization and runtime security checks; these extra steps take up more resources and further slow down the application.

OK, through the above study, I believe everyone has a general understanding of interpreted languages ​​and compiled languages, and PHP language is an interpreted language, and the interpreter that interprets PHP language It's Zend Engine.

Moreover, based on the comparison of the advantages and disadvantages of the two, it can be found that compiled languages ​​are more suitable for low-level operations, while interpreted languages ​​are more used in Web development.

Let’s take a deeper look at the execution process of PHP:

The compilation and execution of PHP are separated, that is: the compilation is completed first, and then executed. Many people will say: The same is true for c, indeed. However, this separation of PHP can provide us with a lot of convenience, but of course it also has many disadvantages.

Let’s talk about the whole process first:

①php will call the compilation function zend_compile_file() to compile. The specific implementation of this function actually includes two main processes: lexical analysis (Lex implementation) and syntax analysis (Yacc implementation). After executing this function: the compilation of the php script is complete. The input of this function is: php script file, and the output is op_array. To put it simply: the compilation process is to parse the script into instructions that the php virtual machine can process, and op_array is just an array made of these instructions ( This is very similar to the assembly code generated by compilation of some compiled languages, which are also commands one by one).

②: The PHP virtual machine will then call the zend_execute() function to execute. The input of this function is the op_array generated in the compilation stage above, where it will parse each command and process it. Since there are about 150 op commands in total, it needs to process these 150 commands. A very interesting question arises here: How does it handle these 150 commands? First of all, each command has a corresponding processor for processing. Therefore: the virtual machine will be distributed to the corresponding processor for processing based on the type of each command in op_array.

There are two small questions here: 1: What is the processor here? 2: How is it distributed?

To answer these two questions, we need to explain it from the distribution mechanism: There are three mechanisms for the PHP virtual machine to distribute commands: CALL, SWITCH, and GOTO. PHP uses the CALL method by default, and That is, all opcode processors are defined as functions and then called by the virtual machine. This method is the traditional method and is generally considered the most stable method. The SWITCH method and the GOTO method distribute opcodes through switch and goto. to the corresponding processing logic (segment) for execution.

Now let’s answer the two questions above:

1: The processor actually processes the logic of the op command. It can exist in the form of a function or a logical segment, depending on how the command is distributed.

2: There are three distribution methods: call, switch and goto. Which one is more efficient? In fact, you can already have a preliminary understanding from the above explanation. Both switch and goto have corresponding logical segments in the zend_execute() function, which can be executed directly. The call executes the function call in the zend_execute() function. It's obvious: function calling efficiency is the lowest, and you have to push it on the stack after calling it once! So in terms of efficiency: call is the lowest. For switch and goto: For example, if you want to execute the processing of the third command: switch must first judge whether it is the first two, while goto does not need to judge at all and jumps directly to the logical code segment of the third command for execution. This is better than Switch reduces the loss of sequential judgment from top to bottom, so: goto efficiency is higher than switch. So these three distribution methods are generally: goto > switch > call

Digression: Since PHP defaults to call, if you want to further drain the performance of PHP, you can change its command distribution method to goto. However, although the goto method improves the execution speed, the compilation speed is actually the slowest.

-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- --

Let’s talk about the weakness of PHP’s separation of compilation and execution:

In fact, it cannot be regarded as a weakness. Although zend engine (php’s virtual machine) strictly separates compilation and execution, but for From the user's perspective: It's like there is no separation, because every time I execute a php script request, I have to execute these two stages: compile->execute. No stage is missing. So we can compare this with a compiled language like c: Run the same request 100 times

①For c, since it only needs to be compiled once in the early stage, it will not be compiled again after it is compiled. , it only needs to be executed, so the loss is:

1 compile and execute 100 times

② For php, it needs to be compiled and executed every time, so the loss is:

100 compilations and 100 executions

Obviously: from a quantitative point of view, the consumption of interpreted languages ​​is much greater than that of compiled languages. To put it bluntly: the separation of compilation and execution of PHP is not a real separation. And c is the real separation.

php has also been aware of this problem for a long time, so it thought of a way to solve this problem: this solution is eAccelerator. The main idea is as follows:

After the script is run for the first time, the compiled script is saved in a certain way (op_array is stored in it). Within the cache validity time specified by us, when the script is run for the second time At this time, there is no need to perform repetitive compilation work, but directly call and execute the compiled file saved previously, which greatly improves program performance.

This method improves the efficiency of PHP to a certain extent, but it is not the ultimate method. The ultimate method is to change it to a compiled language, haha~~~

------------------------------------------------ -------------------------------------------------- ------------------------------------------------

Finally, let’s talk about the advantages of separating PHP compilation and execution;

This advantage is actually for programmers, not for users. Because of the separation of these two stages, we can do some things we want to do here.

For example, if you want to encrypt and decrypt files, you want to encrypt some php script source code files so that users cannot see the source code. At the same time, this encrypted source code file can be parsed and processed by the PHP virtual machine. Of course: to achieve this, you must first think about the encryption and decryption algorithm and ensure that this is a reversible process.

Now that you have encrypted the php source code file, you need to define the suffix of this encrypted file, assuming it is: *.buaa. The question is: How do we enable the PHP virtual machine to process files with this suffix? This requires the separation of compilation and execution mentioned above.

Recall: the input of the compilation phase is the php source file, and the output is op_array. OK, let’s make a fuss at this stage. The main idea is: first in the compilation function zend_compile_file(): look at the suffix of the input file: if it is normal .php, then follow the normal logic; if it is *.buaa, then decrypt it first and then follow the normal logic. . .

Ha~ It’s that simple. Of course: this process is not as simple as said, and you cannot directly modify the zend_compile_file() function. In the end, you need to extend and implement a module yourself to handle this process.

Conclusion:

PHP is an interpreted language. The PHP code is interpreted into opcode and then handed over to the Zend engine for execution.

Use APC to cache opcode, reducing the time for PHP to interpret it as opcode.

Recommended learning: php video tutorial

The above is the detailed content of Is PHP an interpreted language or a compiled language?. For more information, please follow other related articles on the PHP Chinese website!