每日五個 PHP 函式記憶

finecho發表於2019-01-14

@這是小豪的第六篇文章（其實也不算文章哈哈）

差不多是 2017 年年底的時候接觸的 PHP，也沒有系統正式的學習過任何基礎，當時直接上手了一個 Thinkphp5.0 的商城專案，還是二次開發，在之後的時間裡我所有的 PHP 開發思維全部固化在第一個專案裡面，模仿....一味的模仿，專案開發框架也一直是 Thinkphp5.0，沒有任何改變。

在四個月前，我依然是這樣。就連專案中出現的 PHP 函式也只是自己所熟悉的函式的組合，沒有願意去發掘新的自己所不熟知的東西，一直這樣，學習也是，東學西學，啥也沒學到。

我都知道自己的問題所在，但是總是不願意跳出自己的舒適區，總以自己還年輕，可以慢慢來當作藉口，其實都是屁話。

一直沒有進步........

來到新的公司遇到了超哥，很幸運，很幸運，多的話不說了哈哈。

超哥給了我幾點建議：

1. 記 PHP 函式

2. 學習優秀程式碼的思想

3. 不停寫程式碼，十萬行程式碼什麼時候達到什麼時候就 NB 了

4. 多嘗試脫離任何固定思維去寫東西、按自己的想法去做、然後你會遇到問題，總結起來

5. 反思自己寫程式碼的套路與流程，敢於懷疑

一步一個腳印，穩紮穩打，重新出發！從基本的函式記憶開始，堅持 ing！

每天花 5 分鐘左右的時間刷一遍，哈哈。

這篇文章已經更新不動了，請戳《每日五個 PHP 函式 (2)》

2019/02/19

今日小練習

// 說明：確保指定 user_id 存在於 users 陣列中

$users = array(2, 3);

$user_id = 1;

in_array($user_id, $users) || array_unshift($users, $user_id);


print_r($users);

// 輸出：
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
)

--------------------------------------- 回顧 01-15 (點我) ---------------------------------------

2019/02/18

今日小練習

// 說明：將陣列以指定字元拼接為字串、根據指定字元將字串打散為陣列、根據長度將字串拆分為陣列

$arr = array('Hello','World!','I','love','Shenzhen!');
$str = "Hello World! I love Shenzhen!";

echo implode(" ", $arr);
print_r (explode(" ", $str));
print_r (str_split($str, 4));

// 輸出：
Hello World! I love Shenzhen!

// 輸出：
(
    [0] => Hello
    [1] => World!
    [2] => I
    [3] => love
    [4] => Shenzhen!
)

// 輸出：
(
    [0] => Hell
    [1] => o Wo
    [2] => rld!
    [3] =>  I l
    [4] => ove 
    [5] => Shen
    [6] => zhen
    [7] => !
)

--------------------------------------- 回顧 01-14 (點我) ---------------------------------------

2019/02/17

繼續回顧之前的噢

今日小練習

// 說明：獲取一堆使用者中指定 uid 的鍵值

$key = array_search(40489, array_column($users, 'uid'));

--------------------------------------- 回顧 01-13 (點我) ---------------------------------------

2019/02/16

繼續回顧之前的噢，哈哈

今日小練習

// 說明：時間戳相互轉換

echo date("Y-m-d H:i", time());
echo strtotime("2019-02-16 20:33");

// 輸出：2019-02-16 20:33
// 輸出：1550320380

--------------------------------------- 回顧 01-12 (點我) ---------------------------------------

2019/02/15

繼續回顧之前的噢，哈哈

今日小練習

// 說明：獲取 abc.jpeg 字尾名

$fileName = 'abc.jpeg';

echo substr($fileName, strrpos($fileName, "."));

// 輸出：.jpeg

--------------------------------------- 回顧 01-11 (點我) ---------------------------------------

2019/02/14

也刷了這麼多天的函式了，感覺之前的都忘記了哈哈，現在就回顧一下之前的吧。

今日小練習

// 說明：將 [1, 2, 3] 轉變為：[1=>"a", 2=>"a", 3=>"a"]

$arr = array(1, 2, 3);

var_dump(array_combine($arr, array_fill(0, count($arr), 'a')));

// 輸出：
array(3) {
  [1]=>
  string(1) "a"
  [2]=>
  string(1) "a"
  [3]=>
  string(1) "a"
}

--------------------------------------- 回顧 01-10 (點我) ---------------------------------------

2019/02/13

檔案系統 No.1

// 說明：chdir ( string $directory ) : bool
// 將 PHP 的當前目錄改為 directory。

// 說明：chroot ( string $directory ) : bool
// 將當前程式的根目錄改變為 directory ，本函式僅在系統支援且執行於 CLI，CGI 或嵌入 SAPI 版本時才能正確工作。此外本函式還需要 root 許可權。

closedir — 關閉目錄控制程式碼

// 說明：closedir ([ resource $dir_handle ] ) : void
// 關閉由 dir_handle 指定的目錄流。流必須之前被 opendir() 所開啟。

dir —返回一個 Directory 類例項

// 說明：dir ( string $directory [, resource $context ] ) : Directory
// 以物件導向的方式訪問目錄。開啟 directory 引數指定的目錄。

getcwd — 取得當前工作目錄

// 說明：getcwd ( void ) : string
// 取得當前工作目錄

2019/02/12

日期函式 No.3

localtime — 取得本地時間

// 說明：localtime ([ int $timestamp = time() [, bool $is_associative = false ]] ) : array

$localtime = localtime();
$localtime_assoc = localtime(time(), true);

print_r($localtime);
print_r($localtime_assoc);

// 輸出：
Array
(
    [0] => 53
    [1] => 46
    [2] => 22
    [3] => 12
    [4] => 1
    [5] => 119   // 1900 + 119 = 2019
    [6] => 2
    [7] => 42
    [8] => 0
)
Array
(
    [tm_sec] => 53
    [tm_min] => 46
    [tm_hour] => 22
    [tm_mday] => 12
    [tm_mon] => 1
    [tm_year] => 119
    [tm_wday] => 2
    [tm_yday] => 42
    [tm_isdst] => 0
)

file

time — 返回當前的 Unix 時間戳

// 說明：time ( void ) : int

$nextWeek = time() + (7 * 24 * 60 * 60);
                   // 7 days; 24 hours; 60 mins; 60 secs

echo 'Now:       '. date('Y-m-d') ."\n"; // 輸出：Now:       2019-02-12

echo 'Next Week: '. date('Y-m-d', $nextWeek) ."\n"; // 輸出：Next Week: 2019-02-19

echo 'Next Week: '. date('Y-m-d', strtotime('+1 week')) ."\n"; // 輸出：Next Week: 2019-02-19

gmdate — 格式化一個 GMT/UTC 日期／時間

// 說明：gmdate ( string $format [, int $timestamp ] ) : string

echo date("M d Y H:i:s", mktime (0,0,0,02,12,2019)); // 輸出：Feb 12 2019 00:00:00
echo gmdate("M d Y H:i:s", mktime (0,0,0,02,12,2019)); // 輸出：Feb 12 2019 00:00:00

gettimeofday —取得當前時間

// 說明：gettimeofday ([ bool $return_float = false ] ) : mixed

print_r(gettimeofday());

echo gettimeofday(true);

// 輸出：
Array
(
    [sec] => 1549983633
    [usec] => 757476
    [minuteswest] => 0
    [dsttime] => 0
)

1549983633.7576

file

gmmktime — 取得 GMT 日期的 UNIX 時間戳

// 說明：gmmktime ([ int $hour [, int $minute [, int $second [, int $month [, int $day [, int $year [, int $is_dst ]]]]]]] ) : int

echo gmmktime(0, 0, 0, 2, 12, 2019); // 輸出：1549929600

2019/02/11

日期函式 No.2

date — 格式化一個本地時間／日期

// 說明：date ( string $format [, int $timestamp ] ) : string

// 星期幾
echo date("l") . "<br>"; // 輸出：Monday

echo date("Y-m-d H:i");  // 輸出：2019-02-11 19:48

詳細引數說明請戳 -> date 官方文件

strtotime — 將任何字串的日期時間描述解析為 Unix 時間戳

// 說明：strtotime ( string $time [, int $now = time() ] ) : int

echo strtotime("now"), "\n"; // 輸出：1549885944
echo strtotime("10 September 2000"), "\n"; // 輸出：968515200
echo strtotime("+1 day"), "\n"; // 輸出：1549972344
echo strtotime("+1 week"), "\n"; // 輸出：1550490744
echo strtotime("+1 week 2 days 4 hours 2 seconds"), "\n"; // 輸出：1550677946
echo strtotime("next Thursday"), "\n"; // 輸出：1550073600
echo strtotime("last Monday"), "\n"; // 輸出：1549209600
echo strtotime("2019-02-11"), "\n"; // 輸出：1549814400

getdate —取得日期／時間資訊

// 說明：getdate ([ int $timestamp = time() ] ) : array

$today = getdate();

print_r($today);

// 輸出：
Array
(
    [seconds] => 9
    [minutes] => 58
    [hours] => 19
    [mday] => 11
    [wday] => 1
    [mon] => 2
    [year] => 2019
    [yday] => 41
    [weekday] => Monday
    [month] => February
    [0] => 1549886289
)

microtime — 返回當前 Unix 時間戳和微秒數

// 說明：microtime ([ bool $get_as_float ] ) : mixed
// 如果呼叫時不帶可選引數，本函式以 "msec sec" 的格式返回一個字串，其中 sec 是自 Unix 紀元（0:00:00 January 1, 1970 GMT）起到現在的秒數，msec 是微秒部分。字串的兩部分都是以秒為單位返回的

echo(microtime()); // 輸出：0.85606500 1549886401

mktime — 取得一個日期的 Unix 時間戳

// 說明：mktime ([ int $hour = date("H") [, int $minute = date("i") [, int $second = date("s") [, int $month = date("n") [, int $day = date("j") [, int $year = date("Y") [, int $is_dst = -1 ]]]]]]] ) : int

// 設定要使用的預設時區。 自PHP 5.1起可用
date_default_timezone_set('UTC');

// 輸出: July 1, 2000 is on a Saturday
echo "July 1, 2000 is on a " . date("l", mktime(0, 0, 0, 7, 1, 2000));

// 輸出: 2006-04-05T01:02:03+00:00
echo date('c', mktime(1, 2, 3, 4, 5, 2006));

2019/02/10

日期函式 No.1

date_create / DateTime::__construct — 函式返回一個新的 DateTime 物件

// 面對物件風格：public DateTime::__construct ([ string $time = "now" [, DateTimeZone $timezone = NULL ]] )
// 過程化風格：date_create ([ string $time = "now" [, DateTimeZone $timezone = NULL ]] ) : DateTime

$date=date_create("2019-02-10");
echo date_format($date,"Y/m/d"); // 輸出：2019/02/10

checkdate — 檢查一些日期是否是有效的格利高裡日期

// 說明：checkdate ( int $month , int $day , int $year ) : bool
// 檢查由引數構成的日期的合法性。如果每個引數都正確定義了則會被認為是有效的。

var_dump(checkdate(12, 31, 2000)); // 輸出：bool(true)
var_dump(checkdate(2, 29, 2001)); // 輸出：bool(false)

date_format —函式返回一個根據指定格式進行格式化的日期

// 面對物件風格：public DateTime::format ( string $format ) : string、public DateTimeImmutable::format ( string $format ) : string、public DateTimeInterface::format ( string $format ) : string
// 過程化風格：date_format ( DateTimeInterface $object , string $format ) : string

$date = new DateTime('2019-02-10');
echo $date->format('Y-m-d H:i:s'); // 輸出：2019-02-10 00:00:00

$date = date_create('2019-02-10');
echo date_format($date, 'Y-m-d H:i:s'); // 輸出：2019-02-10 00:00:00

date_add / DateTime::add — 給一個 DateTime 物件增加一定量的天，月，年，小時，分鐘以及秒

// 面對物件風格：public DateTime::add ( DateInterval $interval ) : DateTime
// 過程化風格：date_add ( DateTime $object , DateInterval $interval ) : DateTime

// 新增 40 天到 2013 年 3 月 15 日：

$date=date_create("2019-02-10");
date_add($date,date_interval_create_from_date_string("40 days"));
echo date_format($date,"Y-m-d"); // 輸出：2019-03-22

date_interval_create_from_date_string / DateInterval::createFromDateString() — 從字串的相關部分建立一個 DateInterval

// 說明：public static DateInterval::createFromDateString ( string $time ) : DateInterval

2019/02/08

日曆函式 No.2

JDToGregorian — 轉變一個Julian Day計數為Gregorian曆法日期

// 說明：jdtogregorian ( int $julianday ) : string

gregoriantojd — 轉變一個 Gregorian 曆法日期到 Julian Day 計數

// 說明：gregoriantojd ( int $month , int $day , int $year ) : int

$jd = GregorianToJD(10, 11, 1970);
echo "$jd\n"; // 輸出：2440871

$gregorian = JDToGregorian($jd);
echo "$gregorian\n"; //  輸出：10/11/1970

JDMonthName — 返回月份的名稱

// 說明：jdmonthname ( int $julianday , int $mode ) : string

$jd=gregoriantojd(1,13,1998);
echo jdmonthname($jd,0);

file

jdtounix —轉變 Julian Day 計數為一個 Unix 時間戳

// 說明：jdtounix ( int $jday ) : int
// 這個函式根據給定的 julian 天數返回一個Unix時間戳，或如果引數 jday 不在 Unix 時間（ Gregorian 曆法的 1970 年至 2037 年，或 2440588 <= jday <= 2465342）範圍內返回 FALSE 。返回的時間是本地時間（不是 GMT ）。

unixtojd — 轉變 Unix 時間戳為 Julian Day 計數

// 說明：unixtojd ([ int $timestamp = time() ] ) : int
// 根據指定的Unix時間戳 timestamp，返回 Julian 天數。如果沒有指定時間戳則返回當前日期的天數

2019/02/07

日曆函式 No.1

cal_info — 返回選定曆法的資訊

// 說明：cal_info ([ int $calendar = -1 ] ) : array
// 0 or CAL_GREGORIAN - 陽曆
// 1 or CAL_JULIAN - 儒略日（是在儒略週期內以連續的日數計算時間的計時法，主要是天文學家在使用。）
// 2 or CAL_JEWISH - 猶太曆；猶歷(猶太人所用的一種陰陽曆記日系統，從公元前3761年算起)
// 3 or CAL_FRENCH - 法國共和曆(法蘭西第一共和國採用的革命曆法，於1793年11月24日起採用，1806年元旦廢止)

$info = cal_info(0);
print_r($info);

// 輸出：
Array
(
    [months] => Array
        (
            [1] => January
            [2] => February
            [3] => March
            [4] => April
            [5] => May
            [6] => June
            [7] => July
            [8] => August
            [9] => September
            [10] => October
            [11] => November
            [12] => December
        )

    [abbrevmonths] => Array
        (
            [1] => Jan
            [2] => Feb
            [3] => Mar
            [4] => Apr
            [5] => May
            [6] => Jun
            [7] => Jul
            [8] => Aug
            [9] => Sep
            [10] => Oct
            [11] => Nov
            [12] => Dec
        )

    [maxdaysinmonth] => 31
    [calname] => Gregorian
    [calsymbol] => CAL_GREGORIAN
)

cal_days_in_month — 返回某個曆法中某年中某月的天數

// 說明：cal_days_in_month ( int $calendar , int $month , int $year ) : int

$num = cal_days_in_month(CAL_GREGORIAN, 8, 2003); // 31
echo "There was $num days in August 2003";

easter_date — 得到指定年份的復活節午夜時的Unix時間戳

// 說明：easter_date ([ int $year ] ) : int

echo date("M-d-Y", easter_date(1999));        // Apr-04-1999
echo date("M-d-Y", easter_date(2000));        // Apr-23-2000
echo date("M-d-Y", easter_date(2001));        // Apr-15-2001

easter_days — 得到指定年份的3月21日到復活節之間的天數

// 說明：easter_days ([ int $year [, int $method = CAL_EASTER_DEFAULT ]] ) : int
// 返回指定年份的3月21日到復活節之間的天數，如果沒有指定年份，預設是當年。

echo easter_days(1999);        // 14, i.e. April 4
echo easter_days(1492);        // 32, i.e. April 22
echo easter_days(1913);        //  2, i.e. March 23

JDDayOfWeek — 返回星期的日期

// 說明：jddayofweek ( int $julianday [, int $mode = CAL_DOW_DAYNO ] ) : mixed
// mode：
// 0 -> 返回數字形式(0=Sunday, 1=Monday, etc)
// 1 -> 返回字串形式 (English-Gregorian)
// 2 -> 返回縮寫形式的字串 (English-Gregorian)

// 返回 1998 年 1 月 13 日這天是周幾：
$jd=gregoriantojd(1,13,1998); // gregoriantojd：轉變一個 Gregorian 曆法日期到 Julian Day 計數

echo jddayofweek($jd,1); //  輸出：Tuesday

2019/02/06

過濾器函式 No.1

filter_has_var — 檢測是否存在指定型別的變數

// 說明：filter_has_var ( int $type , string $variable_name ) : bool

if ( !filter_has_var(INPUT_GET, 'email') ) {
    echo "Email Not Found";
}else{
    echo "Email Found";
}

localhost/test.php?email=1 //Email Found
localhost/test.php?email //Email Found
localhost/test.php //Email Not Found

filter_list — 返回所支援的過濾器列表

// 說明：filter_list ( void ) : array

print_r(filter_list());

// 輸出類似：
Array
(
    [0] => int
    [1] => boolean
    [2] => float
    [3] => validate_regexp
    [4] => validate_url
    [5] => validate_email
    [6] => validate_ip
    [7] => string
    [8] => stripped
    [9] => encoded
    [10] => special_chars
    [11] => unsafe_raw
    [12] => email
    [13] => url
    [14] => number_int
    [15] => number_float
    [16] => magic_quotes
    [17] => callback
)

filter_id — 返回與某個特定名稱的過濾器相關聯的 id

// 說明：filter_id ( string $filtername ) : int

$filters = filter_list(); 

foreach($filters as $filter_name) { 
    echo $filter_name .": ".filter_id($filter_name) ."<br>"; 
} 

// 輸出類似：
boolean: 258 
float: 259 
validate_regexp: 272 
validate_url: 273 
validate_email: 274 
validate_ip: 275 
string: 513 
stripped: 513 
encoded: 514 
special_chars: 515 
unsafe_raw: 516 
email: 517 
url: 518 
number_int: 519 
number_float: 520 
magic_quotes: 521 
callback: 1024

filter_input — 過名稱獲取特定的外部變數，並且可以通過過濾器處理它

// 說明：filter_input ( int $type , string $variable_name [, int $filter = FILTER_DEFAULT [, mixed $options ]] ) : mixed
// type: INPUT_GET, INPUT_POST, INPUT_COOKIE, INPUT_SERVER或 INPUT_ENV之一。

$search_html = filter_input(INPUT_GET, 'search', FILTER_SANITIZE_SPECIAL_CHARS);
$search_url = filter_input(INPUT_GET, 'search', FILTER_SANITIZE_ENCODED);

echo "You have searched for $search_html.\n"; // 輸出：You have searched for Me & son.
echo "<a href='?search=$search_url'>Search again.</a>"; // 輸出：<a href='?search=Me%20%26%20son'>Search again.</a>

filter_var — 使用特定的過濾器過濾一個變數

// 說明：filter_var ( mixed $variable [, int $filter = FILTER_DEFAULT [, mixed $options ]] ) : mixed

var_dump(filter_var('bob@example.com', FILTER_VALIDATE_EMAIL)); // 輸出：string(15) "bob@example.com"
var_dump(filter_var('http://example.com', FILTER_VALIDATE_URL, FILTER_FLAG_PATH_REQUIRED)); // 輸出：bool(false)

2019/02/05

可變處理函式 No.4

is_string — 檢測變數是否是字串

// 說明：is_string ( mixed $var ) : bool

isset — 檢測變數是否已設定並且非 NULL

// 說明：isset ( mixed $var [, mixed $... ] ) : bool

$var = '';

// 結果為 TRUE，所以後邊的文字將被列印出來。
if (isset($var)) {
    echo "This var is set so I will print.";
}

$a = "test";
$b = "anothertest";

var_dump(isset($a));      // TRUE
var_dump(isset($a, $b)); // TRUE

unset ($a);

var_dump(isset($a));     // FALSE
var_dump(isset($a, $b)); // FALSE

$foo = NULL;
var_dump(isset($foo));   // FALSE

serialize — 產生一個可儲存的值的表示

// 說明：serialize ( mixed $value ) : string
// serialize() 返回字串，此字串包含了表示 value 的位元組流，可以儲存於任何地方

unserialize — 從已儲存的表示中建立 PHP 的值

// 說明：unserialize ( string $str ) : mixed
// unserialize() 對單一的已序列化的變數進行操作，將其轉換回 PHP 的值。

unset — 釋放給定的變數

// 說明：unset ( mixed $var [, mixed $... ] ) : void
// unset() 銷燬指定的變數。

2019/02/04

可變處理函式 No.3

is_float / is_double — 檢測變數是否是浮點型

// 說明：is_float ( mixed $var ) : bool

is_int / is_integer / is_long — 檢測變數是否是整數

// 說明：is_int ( mixed $var ) : bool

is_null — 檢測變數是否為 NULL

// 說明：is_null ( mixed $var ) : bool

is_numeric — 檢測變數是否為數字或數字字串

// 說明：is_numeric ( mixed $var ) : bool

is_object — 檢測變數是否是一個物件

// 說明：is_object ( mixed $var ) : bool

哈哈，今天新年啦，祝福大家新年快樂，身體棒棒噠！

2019/02/03

可變處理函式 No.2

get_resource_type — 返回資源（resource）型別

// 說明：get_resource_type ( resource $handle ) : string

$c = mysql_connect();
echo get_resource_type($c)."\n"; // 輸出：mysql link

$fp = fopen("foo","w");
echo get_resource_type($fp)."\n"; // 輸出：file

$doc = new_xmldoc("1.0");
echo get_resource_type($doc->doc)."\n"; // 輸出：domxml document

is_array — 檢測變數是否是陣列

// 說明：is_array ( mixed $var ) : bool
// 如果 var 是 array，則返回 TRUE，否則返回 FALSE。

is_bool — 檢測變數是否是布林型

// 說明：is_bool ( mixed $var ) : bool
// 如果 var 是 boolean 則返回 TRUE。

is_callable — 檢測引數是否為合法的可呼叫結構

// 說明：is_callable ( callable $name [, bool $syntax_only = false [, string &$callable_name ]] ) : bool

// name：要檢查的回撥函式。
// syntax_only：如果設定為 TRUE，這個函式僅僅驗證 name 可能是函式或方法。 它僅僅拒絕非字元，或者未包含能用於回撥函式的有效結構。有效的應該包含兩個元素，第一個是一個物件或者字元，第二個元素是個字元。
// callable_name 接受“可呼叫的名稱”。下面的例子是 “someClass::someMethod” 。 注意，儘管 someClass::SomeMethod() 的含義是可呼叫的靜態方法，但例子的情況並不是這樣的。

function someFunction() 
{
}

$functionVariable = 'someFunction';

var_dump(is_callable($functionVariable, false, $callable_name));  // bool(true)

echo $callable_name, "\n";  // someFunction

//
//  Array containing a method
//

class someClass {

  function someMethod() 
  {
  }

}

$anObject = new someClass();

$methodVariable = array($anObject, 'someMethod');

var_dump(is_callable($methodVariable, true, $callable_name));  //  bool(true)

echo $callable_name, "\n";  //  someClass::someMethod

is_countable — 驗證變數的內容是否為可數值

// 說明：is_countable ( mixed $var ) : bool

var_dump(is_countable([1, 2, 3])); // bool(true)
var_dump(is_countable(new ArrayIterator(['foo', 'bar', 'baz']))); // bool(true)
var_dump(is_countable(new ArrayIterator())); // bool(true)
var_dump(is_countable(new stdClass())); // bool(false)

2019/02/02

可變處理函式 No.1

boolval — 獲取變數的布林值

// 說明：boolval ( mixed $var ) : boolean

echo '0:        '.(boolval(0) ? 'true' : 'false')."\n"; // 輸出：0: false
echo '42:       '.(boolval(42) ? 'true' : 'false')."\n"; // 輸出：42: true
echo '0.0:      '.(boolval(0.0) ? 'true' : 'false')."\n"; // 輸出：0.0: false
echo '4.2:      '.(boolval(4.2) ? 'true' : 'false')."\n"; // 輸出：4.2: true
echo '"":       '.(boolval("") ? 'true' : 'false')."\n"; // 輸出："": false
echo '"string": '.(boolval("string") ? 'true' : 'false')."\n"; // 輸出："string": true
echo '"0":      '.(boolval("0") ? 'true' : 'false')."\n"; // 輸出："0": false
echo '"1":      '.(boolval("1") ? 'true' : 'false')."\n"; // 輸出："1": true
echo '[1, 2]:   '.(boolval([1, 2]) ? 'true' : 'false')."\n"; // 輸出：[1, 2]: true
echo '[]:       '.(boolval([]) ? 'true' : 'false')."\n"; // 輸出：[]: false
echo 'stdClass: '.(boolval(new stdClass) ? 'true' : 'false')."\n"; // 輸出：stdClass: true

floatval — 獲取變數的浮點值

// 說明：floatval ( mixed $var ) : float

$var = '122.34343The';
$float_value_of_var = floatval ($var);
print $float_value_of_var; // 輸出： 122.34343

intval — 獲取變數的整數值

// 說明：intval ( mixed $var [, int $base = 10 ] ) : int

echo intval(42);                      // 42
echo intval(4.2);                     // 4
echo intval('42');                    // 42
echo intval('+42');                   // 42
echo intval('-42');                   // -42
echo intval(042);                     // 34
echo intval('042');                   // 42
echo intval(1e10);                    // 1410065408
echo intval('1e10');                  // 1
echo intval(0x1A);                    // 26
echo intval(42000000);                // 42000000
echo intval(420000000000000000000);   // 0
echo intval('420000000000000000000'); // 2147483647
echo intval(42, 8);                   // 42
echo intval('42', 8);                 // 34
echo intval(array());                 // 0
echo intval(array('foo', 'bar'));     // 1

strval — 獲取變數的字串值

// 說明：strval ( mixed $var ) : string

$foo = strval(123);
var_dump($foo); // string(3) "123"

settype — 設定變數的型別

// 說明：settype ( mixed &$var , string $type ) : bool

$foo = "5bar"; // string
$bar = true;   // boolean

settype($foo, "integer"); // $foo 現在是 5   (integer)
settype($bar, "string");  // $bar 現在是 "1" (string)

2019/02/01

Ctype 函式 No.2

ctype_lower — 做小寫字元檢測

// 說明：ctype_lower ( string $text ) : bool
// 檢查提供的 string 和 text 裡面的字元是不是都是小寫字母。

$strings = array('aac123', 'qiutoas', 'QASsdks');

foreach ($strings as $testcase) {
    if (ctype_lower($testcase)) {
        echo "The string $testcase consists of all lowercase letters.\n";
    } else {
        echo "The string $testcase does not consist of all lowercase letters.\n";
    }
}

// 輸出：
// The string aac123 does not consist of all lowercase letters.
// The string qiutoas consists of all lowercase letters.
// The string QASsdks does not consist of all lowercase letters.

ctype_print — 做可列印字元檢測

// 說明：ctype_print ( string $text ) : bool
// 檢查提供的 string 和 text 裡面的字元是不是都是可以列印出來。

$strings = array('string1' => "asdf\n\r\t", 'string2' => 'arf12', 'string3' => 'LKA#@%.54');

foreach ($strings as $name => $testcase) {
    if (ctype_print($testcase)) {
        echo "The string '$name' consists of all printable characters.\n";
    } else {
        echo "The string '$name' does not consist of all printable characters.\n";
    }
}

// 輸出：
// The string 'string1' does not consist of all printable characters.
// The string 'string2' consists of all printable characters.
// The string 'string3' consists of all printable characters.

ctype_punct — 檢測可列印的字元是不是不包含空白、數字和字母

// 說明：ctype_punct ( string $text ) : bool
// 檢查提供的 string 和 text 裡面的字元是不是都是標點符號。

$strings = array('ABasdk!@!$#', '!@ # $', '*&$()');

foreach ($strings as $testcase) {
    if (ctype_punct($testcase)) {
        echo "The string $testcase consists of all punctuation.\n";
    } else {
        echo "The string $testcase does not consist of all punctuation.\n";
    }
}

// 輸出：
// The string ABasdk!@!$# does not consist of all punctuation.
// The string !@ # $ does not consist of all punctuation.
// The string *&$() consists of all punctuation.

ctype_space — 做空白字元檢測

// 說明：ctype_space ( string $text ) : bool
// 檢查提供的 string 和 text 裡面的字元是否包含空白。

$strings = array('string1' => "\n\r\t", 'string2' => "\narf12", 'string3' => '\n\r\t');

foreach ($strings as $name => $testcase) {
    if (ctype_space($testcase)) {
        echo "The string '$name' consists of all whitespace characters.\n";
    } else {
        echo "The string '$name' does not consist of all whitespace characters.\n";
    }
}

// 輸出：
// The string 'string1' consists of all whitespace characters.
// The string 'string2' does not consist of all whitespace characters.
// The string 'string3' does not consist of all whitespace characters.

ctype_upper — 做大寫字母檢測

// 說明：ctype_upper ( string $text ) : bool
// 檢查 string 和 text 裡面的字元是不是都是大寫字母。

$strings = array('AKLWC139', 'LMNSDO', 'akwSKWsm');

foreach ($strings as $testcase) {
    if (ctype_upper($testcase)) {
        echo "The string $testcase consists of all uppercase letters.\n";
    } else {
        echo "The string $testcase does not consist of all uppercase letters.\n";
    }
}

// 輸出：
// The string AKLWC139 does not consist of all uppercase letters.
// The string LMNSDO consists of all uppercase letters.
// The string akwSKWsm does not consist of all uppercase letters.

2019/01/31

Ctype 函式 No.1

ctype_alnum — 做字母和數字字元檢測

// 說明：ctype_alnum ( string $text ) : bool
// 如果 text 中所有的字元全部是字母和(或者)數字，返回 TRUE 否則返回 FALSE

$strings = array('AbCd1zyZ9', 'foo!#$bar');

foreach ($strings as $testcase) {
    if (ctype_alnum($testcase)) {
        echo "The string $testcase consists of all letters or digits.\n";
    } else {
        echo "The string $testcase does not consist of all letters or digits.\n";
    }
}

// 輸出：
// The string AbCd1zyZ9 consists of all letters or digits.
// The string foo!#$bar does not consist of all letters or digits.

ctype_alpha — 做純字元檢測

// 說明：ctype_alpha ( string $text ) : bool
// 如果在當前語言環境中 text 裡的每個字元都是一個字母，那麼就返回 TRUE，反之則返回 FALSE。

$strings = array('KjgWZC', 'arf12');
foreach ($strings as $testcase) {
    if (ctype_alpha($testcase)) {
        echo "The string $testcase consists of all letters.\n";
    } else {
        echo "The string $testcase does not consist of all letters.\n";
    }
}

// 輸出：
// The string KjgWZC consists of all letters.
// The string arf12 does not consist of all letters.

ctype_cntrl — 做控制字元檢測

// 說明：ctype_cntrl ( string $text ) : bool
// 如果在當前的語言環境下 text 裡面的每個字元都是控制字元，就返回 TRUE ；反之就返回 FALSE 。
// 控制字元就是例如：換行、縮排、空格。

$strings = array('string1' => "\n\r\t", 'string2' => 'arf12');
foreach ($strings as $name => $testcase) {
    if (ctype_cntrl($testcase)) {
        echo "The string '$name' consists of all control characters.\n";
    } else {
        echo "The string '$name' does not consist of all control characters.\n";
    }
}

// 輸出：
// The string 'string1' consists of all control characters.
// The string 'string2' does not consist of all control characters.

ctype_digit — 做純數字檢測

// 說明：ctype_digit ( string $text ) : bool

$strings = array('1820.20', '10002', 'wsl!12');

foreach ($strings as $testcase) {
    if (ctype_digit($testcase)) {
        echo "The string $testcase consists of all digits.\n";
    } else {
        echo "The string $testcase does not consist of all digits.\n";
    }
}

// 輸出：
// The string 1820.20 does not consist of all digits.
// The string 10002 consists of all digits.
// The string wsl!12 does not consist of all digits.

ctype_graph — 做可列印字串檢測，空格除外

// 說明：ctype_graph ( string $text ) : bool
// 如果 text 裡面的每個字元都是輸出可見的（沒有空白），就返回 TRUE ；反之就返回 FALSE 。

$strings = array('string1' => "asdf\n\r\t", 'string2' => 'arf12', 'string3' => 'LKA#@%.54');

foreach ($strings as $name => $testcase) {
    if (ctype_graph($testcase)) {
        echo "The string '$name' consists of all (visibly) printable characters.\n";
    } else {
        echo "The string '$name' does not consist of all (visibly) printable characters.\n";
    }
}

// 輸出：
// The string 'string1' does not consist of all (visibly) printable characters.
// The string 'string2' consists of all (visibly) printable characters.
// The string 'string3' consists of all (visibly) printable characters.

2019/01/30

類/物件函式 No.3

is_a — 如果物件屬於該類或該類是此物件的父類則返回 TRUE

// 說明：is_a ( object $object , string $class_name [, bool $allow_string = FALSE ] ) : bool

// 定義一個類
class WidgetFactory
{
  var $oink = 'moo';
}

// 建立一個新物件
$WF = new WidgetFactory();

if (is_a($WF, 'WidgetFactory')) {
  echo "yes, \$WF is still a WidgetFactory\n";
}

is_subclass_of — 如果此物件是該類的子類，則返回 TRUE

// 說明：is_subclass_of ( object $object , string $class_name ) : bool

// define a class
class WidgetFactory
{
  var $oink = 'moo';
}

// define a child class
class WidgetFactory_Child extends WidgetFactory
{
  var $oink = 'oink';
}

// create a new object
$WF = new WidgetFactory();
$WFC = new WidgetFactory_Child();

if (is_subclass_of($WFC, 'WidgetFactory')) {
  echo "yes, \$WFC is a subclass of WidgetFactory\n";
} else {
  echo "no, \$WFC is not a subclass of WidgetFactory\n";
}

if (is_subclass_of($WF, 'WidgetFactory')) {
  echo "yes, \$WF is a subclass of WidgetFactory\n";
} else {
  echo "no, \$WF is not a subclass of WidgetFactory\n";
}

// usable only since PHP 5.0.3
if (is_subclass_of('WidgetFactory_Child', 'WidgetFactory')) {
  echo "yes, WidgetFactory_Child is a subclass of WidgetFactory\n";
} else {
  echo "no, WidgetFactory_Child is not a subclass of WidgetFactory\n";
}

// 輸出：
// yes, $WFC is a subclass of WidgetFactory
// no, $WF is not a subclass of WidgetFactory
// yes, WidgetFactory_Child is a subclass of WidgetFactory

method_exists — 檢查類的方法是否存在

// 說明：method_exists ( mixed $object , string $method_name ) : bool

$directory = new Directory('.');
var_dump(method_exists($directory,'read')); // 輸出：bool(true)

property_exists — 檢查物件或類是否具有該屬性

// 說明：property_exists ( mixed $class , string $property ) : bool

class myClass {
    public $mine;
    private $xpto;
    static protected $test;

    static function test() {
        var_dump(property_exists('myClass', 'xpto')); //true
    }
}

var_dump(property_exists('myClass', 'mine'));   //true
var_dump(property_exists(new myClass, 'mine')); //true
var_dump(property_exists('myClass', 'xpto'));   //true, as of PHP 5.3.0
var_dump(property_exists('myClass', 'bar'));    //false
var_dump(property_exists('myClass', 'test'));   //true, as of PHP 5.3.0
myClass::test();

trait_exists — 檢查指定的 trait 是否存在

// 說明：trait_exists ( string $traitname [, bool $autoload ] ) : bool

trait World {

    private static $instance;
    protected $tmp;

    public static function World()
    {
        self::$instance = new static();
        self::$instance->tmp = get_called_class().' '.__TRAIT__;

        return self::$instance;
    }

}

if ( trait_exists( 'World' ) ) {

    class Hello {
        use World;

        public function text( $str )
        {
            return $this->tmp.$str;
        }
    }

}

echo Hello::World()->text('!!!'); // Hello World!!!

2019/01/29

類/物件函式 No.2

get_class_methods — 返回由類的方法名組成的陣列

// 說明：get_class_methods ( mixed $class_name ) : array

class myclass {
    // constructor
    function myclass()
    {
        return(true);
    }

    // method 1
    function myfunc1()
    {
        return(true);
    }

    // method 2
    function myfunc2()
    {
        return(true);
    }
}

$class_methods = get_class_methods('myclass');
// or
$class_methods = get_class_methods(new myclass());

foreach ($class_methods as $method_name) {
    echo "$method_name\n";
}

// 輸出：myclass、myfunc1、myfunc2

get_class — 返回物件的類名

// 說明：get_class ([ object $object = NULL ] ) : string

class foo {
    function name()
    {
        echo "My name is " , get_class($this) , "\n";
    }
}

// create an object
$bar = new foo();

// external call
echo "Its name is " , get_class($bar) , "\n"; // 輸出：Its name is foo

// internal call
$bar->name(); // 輸出：My name is foo

get_class_vars — 返回由類的預設屬性組成的陣列

// 說明：get_class_vars ( string $class_name ) : array

class myclass {

    var $var1; // this has no default value...
    var $var2 = "xyz";
    var $var3 = 100;
    private $var4;

    // constructor
    function __construct() {
        // change some properties
        $this->var1 = "foo";
        $this->var2 = "bar";
        return true;
    }

}

$my_class = new myclass();

$class_vars = get_class_vars(get_class($my_class));

foreach ($class_vars as $name => $value) {
    echo "$name : $value\n";
}

// 輸出：var1 : 、var2 : xyz、var3 : 100

get_parent_class — 返回物件或類的父類名

// 說明：get_parent_class ([ mixed $obj ] ) : string

class dad {
    function dad()
    {
    // implements some logic
    }
}

class child extends dad {
    function child()
    {
        echo "I'm " , get_parent_class($this) , "'s son\n";
    }
}

class child2 extends dad {
    function child2()
    {
        echo "I'm " , get_parent_class('child2') , "'s son too\n";
    }
}

$foo = new child(); // 輸出：I'm dad's son
$bar = new child2(); // 輸出：I'm dad's son too

interface_exists — 檢查介面是否已被定義

// 說明：interface_exists ( string $interface_name [, bool $autoload = true ] ) : bool

// 在嘗試使用前先檢查介面是否存在
if (interface_exists('MyInterface')) {
    class MyClass implements MyInterface
    {
        // Methods
    }
}

2019/01/28

類/物件函式 No.1

__autoload — 嘗試載入未定義的類

// 說明：__autoload ( string $class ) : void

// index.php
function __autoload($class) {
    $file = $class . '.php';
    require_once $file;
}

$test = new test();

// test.php
class test {
  public function __construct() {
     echo "this is test";
  }
}

// 當在 index.php 中初始化 test 時，因為找不到對應類，就會呼叫 __autoload() 引入對應檔案。

spl_autoload_register — 註冊給定的函式作為 __autoload 的實現

// 說明：spl_autoload_register ([ callable $autoload_function [, bool $throw = true [, bool $prepend = false ]]] ) : bool
// 因為 __autoload() 在一個程式中只能定義它一次。當我們在進行專案合併的時候，如果出現多個 autoload() 需要將其合併為一個函式。那麼，出現了 spl_autoload_register()。

// index.php
function autoload_test($class) {
    $file = $class . '.php';
    require_once $file;
}
spl_autoload_register("autoload_test");
$test = new test();

// test.php
class test {
  public function __construct() {
     echo "this is test";
  }
}

// 使用此函式可以生成一個__autoload()佇列，可以註冊多個函式。

// index.php
function autoload_test($class) {
    $file = $class . '.php';
    require_once $file;
}

function autoload_vos($class) {
    $file = $class . '.php';
    require_once $file;
}

spl_autoload_register("autoload_test");
spl_autoload_register("autoload_vos");

$test = new test();

class_alias — 為一個類建立別名

// 說明：class_alias ( string $original , string $alias [, bool $autoload = TRUE ] ) : bool

class foo { }

class_alias('foo', 'bar');

$a = new foo;
$b = new bar;

// the objects are the same
var_dump($a == $b, $a === $b); // 輸出：bool(true)
var_dump($a instanceof $b); // 輸出：bool(false)

// the classes are the same
var_dump($a instanceof foo); // 輸出：bool(true)
var_dump($a instanceof bar); // 輸出：bool(true)

var_dump($b instanceof foo); // 輸出：bool(true)
var_dump($b instanceof bar); // 輸出：bool(true)

class_exists — 檢查類是否已定義

// 說明：class_exists ( string $class_name [, bool $autoload = true ] ) : bool

if (class_exists('MyClass')) {
    $myclass = new MyClass();
}

get_called_class — 後期靜態繫結（"Late Static Binding"）類的名稱

// 說明：get_called_class ( void ) : string

class foo {
    static public function test() {
        var_dump(get_called_class());
    }
}

class bar extends foo {
}

foo::test(); // 輸出：string(3) "foo"
bar::test(); // 輸出：string(3) "bar"

2019/01/27

Math 函式 No.2

max — 找出最大值

// 說明：max ( array $values ) : mixed、max ( mixed $value1 , mixed $value2 [, mixed $... ] ) : mixed
// 如果僅有一個引數且為陣列，max() 返回該陣列中最大的值。如果第一個引數是整數、字串或浮點數，則至少需要兩個引數而 max() 會返回這些值中最大的一個。可以比較無限多個值。

echo max(1, 3, 5, 6, 7);  // 7
echo max(array(2, 4, 5)); // 5

// 當 hello 被轉換為整數時轉化為了 0 ，兩個值相等
echo max(0, 'hello');     // 0

// hello 的長度要比 0 長，所以輸出 hello
echo max('hello', 0);     // hello

echo max('42', 3); // '42'

// 這裡 0 > -1, 所以返回 hello
echo max(-1, 'hello');    // hello

// 多個陣列長度不同時，返回長度長的
$val = max(array(2, 2, 2), array(1, 1, 1, 1)); // array(1, 1, 1, 1)

// 對多個陣列，max 從左向右比較。
// 因此在本例中：2 == 2，但 4 < 5
$val = max(array(2, 4, 8), array(2, 5, 7)); // array(2, 5, 7)

// 如果同時給出陣列和非陣列作為引數，則總是將陣列視為
// 最大值返回
$val = max('string', array(2, 5, 7), 42);   // array(2, 5, 7)

min — 找出最小值

// 說明：min ( array $values ) : mixed、min ( mixed $value1 , mixed $value2 [, mixed $... ] ) : mixed
// 如果僅有一個引數且為陣列，min() 返回該陣列中最小的值。如果給出了兩個或更多引數, min() 會返回這些值中最小的一個。

echo min(2, 3, 1, 6, 7);  // 1
echo min(array(2, 4, 5)); // 2

echo min(0, 'hello');     // 0
echo min('hello', 0);     // hello
echo min('hello', -1);    // -1

// 對多個陣列，min 從左向右比較。
// 因此在本例中：2 == 2，但 4 < 5
$val = min(array(2, 4, 8), array(2, 5, 1)); // array(2, 4, 8)

// 如果同時給出陣列和非陣列作為引數，則不可能返回陣列，因為
// 陣列被視為最大的
$val = min('string', array(2, 5, 7), 42);   // string

mt_rand — 生成更好的隨機數

// 說明：mt_rand ( void ) : int、mt_rand ( int $min , int $max ) : int
// 很多老的 libc 的隨機數發生器具有一些不確定和未知的特性而且很慢。PHP 的 rand() 函式預設使用 libc 隨機數發生器。mt_rand() 函式是非正式用來替換它的。該函式用了 » Mersenne Twister 中已知的特性作為隨機數發生器，它可以產生隨機數值的平均速度比 libc 提供的 rand() 快四倍。

echo mt_rand() . "\n"; // 輸出：1604716014
echo mt_rand() . "\n"; // 輸出：1478613278

echo mt_rand(5, 15); // 輸出：6

mt_getrandmax — 顯示隨機數的最大可能值

// 說明：mt_getrandmax ( void ) : int
// 返回撥用 mt_rand() 所能返回的最大的隨機數。

function randomFloat($min = 0, $max = 1) {
    return $min + mt_rand() / mt_getrandmax() * ($max - $min);
}

var_dump(randomFloat());  // 輸出：float(0.91601131712832)
var_dump(randomFloat(2, 20)); // 輸出：float(16.511210331931)

round — 對浮點數進行四捨五入

// 說明：round ( float $val [, int $precision = 0 [, int $mode = PHP_ROUND_HALF_UP ]] ) : float

echo round(3.4);         // 3
echo round(3.5);         // 4
echo round(3.6);         // 4
echo round(3.6, 0);      // 4
echo round(1.95583, 2);  // 1.96
echo round(1241757, -3); // 1242000
echo round(5.045, 2);    // 5.05
echo round(5.055, 2);    // 5.06

2019/01/26

Math 函式 No.1

ceil — 進一法取整

// 說明：ceil ( float $value ) : float
// 返回不小於 value 的下一個整數，value 如果有小數部分則進一位

echo ceil(4.3);    // 5
echo ceil(9.999);  // 10
echo ceil(-3.14);  // -3

exp — 計算 e 的指數

// 說明：exp ( float $arg ) : float
// 返回 e 的 arg 次方值，用 'e' 作為自然對數的底 2.718282.

echo exp(12) . "\n"; //輸出：1.6275E+005
echo exp(5.7); // 輸出：298.87

floor — 捨去法取整

// 說明：floor ( float $value ) : float
// 返回不大於 value 的最接近的整數，捨去小數部分取整。

echo floor(4.3);   // 4
echo floor(9.999); // 9
echo floor(-3.14); // -4

fmod — 返回除法的浮點數餘數

// 說明：fmod ( float $x , float $y ) : float
// 返回被除數（x）除以除數（y）所得的浮點數餘數。餘數（r）的定義是：x = i * y + r，其中 i 是整數。如果 y 是非零值，則 r 和 x 的符號相同並且其數量值小於 y。

$x = 5.7;
$y = 1.3;
$r = fmod($x, $y);

echo $r; // 輸出：0.5     (4 * 1.3 + 0.5 = 5.7)

getrandmax — 顯示隨機數最大的可能值

// 說明：getrandmax ( void ) : int
// 返回撥用 rand() 可能返回的最大值。

echo(getrandmax());  // 輸出：2147483647

2019/01/25

函式處理函式

func_num_args — 返回傳遞給函式的引數個數

// 說明：func_num_args ( void ) : int

function foo()
{
    $numargs = func_num_args();
    echo "Number of arguments: $numargs\n";
}

foo(1, 2, 3);   // 輸出：Number of arguments: 3

func_get_arg — 返回引數列表的某一項

// 說明：func_get_arg ( int $arg_num ) : mixed
// arg_num：引數的偏移量。函式的引數是從0開始計數的。

function foo()
{
     $numargs = func_num_args();

     echo "Number of arguments: $numargs\n";

     if ($numargs >= 2) {
         echo "Second argument is: " . func_get_arg(1) . "\n";
     }
}

foo (1, 2, 3); 
// 輸出：
// Number of arguments: 3
// Second argument is: 2

func_get_args — 返回一個包含函式引數列表的陣列

// 說明：func_get_args ( void ) : array

function foo()
{
    $numargs = func_num_args();
    echo "Number of arguments: $numargs<br />\n";
    if ($numargs >= 2) {
        echo "Second argument is: " . func_get_arg(1) . "<br />\n";
    }
    $arg_list = func_get_args();
    for ($i = 0; $i < $numargs; $i++) {
        echo "Argument $i is: " . $arg_list[$i] . "<br />\n";
    }
}

foo(1, 2, 3); 
// 輸出：
// Number of arguments: 3<br />
// Second argument is: 2<br />
// Argument 0 is: 1<br />
// Argument 1 is: 2<br />
// Argument 2 is: 3<br />

function_exists — 如果給定的函式已經被定義就返回 TRUE

// 說明：function_exists ( string $function_name ) : bool

if (function_exists('imap_open')) {
    echo "IMAP functions are available.<br />\n";
} else {
    echo "IMAP functions are not available.<br />\n";
}

// 輸出：IMAP functions are not available.<br />

get_defined_functions — 返回所有已定義函式的陣列

// 說明：get_defined_functions ([ bool $exclude_disabled = FALSE ] ) : array
// exclude_disabled：禁用的函式是否應該在返回的資料裡排除

function myrow($id, $data)
{
    return "<tr><th>$id</th><td>$data</td></tr>\n";
}

$arr = get_defined_functions();

print_r($arr);

// 輸出：
Array
(
    [internal] => Array
        (
            [0] => zend_version
            [1] => func_num_args
            [2] => func_get_arg
            [3] => func_get_args
            [4] => strlen
            [5] => strcmp
            [6] => strncmp
            ...
            [750] => bcscale
            [751] => bccomp
        )

    [user] => Array
        (
            [0] => myrow
        )

)

2019/01/24

函式處理函式

call_user_func_array — 呼叫回撥函式，並把一個陣列引數作為回撥函式的引數

// 說明：call_user_func_array ( callable $callback , array $param_arr ) : mixed

function foobar($arg, $arg2) {
    echo __FUNCTION__, " got $arg and $arg2\n";
}

class foo {
    function bar($arg, $arg2) {
        echo __METHOD__, " got $arg and $arg2\n";
    }
}

// Call the foobar() function with 2 arguments
call_user_func_array("foobar", array("one", "two")); // 輸出：foobar got one and two

// Call the $foo->bar() method with 2 arguments
$foo = new foo;
call_user_func_array(array($foo, "bar"), array("three", "four")); // 輸出：foo::bar got three and four

call_user_func — 把第一個引數作為回撥函式呼叫

// 說明：call_user_func ( callable $callback [, mixed $parameter [, mixed $... ]] ) : mixed

function barber($type)
{
    echo "You wanted a $type haircut, no problem\n";
}

call_user_func('barber', "mushroom"); // 輸出：You wanted a mushroom haircut, no problem
call_user_func('barber', "shave"); // 輸出：You wanted a shave haircut, no problem

create_function — 建立一個匿名函式

// 說明：create_function ( string $args , string $code ) : string

// log()：返回自然對數
$newfunc = create_function('$a,$b', 'return "ln($a) + ln($b) = " . log($a * $b);');

echo "New anonymous function: $newfunc\n";

// M_E：常量值：2.7182818284590452354
echo $newfunc(2, M_E) . "\n";

// 輸出：
// New anonymous function: lambda_1
// ln(2) + ln(2.718281828459) = 1.6931471805599

forward_static_call_array — 呼叫靜態方法並將引數作為陣列傳遞

// 說明：forward_static_call_array ( callable $function , array $parameters ) : mixed

class A
{
    const NAME = 'A';
    public static function test() {
        $args = func_get_args();
        echo static::NAME, " ".join(',', $args)." \n";
    }
}

class B extends A
{
    const NAME = 'B';

    public static function test() {
        echo self::NAME, "\n";
        forward_static_call_array(array('A', 'test'), array('more', 'args'));
        forward_static_call_array( 'test', array('other', 'args'));
    }
}

B::test('foo');

// join：implode 的別名
function test() {
        $args = func_get_args();
        echo "C ".join(',', $args)." \n";
}

// 輸出：
// B
// B more,args 
// C other,args

forward_static_call — 呼叫靜態方法

// 說明：forward_static_call ( callable $function [, mixed $parameter [, mixed $... ]] ) : mixed

class A
{
    const NAME = 'A';
    public static function test() {
        $args = func_get_args();
        echo static::NAME, " ".join(',', $args)." \n";
    }
}

class B extends A
{
    const NAME = 'B';

    public static function test() {
        echo self::NAME, "\n";

        forward_static_call(array('A', 'test'), 'more', 'args');
        forward_static_call( 'test', 'other', 'args');
    }
}

B::test('foo');

function test() {
        $args = func_get_args();

        echo "C ".join(',', $args)." \n";
}

// 輸出：
// B
// B more,args 
// C other,args

2019/01/23

字串相關函式 No.2

sscanf — 根據指定格式解析輸入的字元

// 說明：sscanf ( string $str , string $format [, mixed &$... ] ) : mixed

// getting the serial number
list($serial) = sscanf("SN/2350001", "SN/%d");

// and the date of manufacturing
$mandate = "January 01 2000";

list($month, $day, $year) = sscanf($mandate, "%s %d %d");

echo "Item $serial was manufactured on: $year-" . substr($month, 0, 3) . "-$day\n";
// 輸出：Item 2350001 was manufactured on: 2000-Jan-1

strlen — 獲取字串長度

// 說明：strlen ( string $string ) : int

$str = 'abcdef';
echo strlen($str); // 6

$str = ' ab cd ';
echo strlen($str); // 7

strpbrk — 在字串中查詢一組字元的任何一個字元

// 說明：strpbrk ( string $haystack , string $char_list ) : string

$text = 'This is a Simple text.';

// 輸出 "is is a Simple text."，因為 'i' 先被匹配
echo strpbrk($text, 'mi');

// 輸出 "Simple text."，因為字元區分大小寫
echo strpbrk($text, 'S');

preg_match — 執行匹配正規表示式

// 說明：preg_match ( string $pattern , string $subject [, array &$matches [, int $flags = 0 [, int $offset = 0 ]]] ) : int

// 從URL中獲取主機名稱
preg_match('@^(?:http://)?([^/]+)@i',
    "http://www.runoob.com/index.html", $matches);
$host = $matches[1];

// 獲取主機名稱的後面兩部分
preg_match('/[^.]+\.[^.]+$/', $host, $matches);
echo "domain name is: {$matches[0]}\n";

// 輸出：domain name is: runoob.com

wordwrap — 打斷字串為指定數量的字串

// 說明：wordwrap ( string $str [, int $width = 75 [, string $break = "\n" [, bool $cut = FALSE ]]] ) : string

$text = "The quick brown fox jumped over the lazy dog.";
$newtext = wordwrap($text, 20, "、");

echo $newtext; 
// 輸出：The quick brown fox、jumped over the lazy、dog.

2019/01/22

字串相關函式 No.1

sprintf — 返回格式化的字串

// 說明：sprintf ( string $format [, mixed $... ] ) : string

// string - s
// integer - d, u, c, o, x, X, b
// double - g, G, e, E, f, F

$num = 5;
$location = 'tree';

$format = 'There are %d monkeys in the %s';

echo sprintf($format, $num, $location); // 輸出："There are 5 monkeys in the tree"

// 指定順序
$format = 'The %2$s contains %1$d monkeys';

echo sprintf($format, $num, $location);// 輸出："The tree contains 5 monkeys"

ltrim — 刪除字串開頭的空白字元（或其他字元）

// 說明：ltrim ( string $str [, string $character_mask ] ) : string

$text = "\t\tThese are a few words :) ...  ";
$binary = "\x09Example string\x0A";
$hello  = "Hello World";

$trimmed = ltrim($text);
echo $trimmed; // 輸出："These are a few words :) ...  "

$trimmed = ltrim($text, " \t.");
var_dump($trimmed);// 輸出："These are a few words :) ...  "

$trimmed = ltrim($hello, "Hdle");
var_dump($trimmed);// 輸出："o World"

// 刪除 $binary 開頭的 ASCII 控制字元
// (從 0 到 31，包括 0 和 31)
$clean = ltrim($binary, "\x00..\x1F");
var_dump($clean);// 輸出："These are a few words :) ...  "

// trim、ltrim、rtrim 都是類似的：左右都過濾、左過濾、右過濾

strtolower — 將字串轉化為小寫

// 說明：strtolower ( string $string ) : string

$str = "Mary Had A Little Lamb and She LOVED It So";
$str = strtolower($str);

echo $str; // 列印 mary had a little lamb and she loved it so

strtoupper — 將字串轉化為大寫

// 說明：strtoupper ( string $string ) : string

$str = "Mary Had A Little Lamb and She LOVED It So";
$str = strtoupper($str);

echo $str; // 列印 MARY HAD A LITTLE LAMB AND SHE LOVED IT SO

strtok — 標記分割字串

// 說明：strtok ( string $str , string $token ) : string 、strtok ( string $token ) : string

$string = "This is\tan example\nstring";

// 注意僅第一次呼叫 strtok 函式時使用 string 引數。後來每次呼叫 strtok，都將只使用 token 引數，因為它會記住它在字串 string 中的位置。如果要重新開始分割一個新的字串，你需要再次使用 string 來呼叫 strtok 函式，以便完成初始化工作。注意可以在 token 引數中使用多個字元。字串將被該引數中任何一個字元分割。
$tok = strtok($string, " \n\t");

while ($tok !== false) {
    echo "Word=$tok";
    $tok = strtok(" \n\t");
}
// 輸出：Word=This Word=is Word=an Word=example Word=string

$first_token  = strtok('/something', '/');
$second_token = strtok('/');

var_dump($first_token, $second_token); // 輸出：  string(9) "something" 、  bool(false)

2019/01/21

陣列相關函式 No.6

array_key_exists — 檢查陣列裡是否有指定的鍵名或索引

// 說明：array_key_exists ( mixed $key , array $array ) : bool

$search_array = array('first' => 1, 'second' => 4);

if (array_key_exists('first', $search_array)) {
    echo "The 'first' element is in the array";
}

// array_key_exists() 與 isset() 的對比

$search_array = array('first' => null, 'second' => 4);

// returns false
isset($search_array['first']);

// returns true
array_key_exists('first', $search_array);

key — 從關聯陣列中取得鍵名

// 說明：key ( array $array ) : mixed

$array = array(
    'fruit1' => 'apple',
    'fruit2' => 'orange',
    'fruit3' => 'grape',
    'fruit4' => 'apple',
    'fruit5' => 'apple');

// this cycle echoes all associative array
// key where value equals "apple"
while ($fruit_name = current($array)) {
    if ($fruit_name == 'apple') {
        echo key($array);
    }
    next($array);
}

// 輸出：fruit1、fruit4、fruit5

sort — 對陣列排序

// 說明：sort ( array &$array [, int $sort_flags = SORT_REGULAR ] ) : bool

/**
 *  sort_flags：第二個引數介紹
 *  
 *  SORT_REGULAR - 正常比較單元（不改變型別）
 *  SORT_NUMERIC - 單元被作為數字來比較
 *  SORT_STRING - 單元被作為字串來比較
 *  SORT_LOCALE_STRING - 根據當前的區域（locale）設定來把單元當作字串比較，可以用 setlocale() 來改變。
 *  SORT_NATURAL - 和 natsort() 類似對每個單元以“自然的順序”對字串進行排序。 PHP 5.4.0 中新增的。
 *  SORT_NATURAL - 和 natsort() 類似對每個單元以“自然的順序”對字串進行排序。 PHP 5.4.0 中新增的。
 */

$fruits = array("lemon", "orange", "banana", "apple");

sort($fruits);

foreach ($fruits as $key => $val) {
    echo "fruits[" . $key . "] = " . $val . "\n";
}

// 輸出：fruits[0] = apple、fruits[1] = banana、fruits[2] = lemon、fruits[3] = orange

// 帶 sort_flags 引數：

$fruits = array(
    "Orange1", "orange2", "Orange3", "orange20"
);

sort($fruits, SORT_NATURAL | SORT_FLAG_CASE);

foreach ($fruits as $key => $val) {
    echo "fruits[" . $key . "] = " . $val . "\n";
}

// 輸出：fruits[0] = Orange1、fruits[1] = orange2、fruits[2] = Orange3、fruits[3] = orange20

natcasesort — 用“自然排序”演算法對陣列進行不區分大小寫字母的排序

// 說明：natcasesort ( array &$array ) : bool

$array1 = $array2 = array('IMG0.png', 'img12.png', 'img10.png', 'img2.png', 'img1.png', 'IMG3.png');

sort($array1);
print_r($array1); // 輸出：['IMG0.png', 'IMG3.png', 'img1.png', 'img10.png', 'img12.png', 'img2.png']

natcasesort($array2);
print_r($array2); // 輸出：['IMG0.png', 'img1.png', 'img2.png', 'IMG3.png', 'img10.png', 'img12.png']

usort — 使用使用者自定義的比較函式對陣列中的值進行排序

// 說明：usort ( array &$array , callable $value_compare_func ) : bool

function cmp($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

$a = array(3, 2, 5, 6, 1);

usort($a, "cmp");

foreach ($a as $key => $value) {
    echo "$key: $value\n";
}

// 輸出：[1, 2, 3, 5, 6]

2019/01/20

陣列相關函式 No.5

reset — 將陣列的內部指標指向第一個單元

// 說明：reset ( array &$array ) : mixed

$array = array('step one', 'step two', 'step three', 'step four');

// by default, the pointer is on the first element
echo current($array) . "<br />\n"; // "step one"

// skip two steps
next($array);
next($array);
echo current($array) . "<br />\n"; // "step three"

// reset pointer, start again on step one
reset($array);
echo current($array) . "<br />\n"; // "step one"

list — 把陣列中的值賦給一組變數

// 說明：list ( mixed $var1 [, mixed $... ] ) : array

$info = array('coffee', 'brown', 'caffeine');

// 列出所有變數
list($drink, $color, $power) = $info;
echo "$drink is $color and $power makes it special.\n";

// 列出他們的其中一個
list($drink, , $power) = $info;
echo "$drink has $power.\n";

// 或者讓我們跳到僅第三個
list( , , $power) = $info;
echo "I need $power!\n";

// list() 不能對字串起作用
list($bar) = "abcde";
var_dump($bar); // NULL

each — 返回陣列中當前的鍵／值對並將陣列指標向前移動一步

// 說明：each ( array &$array ) : array
// 返回 array 陣列中當前指標位置的鍵／值對並向前移動陣列指標。鍵值對被返回為四個單元的陣列，鍵名為0，1，key和 value。單元 0 和 key 包含有陣列單元的鍵名，1 和 value 包含有資料。

// 如果內部指標越過了陣列的末端，則 each() 返回 FALSE。

$foo = array("bob", "fred", "jussi", "jouni", "egon", "marliese");
$bar = each($foo);

print_r($bar); // [1 => "bob", "value" => "bob", 0 => 0, "key" => 0]

// 我們來看一下 list 與 each 和 reset 的連用
$fruit = array('a' => 'apple', 'b' => 'banana', 'c' => 'cranberry');

reset($fruit);
while (list($key, $val) = each($fruit)) {
    echo "$key => $val\n";
}

// 輸出：["a" => "apple", "b" => "banana", "c" => "cranberry"]

end — 將陣列的內部指標指向最後一個單元

// 說明：end ( array &$array ) : mixed

$fruits = array('apple', 'banana', 'cranberry');

echo end($fruits); // cranberry

extract — 從陣列中將變數匯入到當前的符號表

// 說明：extract ( array &$array [, int $flags = EXTR_OVERWRITE [, string $prefix = NULL ]] ) : int
// 符號表是指當前php頁面中，所有變數名稱的集合

/**
 *  flag：第二個引數介紹
 *  EXTR_OVERWRITE：如果有衝突，覆蓋已有的變數。
 *  EXTR_SKIP：如果有衝突，不覆蓋已有的變數。
 *  EXTR_PREFIX_SAME：如果有衝突，在變數名前加上字首 prefix。
 *  EXTR_PREFIX_ALL：給所有變數名加上字首 prefix。
 *  EXTR_PREFIX_INVALID：僅在非法／數字的變數名前加上字首 prefix。
 *  EXTR_IF_EXISTS：僅在當前符號表中已有同名變數時，覆蓋它們的值。其它的都不處理。 舉個例子，以下情況非常有用：定義一些有效變數，然後從 $_REQUEST 中僅匯入這些已定義的變數。
 *  EXTR_PREFIX_IF_EXISTS：僅在當前符號表中已有同名變數時，建立附加了字首的變數名，其它的都不處理。
 *  EXTR_REFS：將變數作為引用提取。這有力地表明瞭匯入的變數仍然引用了 array 引數的值。可以單獨使用這個標誌或者在 flags 中用 OR 與其它任何標誌結合使用。
 *  
 *  如果沒有指定 flags，則被假定為 EXTR_OVERWRITE。
 */

/* 假定 $var_array 是 wddx_deserialize 返回的陣列*/

$size = "large";
$var_array = array("color" => "blue",
                   "size"  => "medium",
                   "shape" => "sphere");
extract($var_array, EXTR_PREFIX_SAME, "wddx");

echo "$color, $size, $shape, $wddx_size\n"; // 輸出：blue, large, sphere, medium

2019/01/19

陣列相關函式 No.4

array_walk_recursive — 對陣列中的每個成員遞迴地應用使用者函式

// 說明：array_walk_recursive ( array &$array , callable $callback [, mixed $userdata = NULL ] ) : bool

$sweet = array('a' => 'apple', 'b' => 'banana');
$fruits = array('sweet' => $sweet, 'sour' => 'lemon');

function test_print($item, $key)
{
    echo "$key holds $item\n";
}

array_walk_recursive($fruits, 'test_print'); // 輸出："a holds apple"、"b holds banana"、"sour holds lemon"
// 注意上例中的鍵 'sweet' 並沒有顯示出來。任何其值為 array 的鍵都不會被傳遞到回撥函式中去。

arsort — 對陣列進行逆向排序並保持索引關係

// 說明：arsort ( array &$array [, int $sort_flags = SORT_REGULAR ] ) : bool

$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");

arsort($fruits);

foreach ($fruits as $key => $val) {
    echo "$key = $val\n";
}

// 輸出：a = orange ；d = lemon；b = banana；c = apple

asort — 對陣列進行排序並保持索引關係

// 說明：asort ( array &$array [, int $sort_flags = SORT_REGULAR ] ) : bool

$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");

asort($fruits);

foreach ($fruits as $key => $val) {
    echo "$key = $val\n";
}

// 輸出：c = apple；b = banana；d = lemon；a = orange

compact — 建立一個陣列，包括變數名和它們的值

// 說明：compact ( mixed $varname1 [, mixed $... ] ) : array

$city  = "San Francisco";
$state = "CA";
$event = "SIGGRAPH";

$location_vars = array("city", "state");

$result = compact("event", "nothing_here", $location_vars);

print_r($result); // 輸出：["event" => "SIGGRAPH", "city" => "San Francisco", "state" => "CA"]

current — 返回陣列中的當前單元

// 說明：current ( array &$array ) : mixed

$transport = array('foot', 'bike', 'car', 'plane');
$mode = current($transport); // $mode = 'foot';
$mode = next($transport);    // $mode = 'bike';
$mode = current($transport); // $mode = 'bike';
$mode = prev($transport);    // $mode = 'foot';
$mode = end($transport);     // $mode = 'plane';
$mode = current($transport); // $mode = 'plane';

$arr = array();
var_dump(current($arr)); // bool(false)

$arr = array(array());
var_dump(current($arr)); // array(0) { }

2019/01/18

陣列相關函式 No.3

array_combine — 建立一個陣列，用一個陣列的值作為其鍵名，另一個陣列的值作為其值

// 說明：array_combine ( array $keys , array $values ) : array
// 兩個陣列數量如果不一致的情況是會出現警告的噢

$a = array('green', 'red', 'yellow');
$b = array('avocado', 'apple', 'banana');
$c = array_combine($a, $b);

print_r($c); // 輸出：['green' => 'avocado', 'red' => 'apple', 'yellow' => 'banana']

array_count_values — 統計陣列中所有的值

// 說明：array_count_values ( array $array ) : array

$array = array(1, "hello", 1, "world", "hello");

print_r(array_count_values($array)); // 輸出：[1 => 2, "hello" => 2, "world" => 1]

array_diff_assoc — 帶索引檢查計算陣列的差集

// 說明：array_diff_assoc ( array $array1 , array $array2 [, array $... ] ) : array

$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");

$result = array_diff_assoc($array1, $array2);

print_r($result); // 輸出：["b" => "brown", "c" => "blue", 0 => "red"]
// 大家可以發現這裡 red 有輸出，為啥呢，因為第二個陣列中 red 的 key 為 1。與陣列一中的 key 為 0，不一致，所以有輸出。

array_diff_key — 使用鍵名比較計算陣列的差集

// 說明：array_diff_key ( array $array1 , array $array2 [, array $... ] ) : array

$array1 = array('blue'  => 1, 'red'  => 2, 'green'  => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan'   => 8);

var_dump(array_diff_key($array1, $array2)); // 輸出：['red' => 2, 'purple' => 4]

array_diff_uassoc — 用使用者提供的回撥函式做索引檢查來計算陣列的差集

// 說明：array_diff_uassoc ( array $array1 , array $array2 [, array $... ], callable $key_compare_func ) : array

function key_compare_func($a, $b)
{
    if ($a === $b) {
        return 0;
    }
    return ($a > $b)? 1:-1;
}

$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");

$result = array_diff_uassoc($array1, $array2, "key_compare_func");

print_r($result); // 輸出：["b" => "brown", "c" => "blue", 0 => "red"]
// 這個回掉函式有點沒看明白啊 。。。。

2019/01/17

陣列相關函式 No.2

array_filter — 用回撥函式過濾陣列中的單元

// 說明：array_filter ( array $array [, callable $callback [, int $flag = 0 ]] ) : array
// 如果沒有傳遞迴掉函式，就起到過濾陣列中空值的方法了

function odd($var)
{
    // & 按位與
    return($var & 1);
}

function even($var)
{
    // returns whether the input integer is even
    return(!($var & 1));
}

$array1 = array("a" => 1, "b" => 2, "c" => 3, "d" => 4, "e" => 5);
$array2 = array(6, 7, 8, 9, 10, 11, 12);

print_r(array_filter($array1, "odd")); // 輸出：["a" => 1, "c" => 3, "e" => 5]
print_r(array_filter($array2, "even")); // 輸出：[6, 8, 10, 12]

array_unshift — 在陣列開頭插入一個或多個單元

// 說明：array_unshift ( array &$array [, mixed $... ] ) : int

$queue = array("orange", "banana");
array_unshift($queue, "apple", "raspberry");

print_r($queue); // 輸出：["apple", "raspberry", "orange", "banana"]

array_shift — 將陣列開頭的單元移出陣列

// 說明：array_shift ( array &$array ) : mixed

$stack = array("orange", "banana", "apple", "raspberry");
$fruit = array_shift($stack);

print_r($stack); // 輸出：["banana", "apple", "raspberry"]

array_pop — 彈出陣列最後一個單元（出棧）

// 說明：array_pop ( array &$array ) : mixed

$stack = array("orange", "banana", "apple", "raspberry");
$fruit = array_pop($stack);

print_r($stack); // 輸出：["orange", "banana", "apple"]

array_push — 將一個或多個單元壓入陣列的末尾（入棧）

// 說明：array_push ( array &$array , mixed $value1 [, mixed $... ] ) : int

$stack = array("orange", "banana");
array_push($stack, "apple", "raspberry");

print_r($stack); // 輸出：["orange", "banana", "apple", "raspberry"]

2019/01/16

陣列相關函式 No.1

array_fill — 用給定的值填充陣列

// 說明：array_fill ( int $start_index , int $num , mixed $value ) : array
// 如果 start_index 是負數， 那麼返回的陣列的第一個索引將會是 start_index ，而後面索引則從0開始

$a = array_fill(6, 6, 'banana');
$b = array_fill(-2, 4, 'pear');

print_r($a); // 輸出：[6 => 'banana', 7 => 'banana', 8 => 'banana', 9 => 'banana', 10 => 'banana']
print_r($b); // 輸出：[-2 => 'pear', 0 => 'pear', 1 => 'pear', 2 => 'pear']

array_chunk — 將一個陣列分割成多個

// 說明：array_chunk ( array $array , int $size [, bool $preserve_keys = false ] ) : array
// 第三個引數如果設為 TRUE，可以使 PHP 保留輸入陣列中原來的鍵名

$input_array = array('a', 'b', 'c', 'd', 'e');

print_r(array_chunk($input_array, 2)); // 輸出：[['a','b'],['c','d'],['e']]
print_r(array_chunk($input_array, 2, true)); // 輸出：[[1 => 'a',3 => 'b'],[5 => 'c',7 => 'd'],[9 => 'e']]

array_slice — 從陣列中取出一段

// 說明：array_slice ( array $array , int $offset [, int $length = NULL [, bool $preserve_keys = false ]] ) : array
// 第二個引數如果為負，則序列將從 array 中距離末端這麼遠的地方開始
// 第三個引數如果設為 TRUE，可以使 PHP 保留輸入陣列中原來的鍵名

$input = array("a", "b", "c", "d", "e");

$output = array_slice($input, 2);      // [ "c", "d", "e"]
$output = array_slice($input, -2, 1);  // ["d"]
$output = array_slice($input, 0, 3);   // ["a", "b", "c"]

// note the differences in the array keys
print_r(array_slice($input, 2, -1)); // 輸出：["c", "d"]
print_r(array_slice($input, 2, -2, true)); // 輸出：[2 => "c"]

array_diff — 計算陣列的差集

// 說明：array_diff ( array $array1 , array $array2 [, array $... ] ) : array

$array1 = array("a" => "green", "red", "blue", "red");
$array2 = array("b" => "green", "yellow", "red");
$result = array_diff($array1, $array2);

print_r($result); // 輸出：[1 => "blue"]

array_intersect — 計算陣列的交集

// 說明：array_intersect ( array $array1 , array $array2 [, array $... ] ) : array

$array1 = array("a" => "green", "red", "blue");
$array2 = array("b" => "green", "yellow", "red");
$result = array_intersect($array1, $array2);

print_r($result); // 輸出：["a" => "green", "red"]

2019/01/15

strip_tags — 從字串中去除 HTML 和 PHP 標記

// 說明：strip_tags ( string $str [, string $allowable_tags ] ) : string

$text = '<p>Test paragraph.</p><!-- Comment --> <a href="#fragment">Other text</a>';
echo strip_tags($text); // 輸出：Test paragraph. Other text

// 允許 <p> 和 <a>
echo strip_tags($text, '<p><a>'); // 輸出：<p>Test paragraph.</p> <a href="#fragment">Other text</a>

explode — 使用一個字串分割另一個字串

// 說明：explode ( string $delimiter , string $string [, int $limit ] ) : array

// 示例 1
$pizza  = "piece1 piece2 piece3 piece4 piece5 piece6";
$pieces = explode(" ", $pizza);

echo $pieces[0]; // 輸出：piece1
echo $pieces[1]; // 輸出：piece2

// 示例 2
$data = "foo:*:1023:1000::/home/foo:/bin/sh";
list($user, $pass, $uid, $gid, $gecos, $home, $shell) = explode(":", $data);

echo $user; // 輸出：foo
echo $pass; // 輸出：*

implode — 將一個一維陣列的值轉化為字串

// 說明：implode ( string $glue , array $pieces ) : string

$array = array('lastname', 'email', 'phone');
$comma_separated = implode(", ", $array);

echo $comma_separated; // 輸出：lastname, email, phone

// Empty string when using an empty array:
var_dump(implode('hello', array())); // 輸出：string(0) ""

substr — 返回字串的子串

// 說明：substr ( string $string , int $start [, int $length ] ) : string

$rest = substr("abcdef", -1);    // 返回 "f"
$rest = substr("abcdef", -2);    // 返回 "ef"
$rest = substr("abcdef", -3, 1); // 返回 "d"

str_word_count — 返回字串中單詞的使用情況

// 說明：str_word_count ( string $string [, int $format = 0 [, string $charlist ]] ) : mixed

/**
 * format -> 指定函式的返回值，當前支援的值如下：
 * 
 * 0 - 返回單詞數量
 * 1 - 返回一個包含 string 中全部單詞的陣列
 * 2 - 返回關聯陣列。陣列的鍵是單詞在 string 中出現的數值位置，陣列的值是這個單詞
 * 
 * charlist -> 附加的字串列表，其中的字元將被視為單詞的一部分
 */

$str = "Hello fri3nd, you're  looking good today!";

print_r(str_word_count($str, 1)); // 輸出：["Hello", "fri", "nd", "you're", "looking", "good", "today"]
print_r(str_word_count($str, 2)); // 輸出：["Hello", "fri", "nd", "you're", "looking", "good", "today"]
print_r(str_word_count($str, 1, '3')); // 輸出：[''Hello", "fri3nd", "you're", "looking", "good", "today"]

echo str_word_count($str); // 輸出：7

2019/01/14

abs — 絕對值

// 說明：abs ( mixed $number ) : number

$abs = abs(-4.2); // $abs = 4.2; (double/float)
$abs2 = abs(5);   // $abs2 = 5; (integer)
$abs3 = abs(-5);  // $abs3 = 5; (integer)

str_pad — 使用另一個字串填充字串為指定長度

// 說明：str_pad ( string $input , int $pad_length [, string $pad_string = " " [, int $pad_type = STR_PAD_RIGHT ]] ) : string

$input = "Alien";

echo str_pad($input, 10);                      // 輸出 "Alien     "
echo str_pad($input, 10, "-=", STR_PAD_LEFT);  // 輸出 "-=-=-Alien"
echo str_pad($input, 10, "_", STR_PAD_BOTH);   // 輸出 "__Alien___"
echo str_pad($input,  6, "___");               // 輸出 "Alien_"
echo str_pad($input,  3, "*");                 // 輸出 "Alien"

str_repeat — 重複一個字串

// 說明：str_repeat ( string $input , int $multiplier ) : string

echo str_repeat("-=", 10); // 輸出 "-=-=-=-=-=-=-=-=-=-="

str_split — 將字串轉換為陣列

// 說明：str_split ( string $string [, int $split_length = 1 ] ) : array

$str = "Hello";

$arr1 = str_split($str);
$arr2 = str_split($str, 3);

print_r($arr1); // 輸出：["H", "e", "l", "l", "o"]
print_r($arr2); // 輸出：["Hel", "lo"]

strrev — 反轉字串

// 說明：strrev ( string $string ) : string

echo strrev("Hello world!"); // 輸出 "!dlrow olleH"

2019/01/13

is_numeric — 檢測變數是否為數字或數字字串

// 說明：is_numeric ( mixed $var ) : bool

array_column — 返回陣列中指定的一列

// 說明：array_column ( array $input , mixed $column_key [, mixed $index_key = null ] ) : array

$records = array(
    array(
        'id' => 2135,
        'first_name' => 'John',
        'last_name' => 'Doe',
    ),
    array(
        'id' => 3245,
        'first_name' => 'Sally',
        'last_name' => 'Smith',
    ),
    array(
        'id' => 5342,
        'first_name' => 'Jane',
        'last_name' => 'Jones',
    ),
    array(
        'id' => 5623,
        'first_name' => 'Peter',
        'last_name' => 'Doe',
    )
);

$first_names = array_column($records, 'first_name');
print_r($first_names);

// 輸出：
Array
(
    [0] => John
    [1] => Sally
    [2] => Jane
    [3] => Peter
)

$last_names = array_column($records, 'last_name', 'id');
print_r($last_names);

// 輸出：
Array
(
    [2135] => Doe
    [3245] => Smith
    [5342] => Jones
    [5623] => Doe
)

array_search — 在陣列中搜尋給定的值，如果成功則返回首個相應的鍵名

// 說明：array_search ( mixed $needle , array $haystack [, bool $strict = false ] ) : mixed
// 如果可選的第三個引數 strict 為 TRUE，則 array_search() 將在 haystack 中檢查完全相同的元素。 這意味著同樣嚴格比較 haystack 裡 needle 的 型別，並且物件需是同一個例項。

$array = array(0 => 'blue', 1 => 'red', 2 => 'green', 3 => 'red');

$key = array_search('green', $array); // $key = 2;
$key = array_search('red', $array);   // $key = 1;
$key = array_search('white', $array);   // $key = false;

in_array — 檢查陣列中是否存在某個值

// 說明：in_array ( mixed $needle , array $haystack [, bool $strict = FALSE ] ) : bool

$os = array("Mac", "NT", "Irix", "Linux");
if (in_array("Irix", $os)) {
    echo "Got Irix";
}

if (in_array("mac", $os)) {
    echo "Got mac";
}

// 輸出： Got Irix （in_array 區分大小寫）

array_unique — 移除陣列中重複的值

// 說明：array_unique ( array $array [, int $sort_flags = SORT_STRING ] ) : array

$input = array("a" => "green", "red", "b" => "green", "blue", "red");
$result = array_unique($input);

print_r($result);

// 輸出：
Array
(
    [a] => green
    [0] => red
    [1] => blue
)

file

2019/01/12

array_keys — 返回陣列中部分的或所有的鍵名

// 說明：array_keys ( array $array [, mixed $search_value = null [, bool $strict = false ]] ) : array

$array = array(0 => 100, "color" => "red");
print_r(array_keys($array));

$array = array("blue", "red", "green", "blue", "blue");
print_r(array_keys($array, "blue"));

$array = array("color" => array("blue", "red", "green"),
               "size"  => array("small", "medium", "large"));
print_r(array_keys($array));

//  輸出：
Array
(
    [0] => 0
    [1] => color
)
Array
(
    [0] => 0
    [1] => 3
    [2] => 4
)
Array
(
    [0] => color
    [1] => size
)

array_values — 返回陣列中所有的值

// 說明：array_values ( array $array ) : array

$array = array("size" => "XL", "color" => "gold");
print_r(array_values($array));

// 輸出：
Array
(
    [0] => XL
    [1] => gold
)

array_merge — 合併一個或多個陣列

// 說明：array_merge ( array $array1 [, array $... ] ) : array
// 如果陣列中有相同的字串鍵名，則該鍵名後面的值覆蓋前面的值；如果想讓前面的值覆蓋後面，則可以使用 + 號。

$array1 = array("color" => "red", 2, 4);
$array2 = array("a", "b", "color" => "green", "shape" => "trapezoid", 4);

$result = array_merge($array1, $array2);
print_r($result);

// 輸出：
Array
(
    [color] => green
    [0] => 2
    [1] => 4
    [2] => a
    [3] => b
    [shape] => trapezoid
    [4] => 4
)

str_shuffle — 隨機打亂一個字串

// 說明：str_shuffle ( string $str ) : string

$str = 'abcdef';
$shuffled = str_shuffle($str);

echo $shuffled; // 輸出：bfdaec

shuffle — 打亂陣列

// 說明：shuffle ( array &$array ) : bool

$numbers = range(1, 20);

shuffle($numbers);

foreach ($numbers as $number) {
    echo "$number ";
}

// 輸出：7 8 11 1 17 3 14 2 16 15 5 9 4 18 12 20 13 10 19 6

2019/01/11

iconv — 字串按要求的字元編碼來轉換

// 說明：iconv ( string $in_charset , string $out_charset , string $str ) : string
// 將字串 str 從 in_charset 轉換編碼到 out_charset。

$text = "This is the Euro symbol '€'.";

echo 'Original : ', $text, PHP_EOL; // 輸出：Original : This is the Euro symbol '€'.

echo 'TRANSLIT : ', iconv("UTF-8", "ISO-8859-1//TRANSLIT", $text), PHP_EOL; // 輸出：TRANSLIT : This is the Euro symbol 'EUR'.

echo 'IGNORE   : ', iconv("UTF-8", "ISO-8859-1//IGNORE", $text), PHP_EOL; // 輸出：IGNORE   : This is the Euro symbol ''.

echo 'Plain    : ', iconv("UTF-8", "ISO-8859-1", $text), PHP_EOL; // 輸出：Plain    :
Notice: iconv(): Detected an illegal character in input string in .\iconv-example.php on line 7

uniqid — 生成一個唯一ID

// 說明：uniqid ([ string $prefix = "" [, bool $more_entropy = false ]] ) : string
// 獲取一個帶字首、基於當前時間微秒數的唯一ID。

printf("uniqid(): %s\r\n", uniqid()); // 輸出：uniqid(): 5c66c6e20fb7f

printf("uniqid('php_'): %s\r\n", uniqid('php_')); // 輸出：uniqid('php_'): php_5c66c6e20fbde

printf("uniqid('', true): %s\r\n", uniqid('', true)); // 輸出：uniqid('', true): 5c66c6e20fbe59.21437161

gettype — 獲取變數的型別

Warning! 不要使用 gettype() 來測試某種型別，因為其返回的字串在未來的版本中可能需要改變。此外，由於包含了字串的比較，它的執行也是較慢的。

settype — 設定變數的型別

// 說明：settype ( mixed &$var , string $type ) : bool
// 將變數 var 的型別設定成 type。

$foo = "5bar"; // string
$bar = true;   // boolean

settype($foo, "integer"); // $foo 現在是 5   (integer)
settype($bar, "string");  // $bar 現在是 "1" (string)

getcwd — 取得當前工作目錄

// 說明：getcwd ( void ) : string
// 取得當前工作目錄

echo getcwd() . "\n"; //  輸出類似：/home/didou

chdir('cvs');

echo getcwd() . "\n"; //  輸出類似：/home/didou/cvs

2019/01/10

strpos — 查詢字串首次出現的位置

// 說明：strpos ( string $haystack , mixed $needle [, int $offset = 0 ] ) : int

echo strpos("I love php, I love php too!","php"); // 輸出：7

stripos — 查詢字串首次出現的位置（不區分大小寫）

// 說明：stripos ( string $haystack , string $needle [, int $offset = 0 ] ) : int

echo strpos("I love pHp, I love php too!","php"); // 輸出：19
echo stripos("I love pHp, I love php too!","php"); // 輸出：7

strrpos — 計算指定字串在目標字串中最後一次出現的位置

// 說明：strrpos ( string $haystack , string $needle [, int $offset = 0 ] ) : int

$foo = "0123456789a123456789b123456789c";

var_dump(strrpos($foo, '7', -5));  // 從尾部第 5 個位置開始查詢
                                   // 結果: int(17)

var_dump(strrpos($foo, '7', 20));  // 從第 20 個位置開始查詢
                                   // 結果: int(27)

var_dump(strrpos($foo, '7', 28));  // 結果: bool(false)

strrchr — 查詢指定字元在字串中的最後一次出現

說明：strrchr ( string $haystack , mixed $needle ) : string

echo strrchr("Hello world!","world"); // 輸出：world!

strstr — 查詢字串的首次出現

// 說明：strstr ( string $haystack , mixed $needle [, bool $before_needle = FALSE ] ) : string

$email  = 'name@example.com';
$domain = strstr($email, '@');

echo $domain; //  輸出： @example.com

$user = strstr($email, '@', true); // 從 PHP 5.3.0 起
echo $user; //  輸出： name

未完待續

其實我開始寫文章的初心是對自己新學的知識點的一個總結，後面發現還有很多人看的，哈哈，挺開心的，每天上班的第一件事情就是看訊息提醒，看到那麼多的小紅心，別提有多激動了，潛移默化的就促使自己學習更加的有激情，願意寫出更多更好的文章，哈哈。

昨天晚上我在記筆記的時候，偶然想到，為什麼不放出來，讓有需要的人可以一起進步呢，哈哈，就果斷把筆記中記憶 PHP 函式的內容，就放到這裡來了，哈哈。

大家如果有建議的 PHP 函式，可以放到評論區，我來更新學習哈。

finecho # Lhao

每日五個 PHP 函式（2）
2019-02-20
PHP函式
PHP 每日一函式 — 字串函式 crypt ()
2020-05-04
PHP函式字串
PHP 每日一函式 — 字串函式 chr ()
2020-04-29
PHP函式字串
PHP 每日一函式 — 字串函式 addcslashes ()
2020-04-25
PHP函式字串
PHP 每日一函式 — 字串函式 addslashes ()
2020-04-26
PHP函式字串
PHP 第五週函式學習記錄
2020-07-05
PHP函式
PHP 每日一函式 — 字串函式 count_chars ()
2020-05-03
PHP函式字串
PHP 每日一函式 — 字串函式 crc32 ()
2020-05-04
PHP函式字串
PHP 每日一函式 — 字串函式 chunk_split ()
2020-04-28
PHP函式字串
PHP 每日一函式 — 字串函式 bin2hex ()
2020-04-28
PHP函式字串
PHP 每日一函式 — 字串函式 convert_cyr_string ()
2020-05-01
PHP函式字串
【函式分享】每日PHP函式分享(2021-3-1)
2021-03-01
函式PHP
【函式分享】每日PHP函式分享(2021-1-19)
2021-01-19
函式PHP
php函式瑣記
2019-05-11
PHP函式
共享記憶體函式
2013-01-19
記憶體函式
PHP 手冊 (類與物件) 學習筆記五：建構函式和解構函式
2020-06-01
PHP物件筆記函式
【每日函式】每日函式（2021.08.05）
2021-08-05
函式
php實現共享記憶體程式通訊函式之_shm
2018-06-06
PHP記憶體函式
如何高效記憶字串函式
2019-10-28
字串函式
常用記憶體操作函式
2020-12-21
記憶體函式
[php]幾個常用函式
2014-12-08
PHP函式
【每日函式】每日函式（2021.08.06）
2021-08-06
函式
【每日函式】每日函式（2021.08.08）
2021-08-08
函式
【每日函式】每日函式（2021.08.09）
2021-08-09
函式
【每日函式】每日函式（2021.08.10）
2021-08-10
函式
【每日函式】每日函式（2021.08.14）
2021-08-14
函式
【每日函式】每日函式（2021.08.16）
2021-08-16
函式
函式-PHP手冊筆記
2015-06-19
函式PHP筆記
PHP筆記：建構函式與解構函式
2021-09-09
PHP筆記函式
手撕記憶體操作函式
2020-12-22
記憶體函式
JavaScript 專題之函式記憶
2017-09-06
JavaScript函式
Golang記憶體分配內建函式之new函式
2018-08-30
Golang記憶體函式
PHP 每日一函式 — 字串函式 convert_uuencode () & convert_uudecode ()
2020-05-01
PHP函式字串
Delphi 的記憶體操作函式(5): 複製記憶體
2014-09-07
記憶體函式
php中四捨五入的數學函式
2007-11-28
PHP函式
核心記憶體分配常用函式使用
2016-11-05
記憶體函式
windows記憶體管理和API函式
2013-04-08
Windows記憶體API函式
python函式每日一講 - int()函式
2021-09-09
Python函式

每日五個 PHP 函式記憶

2019/02/19

2019/02/18

2019/02/17

2019/02/16

2019/02/15

2019/02/14

2019/02/13

2019/02/12

2019/02/11

2019/02/10

2019/02/08

2019/02/07

2019/02/06

2019/02/05

2019/02/04

2019/02/03

2019/02/02

2019/02/01

2019/01/31

2019/01/30

2019/01/29

2019/01/28

2019/01/27

2019/01/26

2019/01/25

2019/01/24

2019/01/23

2019/01/22

2019/01/21

2019/01/20

2019/01/19

2019/01/18

2019/01/17

2019/01/16

2019/01/15

2019/01/14

2019/01/13

2019/01/12

2019/01/11

2019/01/10

未完待續

相關文章