以下のような処理を通って、「飛び先URL②」へ飛んだ後で…。
┌──────────────────────────────────────┐
│<form method="post" action="飛び先URL①">                                   │
├──────────────────────────────────────┤
│document.forms[0].action = '飛び先URL②';                                   │
│document.forms[0].submit();                                                 │
└──────────────────────────────────────┘

ブラウザの「戻る」ボタンで元の画面に戻って、
以下のような処理で再度実行したとする…。
＃条件分岐で「'飛び先URL②'」の代入をスキップしたとする
┌──────────────────────────────────────┐
│<form method="post" action="飛び先URL①">                                   │
├──────────────────────────────────────┤
│document.forms[0].submit();                                                 │
└──────────────────────────────────────┘

(「document.forms[0].action」の値に従い)
IEやChromeであれば「飛び先URL①」に飛ぶのに対して
Firefoxだと、「飛び先URL②」に飛んでしまう。

前に表示した時の内容を記憶しているからのようだ。

「date」

結果例）「Wed Aug 27 14:33:48 JST 2014」

情報量の多いページの場合、以下の二つのパターンがある。
  (1) 部分的に徐々に表示する
  (2) 全部出揃うまでは表示せず、最後に一気に表示する

たいては、(2)なのだが、それは「php.ini」の以下の設定による。
┌──────────────────────────────────────┐
│implicit_flush = Off                                                        │
└──────────────────────────────────────┘

これを「On」にすると、「echo」などを行う場合、都度、「flush()」で出力され
部分的に表示される形となる。

但し、「On」にすると著しい性能低下を生じさせるので、
これをするのはやむを得ないデバッグの時に限定すべきらしい。

┌──────────┬───────────────┬───────────┐
│char_t              │character                     │文字( 8ビット文字)    │
│char                │character                     │                      │
├──────────┼───────────────┼───────────┤
│string              │character string              │文字列                │
└──────────┴───────────────┴───────────┘
┌──────────┬───────────────┬───────────┐
│numeric             │numeric                       │数値(小数)            │
├──────────┼───────────────┼───────────┤
│decimal             │decimal                       │小数                  │
└──────────┴───────────────┴───────────┘
┌──────────┬───────────────┬───────────┐
│short               │short integer                 │短精度整数            │
│signed short        │signed short integer          │符号あり短精度整数    │
│unsigned short      │unsigned short integer        │符号なし短精度整数    │
├──────────┼───────────────┼───────────┤
│int                 │integer                       │整数                  │
│signed int          │signed integer                │符号あり整数          │
│unsigned int        │unsigned integer              │符号なし整数          │
├──────────┼───────────────┼───────────┤
│long                │long integer                  │長精度整数            │
│signed long         │signed long integer           │符号あり長精度整数    │
│unsigned long       │unsigned long integer         │符号なし長精度整数    │
├──────────┼───────────────┼───────────┤
│long long           │double long integer           │倍長精度整数          │
│signed long long    │signed double long integer    │符号あり倍長精度整数  │
│unsigned long long  │unsigned double long integer  │符号なし倍長精度整数  │
└──────────┴───────────────┴───────────┘
┌──────────┬───────────────┬───────────┐
│int8_t              │signed 8-byte integer         │符号あり 8ビット整数  │
│signed char         │signed character              │(符号あり文字)        │
├──────────┼───────────────┼───────────┤
│uint8_t             │unsigned 8-byte integer       │符号なし 8ビット整数  │
│unsigned char       │unsigned character            │(符号なし文字)        │
│byte                │byte                          │( 1バイト文字)        │
├──────────┼───────────────┼───────────┤
│int16_t             │signed 16-byte integer        │符号あり16ビット整数  │
│(signed short)      │                              │                      │
│(signed int)        │                              │                      │
├──────────┼───────────────┼───────────┤
│uint16_t            │unsigned 16-byte integer      │符号なし16ビット整数  │
│word                │word                          │( 2バイト文字(2×1))  │
│(unsigned short)    │                              │                      │
│(unsigned int)      │                              │                      │
├──────────┼───────────────┼───────────┤
│int32_t             │signed 32-byte integer        │符号あり32ビット整数  │
│(signed int)        │                              │                      │
│(signed long)       │                              │                      │
├──────────┼───────────────┼───────────┤
│uint32_t            │unsigned 32-byte integer      │符号なし32ビット整数  │
│dword               │double word                   │( 4バイト文字(2×2))  │
│(unsigned int)      │                              │                      │
│(unsigned long)     │                              │                      │
├──────────┼───────────────┼───────────┤
│int64_t             │signed 64-byte integer        │符号あり64ビット整数  │
│(signed long)       │                              │                      │
│(signed long long)  │                              │                      │
├──────────┼───────────────┼───────────┤
│uint64_t            │unsigned 64-byte integer      │符号なし64ビット整数  │
│qword               │quadruple word                │( 8バイト文字(2×4))  │
│(unsigned long long)│                              │                      │
│(unsigned long)     │                              │                      │
├──────────┼───────────────┼───────────┤
│float32_t           │32-byte floating point number │32ビット浮動小数点数  │
│float               │floating point number         │短精度浮動小数点数    │
├──────────┼───────────────┼───────────┤
│float64_t           │64-byte floating point number │64ビット浮動小数点数  │
│double              │double floating point number  │倍精度浮動小数点数    │
└──────────┴───────────────┴───────────┘

一定の周期でグループ化されている連番から、グループ番号と枝番を算出する方法。
┌──────────────────────────────────────┐
│                        Y座標                                               │
│      ┌─┬─┬─┬─┐                                                    │
│      │ 1│ 2│ 3│ 4│    1                                               │
│      ├─┼─┼─┼─┤                                                    │
│      │ 5│ 6│ 7│ 8│    2                                               │
│      └─┴─┴─┴─┘                                                    │
│ X座標   1   2   3   4                                                      │
└──────────────────────────────────────┘
例えば、上記の場合「7」は「2-3」(Y-X)みたいな感じに変換する方法。

単純に以下のようにやってしまうと、剰余がない場合にずれてしまう。
┌──────────────────────────────────────┐
│グループ番号 = (値 / グループ単位) + 1;  …商(端数切捨)                     │
│        枝番 = 値 % グループ単位;        …剰余                             │
└──────────────────────────────────────┘
上記の例でいえば、「8」は「2-0」ではなく「3-0」になってしまう。

よって、以下のように「-1」して0オリジンにしてから計算しなければならない。
┌──────────────────────────────────────┐
│                        商                                                  │
│      ┌─┬─┬─┬─┐                                                    │
│      │ 0│ 1│ 2│ 3│ 0                                                  │
│      ├─┼─┼─┼─┤                                                    │
│      │ 4│ 5│ 6│ 7│ 1                                                  │
│      └─┴─┴─┴─┘                                                    │
│  剰余   0   1   2   3                                                      │
└──────────────────────────────────────┘
つまり、以下のような感じになる。
┌──────────────────────────────────────┐
│グループ番号 = ((値 - 1) / グループ単位) + 1;  …商(端数切捨)               │
│        枝番 = ((値 - 1) % グループ単位) + 1;  …剰余                       │
└──────────────────────────────────────┘
注意が必要だ。

前回までCOUNT関数系の複数条件を扱ったが、SUM関数系の場合はどうするか？

すばり、地道にCASE文でやってしまう方法となりそうだ。
┌──────────────────────────────────────┐
│SELECT SUM(列)                                  AS `全ての集計`,            │
│       SUM(CASE WHEN 列 > 0 THEN 列 ELSE 0 END) AS `正数の集計`,            │
│       SUM(CASE WHEN 列 = 0 THEN 列 ELSE 0 END) AS `ゼロの集計`,            │
│       SUM(CASE WHEN 列 < 0 THEN 列 ELSE 0 END) AS `負数の集計`             │
│    FROM 表;                                                                │
└──────────────────────────────────────┘
もちろん条件は他の列とかを絡めたりしていろいろと対応できる。

前回の方法をSUM関数を使って行うこともできる。
┌──────────────────────────────────────┐
│SELECT SUM(TRUE)           AS `全ての件数(NULLを含む)`,                     │
│       SUM(列 IS NOT NULL) AS `全ての件数(NULLを除く)`,                     │
│       SUM(列 > 0)         AS `正数の集計`,                                 │
│       SUM(列 = 0)         AS `ゼロの集計`,                                 │
│       SUM(列 < 0)         AS `負数の集計`                                  │
│    FROM 表;                                                                │
└──────────────────────────────────────┘
これは「TRUE」が「1」、「FALSE」が「0」と換算されることを利用している。
(ちなみに「NULL」は「NULL」のままだが集計から除外されるのでほぼ「0」扱い)
  ・SELECT SUM(TRUE);              → 1
  ・SELECT SUM(FALSE);             → 0
  ・SELECT SUM(NULL);              → NULL
  ・SELECT COALESCE(SUM(NULL), 0); → 0

データが1件もない場合については、
こちらは(上記列全てが)「NULL」となってしまうので
念のため「COALESCE(,0)」で「0」変換の補正を付けてあげた方がより無難かも。
┌──────────────────────────────────────┐
│SELECT COALESCE(SUM(TRUE)          , 0) AS `全ての件数(NULLを含む)`,        │
│       COALESCE(SUM(列 IS NOT NULL), 0) AS `全ての件数(NULLを除く)`,        │
│       COALESCE(SUM(列 > 0)        , 0) AS `正数の集計`,                    │
│       COALESCE(SUM(列 = 0)        , 0) AS `ゼロの集計`,                    │
│       COALESCE(SUM(列 < 0)        , 0) AS `負数の集計`                     │
│    FROM 表;                                                                │
└──────────────────────────────────────┘
但し、データが1件以上あれば、条件に一致しなくても「0」となる。
＃正数が1件だけあっても、それで負数の集計ではFALSE(=0)が1件と換算されるので
  負数の集計が(0となり)NULLになることはない。

┌──────────────────────────────────────┐
│SELECT COUNT(*) FROM 表 WHERE 列 > 0;                                       │
│SELECT COUNT(*) FROM 表 WHERE 列 = 0;                                       │
│SELECT COUNT(*) FROM 表 WHERE 列 < 0;                                       │
└──────────────────────────────────────┘
上記を同時に行う方法。

┌──────────────────────────────────────┐
│SELECT COUNT(*)              AS `全ての件数(NULLを含む)`,                   │
│       COUNT(列)             AS `全ての件数(NULLを除く)`,                   │
│       COUNT(列 > 0 OR NULL) AS `正数の件数`,                               │
│       COUNT(列 = 0 OR NULL) AS `ゼロの件数`,                               │
│       COUNT(列 < 0 OR NULL) AS `負数の件数`                                │
│    FROM 表;                                                                │
└──────────────────────────────────────┘

COUNT関数はNULL以外の件数を数えるのだが、
これと以下の論理和条件(●)を駆使して、FALSEをNULLに置換させることにより
条件に一致するものだけをNULL以外としてカウントするという仕組みだ。
  ・(TRUE  AND TRUE ) → TRUE     ・(TRUE  OR  TRUE ) → TRUE
  ・(TRUE  AND FALSE) → FALSE    ・(TRUE  OR  FALSE) → TRUE
  ・(TRUE  AND NULL ) → NULL     ●(TRUE  OR  NULL ) → TRUE
  ・(FALSE AND FALSE) → FALSE    ・(FALSE OR  FALSE) → FALSE
  ・(FALSE AND NULL ) → FALSE    ●(FALSE OR  NULL ) → NULL
  ・(NULL  AND NULL ) → NULL     ・(NULL  OR  NULL ) → NULL

半角に変換して変化があるかで判定する。
┌──────────────────────────────────────┐
│If 値 = StrConv(値, vbNarrow) Then                                          │
│    MsgBox "半角のみ"                                                       │
│Else                                                                        │
│    MsgBox "全角を含む"                                                     │
│End If                                                                      │
└──────────────────────────────────────┘

ちなみにその逆で、半角を含むかの判定は以下のようになる。
┌──────────────────────────────────────┐
│If 値 = StrConv(値, vbWide) Then                                            │
│    MsgBox "全角のみ"                                                       │
│Else                                                                        │
│    MsgBox "半角を含む"                                                     │
│End If                                                                      │
└──────────────────────────────────────┘

配列の実体の場合
┌──────────────────────────────────────┐
│型   配列[添字];                                                            │
├──────────────────────────────────────┤
│memset(配列, 0, sizeof(配列));                                              │
│memset(配列, 0, sizeof(配列[0]) * 添字);                                    │
│memset(配列, 0, sizeof(型) * 添字);                                         │
│memset(配列, 0, 配列のサイズ);                                              │
├──────────────────────────────────────┤
│memcpy(コピー先の配列, 配列, sizeof(コピー先の配列));                       │
│memcpy(コピー先の配列, 配列, sizeof(配列[0]) * 添字);                       │
│memcpy(コピー先の配列, 配列, sizeof(型) * 添字);                            │
│memcpy(コピー先の配列, 配列, コピー先の配列のサイズ);                       │
│──────────────────────────────────────│
│memcpy(コピー先の配列のポインタ, 配列, sizeof(型) * 添字);                  │
│memcpy(コピー先の配列のポインタ, 配列, コピー先の配列のサイズ);             │
└──────────────────────────────────────┘

配列のポインタの場合
┌──────────────────────────────────────┐
│型*  配列のポインタ = 配列;                                                 │
├──────────────────────────────────────┤
│memset(配列のポインタ, 0, sizeof(型) * 添字);                               │
│memset(配列, 0, 配列のサイズ);                                              │
├──────────────────────────────────────┤
│memcpy(コピー先の配列のポインタ, 配列, sizeof(型) * 添字);                  │
│memcpy(コピー先の配列のポインタ, 配列, コピー先の配列のサイズ);             │
│──────────────────────────────────────│
│memcpy(コピー先の配列のポインタ, 配列のポインタ, sizeof(型) * 添字);        │
│memcpy(コピー先の配列のポインタ, 配列のポインタ, コピー先の配列のサイズ);   │
└──────────────────────────────────────┘