QByteArray Class

成员函数文档

它返回字节数组理论上可容纳的最大元素数。实际上，受系统可用内存量的限制，这个数字可能要小得多。

此函数在 Qt 6.8 中引入。

返回存储在字节数组中数据的指针。该指针可用于访问组成数组的字节。数据以"\0 "结束。

只要不发生分离且QByteArray 不被修改，指针就一直有效。

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

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

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

另请参阅 constData()。

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

如果知道len 不可能出界，请在新代码中使用first() 代替，因为这样速度更快。

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

如果len 小于 0，则返回空QByteArray 。

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

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

如果知道len 不可能出界，请在新代码中使用last() 代替，因为这样速度更快。

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

如果len 小于 0，则返回空QByteArray 。

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

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

如果知道pos 和len 不能出界，请在新代码中使用sliced() 代替，因为这样速度更快。

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

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

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

示例：

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

此函数在 Qt 6.0 中引入。

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

返回字节数组的最后n 字节。

示例：

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

此函数在 Qt 6.0 中引入。

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

返回一个字节数组，其中包含该对象从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() 。

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

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

这是一个重载函数。

使用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().

[constexpr noexcept] QByteArray::QByteArray()

构造一个空字节数组。

另请参阅 isEmpty().

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::QByteArray(qsizetype size, char ch)

构造一个大小为size 的字节数组，每个字节都设置为ch 。

另请参见 fill()。

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

构造other 的副本。

由于 QByteArray 是隐式共享的，因此该操作耗时不变。这使得从函数返回 QByteArray 的速度非常快。如果共享实例被修改，它将被复制（写时复制），这需要线性时间。

另请参见 operator=().

[noexcept] 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)

这是一个重载函数。

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

如果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

该函数重载 begin()

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()。

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

返回存储在字节数组中的 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

返回一个 ConstSTL 样式的反向迭代器，以相反顺序指向字节数组中的第一个字节。

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

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

返回一个 ConstSTL 样式的反向迭代器，以相反的顺序指向字节数组中最后一个字节的后面。

另请参见 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

此函数重载 end()。

[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 不同（默认值），字节数组的大小会事先调整为size 。

示例

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

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

另请参阅 resize().

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

使用options 定义的选项，返回 Base64 数组base64 的解码副本。如果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()。

[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 参数必须是引用 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 ，其中包含 NSDatadata 的副本。

另请参阅 fromRawNSData(),fromRawData(),toNSData() 和toRawNSData().

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

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

返回包含解码文本的字节数组。percent 参数允许使用不同于'%'的字符（例如'_'或'='）作为转义字符。percentDecoded （百分数）。

例如

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

另见 percentDecoded().

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

构造一个使用 CFDatadata 字节的QByteArray 。

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 修改。

下面是一个示例，说明如何在不将原始数据复制到QByteArray 的情况下，使用QDataStream 对内存中的原始数据进行读取：

 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()。

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

构造一个使用 NSDatadata 字节的QByteArray 。

data 的字节不会被复制。

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

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

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

以QByteArray 的形式返回str 字符串的副本。

另请参阅 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

从索引位置from 开始向前搜索，返回bv 所查看的字节序列在该字节数组中首次出现时的起始索引位置。如果未找到匹配项，则返回-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

这是一个重载函数。

从索引位置from 开始向前搜索，返回该字节数组中第一次出现的字节ch 的起始索引位置。如果未找到匹配项，则返回-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)

这是一个重载函数。

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

该数组会不断增长，以容纳插入的内容。如果i 超过了数组的末尾，则首先用空格字符扩展数组，以达到i 的位置。

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

这是一个重载函数。

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

该数组会增长以适应插入。如果i 超过了数组的末尾，则首先用空格字符扩展数组，以达到i 。

[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 中引入。

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

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

如果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

这是一个重载函数。

从索引位置from 开始向后搜索，返回该字节数组中最后出现的字节ch 的起始索引位置。如果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()。

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

返回一个大小为width 的字节数组，该数组包含一个以fill 字节填充的字节数组。

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

如果truncate 为 true，且字节数组的size() 大于width ，则删除width 位置后字节数组副本中的任何字节，并返回副本。

示例

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

另请参见 rightJustified()。

[noexcept] qsizetype QByteArray::length() const

与size() 相同。

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

以文本形式返回表示整数n 的字节数组。

使用指定的base （默认为 10），返回包含字符串的字节数组n 。支持基数 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 ，其含义与QString::number （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()。

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)

这是一个重载函数。

将len 从str 开始的字节预置到此字节数组中。预输入的字节可能包括"（0）"字节。

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

这是一个重载函数。

将count 的字节副本ch 预置到此字节数组中。

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)

从数组中删除len 字节，从索引位置pos 开始，并返回数组的引用。

如果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)

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

示例

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)

这是一个重载函数。

用字节数组after 替换字节数组before 的每一次出现。

举例说明：

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)

这是一个重载函数。

用字节数组after 替换字节before 中出现的每一个字节。

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

这是一个重载函数。

用字节after 替换before 中出现的每一个字节。

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

这是一个重载函数。

用从after 开始的asize 字节替换从before 开始的bsize 字节。由于字符串的大小由bsize 和asize 给出，因此它们可能包含"（0）"字节，不需要以"（0）"结尾。

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

这是一个重载函数。

用从位置after 开始的alen 字节替换索引位置pos 的len 字节。插入的字节可能包括"（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()。

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

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

如果truncate 为假，且字节数组的大小大于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 表示为文本。

使用给定的format 和precision （含义与QString::number （double、char、int）相同）将此字节数组设置为表示n 的字符串，并返回对该字节数组的引用。

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

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

这是一个重载函数。

将浮点数n 表示为文本。

使用给定的format 和precision （含义与QString::number （double、char、int）相同）将此字节数组设置为表示n 的字符串，并返回对该字节数组的引用。

另请参阅 toFloat() 。

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

重置QByteArray ，使用data 数组的第一个size 字节。这些字节不会被复制。QByteArray 将包含data 指针。调用者保证，只要QByteArray 及其副本未被修改，data 就不会被删除或修改。

该函数可代替fromRawData() 用于重新使用现有的QByteArray 对象，以节省内存重新分配。

另请参见 fromRawData()、data() 和constData()。

void QByteArray::shrink_to_fit()

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

QByteArray QByteArray::simplified() const

返回该字节数组的副本，该副本的开头和结尾的间距字符已被删除，内部间距字符的每个序列都被一个空格替换。

间距字符是标准 C++isspace() 函数在 C 语言中返回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 。

[noexcept] qsizetype QByteArray::size() const

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

字节数组中的最后一个字节位于 size() - 1 位置。此外，QByteArray 还会确保 size() 位置的字节始终为"（0）"，这样就可以将data() 和constData() 的返回值用作预期以"（0）"结尾的字符串函数的参数。如果QByteArray 对象是从raw data 创建的，而 没有包含尾部的"（0）"字节，那么QByteArray 不会自动添加尾部的"（0）"字节，除非创建了深拷贝。

举例说明：

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() 。

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

用于编码 Base64-encoded 数据的算法在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 = str.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 中引入。

另请参阅 toEcmaUint8Array()。

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 = str.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

返回使用基数base 转换为int 的字节数组，默认为 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 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;
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

返回使用基数base 转换为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().

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 参数允许您用其他字符覆盖默认的"%"字符。

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

ALPHA（"a "至 "z "和 "A "至 "Z"）/ DIGIT（0 至 9）/ "-" / "."。/ "_" / "~"

要防止字节被编码，请将其发送至exclude 。要强制字节被编码，请将其发送至include 。percent 字符始终被编码。

示例

QByteArraytext= "{a fishy string?}"；QByteArrayba=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()。