<?php
...
?>

<p> ここはPHPは無視。ブラウザに表示されるよ</p>
<?php echo 'ここはPHPにパースされる' ?>
<p> ここもPHPは無視。ブラウザに表示されるよ</p>

<?php if($hoge== true) ?>
条件がtrueなら表示されるよ
<?php else: ?>
条件がfalseなら表示されるよ
<?php end if; ?>

<?php echo "Hello!"; ?> // -> Hello!
<?="Hello!" ?> // -> Hello!

<?php
// 単一行コメント

/*
複数行コメント
ここもコメントにできる
*/

# これも単一行コメント

?>

<?php
 /*
    echo 'テストです'; /* このコメントが問題を生じます */
 */
?>

<?php
 $var = null;
 $var = NULL;
?>

### 関数

is_null($hoge): $hogeがnullか調べる関数
unset($hoge):$hogeの割当を解除してnullにする関数 

<?php
$foo = true;
>

$a = 1234; // 10進数
$a = 0123; // 8進数
$a = 0o123; // 8進数(8.1.0以降)
$a = 0x1A; // 16進数
$a= 0b11111111; // 2進数
$a = 1_234_567; // 10進数

<?php
$large_number = 2147483647;
var_dump($large_number);                     // int(2147483647)

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

$million = 1000000;
$large_number =  50000 * $million;
var_dump($large_number);                     // float(50000000000)
?>

<?php
$large_number = 9223372036854775807;
var_dump($large_number);                     // int(9223372036854775807)

$large_number = 9223372036854775808;
var_dump($large_number);                     // float(9.2233720368548E+18)

$million = 1000000;
$large_number =  50000000000000 * $million;
var_dump($large_number);                     // float(5.0E+19)
?>

$a = 1.234;
$b = 1.2e3;
$c = 7E-10;
$d = 1_234.567; // PHP 7.4.0以降

$str = 'this is a pen!';

$str = "this is a pen!";

<<<ID
ここにテキストを書ける
ID;

// PHP7.3ならこういうのも書ける
<<<ID
ここにテキストを書ける
　ここにテキストを書ける
　　ここにテキストを書ける
　　　ここにテキストを書ける
　　　ID;

// こうしたらエラーになる
<<<ID
ここにテキストを書ける
　ここにテキストを書ける
　　ここにテキストを書ける
　　　ここにテキストを書ける
ID;

<<<'LABEL'
ここにテキストを書ける
LABEL

$hoge = "hello";

echo "$hoge world"; //->hello world!
echo "{$hoge} world!"; //-> hello world!

$juices = array("red","blue","org_color" => "green");

echo "this is {$juices[0]}"; // -> this is red
echo "this is {$juices[1]}"; // -> this is blue
echo "this is {$juices[org_color]}"; // -> this is green;

class human {
 public $name = "suzuki";
}

$human = new human();

echo "hi! {$human->name}!" -> hi! suzuki!

$great = 'fantastic';

// 動かないパターン
echo "This is { $great}; // -> エラーになる(変数の前に空白があるため)

// 動く
echo "This is {$great}; // -> This is fantastic

// 動く(クラス内プロパティ)を表示
echo "This square is {$square->width}00 centimeters broad." ;

// 動く(キーの文字列にクォートを使うときは波括弧を使う
echo "This works: {$arr['key']}";

// 動く 配列に添字を指定
echo "This works: {$arr[4][3]}";

// 動かない (fooが変数扱いになるので未定義になる)
echo "This works: {$arr[foo][3]};

// 動く (配列arr のキーfoo の3番目の要素)
echo "This works: ".$arr['foo'][3];

// 動く (オブジェクトobjのプロパティvalueの3番目が持つname)
echo "You can even write {$obj->values[3]->name}";

// 動く ($nameが'value'の場合、{$value}と同値になる)
echo "This is the value of the var named $name: {${$name}}";

// 動く(getNameの戻り値が 'Tanaka' の場合 {$value}>{Tanaka}?
echo "This is the value of the var named by the return value of getName(): {${getName()}}";

// 動かない
echo "This is the return value of getName(): {getName()}";

// 動かない { が\によってエスケープされているため
echo "C:\folder\{$great}.txt"

// 動く
echo "C:\\folder\\{$great}.txt"

class foo {
 var $bar = 'I am bar.';
}

$foo = new foo();
$bar = 'bar';
$baz = array('foo' , 'bar' , 'baz' , 'quux');
echo "{$foo->$bar}"; // ->I am bar.
echo "{$foo->{$baz[1]}}; // ->I am bar.  baz[1]はbarなのでfooのbarにアクセスしてる。

class beers {
    const softdrink = 'rootbeer';
    public static $ale = 'ipa';
}

$rootbeer = 'A & W';
$ipa = 'Alexander Keith\'s';

// これは動作し、出力は I'd like an A & W となります
echo "I'd like an {${beers::softdrink}}\n";
//-> beers::softdrinkは rootbeer, {$rootbeer}となるので「A & W」が出力される

// これも動作し、出力は I'd like an Alexander Keith's となります
echo "I'd like an {${beers::$ale}}\n";
//-> beers->aleが「ipa」、{$ipa}となるので「Alexander Keith」が出力される

// 文字列の最初の文字を取得します
$str = 'This is a test.';
$first = $str[0]; // ->T

// 文字列の 3 番目の文字を取得します
$third = $str[2]; // ->i

// 文字列の最後の文字を取得します
$str = 'This is still a test.';
$last = $str[strlen($str)-1];  // strlenで文字数を取得、添字は0から始まるので-1して末尾の文字を指す

// 文字列の最後の文字を変更します
$str = 'Look at the sea';
$str[strlen($str)-1] = 'e';

$hoge = 1 + "105.5"; // -> "105.5"をfloatに変換して計算してくれるので 106.5になる。

// > ver8.0
$hoge = 1 + "my 10"; // -> エラー(PHP8.0以降のみ)
// < ver7.0
$hoge = 1 + "my 10"; // -> 1 ( "my 10"が0として扱われる)

array(
    key  => value,
    key2 => value2,
    key3 => value3,
    ...
)

$array = array(
    "foo" => "bar",
    "bar" => "foo", //末尾にカンマはあってもなくてもOK
);

// 短縮形
$array =[
    "foo" => "bar",
    "bar" => "foo",
];


$array =[
    // キーの"8"はintにキャストされるので$array[8]で呼び出す。$array["8"]じゃないので注意
    "8" => "bar", 
　// キー"08"はキャストされないので$array["08"]で呼び出す。
    "08" => "foo",
　// "8.7"はintにキャストされ小数部分が切り捨てされる。つまり$array[8]で呼ぶ
　 "8.7" => "foo",
   // boolもintになる。 trueは1、falseは0
　true => "foo",
   // null は空文字のキーになる。 $array[""]
   null => "foo",
   // arrayやobjectはキーとして使えない。
];

$array = [
 1 =>     "a",
 "1" =>   "b",
 1.5 =>  "c",
 true => "d",
];

// 最終的には
$array[1] の中に "d"が格納されている状態になる。

$array = array(
    "foo" => "bar",
    "bar" => "foo",
    100   => -100,
    -100  => 100,
);

$array = array("foo", "bar", "hello", "world");

$array = array(
         "a",
         "b",
    6 => "c",
         "d",
);

$array = array(
    "foo" => "bar",
    42    => 24,
    "multi" => array(
         "dimensional" => array(
             "array" => "foo"
         )
    )
);

$array["foo"] // -> "bar"
$array[42]; // -> 24
$array["multi"]["dimensional"]["array"]; // 配列の入れ子もできる

<?php

class foo{
  function fo_foo(){
     echo "foo を実行";
  }
}
$bar = new foo;
$bar->foo;

<?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)'
?>

enum Suit
{
  case Hearts;
  case Diamonds;
  case Clubs;
  case Spades;
}

function do_stuff(Suit $s)
{
   //...
}

do_stuff(Suit::Spades);

function my_callback_function(){
  echo 'hello world';
}

class MyClass{
  static function myCallbackMethod(){
    echo 'Hello World!';
  }
}

// 単純なコールバック
call_user_func('myCallbackMethod');

// staticメソッドコール
call_user_func(array('MyClass', 'myCallbackMethod'));

// オブジェクトメソッドのコール
$obj = new MyClass();
call_user_func(array($obj, 'myCallbackMethod'));

// staticメソッドコール
call_user_func('MyClass:myCallbackMethod');

// 相対していによるstaticメソッドコール
class A {
  public static function who(){
    echo "A";
  }
}

class B extends A {
  public static function who(){
    echo "B";
  }
}

call_user_func(array('B', 'parent::who')); // A -> PHP8.2.0以降は非推奨

class C {
    public function __invoke($name) {
        echo 'Hello ', $name, "\n";
    }
}

//__invokeというのはこのクラスを関数みたいに呼べるようにする定義

$c = new C();
call_user_func($c , 'PHP!');  // Hello PHP!

function test(mixed $data){
...
}

$a = 100;
$b = $a;
$a = 150;

echo $a // -> 150
echo $b // -> 100;

$a = 100;
$b = &$a;
$a = 150;

echo $a // -> 150
echo $b // -> 150;