Swift 无法转换类型为'；(u)->；可观察<；回应>'；到预期的参数类型'；（[)]->_'；

我遇到了以下错误：

Cannot convert value of type '(_) -> Observable<Response>' 
to expected argument type '([_]) -> _'

---

无法转换类型为“（\ux）->Observable”的值
到预期的参数类型“（[[u]）->”

当我试图编译时：

func request(_ token: MyAPI) -> Observable<Moya.Response> {
    switch (target.requiresCSRF, target.requiresOAuth) {
    case (false, false): return actualRequest 
    case (true, false): return CSRFTokenRequest().flatMap { _ in actualRequest }
    case (false, true): return OAuthTokenRequest().flatMap { _ in actualRequest }
    case (true, true): return Observable.zip([CSRFTokenRequest(), OAuthTokenRequest()]) { _ in actualRequest }
    } 
}

func请求（令牌：MyAPI）->可观察{
开关（target.requiressrf、target.requiresAuth）{
案例（false，false）：返回实际请求
大小写（true，false）：返回CSRFTokenRequest（）.flatMap{inactualrequest}
大小写（false，true）：返回OAuthTokenRequest（）.flatMap{inActualRequest}
case（true，true）：返回Observable.zip（[CSRFTokenRequest（），oauthttokenrequest（）]）{in actualRequest}
} 
}

实际请求的类型为“可观察的” CSRFTokenRequest和OAuthTokenRequest都属于可观察的类型

我试图在OAuthTokenRequest之前运行CSRFTokenRequest，然后运行实际请求

下面解决了这个问题。。。但我不确定这是不是正确的方法

return RequiresCSRFTokenRequest().flatMap{ _ in
            self.RequiresAuthenticationRequest().flatMap{ _ in actualRequest}
        }



fileprivate extension Networking{

    func RequiresAuthenticationRequest() -> Observable<String> {

        /// This has 3 cases

        // 0. token is not present, error out
        // 1. token is not expired, return token
        // 2. token is expired, needs refresh

        guard let jwt = AuthManager.shared.accessToken else{
            return .just("Error!! No access tokens")
        }

        // If access token is valid
        if AuthManager.shared.expiredAccessToken == false{

            return .just(jwt)

        }else{

            return request(.refreshAccessToken(refreshToken: AuthManager.shared.refreshTokenWithBearer!))
                .filterSuccessfulStatusCodes()
                .mapObject(type: UserAuthenticationTokens.self)
                .do(onNext: {
                    $0.save()})
                .map{ (token) -> String in
                    // Get new access token that was just saved
                    return AuthManager.shared.accessToken!
            }
        }

    }


    func RequiresCSRFTokenRequest() -> Observable<String> {

        // Always get a new csrf token
        return request(.getCSRF())
            .filterSuccessfulStatusCodes()
            .mapObject(type: CSRFToken.self)
            .do(onNext: {
                $0.save()
            }).map{ (token) -> String in
                return AuthManager.shared.csrf_token!
            }
    }

}

返回requiressrftokenrequest（）.flatMap{uu}in
self.requireAuthenticationRequest（）
}
文件专用扩展网络{
func requireAuthenticationRequest（）->可观察{
///这有3个案例
//0.令牌不存在，出现错误
//1.令牌未过期，返回令牌
//2.令牌已过期，需要刷新
guard let jwt=AuthManager.shared.accessToken else{
return.just（“错误！！没有访问令牌”）
}
//如果访问令牌有效
如果AuthManager.shared.expiredAccessToken==false{
return.just（jwt）
}否则{
返回请求（.refreshAccessToken（refreshToken:AuthManager.shared.RefreshTokenWithBear！））
.filterSuccessfulStatusCodes（）
.mapObject（类型：UserAuthenticationTokens.self）
.do（onNext:{
$0.save（）}）
.map{（令牌）->中的字符串
//获取刚保存的新访问令牌
返回AuthManager.shared.accessToken！
}
}
}
func requiressrftokenrequest（）->可观察{
//始终获取新的csrf令牌
返回请求（.getCSRF（））
.filterSuccessfulStatusCodes（）
.mapObject（类型：CSRFToken.self）
.do（onNext:{
$0.save（）
}).map{（令牌）->中的字符串
返回AuthManager.shared.csrf_令牌！
}
}
}

---

谢谢

如果您仔细查看

switch

语句中的最后一个案例，以及

CSRFTokenRequest（）

和

oauthttokenrequest（）

两个函数都返回

observeables

这一事实，那么我可以从您的代码中看出，您正在创建一个新的

observeable

，等待这两个函数发出

zip

为您发出两个观察值，在您的示例中，您使用{return actualRequest}忽略了这两个但是在返回函数

actualRequest

时要小心，因为它需要另一件事，所以这里的要点是将

可观察的

转换为

可观察的

为此，您将需要像以前一样使用

flatMap

函数，而在上一个案例中，您缺少它

让我们看看下面的例子：

Observable.zip(Observable.just(1), Observable.just("!")) { (a, b) in
   return (a,b)
}
.flatMap {  _ in return Observable.just(4.0) }
.subscribe(onNext: { value in
    print(value)
})
.addDisposableTo(disposeBag)

在上面的例子中，我省略了

Observable

和

Observable

的两个值，以创建一个新的

Observable

在您的情况下，您应该这样做：

return Observable.zip(CSRFTokenRequest(), OAuthTokenRequest()).flatMap { _ in actualRequest }

---

我希望这能帮助您

所有这些表达式的返回类型是什么？它们应该是可观察的？。我想它会返回一个“可观察的”不是吗？请分享更多关于您的类型的信息，如果没有更多信息，很难帮助您。当您在函数中仅返回

实际请求时会发生什么情况
可观察的
？（删除所有其他内容只需
返回实际请求
）没有切换追踪，它构建得很好，只需返回实际请求。我更新了我的帖子，找到了解决问题的方法。。。。但我不确定这是否是平面图的正确方法。。。你有什么建议？@user805981不，完全不建议将嵌套调用放入Observable，你应该使用类似
flatMap
does的链接，请参阅我的更新答案
无法将类型为“Observable”（又名“Observable”）的值转换为预期的参数类型（[\u]）使用您的方法抛出->\u'
现在给我以下信息。。。是的，确实你必须在某一点上进行转换，但这很奇怪，因为你忽略了结果，这不必要。你会建议我怎么做？我查看了Observable.zip返回类型，它看起来是
Observable
，与函数返回类型不一致。。。