PHP 學習筆記(持續更新中)

<?php
$foo = true; // 設置foo變數為true
?>

<?php
// 兩個等於代表操作符，檢測兩個遍量是否相等，返回布林值
if ($password == '123'){
    echo 'pass';
}

// 這樣寫是不必要的
if ($check == true){
    echo 'check in';
}

// 可以使用以下方式
if ($check){
    echo 'check in';
}
?>

<?php
$a = 10; // 十進位
$a = 012; // 八進位 (等於十進位 10)
$a = 0xa; // 十六進位 (等于十進制 10)
$a = 0b1010; // 二進制数字 (等于十進制 10)
$a = 1_0_1_0_; // 整型数值 (PHP 7.4.0 以后)輸出1010
?>

<?php
// var_dump()方法是判斷一個變量的類型與長度,並輸出變量的數值
$large_number = 2147483647;
var_dump($large_number); // int(2147483647)

$large_number = 2147483648;
var_dump($large_number); // float(2147483648)
?>

<?php
$num = 99.01;
$num = -50.30;
?>

<?php
$text = 'This is test string';
echo $text; // 輸出: This is test string
?>

<?php
// 可以直接將變數帶入
$food = 'noodles';
echo "Hi \n"; // 換行
echo "I like to eat $food";
?>

<?php
$arry = array( 0 => 'apple',
               1 => 'tomato',
               2 => 'banana',);
echo $arry[0]; // apple

// 可以使用以下短數組語法
$arry = [ 0 => 'apple',
          1 => 'tomato',
          2 => 'banana',];
echo $arry[0]; // apple
?>

<?php
$array = array("apple", "tomato", "banana", );
var_dump($array);

// 輸出
array(4) {
  [0]=>
  string(5) "apple"
  [1]=>
  string(6) "tomato"
  [2]=>
  string(6) "banana"
}
?>

<?php
$map = array( 'version' => 4,
              'OS' => 'Linux',
              'lang' => 'english',
              'short_tags' => true
        );

// . . .完全等同於:
$a = array();
$a['version'] = 4;
$a['os'] = 'Linux';
$a['lang'] = 'english';
$a['short_tags']  = true;

unset($a['os']); // 刪除 "Linux"
?>

<?php
$maps = array( 'version' => 4,
              'OS' => 'Linux',
              'lang' => 'english',
              'short_tags' => true
        );

foreach ($maps as $key => $value) {
    echo "$key is $value\n";
}
// version is 4
// OS is Linux
// lang is english
// short_tags is 1
?>

<?php
sort($files); // 對value排序
print_r($files);
?>

<?php
function gen(): iterable { // 建立一個可迭代生成器
    yield 1;
    yield 2;
    yield 3;
}
$iterable = gen(); // 實例化
foreach($iterable as $value){
    echo "$value\n";
}
// 輸出
// 1
// 2
// 3

// 答案相同
function gen(): iterable {
    return [1, 2, 3];
}
$iterable = gen();
foreach($iterable as $value){
    echo "$value\n";
}
?>

<?php
class SayHi
{
    function do_sayhi()
    {
        echo "Hello.";
    }
}

$bar = new foo;
$bar->do_sayhi(); // Hello
?>

<?php
$obj = (object) array('1' => 'foo');
var_dump(isset($obj->{'1'})); // PHP 7.2.0 後輸出 'bool(true)'，之前版本會輸出 'bool(false)'
var_dump(key($obj)); // PHP 7.2.0 後輸出 'string(1) "1"'，之前版本輸出  'int(1)'
?>

<?php
$obj = (object) 'hello';
echo $obj->scalar;  // outputs 'hello'
?>

<?php
$var = NULL;
?>

<?php
$firstName = 'Wang';
$lastName = 'Joe';
echo "$firstName, $lastName";      // 输出 "Wang, Joe"

$4site = 'not yet';     // 非法變數名；以數字開頭
$_4site = 'not yet';    // 合法變數名；以底線開頭
$i站點is = 'TW';  // 合法變數名；可以用中文
?>

<?php
define("CONSTANT", "Hello world.");
echo CONSTANT; // 輸出 "Hello world."
echo Constant; // 拋出錯誤：未定義的常量 "Constant"
               // 在 PHP 8.0.0 之前，输出 "Constant" 會併發出一個提示級別錯誤訊息
?>

<?php
// 簡單的標量值
const CONSTANT = 'Hello World';

echo CONSTANT;

// 標量表達式
const ANOTHER_CONST = CONSTANT.'; Goodbye World';
echo ANOTHER_CONST;

const ANIMALS = array('dog', 'cat', 'bird');
echo ANIMALS[1]; // 將輸出 "cat"

// 常量數組
define('ANIMALS', array(
    'dog',
    'cat',
    'bird'
));
echo ANIMALS[1]; // 將輸出 "cat"
?>

<?php
namespace UserModel {
    class User {
        public function __construct() {
            echo 'I am in '.__CLASS__."\n";
        }
        public function showData() {
            echo 'I am in '.__METHOD__."\n";
        }
    }

    $obj = new User;
    $obj->showData();
    echo __NAMESPACE__;
}
?>

// outputs
// I am in UserModel\User
// I am in UserModel\User::showData
// UserModel

<?php
$a = 1;
$b = 2;
echo $a + 1 * $b; // output: 3
?>

<?php
$output = `ipconfig /all`;
echo "<pre>$output</pre>"; // 輸出所有IP資訊
?>

<?php
echo "後增量(PostIncrement)\n";
$a = 5;
echo "Should be 5: " . $a++ . "<br />\n";
echo "Should be 6: " . $a . "<br />\n";

echo "先增量(PreIncrement)\n";
$a = 5;
echo "Should be 6: " . ++$a . "<br />\n";
echo "Should be 6: " . $a . "<br />\n";

echo "後減(PostDecrement)\n";
$a = 5;
echo "Should be 5: " . $a-- . "<br />\n";
echo "Should be 4: " . $a . "<br />\n";

echo "先減(Predecrement)\n";
$a = 5;
echo "Should be 4: " . --$a . "<br />\n";
echo "Should be 4: " . $a . "<br />\n";
?>

<?php
$a = "Hello ";
$b = $a . "World!";
echo $b."\n"; // output "Hello World!"

$a = "Hello ";
$a .= "World!";     // output "Hello World!"
echo $a;
?>

<?php
$a = array("a" => "apple", "b" => "banana");
$b = array("a" => "pear", "b" => "strawberry", "c" => "cherry");

$c = $a + $b; // Union of $a and $b
var_dump($c);

$c = $b + $a; // Union of $b and $a
var_dump($c);

// 輸出:
// array(3) {
//   ["a"]=>
//   string(5) "apple"
//   ["b"]=>
//   string(6) "banana"
//   ["c"]=>
//   string(6) "cherry"
// }

// array(3) {
//   ["a"]=>
//   string(4) "pear"
//   ["b"]=>
//   string(10) "strawberry"
//   ["c"]=>
//   string(6) "cherry"
// }
?>

<?php
$a = array("apple", "banana");
$b = array(1 => "banana", "0" => "apple");

var_dump($a == $b); // bool(true)
var_dump($a === $b); // bool(false)
?>

<?php
class MyClass
{
}

class NotMyClass
{
}
$a = new MyClass;

var_dump($a instanceof MyClass);
var_dump($a instanceof NotMyClass);
?>

// 輸出
// bool(True)
// bool(False)

<?php
if ($a > $b){
console.log("a win");
}else {
console.log("b win");
}
?>

<?php
if($a > $b){
    echo "a is bigger than b";
}
elseif($a == $b){
    echo "a is equal to b";
}else{
    echo "a is smaller than b";
}
?>

<?php
$i = 1;
while ($i <= 10) { // i > 10停止迴圈
    echo $i++; // 先輸出 i 後再加一
}
?>

<?php
$i = 0;
do{
    echo $i;
} while($i<0);
?>

<?php
/* example 1 */

for ($i = 1; $i <= 10; $i++) {
    echo $i;
}

/* example 2 */

for ($i=1; ; $i++){
    if　($i > 10){
        break;
    }
    echo $i;
}

/* example 3 */

for (;;){
    if ($i > 10) {
    break;
}
    echo $i;
    $i++;
}

/* example 4 */

for ($i = 1, $j = 0; $i <= 10; $j += $i, print $i, $i++);
?>

<?php
/* foreach example 1: value only */
$arr = array(2, 4, 6, 8);
foreach($arr as $value){
    echo "value = $value \n";
}

/* foreach example 2: key and value */
$arr = array(
    "name" => "joe",
    "cel" => 1234567,
    "address" => "Taiwan"
);
foreach($arr as $key => $value){
    echo "$key => $value \n";
}
?>

/* foreach example 3: dynamic arrays */

foreach (array(2, 4, 6, 8, 10) as $v) {
    echo "$v\n";
}

<?php
$array = [
[1, 2],
[3, 4],
];

foreach ($array as list($a, $b)) {
    // $a contains the first element of the nested array,
    // and $b contains the second element.
    echo "A: $a; B: $b\n";
}
?>

<?php
$array = [
[1, 2],
[3, 4],
];

foreach ($array as list($a)) {
    // Note that there is no $b here.
    echo "A: $a;\n";
}
?>

<?php
$arr = array('one', 'two', 'three', 'four', 'stop', 'five');
// 使用each() 和list() 結合用來遍歷數組
while (list (, $val) = each($arr)) {
    if ($val == 'stop') {
        break;    /* You could also write 'break 1;' here. */
    }
    echo "$val<br />\n";
}

/* 使用可選参数 */

$i = 0;
while (++$i) {
    switch ($i) {
    case 5:
        echo "At 5<br />\n";
        break 1;  /* 只退出 switch. */
    case 10:
        echo "At 10; quitting<br />\n";
        break 2;  /* 退出 switch 和 while 循环 */
    default:
        break;
    }
}
?>

<?php
for($i=1; $i<5; $i++){
    if($i==2){
        continue;
    }
    echo "$i\n";  // outputs: 1 3 4
}
?>

<?php
if ($i == 0) {
    echo "i equals 0";
} elseif ($i == 1) {
    echo "i equals 1";
} elseif ($i == 2) {
    echo "i equals 2";
}

switch ($i) {
    case 0:
        echo "i equals 0";
        break;
    case 1:
        echo "i equals 1";
        break;
    case 2:
        echo "i equals 2";
        break;
}
?>

<?php
switch ($i) {
    case 0:
        echo "i equals 0";
        break;
    case 1:
        echo "i equals 1";
        break;
    case 2:
        echo "i equals 2";
        break;
    default:
        echo "i is not equal to 0, 1 or 2";
}
?>

<?php

$age = 23;

$result = match (true) {
    $age >= 65 => 'senior',
    $age >= 25 => 'adult',
    $age >= 18 => 'young adult',
    default => 'kid',
};

var_dump($result);
echo($result);
?>

// outputs:
// string(11) "young adult"
// young adult

declare (directive)
statement

<?php
// 兩個相等：

// 可以這樣用：
declare(ticks=1) {
    // 這裡寫腳本
}

// 也可以這樣用：
declare(ticks=1);
// 這裡寫腳本
?>

<?php
// 有效程式碼：
declare(ticks=1);

// 無效，無法指定常量：
const TICK_VALUE = 1;
declare(ticks=TICK_VALUE);
?>

<?php

declare(ticks=1);

// 每次 tick 事件都會調用此函数
function tick_handler()
{
    echo "tick_handler() called\n";
}

register_tick_function('tick_handler');

$a = 1;

if ($a > 0) {
    $a += 2;
    print($a);
}

?>

<?php
declare(encoding='ISO-8859-1');
// code here
?>

// 正常情況下
<?php
function add(int $a, int $b): int
{
    return $a + $b;
}

var_dump(add(1.0, 1.0));

// output
// int(2)

<?php
declare(strict_types=1);    //加入这句

function add(int $a, int $b): int
{
    return $a + $b;
}

var_dump(add(1.0, 1.0));

// 拋出TypeError:必須為integer整數

vars.php
<?php

$color = 'red';
$car = 'vovlo';

?>

test.php
<?php

echo "A $color $car"; // A

include 'vars.php';

echo "A $color $car"; // A red vovlo

?>

return.php
<?php

$var = 'PHP';

return $var;

?>

noreturn.php
<?php

$var = 'PHP';

?>

testreturns.php
<?php

$foo = include 'return.php';

echo $foo; // 輸出 'PHP'

$bar = include 'noreturn.php';

echo $bar; // 輸出 1(因為成功返回true = 1)

?>

<?php
function foo($arg_1, $arg_2, /* ..., */ $arg_n)
{
    echo "Example function.\n";
    return $retval;
}
?>

<?php

$makefoo = true;

/* 不能在此處調用foo()函數，
 因為它還不存在，但可以調用bar()函數。*/

bar();

if ($makefoo) {
  function foo()
  {
    echo "I don't exist until program execution reaches me.\n";
  }
}

/* 現在可以安全調用函數 foo()
   因為 $makefoo 值為真true */

if ($makefoo) foo();

function bar()
{
  echo "I exist immediately upon program start.\n";
}

?>

<?php
function foo()
{
  function bar()
  {
    echo "I don't exist until foo() is called.\n";
  }
}

/* 現在還不能調用 bar() 函數，因為它還不存在 */

foo();

/* 現在可以調用 bar() 函數了，因為 foo() 函數的執行使得 bar() 函數變為已定義的函數 */

bar();

?>

<?php
function fib($n)
{
    if($n == 0) return 0;
    if($n == 1) return 1;
    return fib($n-1) + fib($n - 2);
}

for($i = 0; $i <= 5; $i++){
    echo fib("$i ");
}

// outputs
// 0,1,1,2,3,5

<?php
function takes_array($nums)
{
    echo '$nums[0] + $nums[1] = ', $nums[0] + $nums[1];
}

<?php
function takes_many_args(
    $first_name,
    $last_name,
    $age,
    $gender = 1,
    $cellphone = null, // 在 8.0.0 之前，尾部逗號是不允许的。
)
{
    // ...
}
?>

<?php
function foo($a = [], $b) {} // 之前
function foo($a, $b) {}      // 之後

function bar(A $a = null, $b) {} // 同時可用
function bar(?A $a, $b) {}       // 官方推薦
?>

<?php
function makecoffee($type = "cappuccino")
{
    return "Making a cup of $type.\n";
}
echo makecoffee();
echo makecoffee(null);
echo makecoffee("espresso");
?>

// outputs
// Making a cup of cappuccino.
// Making a cup of .
// Making a cup of espresso.

<?php
function makeyogurt($type = "acidophilus", $flavour)
{
    return "Making a bowl of $type $flavour.\n";
}

echo makeyogurt("raspberry");   // won't work as expected
?>

// Warning: Missing argument 2 in call to makeyogurt()

<?php
function makeyogurt($flavour, $type = "acidophilus")
{
    return "Making a bowl of $type $flavour.\n";
}

echo makeyogurt("raspberry");   // works as expected
?>

// outputs
// Making a bowl of acidophilus raspberry.

<?php
function sum(...$numbers) {
    $acc = 0;
    foreach ($numbers as $n) {
        $acc += $n;
    }
    return $acc;
}

echo sum(1, 2, 3, 4);
?>

// 10

<?php
function add($a, $b) {
    return $a + $b;
}

echo add(...[1, 2])."\n";

$a = [1, 2];
echo add(...$a);
?>

// 3
// 3

<?php
function total_intervals($unit, DateInterval ...$intervals) { // 必須傳遞DateInterval類的參數
    $time = 0;
    foreach ($intervals as $interval) {
        $time += $interval->$unit;
    }
    return $time;
}

$a = new DateInterval('P1D');
$b = new DateInterval('P2D');
echo total_intervals('d', $a, $b).' days';

// This will fail, since null isn't a DateInterval object.
echo total_intervals('d', null);
?>

// outputs
// 3 days
// Catchable fatal error: Argument 2 passed to total_intervals() must be an instance of DateInterval,
// null given, called in - on line 14 and defined in - on line 2

<?php
function myFunction($paramName){
    echo $paramName;
}
myFunction(paramName: $value);  // $value指定給予paramName這個參數
array_foobar(array: $value);

// NOT supported.
function_name($variableStoringParamName: $value); // 不能動態指定
?>

<?php
// 使用順序傳遞：
array_fill(0, 100, 50);

// 使用命名參數：
array_fill(start_index: 0, count: 100, value: 50);
?>

<?php
array_fill(value: 50, count: 100, start_index: 0);
?>

<?php
function foo($param) { ... }

foo(param: 1, param: 2);
// Error: Named parameter $param overwrites previous argument
foo(1, param: 2);
// Error: Named parameter $param overwrites previous argument
?>

<?php
function square($num)
{
    return $num * $num;
}
echo square(5);   // outputs '25'.
?>

<?php
function small_numbers()
{
    return [0, 1, 2];
}
// 使用短數組語法將数组中的值賦给一組變數
[$zero, $one, $two] = small_numbers();

// 在 7.1.0 之前，唯一相等的選擇是使用 list() 結構
list($zero, $one, $two) = small_numbers();
?>

<?php
function &returns_reference()
{
    return $someref;
}

$newref =& returns_reference();
?>

<?php
function foo() {
    echo "In foo()<br />\n";
}

function bar($arg = '')
{
    echo "In bar(); argument was '$arg'.<br />\n";
}

// 使用名為 echo 的函數
function echoit($string)
{
    echo $string;
}

$func = 'foo';
$func();        // This calls foo()

$func = 'bar';
$func('test');  // This calls bar()

$func = 'echoit';
$func('test');  // This calls echoit()
?>

<?php
class Foo
{
    function Variable()
    {
        $name = 'Bar';
        $this->$name(); // This calls the Bar() method
    }

    function Bar()
    {
        echo "This is Bar";
    }
}

$foo = new Foo();
$funcname = "Variable";
$foo->$funcname();  // This calls $foo->Variable()

?>

<?php
class Foo
{
    static $variable = 'static property';
    static function Variable()
    {
        echo 'Method Variable called';
    }
}

echo Foo::$variable; // This prints 'static property'. It does need a $variable in this scope.
$variable = "Variable";
Foo::$variable();  // This calls $foo->Variable() reading $variable in this scope.

?>

<?php
class Foo
{
    static function bar()
    {
        echo "bar\n";
    }
    function baz()
    {
        echo "baz\n";
    }
}

$func = array("Foo", "bar");
$func(); // prints "bar"
$func = array(new Foo, "baz");
$func(); // prints "baz"
$func = "Foo::bar";
$func(); // prints "bar"

// 這樣可是會出錯的哦，沒有先實體化類別
$func = array("Foo", "baz");
$func(); // Uncaught Error: Non-static method Foo::baz() cannot be called statically in ....
?>

<?php
// 使用回調執行正則表達式搜索和替換
echo preg_replace_callback('~-([a-z])~', function ($match) {
    return strtoupper($match[1]);  // 將所選的變成大寫，從index: 1開始過濾掉原先"-"
}, 'hello-world');
// 输出 helloWorld
?>

<?php
$sayHi = function($name)
{
    echo "Hello $name";
}; // 記得加上分號

$sayHi('joe');
$sayHi('cherry');
?>

<?php
$message = 'hello';

// 没有 "use" php會不知道這變數從哪來
$example = function () {
    var_dump($message);
};
$example();

// 繼承父作用域 $message
$example = function () use ($message) {
    var_dump($message);
};
$example();

// Inherited variable's value is from when the function
// is defined, not when called
$message = 'world';
$example();  // 不會受到改變因為已經在上面先調用了(14行)

// Reset message
$message = 'hello';

// Inherit by-reference
$example = function () use (&$message) {
    var_dump($message);
};
$example();

// The changed value in the parent scope
// is reflected inside the function call
// 父作用域更改值，影響函式回調
$message = 'world';
$example();

// Closures can also accept regular arguments
// 閉包可使用常規變數
$example = function ($arg) use ($message) {
    var_dump($arg . ' ' . $message);
};
$example("hello");
?>

// outputs
// Notice: Undefined variable: ...
// NULL
// string(5) "hello"
// string(5) "hello"
// string(5) "hello"
// string(5) "world"
// string(11) "hello world"

<?php

$y = 1;

$fn1 = fn($x) => $x + $y;

// 相當於 using $y by value:
$fn2 = function ($x) use ($y) {
    return $x + $y;
};

// var_export -- 輸出或返回一個變量的字串表示
var_export($fn1(3)); // 4
?>

<?php

$z = 1;
$fn = fn($x) => fn($y) => $x * $y + $z;
// 輸出 21
var_export($fn(5)(4));
?>

<?php

fn(array $x) => $x;
static fn(): int => $x;
fn($x = 42) => $x;
fn(&$x) => $x;
fn&($x) => $x;
fn($x, ...$rest) => $rest;

?>

<?php

$x = 1;
$fn = fn() => $x++; // 不會影響 x 的值
$fn();
var_export($x);  // 輸出 1

?>

<?php
class SimpleClass
{
    // 聲明屬性
    public $var = 'a default value';

    // 聲明方法
    public function displayVar() {
        echo $this->var;
    }
}
?>

<?php
$instance = new SimpleClass();

// 也可以這樣做：
$className = 'SimpleClass';
$instance = new $className(); // new SimpleClass()
?>

<?php
class Test
{
    static public function getNew()
    {
        return new static;
    }
}

class Child extends Test
{}

$obj1 = new Test();
$obj2 = new $obj1;
var_dump($obj1 !== $obj2);

$obj3 = Test::getNew();
var_dump($obj3 instanceof Test);

$obj4 = Child::getNew();
var_dump($obj4 instanceof Child);
?>

// outputs
// bool(true)
// bool(true)
// bool(true)

<?php
class Foo
{
    public $bar = 'property';

    public function bar() {
        return 'method';
    }
}

$obj = new Foo();
echo $obj->bar, PHP_EOL, $obj->bar(), PHP_EOL; // PHP_EOL: php換行符號

// property
// method
?>

<?php
class Foo
{
    public $bar;

    public function __construct() {
        $this->bar = function() {
            return 10;
        };
    }
}

$obj = new Foo();

echo ($obj->bar)(), PHP_EOL; // 10

<?php
class ExtendClass extends SimpleClass
{
    // 同樣名稱的方法，將會覆蓋父類的方法
    function displayVar()
    {
        echo "Extending class\n";
        parent::displayVar();
    }
}

$extended = new ExtendClass();
$extended->displayVar();

// outputs
// Extending class
// a default value
?>

<?php

class Base
{
    public function foo(int $a) {
        echo "Valid\n";
    }
}

class Extend1 extends Base
{
    function foo(int $a = 5) // 新參數為可選參數
    {
        parent::foo($a);
    }
}

class Extend2 extends Base
{
    function foo(int $a, $b = 5)
    {
        parent::foo($a);
    }
}

$extended1 = new Extend1();
$extended1->foo();
$extended2 = new Extend2();
$extended2->foo(1);


// 輸出
// Valid
// Valid

<?php

class Base
{
    public function foo(int $a = 5) {
        echo "Valid\n";
    }
}

class Extend extends Base
{
    function foo()
    {
        parent::foo(1);
    }
}

// 聲明必須與Base class 的foo方法兼容
//Fatal error: Declaration of Extend::foo() must be compatible with Base::foo(int $a = 5)

<?php
namespace NS {
    class ClassName {
    }

    echo ClassName::class;
}
?>
// 輸出
// NS\ClassName

<?php
print Does\Not\Exist::class;
?>

<?php
namespace NS {
    class ClassName {
    }
}
$c = new ClassName();
print $c::class;
?>

// 輸出
// NS\ClassName

<?php

// 自 PHP 8.0.0 起可用
$result = $repository?->getUser(5)?->name;

// 上面的code和下面相同
if (is_null($repository)) {
    $result = null;
} else {
    $user = $repository->getUser(5);
    if (is_null($user)) {
        $result = null;
    } else {
        $result = $user->name;
    }
}
?>

<?php
class SimpleClass
{
   // 錯誤的屬性聲明
   public $var1 = 'hello ' . 'world';
   public $var2 = <<<EOD
hello world
EOD;
   public $var3 = 1+2;
   public $var4 = self::myStaticMethod();
   public $var5 = $myVar;

   // 正確的屬性聲明
   public $var6 = myConstant;
   public $var7 = array(true, false);

   //在 PHP 5.3.0 及之後，下面的聲明也正確
   public $var8 = <<<'EOD'
hello world
EOD;
}
?>

<?php
class MyClass
{
    const constant = 'constant value';

    function showConstant() {
        echo  self::constant . "\n";
    }
}

echo MyClass::constant . "\n";

$classname = "MyClass";
echo $classname::constant . "\n"; // 自 5.3.0 起

$class = new MyClass();
$class->showConstant();

echo $class::constant."\n"; // 自 PHP 5.3.0 起
?>

<?php
spl_autoload_register(function ($class_name) {
    require_once $class_name . '.php';
});

$obj  = new MyClass1();
$obj2 = new MyClass2();
?>

<?php
spl_autoload_register(function ($name) {
    echo "Want to load $name.\n";
    throw new Exception("Unable to load $name.");
});

try {
    $obj = new NonLoadableClass();
} catch (Exception $e) {
    echo $e->getMessage(), "\n";
}
?>

// Want to load NonLoadableClass.
// Unable to load NonLoadableClass.

<?php
class BaseClass {
    function __construct() {
        print "In BaseClass constructor\n";
    }
}

class SubClass extends BaseClass {
    function __construct() {
        parent::__construct();
        print "In SubClass constructor\n";
    }
}

class OtherSubClass extends BaseClass {
    // 繼承 BaseClass 的構造函數
}

// In BaseClass constructor
$obj = new BaseClass();

// In BaseClass constructor
// In SubClass constructor
$obj = new SubClass();

// In BaseClass constructor
$obj = new OtherSubClass();
?>

<?php
class Point {
    protected int $x;
    protected int $y;

    public function __construct(int $x, int $y = 0) {
        $this->x = $x;
        $this->y = $y;
    }
}

// 兩個參數都傳入
$p1 = new Point(4, 5);
// 僅傳入必填的參數。 $y 會默認為0。
$p2 = new Point(4);
// 使用命名參數（PHP 8.0 起）:
$p3 = new Point(y: 5, x: 4);
?>

<?php

class MyDestructableClass
{
    function __construct() {
        print "In constructor\n";
    }

    function __destruct() {
        print "Destroying " . __CLASS__ . "\n";
    }
}

$obj = new MyDestructableClass();

<?php
/**
 * Define MyClass
 */
class MyClass
{
    public $public = 'Public';
    protected $protected = 'Protected';
    private $private = 'Private';

    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}

$obj = new MyClass();
echo $obj->public; // 這行能被正常執行
echo $obj->protected; // 這行會產生一個致命錯誤
echo $obj->private; // 這行也會產生一個致命錯誤
$obj->printHello(); // 輸出 Public、Protected 和 Private


/**
 * Define MyClass2
 */
class MyClass2 extends MyClass
{
    // 可以對 public 和 protected 進行重定義，但 private 而不能
    public $public = 'Public2';
    protected $protected = 'Protected2';

    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}

$obj2 = new MyClass2();
echo $obj2->public; // 這行能被正常執行
echo $obj2->protected; // 這行會產生一個致命錯誤
echo $obj2->private; // 未定義 private
$obj2->printHello(); // 輸出 Public2、Protected2 和 Undefined

?>

<?php
/**
 * Define MyClass
 */
class MyClass
{
    // 聲明一個公有的構造函數
    public function __construct() { }

    // 聲明一個公有的方法
    public function MyPublic() { }

    // 聲明一個受保護的方法
    protected function MyProtected() { }

    // 聲明一個私有的方法
    private function MyPrivate() { }

    // 預設為公開方法
    function Foo()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate();
    }
}

$myclass = new MyClass;
$myclass->MyPublic(); // 這行能被正常執行
$myclass->MyProtected(); // 會出現致命錯誤
$myclass->MyPrivate(); // 會出現致命錯誤
$myclass->Foo(); // 公有，受保護，私有都可以執行


/**
 * Define MyClass2
 */
class MyClass2 extends MyClass
{
    // 為公開的函數
    function Foo2()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate(); // 會發生錯誤
    }
}

$myclass2 = new MyClass2;
$myclass2->MyPublic(); // 这行能被正常执行
$myclass2->Foo2(); // 公有，受保護，私有不可執行只能在原class裡執行

class Bar
{
    public function test() {
        $this->testPrivate();
        $this->testPublic();
    }

    public function testPublic() {
        echo "Bar::testPublic\n";
    }

    private function testPrivate() {
        echo "Bar::testPrivate\n";
    }
}

class Foo extends Bar
{
    public function testPublic() {
        echo "Foo::testPublic\n";
    }

    private function testPrivate() {
        echo "Foo::testPrivate\n";
    }
}

$myFoo = new foo();
$myFoo->test(); // Bar::testPrivate
                // Foo::testPublic
?>

<?php
/**
 * Define MyClass
 */
class MyClass
{
    // 公有常量
    public const MY_PUBLIC = 'public';

    // 受保護的常量
    protected const MY_PROTECTED = 'protected';

    // 私有常量
    private const MY_PRIVATE = 'private';

    public function foo()
    {
        echo self::MY_PUBLIC;
        echo self::MY_PROTECTED;
        echo self::MY_PRIVATE;
    }
}

$myclass = new MyClass();
MyClass::MY_PUBLIC; // 這行可以正常執行
MyClass::MY_PROTECTED; // 這行會產生一個致命錯誤
MyClass::MY_PRIVATE; // 這行會產生一個致命錯誤
$myclass->foo(); // 將會輸出：Public Protected Private


/**
 * Define MyClass2
 */
class MyClass2 extends MyClass
{
    // This is public
    function foo2()
    {
        echo self::MY_PUBLIC;
        echo self::MY_PROTECTED;
        echo self::MY_PRIVATE; // 這行會產生一個致命錯誤
    }
}

$myclass2 = new MyClass2;
echo MyClass2::MY_PUBLIC; // 這行可以正常執行
$myclass2->foo2(); // 將會輸出：Public Protected，MY_PRIVATE 是私有常量，無法輸出
?>

<?php
class Test
{
    private $foo;

    public function __construct($foo)
    {
        $this->foo = $foo;
    }

    private function bar()
    {
        echo 'Accessed the private method.';
    }

    public function baz(Test $other)
    {
        // We can change the private property:
        $other->foo = 'hello';
        var_dump($other->foo);

        // We can also call the private method:
        $other->bar();
    }
}

$test = new Test('test');

$test->baz(new Test('other'));
?>

// outputs
// string(5) "hello"
// Accessed the private method.

<?php
class MyClass {
    const CONST_VALUE = 'A constant value';
}

$classname = 'MyClass';
echo $classname::CONST_VALUE; // 自 PHP 5.3.0 起

echo MyClass::CONST_VALUE;
?>

<?php
class OtherClass extends MyClass
{
    public static $my_static = 'static var';

    public static function doubleColon() {
        echo parent::CONST_VALUE . "\n";
        echo self::$my_static . "\n";
    }
}

$classname = 'OtherClass';
echo $classname::doubleColon(); // 自 PHP 5.3.0 起

OtherClass::doubleColon();
?>

<?php
class MyClass
{
    protected function myFunc() {
        echo "MyClass::myFunc()\n";
    }
}

class OtherClass extends MyClass
{
    // 覆蓋了父類定義
    public function myFunc()
    {
        // 但還是可以調用父類中被覆盖的方法
        parent::myFunc();
        echo "OtherClass::myFunc()\n";
    }
}

$class = new OtherClass();
$class->myFunc();
?>

<?php
class Foo {
    public static function aStaticMethod() {
        // ...
    }
}

Foo::aStaticMethod();
$classname = 'Foo';
$classname::aStaticMethod();
?>

<?php
class Foo
{
    public static $my_static = 'foo';

    public function staticValue() {
        return self::$my_static;
    }
}

class Bar extends Foo
{
    public function fooStatic() {
        return parent::$my_static;
    }
}


print Foo::$my_static . "\n";

$foo = new Foo();
print $foo->staticValue() . "\n";
print $foo->my_static . "\n";      // 未定義的 "屬性" my_static

print $foo::$my_static . "\n";
$classname = 'Foo';
print $classname::$my_static . "\n";

print Bar::$my_static . "\n";
$bar = new Bar();
print $bar->fooStatic() . "\n";
?>

<?php
abstract class AbstractClass
{
 // 子類必須定義這些方法，否則會出錯
    abstract protected function getValue();
    abstract protected function prefixValue($prefix);

    // 普通方法（非抽象方法）
    public function printOut() {
        print $this->getValue() . "\n";
    }
}

class ConcreteClass1 extends AbstractClass
{
    protected function getValue() {
        return "ConcreteClass1";
    }

    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass1";
    }
}

class ConcreteClass2 extends AbstractClass
{
    public function getValue() {
        return "ConcreteClass2";
    }

    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass2";
    }
}

$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') ."\n";

$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') ."\n";
?>

// outputs
// ConcreteClass1
// FOO_ConcreteClass1
// ConcreteClass2
// FOO_ConcreteClass2

<?php
abstract class AbstractClass
{
    // 我们的抽象方法仅需要定义需要的参数
    abstract protected function prefixName($name);

}

class ConcreteClass extends AbstractClass
{

    // 子類的方法可以定義父類方法中不存在的可選參數，不衝突
    public function prefixName($name, $separator = ".") {
        if ($name == "Pacman") {
            $prefix = "Mr";
        } elseif ($name == "Pacwoman") {
            $prefix = "Mrs";
        } else {
            $prefix = "";
        }
        return "{$prefix}{$separator} {$name}";
    }
}

$class = new ConcreteClass;
echo $class->prefixName("Pacman"), "\n";
echo $class->prefixName("Pacwoman"), "\n";
?>

// outputs
// Mr. Pacman
// Mrs. Pacwoman

<?php

// 聲明一個'Template'介面
interface Template
{
    public function setVariable($name, $var);
    public function getHtml($template);
}


// 使用介面
// 正確寫法如下
class WorkingTemplate implements Template
{
    private $vars = [];

    public function setVariable($name, $var)
    {
        $this->vars[$name] = $var;
    }

    public function getHtml($template)
    {
        foreach($this->vars as $name => $value) {
            $template = str_replace('{' . $name . '}', $value, $template);
        }

        return $template;
    }
}

// 下面的寫法是錯誤的，會報錯，因為沒有使用到該介面方法 getHtml()：
// Fatal error: Class BadTemplate contains 1 abstract methods
// and must therefore be declared abstract (Template::getHtml)
class BadTemplate implements Template
{
    private $vars = [];

    public function setVariable($name, $var)
    {
        $this->vars[$name] = $var;
    }
}
?>

<?php
interface A
{
    public function foo();
}

interface B extends A
{
    public function baz(Baz $baz);
}

// 正確寫法
class C implements B
{
    public function foo()
    {
    }

    public function baz(Baz $baz)
    {
    }
}

// 錯誤寫法導致致命錯誤
class D implements B
{
    public function foo()
    {
    }

    public function baz(Foo $foo) // 參考錯誤
    {
    }
}
?>

<?php
interface A
{
    public function foo();
}

interface B
{
    public function bar();
}

interface C extends A, B
{
    public function baz();
}

class D implements C
{
    public function foo()
    {
    }

    public function bar()
    {
    }

    public function baz()
    {
    }
}
?>

<?php
interface A
{
    const B = 'Interface constant';
}

// 输出接口常量
echo A::B;

// 錯誤寫法，因為常量不能被覆蓋。接口常量的概念和類常量是一樣的。
class B implements A
{
    const B = 'Class constant';
}
?>

<?php
interface A
{
    public function foo(string $s): string;

    public function bar(int $i): int;
}

//  抽象類可能僅實現了接口的一部分。
// 擴展該抽象類時必須實現剩餘部分
abstract class B implements A
{
    pubic function foo(string $s): string
    {
        return $s . PHP_EOL;
    }
}

class C extends B
{
    public function bar(int $i): int
    {
        return $i * 2;
    }
}
?>

<?php

class One
{
    /* ... */
}

interface Usable
{
    /* ... */
}

interface Updatable
{
    /* ... */
}

// 關鍵字順序至關重要： 'extends' 必須在前面
class Two extends One implements Usable, Updatable
{
    /* ... */
}
?>