概念区分
数据库 vs 数据表
数据表包含于数据库
连接MySQL服务器
sudo /Applications/MAMP/Library/bin/mysql -u root -p
检测MySQL服务器是否启动
ps -ef | grep mysqld
管理MySQL的命令
use 数据库名
选择要操作的Mysql数据库，使用该命令后所有Mysql命令都只针对该数据库。
mysql> use mysql;
Database changed
show databases
列出 MySQL 数据库管理系统的数据库列表。
mysql> show databases
show tables
显示指定数据库的所有表，使用前需要use指定的数据库
mysql> show tables;
+---------------------------+
| Tables_in_mysql |
+---------------------------+
| columns_priv |
| db |
| event |
| func |
| general_log |
| help_category |
| help_keyword |
| help_relation |
| help_topic |
| innodb_index_stats |
| innodb_table_stats |
| ndb_binlog_index |
| plugin |
| proc |
| procs_priv |
| proxies_priv |
| servers |
| slave_master_info |
| slave_relay_log_info |
| slave_worker_info |
| slow_log |
| tables_priv |
| time_zone |
| time_zone_leap_second |
| time_zone_name |
| time_zone_transition |
| time_zone_transition_type |
| user |
+---------------------------+
28 rows in set (0.01 sec)
show columns from 数据表
显示数据表的属性，属性类型，主键信息 ，是否为 NULL，默认值等其他信息。
mysql> show columns from plugin;
+-------+--------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+-------+
| name | varchar(64) | NO | PRI | | |
| dl | varchar(128) | NO | | | |
+-------+--------------+------+-----+---------+-------+
2 rows in set (0.01 sec)
SHOW INDEX FROM 数据表
显示数据表的详细索引信息，包括PRIMARY KEY（主键）。
查询数据表所有数据
select * from Users;
面向对象内容
- 类-定义了抽象特点，包括数据形式与操作
- 对象-类的实例
- 成员变量-定义在类内部的变量，可以通过成员函数访问，在类被实例化为对象后，可以认为是这个对象的属性
- 成员函数-定义于类的内部，可以访问对象的数据
- 继承-子类共享父类数据结构和方法
- 父类-一个类被其他类继承(基类,超类)
- 子类-一个类继承其他类(派生类)
- 多态-相同函数或方法可以作用于多种类型的变量并获得不同的结果，不同的对象收到同一消息可以产生不同的结果
- 重载-函数或方法同名，但参数列表不同，这些函数或者方法之间互相称为重载函数或者方法
- 构造函数-在创建对象时初始化对象
- 析构函数-destructor，当对象结束生命周期时，系统自动执行析构函数清理善后
类的定义
<?php
class phpClass
{
var $var1;
var $var2 = "constant string";
function myFunction() {
}
}
?>
成员函数
<?php
class phpClass
{
var $var1;
var $var2 = "constant string";
function myFunction() {
}
/**
* @return mixed
*/
public function getVar1()
{
return $this->var1;
}
/**
* @param mixed $var1
*/
public function setVar1($var1)
{
$this->var1 = $var1;
}
/**
* @return string
*/
public function getVar2(): string
{
return $this->var2;
}
/**
* @param string $var2
*/
public function setVar2(string $var2)
{
$this->var2 = $var2;
}
}
?>
$this代表自身的对象
创建对象
使用new创建新的对象,使用->访问成员变量和对象内部的方法
建议使用getter和setter方法
<?php
class User
{
var $userName;
var $passWord;
/**
* @return mixed
*/
public function getUserName()
{
return $this->userName;
}
/**
* @param mixed $userName
*/
public function setUserName($userName)
{
$this->userName = $userName;
}
/**
* @return mixed
*/
public function getPassWord()
{
return $this->passWord;
}
/**
* @param mixed $passWord
*/
public function setPassWord($passWord)
{
$this->passWord = $passWord;
}
}
$laphets=new User();
$laphets->setUserName("laphets");
$laphets->setPassWord("123456");
echo $laphets->getUserName();
echo $laphets->getPassWord();
?>
构造函数
主要用于在创建对象时初始化对象；PHP5允许开发者在类中定义一个方法作为构造函数
function __construct () {
}
function __construct($par1,$par2)
{
$this->userName=$par1;
$this->passWord=$par2;
}
$laphets=new User("laphets","123456");
echo $laphets->getUserName();
echo $laphets->getPassWord();
其中”laphets”对应的是par1,“123456”对应的是par2
析构函数
function __destruct() {
}
继承
PHP使用extends继承一个类,但不支持多继承
class Child extends Parent {
}
方法重写
如果对父类继承的方法不满意，可以在子类中对方法进行重写，即考虑覆盖(override)
访问控制
PHP可以对属性和方法实现访问控制，通过在前添加关键字来实现
- public:共有的类成员可以在任何地方被访问
- protected:受保护的类成员可以被自身或者子类父类访问
- private:只能被其定义的类访问
属性的访问控制
类属性必须定义为公有,受保护,私有之一。如果直接var定义，则被视为公有
重要：类中的属性前面要加上var ；类之外的变量不需要加var
<?php
/**
* Define MyClass
*/
class MyClass
{
public $public = 'Public';
protected $protected = 'Protected';
private $private = 'Private';
function printHello()
{
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
$obj = new MyClass();
echo $obj->public; // 这行能被正常执行
echo $obj->protected; // 这行会产生一个致命错误
echo $obj->private; // 这行也会产生一个致命错误
$obj->printHello(); // 输出 Public、Protected 和 Private
/**
* Define MyClass2
*/
class MyClass2 extends MyClass
{
// 可以对 public 和 protected 进行重定义，但 private 而不能
protected $protected = 'Protected2';
function printHello()
{
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
$obj2 = new MyClass2();
echo $obj2->public; // 这行能被正常执行
echo $obj2->private; // 未定义 private
echo $obj2->protected; // 这行会产生一个致命错误
$obj2->printHello(); // 输出 Public、Protected2 和 Undefined
?>
方法的访问控制
类中的方法可以被定义为公有,私有,或者被保护。如果没有设置，则默认为public
<?php
/**
* Define MyClass
*/
class MyClass
{
// 声明一个公有的构造函数
public function __construct() { }
// 声明一个公有的方法
public function MyPublic() { }
// 声明一个受保护的方法
protected function MyProtected() { }
// 声明一个私有的方法
private function MyPrivate() { }
// 此方法为公有
function Foo()
{
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate();
}
}
$myclass = new MyClass;
$myclass->MyPublic(); // 这行能被正常执行
$myclass->MyProtected(); // 这行会产生一个致命错误
$myclass->MyPrivate(); // 这行会产生一个致命错误
$myclass->Foo(); // 公有，受保护，私有都可以执行
/**
* Define MyClass2
*/
class MyClass2 extends MyClass
{
// 此方法为公有
function Foo2()
{
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate(); // 这行会产生一个致命错误
}
}
$myclass2 = new MyClass2;
$myclass2->MyPublic(); // 这行能被正常执行
$myclass2->Foo2(); // 公有的和受保护的都可执行，但私有的不行
class Bar
{
public function test() {
$this->testPrivate();
$this->testPublic();
}
public function testPublic() {
echo "Bar::testPublic\n";
}
private function testPrivate() {
echo "Bar::testPrivate\n";
}
}
class Foo extends Bar
{
public function testPublic() {
echo "Foo::testPublic\n";
}
private function testPrivate() {
echo "Foo::testPrivate\n";
}
}
$myFoo = new foo();
$myFoo->test(); // Bar::testPrivate
// Foo::testPublic
?>
接口
接口(interface)可以指定某个类必须实现哪些方法，而不必定义这些方法的具体内容。
接口是通过 interface 关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。
接口中定义的所有方法都必须是公有，这是接口的特性。
interface iTemplate
{
public function setVariable($name,$val);
public function getHtml($template);
}
实现接口，使用implements操作符，类中实现借口所定义的所有方法；类可以实现多个接口，用逗号来分隔多个接口的名称
interface iTemplate
{
public function add($x,$y);
public function sub($x,$y);
}
class template implements iTemplate
{
var $sub;
function add($x, $y)
{
$sum=$x+$y;
return $sum;
// TODO: Implement add() method.
}
function sub($x, $y)
{
$sub=$x-$y;
return $sub;
// TODO: Implement sub() method.
}
}
常量
可以把类中保持不变的量定义为常量，定义和使用的时候不需要用$
常量的值必须是一个定值，不能是变量，类属性，数学运算的结果或函数调用
来看一个实例
<?php
class MyClass
{
const constant = '常量值';
function showConstant() {
echo self::constant . PHP_EOL;
}
}
echo MyClass::constant . PHP_EOL;
$classname = "MyClass";
echo $classname::constant . PHP_EOL; // 自 5.3.0 起
$class = new MyClass();
$class->showConstant();
echo $class::constant . PHP_EOL; // 自 PHP 5.3.0 起
?>
首先第一个用法，直接在成员函数内部使用self::constant访问常量；第二个用法，在未创建对象的情况下直接通过类来访问到常量（或者这样访问MyClass::constant）；第三个，通过成员函数的getter方法进行访问；第四个，直接通过对象进行访问（$class::constant）
抽象类
任何一个类，如果其中有一个方法是抽象的，那么这个类就是抽象类
抽象类不能够被实例化
抽象方法只是声明了调用方式（参数），不定义具体实现
继承一个抽象类时，子类必须定义父类的所有抽象方法，访问控制必须和父类一样活着更加宽松
来看一个栗子
<?php
abstract class AbstractClass
{
// 强制要求子类定义这些方法
abstract protected function getValue();
abstract protected function prefixValue($prefix);
// 普通方法（非抽象方法）
public function printOut() {
print $this->getValue() . PHP_EOL;
}
}
class ConcreteClass1 extends AbstractClass
{
protected function getValue() {
return "ConcreteClass1";
}
public function prefixValue($prefix) {
return "{$prefix}ConcreteClass1";
}
}
class ConcreteClass2 extends AbstractClass
{
public function getValue() {
return "ConcreteClass2";
}
public function prefixValue($prefix) {
return "{$prefix}ConcreteClass2";
}
}
$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') . PHP_EOL;
$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') . PHP_EOL;
?>
首先抽象类的定义方法
abstract class Abstractclass {
abstract protected function AF() {
...
}
}
可以理解为子类必须定义这个方法
但是方法使用的是子类所定义的
Static
声明类属性或者方法为static，就可以不实例化类而直接访问
静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）？
由于静态方法不需要通过对象即可调用，所以伪变量 $this 在静态方法中不可用。
静态属性不可以由对象通过 -> 操作符来访问。
来看一个栗子
<?php
class Foo {
public static $my_static = 'foo';
public static function staticValue() {
return self::$my_static;
}
}
print Foo::$my_static . PHP_EOL;
echo Foo::staticValue() . PHP_EOL;
$foo = new Foo();
print $foo->staticValue() . PHP_EOL;
?>
直接使用::来访问，类成员或者方法
Final
如果父类的方法被声明为final，则子类无法覆盖该方法；同样，如果一个类被声明为final，则不能够被继承
来看一个栗子
<?php
class BaseClass {
public function test() {
echo "BaseClass::test() called" . PHP_EOL;
}
final public function moreTesting() {
echo "BaseClass::moreTesting() called" . PHP_EOL;
}
}
class ChildClass extends BaseClass {
public function moreTesting() {
echo "ChildClass::moreTesting() called" . PHP_EOL;
}
}
// 报错信息 Fatal error: Cannot override final method BaseClass::moreTesting()
?>
调用父类的构造方法
PHP 不会在子类的构造方法中自动的调用父类的构造方法。要执行父类的构造方法，需要在子类的构造方法中调用 parent::__construct() 。
class subClass extends BaseClass {
function __construct() {
parent::__construct()；
}
}
来看这样的栗子
<?php
class BaseClass {
function __construct() {
print "BaseClass 类中构造方法" . PHP_EOL;
}
}
class SubClass extends BaseClass {
function __construct() {
parent::__construct(); // 子类构造方法不能自动调用父类的构造方法
print "SubClass 类中构造方法" . PHP_EOL;
}
}
class OtherSubClass extends BaseClass {
// 继承 BaseClass 的构造方法
function __construct() {
print "SubClass 类中构造方法" . PHP_EOL;
}
}
// 调用 BaseClass 构造方法
$obj = new BaseClass();
// 调用 BaseClass、SubClass 构造方法
$obj = new SubClass();
// 调用 BaseClass 构造方法
$obj = new OtherSubClass();
?>
我们可以这样理解，如果子类不定义一个构造方法，那么他会默认继承父类的一个构造方法；如果子类定义了自己的构造方法，那么他便不会继承父类的构造方法，除非你在construct()函数中使用了parent::__construct();
变量
- 变量以 $ 符号开始，后面跟着变量的名称
- PHP是一门弱类型语言
Assigning by Reference
PHP (from PHP4) offers another way to assign values to variables: assign by reference. This means that the new variable simply points the original variable. Changes to the new variable affect the original, and vice a verse.
Using ‘&’ to reference
<?php
$foo='bob';
$bar=&$foo;
$bar="my $bar";
echo $bar;
echo '<br />';
echo $foo;
?>
变量作用域
- local
- global
- static
- parameter
函数内调用全局变量
可以采用global的方式（重新定义？）
$x=1;
function work()
{
//echo $x;
global $x;
echo $x;
}
或者，PHP 将所有全局变量存储在一个名为 $GLOBALS[index] 的数组中。 index 保存变量的名称。这个数组可以在函数内部访问，也可以直接用来更新全局变量。
function work()
{
echo $GLOBALS['x'];
echo $GLOBALS['y'];
}
而在函数内定义的变量均为局部变量(local)
Static作用域(?)
当一个函数结束后，函数内定义的变量将会被删除，而使用了static，则可以使之不被内存回收。
function Work()
{
static $x=0;
echo $x;
$x++;
}
Print&Echo
echo
注意输出的均为HTML的标签形式
function Work()
{
global $txt1,$txt2,$cars;
echo "<h1>HelloWorld</h1>";
echo "Hello<br>";
echo "Third<br>";
echo "$txt2,$txt1,{$cars[0]}";
}
注意:变量可以直接在引号内输出，当在引号外输出时，采用comma连接
只能够输出一个字符串，即without comma
数据类型
String（字符串）, Integer（整型）, Float（浮点型）, Boolean（布尔型）, Array（数组）, Object（对象）, NULL（空值）
Boolean
$x=true;
$y=false;
Array
$cars=array("1","2","3");
cars[0]
Null
NULL 值表示变量没有值。NULL 是数据类型为 NULL 的值。NULL 值指明一个变量是否为空值。 同样可用于数据空值和NULL值的区别。可以通过设置变量值为 NULL 来清空变量数据
常量
使用define定义一个常量（全局）
define("Name", "Laphets"); //区分大小写
define("Name", "Laphets", true); //不区分大小写
字符串
并置运算符(? differ from ‘,’)
并置运算符 (.) 用于把两个字符串值连接起来。
<?php
$txt1="Hello world!";
$txt2="What a nice day!";
echo $txt1 . " " . $txt2;
?>
获取字符串长度
strlen() 函数返回字符串的长度（字符数）
$str[strlen($str)-1]；
查找子串
strpos() 函数用于在字符串内查找一个字符或一段指定的文本。
如果在字符串中找到匹配，该函数会返回第一个匹配的字符位置。如果未找到匹配，则返回 FALSE。
<?php
$str="Hello";
echo strpos($str,"ll1o");
?>
运算符
- -x按位取反
- a.b 并置 连接两个字符串
- 区分==和=== !=和!==
$x=1;
$y="1";
var_dump($x==$y);
var_dump($x===$y);
- 与&&
- 或||
- 非!
- 异或xor
数组运算符
| 运算符 | 名称 | 描述 |
|---|---|---|
| x + y | 集合 | x 和 y 的集合 |
| x == y | 相等 | 如果 x 和 y 具有相同的键/值对，则返回 true |
| x === y | 恒等 | 如果 x 和 y 具有相同的键/值对，且顺序相同类型相同，则返回 true |
| x != y | 不相等 | 如果 x 不等于 y，则返回 true |
| x <> y | 不相等 | 如果 x 不等于 y，则返回 true |
| x !== y | 不恒等 | 如果 x 不等于 y，则返回 true |
三目运算符
(expr1) ? (expr2) : (expr3)
和C++类似，当expr1为true时，为expr2，else为expr3
组合比较符(PHP7新特性)
echo 1<=>2;
echo 2<=>1;
echo 1<=>1;
小于是-1，等于是0，大于是1
If语句
和C++类似，if else elseif
Switch
不再赘述
数组
创建数组
array();
数值数组
带有数字 ID 键的数组，即可以通过数值的index访问到元素
$car=array("a","b","c");
$car[0];
获取数组长度
count() 函数用于返回数组的长度（元素的数量），相当于C++ vector的size()
$cars=array(1,2,3);
echo count($cars);
遍历数组
for($i=0;$i<count($cars);$i++)
{
echo $cars[$i]."<br>";
}
关联数组
带有指定的键（分配）的数组，每个键关联一个值，相当于C++的map
$cars=array("a"=>"1","b"=>"2","c"=>"3");
echo $cars['b'];
遍历数组
使用foreach进行遍历，其中注意x=>x_value，其中x代表键值，x_value代表对应的值
$cars=array("a"=>"1","b"=>"2","c"=>"3");
foreach ($cars as $x=>$x_value)
{
echo "Key ".$x." Value ".$x_value;
echo "<br>";
}
Foreach方法
Foreach提供了遍历数组的简单方式，仅能应用于遍历数组与对象
foreach (array_expression as $value)
statement
//or
foreach (array_expression as $key=>$value
statement
数组排序
sort()方法，直接对一个数组进行升序排序，rsort()方法，直接对一个数组降序排序。更多则参照PHP Array 参考手册
超级全局变量
$GLOBALS
$GLOBALS是PHP的超级全局变量组，在PHP的所有作用域内都可以进行访问；它是一个包含了全部变量的全局组合数组，变量的名字是数组的键值。
$x=1;
$GLOBALS['x']
$_SERVER
$_SERVER是一个包含了header,path,script locations的数组，由Web Sever创建。
| 元素/代码 | 描述 |
|---|---|
| $_SERVER[‘PHP_SELF’] | 当前执行脚本的文件名，与 document root 有关。例如，在地址为 http://example.com/test.php/foo.bar 的脚本中使用 _SERVER[‘PHP_SELF’] 将得到 /test.php/foo.bar。FILE 常量包含当前(例如包含)文件的完整路径和文件名。 从 PHP 4.3.0 版本开始，如果 PHP 以命令行模式运行，这个变量将包含脚本名。之前的版本该变量不可用。 |
| $_SERVER[‘GATEWAY_INTERFACE’] | 服务器使用的 CGI 规范的版本；例如，”CGI/1.1”。 |
| $_SERVER[‘SERVER_ADDR’] | 当前运行脚本所在的服务器的 IP 地址。 |
| $_SERVER[‘SERVER_NAME’] | 当前运行脚本所在的服务器的主机名。如果脚本运行于虚拟主机中，该名称是由那个虚拟主机所设置的值决定。(如: www.runoob.com) |
| $_SERVER[‘SERVER_SOFTWARE’] | 服务器标识字符串，在响应请求时的头信息中给出。 (如：Apache/2.2.24) |
| $_SERVER[‘SERVER_PROTOCOL’] | 请求页面时通信协议的名称和版本。例如，”HTTP/1.0”。 |
| $_SERVER[‘REQUEST_METHOD’] | 访问页面使用的请求方法；例如，”GET”, “HEAD”，”POST”，”PUT”。 |
| $_SERVER[‘REQUEST_TIME’] | 请求开始时的时间戳。从 PHP 5.1.0 起可用。 (如：1377687496) |
| $_SERVER[‘QUERY_STRING’] | query string（查询字符串），如果有的话，通过它进行页面访问。 |
| $_SERVER[‘HTTP_ACCEPT’] | 当前请求头中 Accept: 项的内容，如果存在的话。 |
| $_SERVER[‘HTTP_ACCEPT_CHARSET’] | 当前请求头中 Accept-Charset: 项的内容，如果存在的话。例如：”iso-8859-1,*,utf-8”。 |
| $_SERVER[‘HTTP_HOST’] | 当前请求头中 Host: 项的内容，如果存在的话。 |
| $_SERVER[‘HTTP_REFERER’] | 引导用户代理到当前页的前一页的地址（如果存在）。由 user agent 设置决定。并不是所有的用户代理都会设置该项，有的还提供了修改 HTTP_REFERER 的功能。简言之，该值并不可信。) |
| $_SERVER[‘HTTPS’] | 如果脚本是通过 HTTPS 协议被访问，则被设为一个非空的值。 |
| $_SERVER[‘REMOTE_ADDR’] | 浏览当前页面的用户的 IP 地址。 |
| $_SERVER[‘REMOTE_HOST’] | 浏览当前页面的用户的主机名。DNS 反向解析不依赖于用户的 REMOTE_ADDR。 |
| $_SERVER[‘REMOTE_PORT’] | 用户机器上连接到 Web 服务器所使用的端口号。 |
| $_SERVER[‘SCRIPT_FILENAME’] | 当前执行脚本的绝对路径。 |
| $_SERVER[‘SERVER_ADMIN’] | 该值指明了 Apache 服务器配置文件中的 SERVER_ADMIN 参数。如果脚本运行在一个虚拟主机上，则该值是那个虚拟主机的值。(如：someone@runoob.com) |
| $_SERVER[‘SERVER_PORT’] | Web 服务器使用的端口。默认值为 “80”。如果使用 SSL 安全连接，则这个值为用户设置的 HTTP 端口。 |
| $_SERVER[‘SERVER_SIGNATURE’] | 包含了服务器版本和虚拟主机名的字符串。 |
| $_SERVER[‘PATH_TRANSLATED’] | 当前脚本所在文件系统（非文档根目录）的基本路径。这是在服务器进行虚拟到真实路径的映像后的结果。 |
| $_SERVER[‘SCRIPT_NAME’] | 包含当前脚本的路径。这在页面需要指向自己时非常有用。FILE 常量包含当前脚本(例如包含文件)的完整路径和文件名。 |
| $_SERVER[‘SCRIPT_URI’] | URI 用来指定要访问的页面。例如 “/index.html”。 |
$_REQUEST
用以收集HTML Form提交的数据
<html>
<head>
<title>Test</title>
</head>
<body>
<form method="post" action="<?php echo $_SERVER['PHP_SELF'];?>">
Name:<input type="text" name="fname">
<input type="submit">
</form>
<?php
$name = $_REQUEST['fname'];
echo $name;
?>
</body>
</html>
当点击Submit时，表单将数据发送至action中指定的PHP文件，也即$_SERVER[‘PHP_SELF’]，接着使用_REQUEST来收集数据。
关于name属性：The name attribute specifies the name of a form. The name attribute is used to reference elements in a JavaScript, or to reference form data after a form is submitted.
$_POST
$_POST用于收集表单数据，需要指定method=“post”.可以收集input字段数据.
Difference Between _REQUEST and _POST
_REQUEST contains: _COOKIE, _GET, and _POST variables
Basically… never use _REQUEST, use _POST for post method forms, _GET for query string and get method forms, and $COOKIE to handle cookies.
$_GET
$_GET可以收集method=”get”的数据，或者收集URL发送的数据
<html>
<head>
<title>Test</title>
</head>
<body>
<?php
echo "Study ".$_GET['subject']." at ".$_GET['web'];
?>
</body>
</html>
http://localhost:63342/Learning/test.php?subject=PHP&web=laphets.com
While循环
While
$i=1;
while($i<=5)
{
echo $i."<br>";
$i++;
}
do…while
至少执行一次
$i=1;
do
{
$i++;
echo $i."<br>";
}while($i<=5);
For循环
和C++类似
for($i=1;$i<=10;$i++)
{
echo $i."<br>";
}
foreach
用于遍历数组
$a=array();
for($i=1;$i<=10;$i++)
{
$a[$i]=$i;
}
foreach ($a as $key=>$value)
echo $a[$key]." ".$value."<br>";
每进行一次循环，当前数组的key将被赋值到$key变量，数组的值将被赋值给value变量，然后指针进行移动
函数
创建函数
function functionName()
{
}
参数,返回值
和C++类似
function get_max($a,$b)
{
if($a>$b)
return $a;
elseif ($a<$b)
return $b;
else
return $a;
}
$x=$_POST['x'];
$y=$_POST['y'];
echo get_max($x,$y);
魔术变量
可以理解为预定义常量，但随着在代码中的位置改变而改变，不区分大小写.
LINE
显示文件中的当前行号
<html>
<head>
<title>Test</title>
</head>
<body>
<?php
echo __LINE__;
?>
</body>
</html>
output
7
FILE
文件的完整路径和文件名
<?php
echo '该文件位于 " ' . __FILE__ . ' " ';
?>
该文件位于 " /Users/laphets/Code/PHP/Learning/test.php "
还有FUNCTION,CLASS,METHOD等显示函数名,类名和类的方法名
命名空间
用途
- 用户编写的代码与PHP内部的类/函数/常量或第三方类/函数/常量之间的名字冲突。
- 为很长的标识符名称(通常是为了缓解第一类问题而定义的)创建一个别名（或简短）的名称，提高源代码的可读性。
Define a Namespace
namespace MyProject1;
….
- Study hard
- Group learning
- learn how your professors learn learn from them
- Plan ahead and manage your time such as Todo list
- Develop a peer support network — work together
- Meet people who are different than you
- Go to office hours — Just to ask questions and talk with them
- Talk with your professors outside of the classroom
- Be open to new experiences
- Don’t forget where come from — Yourt parents
- Understand and embrace what makes you unique
- Reading widly ,just benefitting your writing
- Team work! Work hard with every one around you.
- Don’t work for GPA, let GPA work for you.
起因
以前用Next的时候采用的是多说的评论系统，但貌似多说早在6月份就停止了服务，于是在开始写自己的主题Lapherial时，我便考虑自己写一个评论系统
Technology
首先，我并不具有后端的技术栈，因此全部系统的搭建完全建立在JavaScript以及Baas SDK的基础上
逻辑实现
首先，我们考虑的是将每一条评论与文章建立起对应关系(Point)。于是初步考虑的是将每一个Post建立起一个大表，在大表里存储对应的评论，但由于Baas提供的大表数有限，于是考虑只建立Post和Comment两个表，并在每一条comment内存储一条Point指向Post。这样一来，当访问到一个文章时，先在表中查找有没有这个文章存在，如果不存在则通过Post的title建立一条新记录，并获取到ObjectID。接着便通过遍历Comment表的方式加载出评论
关于JS的异步
我们知道获取id与save的方法都是异步的，因此很有可能造成先save了却没有得到id的错误。因此我使用了setTimeout的方法，将save方法异步0.4s后执行，并对相应的UI组件进行构建
- 通过Pace.js实现了加载进度条（自动读取DOM树）
- 加入了评论系统，并完善了对应逻辑
- 将alert转为Material Design风格的Toast
- 全新加入了标签系统（在Post的底部）
- 完善了图片显示功能，实现了图片自适应与Lightbox