能否通过桥接头文件将OC的NSError回调块转为Swift抛出式闭包？

Absolutely—this is totally achievable! The default Swift bridging for your Objective-C method uses an optional Error parameter in the closure because that's how Objective-C traditionally handles error callbacks, but we can wrap or adapt it to match the throws style you want.

Let's break down two common approaches depending on whether you can modify the original Objective-C code or not:

1. If You Can Modify the Objective-C Code #

You can create a compatibility category to expose a method that maps directly to Swift's throws pattern. Here's how:

First, add an Objective-C category for your Test class:

// Test+SwiftThrows.h
#import "Test.h"

@interface Test (SwiftThrows)
// Use NS_SWIFT_THROWS to signal Swift this method can throw errors
- (void)doSomethingWithThrows:(void (^)(void))block NS_SWIFT_THROWS;
@end

Then implement the category to wrap your original method:

// Test+SwiftThrows.m
#import "Test+SwiftThrows.h"

@implementation Test (SwiftThrows)
- (void)doSomethingWithThrows:(void (^)(void))block {
    [self doSomething:^(NSError *error) {
        if (error) {
            // Throw the error so Swift can catch it as a thrown error
            @throw error;
        }
        // Execute the provided block once no error exists
        block();
    }];
}
@end

Add the category header to your bridging header, and Swift will expose it as:

func doSomethingWithThrows(block: () throws -> Void) throws

2. If You Can't Modify the Objective-C Code (Swift-Only Wrapper) #

If you can't touch the Objective-C implementation, create a Swift extension to wrap the bridged method. The approach varies slightly depending on whether your original method runs synchronously or asynchronously:

For Synchronous Execution #

If your doSomething: method calls the callback immediately (synchronously), use this simple wrapper:

extension Test {
    func doSomething(block: () throws -> Void) throws {
        var callbackError: Error?
        
        // Call the original bridged method
        self.doSomething { error in
            callbackError = error
        }
        
        // Throw if the callback returned an error
        if let error = callbackError {
            throw error
        }
        
        // Execute the throwing block and propagate any errors
        try block()
    }
}

For Asynchronous Execution #

If the method runs asynchronously (the callback is called later), use Swift's withCheckedThrowingContinuation to convert the callback pattern to an async/throws method:

extension Test {
    func doSomething(block: @escaping () throws -> Void) async throws {
        try await withCheckedThrowingContinuation { continuation in
            self.doSomething { error in
                if let error = error {
                    continuation.resume(throwing: error)
                    return
                }
                
                do {
                    try block()
                    continuation.resume()
                } catch {
                    continuation.resume(throwing: error)
                }
            }
        }
    }
}

Key Notes #

• The NS_SWIFT_THROWS macro tells Swift that an Objective-C method can throw errors, which maps directly to Swift's throws keyword.
• For asynchronous methods, using async/throws with continuations is the idiomatic Swift approach, aligning with modern concurrency patterns.

Either way, you'll get the method signature you're aiming for, making the Swift code feel more native and aligned with Swift's error handling conventions.

内容的提问来源于stack exchange，提问作者Francesco Xu