MySQL Details

概念区分

数据库 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;

PHP Object-oriented Programming

面向对象内容

  • 类-定义了抽象特点,包括数据形式与操作
  • 对象-类的实例
  • 成员变量-定义在类内部的变量,可以通过成员函数访问,在类被实例化为对象后,可以认为是这个对象的属性
  • 成员函数-定义于类的内部,可以访问对象的数据
  • 继承-子类共享父类数据结构和方法
  • 父类-一个类被其他类继承(基类,超类)
  • 子类-一个类继承其他类(派生类)
  • 多态-相同函数或方法可以作用于多种类型的变量并获得不同的结果,不同的对象收到同一消息可以产生不同的结果
  • 重载-函数或方法同名,但参数列表不同,这些函数或者方法之间互相称为重载函数或者方法
  • 构造函数-在创建对象时初始化对象
  • 析构函数-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 Basic Details

变量

  • 变量以 $ 符号开始,后面跟着变量的名称
  • 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++;
}

echo

注意输出的均为HTML的标签形式

function Work()
{
    global $txt1,$txt2,$cars;
    echo "<h1>HelloWorld</h1>";
    echo "Hello<br>";
    echo "Third<br>";
    echo "$txt2,$txt1,{$cars[0]}";
}

注意:变量可以直接在引号内输出,当在引号外输出时,采用comma连接

print

只能够输出一个字符串,即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等显示函数名,类名和类的方法名

命名空间

用途

  1. 用户编写的代码与PHP内部的类/函数/常量或第三方类/函数/常量之间的名字冲突。
  2. 为很长的标识符名称(通常是为了缓解第一类问题而定义的)创建一个别名(或简短)的名称,提高源代码的可读性。

Define a Namespace

namespace MyProject1;

….

CS101 Details

Lecture 3

  • 2**3=8 (it means pow in Python)
  • x,y=y,x just change value of x and y
  • literal—10 variable—X statement— x=y expression— x*y
  • binary decimal hex
  • Negative numbers left most—sign bit
  • type() show the type of
  • 1000 0000 -> -1 1111 1111 -> -128

Some Tips From Illinois

  1. Study hard
  2. Group learning
  3. learn how your professors learn learn from them
  4. Plan ahead and manage your time such as Todo list
  5. Develop a peer support network — work together
  6. Meet people who are different than you
  7. Go to office hours — Just to ask questions and talk with them
  8. Talk with your professors outside of the classroom
  9. Be open to new experiences
  10. Don’t forget where come from — Yourt parents
  11. Understand and embrace what makes you unique
  12. Reading widly ,just benefitting your writing
  13. Team work! Work hard with every one around you.
  14. Don’t work for GPA, let GPA work for you.

Node.js

REPL

Read Eval Print Loop:交互解释器,类似于Python

NPM的使用细节

NPM的安装

一般随带Node.js安装,使用以下命令查看版本号

npm -v

安装模块

npm install <Module Name>

全局安装与本地安装

npm install ... -g  #Global

全局:直接安装在/usr/local 可以直接在命令行运行

本地:安装包保存在./node_modules内,通过require调用

Save

之后运行npm install 会自动安装已有模块

一个伪静态评论系统的逻辑实现

起因

以前用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组件进行构建

Lapherial V1.3 Beta1

  1. 通过Pace.js实现了加载进度条(自动读取DOM树)
  2. 加入了评论系统,并完善了对应逻辑
  3. 将alert转为Material Design风格的Toast
  4. 全新加入了标签系统(在Post的底部)
  5. 完善了图片显示功能,实现了图片自适应与Lightbox

title: 军训交稿系统

date: 2017-09-12 21:06:00

tags: JavaScript

逻辑实现

用户字段

班 排 名字 学号 是否提交(提交状态)

输入框

稿件类型 标题 名字 学号

还有一个文件提交框

一些功能

稿件要求的示例功能



dashboard