php的字串管理 zend_string

#                                                

##字串管理：zend_string

任何程式中需要管理字串。在這裡，我們將詳細介紹適合 PHP 需求的自訂解決方案：

zend_string。每次 PHP 需要使用字串時，都會使用 zend_string 結構。這個結構只是 C 語言的 char * 字串類型的簡單精簡包裝。

它添加了記憶體管理的功能，所以同一字串可以在多個地方共享，而無需重複。另外，一些字串是“內部的”，即“持久的”分配，並透過記憶體管理特殊管理，以便它們不會在多個請求中被銷毀。之後，那些從Zend 記憶體管理獲得永久分配。

相關學習推薦：

PHP程式設計從入門到精通

#結構與存取巨集

這裡是簡單的

zend_string結構：

struct _zend_string {
        zend_refcounted_h gc;
        zend_ulong        h;
        size_t            len;
        char              val[1];
};

如你所見，該結構嵌入了一個 

zend_refcounted_h 標頭。這個是記憶體管理和引用需要用到的。由於該字串很有可能作為哈希表檢查的關鍵字，因此它在 h字段中嵌入了其哈希值。這是無符號長整型 zend_ulong。只有在需要對 zend_string 進行哈希處理時會用到，特別是和哈希表：zend_array一起用時。這很有可能。

如你所知，字串知道其長度為 

len 字段，以支援「二進位字串。二進位字串是嵌入一個或多個 NUL 字符（\0）的字串。當傳遞給函式庫函數，那些字串會被截斷，否則無法正確計算其長度。所以在 zend_string 中，字串的長度總是已知的。請請注意，該長度計算的ASCII 字元（位元組），不計算最後的NUL，而是計算最終的中間的NUL。例如，字串“foo” 在 zend_string 中儲存為“foo\0”，且它的長度為3。另外，字串“foo\0bar” 將儲存為“foo\0bar\0”，且其長度為7。

最終，該字元儲存在 

char[1]。這不是 char *，而是 char[1]。為什麼？這是一種稱為「C struct hack 」 的記憶體最佳化（你可以使用帶有這些術語的搜尋引擎）。基本上，它允許引擎為 zend_string 結構和要儲存的字元分配空間，作為一個單獨的C 指標。這優化了內存，因為內存存取將是一個連續分配的區塊，而不是兩個分散的區塊（一個用於存儲 zend_string *，另一個用於存儲char *）。

必須記住這種struct hack，由於記憶體佈局看起來像C 字元位於C 

zend_string 結構的末尾，因此當使用C 偵錯器（或調試字串）時可能會感覺到/看到過。該hack 是完全由API 管理，當你操作zend_string結構時會用到。

使用zend_string API

簡單用例

像Zvals，你不需要手動操作 

zend_string 內部字段，而總是為此使用巨集。還存在觸發字串操作的巨集。這並不是函數，而是宏，都儲存在必需的Zend/zend_string.h 頭檔：

zend_string *str;

str = zend_string_init("foo", strlen("foo"), 0);
php_printf("This is my string: %s\n", ZSTR_VAL(str));
php_printf("It is %zd char long\n", ZSTR_LEN(str));

zend_string_release(str);

上面簡單的例子為你展示了基本的字串管理。應該為

zend_string_init() 函數（實際上是宏，但先讓我們忽略它）給出完整的 char * C 字串和它的長度。類型為int 的最後一個參數應該是0 或1。如果傳遞0，則要求引擎透過Zend 記憶體管理使用請求綁定的堆分配。這種分配在當前請求結束後時銷毀。如果你不這麼做，則在偵錯版本中，引擎會提醒你記憶體洩漏。如果傳遞1，則要求了所謂的「持久」分配，引擎將使用傳統的 C malloc() 調用，並且不會以任何方式追蹤記憶體分配。

注意

如果你需要更多有關記憶體管理的信息，你可以閱讀專用章節。

然后，我们来显示字符串。我们使用 ZSTR_VAL() 宏访问字符数组。ZSTR_LEN() 允许访问长度信息。zend_string 相关宏都以 ZSTR_**() 开始，注意和 Z_STR**() 宏不一样。

注意

长度使用 size_t 类型存储，为了显示它，printf() 必须使用 “%zd”。你应该总是使用正确的printf()格式。否则可能会导致应用程序崩溃或创建安全问题否则可能会导致内存泄漏和。有关 printf() 格式的详细信息，请访问此链接

最后，我们使用 zend_string_release()释放字符串。该释放是强制的。这与内存管理有关。“释放”是一个简单的操作：字符串的引用计数递减，如果减到0，API会为你释放字符串。如果忘记释放字符串，则很可能造成内存泄漏。

注意

在 C 语言中，你必须总是考虑内存管理。如果你分配——不管是直接使用 malloc()，或者使用能为你这样做的 API，在某些时候你必须使用 free()。否则可能会导致内存泄漏，并转换为任何人都不能安全使用的糟糕设计程序。 

玩转 hash

如果你需要访问哈希值，可使用 ZSTR_H()。但创建 zend_string 时，不会自动计算其哈希值。而当将该字符串与 HashTable API 一起使用时，它将为你完成。如果你强制立即计算哈希值，可使用 ZSTR_HASH() 或 zend_string_hash_val()。当哈希值被计算出来，它会被保存起来并且不再被计算。无论如何，你必须使用  zend_string_forget_hash_val() 重新计算——因为你改变了字符串的值：

zend_string *str;

str = zend_string_init("foo", strlen("foo"), 0);
php_printf("This is my string: %s\n", ZSTR_VAL(str));
php_printf("It is %zd char long\n", ZSTR_LEN(str));

zend_string_hash_val(str);
php_printf("The string hash is %lu\n", ZSTR_H(str));

zend_string_forget_hash_val(str);
php_printf("The string hash is now cleared back to 0!");

zend_string_release(str);

字符串复制和内存管理

 zend_string API 的一个非常棒的特性是：允许某部分通过简单的声明“拥有”字符串。引擎不会在内存复制字符串，而是递增其引用计数（作为字符串zend_refcounted_h 的一部分）。这允许在代码的多个地方共享一个内存。

由此，当我们讨论“复制”一个 zend_string 时，实际上并没有复制内存中的任何东西。如果需要（这仍是可能的操作），之后我们来讨论“复制”字符串。开始吧：

zend_string *foo, *bar, *bar2, *baz;

foo = zend_string_init("foo", strlen("foo"), 0); /* 创建变量foo，值为“foo” */
bar = zend_string_init("bar", strlen("bar"), 0); /* 创建变量bar，值为"bar" */

/* 创建变量bar2，共享变量bar的值。
  另外递增"bar"字符串的引用计数到2 */
bar2 = zend_string_copy(bar);

php_printf("We just copied two strings\n");
php_printf("See : bar content : %s, bar2 content : %s\n", ZSTR_VAL(bar), ZSTR_VAL(bar2));

/* 在内存中复制"bar"字符串，创建变量 baz，
使 baz 单独拥有新创建的"bar"字符串 */
baz = zend_string_dup(bar, 0);

php_printf("We just duplicated 'bar' in 'baz'\n");
php_printf("Now we are free to change 'baz' without fearing to change 'bar'\n");

/* 更改第二个"bar"字符串的最后一个字符，
变为"baz" */
ZSTR_VAL(baz)[ZSTR_LEN(baz) - 1] = 'z';

/* 当字符串改变时，忘记旧哈希值（如果已计算），
因此其哈希值必须更改并重新计数 */
zend_string_forget_hash_val(baz);

php_printf("'baz' content is now %s\n", ZSTR_VAL(baz));

zend_string_release(foo);  /* 销毁（释放）"foo"字符串 */
zend_string_release(bar);  /* 递减"bar"字符串的引用计数到1 */
zend_string_release(bar2); /* 销毁（释放）bar和bar2变量中的"bar"字符串 */
zend_string_release(baz);  /* 销毁（释放）"baz"字符串 */

我们一开始仅分配 “foo” 和 “bar”。然后，我们创建 bar的副本到bar2字符串。这里，必须记住：在内存中，bar 和 bar2 指向同一 C 字符串，更改一个将更改第二个。这是 zend_string_copy() 行为：它仅递增 C 字符串的引用计数。

如果想要分离字符串，即想在内存中拥有该字符串的两个不同副本，我们必须使用 zend_string_dup()复制。然后我们将 bar2 变量字符串复制到 baz 变量。现在，baz 变量嵌入它的字符串副本，并且可以改变它而不影响 bar2 。这就是我们要做的：我们用‘z’改变了‘bar’最后的‘r’，之后，我们显示它，并释放所有字符串。

注意，我们忘记哈希值（如果它在之前已经计算，则不需要考虑其细节）。这是一个值得记住的好习惯。就像我们曾说过，如果 zend_string 作为 HashTables 的一部分，则使用哈希值。这在开发中是很常见的，并且改变字符串的值必须重新计算哈希值。忘记这一步骤将导致可能需要花一些时间去追踪错误。

字符串操作

zend_string API 允许其他操作，例如扩展或缩小字符串，更改大小写或比较字符串。目前尚未有连接字符串操作，但是很容易执行：

zend_string *FOO, *bar, *foobar, *foo_lc;

FOO = zend_string_init("FOO", strlen("FOO"), 0);
bar = zend_string_init("bar", strlen("bar"), 0);

/* 将 zend_string 与 C 字符串文字进行比较 */
if (!zend_string_equals_literal(FOO, "foobar")) {
    foobar = zend_string_copy(FOO);

    /* realloc() 将 C 字符串分配到更大的缓冲区 */
    foobar = zend_string_extend(foobar, strlen("foobar"), 0);

    /* 在重新分配的足够大的“FOO”之后，连接"bar" */
    memcpy(ZSTR_VAL(foobar) + ZSTR_LEN(FOO), ZSTR_VAL(bar), ZSTR_LEN(bar));
}

php_printf("This is my new string: %s\n", ZSTR_VAL(foobar));

/* 比较两个 zend_string */
if (!zend_string_equals(FOO, foobar)) {
    /*复制字符串并改为小写*/
    foo_lc = zend_string_tolower(foo);
}

php_printf("This is FOO in lower-case: %s\n", ZSTR_VAL(foo_lc));

/* 释放内存 */
zend_string_release(FOO);
zend_string_release(bar);
zend_string_release(foobar);
zend_string_release(foo_lc);

使用 zval 访问 zend_string

现在你知道如何管理和操作 zend_string，让我们看看它们与 zval 容器的互动。

注意

你必须熟悉 zval，如果不熟悉，阅读Zvals专用章节。

宏将允许你将 zend_string 存储到 zval，或从 zval 读取 zend_string：

zval myval;
zend_string *hello, *world;

zend_string_init(hello, "hello", strlen("hello"), 0);

/* 存储字符串到 zval */
ZVAL_STR(&myval, hello);

/* 从 zval 的 zend_string 中读取 C 字符串 */
php_printf("The string is %s", Z_STRVAL(myval));

zend_string_init(world, "world", strlen("world"), 0);

/* 将 zend_string 更改为 myval：将其替换为另一个 */
Z_STR(myval) = world;

/* ... */

你必须记住的是，以ZSTR_***(s)开头的每个宏都会作用到 zend_string。

• ZSTR_VAL()
• ZSTR_LEN()
• ZSTR_HASH()
• …

每个以 Z_STR**(z) 开头的宏都会作用于嵌入到 zval 中的 zend_string 。

• Z_STRVAL()
• Z_STRLEN()
• Z_STRHASH()
• …

还有一些你可能不需要的东西也存在。

PHP 的历史和经典的 C 字符串

简单介绍一下。在 C 语言中，字符串是字符数组（char foo[]）或者指向字符的指针（char *）。它们并不知道其长度，这就是它们为什么末尾是 NUL（知道字符串的开始和结尾，就可以知道它的长度）。

在 PHP 7 之前，zend_string 结构还未出现。在那时，还是使用传统的 char * / int。你可能仍会在 PHP 源代码中找到使用了罕见的 char * / int，而不是 zend_string。你也可能发现 API 功能，可以一边使用 zend_string，另一边使用 char * / int来交互。

在任何可能的地方：使用 zend_string。那些罕见的没有使用 zend_string 的地方，是因为在那里使用它们并没有什么意义，但是你仍会发现在 PHP 源代码中有很多对 zend_string 的引用。

Interned zend_string

在这里简单的介绍一下 interned 字符串。你在扩展开发中应该需要这样的概念。Interned 字符串也和 OPCache 扩展交互。

Interned 字符串是去重复的字符串。当与 OPCache 一起使用时，它还可以在请求之间循环使用。

假设你想要创建字符串“foo”。你更想做的是简单地创建一个新字符串“foo”：

zend_string *foo;
foo = zend_string_init("foo", strlen("foo"), 0);

/* ... */

但是有一个问题：字符串是不是在你需要之前已经创建了？当你需要一个字符串时，你的代码会在PHP生命中的某个时刻执行，这意味着在你需要完全相同的字符串（在我们的示例中为“ foo”）之前发生了一些代码。

Interned 字符串是关于要求引擎去探查 interned 字符串存储，并且如果它能找到你的字符串，会重用已经分配的指针。如果没有找到：创建一个新的字符串并“intern” 它，这使得它可用于 PHP 源代码的其他部分（其他扩展，引擎本身等）。

这里有个例子：

zend_string *foo;
foo = zend_string_init("foo", strlen("foo"), 0);

foo = zend_new_interned_string(foo);

php_printf("This string is interned : %s", ZSTR_VAL(foo));

zend_string_release(foo);

上面的代码创建了一个非常经典的新 zend_string 。然后，我们将创建的 zend_string 传递给 zend_new_interned_string()。该函数在引擎 interned 字符串缓冲区查找相同的字符串（这里是“foo”）。如果找到它（意味着有人已经创建了这样的字符串），那么它将释放你的字符串（可能释放它），并且用 interned 字符串缓冲区中的字符串替代它。如果找不到：它将被添加到 interned 字符串缓冲区，使它在将来可使用或可用于 PHP 的其他部分。

你必须注意内存分配。Interned 字符串总是将 refcount 设为1，因为它们不必被引用，由于它们会和 interned 字符串缓冲区共享，因此不可被销毁。

例：

zend_string *foo, *foo2;

foo  = zend_string_init("foo", strlen("foo"), 0);
foo2 = zend_string_copy(foo); /* 递增 foo 的引用计数 */

 /* 引用计数退回 1，即使现在字符串在三个不同的地方被使用 */
foo = zend_new_interned_string(foo);

/* 这没有任何作用，因为 foo 是 interned */
zend_string_release(foo);

/*  这没有任何作用，因为 foo2 是 interned*/
zend_string_release(foo2);

/* 在流程结束时，PHP 将清除它的 interned 字符串缓冲区，
  因此 free() 我们 "foo" 字符串本身 */

这都是关于垃圾收集的。

当字符串是 interned，更改其 GC 标志以添加  IS_STR_INTERNED 标志，不管使用的是什么内存分配类（基于永久或基于请求）。当你想要复制或释放字符串，都会检查该标志。如果是 interned 字符串，当你复制该字符串时，引擎不会递增它的引用计数。但是如果你释放字符串，它也不会递减或释放它。它不做任何事情。在进程生命周期的最后，它会销毁它的 interned 字符串缓冲区，并且释放你的 interned 字符串。

事实上，此过程比这更为复杂。如果你使用的是请求处理中的 interned 字符串，那么该字符串肯定被 interned。但是，如果你是在 PHP 处理一个请求时使用 interned 字符串，那么该字符串只会在当前请求被 interned，并在之后会清理掉。如果你不使用 OPCache 扩展，那这一切都是有效的，有时你不应该使用它。

当使用 OPCache 扩展，如果你使用请求处理中的 interned 字符串，那么该字符串肯定被 interned ，并且和并行产生的每个 PHP 的进程或线程共享。另外，如果当你处理一个请求时使用 interned 字符串，该字符串也将由 OPCache 本身进行 interned，并且共享给并行产生的每个 PHP 进程或线程。

然後，在觸發 OPCache 擴充時，會變更 Interned 字串機制。 OPCache 不僅允許從請求來的 interned 字串，而且允許將它們共用給同一池的每個 PHP 進程。這樣做是使用了共享記憶體。當儲存一個 interned 字串時，OPCache 也會加入 IS_STR_PERMANENT 標誌到它的 GC 資訊。此標誌表示用於結構（這裡是zend_string）的記憶體分配是永久的，它可以是共享的唯讀記憶體段。

Interned 字串可節省內存，因為在記憶體中，同樣的字串不會再儲存。但是當它經常需要查找 interned 字串儲存時，可能會浪費一些 CPU 時間，即使該進程如今已經最佳化了。作為擴展設計師，這是全域規則：

• 如果使用了 OPCache（應該會），並且需要建立唯讀字串：請使用 interned 字串。
• 如果你需要的字串是你確切知道 PHP 會有的 interned（眾所周知的 PHP 字串，例如「php」 或 “str_replace”）， 請使用 interned 字串。
• 如果字串不是唯讀，且在建立之後可以/應該修改，請不要使用 interned 字串。
• 如果字串在未來不太可能被重複使用，請不要使用 interned 字串。

警告

不要試圖修改（寫入）一個 interned 字串，否則很可能會崩潰。

Interned 字串詳情請看 Zend/zend_string.c。

以上是php的字串管理 zend_string的詳細內容。更多資訊請關注PHP中文網其他相關文章！