【报Bug】uniapp开发iOS应用，调用uni.request api ios26版本持续请求超时

根据您描述的问题，iOS 26版本使用uni.request API时，添加Authorization请求头导致持续请求超时，而无此头则正常，这很可能是iOS新版本的安全机制变更导致。

知识库中相关参考：

1. iOS平台网络请求注意事项：https://uniapp.dcloud.net.cn/api/request/request.html
2. iOS首次安装会弹出网络权限询问框，若用户未同意会导致网络请求失败（但您描述的是已安装应用）

可能原因及建议：

• iOS新版本可能对Authorization头有额外安全校验，尝试将"Authorization"改为小写"authorization"（iOS系统对Header字段名大小写敏感度变化）
• 检查Authorization值格式是否正确（应为"Bearer token"）
• 在manifest.json中添加网络安全配置（iOS ATS设置），确保允许连接到您的HTTPS服务器
• 尝试使用其他方式传递认证信息（如URL参数），作为临时解决方案
• 确认HBuilderX版本是否为最新（当前正式版4.85），新版本可能已修复此问题

若问题依旧，建议在DCloud论坛提交issue，提供可复现的示例代码，以便官方确认是否为iOS平台适配问题。

提供实际工程说明具体问题

const request = async (options) => {  
    console.log(options.url);  
    // 处理请求头  
    let headers = {  
        ...options.header,  
        "tenant-id": 1  
    };  
    // console.log(headers);  
    headers = await handleHeader(headers, options.noAuth);  
    console.log(headers.Authorization)  
    let ownOptions = {  
        ...options,  
        ifReject: options.ifReject || false,  
        header: headers  
    }  

    if (ownOptions.showLoad) {}  

    return new Promise((resolve, reject) => {  
        uni.request({  
            ...ownOptions,  
            success: (res) => {  
                const errMsg = '网络繁忙,请稍后重试';  
                if (res.statusCode !== 200) {  
                    const data = res.data  
                    if (res.statusCode == '400') {  
                        uni.showModal({  
                            title: '提示',  
                            content: errMsg,  
                            success(res) {}  
                        })  
                    }  
                    if (res.statusCode == '500') {  

                        uni.showModal({  
                            title: '提示',  
                            content: '网络繁忙,请稍后重试',  
                            success(res) {}  
                        })  
                    }  
                    if (res.statusCode == '401') {  
                        if (!isRefreshing) {  
                            isRefreshing = true  
                            getRefreshToken().then(newToken => {  
                                // console.log('token----------', newToken)  
                                isRefreshing = false  

                                requests.forEach(callback => callback(newToken))  
                                requests = []  

                                ownOptions.header.Authorization =  
                                    `Bearer ${newToken}`;  
                                uni.request({  
                                    ...ownOptions,  
                                    success: (res) => {  
                                        if (res.statusCode == 200) {  
                                            resolve(res.data)  
                                        } else {  
                                            reject(res)  
                                        }  
                                    }  
                                })  
                            }).catch((err) => {  
                                console.error(err)  

                                uni.showModal({  
                                    title: '提示',  
                                    content: '登录超时，请重新登录',  
                                    success(res) {  
                                        reject('token刷新失败')  
                                        isRefreshing = false  
                                        uni.removeStorageSync('token')  
                                        uni.removeStorageSync(  
                                            'refreshToken')  
                                        uni.setStorageSync('ifLogin', false)  
                                        uni.removeStorageSync('userInfo')  
                                        uni.reLaunch({  
                                            url: '/pages/login/index'  
                                        })  
                                    }  
                                });  
                            })  
                        } else {  
                            requests.push((newToken) => {  
                                ownOptions.header.Authorization =  
                                    `Bearer ${newToken}`;  
                                uni.request({  
                                    ...ownOptions,  
                                    success(res) {  
                                        if (res.statusCode == 200) {  
                                            resolve(res.data)  
                                        } else {  
                                            reject(res)  
                                        }  
                                    }  
                                })  
                            })  
                        }  

                    }  
                    reject(res)  
                } else {  
                    const result = res.data  
                    const code = result.code  
                    if (code == 401) {  
                        if (!isRefreshing) {  
                            isRefreshing = true  
                            getRefreshToken().then(newToken => {  
                                isRefreshing = false  

                                requests.forEach(callback => callback(newToken))  
                                requests = []  

                                ownOptions.header.Authorization =  
                                    `Bearer ${newToken}`;  
                                uni.request({  
                                    ...ownOptions,  
                                    success: (res) => {  
                                        if (res.statusCode == 200) {  
                                            resolve(res.data)  
                                        } else {  
                                            reject(res)  
                                        }  
                                    }  
                                })  
                            }).catch((err) => {  
                                console.error(err)  

                                uni.showModal({  
                                    title: '提示',  
                                    content: '登录超时，请重新登录',  
                                    success(res) {  
                                        reject('token刷新失败')  
                                        isRefreshing = false  
                                        uni.removeStorageSync('token')  
                                        uni.removeStorageSync(  
                                            'refreshToken')  
                                        uni.setStorageSync('ifLogin', false)  
                                        uni.removeStorageSync('userInfo')  
                                        uni.reLaunch({  
                                            url: '/pages/login/index'  
                                        })  
                                    }  
                                });  
                            })  
                        } else {  
                            requests.push((newToken) => {  
                                ownOptions.header.Authorization =  
                                    `Bearer ${newToken}`;  
                                uni.request({  
                                    ...ownOptions,  
                                    success(res) {  
                                        if (res.statusCode == 200) {  
                                            resolve(res.data)  
                                        } else {  
                                            reject(res)  
                                        }  
                                    }  
                                })  
                            })  
                        }  
                    } else {  
                        resolve(res.data);  
                    }  
                }  
            },  
            fail: (error) => {  
                console.error('报错进来了 ');  
                console.error(error)  
                uni.showToast({  
                    title: '网络异常，请稍后重试',  
                    icon: 'none'  
                })  
                if (options.ifReject) {  
                    reject(error)  
                }  
            },  
            complete: (res) => {  

            }  
        })  
    })  
}  

export default request;