分支结构

单分支

<?php

$n = 5;
if ($n > 10) {
  echo "大于";
}

双分支

<?php
$n = 5;

if ($n > 10) {
  echo "大于";
} else {
  echo "小于";
}

// 三元
echo $n > 10 ? "大于": "小于";

多分支

<?php
// if elseif else
$n = 5;
if ($n > 10) {
  echo "大于10";
} else if($n > 8) {
  echo "小于8";
} else {
  echo "既不大于 10 也不大于 8"
}

// switch
switch($n) {
  case $n>10:
    echo "greater than 10";
  break;
  case $n>8:
    echo "greater than 10";
  default:
    echo "less than 8 and 10";
}

循环结构

这两个关键字都是有的, 而且作用和 C 是一样的

• continue
• break

for 循环

<?php
for ($i = 0; $i < 5; $i++) {
  echo "{$i}<br/>";
}

while 循环

<?php
$i = 0;

while ($i < 5) {
  // 依次输出: 0,1,2,3,4
  echo "i = {$i}<br/>";
  $i += 1;
}

$j = 0;
do {
  // 依次输出: 0,1,2,3,4
  echo "j = {$j} <br/>";
  $j += 1;
} while ($j < 5);

foreach 循环

<?php
$arr = ["1", "2", "3", "4", "5"];

# 获取数组元素的下标和值
foreach ($arr as $key => $val) {
  // 输出:
  // 0: 1
  // 1: 2
  // 2: 3
  // 3: 4
  // 4: 5
  echo "{$key}: {$val}<br/>";
}

# 仅仅获取数组元素的值
foreach ($arr as $val) {
  // 输出:
  // value: 0
  // value: 1
  // value: 2
  // value: 3
  // value: 4
  echo "value: {$val}<br/>";
}

PHP 8 新语法: match

Rust: 你怎么肉眼可见的 "锈化了" 🤣

<?php

$fruit = "apple";

// 1.类似 switch 语句
// default: 表示匹配其他所有值
// 作用相当于 switch 语句中的 default
$res1 = match ($fruit) {
  "banana" => "is banana",
  "apple" => "is apple",
   default => "is unknown fruit"
}; // 注意: 这是一个表达式, 所以行末必须加 ; 结尾
echo $res1; // is apple
echo "<br/>";

// 2.使用match必须要穷尽所有可能的值, 否则报错
$n = 10;
$res2 = match ($n) {
  $n > 20  => "greater than 20",
  $n == 20 => "equal to 20",
  default  => "unknown number"
  // 不加 default 这行就报错: 因为 $n 可能小于10, 让上面两个表达式无法成立
  // 报错信息如下:
  // Fatal error: Uncaught UnhandledMatchError: Unhandled match case 10
};
echo $res2; // unknown number
echo "<br/>";

// 3.与switch语句的不同
// match 匹配的是表达是的结果, 而不是表达式是否返回 true
$res3 = "";
switch ($n)  {
  case $n > 20:
    $res3 = "greater than 20";
  break;
  case $n == 20:
    $res3 = "equal to 20";
  break;
  case $n < 20:
    $res3 = "less than 20";
  break;
  default:
    $res3 = "unknown number";
};
echo $res3; // less than 20
echo "<br/>";

$res4 = match ($n) {
  $n > 20  => "greater than 20",
  $n == 20 => "equal to 20",
  $n < 20  => "less than 20",
  default  => "unknown number"
};

echo $res4; // unknown number
echo "<br/>";

/*
为什么会这样?
因为: match 匹配的是表达式的结果, 而不是表达式的值是否为真

$res4 = match ($n) {
  $n > 20  => "greater than 20", 表达式结果 false, false === 10 吗? 不等,所以不匹配
  $n == 20 => "equal to 20",     表达式结果 false,
  $n < 20  => "less than 20",    表达式结果 true,  true === 10 吗? 不等,所以也不匹配
  default  => "unknown number"   不管表达式返回什么, 只要什么没有匹配到,就会走这个默认的值
}


还有一个小细节:
由于 match 表达式, 必须要穷尽所有可能的值, 否则报错
如果 $res4 = match 这个表达式, 如果去掉 default 就会报错
因为如果没有 default, 那么就没有穷尽所有可能的值:
因为上面三个表达式的结果都不能匹配到 10 这个值
--------------------------------------------------------

如果想要 $res4 = match 这个表达式的效果和 switch
语句的效果一样, 可以这样做: 去匹配 true, 而不是匹配 $n 的值
因为任意两个数字对比大小: 只能有3种结果, 大于/小于/等于

$res5 = match (true) {
  $n > 20  => "greater than 20", 表达式结果 false, false === true 吗? 不等,所以不匹配
  $n == 20 => "equal to 20",     表达式结果 false,
  $n < 20  => "less than 20",    表达式结果 true,  true === true 吗? 相等,所以匹配到了
}
echo $res5; // less than 20
*/
$res5 = match (true) {
  $n > 20  => "greater than 20",
  $n == 20 => "equal to 20",
  $n < 20  => "less than 20",
};
echo $res5; // less than 20
echo "<br/>";