/*
まず、sort 関数=>ハッシュの値をアルファベット順に並べ替え、それぞれの
key値をインデックスの配列に置き換えていく。

対して rsort 関数は同じくアルファベット順に違いは無いがアルファベットの逆順に
並べ替えを行い、key 値をインデックスの配列に置き換えていく。
*/
//動作検証用ハッシュ
$array = array("c" => "stringE","d" => "stringD","b" => "stringB" ,"a" => "stringC","e" => "stringA");

print_r($array);

sort($array);
print_r($array);
$array = array("c" => "stringE","d" => "stringD","b" => "stringB" ,"a" => "stringC","e" => "stringA");

rsort($array);
print_r($array);

//デフォルトの配列
/*
Array
(
    [c] => stringE
    [d] => stringD
    [b] => stringB
    [a] => stringC
    [e] => stringA
)
//sort 関数の実行結果
Array
(
    [0] => stringA
    [1] => stringB
    [2] => stringC
    [3] => stringD
    [4] => stringE
)
//rsort 関数の実行結果
Array
(
    [0] => stringE
    [1] => stringD
    [2] => stringC
    [3] => stringB
    [4] => stringA
)
*/
print "---------------------------------------------------------------";
/*
次に、検証するソート関数は asort 関数=>ハッシュの値をアルファベット順に並べ替え
ハッシュの key値は元のままを保持する関数。

対して、arsort 関数は同じくアルファベット順に並べ替えるのだが、先に述べた rsort 関数と
同じく、アルファベットと逆順に並べ替えることになる。
*/
//動作検証用ハッシュ
$array = array("c" => "stringE","d" => "stringD","b" => "stringB" ,"a" => "stringC","e" => "stringA");

print_r($array);

asort($array);
print_r($array);
$array = array("c" => "stringE","d" => "stringD","b" => "stringB" ,"a" => "stringC","e" => "stringA");

arsort($array);
print_r($array);
//デフォルトの配列
/*
Array
(
    [c] => stringE
    [d] => stringD
    [b] => stringB
    [a] => stringC
    [e] => stringA
)
//asort関数の実行結果
Array
(
    [e] => stringA
    [b] => stringB
    [a] => stringC
    [d] => stringD
    [c] => stringE
)
//arsort関数の実行結果
Array
(
    [c] => stringE
    [d] => stringD
    [a] => stringC
    [b] => stringB
    [e] => stringA
)
*/
print "---------------------------------------------------------------";
/*
次に、検証するソート関数は ksort 関数=>この関数はハッシュ値の値ではなく ハッシュの key値を
アルファベット順に並び替えるソート関数である。
対して、krsort 関数は同じく ハッシュの key値を アルファベット順に並べ替えるのだが、
先に述べた rsort 関数と同じく、アルファベットと逆順に並べ替えることになる。
*/
//動作検証用ハッシュ
$array = array("c" => "stringE","d" => "stringD","b" => "stringB" ,"a" => "stringC","e" => "stringA");

print_r($array);

ksort($array);
print_r($array);
$array = array("c" => "stringE","d" => "stringD","b" => "stringB" ,"a" => "stringC","e" => "stringA");

krsort($array);
print_r($array);
/*
//デフォルトの配列
Array
(
    [c] => stringE
    [d] => stringD
    [b] => stringB
    [a] => stringC
    [e] => stringA
)
//ksort関数の実行結果
Array
(
    [a] => stringC
    [b] => stringB
    [c] => stringE
    [d] => stringD
    [e] => stringA
)
//krsort関数の実行結果
Array
(
    [e] => stringA
    [d] => stringD
    [c] => stringE
    [b] => stringB
    [a] => stringC
)
*/

//======================================
//array_diff 関数の使い方
//======================================
//下記のように、二つの配列があるとする
$arrayA = array("name" => "user_name",
						"address" => "test@gmail.com",
						"tel" => 45
						);
$arrayB = array("name" => "user_name2",
						"address" => "testtest@gmail.com",
						"tel" => 20,
						"testkey" => "test@gmail.com",
						"key" => 45
						);

//array_diff 関数は、第一引数に与えた配列と第二引数以降の配列を比較して
//第一引数にしか存在しない値(わかりやすくういうと value 値)のみを配列にして返す。
$arrayC = array_diff($arrayA,$arrayB);

/*
$arrayC の中身は以下の内容
上記の様な場合だと、第一引数の配列のみに存在する値は【user_name】のみなので返り値にはこの値のみが返る。
Array
(
    [name] => user_name
)
*/

//======================================
//array_intersect 関数の使い方
//======================================
//下記のように、二つの配列があるとする
$arrayA = array("name" => "user_name",
						"address" => "test@gmail.com",
						"tel" => 45
						);
$arrayB = array("name" => "user_name2",
						"address" => "testtest@gmail.com",
						"tel" => 20,
						"testkey" => "test@gmail.com",
						"key" => 45
						);

//intersect 関数は第一引数と第二引数以降の配列を比較して
//すべての配列に存在する value 値のみを配列として返す。
//上記のような配列の場合は、【test@gmail.com】と【45】という値のみなので二つの値が配列として返る。
$arrayC = array_intersect($arrayA,$arrayB);

print "
";
print_r($arrayC);
print "

";
/*
$arrayC の中身は以下の内容
第一引数で "tel" => 45
第二引数で "key" => 45
と同じ値を持つ key値が存在するが array_intersect の場合は
第一引数の key 値が基準となるためこの場合 は　【"tel" => 45】が優先される。

Array
(
    [address] => test@gmail.com
    [tel] => 45
)
*/

//======================================
//array_merge 関数の使い方
//======================================
//下記のように、二つの配列があるとする
$arrayA = array("name" => "user_name",
						"address" => "test@gmail.com",
						"tel" => 45
						);
$arrayB = array("name" => "user_name2",
						"address" => "testtest@gmail.com",
						"tel" => 20,
						"testkey" => "test@gmail.com",
						"key" => 45
						);

//array_merge 関数は第一引数と第二引数以降の配列を比較して
//第一引数に存在しない key値を第一引数にくっつけていく。
$arrayC = array_merge($arrayA,$arrayB);

print_r($arrayC);
/*
$arrayC の中身は以下の内容
第一引数になくて第二引数に存在する key 値は【 testkey 】と 【key 】 というキーのみであるため
これら二つのキーが新しく第一引数に追加されたものが返り値となる。

※ただし、第一引数にあり第二引数以降にも同じ key値が存在する場合、その value 値はその都度
値が上書きされていく。
Array
(
    [name] => user_name2
    [address] => testtest@gmail.com
    [tel] => 20
    [testkey] => test@gmail.com
    [key] => 45
)

*/

/*=======================================================================
上記が、array_merge と array_diff と array_intersect 各関数の
微妙な動きらしい。
特に、注意するのは array_merge は各配列の key値どうしを比較するのに対して
array_diff と array_intersect は value 値どうしを比較する点に注意する
=======================================================================*/

<script type="text/javascript">

//====================================================================
//【javascript でクラス定義を行う方法】
//====================================================================

//クラス定義のためのコンストラクタの作成
/*
通常の関数定義でも、無名関数としての定義でも
どちらでもコンストラクタは定義できる。

//このコンストラクタを定義すると同時に TestClassFunction というクラスを
//定義したものと同義と考えれる。
*/
var TestClassFunction = function(){
//コンストラクタの実行
alert("コンストラクタの実行");
//インスタンス作成時に、クラス変数の staticMenber をインクリメント
TestClassFunction.staticMenber++;
};

//javascript において関数は関数オブジェクトである。つまり
//以下のようにも書き直せる。
var TestClassFunction = new Function("~上記関数の中身を引数として与えてやる〜");

//スタティックメンバの指定（インスタンスではなくクラス定義したクラスから直接呼びだすメンバ）
TestClassFunction.staticMenber = 0;
TestClassFunction.staticVariable = "スタティック変数";

//メンバ変数の定義（これはインスタンス毎に異なる値を持つインスタンス変数）
TestClassFunction.prototype.nameProperty = "メンバ変数1";
TestClassFunction . prototype . addressProperty = "メンバ変数";
TestClassFunction . prototype . age = "メンバ変数　年齢";

//メンバメソッドの定義（これはインスタンス毎に異なるインスタンスメソッド）
TestClassFunction . prototype . displayClassName = "TestClassFunction";
TestClassFunction .prototype .getMethod = function(){
//ゲッターメソッド
return this.nameProperty;
};
TestClassFunction .prototype. setMethod = function(nameParams__){
//セッターメソッド
this.nameProperty = nameParams__;
};

//クラスのインスタンスの作成
var newObj = new TestClassFunction();
alert(newObj.nameProperty);
alert(TestClassFunction.staticMenber);

//クラスプロパティの
//メンバ変数の値を変更する
newObj . nameProperty = "メンバ変数1の変更";
alert(newObj.nameProperty);

//同じクラスから別のインスタンスを作成する
var anotherObj = new TestClassFunction();
alert(TestClassFunction.staticMenber);
alert(anotherObj.nameProperty)
anotherObj . nameProperty = "別インスタンスのメンバ変数の変更";
alert(anotherObj.nameProperty);
anotherObj.setMethod("セッターメソッドからメンバ変数を変更");
alert(anotherObj.getMethod());

</script>

<script type="text/javascript">
/*【javascript でクラス定義を行う。】*/

/*
javascript でクラス定義を行うには、
最初にコンストラクタを通常の関数として定義する
*/

//Sample という関数を定義すると同時に、Sampleクラスを定義したもの同義
//===============================================================
function Sample(){
	alert("Sample クラス コンストラクタ");
}
/*
この時点で Sample という関数は関数オブジェクトとなるらしい
*/
//===============================================================

//上記の記述方法は以下の用にも書き換えることができる。

//===============================================================
//これは、明示的に通常の関数が Function クラスのオブジェクトだという
//ことがわかる書き方。通常はあまり使わない書き方
var SampleAnother = new Function ("alert('Sample クラスコンストラクタ　もう一つの記述方法');");
//もちろん実行することができる。
SampleAnother();
//===============================================================

//次に Sample クラスのメソッドを以下のようにして定義する
//メソッド自体は無名関数として定義する。
Sample.prototype.testMethod = function (){
		alert("testMethod の作成");
};
//もう一つ次はインスタンス変数の定義をしておく。
Sample.prototype.name = "SampleClass のメンバ変数";
//また prototype 自体に、JSON として与えてやることでもプロパティの追加ができる
Sample.prototype.proValue01  = "プロパティ01";

//以上で簡単なクラスを定義するための順は終了
//まずは一般的な方法でクラスを作成する
var obj = new Sample();
//次に、メソッドの実行
obj.testMethod();
//クラス定義持に、一緒に定義したメンバ変数の出力
alert(obj.name);
alert(obj.proValue01);

//=================================================================================
/*
もう一つインスタンスを作成する方法が
以下のように JSON を使って作成する方法
*/

//以下の用にして JSON データをつくってみる。
obj = {name : "メンバ変数その1",address :"メールアドレス",testMethod : function(){ alert("JSON 形式メソッド")}};

//するとハッシュとしてアクセスもできるし、オブジェクトのメンバのようにアクセスすることもできる。
obj.testMethod();
obj["testMethod"]();
alert(obj.name);
alert(obj["name"]);
alert(obj.address);
alert(obj["address"]);

//以上のことから javascript のオブジェクトは JSON のようなハッシュと同じようなもの
//と言える。とりあえずクラスの定義方法のみメモ。後日きちんとまとめる
//=================================================================================
</script>

<?php
//PHP では定義したクラス内では未定義のプロパティでも
//インスタンスから新規でプロパティを作成することができる。

//例えば以下のような単純なクラスを定義する

class SimpleClass{
	//このクラスで事前定義のプロパティは以下の一つだけ
	public $value = "デフォルトプロパティ";
}

$obj = new SimpleClass();
//プロパティを新規で作成する
$obj->newProperty = "インスタンスからプロパティを作成";
print $obj->newProperty;

//上記の用に、その場でプロパティを追加することができる
//この仕様が紛らわしい場合は、以下のようにして防ぐことができる。

class TestClass{
	//事前定義のプロパティは以下の一つだけ
	public $str ="文字列";

	public function testMethod(){
		echo $this->str;
	}
	//以下の【__set】とというメソッドはインスタンスから未定義のプロパティへアクセス（代入）
	//しようとした場合に自動で呼び出されるマジックメソッドである
	public function __set($undefName,$value){
		print "未定義のインスタンス変数への代入はできません";
	}
	//以下の【__get】とというメソッドはインスタンスから未定義のプロパティを参照
	//しようとした場合に自動で呼び出されるマジックメソッドである
	public function __get($name){
		print "{$name}は定義されていないため参照できません。";
	}
	//以下の【__call】とというメソッドは未定義のメソッドをコールした場合によばれる
	public function __call($undefMethod,$undefParam){
			print "メソッド{$undefMethod}は定義されていません。";
	}
}

$obj = new TestClass();
//以下で未定義のプロパティへアクセス（代入）してみる
$obj->abc = "未定義のプロパティ";

//未定義のプロパティを参照してみる
print $obj->abc;

//また以下では未定義のメソッドをコールしてみる。
$obj -> undefMethod();
?>

上記のように、自由すぎるPHPの仕様をある程度
制御できるっぽい。

<?php
/*
PHP では未定義のクラスのインスタンスを作成しようとすると
自動的に 【__autoload()】という関数を呼び出す仕様になっている
*/

//オートロード関数を用いて、未定義のクラスからインスタンスを作成する
//クラスからインスタンスを作成するときは常にこの__autoload関数が走る。

/*
まず、未定義のクラスのインスタンスを作成する際に呼び出される関数
__autoloadを事前に定義する
*/

//引数には、未定のクラス名が渡されることになる。
//そのため呼び出すファイル名はクラス名をつかって呼び出せるような命名規則にしておく
//今回は、とりあえずクラス名まんまの PHP ファイルにしておく

function __autoload($className){
	//クラス名は念のためすべて小文字にしておく
	$className = strtolower($className);
	require("./".$className.".php");
}

//オートロード関数の登録
//spl_autoload_register();

//ここから未定義のクラスのインスタンスを作成する

$obj = new TestClass();
$obj->testMethod();

$obj = new TestClassExt();
$obj->testMethod();
?>

ただ、上記のような __autoload 関数は現在は非推奨となっいる。
では、その代替え機能はなにかというと 【spl_autoload】という関数が
使えるようになっている。

ただし、この spl_autoload　関数を呼ぶにはちょっと修正を加える必要がある

/*
__autoload 関数は、あたらしい PHP では非推奨の関数なので別の方法をとる
spl_autoload_register 関数を用いる方法
第一引数に作成した関数の文字列を渡すことで 通常の__autoload 関数と
同じ機能を実装する関数
*/

/*
まずは任意の名前で、実行したい関数をつくる。とりあえずは__autoload という名前
ではなく myAutoLoad という名前に変更
*/
function myAutoLoad($className){
	//クラス名は念のためすべて小文字にしておく
	$className = strtolower($className);
	require("./".$className.".php");
}
/*
上記で定義した関数を、クラスのオートローディング機能として使うためには
以下の、関数で登録してやる必要がある
*/
spl_autoload_register("myAutoLoad");

//上記のような記述を行うことで未定義のクラス実行時は
//自分で定義した、 my_autoload関数を実行してくる。

//ここから未定義のクラスのインスタンスを作成する

$obj = new TestClassExt();
$obj->testMethod();

$obj = new TestClass();
$obj->testMethod();

?php

//【PHP のリフレクションクラスの使い方】
//まず、適当なクラスを定義する。
class TestClass{
	public $str = "プロパティ01";
	public $strNull = null;
	static $staticStr = "スタティックプロパティ";
	private $priStr = "プライベートプロパティ01";
	public function testMethod01(){
		//処理内容
	}

	public function testMethod02(){
		//処理内容
	}
	private function testMethod03(){
		//処理内容
	}

}

//定義したクラスのインスタンスをつくる
$obj = new TestClass();

//実際にリフレクションクラスを作成する
$refObj = new ReflectionClass($obj);

//指定したインスタンスのプロパティの ReflectionPropertyインスタンスを返す
print_r($array = $refObj->getProperties());
/*
出力結果
Array
(
    [0] => ReflectionProperty Object
        (
            [name] => str
            [class] => TestClass
        )

    [1] => ReflectionProperty Object
        (
            [name] => staticStr
            [class] => TestClass
        )

    [2] => ReflectionProperty Object
        (
            [name] => priStr
            [class] => TestClass
        )

)
*/
print "指定したプロパティの値を取得";
print ($array[0]->getValue($obj));

//指定したインスタンスのメソッドの RelflectionMethod インスタンスを返す
print_r($refObj->getMethods());
/*
出力結果
Array
(
    [0] => ReflectionMethod Object
        (
            [name] => testMethod01
            [class] => TestClass
        )

    [1] => ReflectionMethod Object
        (
            [name] => testMethod02
            [class] => TestClass
        )

)
*/
//===============================================

print_r($refObj->getMethod("testMethod01"));
print_r($refObj->getMethods());

/*
リフレクションクラスを利用せずに、任意のクラス、あるいはオブジェクトの
実態を調査するには以下のような組み込み関数を利用する
*/
//指定した、インスタンスのメソッド一覧を返す内部検査
//プライベートなメソッドは返さない。
print_r(get_class_methods($obj));

//指定した、インスタンスのクラス名を返す内部検査
print (get_class($obj));

//指定したインスタンスのプロパティを返す内部検査
//プライベートなプロパティは返さない。
print_r(get_class_vars("TestClass"));

//指定したインスタンスの親クラスを返す内部検査
print (get_parent_class($obj));

//指定したインスタンスのアクセス可能なプロパティを返す。
//初期値がないプロパティも返すことができる。
print_r(get_object_vars($obj));

/*
【クロージャーとは：変数の値を無名関数内に閉じ込めてその値を保持することができる。】
*/

/*
クロージャーを実現する方法は
関数内でその関数に返り値として無名関数を返す仕様にしてあげる。
基本系としては、以下のような形
*/
//親スコープの関数を定義
	function outer(){
		var x	= 1;// outerのスコープ内で変数を定義
		/*
		上記変数は無名関数内で仕様するプロパティ的なもの
		この上記変数は無名関数内で以降ずっと保持される値
		*/
		return function (){ //この関数が「クロージャ」
			 alert(x);	//	"関数内関数"の中で、outerスコープの変数を参照。
			 x++;
			 //ここで無名関数の処理が止まっているが、親スコープから拝借している変数の値は保持する。
		};
	}

//まず、関数内の無名関数を帰り値として取得する
var f =  outer();
//次に、帰ってきた無名関数を実行する
f();  // 1と表示。
f();  // 2と表示。
f();  // 3と表示。
f();  // 4と表示。
f();  // 5と表示。
/*
上記のように本来なら【1】とだけ表示されるはずだが、
クロージャーという特性上、エンクロージャーから引き継いだ（参照している）変数は
無名関数の中に永久に閉じ込められて値が常に保持される
そのため、x の値は増え続けていく。
*/

上記のクロージャーをPHP でもやってみる

<?php

/*
PHP で上記 javascriptのクロージャーを実現する方法は以下のようにする。
*/
function test(){
		//無名関数内で使い回す変数を初期化後のクロージャーのプロパティとなる。
		$str = 0;
		/*
		PHP で無名関数内に変数を閉じ込め保持するためには参照渡しを行う。
		無名関内で変数を保持する必要がない場合は値渡しでかまわない。
		*/
		return function () use (&$str){
			$str= $str +1;
			return $str;
		};
}

$obj = test();
print_r($obj);
print $obj();
print $obj();
print $obj();
?>

useで引数を使えるようにするときは値が参照ではなくコピーで渡されるようで

無名関数内で使いたいときは変数名の前に&をつけてあげないと書き換えが反映されません。

外部変数の値を書き換える必要がなければ、&は必要ありません。
参考URL
=> http://d.hatena.ne.jp/Nilfs/20120128/1327767322#c

/*
【javascript におけるレキシカルスコープとはなにか？】
*/

/*
以下のような関数があった場合
出力される値はどうなるだろうか？
*/
	var num = 100;
	function makefunc() {
		return function() {
			/*
			この無名関数内で参照されている変数【num】のスコープ・・というより参照先は、
			実質、グローバルスコープにある変数 var num　という変数である。
			*/
			alert(num);
		}
	}

	function callfunc() {
		/*
		以下でグローバルスコープ内にある変数　num と同じ
		変数を宣言している。（※スコープ自体は全く別）
		*/
		var num = 50;
		var func = makefunc();
		/*
		人情的には、以下で呼び出される無名関数内の
		変数【num】は上記の var num =50　という値のことを
		参照したくなるが・・・・。
		*/
		func();
	};

	callfunc(); //出力される値は100となる。
/*
上記の用に、人情的には 無名関数で参照している変数【num】は親スコープの
関数 callfunc で宣言された　var num =50　を参照していると思いたいが
実際参照されているのは冒頭で宣言された var num = 100 という変数である。
これが、【レキシカルスコープ】というスコープ方式である。

もし、仮に javascript がダイナミックスコープであれば
参照される値は、　call_func 内の var num=50となる。

端的に言えば、javascript で関数を定義した場合、その関数内で
用いる変数はその関数を書いたコード上で一番直前に宣言された 変数となる。
この変数のスコープ動作については PHP しかしらない人には
なじみなく、理解するのにちょっと戸惑うかもしれない。
*/

/*
【javascript におけるスコープとは】
まず、javascript において一番外側のスコープで
変数を宣言した場合、通常そのままその変数を使用すると以降、ユーザー定義関数内
のスコープであっても、一番外側のスコープで定義した変数を使うことができる。
*/
var variable  = "一番外側スコープ";

alert(variable); //一番外側スコープ　が出力される。

	function test01 (){
		alert(variable);

		variable = "スコープ変更";
		/*
		仮にここで 【variable="スコープ変更";】とすると
		親スコープでの 変数　 variable　も値がかわってしまう。
		*/
	}

	function test02(){
		alert(variable);
	}

	test01(); //一番外側スコープ　が出力される。
	test02(); //一番外側スコープ　が出力される。
	alert(variable); //一番外側スコープ　が出力される。
/*
php では上記のコードは関数スコープ内では
親スコープの変数は言語上使用できないため、未定義変数の注意が出る。

上記の場合だと、関数スコープ内でグローバルなスコープ個所で宣言した変数の
値をいじってしまうと、関数のスコープを出ても関数内での変数に行った処理が
生きたままになってしまう。

そのため、関数内で引数以外の変数を使用する際は必ず【var】キーワードを用いる。
これによってたとえ同じ識別子の変数でも独立した関数スコープの変数として使用できる。
※ただし関数のパラメータに親スコープの変数を渡した場合はこの限りではない。
*/

var variable  = "一番外側スコープ";

alert(variable); //一番外側スコープ　が出力される。

	function test03 (){
		//関数 test03の中だけの変数として宣言する。(※関数スコープ = ローカルスコープ)
		var variable;
		variable="内側スコープ";
		alert("---" + variable + "-----");

	}

	function test04(){
		alert(variable);
	}

	test03(); //---内側スコープ---　が出力される。
	test04(); //一番外側スコープ　が出力される。
	alert(variable); //一番外側スコープ　が出力される。

対して、PHPは上記のようなスコープとは異なる

<?php
/*
対して PHP はグローバルスコープで初期化した変数を
関数スコープでは参照できない言語構造
*/

$str = "グローバルスコープ";

function testMethod(){
	//以下で出てきた【$str】という変数はこの関数スコープ内でのみ利用できる変数。
	print $str;
}

/*
以下の、注意が発生する。
Notice: Undefined variable: str in
*/
testMethod();

/*
この、グローバル変数を関数スコープの中でデフォルトで利用できないため
PHP のスコープはレキシカルスコープでもダイナミックスコープでもない
静的・動的スコープのくくりの対象外となる。
そのため無名関数でクロージャ処理を書くためにuse処理が必要となってくる。
*/