PHP基础入门

学习路径：讯飞AI大学《PHP编程入门》 转载请注明出处 MindMaster @Tracy

PHP

• Syntax
  • document type
    • <?php ... ?>
      • remove ?> if file ends with PHP code
    • <?= "hello\n"; ?>
    • <? echo "hello\n"; ?>
  • comment
    • #comment
    • //comment
    • /* comment */
  • output
    • echo function()."\n";
    • echo "string here: $num"."\n";
      • //string here: 123
    • print
      • same as echo, but returns 1 or 0 as well
    • var_dump
      • dumps variable info
    • print_r
      • prints variable info in a more human-readable way
• Scalar types
  • boolean
    • true、false、TRUE、FALSE
  • integer
    • 567
      • //decimal
    • 0123
      • //octadecimal
    • 0x1A
      • //hexadecimal
    • 0b1101
      • //binary
  • float
    • 1.234
    • 1.2e3
      • //1200
    • 7E-10
      • //7.0E-10
    • float precision error:
      • $epsilon = 0.00001; if (abs($a-$b) < $epsilon) { echo "true"; } else { echo "false"; }
  • string
    • escape
      • "\n" OR PHP_EOL
      • "some string $str"
        • //some string Greet in Hong Kong
      • "bunchofstring{$str}"
        • //bunchofstringGreet in Hong Kong
    • NO escape
      • '\n'
      • 'some string $str'
        • //some string $str
      • "bunchofstring$str"
        • //bunchofstring$str
    • 'string of multiple lines'
      • OR "
    • array index:
      • $str[0]
        • //G
      • $str[3] = 'a';
        • //Great in Hong Kong
        • Replaces with the first character only if ' ' contains multiple
    • functions:
      • strlen($str)
      • substr($str, 2, 4)
        • //eet
        • returns $str[2] to $str[4]
      • substr_replace($str, "Beijing from", 6, 7)
        • //Greet Beijing from Kong
        • replace starting from $str[6] for 7 characters
  • declaration:
    • $var_name = 123456;
  • get variable type:
    • gettype($var_name)
  • Varaible info:
    • var_dump($var_name);
      • //int(123456)
      • //bool(true)
    • var_dump(expression: 25/7);
      • //float(3.5714285714286)
    • var_dump((int)(25/7));
      • //int(3)
    • var_dump(round(val: 25/7));
      • //float(4)
    • var_dump($str)
      • //string(5) "hello"
• Compound types
  • array
    • $name = array( "Amy"=>3, "17", "David", "58"=>"Cathy", 58.6=>"Carmen", "Elmo", - 888=>"last" );
      • OR $name = ["Amy"...]; for PHP5.4+
      • keys are:
        • ["Amy"], [0], [1], [58], [59], [-888]
    • keys:
      • string
        • float in string form REMAINS string
      • int
        • float TO int (round down)
        • int in string form TO int
      • only keep the last element for duplicated keys
    • add elements:
      • $name[] = "new name";
        • key indexing is minimum
      • $name["girl"] = "new girl";
    • functions:
      • count($name)
      • $name = array_values($name);
        • re-indexing
      • unset($name[0]);
        • delete name[0]
    • can put array in an array
  • object
    • class foo { function do() { ...; } }
    • $obj = new foo; $obj->do();
    • OR foo::do();
    • OR call_user_func(array('foo', 'do');
  • callable
    • function myfunc($arg) { ...; }
    • myfunc($param);
    • OR call_user_func('myfunc', $param);
  • resource
    • $f = fopen($filename, "w");
    • get_resource_type($f)
  • NULL
    • undefined variables
    • $var = null;
    • unset($var);
• Type-casting
  • AUTO string TO int/float
    • $foo = "1";
      • string //ASCII49
    • $foo *= 2;
      • int //2
    • $foo *= 1.3;
      • float //1.3
    • $foo = 5 * "12.0th day of Christmas";
      • float //60
      • with warning
    • $foo = 5 + "letters before 12";
      • int //5
      • with warning
  • settype()
    • settype($foo, "float");
    • settype($foo, "integer");
  • TO boolean
    • true
      • (bool) "false"
      • (bool) -2.3
      • (bool) array(5)
    • false
      • (bool) ""
      • (bool) 0
      • (bool) array()
  • intval()
    • $to_int = intval(true)
      • //1
    • $to_int = intval(12.7)
      • //12
  • object TO array
    • class A { private $a; } $arr = (array) new A();
      • //array(1) { [" A a"]=>NULL }
  • array TO object
    • $obj = (object) array('1'=>'foo');
    • isset($obj->{'1'})
      • //true
    • key($obj)
      • //1
• Defining variables
  • $var_name = /*value*/ ;
  • cap-sensitive
  • global scope:
    • declare global variables in local function
      • $var = "global" ;
      • function localfunc() { $var = "local"; } localfunc(); echo $var;
        • //global
        • global $var unchanged
      • function localfunc() { global $var; $var = "local"; } localfunc(); echo $var;
        • //local
        • assigns global $var to "local" directly
  • static
    • static $a = 0;
  • variable
    • $a = "b"; $$a = "hello";
      • in $a, //"b" in $b, //"hello"
    • $list = arr; $$list = ['one', 'two', 'three']; ${$arr[1]} = "hi"; $arr[1] = "bye";
      • in $two, //"hi"
      • //array(3) { [0]=>"one", [1]=>"bye", [2]=>"three" }
  • predefined
    • $GLOBALS
      • array of all global variables (inc. system environment variables)
      • function fun() { $GLOBALS['var'] = "new value"; echo $GLOBALS['var']; } fun(); echo $var;
        • //new value //new value
    • $_SERVER、$_GET、$_POST、$_FILES、$_REQUEST、$_SESSION
    • $_ENV、$COOKIE
    • $php_errormsg
    • $http_response_header
    • $argc、$argv
• Defining constants
  • user defined
    • define("CONST_NAME", "const_value");
    • OR const CONST_NAME = "const_value";
    • scalar types only
    • don't begin const name with __
    • no scope constraint
  • magic
    • __FILE__
      • full path and filename of file
    • __DIR__
      • directory of file
      • OR dirname(__FILE__)
    • __LINE__
      • current line number of file
    • __FUNCTION__
      • name of function
      • {closure} if anonymous
    • __METHOD__
      • name of class method aka. name of class and function
    • __CLASS__
      • namespace\name of class
    • __TRAIT__
      • namespace\name of trait
    • __NAMESPACE__
      • name of namespace
    • ClassName::class
      • name of fully qualified class
• Operators
  • priority
    • clone new [] ** ++ -- ~ (int) (float) (string) (array) (object) (bool) instanceof ...(same as C++)
  • special arithmetic
    • **
      • exponential
    • ===
      • same value AND same type
    • <>
      • same as != (after type-casting)
    • !==
      • different value OR different type
    • <=>
      • returns an integer <. =, >0 respectively
      • PHP7+
    • ?? ... ?? ...
      • returns first defined operand not NULL
      • if all undefined and not NULL, return NULL
    • and or
  • execution
    • `ls -lh`
      • executes as shell command
  • type
    • $obj instanceof $myclass
      • check if $obj is an instance of the class $myclass
  • string
    • .
      • join strings
    • .=
      • join to current string
  • array
    • +
      • join arrays
    • can use special arithmetic operators
• Control structures
  • if() else{}
  • switch() {case: }
  • for(;;){}
  • foreach($arr as &$val) {}
    • $arr must be of type array or object
    • operating on $val will change respective $arr[i]
  • while{}, do{} while()
  • break, return, continue, goto
• Functions
  • function func_name($arg1, $arg2 = 0) {}
  • can be called anywhere unless defined in condition
    • if ($sth) { function conditional_func() {} }
  • NO overload/override/redefine
  • referencing &
    • function func(&$arg) {}
    • change the content of the original variable directly
    • NO pointer / address usage
  • internal
    • phpinfo()
    • is_bool()
    • var_dump()
  • anonymous (closures)
    • call_user_func(function($arg){}, "some arguments");
• OOP
  • class Base { }
    • private / protected / public
      • variable or function
    • construct
      • /*type*/ function __construct($v) {...}
        • //prioritized method
      • /*type*/ function Base() {}
    • destruct
      • /*type*/ function __destruct() {}
    • copy
      • /*type*/ function __clone() {}
  • keywords
    • $this->
      • points to the current instance
      • e.g. definition
        • $this->var = $v;
    • self::
      • points to static members in class
      • e.g. singleton pattern
        • private static $instance = null;
        • //in construction self::$instance = new self();
    • parent::
      • points to base class
      • e.g. in derived
        • class Derive extends Base { }
          • can extend only 1 base
        • //in construction parent::__construct($v); $this->w = $w;
  • static
    • static variable
      • //in member func return self::$var;
      • //in derive member func return parent::$var;
      • echo Base::$var;
    • static function
      • Base::statFunc();
  • const
    • const data
      • //in member func echo self::constant;
      • echo Base::constant;
  • abstract
    • abstract class A { //declare abstract functions }
    • class B extends A { //define all abstract functions in A }
  • interface
    • interface iTemp { //declare functions }
    • class Temp implements iTemp { //define functions in iTemp }
      • can implement >1 interface
  • trait
    • trait Tr { }
    • class Derive extends Base { use Tr; }
    • function calling priority:
      • 1. Derive
      • 2. Tr
      • 3. Base
  • iteration
    • iterates all member variables visible in the calling scope
    • foreach ($this as $key=>$value) { //echo "$key => $value"; }
  • magic
    • __construct
    • __destruct
    • __toString
      • public function __toString() { return $this->$str; }
      • echo $instance;
• namespace
  • CAN't have any content before <?php if namespace is defined
  • define
    • namespace nspc;
  • call under nspc:
    • \nspc\func();
      • OR func();
    • $a = new \nspc\ClsName();
      • OR $a = new ClsName();
    • \nspc\StaticCls::method();
      • OR StaticCls::method();
  • require_once(example.php)
    • //in example.php namespace nspc\sub;
    • call under nspc:
      • \nspc\sub\func();
        • OR sub\func();
      • echo \nspc\sub\CONSTANT;
        • OR echo sub\CONSTANT;
      • \nspc\sub\StaticCls::method();
        • OR sub\StaticCls::method();
  • dynamic under nspc:
    • $x = 'nspc\ClsName'; $obj = new $a;
      • OR $x = '\nspc\ClsName'; $obj = new $a;
    • $b = 'dynam\funcname; $b();
      • OR $b = '\dynam\funcname; $b();
    • echo constant('nspc\CONSTANT');
      • OR echo constant('\nspc\CONSTANT');
• error
  • error_reporting(/*level*/);
    • any binary number or constant
    • 1 E_ERROR
      • fatal error
    • 2 E_WARNING
      • runtime warning
      • will not stop running
    • 4 E_PARSE
      • syntax parsing warning during compilation
    • 8 E_NOTICE
      • runtime notice
      • displays all possible errors
    • 16/32 E_CORE_ERROR/WARNING
      • E_ERROR/WARNING for initialization of PHP engine core
    • 64/128 E_COMPILE_ERROR/WARNING
      • E_ERROR/WARNING FOR Zend script engine
    • 256/512/1024 E_USER_ERROR/WARNING/NOTICE
      • E_ERROR/WARNING/NOTICE by users
      • trigger_error()
    • 2048 E_STRICT
      • give code suggestions
    • 4096 E_RECOVERABLE_ERROR
      • fatal errors that can be caught by users (else, E_ERROR)
      • set_error_handler()
    • 8192 E_DEPRECATED
      • runtime notice for unsupported codes in future versions
    • 16384 E_USER_DEPRECATED
      • E_DEPRECATED by users
      • trigger_error()
    • 30719 E_ALL
      • all error levels except E_STRICT
  • error_log(/*msg*/, /*msg type (int)*/, /*dst (e.g. error.log)*/);
  • ini_set(/*var name*/, /*value (int)*/);
  • function MyErrorHandler($errno, $errstr, $errfile, $errline) { if (!(error_reporting()) & $errno) return false; switch ($errno) { case E_USER_ERROR: echo ... exit(1); break; case ... default: echo "Unknown ..."; break; } }
  • set_error_handler("myErrorHandler");
• exceptions
  • function func($var) { if (/*invalid $var*/) throw new Exception(/*msg*/, /*code (int)*/); else return /*func result*/; }
  • try { $result = func("input"); } catch (Exception $exception) { var_dump($exception->getMessage()); exit; }
  • echo $result; exit;
  • user-defined exception
    • class MyException extends Exception { public function __construct($message = "", $code = 0, Throwable $previous = null) { parent::__construct($message, $code, $previous); } public function __toString() { return __CLASS__.": displays exception code and message"; } public function customFunc() {...} }
      • extends system class Exception
      • //in class Exception implements Throwable protected $message, $code, $file, $line final private function __clone(){}