Share the latest 28 PHP interview questions in 2023 (with answers)-PHP Tutorial-php.cn

This article compiles and shares 28 PHP interview questions (with answers to share) to help you sort out the basic knowledge. It has certain reference value. Friends in need can refer to it. I hope it will be helpful to everyone.

Share the latest 28 PHP interview questions in 2023 (with answers)

Related recommendations: 2023 PHP interview questions summary (collection)

After the New Year I plan to look for new job opportunities, but I found that my understanding and study of many basic interviews were not deep enough before. In order to encourage myself to keep moving forward, I recently started to learn and summarize relevant knowledge on forums and search engines. Some of the questions are from the forums. Questions or answers shared by seniors, and some of them are questions I encountered in recent interviews. Based on my own understanding and the sharing of seniors, I have archived some of them, so I share them in the hope that they will be helpful to other friends. I also hope that I can receive guidance from the experts on misunderstandings, and will continue to update in the near future

1. The underlying implementation principle of PHP arrays

1 , the underlying implementation is through a hash table (hash table) doubly linked list (resolving hash conflicts)

hashtable: calculate the hash of different keywords (keys) through the mapping function Value (Bucket->h) thereby directly indexing to the corresponding Bucket
The hash table saves the pointer of the current loop, so foreach is faster than for
Bucket: Save the key and value of the array elements, as well as the hash value h

2. How to ensure orderliness

1. Add a mapping table with the same size as the storage element array between the hash function and the element array (Bucket).
2. The subscript used to store the elements in the actual storage array
3. The elements are inserted into the actual storage in the order of the mapping table
in the array 4. The mapping table is just a theoretical idea. In fact, there is no actual mapping table. Instead, when the Bucket memory is allocated during initialization, the same Amount of space the size of uint32_t, and then offset arData to the location where the array of elements is stored.

3. Solve hash duplication (linked list method used by PHP):

1. Linked list method: different keys When the words point to the same unit, use a linked list to save the keyword (traverse the linked list to match the key)
2. Open addressing method: When the keyword points to a unit where data already exists, continue Search for other units until an available unit is found (occupying the position of other units, more prone to hash conflicts, performance degradation)

4. Basic knowledge

Linked list: queue, stack, two-way linked list,
linked list: pointer of the element pointing to the next element
bidirectional Linked list: Pointer to the previous element Pointer to the next element Complexity and space complexity

2. Time complexity and space complexity of bubble sort

1. Code implementation

         $arr = [2, 4, 1, 5, 3, 6];
         for ($i = 0; $i < (count($arr)); $i++) {
             for ($j = $i + 1; $j < (count($arr)); $j++) {
                 if ($arr[$i] <= $arr[$j]) {
                     $temp = $arr[$i];
                     $arr[$i] = $arr[$j];
                     $arr[$j] = $temp;
                 }
             }
         }
     result : [6,5,4,3,2,1]

Copy after login

2. Calculation principle

First round: Compare the first element of the array with all other elements , whichever element is larger, change the order, thus bubble up the first largest (largest) element

First round: Combine the second element of the array and all other elements Compare (the first largest element has been filtered out, no need to continue comparing), whichever element is larger, change the order, so that the second largest element

... and so on , an array sorted by bubbles from large to small
Average time complexity:
O(n^2)
;
Optimal time complexity Degree:
O(n)
, need to add judgment. If there is no exchange in the first loop, jump out of the loop directly

Space complexity:

O(1) , the space occupied by temporary variables when exchanging elements

Optimal space complexity:

O(1), sorted, no need to swap positions

3. Time complexity and space complexity

Time complexity: The whole process is asymptotic time complexity, estimating the usage efficiency of the processor (describing the efficiency trend of the algorithm, not referring to the specific use of the algorithm time, because the performance of different machines is inconsistent, it is just a general method of efficiency calculation)

Representation method: Big O notation

Complexity metric level:

Constant order O(1)

Linear order O(n)

Square order O(n²)

Cubic order O(n³ )

Kth power order O(n^k)

Exponential order (2^n)

Logarithmic order O(logN)

Linear logarithmic order O(nlogN)

Time replication type:

Best time complexity
Worst time complexity
Average time complexity
Amortized time complexity

Space complexity: the asymptotic space complexity of the whole process, estimating the usage of computer memory (describing the storage space occupied by the algorithm Trend, not actual occupied space, same as above)

Reference:
This article talks about the time complexity and space complexity of the algorithm

3. Seven-layer network protocols and TCP and TCP

Application layer, presentation layer, session layer, transport layer, network layer, (data) link layer, physical layer

Memory routine:

First word: Response to form and transfer (Things Chain Network)

First word: Application layer (occurs many times, easy to remember)

The first four forward directions: should be expressed - will be transmitted

The last three reverse directions: the homophony of the Internet of Things is easier to remember than the Internet of things

4. TCP and UDP The characteristics and differences

1. They all belong to the transport layer protocol

2.TCP

Connection-oriented, so it can only be one-to-one
Oriented to byte stream transmission
The data is reliable and will not be lost
Full-duplex communication

3. UDP (reverse according to TCP characteristics)

No connection, supports one-to-one, one-to-many, many-to-many
Insulation-oriented transmission
The header overhead is small, and the data Not necessarily reliable but faster

5. TCP’s three-way handshake and four-way wave

1. Three-way handshake:

1) First time: client sends SYN = 1,seq = client_isn
Function:
Client: None
Server: Confirm its own receiving function and client’s sending function
2) Second time: Server sends SYN = 1, seq = server_isn, ACK =client_isn 1
Function:
Client: Confirm that its own sending and receiving are normal, confirm that the server's receiving and sending are normal
Server: Confirm that its own receiving and receiving are normal, confirm that the server's receiving and sending are normal The sending is normal (at this time, the server cannot confirm whether the client is receiving normally)
3) The third time: the client sends SYN = 0, ACK = server_isn 1, seq =client_isn 1
Function: Both parties confirm that each other’s reception and transmission are normal and establish a connection

2. Wave four times

1) The first time: the client sends FIN
Function: Tell the server that I have no data to send (but can still receive data)
2 ) The second time: The server sends ACK
Function: Tells the client that the request has been received. The server may still have data to send, so the client enters the FIN_WAIT state upon receipt and waits for the server data transmission to complete Then send FIN
##3) The third time: The server sends FIN
Function: The server tells the client that I have finished sending and the connection can be closed.
4) The fourth time: the client sends ACK
Function: After receiving the FIN, the client is worried that the server does not know to close, so it sends an ACK. Enter TIME_WAIT and wait for 2MSL. If no reply is received, it proves that the server has been closed. At this time, the client also closes the connection.

Note:

When receiving the other party’s FIN message, it only means that the other party no longer sends data but can still receive data
You need to wait for 2MSL in the end because the network is unreliable. If the server does not receive the last ACK, the server will replay the FIN packet and wait for the client to send the ACK packet again and then close. (So the client cannot close the connection immediately after sending the last ACK)

6. HTTP status code

1. Status code classification

- 1xx: Information, the server received the request and the requester needs to continue the operation
- 2xx: Success
- 3xx: Redirect
- 4xx: Client Error
- 5xx: Server Error

2. Common status codes

200: Request successful
301: Permanent redirection
302: Temporary move
401 unauthorized: The client has no permission
403 forbidden: The server refuses the client request
##404 not found: The resource requested by the client does not exist
500 Internal Server Eerro: Server internal error
502 bad gateway: Working as a gateway or proxy The server received an invalid response from the upstream server while trying to perform the request
503 Service Unavailable Overload or system maintenance
504 Gateway timeout: Gateway Timeout

3. Reasons and solutions for 502

Cause: nginx submits the request to the gateway (php-fpm) to handle the exception

1) The fastcgi buffer is set too small

fastcgi_buffers 8 16k;

fastcgi_buffer_size 32k;

2) The number of php-cgi processes is set too few

Check the number of FastCgi processes:

netstat -anpo | grep "php-cgi"| wc -l

Adjust parameters Maximum number of child processes:

max_children

Generally, the number of child processes that need to be set is calculated based on a single process of 20M

3) max_requests (memory overflow or frequent restarts)

The parameter specifies the maximum number of requests that each child can handle. Children will be restarted after reaching the maximum value.

Setting too small may lead to frequent restart of children:

PHP will poll the request to each child. In a large traffic scenario, the time for each child to reach the maximum value is almost the same. If set If it is too small, multiple children may be closed at the same time, nginx cannot forward the request to php-fpm, the CPU will be reduced, and the load will become high.

Setting too large may cause memory leaks

4) PHP execution time exceeds nginx waiting time

fastcgi_connect_timeout

fastcgi_send_timeout

fastcgi_read_timeout

5) fastcgi execution time

max_execution_time

Reference:

Learn more about how to optimize php php-fom nginx configuration parameters
What should I do if nginx reports error 502? Solution sharing

7. The difference between http and HTTPS

1. Port: http 80; https: 443

2. http is stateless, https is a protocol built with http ssl that can perform encrypted transmission

3. http plain text transmission, https encrypted transmission

4. http is faster, with three three-way handshakes Package, https requires 12 packages (3 tcp packages and 9 ssl handshake packages)

8. Redis distributed locks and issues

1. Implementation ：

Locking: setnx

Unlocking: del

Lock timeout: expire

2. Possible problems

1) The problem of non-atomicity of setnx and expire (it hangs before the timeout can be set after locking)
Solution:
Redis 2.6.12 or above adds optional parameters to the set instruction. The pseudo code is as follows: set (key, 1, 30, NX), which can replace the setnx instruction
2) Other process locks are accidentally deleted after timeout. (The execution of process A times out, causing the lock to be released. At this time, process B acquires the lock and starts processing the request. When process A completes the processing, the lock of process B will be deleted by mistake)
Solution: You can only delete the lock of your own process Lock (lua script prevents process B from accidentally deleting the lock of process A after acquiring the expired lock)
3) Concurrency scenario, the execution timeout of process A causes the lock to be released, and process B acquires the lock at this time .
Solution: Start the daemon process and delay the lock for the current process to expire.
4) Single point instance security issue
After a single machine crashes, all clients cannot obtain the lock
Solution:
Master-slave replication cannot be completely solved because it is completed asynchronously

Reference:

Redis requires attention when implementing distributed locks What? [Summary of Notes]
Take you in-depth understanding of distributed locks in Redis

9. Why is redis single-threaded? Why fast?

Recommended reading: https://www.php.cn/redis/475918.html

10. Data types and applications of redis Scenario

1. String:

Ordinary key/value storage

2. Hash:

Hashmap: key-value team collection, storing object information

3, list:

Doubly linked list: message queue

4 , set:

hashMap whose value is always null: unordered set and non-repeating: calculate intersection, union, difference set, deduplication value

5, zset ：

Ordered collection without duplication: hashMap (remove duplication) skiplist jump table (guaranteed order): Ranking list

Reference:

The 5 data types and application scenarios of Redis

11. The method, principle and characteristics of redis to achieve persistence

1. RDB persistence (snapshot): The memory data set snapshot within the specified time interval is written to the disk (dump.rdb), when the child process writes the snapshot content, the new file replaces the old file

2) The entire redis database only contains one backup file

3) Maximize performance, Only the fork child process is needed to complete the persistence work and reduce disk IO

4) Downtime before persistence may cause data loss

2. AOF persistence: in the form of logs Record all write and delete operations of the server

1) Each time a write command is received, use the write function to append to the file appendonly.aof

2) The persistent file will be longer than As it gets bigger, there are a lot of redundant logs (0 increases from 100 times to 100, 100 log records will be generated)

3) Different fsync policies can be set

Reference:

Detailed explanation of the persistence principle of Redis in-depth learning
A brief analysis of RDB and AOF persistence, what are the advantages and disadvantages? How to choose?

12. Flash sale design process and difficulties

1. Static cache

2. nginx load balancing

Three methods: DNS polling, IP debt balancing, CDN

3, current limiting mechanism

Method: IP current limit, interface token current limit, user current limit, header dynamic token (front-end encryption, back-end decryption)

4, distributed lock

Method:

5. Cache data

Method:

6. Inventory and order

The above is the detailed content of Share the latest 28 PHP interview questions in 2023 (with answers). For more information, please follow other related articles on the PHP Chinese website!