php中get_adjacent_post函数PHP源码阅读笔记

下面我们来看一篇关于get_adjacent_post函数PHP源码阅读笔记，希望文章能够让各位了解到get_adjacent_post函数用法。

这个函数是wordpress里的一个函数，作用是获取相邻的POST文章。

函数并不大，有效代码大概只有70行左右，但是里面包含的知识不少，所以专门用一篇文章来解释一下。

get_adjacent_post函数的源码位于wp-includes/link-template.php中。

我会通过“//roc:”在引出源码阅读笔记。

/**
 * Retrieve adjacent post.
 *
 * Can either be next or previous post.
 *
 * @since 2.5.0
 *
 * @param bool $in_same_cat Optional. Whether post should be in a same category.
 * @param array|string $excluded_categories Optional. Array or comma-separated list of excluded category IDs.
 * @param bool $previous Optional. Whether to retrieve previous post.                                                            
 * @return mixed Post object if successful. Null if global $post is not set. Empty string if no corresponding post exists.
 */
【笔记】

上面这一段是函数的介绍信息，这个函数包括三个参数：

1 $in_same_cat参数，表示是否需要在同一category中，默认为false。

2 $excluded_categories参数，用于设置忽略哪些category中的post。可以将category ID组成array或comma-separated list的方式来赋值。

3 $previous参数，表示是否提取前一篇post。默认为true。如果希望提取后一篇post，需则设置为false。

此函数的返回值也有三种情况：

1 返回post object，则表明成功；

2 返回NULL，则表明全局$post未设置；

3 返回空字符串，则表明相应的post不存在。

function get_adjacent_post( $in_same_cat = false, $excluded_categories = "", $previous = true ) {
    global $wpdb;
【笔记】

这里声明了$wpdb全局变量，这个变量其实很有来头的，它是wordpress自身为开发者提供的公有全局变量，开发者们可以直接利用这个函数来对数据库进行操作，包括新建、删除、添加、更新等等。

需要注意的是，如果想使用这个“万能钥匙”，需要在自己的函数中向上面这样声明一下这个变量。

另外，在正常情况下，$wpdb变量只有权限访问博客所对应的一个数据库，对其他数据库是没有权限的。

比如想查询数据库中的表内容，那么可以这样：

if ( ! $post = get_post() )        return null;
    $current_post_date = $post->post_date;

    $join = "";
    $posts_in_ex_cats_sql = "";
    if ( $in_same_cat || ! empty( $excluded_categories ) ) {
        $join = " INNER JOIN $wpdb->term_relationships AS tr ON p.ID = tr.object_id INNER JOIN $wpdb->term_taxonomy tt ON tr.term_taxonomy_id = tt.term_taxonomy_id";

        if ( $in_same_cat ) {
            if ( ! is_object_in_taxonomy( $post->post_type, "category" ) )
                return "";
            $cat_array = wp_get_object_terms($post->ID, "category", array("fields" => "ids"));
            if ( ! $cat_array || is_wp_error( $cat_array ) )
                return "";
            $join .= " AND tt.taxonomy = "category" AND tt.term_id IN (" . implode(",", $cat_array) . ")";
        }   

        $posts_in_ex_cats_sql = "AND tt.taxonomy = "category"";
        if ( ! empty( $excluded_categories ) ) {
            if ( ! is_array( $excluded_categories ) ) {
                // back-compat, $excluded_categories used to be IDs separated by " and "
                if ( strpos( $excluded_categories, " and " ) !== false ) {
                    _deprecated_argument( __FUNCTION__, "3.3", sprintf( __( "Use commas instead of %s to separate excluded categories." ), ""and"" ) );
                    $excluded_categories = explode( " and ", $excluded_categories );
                } else {
                    $excluded_categories = explode( ",", $excluded_categories );
                }
            }

            $excluded_categories = array_map( "intval", $excluded_categories );

            if ( ! empty( $cat_array ) ) {
                $excluded_categories = array_diff($excluded_categories, $cat_array);
                $posts_in_ex_cats_sql = "";
            }

            if ( !empty($excluded_categories) ) {
                $posts_in_ex_cats_sql = " AND tt.taxonomy = "category" AND tt.term_id NOT IN (" . implode($excluded_categories, ",") . ")";
            }
        }
    }

    $adjacent = $previous ? "previous" : "next";
    $op = $previous ? "<" : ">";
    $order = $previous ? "DESC" : "ASC";

    $join  = apply_filters( "get_{$adjacent}_post_join", $join, $in_same_cat, $excluded_categories );
    $where = apply_filters( "get_{$adjacent}_post_where", $wpdb->prepare("WHERE p.post_date $op %s AND p.post_type = %s AND p.post_status = "publish" $posts_in_ex_cats_sql", $current_post_date, $post->post_type), $in_same_cat, $excluded_categories );
    $sort  = apply_filters( "get_{$adjacent}_post_sort", "ORDER BY p.post_date $order LIMIT 1" );

    $query = "SELECT p.id FROM $wpdb->posts AS p $join $where $sort";
    $query_key = "adjacent_post_" . md5($query);
    $result = wp_cache_get($query_key, "counts");
    if ( false !== $result ) {
        if ( $result )
            $result = get_post( $result );
        return $result;
    }

    $result = $wpdb->get_var( $query );
    if ( null === $result )
        $result = "";

    wp_cache_set($query_key, $result, "counts");

    if ( $result )
        $result = get_post( $result );

    return $result;
}

下面我们来看一篇关于PHP7 的抽象语法树（AST）带来的变化吧，希望这篇文章能够帮助到各位朋友，具体如下。

本文并不会告诉你抽象语法树是什么，这需要你自己去了解，这里只是描述 AST 给 PHP 带来的一些变化。

新的执行过程

PHP7 的内核中有一个重要的变化是加入了 AST。在 PHP5中，从 php 脚本到 opcodes 的执行的过程是：

Lexing：词法扫描分析，将源文件转换成 token 流；
Parsing：语法分析，在此阶段生成 op arrays。
PHP7 中在语法分析阶段不再直接生成 op arrays，而是先生成 AST，所以过程多了一步：

Lexing：词法扫描分析，将源文件转换成 token 流；
Parsing：语法分析，从 token 流生成抽象语法树；
Compilation：从抽象语法树生成 op arrays。
执行时间和内存消耗

从以上的步骤来看，这比之前的过程还多了一步，所以按常理来说这反而会增加程序的执行时间和内存的使用。但事实上内存的使用确实增加了，但是执行时间上却有所降低。

以下结果是使用小（代码大约 100 行）、中（大约 700 行）、大（大约 2800 行）三个脚本分别进行测试得到的，测试脚本： https://gist.github.com/nikic/289b0c7538b46c2220bc .

每个文件编译 100 次的执行时间（注意文章的测试结果时间是 14 年，PHP7 还叫 PHP-NG 的时候）：

php-ng php-ast diff
SMALL 0.180s 0.160s -12.5%
MEDIUM 1.492s 1.268s -17.7%
LARGE 6.703s 5.736s -16.9%
单次编译中的内存峰值：

php-ng php-ast diff
SMALL 378kB 414kB +9.5%
MEDIUM 507kB 643kB +26.8%
LARGE 1084kB 1857kB +71.3%
单次编译的测试结果可能并不能代表实际使用的情况，以下是使用 PhpParser 进行完整项目测试得到的结果：

php-ng php-ast diff
TIME 25.5ms 22.8ms -11.8%
MEMORY 2360kB 2482kB +5.1%
测试表明，使用 AST 之后程序的执行时间整体上大概有 10% 到 15% 的提升，但是内存消耗也有增加，在大文件单次编译中增加明显，但是在整个项目执行过程中并不是很严重的问题。

还有注意的是以上的结果都是在没有 Opcache 的情况下，生产环境中打开 Opcache 的情况下，内存的消耗增加也不是很大的问题。

语义上的改变

如果仅仅是时间上的优化，似乎也不是使用 AST 的充足理由。其实实现 AST 并不是基于时间优化上的考虑，而是为了解决语法上的问题。下面来看一下语义上的一些变化。

yield 不需要括号

在 PHP5 的实现中，如果在一个表达式上下文（例如在一个赋值表达式的右侧）中使用 yield，你必须在 yield 申明两边使用括号：

<?php
$result = yield fn();   // 不合法的
$result = (yield fn()); // 合法的
这种行为仅仅是因为 PHP5 的实现方式的限制，在 PHP7 中，括号不再是必须的了。所以下面这些写法也都是合法的：

<?php
$result = yield;
$result = yield $v;
$result = yield $k => $v;
当然了，还得遵循 yield 的应用场景才行。

括号不影响行为

在 PHP5 中， ($foo)['bar'] = 'baz' 和 $foo['bar'] = 'baz' 两个语句的含义不一样。事实上前一种写法是不合法的，你会得到下面这样的错误：

<?php
($foo)['bar'] = 'baz';
# PHP Parse error: Syntax error, unexpected '[' on line 1
但是在 PHP7 中，两种写法表示同样的意思。

同样，如果函数的参数被括号包裹，类型检查存在问题，在 PHP7 中这个问题也得到了解决：

<?php
function func() {
    return [];
}

function byRef(array &$a) {
}

byRef((func()));
以上代码在 PHP5 中不会告警，除非使用 byRef(func()) 的方式调用，但是在 PHP7 中，不管 func() 两边有没有括号都会产生以下错误：

PHP Strict standards:  Only variables should be passed by reference ...
list() 的变化

list 关键字的行为改变了很多。list 给变量赋值的顺序（等号左右同时的顺序）以前是从右至左，现在是从左到右：

<?php
list($array[], $array[], $array[]) = [1, 2, 3];
var_dump($array);

// PHP5: $array = [3, 2, 1]
// PHP7: $array = [1, 2, 3]

# 注意这里的左右的顺序指的是等号左右同时的顺序，
# list($a, $b) = [1, 2] 这种使用中 $a == 1, $b == 2 是没有疑问的。
产生上面变化的原因正是因为在 PHP5 的赋值过程中， 3 会最先被填入数组， 1 最后，但是现在顺序改变了。

同样的变化还有：

<?php
$a = [1, 2];
list($a, $b) = $a;

// PHP5: $a = 1, $b = 2
// PHP7: $a = 1, $b = null + "Undefined index 1"
这是因为在以前的赋值过程中 $b 先得到 2 ，然后 $a 的值才变成 1 ，但是现在 $a 先变成了 1 ，不再是数组，所以 $b 就成了 null 。

list 现在只会访问每个偏移量一次：

<?php
list(list($a, $b)) = $array;

// PHP5:
$b = $array[0][1];
$a = $array[0][0];

// PHP7:
// 会产生一个中间变量，得到 $array[0] 的值
$_tmp = $array[0];
$a = $_tmp[0];
$b = $_tmp[1];
空的 list 成员现在是全部禁止的，以前只是在某些情况下：

<?php
list() = $a;           // 不合法
list($b, list()) = $a; // 不合法
foreach ($a as list()) // 不合法 (PHP5 中也不合法)
引用赋值的顺序

引用赋值的顺序在 PHP5 中是从右到左的，现在时从左到右：

<?php
$obj = new stdClass;
$obj->a = &$obj->b;
$obj->b = 1;
var_dump($obj);

// PHP5:
object(stdClass)#1 (2) {
  ["b"] => &int(1)
  ["a"] => &int(1)
}

// PHP7:
object(stdClass)#1 (2) {
  ["a"] => &int(1)
  ["b"] => &int(1)
}
__clone 方法可以直接调用

现在可以直接使用 $obj->__clone() 的写法去调用 __clone 方法。 __clone 是之前唯一一个被禁止直接调用的魔术方法，之前你会得到一个这样的错误：

Fatalerror:Cannotcall__clone()methodonobjects-use'clone $obj'insteadin...
变量语法一致性

AST 也解决了一些语法一致性的问题，这些问题是在另外一个 RFC 中被提出的： https://wiki.php.net/rfc/uniform_variable_syntax .

在新的实现上，以前的一些语法表达的含义和现在有些不同，具体的可以参照下面的表格：

Expression PHP5 PHP7
$$foo[‘bar’][‘baz’] ${$foo[‘bar’][‘baz’]} ($$foo)[‘bar’][‘baz’]
$foo->$bar[‘baz’] $foo->{$bar[‘baz’]} ($foo->$bar)[‘baz’]
$foo->$bar[‘baz’]() $foo->{$bar[‘baz’]}() ($foo->$bar)[‘baz’]()
Foo::$bar[‘baz’]() Foo::{$bar[‘baz’]}() (Foo::$bar)[‘baz’]()
整体上还是以前的顺序是从右到左，现在从左到右，同时也遵循括号不影响行为的原则。这些复杂的变量写法是在实际开发中需要注意的。

构造函数意思就是在类执行时通过构造函数作为入口进行操作了，我们下面来看一篇关于php构造函数用法吧。

构造函数 和 析构函数

构造函数

void __construct ([ mixed $args [, $... ]] )
PHP 5 允行开发者在一个类中定义一个方法作为构造函数。具有构造函数的类会在每次创建新对象时先调用此方法，所以非常适合在使用对象之前做一些初始化工作。

Note: 如果子类中定义了构造函数则不会隐式调用其父类的构造函数。要执行父类的构造函数，需要在子类的构造函数中调用 parent::__construct()。如果子类没有定义构造函数则会如同一个普通的类方法一样从父类继承（假如没有被定义为 private 的话）。

Example #1 使用新标准的构造函数

<?php
class BaseClass {
  //我是一个父亲的构造函数
   function __construct() {
       print "In BaseClass constructor<br>";
   }
}
 
//我是一个孩子类
class SubClass extends BaseClass {
   function __construct() {//孩子的构造函数
       parent::__construct(); //我执行一次父亲的构造函数先。
       print "In SubClass constructor<br>";
   }
}
 
//我是个孩子，但是我没有自己的构造函数，所以我自动用我父亲的
class OtherSubClass extends BaseClass {
    // inherits BaseClass's constructor
}
 
//我是个孩子，我有自己的构造函数，抛弃父亲的。所以我不执行父亲的构造函数的打印
class OtherSub2Class extends BaseClass {
    // inherits BaseClass's constructor
    function __construct() {//孩子的构造函数
       print "In OtherSub2Class constructor<br>";
   }
}
 
// In BaseClass constructor
$obj = new BaseClass();
 
// In BaseClass constructor
// In SubClass constructor
$obj = new SubClass();
 
// In BaseClass constructor
$obj = new OtherSubClass();
 
$obj = new OtherSub2Class();
 
?>
为了实现向后兼容性，如果 PHP 5 在类中找不到 __construct() 函数并且也没有从父类继承一个的话，它就会尝试寻找旧式的构造函数，也就是和类同名的函数。因此唯一会产生兼容性问题的情况是：类中已有一个名为 __construct()的方法却被用于其它用途时。

与其它方法不同，当 __construct() 被与父类 __construct() 具有不同参数的方法覆盖时，PHP 不会产生一个 E_STRICT错误信息。

自 PHP 5.3.3 起，在命名空间中，与类名同名的方法不再作为构造函数。这一改变不影响不在命名空间中的类。

Example #2 Constructors in namespaced classes

<?php
namespace Foo;
class Bar {
    public function Bar() {
        // treated as constructor in PHP 5.3.0-5.3.2
        // treated as regular method as of PHP 5.3.3
    }
}
?>
析构函数

void __destruct ( void )
PHP 5 引入了析构函数的概念，这类似于其它面向对象的语言，如 C++。析构函数会在到某个对象的所有引用都被删除或者当对象被显式销毁时执行。

在 php 文件完全执行完毕，这个类会进入销毁，执行一次析构函数，和构造函数，正好相反，构造函数是在创建类的时候进入执行

Example #3 析构函数示例

<?php
class MyDestructableClass {
   function __construct() {
       print "In constructor<br>";
       $this->name = "MyDestructableClass";
   }
 
   function __destruct() {
       print "Destroying " . $this->name . "<br>";
   }
}
 
$obj = new MyDestructableClass();
echo 'i write something <br>';
 
?>
输出

In constructor
i write something
Destroying MyDestructableClass
和构造函数一样，父类的析构函数不会被引擎暗中调用。要执行父类的析构函数，必须在子类的析构函数体中显式调用 parent::__destruct()。此外也和构造函数一样，子类如果自己没有定义析构函数则会继承父类的。

析构函数即使在使用 exit() 终止脚本运行时也会被调用。在析构函数中调用 exit() 将会中止其余关闭操作的运行。

Note:

析构函数在脚本关闭时调用，此时所有的 HTTP 头信息已经发出。脚本关闭时的工作目录有可能和在 SAPI（如 apache）中时不同。

Note:

试图在析构函数（在脚本终止时被调用）中抛出一个异常会导致致命错误。

时间戳在php中可以精确到秒了,那么我们今天要给各位举例子是关于今天的时间戳计算哦,具体的我们一起来看看这篇关于 PHP获取今天开始和结束的时间戳例子吧.

例子

$t = time();

//开始时间戳

$start = mktime(0,0,0,date("m",$t),date("d",$t),date("Y",$t));

//结束时间戳

$end = mktime(23,59,59,date("m",$t),date("d",$t),date("Y",$t));
mktime 函数的定义和具体用法记录一下

语法

mktime(hour,minute,second,month,day,year,is_dst)

例子 今日、昨日、上周、本月的起始时间戳和结束时间戳

//开始时间截
$start=mktime(0,0,0,date(“m”),date(“d”),date(“Y”));
//结束时间截：
$end=mktime(0,0,0,date(‘m’),date(‘d’)+1,date(‘Y’))-1;
//php获取昨日起始时间戳和结束时间戳
$beginYesterday=mktime(0,0,0,date(‘m’),date(‘d’)-1,date(‘Y’));
$endYesterday=mktime(0,0,0,date(‘m’),date(‘d’),date(‘Y’))-1;
//php获取上周起始时间戳和结束时间戳
$beginLastweek=mktime(0,0,0,date(‘m’),date(‘d’)-date(‘w’)+1-7,date(‘Y’));
$endLastweek=mktime(23,59,59,date(‘m’),date(‘d’)-date(‘w’)+7-7,date(‘Y’));
//php获取本月起始时间戳和结束时间戳
$beginThismonth=mktime(0,0,0,date(‘m’),1,date(‘Y’));
$endThismonth=mktime(23,59,59,date(‘m’),date(‘t’),date(‘Y’));

定义和用法

mktime() 函数返回一个日期的 Unix 时间戳。

参数总是表示 GMT 日期，因此 is_dst 对结果没有影响。

参数可以从右到左依次空着，空着的参数会被设为相应的当前 GMT 值。