剰余で判定する方法は以下の通り。
┌──────────────────────────────────────┐
│if ($a % 2 == 1) {                                                          │
│  // 奇数です                                                               │
│} else {                                                                    │
│  // 偶数です                                                               │
│}                                                                           │
└──────────────────────────────────────┘

こんな方法もありです。
┌──────────────────────────────────────┐
│if ($a & 1) {                                                               │
│  // 奇数です                                                               │
│} else {                                                                    │
│  // 偶数です                                                               │
│}                                                                           │
└──────────────────────────────────────┘

なんともっと簡単にアクセス修飾子の挙動を把握できる方法があった。
生成したクラスを「print_r()」で中身を表示すればよいのだ

例えば、
┌──────────────────────────────────────┐
│class 親 {                                                                  │
│  public $a = '親';  ←★                                                   │
│}                                                                           │
├──────────────────────────────────────┤
│class 子 extends 親 {                                                       │
│  public $a = '子';  ←★                                                   │
│}                                                                           │
└──────────────────────────────────────┘
上記のように同名で変数を定義し、以下のように「print_r()」すると
┌──────────────────────────────────────┐
│$子 = new 子();                                                             │
│print_r((array)$子);                                                        │
└──────────────────────────────────────┘
結果は「Array ( [a] => 子 )」となる。

ではそれぞれのパターンでは？(×はエラー)
┌─────┬─────┬─────┬─────┬─────┐
│  親＼子  │(定義なし)│   private│ protected│    public│
├─────┼─────┼─────┼─────┼─────┤
│          │    ×    │[子a]=> 子│[*a] => 子│[a]  => 子│
│(定義なし)│          │          │          │          │
├─────┼─────┼─────┼─────┼─────┤
│          │    ×    │[子a]=> 子│[*a] => 子│[a]  => 子│
│private   │          │[親a]=> 親│[親a]=> 親│[親a]=> 親│
├─────┼─────┼─────┼─────┼─────┤
│          │          │    ×    │[*a] => 子│[a]  => 子│
│protected │[*a] => 親│          │          │          │
├─────┼─────┼─────┼─────┼─────┤
│          │          │    ×    │    ×    │[a]  => 子│
│public    │[a]  => 親│          │          │          │
└─────┴─────┴─────┴─────┴─────┘

では、protected修飾子の変数を、親と子で同名で使用した上で
親メソッド、子メソッドのぞれぞれで参照した場合は？
┌──────────────────────────────────────┐
│class 親 {                                                                  │
│  protected $a = '親';  // →必須ではない                                   │
│  public function method親() {                                              │
│    $this->a .= 'です';                                                     │
│  }                                                                         │
│}                                                                           │
└──────────────────────────────────────┘
┌──────────────────────────────────────┐
│class 子 extends 親 {                                                       │
│  protected $a = '子';                                                      │
│  public function method子() {                                              │
│    $this->method親();                                                      │
│    return $this->a;                                                        │
│  }                                                                         │
│}                                                                           │
└──────────────────────────────────────┘
親メソッドで該当する方の変数に「です」をつけてみた場合
やはり子で定義した値に「です」が追加される。
┌──────────────────────────────────────┐
│$子 = new 子();                                                             │
│echo $子->method子();  // →結果は「子です」                                │
└──────────────────────────────────────┘

protected修飾子の変数を、親と子で同名で使用した場合の挙動を整理した
┌──────────────────────────────────────┐
│class 親 {                                                                  │
│  protected $a = '親';  // →必須ではない                                   │
│  public function method親() {                                              │
│    return $this->a;                                                        │
│  }                                                                         │
│}                                                                           │
└──────────────────────────────────────┘
┌──────────────────────────────────────┐
│class 子 extends 親 {                                                       │
│  protected $a = '子';                                                      │
│  public function method子() {                                              │
│    return $this->a;                                                        │
│  }                                                                         │
│}                                                                           │
└──────────────────────────────────────┘
親クラスのみを生成した場合は、子クラスは存在しないので当然ながら
親クラスで定義した値が優先される(「$a」の値は「親」)
┌──────────────────────────────────────┐
│$親 = new 親();                                                             │
│echo $親->method親();  // →結果は「親」                                    │
└──────────────────────────────────────┘
子クラスを生成した場合は、子クラスの定義がオーバーライドされるので
子クラスで定義した値が優先される(「$a」の値は「子」)
┌──────────────────────────────────────┐
│$子 = new 子();                                                             │
│echo $子->method親();  // →結果は「子」                                    │
│echo $子->method子();  // →結果は「子」                                    │
└──────────────────────────────────────┘

┌──────────────────────────────────────┐
│foreach ($a as &$value) {                                                   │
│  $value ='z';                                                              │
│}                                                                           │
└──────────────────────────────────────┘
foreachの参照渡しの場合の注意点。

┌──────────────────────────────────────┐
│foreach ($a as &$value) {                                                   │
│  $value ='z';                                                              │
│}                                                                           │
│unset($value)                                                               │
└──────────────────────────────────────┘
unset()すること。

とにかく絶対にだ。

2桁数字限定の簡単技。
0～99  →  /^[1-9]?\d$/
1～99  →  /^[1-9]\d?$/

3桁以上になると、これらは使えない
0～999  →  /^[1-9]?\d\d$/  …①
1～999  →  /^[1-9]\d\d?$/

①で「01」が通ってしまうのだ。

┌──────────────────────────────────────┐
│<input type="hidden" name="キー" value="値"/>                               │
└──────────────────────────────────────┘
name属性とvalue属性を設定して、POSTでsubmitすれば
「$_POST['キー'] = '値'」が送信される。

name属性がない場合、例えばid属性とかだった場合は、「$_POST」は送信されない。
┌──────────────────────────────────────┐
│<input type="hidden" id="キー" value="値"/>                                 │
└──────────────────────────────────────┘

では、(name属性はあるのに)value属性がない場合、どうなるのか？
┌──────────────────────────────────────┐
│<input type="hidden" name="キー"/>                                          │
└──────────────────────────────────────┘
「$_POST['キー'] = ''」が送信される。
つまり、そのname属性で送信はされる。
ただ中身は、NULLと思いきや「''」(空文字)なんだね。

小数点以下も含めたい場合。

「-999.99～999.99」の範囲としたい場合。

「((0|\-?[1-9]\d{0,2})(\.\d{2})?)」

「.」だけではだめ「.00」と小数点以下の数字が必要ってこと。

「((0|\-?[1-9]\d{0,2})(\.\d{1,2})?)」

こうすれば「9.99」でも「9.9」でもOKとなる。

負の数も含めたい場合。

「-999～999」の範囲としたい場合。

「(0|\-?[1-9]\d{0,2})」

「0」と「-999～-1」「1～999」みたいな感じか。

「0123456789」を表すものは「[0-9]」か「\d」。

なので「\d\d\d」とすれば「000～999」の数値を表すことができる。

だが、数値は「001」ではなく「1」と書くもの。

なので、「1～999」としたい。

それには「[1-9]\d{0,2}」。

あ、「0」が抜けている、「0～999」だ。

でも「0」は別枠にせねばなるまい、よってこう。

「(0|[1-9]\d{0,2})」

「0」か「1～999」で「0～999」。