QByteArray Class

成员函数文档

[constexpr noexcept] QByteArray::QByteArray()

构建一个空字节数组。

另请参阅 isEmpty()。

[explicit, since 6.8] QByteArray::QByteArray(QByteArrayView v)

构建一个用字节数组视图的数据初始化的字节数组。

当且仅当 `v ` 为空时，`QByteArray` 才会为空。

该函数在 Qt 6.8 中引入。

QByteArray::QByteArray(const char *data, qsizetype size = -1)

构建一个字节数组，其中包含数组data 的前size 个字节。

如果data 为 0，则构建一个空字节数组。

如果size 为负数，则假定data 指向一个以 '\0' 结尾的字符串，并动态确定其长度。

QByteArray 会对字符串数据进行深度复制。

另请参阅 fromRawData()。

QByteArray::QByteArray(qsizetype size, Qt::Initialization)

构建一个大小为size 、内容未初始化的字节数组。

例如：

QByteArray buffer(123, Qt::Uninitialized);

QByteArray::QByteArray(qsizetype size, char ch)

构建一个大小为size 的字节数组，其中每个字节均设置为ch 。

另请参阅 fill()。

[noexcept] QByteArray::QByteArray(const QByteArray &other)

构建other 的副本。

此操作耗时为常数时间，因为 QByteArray 是隐式共享的。这使得从函数中返回一个 QByteArray 非常快。如果修改了共享的实例，则会进行复制（写时复制），耗时为线性时间。

另请参阅 operator=()。

[noexcept default] QByteArray::QByteArray(QByteArray &&other)

通过“move”操作构造一个 QByteArray 实例，使其指向与 `other ` 所指向的同一对象。

[noexcept] QByteArray::~QByteArray()

销毁该字节数组。

QByteArray &QByteArray::append(const QByteArray &ba)

将字节数组ba 追加到该字节数组的末尾。

示例：

QByteArray x("free");
QByteArray y("dom");
x.append(y);
// x == "freedom"

这与 insert(size(),ba) 的效果相同。

注意：QByteArray 是一个隐式共享类。因此，如果将数据追加到一个空的字节数组中，则该字节数组将直接共享ba 中存储的数据。在这种情况下，不会进行数据复制，耗时为常数时间。如果修改了共享实例，则会进行复制（写时复制），耗时为线性时间。

如果要追加数据的字节数组不为空，则会执行数据的深度复制，耗时为线性时间。

append() 函数通常非常快（常数时间），因为QByteArray 会在数据末尾预先分配额外的空间，因此可以在无需每次重新分配整个数组的情况下进行扩展。

另请参阅 operator+=()、prepend() 和insert()。

QByteArray &QByteArray::append(QByteArrayView data)

将data 追加到该字节数组中。

QByteArray &QByteArray::append(char ch)

将字节ch 追加到此字节数组中。

QByteArray &QByteArray::append(const char *str)

将以“\0 ”结尾的字符串str 追加到此字节数组中。

QByteArray &QByteArray::append(const char *str, qsizetype len)

将从str 开始的最初len 个字节追加到此字节数组中，并返回对此字节数组的引用。追加的字节可能包含 '\0' 字节。

如果len 为负数，则会将str 视为以 '\0' 结尾的字符串，并通过qstrlen() 自动确定要复制的长度。

如果len 为零或str 为空，则不会向字节数组追加任何内容。请确保len 的长度不超过 str 。

QByteArray &QByteArray::append(qsizetype count, char ch)

将字节ch 的count 个副本追加到此字节数组中，并返回对此字节数组的引用。

如果count 为负数或零，则不会向字节数组追加任何内容。

[since 6.6] QByteArray &QByteArray::assign(QByteArrayView v)

将此字节数组的内容替换为v 的副本，并返回对此字节数组的引用。

该字节数组的大小将等于 `v` 的大小。

只有当 `v ` 的大小超过该字节数组的容量，或者该字节数组是共享的，此函数才会分配内存。

该函数于 Qt 6.6 中引入。

[since 6.6] template <typename InputIterator, QByteArray::if_input_iterator<InputIterator> = true> QByteArray &QByteArray::assign(InputIterator first, InputIterator last)

将此字节数组的内容替换为迭代器范围 [first,last) 中元素的副本，并返回对此字节数组的引用。

该字节数组的大小将等于范围 [first,last) 中的元素个数。

只有当范围中的元素数量超过该字节数组的能力，或者该字节数组是共享的，此函数才会分配内存。

约束

仅当InputIterator 满足LegacyInputIterator 的要求时，才参与重载解析。

该函数在 Qt 6.6 中引入。

[since 6.6] QByteArray &QByteArray::assign(qsizetype n, char c)

将此字节数组的内容替换为n 个c 的副本，并返回对此字节数组的引用。

该字节数组的大小将等于n ，该值必须为非负数。

只有当n 超过该字节数组的大小，或者该字节数组是共享的，此函数才会分配内存。

该函数在 Qt 6.6 中引入。

另请参阅 fill()。

char QByteArray::at(qsizetype i) const

返回字节数组中索引位置为i 的字节。

i 该索引必须是字节数组中的有效索引位置（即 0 <=i <size())。

另请参阅 operator[]()。

char &QByteArray::back()

返回字节数组中最后一个字节的引用。与operator[](size() - 1) 相同。

提供此函数是为了兼容 STL。

另请参阅 front()、at() 和operator[]()。

char QByteArray::back() const

返回字节数组中的最后一个字节。与 `at(size() - 1)` 相同。

提供此函数是为了兼容 STL。

另请参阅 front()、at() 和operator[]()。

QByteArray::iterator QByteArray::begin()

返回一个指向字节数组中第一个字节的STL 风格迭代器。

另请参阅 constBegin() 和end()。

[noexcept] QByteArray::const_iterator QByteArray::begin() const

qsizetype QByteArray::capacity() const

返回字节数组中可存储的最大字节数，且无需强制重新分配内存。

此函数的唯一目的是提供一种微调QByteArray 内存使用情况的方法。通常情况下，您几乎不需要调用此函数。若要了解字节数组中包含多少字节，请调用size()。

另请参阅 ` reserve()` 和 `squeeze()`。

[noexcept] QByteArray::const_iterator QByteArray::cbegin() const

返回一个指向字节数组中第一个字节的常量STL 风格迭代器。

另请参阅 begin() 和cend()。

[noexcept] QByteArray::const_iterator QByteArray::cend() const

返回一个指向字节数组中最后一个字节之后的常量STL 风格迭代器。

另请参阅 cbegin() 和end()。

void QByteArray::chop(qsizetype n)

从字节数组的末尾删除n 字节。

如果n 大于size()，则结果为一个空字节数组。

示例：

QByteArray ba("STARTTLS\r\n");
ba.chop(2);                 // ba == "STARTTLS"

另请参阅 truncate()、resize() 和first()。

返回一个字节数组，其中包含该字节数组最左侧的size() -len 个字节。

另请参见 endsWith()、first()、last()、sliced()、chop()、truncate() 和slice()。

void QByteArray::clear()

清空字节数组的内容并将其设为空。

另请参阅 resize() 和isNull()。

[noexcept, since 6.0] int QByteArray::compare(QByteArrayView bv, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

根据该QByteArray 在排序时位于QByteArrayView bv 之前、与之处于同一位置还是之后，返回小于、等于或大于零的整数。比较操作将根据cs 中规定的大小写敏感性规则进行。

该函数在 Qt 6.0 中引入。

另请参阅 operator== 和Character Case 。

[noexcept] QByteArray::const_iterator QByteArray::constBegin() const

返回一个指向字节数组中第一个字节的常量STL 风格迭代器。

另请参阅 begin() 和constEnd()。

[noexcept] const char *QByteArray::constData() const

返回指向存储在字节数组中的常量数据的指针。该指针可用于访问构成该数组的字节。除非QByteArray 对象是从原始数据创建的，否则数据以'\0'结尾。

只要未发生断开操作且 `QByteArray ` 未被修改，该指针即保持有效。

该函数主要用于将字节数组传递给接受 `const char *` 的函数。

注意：QByteArray 可以存储任何字节值，包括 '\0'，但大多数接受char * 参数的函数都假设数据在遇到第一个 '\0' 时结束。

另请参阅 data()、operator[]()，以及fromRawData()。

[noexcept] QByteArray::const_iterator QByteArray::constEnd() const

返回一个常量STL 风格的迭代器，该迭代器指向字节数组中最后一个字节的下一位置。

另请参阅 constBegin() 和end()。

[since 6.0] bool QByteArray::contains(QByteArrayView bv) const

如果该字节数组中包含由bv 所查看的字节序列，则返回true ；否则返回false 。

该函数在 Qt 6.0 中引入。

另请参阅 indexOf() 和count()。

bool QByteArray::contains(char ch) const

如果字节数组包含字节ch ，则返回true ；否则返回false 。

[since 6.0] qsizetype QByteArray::count(QByteArrayView bv) const

返回bv 在该字节数组中检测到的（可能存在重叠的）字节序列的出现次数。

该函数在 Qt 6.0 中引入。

另请参见 contains() 和indexOf()。

qsizetype QByteArray::count(char ch) const

返回字节数组中字节ch 出现的次数。

另请参阅 contains() 和indexOf()。

[noexcept] QByteArray::const_reverse_iterator QByteArray::crbegin() const

返回一个指向字节数组中第一个字节的、STL 风格的常量反向迭代器，且顺序为逆序。

另请参阅 begin()、rbegin() 和rend()。

[noexcept] QByteArray::const_reverse_iterator QByteArray::crend() const

返回一个常量STL 风格的反向迭代器，该迭代器指向字节数组中最后一个字节之后的第一个位置，且顺序为反向。

另请参阅 end()、rend() 和rbegin()。

char *QByteArray::data()

返回指向存储在字节数组中的数据的指针。该指针可用于访问和修改构成该数组的字节。数据以“\0 ”结尾，即通过返回的指针可访问的字节数为size() + 1，其中包含“\0 ”结尾符。

示例：

QByteArray ba("Hello world");
char *data = ba.data();
while (*data) {
    cout << "[" << *data << "]" << endl;
    ++data;
}

只要未发生分离且未修改QByteArray ，该指针即保持有效。

对于只读访问，constData() 速度更快，因为它不会引发深度复制。

该函数主要用于将字节数组传递给接受const char * 的函数。

以下示例复制了 data() 返回的 char*，但由于未为末尾的 '\0' 分配一个字节，因此会破坏堆并导致崩溃：

QString tmp = "test";
QByteArray text = tmp.toLocal8Bit();
char *data = new char[text.size()];
strcpy(data, text.data());
delete [] data;

而以下代码则分配了正确的空间：

QString tmp = "test";
QByteArray text = tmp.toLocal8Bit();
char *data = new char[text.size() + 1];
strcpy(data, text.data());
delete [] data;

注意：QByteArray 可以存储任何字节值，包括 '\0'，但大多数接受char * 参数的函数都假设数据以遇到的第一个 '\0' 结尾。

另请参阅 constData() 和operator[]()。

[noexcept] const char *QByteArray::data() const

QByteArray::iterator QByteArray::end()

返回一个STL 风格的迭代器，该迭代器指向字节数组中最后一个字节的下一位置。

另请参阅 begin() 和constEnd()。

[noexcept] QByteArray::const_iterator QByteArray::end() const

[since 6.0] bool QByteArray::endsWith(QByteArrayView bv) const

如果该字节数组以bv 所识别的字节序列结尾，则返回true ；否则返回false 。

示例：

QByteArray url("http://qt-project.org/doc/qt-5.0/qtdoc/index.html");
if (url.endsWith(".html"))
    {/*...*/}

该函数自 Qt 6.0 起引入。

另请参阅 startsWith() 和last()。

bool QByteArray::endsWith(char ch) const

如果该字节数组以字节ch 结尾，则返回true ；否则返回false 。

[since 6.1] QByteArray::iterator QByteArray::erase(QByteArray::const_iterator first, QByteArray::const_iterator last)

从字节数组中删除半开区间 [first,last ) 内的字符。返回一个迭代器，指向在删除操作之前由last 所引用的字符。

该函数在 Qt 6.1 中引入。

[since 6.5] QByteArray::iterator QByteArray::erase(QByteArray::const_iterator it)

从字节数组中删除由it 表示的字符。返回一个迭代器，该迭代器指向被删除字符之后的下一个字符。

QByteArray ba = "abcdefg";
auto it = ba.erase(ba.cbegin()); // ba is now "bcdefg" and it points to "b"

该函数在 Qt 6.5 中引入。

QByteArray &QByteArray::fill(char ch, qsizetype size = -1)

将字节数组中的每个字节设置为ch 。如果size 不等于-1（默认值），则会预先将字节数组调整为sizesize 的大小。

示例：

QByteArray ba("Istambul");
ba.fill('o');
// ba == "oooooooo"

ba.fill('X', 2);
// ba == "XX"

另请参阅 resize()。

返回字节数组的前n 字节。

示例：

QByteArray x("Pineapple");
QByteArray y = x.first(4);
// y == "Pine"

这些函数在 Qt 6.0 中引入。

另请参阅 last()、sliced()、startsWith()、chopped()、chop()、truncate() 以及slice()。

[static] QByteArray QByteArray::fromBase64(const QByteArray &base64, QByteArray::Base64Options options = Base64Encoding)

返回 Base64 数组 `base64` 的解码副本，并使用由 `options` 定义的选项。如果 `options ` 包含 `IgnoreBase64DecodingErrors `（默认值），则不会检查输入的有效性；输入中的无效字符将被跳过，从而使解码过程能够继续处理后续字符。如果 `options ` 包含 `AbortOnBase64DecodingErrors`，则解码将在遇到第一个无效字符时停止。

例如：

QByteArray text = QByteArray::fromBase64("UXQgaXMgZ3JlYXQh");
text.data();            // returns "Qt is great!"

QByteArray::fromBase64("PHA+SGVsbG8/PC9wPg==", QByteArray::Base64Encoding); // returns "<p>Hello?</p>"
QByteArray::fromBase64("PHA-SGVsbG8_PC9wPg==", QByteArray::Base64UrlEncoding); // returns "<p>Hello?</p>"

用于解码 Base64 编码数据的算法在RFC 4648 中定义。

返回解码后的数据；若传入了AbortOnBase64DecodingErrors 选项且输入数据无效，则返回一个空字节数组。

另请参阅 toBase64() 和fromBase64Encoding()。

使用由options 定义的选项，对 Base64 数组base64 进行解码。如果options 的值为IgnoreBase64DecodingErrors （默认值），则不会检查输入的有效性；输入中的无效字符将被跳过，解码过程将继续处理后续字符。如果options 的值为AbortOnBase64DecodingErrors ，则解码将在遇到第一个无效字符时停止。

例如：

void process(const QByteArray &);

if (auto result = QByteArray::fromBase64Encoding(encodedData))
    process(*result);

用于解码 Base64 编码数据的算法在RFC 4648 中有定义。

返回一个 QByteArrayFromBase64Result 对象，其中包含解码后的数据以及一个指示解码是否成功的标志。如果传入了AbortOnBase64DecodingErrors 选项且输入数据无效，则解码后的数据包含什么内容未作规定。

另请参阅 toBase64()。

[static] QByteArray QByteArray::fromCFData(CFDataRef data)

创建一个新的QByteArray ，其中包含CFDatadata 的副本。

另请参阅 fromRawCFData()、fromRawData()、toRawCFData() 和toCFData()。

[static, since 6.5] QByteArray QByteArray::fromEcmaUint8Array(emscripten::val uint8array)

构建一个新的QByteArray ，其中包含Uint8Arrayuint8array 的副本。

该函数将数据从一个 JavaScript 数据缓冲区（该缓冲区无法通过 C++ 代码直接访问）传输到由 `QByteArray` 拥有的堆内存中。一旦该函数返回且已生成副本，即可释放该 `Uint8Array`。

uint8array 参数必须是一个引用Uint8Array对象的emscripten::val，例如从全局JavaScript变量中获取：

emscripten::val uint8array = emscripten::val::global("g_uint8array");
QByteArray byteArray = QByteArray::fromEcmaUint8Array(uint8array);

如果 Uint8Array 的大小超过QByteArray 的最大容量，或者uint8array 参数不是 Uint8Array 类型，则该函数将返回一个空的QByteArray 。

该函数在 Qt 6.5 中引入。

另请参阅 toEcmaUint8Array()。

[static] QByteArray QByteArray::fromHex(const QByteArray &hexEncoded)

返回十六进制编码数组hexEncoded 的解码副本。不会对输入的有效性进行检查；输入中的无效字符将被跳过，从而使解码过程能够继续处理后续字符。

例如：

QByteArray text = QByteArray::fromHex("517420697320677265617421");
text.data();            // returns "Qt is great!"

另请参阅 toHex()。

[static] QByteArray QByteArray::fromNSData(const NSData *data)

创建一个新的QByteArray ，其中包含NSData对象data 的副本。

另请参阅 fromRawNSData()、fromRawData()、toNSData() 以及toRawNSData()。

[static] QByteArray QByteArray::fromPercentEncoding(const QByteArray &input, char percent = '%')

将 URI/URL 风格的百分比编码中的input 解码。

返回一个包含解码文本的字节数组。percent 参数允许使用“%”以外的其他字符（例如“_”或“=”）作为转义字符。等同于输入。percentDecoded （百分比编码）。

例如：

QByteArray text=QByteArray::fromPercentEncoding("Qt%20is%20great%33");
qDebug("%s", text.data());      // reports "Qt is great!"

另请参阅 percentDecoded()。

[static, since 6.11] QByteArray QByteArray::fromPercentEncoding(QByteArray &&input, char percent = '%')

该函数在 Qt 6.11 中引入。

[static] QByteArray QByteArray::fromRawCFData(CFDataRef data)

构建一个QByteArray ，该对象使用CFData对象data 中的字节数据。

data 的字节不会被复制。

调用方必须保证，只要该QByteArray 对象存在，CFData 就不会被删除或修改。

另请参阅 fromCFData()、fromRawData()、toRawCFData() 和toCFData()。

[static] QByteArray QByteArray::fromRawData(const char *data, qsizetype size)

构建一个QByteArray ，该对象使用data 数组的前size 字节。这些字节不会被复制。QByteArray 将包含data 的指针。调用方必须保证，只要此QByteArray 及其任何未被修改的副本仍然存在，data 就不会被删除或修改。 换言之，由于QByteArray 是一个隐式共享类，且该函数返回的实例包含data 指针，因此只要返回的QByteArray 及其任何副本仍存在，调用方就不得删除data 或直接修改它。但是，QByteArray 并不拥有data 的所有权，因此QByteArray 的析构函数永远不会删除原始的data ，即使最后一个引用data 的QByteArray 被销毁也是如此。

随后若尝试修改返回的QByteArray 的内容，或修改由此生成的任何副本，系统会在进行修改前先创建data 数组的深度拷贝。这确保了原始的data 数组本身绝不会被QByteArray 修改。

以下是一个示例，演示了如何使用QDataStream 读取内存中的原始数据，而无需将原始数据复制到QByteArray 中：

static const char mydata[] = {
    '\x00', '\x00', '\x03', '\x84', '\x78', '\x9c', '\x3b', '\x76',
    '\xec', '\x18', '\xc3', '\x31', '\x0a', '\xf1', '\xcc', '\x99',
    //...
    '\x6d', '\x5b'
};

QByteArray data = QByteArray::fromRawData(mydata, sizeof(mydata));
QDataStream in(&data, QIODevice::ReadOnly);
//...

另请参阅 setRawData()、data()、constData()、nullTerminate() 以及nullTerminated()。

[static] QByteArray QByteArray::fromRawNSData(const NSData *data)

构建一个QByteArray ，该对象使用NSDatadata 中的字节。

data 的字节不会被复制。

调用方必须保证，只要该QByteArray 对象存在，NSData 就不会被删除或修改。

另请参阅 fromNSData()、fromRawData()、toRawNSData() 和toNSData()。

[static] QByteArray QByteArray::fromStdString(const std::string &str)

返回str 字符串的副本，类型为QByteArray 。

另请参阅 ` toStdString()` 和 `QString::fromStdString()`。

char &QByteArray::front()

返回字节数组中第一个字节的引用。与operator[](0) 相同。

提供此函数是为了兼容 STL。

另请参阅 back()、at() 和operator[]()。

char QByteArray::front() const

返回字节数组中的第一个字节。与at(0) 相同。

提供此函数是为了兼容 STL。

另请参阅 back()、at() 和operator[]()。

[since 6.0] qsizetype QByteArray::indexOf(QByteArrayView bv, qsizetype from = 0) const

返回在该字节数组中，由bv 处理的字节序列首次出现位置的索引，从索引位置from 开始向前搜索。如果未找到匹配项，则返回-1。

示例：

QByteArray x("sticky question");
QByteArrayView y("sti");
x.indexOf(y);               // returns 0
x.indexOf(y, 1);            // returns 10
x.indexOf(y, 10);           // returns 10
x.indexOf(y, 11);           // returns -1

该函数在 Qt 6.0 中引入。

另请参阅 lastIndexOf()、contains() 和count()。

qsizetype QByteArray::indexOf(char ch, qsizetype from = 0) const

返回在此字节数组中，字节ch 首次出现位置的索引，从索引位置from 开始向前搜索。如果未找到匹配项，则返回-1。

示例：

QByteArray ba("ABCBA");
ba.indexOf("B");            // returns 1
ba.indexOf("B", 1);         // returns 1
ba.indexOf("B", 2);         // returns 3
ba.indexOf("X");            // returns -1

另请参阅 lastIndexOf() 和contains()。

[since 6.0] QByteArray &QByteArray::insert(qsizetype i, QByteArrayView data)

在索引位置i 处插入data ，并返回对此字节数组的引用。

示例：

QByteArray ba("Meal");
ba.insert(1, QByteArrayView("ontr"));
// ba == "Montreal"

对于大型字节数组，此操作可能较慢（线性时间），因为它需要将索引为i 及以上的所有字节在内存中至少向后移动一个位置。

该数组会自动扩展以容纳插入操作。如果i 超出数组末尾，则会先用空格字符扩展数组，使其达到i 位置。

该函数在 Qt 6.0 中引入。

另请参阅 append()、prepend()、replace() 和remove()。

QByteArray &QByteArray::insert(qsizetype i, const QByteArray &data)

在索引位置i 处插入data ，并返回对此字节数组的引用。

该数组会自动扩展以容纳插入的内容。如果i 超出了数组的末尾，则会先用空格字符扩展数组，使其达到i 位置。

另请参阅 append()、prepend()、replace() 以及remove()。

QByteArray &QByteArray::insert(qsizetype i, const char *s)

在索引位置i 处插入s ，并返回对此字节数组的引用。

该数组会自动扩展以容纳插入的内容。如果i 超出了数组的末尾，则会先用空格字符扩展数组，使其达到i 位置。

该函数等同于insert(i, QByteArrayView(s))

另请参阅 append()、prepend()、replace() 和remove()。

QByteArray &QByteArray::insert(qsizetype i, char ch)

在字节数组的索引位置i 处插入字节ch 。

该数组会自动扩展以容纳此次插入。如果i 超出了数组末尾，则会先用空格字符扩展数组，直到达到该i 位置。

QByteArray &QByteArray::insert(qsizetype i, const char *data, qsizetype len)

在字节数组的i 位置，从data 开始插入len 字节。

该数组会自动扩展以容纳此次插入。如果i 超出了数组的末尾，则会先用空格字符扩展数组，直到达到i 为止。

QByteArray &QByteArray::insert(qsizetype i, qsizetype count, char ch)

将字节ch 的count 个副本插入到字节数组的索引位置i 。

该数组会自动扩展以容纳此次插入。如果i 超出了数组的末尾，则会先用空格字符扩展数组，直到达到该i 位置。

[constexpr noexcept] bool QByteArray::isEmpty() const

如果字节数组的大小为 0，则返回 `true `；否则返回 `false`。

示例：

QByteArray().isEmpty();         // returns true
QByteArray("").isEmpty();       // returns true
QByteArray("abc").isEmpty();    // returns false

另请参阅 size()。

bool QByteArray::isLower() const

如果该字节数组均为小写字母，即其内容与通过toLower() 折叠处理后的结果完全一致，则返回true 。

请注意，这并不意味着该字节数组仅包含小写字母；仅表示其不包含任何 ASCII 大写字母。

另请参阅 isUpper() 和toLower()。

[noexcept] bool QByteArray::isNull() const

如果该字节数组为空，则返回true ；否则返回false 。

示例：

QByteArray().isNull();          // returns true
QByteArray("").isNull();        // returns false
QByteArray("abc").isNull();     // returns false

出于历史原因，Qt 将空字节数组与空字节数组区分开来。对于大多数应用程序而言，关键在于字节数组是否包含任何数据，这可以通过isEmpty() 来判断。

另请参阅 isEmpty()。

bool QByteArray::isUpper() const

如果该字节数组为大写字母，即与toUpper() 折叠结果完全一致，则返回true 。

请注意，这并不意味着该字节数组仅包含大写字母；仅表示它不包含任何 ASCII 小写字母。

另请参阅 isLower() 和toUpper()。

[noexcept, since 6.3] bool QByteArray::isValidUtf8() const

如果该字节数组包含有效的 UTF-8 编码数据，则返回true ；否则返回false 。

该函数在 Qt 6.3 中引入。

返回字节数组中最后n 字节的内容。

示例：

QByteArray x("Pineapple");
QByteArray y = x.last(5);
// y == "apple"

这些函数在 Qt 6.0 中引入。

另请参阅 first()、sliced()、endsWith()、chopped()、chop()、truncate() 以及slice()。

[since 6.0] qsizetype QByteArray::lastIndexOf(QByteArrayView bv, qsizetype from) const

返回在该字节数组中，由bv 所处理的字节序列中最后一次出现该序列的起始索引位置，从索引位置from 开始向后搜索。

如果 `from ` 为 -1，则从最后一个字符开始搜索；如果为 -2，则从倒数第二个字符开始搜索，以此类推。

若未找到匹配项，则返回 -1。

示例：

QByteArray x("crazy azimuths");
QByteArrayView y("az");
x.lastIndexOf(y);           // returns 6
x.lastIndexOf(y, 6);        // returns 6
x.lastIndexOf(y, 5);        // returns 2
x.lastIndexOf(y, 1);        // returns -1

该函数在 Qt 6.0 中引入。

另请参阅 indexOf()、contains() 和count()。

[since 6.2] qsizetype QByteArray::lastIndexOf(QByteArrayView bv) const

返回在该字节数组中，由bv 函数识别出的字节序列最后一次出现位置的索引，从字节数组的末尾向后搜索。若未找到匹配项，则返回-1。

示例：

QByteArray x("crazy azimuths");
QByteArrayView y("az");
x.lastIndexOf(y);           // returns 6
x.lastIndexOf(y, 6);        // returns 6
x.lastIndexOf(y, 5);        // returns 2
x.lastIndexOf(y, 1);        // returns -1

该函数于 Qt 6.2 中引入。

另请参见 indexOf()、contains() 和count()。

qsizetype QByteArray::lastIndexOf(char ch, qsizetype from = -1) const

返回在此字节数组中，字节ch 最后一次出现位置的索引，从索引位置from 开始向后搜索。如果from 为-1（默认值），则从最后一个字节（索引size() - 1处）开始搜索。如果未找到匹配项，则返回-1。

示例：

QByteArray ba("ABCBA");
ba.lastIndexOf("B");        // returns 3
ba.lastIndexOf("B", 3);     // returns 3
ba.lastIndexOf("B", 2);     // returns 1
ba.lastIndexOf("X");        // returns -1

另请参阅 indexOf() 和contains()。

返回一个字节数组，其中包含该字节数组的前len 字节。

如果您确定len 不会超出数组范围，请在新的代码中改用first()，因为它的执行速度更快。

如果len 大于size()，则返回整个字节数组。

如果 `len ` 小于 0，则返回一个空的 `QByteArray `。

另请参阅 first()、last()、startsWith()、chopped()、chop() 和truncate()。

QByteArray QByteArray::leftJustified(qsizetype width, char fill = ' ', bool truncate = false) const

返回一个大小为width 的字节数组，其中包含该字节数组，并在末尾用fill 字节进行补零。

如果truncate 为 false，且该字节数组的size() 值大于width ，则返回的字节数组是该字节数组的副本。

如果 `truncate ` 为 `true`，且字节数组的 `size()` 值大于 `width`，则会从字节数组副本中移除位置 `width ` 之后的所有字节，并返回该副本。

示例：

QByteArray x("apple");
QByteArray y = x.leftJustified(8, '.');   // y == "apple..."

另请参阅 rightJustified()。

[constexpr noexcept] qsizetype QByteArray::length() const

与size() 相同。

它返回字节数组在理论上所能容纳的元素最大数量。实际上，该数量可能会小得多，具体取决于系统可用的内存大小。

这些函数是在 Qt 6.8 中引入的。

返回一个字节数组，其中包含从该字节数组中以位置pos 为起始点的len 个字节。

如果您确定pos 和len 不会超出数组边界，请在新代码中改用sliced()，因为它的执行速度更快。

如果len 为 -1（默认值），或者pos +len >=size()，则返回一个字节数组，其中包含从位置pos 开始直至该字节数组末尾的所有字节。

另请参阅 first()、last()、sliced()、chopped()、chop()、truncate()，以及slice()。

[since 6.10] QByteArray &QByteArray::nullTerminate()

如果该字节数组的数据未以空字符结尾，则该方法将对数据进行深度复制，并使其以空字符结尾。

QByteArray 默认是空终止的，但在某些情况下（例如使用fromRawData()时），数据并不一定以\0 字符结尾，这在调用期望接收空终止字符串的方法时可能会造成问题（例如C API）。

该函数于 Qt 6.10 中引入。

另请参阅 nullTerminated()、fromRawData() 和setRawData()。

返回该字节数组的副本，该副本始终以空字符结尾。请参阅nullTerminate()。

这些函数在 Qt 6.10 中引入。

另请参阅 nullTerminate()、fromRawData() 和setRawData()。

[static] QByteArray QByteArray::number(int n, int base = 10)

返回一个字节数组，该数组以文本形式表示整数n 。

返回一个字节数组，其中包含一个字符串，该字符串表示n ，并使用指定的base （默认值为10）。支持2至36进制，其中大于9的数字使用字母表示：A代表10，B代表11，依此类推。

示例：

int n = 63;
QByteArray::number(n);              // returns "63"
QByteArray::number(n, 16);          // returns "3f"
QByteArray::number(n, 16).toUpper();  // returns "3F"

另请参阅 setNum() 和toInt()。

[static] QByteArray QByteArray::number(long n, int base = 10)

另请参阅 toLong()。

[static] QByteArray QByteArray::number(qlonglong n, int base = 10)

另请参阅 toLongLong()。

[static] QByteArray QByteArray::number(qulonglong n, int base = 10)

另请参阅 toULongLong()。

[static] QByteArray QByteArray::number(uint n, int base = 10)

另请参见 toUInt()。

[static] QByteArray QByteArray::number(ulong n, int base = 10)

另请参阅 toULong()。

[static] QByteArray QByteArray::number(double n, char format = 'g', int precision = 6)

返回一个字节数组，该数组以文本形式表示浮点数n 。

返回一个字节数组，其中包含一个字符串，该字符串表示n ，其中format 和precision 的含义与QLocale::toString(double, char, int) 中的含义相同。例如：

QByteArray ba = QByteArray::number(12.3456, 'E', 3);
// ba == 1.235E+01

另请参阅 toDouble() 和QLocale::FloatingPointPrecisionOption 。

[since 6.4] QByteArray QByteArray::percentDecoded(char percent = '%') const &

解码 URI/URL 风格的百分比编码。

返回一个包含解码后文本的字节数组。percent 参数允许使用“%”以外的其他字符（例如“_”或“=”）作为转义字符。

例如：

QByteArray encoded("Qt%20is%20great%33");
QByteArray decoded = encoded.percentDecoded(); // Set to "Qt is great!"

该函数自 Qt 6.4 起引入。

另请参阅 toPercentEncoding() 和QUrl::fromPercentEncoding()。

[since 6.11] QByteArray QByteArray::percentDecoded(char percent = '%') &&

该函数在 Qt 6.11 中引入。

QByteArray &QByteArray::prepend(QByteArrayView ba)

将字节数组视图 `ba ` 追加到此字节数组的前面，并返回对此字节数组的引用。

该操作通常非常快（常数时间），因为 `QByteArray ` 会在数据开头预先分配额外空间，因此无需每次重新分配整个数组即可实现数组扩展。

示例：

QByteArray x("ship");
QByteArray y("air");
x.prepend(y);
// x == "airship"

这等同于 insert(0,ba)。

另请参阅 append() 和insert()。

QByteArray &QByteArray::prepend(char ch)

将字节ch 添加到该字节数组的前面。

QByteArray &QByteArray::prepend(const QByteArray &ba)

在该字节数组前缀添加ba 。

QByteArray &QByteArray::prepend(const char *str)

将以“\0 ”结尾的字符串str 追加到此字节数组的前面。

QByteArray &QByteArray::prepend(const char *str, qsizetype len)

将从str 开始的len 个字节追加到此字节数组的前面。追加的字节可能包含 '\0' 字节。

QByteArray &QByteArray::prepend(qsizetype count, char ch)

将字节ch 的count 个副本追加到此字节数组的前面。

void QByteArray::push_back(const QByteArray &other)

提供此函数是为了兼容 STL。它等同于 append(other)。

[since 6.0] void QByteArray::push_back(QByteArrayView str)

与 append(str) 相同。

该函数在 Qt 6.0 中引入。

void QByteArray::push_back(char ch)

与 append(ch) 相同。

void QByteArray::push_back(const char *str)

与 append(str) 相同。

void QByteArray::push_front(const QByteArray &other)

提供此函数是为了兼容 STL。它等同于 prepend(other)。

[since 6.0] void QByteArray::push_front(QByteArrayView str)

与 prepend(str) 相同。

该函数在 Qt 6.0 中引入。

void QByteArray::push_front(char ch)

与 prepend(ch) 相同。

void QByteArray::push_front(const char *str)

与 prepend(str) 相同。

QByteArray::reverse_iterator QByteArray::rbegin()

返回一个STL 风格的反向迭代器，该迭代器指向字节数组中第一个字节，且顺序为反向。

另请参阅 begin()、crbegin() 和rend()。

[noexcept] QByteArray::const_reverse_iterator QByteArray::rbegin() const

QByteArray &QByteArray::remove(qsizetype pos, qsizetype len)

从数组中移除以索引位置pos 为起点的len 字节，并返回该数组的引用。

如果pos 超出范围，则不执行任何操作。如果pos 有效，但pos +len 大于数组的大小，则数组将在位置pos 处被截断。

示例：

QByteArray ba("Montreal");
ba.remove(1, 4);
// ba == "Meal"

删除元素将保留数组的容量，不会减少已分配的内存量。若要释放多余的容量并尽可能多地释放内存，请在最后一次更改数组大小后调用squeeze()。

另请参阅 insert()、replace() 和squeeze()。

[since 6.5] QByteArray &QByteArray::removeAt(qsizetype pos)

删除索引为pos 处的字符。如果pos 超出范围（即pos >=size()），则该函数不执行任何操作。

该函数在 Qt 6.5 中引入。

另请参阅 remove()。

[since 6.5] QByteArray &QByteArray::removeFirst()

删除该字节数组中的第一个字符。如果字节数组为空，则该函数不执行任何操作。

该函数在 Qt 6.5 中引入。

另请参阅 remove()。

[since 6.1] template <typename Predicate> QByteArray &QByteArray::removeIf(Predicate pred)

从字节数组中移除所有满足谓词pred 返回true的字节。返回对该字节数组的引用。

该函数于 Qt 6.1 中引入。

另请参阅 remove()。

[since 6.5] QByteArray &QByteArray::removeLast()

删除该字节数组中的最后一个字符。如果字节数组为空，则该函数不执行任何操作。

该函数自 Qt 6.5 起引入。

另请参阅 remove()。

QByteArray::reverse_iterator QByteArray::rend()

返回一个STL 风格的反向迭代器，该迭代器指向字节数组中最后一个字节之后的第一个位置，且顺序为反向。

另请参阅 end()、crend() 和rbegin()。

[noexcept] QByteArray::const_reverse_iterator QByteArray::rend() const

QByteArray QByteArray::repeated(qsizetype times) const

返回该字节数组的副本，并按指定的times 数量进行重复。

如果times 小于1，则返回一个空字节数组。

示例：

QByteArray ba("ab");
ba.repeated(4);             // returns "abababab"

QByteArray &QByteArray::replace(qsizetype pos, qsizetype len, QByteArrayView after)

将索引位置为pos 处的len 字节替换为字节数组after ，并返回对此字节数组的引用。

示例：

QByteArray x("Say yes!");
QByteArray y("no");
x.replace(4, 3, y);
// x == "Say no!"

另请参阅 insert() 和remove()。

[since 6.0] QByteArray &QByteArray::replace(QByteArrayView before, QByteArrayView after)

将字节数组before 的所有出现位置替换为字节数组after 。

示例：

QByteArray ba("colour behaviour flavour neighbour");
ba.replace(QByteArray("ou"), QByteArray("o"));
// ba == "color behavior flavor neighbor"

该函数在 Qt 6.0 中引入。

QByteArray &QByteArray::replace(char before, QByteArrayView after)

将字节before 的所有出现位置替换为字节数组after 。

QByteArray &QByteArray::replace(char before, char after)

将所有出现的字节before 替换为字节after 。

QByteArray &QByteArray::replace(const char *before, qsizetype bsize, const char *after, qsizetype asize)

将从before 开始的所有 “bsize ” 字节替换为从after 开始的 “asize ” 字节。由于这两个字符串的大小分别由bsize 和asize 给出，因此它们可能包含 “'\0'” 字节，且无需以 “\0 ” 结尾。

QByteArray &QByteArray::replace(qsizetype pos, qsizetype len, const char *after, qsizetype alen)

将从索引位置pos 开始的len 字节替换为从位置after 开始的alen 字节。插入的字节可能包含 '\0' 字节。

void QByteArray::reserve(qsizetype size)

尝试分配至少size 字节的内存。

如果你事先知道字节数组的大小，可以调用此函数；如果频繁调用resize()，很可能获得更好的性能。

如果不确定需要多少空间，通常最好将size 设为上限，或者如果严格的上限远大于此值，则设为最可能大小的较高估计值。 如果 `size ` 的估计值过低，一旦预留大小被超过，数组将按需扩展，这可能会导致实际分配的大小超过您最乐观的估计值，并会减慢触发该操作的操作速度。

该函数的唯一目的是为微调 `QByteArray` 的内存使用提供一种手段。通常情况下，您几乎不需要调用此函数。

另请参阅 squeeze() 和capacity()。

void QByteArray::resize(qsizetype size)

将字节数组的大小设置为size 字节。

如果 `size ` 大于当前大小，则将字节数组扩展至 `size ` 字节，并将额外字节添加到数组末尾。新增的字节未初始化。

如果size 小于当前大小，则位置size 之后的部分将从字节数组中移除。

另请参阅 size()、truncate() 和squeeze()。

[since 6.4] void QByteArray::resize(qsizetype newSize, char c)

将字节数组的大小设置为newSize 字节。

如果newSize 大于当前大小，则将字节数组扩展至newSize 字节，并将额外字节添加到数组末尾。新增的字节将初始化为c 。

如果newSize 小于当前大小，则位置newSize 之后的字节将从字节数组中剔除。

该函数在 Qt 6.4 中引入。

另请参阅 size()、truncate() 和squeeze()。

[since 6.8] void QByteArray::resizeForOverwrite(qsizetype size)

将字节数组的大小调整为size 字节。如果字节数组的大小增加，新增的字节将处于未初始化状态。

该行为与resize(size) 完全相同。

该函数在 Qt 6.8 中引入。

另请参阅 resize()。

返回一个字节数组，其中包含该字节数组的最后len 字节。

如果已知 `len ` 不会超出范围，请在新代码中改用 `last()`，因为它的执行速度更快。

如果len 大于size()，则返回整个字节数组。

如果 `len ` 小于 0，则返回一个空的 `QByteArray `。

另请参阅 endsWith()、last()、first()、sliced()、chopped()、chop()、truncate() 和slice()。

QByteArray QByteArray::rightJustified(qsizetype width, char fill = ' ', bool truncate = false) const

返回一个大小为width 的字节数组，该数组包含字节fill ，后接此字节数组。

如果 `truncate ` 为 `false`，且字节数组的大小大于 `width`，则返回的字节数组是该字节数组的副本。

如果truncate 为 true，且字节数组的大小大于width ，则返回的字节数组将在位置width 处被截断。

示例：

QByteArray x("apple");
QByteArray y = x.rightJustified(8, '.');    // y == "...apple"

另请参阅 leftJustified()。

QByteArray &QByteArray::setNum(int n, int base = 10)

将整数n 表示为字符串。

将此字节数组设置为一个字符串，该字符串以基数base （默认值为 10）表示n ，并返回对此字节数组的引用。支持 2 到 36 之间的基数，其中 9 以上的数字使用字母表示；A 表示 10，B 表示 11，以此类推。

示例：

QByteArray ba;
int n = 63;
ba.setNum(n);           // ba == "63"
ba.setNum(n, 16);       // ba == "3f"

另请参阅 number() 和toInt()。

QByteArray &QByteArray::setNum(long n, int base = 10)

另请参阅 toLong()。

QByteArray &QByteArray::setNum(qlonglong n, int base = 10)

另请参阅 toLongLong()。

QByteArray &QByteArray::setNum(qulonglong n, int base = 10)

另请参阅 toULongLong()。

QByteArray &QByteArray::setNum(short n, int base = 10)

另请参阅 toShort()。

QByteArray &QByteArray::setNum(uint n, int base = 10)

另请参阅 toUInt()。

QByteArray &QByteArray::setNum(ulong n, int base = 10)

另请参阅 toULong()。

QByteArray &QByteArray::setNum(ushort n, int base = 10)

另请参阅 toUShort()。

QByteArray &QByteArray::setNum(double n, char format = 'g', int precision = 6)

将浮点数n 表示为文本。

将此字节数组设置为表示n 的字符串，其中format 和precision 的含义与QLocale::toString （double、char、int）中的含义相同，并返回对此字节数组的引用。

另请参阅 toDouble() 和QLocale::FloatingPointPrecisionOption 。

QByteArray &QByteArray::setNum(float n, char format = 'g', int precision = 6)

将浮点数n 表示为文本。

将此字节数组设置为表示n 的字符串，其中format 和precision 的含义与QLocale::toString （double, char, int）中的含义相同，并返回对此字节数组的引用。

另请参阅 toFloat() 和QLocale::FloatingPointPrecisionOption 。

QByteArray &QByteArray::setRawData(const char *data, qsizetype size)

将QByteArray 重置为使用data 数组的前size 字节。这些字节不会被复制。QByteArray 将包含data 指针。调用方应保证，只要该QByteArray 及其任何未被修改的副本仍然存在，data 就不会被删除或修改。

该函数可替代fromRawData() 来复用现有的QByteArray 对象，从而节省内存重新分配。

另请参阅 fromRawData()、data()、constData()、nullTerminate(）和nullTerminated()。

void QByteArray::shrink_to_fit()

提供此函数是为了兼容STL。它等同于squeeze()。

QByteArray QByteArray::simplified() const

返回该字节数组的副本，其中已移除了开头和结尾的空格字符，并且每个内部空格字符序列都被替换为一个空格。

这些空格字符是指在 C 语言环境中，标准 C++ 的 `isspace() ` 函数会返回 `true ` 的字符；具体包括 ASCII 字符：制表符 '\t'、换行符 '\n'、回车符 '\r'、垂直制表符 '\v'、换页符 '\f' 以及空格符 ' '。

示例：

QByteArray ba("  lots\t of\nwhitespace\r\n ");
ba = ba.simplified();
// ba == "lots of whitespace";

另请参阅 trimmed(),QChar::SpecialCharacter 以及Spacing Characters 。

[constexpr noexcept] qsizetype QByteArray::size() const

返回此字节数组中的字节数。

字节数组的最后一个字节位于索引 size() - 1 处。此外，QByteArray 确保位于索引 size() 处的字节始终为 '\0'，因此您可以将data() 和constData() 的返回值用作需要 '\0' 结尾字符串的函数的参数。 如果 `QByteArray ` 对象是从一个未包含尾部 `\0` 终止字节的 `raw data ` 创建的，那么除非创建了深度拷贝，否则 `QByteArray ` 不会自动添加该字节。

示例：

QByteArray ba("Hello");
qsizetype n = ba.size();    // n == 5
ba.data()[0];               // returns 'H'
ba.data()[4];               // returns 'o'
ba.data()[5];               // returns '\0'

另请参阅 isEmpty() 和resize()。

[since 6.8] QByteArray &QByteArray::slice(qsizetype pos, qsizetype n)

将此字节数组修改为从位置pos 开始，长度为n 字节，并返回对此字节数组的引用。

示例：

QByteArray x = "Five pineapples"_ba;
x.slice(5);     // x == "pineapples"
x.slice(4, 3);  // x == "app"

该函数在 Qt 6.8 中引入。

另请参阅 sliced()、first()、last()、chopped()、chop() 以及truncate()。

[since 6.8] QByteArray &QByteArray::slice(qsizetype pos)

修改此字节数组，使其从位置pos 开始，直至数组末尾，并返回对此字节数组的引用。

该函数在 Qt 6.8 中引入。

另请参见 sliced()、first()、last()、chopped()、chop(）和truncate()。

返回一个字节数组，其中包含从位置pos 开始的该对象的n 个字节。

示例：

QByteArray x("Five pineapples");
QByteArray y = x.sliced(5, 4);     // y == "pine"
QByteArray z = x.sliced(5);        // z == "pineapples"

这些函数在 Qt 6.0 中引入。

另请参阅 first(),last(),chopped(),chop(),truncate() 以及slice()。

返回一个字节数组，其中包含从该对象的pos 位置开始、直至该对象末尾的所有字节。

这些函数在 Qt 6.0 中引入。

另请参阅 first()、last()、chopped()、chop()、truncate()，以及slice()。

QList<QByteArray> QByteArray::split(char sep) const

在遇到sep 的位置将字节数组拆分为子数组，并返回这些数组的列表。如果sep 在字节数组的任何位置均未匹配，则split()将返回一个仅包含该字节数组的单元素列表。

void QByteArray::squeeze()

释放存储数组数据以外的任何内存。

此函数的唯一目的是提供一种方法来微调QByteArray 的内存使用情况。通常情况下，您几乎无需调用此函数。

另请参阅 reserve() 和capacity()。

[since 6.0] bool QByteArray::startsWith(QByteArrayView bv) const

如果该字节数组以bv 所识别的字节序列开头，则返回true ；否则返回false 。

示例：

QByteArray url("ftp://ftp.qt-project.org/");
if (url.startsWith("ftp:"))
    {/*...*/}

该函数在 Qt 6.0 中引入。

另请参阅 endsWith() 和first()。

bool QByteArray::startsWith(char ch) const

如果该字节数组以字节ch 开头，则返回true ；否则返回false 。

[noexcept] void QByteArray::swap(QByteArray &other)

将该字节数组与other 互换。此操作速度极快，且绝不会失败。

QByteArray QByteArray::toBase64(QByteArray::Base64Options options = Base64Encoding) const

返回一个字节数组的副本，该副本使用选项options 进行编码。

QByteArray text("Qt is great!");
text.toBase64();        // returns "UXQgaXMgZ3JlYXQh"

QByteArray hello("<p>Hello?</p>");
hello.toBase64(QByteArray::Base64Encoding | QByteArray::OmitTrailingEquals);      // returns "PHA+SGVsbG8/PC9wPg"
hello.toBase64(QByteArray::Base64Encoding);                                       // returns "PHA+SGVsbG8/PC9wPg=="
hello.toBase64(QByteArray::Base64UrlEncoding);                                    // returns "PHA-SGVsbG8_PC9wPg=="
hello.toBase64(QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals);   // returns "PHA-SGVsbG8_PC9wPg"

用于编码 Base64 数据的算法在RFC 4648 中进行了定义。

另请参阅 fromBase64()。

CFDataRef QByteArray::toCFData() const

根据QByteArray 创建一个CFData对象。

调用方拥有该 CFData 对象，并负责释放它。

另请参阅 toRawCFData()、fromCFData()、fromRawCFData() 以及fromRawData()。

double QByteArray::toDouble(bool *ok = nullptr) const

返回已转换为double 值的字节数组。

如果转换时发生溢出，则返回无穷大；如果因其他原因（例如下溢）导致转换失败，则返回 0.0。

如果 `ok ` 不是 `nullptr`，则通过将 * `ok ` 设置为 `false` 来报告失败，通过将 * `ok ` 设置为 `true` 来报告成功。

QByteArray string("1234.56");
bool ok;
double a = string.toDouble(&ok);   // a == 1234.56, ok == true

string = "1234.56 Volt";
a = string.toDouble(&ok);             // a == 0, ok == false

该函数会忽略开头和结尾的空白字符。

另请参阅 number()。

[since 6.5] emscripten::val QByteArray::toEcmaUint8Array()

根据QByteArray 创建一个Uint8Array。

该函数将由QByteArray 拥有的堆内存中的数据传输到 JavaScript 数据缓冲区。该函数会分配一个 ArrayBuffer 并将其复制进去，然后返回该缓冲区的 Uint8Array 视图。

JavaScript 对象拥有该数据的副本，因此在复制完成后，可以安全地删除该QByteArray 。

QByteArray byteArray = "test";
emscripten::val uint8array = byteArray.toEcmaUint8Array();

该函数在 Qt 6.5 中引入。

另请参阅 fromEcmaUint8Array()。

float QByteArray::toFloat(bool *ok = nullptr) const

返回已转换为float 值的字节数组。

如果转换发生溢出，则返回无穷大；如果因其他原因（例如下溢）导致转换失败，则返回 0.0。

如果 `ok ` 不是 `nullptr`，则通过将 * `ok ` 设置为 `false` 来报告失败，通过将 * `ok ` 设置为 `true` 来报告成功。

QByteArray string("1234.56");
bool ok;
float a = string.toFloat(&ok);    // a == 1234.56, ok == true

string = "1234.56 Volt";
a = string.toFloat(&ok);              // a == 0, ok == false

该函数会忽略首尾的空白字符。

另请参阅 number()。

QByteArray QByteArray::toHex(char separator = '\0') const

返回字节数组的十六进制编码副本。

十六进制编码使用数字 0-9 和字母 a-f。

如果 `separator ` 不为 `'\0'`，则会在十六进制字节之间插入分隔符。

示例：

QByteArray macAddress = QByteArray::fromHex("123456abcdef");
macAddress.toHex(':'); // returns "12:34:56:ab:cd:ef"
macAddress.toHex(0);   // returns "123456abcdef"

另请参阅 fromHex()。

int QByteArray::toInt(bool *ok = nullptr, int base = 10) const

返回一个已转换为int 的字节数组，转换时采用基数base ，默认基数为10。支持基数0以及2至36，其中大于9的数字使用字母表示；A代表10，B代表11，依此类推。

如果 `base ` 为 0，则根据以下规则自动确定进制：如果字节数组以“0x”开头，则视为十六进制（进制 16）； 否则，若以“0b”开头，则视为二进制（基数 2）；否则，若以“0”开头，则视为八进制（基数 8）；否则视为十进制。

若转换失败，则返回 0。

如果 `ok ` 不是 `nullptr`，则通过将 `*ok ` 设置为 `false` 来报告失败，通过将 `*ok ` 设置为 `true` 来报告成功。

QByteArray str("FF");
bool ok;
int hex = str.toInt(&ok, 16);     // hex == 255, ok == true
int dec = str.toInt(&ok, 10);     // dec == 0, ok == false

另请参阅 number()。

long QByteArray::toLong(bool *ok = nullptr, int base = 10) const

返回一个已转换为long 整数的字节数组，转换时采用基数base ，默认基数为10。支持基数0以及2至36，其中9以上的数字使用字母表示；A代表10，B代表11，依此类推。

如果base 为0，则根据以下规则自动确定进制：如果字节数组以“0x”开头，则视为十六进制（进制16）； 否则，若以“0b”开头，则视为二进制（基数 2）；否则，若以“0”开头，则视为八进制（基数 8）；否则视为十进制。

若转换失败，则返回 0。

如果 `ok ` 不是 `nullptr`，则通过将 `*ok ` 设置为 `false` 来报告失败，通过将 `*ok ` 设置为 `true` 来报告成功。

QByteArray str("FF");
bool ok;
long hex = str.toLong(&ok, 16);   // hex == 255, ok == true
long dec = str.toLong(&ok, 10);   // dec == 0, ok == false

另请参阅 number()。

qlonglong QByteArray::toLongLong(bool *ok = nullptr, int base = 10) const

返回一个已转换为long long 的字节数组，转换时采用基数base ，默认基数为10。支持基数0以及2至36，其中9以上的数字使用字母表示；A代表10，B代表11，依此类推。

如果 `base ` 为 0，则根据以下规则自动确定进制：如果字节数组以“0x”开头，则假定为十六进制（进制 16）； 否则，若以“0b”开头，则视为二进制（基数 2）；否则，若以“0”开头，则视为八进制（基数 8）；否则视为十进制。

若转换失败，则返回 0。

如果 `ok ` 不是 `nullptr`，则通过将 `*ok ` 设置为 `false` 来报告失败，通过将 `*ok ` 设置为 `true` 来报告成功。

另请参阅 number()。

QByteArray QByteArray::toLower() const

返回字节数组的副本，其中每个 ASCII 大写字母都被转换为小写。

示例：

QByteArray x("Qt by THE QT COMPANY");
QByteArray y = x.toLower();
// y == "qt by the qt company"

另请参阅 isLower()、toUpper() 以及Character Case 。

NSData *QByteArray::toNSData() const

根据QByteArray 创建一个NSData。

该 NSData 对象将被自动释放。

另请参阅 fromNSData()、fromRawNSData()、fromRawData() 和toRawNSData()。

QByteArray QByteArray::toPercentEncoding(const QByteArray &exclude = QByteArray(), const QByteArray &include = QByteArray(), char percent = '%') const

返回该字节数组的 URI/URL 风格百分比编码副本。通过percent 参数，您可以将默认的“%”字符替换为其他字符。

默认情况下，该函数会将所有不属于以下情况的字节进行编码：

字母（“a”至“z”和“A”至“Z”） / 数字（0至9） / “-” / “.” / “_” / “~”

若要防止字节被编码，请将其传递给exclude 。若要强制对字节进行编码，请将其传递给include 。字符percent 始终会被编码。

示例：

QByteArray text= "{可疑的字符串？}";
QByteArray ba=text.toPercentEncoding("{}", "s");
qDebug("%s", ba.constData());
// 输出“{a fi%73hy %73tring%3F}”

十六进制编码使用数字 0-9 和大写字母 A-F。

另请参阅 fromPercentEncoding() 和QUrl::toPercentEncoding()。

CFDataRef QByteArray::toRawCFData() const

构建一个使用QByteArray 字节数据的CFData对象。

QByteArray 的字节不会被复制。

调用方保证，只要该 CFData 对象存在，QByteArray 就不会被删除或修改。

另请参阅 toCFData()、fromRawCFData()、fromCFData() 和fromRawData()。

NSData *QByteArray::toRawNSData() const

构建一个使用QByteArray 的字节内容的NSData对象。

QByteArray 的字节不会被复制。

调用方保证，只要该 NSData 对象存在，QByteArray 就不会被删除或修改。

另请参阅 fromRawNSData()、fromNSData()、fromRawData() 和toNSData()。

short QByteArray::toShort(bool *ok = nullptr, int base = 10) const

返回已转换为short 格式的字节数组，转换时采用基数base （默认值为10）。支持基数0以及2至36，其中9以上的数字使用字母表示；A代表10，B代表11，以此类推。

如果 `base ` 为 0，则根据以下规则自动确定进制：如果字节数组以“0x”开头，则视为十六进制（基数 16）； 否则，如果以 "0b" 开头，则视为二进制（基数 2）；否则，如果以 "0" 开头，则视为八进制（基数 8）；否则视为十进制。

若转换失败，则返回 0。

如果 `ok ` 不是 `nullptr`，则通过将 `*ok ` 设置为 `false` 来报告失败，通过将 `*ok ` 设置为 `true` 来报告成功。

另请参阅 number()。

std::string QByteArray::toStdString() const

返回一个包含此QByteArray 中数据的std::string对象。

该运算符主要用于将QByteArray 传递给接受std::string对象的函数。

另请参阅 fromStdString() 和QString::toStdString()。

uint QByteArray::toUInt(bool *ok = nullptr, int base = 10) const

返回一个已转换为unsigned int 的字节数组，转换时采用基数base （默认值为10）。支持基数0以及2至36，其中大于9的数字使用字母表示；A代表10，B代表11，依此类推。

如果 `base ` 为 0，则根据以下规则自动确定进制：如果字节数组以“0x”开头，则视为十六进制（进制 16）； 否则，若以“0b”开头，则视为二进制（基数 2）；否则，若以“0”开头，则视为八进制（基数 8）；否则视为十进制。

若转换失败，则返回 0。

如果 `ok ` 不是 `nullptr`，则通过将 `*ok ` 设置为 `false` 来报告失败，并通过将 `*ok ` 设置为 `true` 来报告成功。

另请参阅 number()。

ulong QByteArray::toULong(bool *ok = nullptr, int base = 10) const

返回一个已转换为unsigned long int 的字节数组，转换时使用基数base （默认值为10）。支持基数0以及2至36，其中大于9的数字使用字母表示；A代表10，B代表11，依此类推。

如果 `base ` 为 0，则根据以下规则自动确定进制：如果字节数组以“0x”开头，则视为十六进制（进制 16）； 否则，若以“0b”开头，则视为二进制（基数 2）；否则，若以“0”开头，则视为八进制（基数 8）；否则视为十进制。

若转换失败，则返回 0。

如果 `ok ` 不是 `nullptr`，则通过将 `*ok ` 设置为 `false` 来报告失败，通过将 `*ok ` 设置为 `true` 来报告成功。

另请参阅 number()。

qulonglong QByteArray::toULongLong(bool *ok = nullptr, int base = 10) const

返回一个字节数组，该数组已根据基数base 转换为unsigned long long ，默认基数为10。支持基数0以及2至36，其中大于9的数字使用字母表示；A代表10，B代表11，依此类推。

如果 `base ` 为 0，则根据以下规则自动确定进制：如果字节数组以“0x”开头，则视为十六进制（进制 16）； 否则，若以“0b”开头，则视为二进制（基数 2）；否则，若以“0”开头，则视为八进制（基数 8）；否则视为十进制。

若转换失败，则返回 0。

如果 `ok ` 不是 `nullptr`，则通过将 `*ok ` 设置为 `false` 来报告失败，并通过将 `*ok ` 设置为 `true` 来报告成功。

另请参阅 number()。

ushort QByteArray::toUShort(bool *ok = nullptr, int base = 10) const

返回一个已转换为unsigned short 的字节数组，转换时采用基数base （默认值为10）。支持基数0以及2至36，其中大于9的数字使用字母表示；A代表10，B代表11，以此类推。

如果 `base ` 为 0，则根据以下规则自动确定进制：如果字节数组以“0x”开头，则视为十六进制（进制 16）； 否则，若以“0b”开头，则视为二进制（基数 2）；否则，若以“0”开头，则视为八进制（基数 8）；否则视为十进制。

若转换失败，则返回 0。

如果 `ok ` 不是 `nullptr`，则通过将 *ok 设置为 `false` 来报告失败，通过将 *ok 设置为 `true` 来报告成功。

另请参阅 number()。

QByteArray QByteArray::toUpper() const

返回字节数组的副本，其中每个 ASCII 小写字母都被转换为大写。

示例：

QByteArray x("Qt by THE QT COMPANY");
QByteArray y = x.toUpper();
// y == "QT BY THE QT COMPANY"

另请参阅 isUpper()、toLower() 以及Character Case 。

QByteArray QByteArray::trimmed() const

返回该字节数组的副本，并从数组的开头和结尾移除空格字符。

这些空格字符是指在 C 语言环境中，标准 C++ 函数 `isspace() ` 返回 `true ` 的字符；它们包括 ASCII 字符：制表符 '\t'、换行符 '\n'、回车符 '\r'、垂直制表符 '\v'、换页符 '\f' 以及空格符 ' '。

示例：

QByteArray ba("  lots\t of\nwhitespace\r\n ");
ba = ba.trimmed();
// ba == "lots\t of\nwhitespace";

与 `simplified()` 不同，`trimmed()` 会保留内部空格不变。

另请参阅 simplified()、QChar::SpecialCharacter 以及Spacing Characters 。

void QByteArray::truncate(qsizetype pos)

截取索引位置为pos 处的字节数组。

如果pos 超出数组末尾，则不执行任何操作。

示例：

QByteArray ba("Stockholm");
ba.truncate(5);             // ba == "Stock"

另请参阅 chop()、resize() 和first()。

返回指向字节数组中存储的数据的指针。该指针可用于访问构成该数组的字节。数据以 '\0' 结尾。

只要未发生脱离且QByteArray 未被修改，该指针即保持有效。

该运算符主要用于将字节数组传递给接受 `const char *` 的函数。

您可以在编译应用程序时通过定义 `QT_NO_CAST_FROM_BYTEARRAY ` 来禁用此运算符。

注意：QByteArray 可以存储任何字节值，包括 '\0'，但大多数接受char * 参数的函数都假设数据以遇到的第一个 '\0' 为结尾。

另请参阅 constData()。

[noexcept, since 6.10] QByteArray::operator std::string_view() const

将此QByteArray 对象转换为std::string_view 对象。返回的字符串视图将覆盖整个字节数组。

该函数于 Qt 6.10 中引入。

QByteArray &QByteArray::operator+=(const QByteArray &ba)

将字节数组ba 追加到该字节数组的末尾，并返回该字节数组的引用。

示例：

QByteArray x("free");
QByteArray y("dom");
x += y;
// x == "freedom"

注意：QByteArray 是一个隐式共享类。因此，若将数据追加到空字节数组中，该字节数组将直接共享ba 中存储的数据。在此情况下，不会进行数据复制，耗时为常数时间。若共享实例被修改，则会进行复制（写时复制），耗时为线性时间。

如果要追加数据的字节数组不为空，则会执行数据的深度复制，耗时为线性时间。

该操作通常不会产生内存分配开销，因为 `QByteArray ` 会在数据末尾预先分配额外空间，从而使其能够动态扩展，而无需在每次追加操作时重新分配内存。

另请参阅 append() 和prepend()。

QByteArray &QByteArray::operator+=(char ch)

将字节ch 追加到此字节数组的末尾，并返回对此字节数组的引用。

QByteArray &QByteArray::operator+=(const char *str)

将以“\0 ”结尾的字符串str 追加到该字节数组的末尾，并返回该字节数组的引用。

[noexcept] QByteArray &QByteArray::operator=(QByteArray &&other)

将other 通过Move操作赋值给此QByteArray 实例。

[noexcept] QByteArray &QByteArray::operator=(const QByteArray &other)

将other 赋值给此字节数组，并返回对此字节数组的引用。

QByteArray &QByteArray::operator=(const char *str)

将str 赋值给此字节数组。

str 该字符串被假定为指向一个以空字符结尾的字符串，其长度由系统动态确定。

char &QByteArray::operator[](qsizetype i)

返回索引位置为i 的字节，作为可修改的引用。

i 该索引位置必须是字节数组中的有效索引位置（即，0 <=i <size())。

示例：

QByteArray ba("Hello, world");
cout << ba[0]; // prints H
ba[7] = 'W';
// ba == "Hello, World"

另请参阅 at()。

char QByteArray::operator[](qsizetype i) const

与 (i) 相同。