Jedes Programm muss Strings verwalten. Hier beschreiben wir eine individuelle Lösung für Ihre PHP-Anforderungen: zend_string. Jedes Mal, wenn PHP mit einer Zeichenfolge arbeiten muss, verwendet es die Struktur zend_string. Diese Struktur ist einfach eine dünne Hülle um den String-Typ char * der C-Sprache.
Es fügt Speicherverwaltungsfunktionen hinzu, sodass dieselbe Zeichenfolge ohne Duplizierung an mehreren Stellen gemeinsam genutzt werden kann. Darüber hinaus werden einige Strings „intern“, d. h. „persistent“, zugewiesen und von der Speicherverwaltung speziell verwaltet, damit sie nicht über mehrere Anfragen hinweg zerstört werden. Danach erhalten diese eine dauerhafte Zuweisung durch die Zend-Speicherverwaltung.
Verwandte Lernempfehlungen: PHP-Programmierung vom Anfänger bis zum Experten
Hier ist es einfachzend_stringStruktur:
struct _zend_string {
zend_refcounted_h gc;
zend_ulong h;
size_t len;
char val[1];
};Wie Sie sehen können, hat diese Struktur einen eingebetteten zend_refcounted_h-Header. Dies wird für die Speicherverwaltung und Referenzen benötigt. Da dieser String am wahrscheinlichsten als Schlüssel für eine Hash-Tabellenprüfung verwendet wird, bettet er seinen Hash-Wert in das Feld h ein. Dies ist ein unsigned long zend_ulong. Es wird nur verwendet, wenn Hashing zend_string erforderlich ist, insbesondere bei Verwendung mit der Hash-Tabelle: zend_array. Das ist sehr gut möglich.
Wie Sie wissen, kennt eine Zeichenfolge ihre Länge als len-Feld, um „binäre Zeichenfolgen“ zu unterstützen. Eine binäre Zeichenfolge besteht aus einem oder mehreren darin eingebetteten NUL-Zeichen (
然后，我们来显示字符串。我们使用 ZSTR_VAL() 宏访问字符数组。ZSTR_LEN() 允许访问长度信息。zend_string 相关宏都以 ZSTR_**() 开始，注意和 Z_STR**() 宏不一样。
注意
长度使用
size_t类型存储，为了显示它，printf()必须使用 “%zd”。你应该总是使用正确的printf()格式。否则可能会导致应用程序崩溃或创建安全问题否则可能会导致内存泄漏和。有关printf()格式的详细信息，请访问此链接
最后，我们使用 zend_string_release()释放字符串。该释放是强制的。这与内存管理有关。“释放”是一个简单的操作：字符串的引用计数递减，如果减到0，API会为你释放字符串。如果忘记释放字符串，则很可能造成内存泄漏。
注意
在 C 语言中，你必须总是考虑内存管理。如果你分配——不管是直接使用
malloc()，或者使用能为你这样做的 API，在某些时候你必须使用free()。否则可能会导致内存泄漏，并转换为任何人都不能安全使用的糟糕设计程序。
如果你需要访问哈希值，可使用 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);现在你知道如何管理和操作 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()还有一些你可能不需要的东西也存在。
简单介绍一下。在 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 字符串。你在扩展开发中应该需要这样的概念。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 进程或线程。
Wenn dann die OPCache-Erweiterung ausgelöst wird, wird der Interned-String-Mechanismus geändert. OPCache ermöglicht nicht nur interne Strings aus Anfragen, sondern auch deren gemeinsame Nutzung für jeden PHP-Prozess im selben Pool. Dies geschieht über Shared Memory. Beim Speichern einer internierten Zeichenfolge fügt OPCache auch das Flag IS_STR_PERMANENT zu seinen GC-Informationen hinzu. Dieses Flag zeigt an, dass die Speicherzuweisung für die Struktur (hier zend_string) dauerhaft ist, wobei es sich um ein gemeinsam genutztes schreibgeschütztes Speichersegment handeln kann.
Internierte Zeichenfolgen sparen Speicher, da dieselbe Zeichenfolge nicht erneut im Speicher gespeichert wird. Wenn jedoch häufig nach internem String-Speicher gesucht werden muss, kann dies zu einer Verschwendung von CPU-Zeit führen, obwohl der Prozess jetzt optimiert ist. Als Erweiterungsdesigner ist dies eine globale Regel:
Warnung
Versuchen Sie nicht, eine internierte Zeichenfolge zu ändern (zu schreiben), da sie sonst wahrscheinlich abstürzt.
Details zu internierten Strings finden Sie unter Zend/zend_string.c.
Das obige ist der detaillierte Inhalt vonPHP-String-Verwaltung zend_string. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
So öffnen Sie eine PHP-Datei
So entfernen Sie die ersten paar Elemente eines Arrays in PHP
Was tun, wenn die PHP-Deserialisierung fehlschlägt?
So verbinden Sie PHP mit der MSSQL-Datenbank
So verbinden Sie PHP mit der MSSQL-Datenbank
So laden Sie HTML hoch
So lösen Sie verstümmelte Zeichen in PHP
So öffnen Sie PHP-Dateien auf einem Mobiltelefon
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
