Ios 如何结合`@dynamicMemberLookup`和`ExpressibleByStringInterpolation`来实现方法链

dynamicMemberLookup不处理函数调用.为了能够呼叫查询到的成员，您可以使用@dynamicCallable.你也可以用callAsFunction做类似的事情.

我认为对此建模的一种更简单的方法是只有更多的"基本"用例，对JS语法树建模.

@dynamicMemberLookup
@dynamicCallable
enum JSCall {
    case stringLiteral(String)
    case integerLiteral(Int)
    // add more literal cases if you like
    case call(String, args: [JSCall])
    case property(String)
    indirect case chain(JSCall, JSCall)

    var value: String {
        switch self {
        case let .call(functionName, args):
            let argList = args.map(\.value)
                .joined(separator: ", ")
            return "\(functionName)(\(argList))"
        case .property(let name):
            return name
        case .chain(let first, let second):
            return "\(first.value).\(second.value)"
        case .stringLiteral(let s):
            return "'\(s)'" // note that this does not escape quotes in the JS string!
        case .integerLiteral(let i):
            return "\(i)"
        }
    }

    // ...
}

当你动态查找一个成员时，创建一个chain，第二件事是property.这与foo.bar这样的 case 相对应

subscript(dynamicMember propertyName: String) -> JSCall {
    return .chain(self, .property(propertyName))
}

然后，在类似foo.bar("bar")的情况下，您将隐式调用(foo.bar).dynamicallyCall(withArguments: [.stringLiteral("baz")]).这应该返回.chain(foo, .call("bar", [.stringLiteral("baz")])).

func dynamicallyCall(withArguments args: JSCall...) -> JSCall {
    switch self {
    case .property(let name):
        return .call(name, args: args)
    case .chain(let first, let second):
        // note the recursive call here:
        return .chain(first, second.dynamicallyCall(withArguments: args))
    default:
        fatalError("Cannot call this!")
    }
}

字面上的大小写可以符合ExpressibleByXXXLiteral:

extension JSCall: ExpressibleByStringLiteral, ExpressibleByIntegerLiteral {
    init(stringLiteral value: String) {
        self = .stringLiteral(value)
    }
    
    init(integerLiteral value: Int) {
        self = .integerLiteral(value)
    }
}

这就是所有的基础设施.现在，您可以添加一些方便的静态工厂和属性:

static let document = JSCall.property("document")

static func getElement(_ id: String) -> JSCall {
    document.getElementById(.stringLiteral(id))
}

static func getInnerHTML(_ id: String) -> JSCall {
    getElement(id).innerHTML
}

static func removeAttribute(id: String, attributeName: String) -> JSCall {
    getElement(id).removeAttribute(.stringLiteral(attributeName))
}

用途:

let one = JSCall.document.getElementById("foo").value
let two = JSCall.removeAttribute(id: "bar", attributeName: "attr").somethingElse.value
print(one) // document.getElementById('foo')
print(two) // document.getElementById('bar').removeAttribute('attr').somethingElse