166.md

# PHP 中的函数

> 原文： [https://zetcode.com/lang/php/functions/](https://zetcode.com/lang/php/functions/)

在 PHP 编程教程的这一部分中，我们讨论函数。

函数是较大程序中的一段代码。 该函数执行特定任务。 使用函数的优点是：

*   减少代码重复
*   将复杂的问题分解成更简单的部分
*   提高代码的清晰度
*   重用代码
*   信息隐藏

有两种基本类型的函数。 内置函数和用户定义的函数。 内置函数是 PHP 语言的一部分。 示例是：`phpinfo()`，`round()`或`abs()`。 用户定义的函数由应用员创建，以满足其需求。 它们是使用`function`关键字创建的。

## PHP 定义函数

使用`function`关键字创建一个函数。

`simple.php`

```php
<?php

function displayVersion() {

    echo "this is PHP " . phpversion();
    echo "\n";
}

displayVersion();

```

`function`关键字后跟带有圆括号的函数名称。 函数的主体位于大括号之间。 我们说我们将称为函数。 如果我们调用一个函数，则会执行函数体内的语句。

```php
displayVersion();

```

该行代码调用该函数。

```php
$ php simple.php 
this is PHP 5.5.9-1ubuntu4.14

```

在这里，我们看到了脚本的结果。

## PHP `return`关键字

`return`关键字用于从函数返回值。 函数可能会也可能不会返回值。

`returning.php`

```php
<?php

function maximum($x, $y) {

    if ($x > $y) { 

        return $x;
    } else {

        return $y;
    }
}

$a = 23;
$b = 32;

$val = maximum($a, $b);
echo "The max of $a and $b is $val \n";

```

我们有一个`maximum()`函数。 它返回两个数字的最大值。 我们无法将其命名为`max`，因为已经有内置的`max()`函数。 创建此示例是出于学习目的； 我们始终希望在现实世界的程序中使用内置函数。

```php
if ($x > $y) { 

    return $x;
} else {

    return $y;
}

```

如果`$x`变量大于`$y`，则返回`$x`。 否则，我们返回`$y`。

```php
$val = maximum($a, $b);

```

`maximum()`函数返回的值分配给`$val`变量。

```php
echo "The max of $a and $b is $val \n";

```

我们将两个数字的最大值打印到控制台。

## PHP 函数参数

大多数函数接受参数。 参数是发送到函数的值。 函数处理值，并可能返回一些结果。

`fahrenheit.php`

```php
<?php

function FTC($c) {

    return $c * 9/5 + 32;
}

echo FTC(100);
echo "\n";
echo FTC(0);
echo "\n";
echo FTC(30);
echo "\n";

```

在我们的示例中，我们将华氏温度转换为摄氏温度。 `FTC()`函数接受一个参数`$c`，即摄氏温度。

```php
$ php fahrenheit.php 
212
32
86

```

## PHP 隐式值

PHP 函数中的参数可能具有隐式值。 如果未提供任何值，则使用隐式值。

`implicit_value.php`

```php
<?php

function power($a, $b=2) {

    if ($b == 2) {

        return $a * $a;
    }

    $value = 1;

    for ($i = 0; $i < $b; $i++) {

        $value *= $a;
    }

    return $value;
}

$v1 = power(5);
$v2 = power(5, 4);

echo "5^2 is $v1 \n";
echo "5^4 is $v2 \n";

```

在这里，我们创建了幂函数。 该函数有一个带有隐式值的参数。 我们可以使用一个或两个参数来调用该函数。

```php
$ php implicit_value.php 
5^2 is 25 
5^4 is 625 

```

## PHP 可变参数数量

一个函数可以接受可变数量的参数。 换句话说，有时我们不知道将有多少参数传递给该函数。 `func_get_args()`函数返回一个包含函数的参数列表的数组。

从 PHP 5.6 开始，`...`运算符可用于创建可变函数。

`variable_arguments1.php`

```php
<?php

function sum(...$nums) {

    $sum = 0;

    foreach ($nums as $n) {
        $sum += $n;
    }

    return $sum;
}

echo sum(1, 2, 3) . "\n";
echo sum(1, 2, 3, 4) . "\n";
echo sum(1, 2, 3, 4, 5) . "\n";

```

我们创建一个`sum()`方法，该方法可以使用可变数量的参数。 该方法计算传递给该方法的值的总和。

```php
$sum = 0;
foreach ($args as $n) {
    $sum += $n;
}

return $sum;

```

我们计算并返回值的总和。

```php
echo sum(1, 2, 3) . "\n";
echo sum(1, 2, 3, 4) . "\n";
echo sum(1, 2, 3, 4, 5) . "\n";

```

我们将三个，四个和五个值传递给`sum()`函数。

```php
$ php variable_arguments1.php 
6
10
15

```

这是输出。

`variable_arguments2.php`

```php
<?php

function sum() {

    $args = func_get_args();

    $sum = 0;
    foreach ($args as $n) {
        $sum += $n;
    }

    return $sum;
}

echo sum(1, 2, 3) . "\n";
echo sum(1, 2, 3, 4) . "\n";
echo sum(1, 2, 3, 4, 5) . "\n";

```

现在，使用`func_get_args()`函数创建相同的示例。

## PHP 静态变量

静态变量是已静态分配的变量，其生存期遍及整个程序运行。 默认的局部变量不会在函数的连续调用中保留其值。

`non_static.php`

```php
<?php

function nonstatic() {

    $value = 0;
    $value += 1;

    return $value;
}

nonstatic();
nonstatic();
nonstatic();
nonstatic();

echo nonstatic(), "\n";

```

在上面的示例中，我们有一个普通的非静态变量。 每次调用函数时，我们都会增加变量。 我们调用该函数 5 次。 但是，对于函数的每次调用都会启动非静态变量。 在 5 个函数调用之后，`$value`等于 2。

首次调用函数时，静态变量仅启动一次。 之后，他们保留自己的值。

`static.php`

```php
<?php

function staticfun() {

    static $value = 0;
    $value += 1;

    return $value;
}

staticfun();
staticfun();
staticfun();
staticfun();

echo staticfun(), "\n";

```

连续 5 次通话后，`$value`等于 5。

```php
$ php nonstatic.php 
2
$ php static.php 
6

```

## PHP 匿名函数

匿名函数没有名称。

`anonymous.php`

```php
<?php

$var = function() {

    echo "This is anonymous function\n";
};

$var();

```

我们将函数主体分配给变量。 只能通过此变量来调用函数。

```php
$var = function() {

    echo "This is anonymous function\n";
};

```

注意右花括号后的分号。 这是必需的，因为构造是分配。

```php
$ php anonymous.php 
This is anonymous function

```

这是示例的输出。

## 通过值和引用传递参数

PHP 支持两种将参数传递给函数的方式。 默认方式是按值传递参数。 当我们按值传递参数时，该函数仅适用于值的副本。 当我们处理大量数据时，这可能会导致性能开销。

当我们通过引用传递值时，该函数会收到对实际值的引用。 修改后，原始值会受到影响。 这种传递值的方式更加节省时间和空间。 另一方面，它更容易出错。

我们应该使用哪种方式传递参数？ 这取决于实际情况。 假设我们有一组数据，即员工工资。 如果我们要计算数据的某些统计信息，则无需修改它们。 我们通过值。 如果我们处理大量数据，并且计算速度至关重要，则可以引用。 如果我们要修改数据，例如进行一些减薪或加薪，我们可以引用一下。

以下两个示例涵盖了这两个概念。

`swap1.php`

```php
<?php

function swap($a, $b) {

    $temp = $a;
    $a = $b;
    $b = $temp;
    echo "inside swap function:\n";
    echo "\$a is $a \n";
    echo "\$b is $b \n";
}

$a = 4;
$b = 7;

echo "outside swap function:\n";
echo "\$a is $a \n";
echo "\$b is $b \n";

swap($a, $b);

echo "outside swap function:\n";
echo "\$a is $a \n";
echo "\$b is $b \n";

```

交换函数在`$a`和`$b`变量之间交换数字。 原始变量不受影响。

```php
$a = 4;
$b = 7;

```

最初，这两个变量被启动。

```php
swap($a, $b);

```

我们称为`swap()`函数。 该函数将`$a`和`$b`变量作为参数。

```php
$temp = $a;
$a = $b;
$b = $temp;

```

在`swap()`函数内部，我们更改值。 请注意，`$a`和`$b`变量是在本地定义的。 它们仅在`swap()`函数内部有效。

```php
$ php swap1.php 
outside swap function:
$a is 4 
$b is 7 
inside swap function:
$a is 7 
$b is 4 
outside swap function:
$a is 4 
$b is 7 

```

输出显示原始变量不受影响。

下一个代码示例通过引用将值传递给函数。 原始变量在`swap()`函数内更改。

`swap2.php`

```php
<?php

function swap(&$a, &$b) {

    $temp = $a;
    $a = $b;
    $b = $temp;
    echo "Inside the swap function:\n";
    echo "\$a is $a \n";
    echo "\$b is $b \n";
}

$a = 4;
$b = 7;

echo "Outside the swap function:\n";
echo "\$a is $a \n";
echo "\$b is $b \n";

swap($a, $b);

echo "Outside the swap function:\n";
echo "\$a is $a \n";
echo "\$b is $b \n";

```

我们使用`&`字符通过引用传递值。

```php
function swap(&$a, &$b) {
...  
}

```

这个例子几乎与前面的例子相同。 除＆字符外。

```php
$ php swap2.php 
Outside the swap function:
$a is 4 
$b is 7 
Inside the swap function:
$a is 7 
$b is 4 
Outside the swap function:
$a is 7 
$b is 4 

```

在这里我们看到`swap()`函数确实改变了变量的值。

## PHP 函数递归

在数学和计算机科学中，递归是一种定义函数的方法，其中所定义的函数在其自己的定义内应用。 换句话说，递归函数调用自身以完成其工作。 递归是迭代的替代方法。 递归是函数式语言中的主要方法。

一个典型的例子是阶乘的计算。

`recursion.php`

```php
<?php

function factorial($n) {

    if ($n==0) {

        return 1;
    } else {

        return $n * factorial($n - 1);
    }
}

echo factorial(4), "\n";
echo factorial(10), "\n";

```

在此代码示例中，我们计算两个数字的阶乘。

```php
return $n * factorial($n - 1);

```

在阶乘函数的主体内部，我们使用经过修改的参数调用阶乘函数。 该函数调用自身。

```php
$ php recursion.php 
24
3628800

```

这些就是结果。

## PHP 全局和局部变量

接下来，我们将讨论 PHP 中变量的范围。 范围是可以引用变量的范围。 当我们使用函数时，有两个基本范围：全局范围和局部范围。 局部作用域也称为函数作用域。

`scope1.php`

```php
<?php

$value = 1;

function simple() {

    var_dump($value);
}

simple();

```

在函数体内定义的变量不能在函数内引用。

```php
$ php scope1.php 
PHP Notice:  Undefined variable: value in /home/janbodnar/prog/php/functions/scope1.php on line 7
NULL

```

`simple()`函数中的`$value`变量为`NULL`。

`scope2.php`

```php
<?php

$value = 4;

function simple() {
    $value = 3;
    echo $value, "\n";
}

simple();

echo $value, "\n";

```

在此示例中，我们有两个具有相同名称的变量。 它们不会冲突，因为它们存在于不同的范围内。

```php
$ php scope2.php 
3
4

```

该值在函数内部为 3，在函数外部为 4。

在下一个示例中，我们将在函数内部修改一个值。

`scope3.php`

```php
<?php

$value = 1;

function simple() {

    global $value;
    $value = 2;
}

echo $value, "\n";
simple();
echo $value, "\n";

```

我们使用`global`关键字来引用在函数主体外部定义的变量。

```php
$ php scope3.php 
1
2

```

`$value`已在`simple()`函数内成功修改。

在 PHP 教程的这一部分中，我们介绍了 PHP 函数。