How to write a function?

Programs once contained subroutines and functions (maybe I didn’t experience this era). Today, only functions remain in programs.

Functions in programming languages ​​are divided into built-in functions and custom functions or class methods. Built-in functions can be called directly, while custom functions are written by programmers.

Function is an extremely important part of the program. To write it well, you need to follow some principles.

Functions should be short. Nested structures such as if...else, etc. should not be allowed in functions. In nested structures such as if..else, while, for or foreach, the code should not exceed one line. This only line of code is a call to the function. Please see code A.

function test($bool){
         $age = 0;
         if($bool){
               $age = 5;
          }else{
                $age = 0;
          }
          return  $age;
}
$bool = true;
echo test($bool);

The above code contains if...else and nested structure in the function body. According to the principle of "the function should be short", the above code should be rewritten as code B:

function testTrue(){
        $age = 5;
         return $age;
}

function testFalse(){
        $age = 0;
        return $age;
}

$bool = true;
if($bool){
      echo testTrue();
}else{
        echo testFalse();
}

I like to use code B style code. It can simplify backbone code (code with a high level of abstraction). In actual programming, I combined code A and code B because I added a function test based on code B. Please see code C.

function testTrue(){
       $age = 5;
       return $age;
}
function testFalse(){
        $age = 0;
        return $age;
}
function test($bool){
        $age = 0;
        if($bool){
             $age  =  testTrue();
         }else{
              $age  =  testFalse();
   }
$bool = true;
echo test($bool);

Three styles of code, which one is better? I can't tell. In programming practice, I choose C-style code. The reason for writing short functions is that short functions are easy to read and facilitate debugging. Of course, it is also subject to the programming principles summarized by many programmers in their programming practice: a function only does one thing.

"The Way of Clean Code" emphasizes this programming principle in these words: For more than thirty years, countless people have conveyed the point of view in countless different expressions that a function should only do one thing; the function should do it well This thing; this function should do this thing.

To master this principle, you must understand: What do you call a thing? One thing means that these things are at the same abstract level. For example, function A saves order data to the database, and in the process creates coupon numbers and sends text messages. On the surface, there are three things, but since they are all at the same level of abstraction, there is actually only one thing. If the code in creating a coupon number is used to replace the create coupon number function, function A does two things.

In addition, reading functions (to...do) "from top to bottom" is also a good way to distinguish whether a function does one thing. It is not easy for junior programmers to learn this skill.

Look at the sections of the function, that is, whether a function can be split into other functions. It is also a way to identify whether a function only does one thing.

I think that based on the "abstraction level", you can judge whether a function only does one thing.