Możesz użyć obserwacji wartości klucza (KVO)...

In your ViewController:

- (void)viewDidLoad {
    ...
    [self.webView.scrollView addObserver:self forKeyPath:@"contentSize" options:NSKeyValueObservingOptionNew context:nil];
}


- (void)dealloc
{
    [self.webView.scrollView removeObserver:self forKeyPath:@"contentSize" context:nil];
}


- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(NSDictionary *)change
                       context:(void *)context
{
    if (object == self.webView.scrollView && [keyPath isEqual:@"contentSize"]) {
        // we are here because the contentSize of the WebView's scrollview changed.

        UIScrollView *scrollView = self.webView.scrollView;
        NSLog(@"New contentSize: %f x %f", scrollView.contentSize.width, scrollView.contentSize.height);
    }
}

Zapisałoby to użycie JavaScript i utrzymywałoby cię w pętli na wszystkich zmianach.

Sam musiałem się ostatnio z tym uporać. W końcu korzystałem z modyfikacji rozwiązania zaproponowanego przez Chrisa Mcclenaghana.

I dzieje się tak dlatego, że te elementy mogą zostać zmienione Po załadowaniu strony. Tak więc wysokość zwrócona w onLoad zawsze będzie prawidłowa. Ale będzie to poprawne tylko dla tego konkretnego przypadku. Obejście polega na monitorowaniu zmiany wysokości body i reagowaniu na nią.

Zmiana rozmiaru monitora document.body

var shouldListenToResizeNotification = false
lazy var webView:WKWebView = {
    //Javascript string
    let source = "window.onload=function () {window.webkit.messageHandlers.sizeNotification.postMessage({justLoaded:true,height: document.body.scrollHeight});};"
    let source2 = "document.body.addEventListener( 'resize', incrementCounter); function incrementCounter() {window.webkit.messageHandlers.sizeNotification.postMessage({height: document.body.scrollHeight});};"

    //UserScript object
    let script = WKUserScript(source: source, injectionTime: .atDocumentEnd, forMainFrameOnly: true)

    let script2 = WKUserScript(source: source2, injectionTime: .atDocumentEnd, forMainFrameOnly: true)

    //Content Controller object
    let controller = WKUserContentController()

    //Add script to controller
    controller.addUserScript(script)
    controller.addUserScript(script2)

    //Add message handler reference
    controller.add(self, name: "sizeNotification")

    //Create configuration
    let configuration = WKWebViewConfiguration()
    configuration.userContentController = controller

    return WKWebView(frame: CGRect.zero, configuration: configuration)
}()

func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) {
    guard let responseDict = message.body as? [String:Any],
    let height = responseDict["height"] as? Float else {return}
    if self.webViewHeightConstraint.constant != CGFloat(height) {
        if let _ = responseDict["justLoaded"] {
            print("just loaded")
            shouldListenToResizeNotification = true
            self.webViewHeightConstraint.constant = CGFloat(height)
        }
        else if shouldListenToResizeNotification {
            print("height is \(height)")
            self.webViewHeightConstraint.constant = CGFloat(height)
        }

    }
}

To rozwiązanie jest zdecydowanie najbardziej eleganckie, jakie mogłem wymyślić. Są jednak dwie rzeczy, o których powinieneś wiedzieć.

Po pierwsze, przed załadowaniem adresu URL należy ustawić shouldListenToResizeNotification na false. Ta dodatkowa logika jest potrzebna w przypadkach, gdy załadowany adres URL może się szybko zmienić. Gdy tak się stanie, powiadomienia ze starej zawartości z jakiegoś powodu mogą pokrywać się z powiadomieniami z nowej zawartości. Aby zapobiec takim zachowaniom, stworzyłem tę zmienną. Zapewnia to, że po rozpoczęciu ładowania nowej zawartości nie przetwarzamy już powiadomień ze starego i wznawiamy przetwarzanie powiadomień o zmianie rozmiaru dopiero po załadowaniu nowej zawartości.

Najbardziej co ważne, musisz być tego świadomy:

Jeśli zastosujesz To rozwiązanie, musisz wziąć pod uwagę, że jeśli zmienisz rozmiar WKWebView na cokolwiek innego niż rozmiar zgłoszony przez powiadomienie-powiadomienie zostanie uruchomione ponownie .

Uważaj z tym, ponieważ łatwo jest wejść w nieskończoną pętlę. Na przykład, jeśli zdecydujesz się obsłużyć powiadomienie, czyniąc wysokość równą zgłoszonej wysokości + dodatkowe padding:

func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) {
        guard let responseDict = message.body as? [String:Float],
        let height = responseDict["height"] else {return}
        self.webViewHeightConstraint.constant = CGFloat(height+8)
    }

Jak widać, ponieważ dodaję 8 do zgłoszonej wysokości, po tym jak to się stanie rozmiar mojego body zmieni się i powiadomienie zostanie ponownie wysłane.

Bądź czujny w takich sytuacjach, a w przeciwnym razie powinieneś być w porządku.

I daj mi znać, jeśli odkryjesz jakiekolwiek problemy z tym rozwiązaniem - sam na nie liczę, więc najlepiej jest wiedzieć, czy są jakieś usterki, których nie zauważyłem!

Musisz poczekać na zakończenie ładowania widoku sieci Web. Oto działający przykład, którego użyłem

WKWebView content loaded function never get called

Następnie po zakończeniu ładowania webview możesz określić wysokość potrzebną przez

func webView(webView: WKWebView!, didFinishNavigation navigation: WKNavigation!) {

   println(webView.scrollView.contentSize.height)

}

Spróbuj wykonać następujące czynności. Gdziekolwiek tworzysz instancję swojej instancji WKWebView, dodaj coś podobnego do następującego:

    //Javascript string
    NSString * source = @"window.webkit.messageHandlers.sizeNotification.postMessage({width: document.width, height: document.height});";

    //UserScript object
    WKUserScript * script = [[WKUserScript alloc] initWithSource:source injectionTime:WKUserScriptInjectionTimeAtDocumentEnd forMainFrameOnly:YES];

    //Content Controller object
    WKUserContentController * controller = [[WKUserContentController alloc] init];

    //Add script to controller
    [controller addUserScript:script];

    //Add message handler reference
    [controller addScriptMessageHandler:self name:@"sizeNotification"];

    //Create configuration
    WKWebViewConfiguration * configuration = [[WKWebViewConfiguration alloc] init];

    //Add controller to configuration
    configuration.userContentController = controller;

    //Use whatever you require for WKWebView frame
    CGRect frame = CGRectMake(...?);

    //Create your WKWebView instance with the configuration
    WKWebView * webView = [[WKWebView alloc] initWithFrame:frame configuration:configuration];

    //Assign delegate if necessary
    webView.navigationDelegate = self;

    //Load html
    [webView loadHTMLString:@"some html ..." baseURL:[[NSBundle mainBundle] bundleURL]];

Następnie dodaj metodę podobną do poniższej, do której zawsze Klasa używa protokołu WKScriptMessageHandler do obsługi wiadomości:

- (void)userContentController:(WKUserContentController *)userContentController didReceiveScriptMessage:(WKScriptMessage *)message {
    CGRect frame = message.webView.frame;
    frame.size.height = [[message.body valueForKey:@"height"] floatValue];
    message.webView.frame = frame;}

Jeśli masz więcej niż tekst w dokumencie, może być konieczne zawinięcie javascript w ten sposób, aby upewnić się, że wszystko jest załadowane:

@"window.onload=function () { window.webkit.messageHandlers.sizeNotification.postMessage({width: document.width, height: document.height});};"

Uwaga: To rozwiązanie nie dotyczy bieżących aktualizacji do dokumentu.

Próbowałem widoku przewijania KVO i próbowałem Oceniać javascript na dokumencie, używając clientHeight, offsetHeight, itd...

W końcu udało mi się: document.body.scrollHeight. Możesz też użyć scrollHeight swojego najwyższego elementu, np. kontenera div.

Słucham zmian właściwości loading WKWebview przy użyciu KVO:

[webview addObserver: self forKeyPath: NSStringFromSelector(@selector(loading)) options: NSKeyValueObservingOptionNew context: nil];

A potem:

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context {
    if(object == self.webview && [keyPath isEqualToString: NSStringFromSelector(@selector(loading))]) {
        NSNumber *newValue = change[NSKeyValueChangeNewKey];
        if(![newValue boolValue]) {
            [self updateWebviewFrame];
        }
    }
}

Realizacja updateWebviewFrame:

[self.webview evaluateJavaScript: @"document.body.scrollHeight" completionHandler: ^(id response, NSError *error) {
     CGRect frame = self.webview.frame;
     frame.size.height = [response floatValue];
     self.webview.frame = frame;
}];

Używając odpowiedzi @Andriy i tej odpowiedzi udało mi się ustawić get height of contentSize w WKWebView I zmienić jego wysokość.

Oto Pełny kod swift 4:

    var neededConstraints: [NSLayoutConstraint] = []

    @IBOutlet weak var webViewContainer: UIView!
    @IBOutlet weak var webViewHeight: NSLayoutConstraint! {
        didSet {
            if oldValue != nil, oldValue.constant != webViewHeight.constant {
                view.layoutIfNeeded()
            }
        }
    }


   lazy var webView: WKWebView = {
        var source = """
var observeDOM = (function(){
    var MutationObserver = window.MutationObserver || window.WebKitMutationObserver,
        eventListenerSupported = window.addEventListener;

    return function(obj, callback){
        if( MutationObserver ){
            // define a new observer
            var obs = new MutationObserver(function(mutations, observer){
                if( mutations[0].addedNodes.length || mutations[0].removedNodes.length )
                    callback();
            });
            // have the observer observe foo for changes in children
            obs.observe( obj, { childList:true, subtree:true });
        }
        else if( eventListenerSupported ){
            obj.addEventListener('DOMNodeInserted', callback, false);
            obj.addEventListener('DOMNodeRemoved', callback, false);
        }
    };
})();

// Observe a specific DOM element:
observeDOM( document.body ,function(){
    window.webkit.messageHandlers.sizeNotification.postMessage({'scrollHeight': document.body.scrollHeight,'offsetHeight':document.body.offsetHeight,'clientHeight':document.body.clientHeight});
});

"""

        let script = WKUserScript(source: source, injectionTime: .atDocumentEnd, forMainFrameOnly: true)
        let controller = WKUserContentController()
        controller.addUserScript(script)
        controller.add(self, name: "sizeNotification")
        let configuration = WKWebViewConfiguration()
        configuration.userContentController = controller
        let this = WKWebView(frame: .zero, configuration: configuration)
        webViewContainer.addSubview(this)
        this.translatesAutoresizingMaskIntoConstraints = false
        this.scrollView.isScrollEnabled = false
        // constraint for webview when added to it's superview
        neededConstraints += NSLayoutConstraint.constraints(withVisualFormat: "H:|[web]|",
                                                            options: [],
                                                            metrics: nil,
                                                            views: ["web": this])
        neededConstraints += NSLayoutConstraint.constraints(withVisualFormat: "V:|[web]|",
                                                            options: [],
                                                            metrics: nil,
                                                            views: ["web": this])
        return this
    }()


    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        _  = webView // to create constraints needed for webView
        NSLayoutConstraint.activate(neededConstraints)
        let url = URL(string: "https://www.awwwards.com/")!
        let request = URLRequest(url: url)
        webView.load(request)
    }

    func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) {
        if let body = message.body as? Dictionary<String, CGFloat>,
            let scrollHeight = body["scrollHeight"],
            let offsetHeight = body["offsetHeight"],
            let clientHeight = body["clientHeight"] {
            webViewHeight.constant = scrollHeight
            print(scrollHeight, offsetHeight, clientHeight)
        }
    }

Musisz dodać opóźnienie, jego działa dla mnie, zamiast rozwiązań z js powyżej:

func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
    DispatchQueue.main.asyncAfter(deadline: .now() + 0.1, execute: {
        print(size: webView.scrollView.contentSize)
    })
}

Większość odpowiedzi używa "document.ciało.offsetHeight".

To ukrywa ostatni przedmiot ciała.

Pokonałem ten problem używając obserwatora KVO nasłuchującego zmian w WKWebview "contentSize", a następnie uruchamiając ten kod:

self.webView.evaluateJavaScript(
    "(function() {var i = 1, result = 0; while(true){result = 
    document.body.children[document.body.children.length - i].offsetTop + 
    document.body.children[document.body.children.length - i].offsetHeight;
    if (result > 0) return result; i++}})()",
    completionHandler: { (height, error) in
        let height = height as! CGFloat
        self.webViewHeightConstraint.constant = height
    }
)

Wypróbowałem wersję Javascript w UITableViewCell i działa idealnie. Jeśli jednak chcesz umieścić go w widoku przewijania. Nie wiem dlaczego, wysokość może być wyższa, ale nie może być krótsza. Jednak znalazłem rozwiązanie UIWebView tutaj. https://stackoverflow.com/a/48887971/5514452

Działa również w WKWebView. Myślę, że problem polega na tym, że WebView wymaga relayout, ale jakoś nie kurczy się i może tylko powiększyć. Musimy zresetować wysokość i na pewno będzie Zmień rozmiar.

Edit: resetuję wysokość Ramki po ustawieniu ograniczenia, ponieważ czasami nie będzie działać z powodu ustawienia wysokości ramki na 0.

func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
    self.webView.frame.size.height = 0
    self.webView.evaluateJavaScript("document.readyState", completionHandler: { (complete, error) in
        if complete != nil {
            self.webView.evaluateJavaScript("document.body.scrollHeight", completionHandler: { (height, error) in
                let webViewHeight = height as! CGFloat
                self.webViewHeightConstraint.constant = webViewHeight
                self.webView.frame.size.height = webViewHeight
            })
        }
    })
}