डायनेमिक सेल हाइट्स के साथ UITableView का पुनः लोडडाटा () जंपिंग स्क्रॉलिंग का कारण बनता है

Question

मुझे लगता है कि यह एक सामान्य मुद्दा हो सकता है और सोच रहा था कि क्या इसका कोई सामान्य समाधान था।

असल में, मेरे UITableView में हर सेल के लिए डायनेमिक सेल हाइट हैं। अगर मैं UITableView और I के शीर्ष पर नहीं हूं tableView.reloadData(), तो स्क्रॉल करना उछल जाता है।

मेरा मानना ​​है कि यह इस तथ्य के कारण है कि क्योंकि मैंने डेटा को पुनः लोड किया है, जैसा कि मैं ऊपर स्क्रॉल कर रहा हूं, यूआईटेबल्यूव दृश्यता में आने वाले प्रत्येक सेल के लिए ऊंचाई पुन: गणना कर रहा है। मैं इसे कैसे कम करूं, या मैं केवल एक निश्चित IndexPath से UITableView के अंत तक कैसे पुनः लोड करूं?

इसके अलावा, जब मैं शीर्ष पर सभी तरह से स्क्रॉल करने का प्रबंधन करता हूं, तो मैं वापस नीचे और फिर ऊपर स्क्रॉल कर सकता हूं, कोई भी समस्या नहीं कूदने के साथ। यह सबसे अधिक संभावना है क्योंकि UITableViewCell ऊंचाइयों की गणना पहले से ही की गई थी।

Comments

कुछ बातें ... (1) हाँ आप निश्चित रूप से कुछ पंक्तियों का उपयोग करके पुनः लोड कर सकते हैं reloadRowsAtIndexPaths। लेकिन (2) "उछल" से आपका क्या मतलब है और (3) आपने एक अनुमानित पंक्ति ऊंचाई निर्धारित की है? (बस यह पता लगाने की कोशिश कर रहा है कि क्या कोई बेहतर समाधान है जो आपको गतिशील रूप से तालिका को अपडेट करने की अनुमति देगा।)

— लिंडसे स्कॉट

@ लिंडसेकॉट, हाँ, मैंने एक अनुमानित पंक्ति ऊंचाई निर्धारित की है। उछल-कूद करने से मेरा मतलब है कि जैसे-जैसे मैं ऊपर स्क्रॉल करता हूँ, पंक्तियाँ ऊपर की ओर खिसकती जाती हैं। मेरा मानना ​​है कि ऐसा इसलिए है क्योंकि मैंने अनुमानित पंक्ति की ऊँचाई १२ I निर्धारित की है, और फिर जैसे ही मैं ऊपर स्क्रॉल करता हूँ, यूआईटेबल व्यू में ऊपर की मेरी सभी पोस्टें छोटी हो जाती हैं, इसलिए यह ऊँचाई को सिकोड़ देती है, जिससे मेरी तालिका उछल जाती है। मैं xअपने TableView में पंक्ति से अंतिम पंक्ति तक reloadRowsAtIndexPaths करने के बारे में सोच रहा हूँ ... लेकिन क्योंकि मैं नई पंक्तियाँ डाल रहा हूँ, तो यह काम नहीं करेगा, मुझे पता नहीं होगा कि मेरे पुनः लोड होने से पहले मेरे टेबलव्यू का अंत क्या होगा आँकड़े।

— डेविड

@ लिंडसेकॉट अभी भी मैं समस्या का समाधान नहीं कर सकता, क्या कोई अच्छा समाधान है?

— राड

क्या आपको कभी इस समस्या का हल मिला? मैं ठीक वैसी ही समस्या का सामना कर रहा हूं जैसा कि आपके वीडियो में देखा गया है।

— user3344977

नीचे दिए गए किसी भी उत्तर ने मेरे लिए काम नहीं किया।

— सुरजन सिम्हा

Answer 1

कूदने से रोकने के लिए आपको कोशिकाओं की ऊँचाई को बचाना चाहिए जब वे लोड करते हैं और सटीक मूल्य देते हैं tableView:estimatedHeightForRowAtIndexPath:

स्विफ्ट:

var cellHeights = [IndexPath: CGFloat]()

func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
    cellHeights[indexPath] = cell.frame.size.height
}

func tableView(_ tableView: UITableView, estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {
    return cellHeights[indexPath] ?? UITableView.automaticDimension
}

उद्देश्य सी:

// declare cellHeightsDictionary
NSMutableDictionary *cellHeightsDictionary = @{}.mutableCopy;

// declare table dynamic row height and create correct constraints in cells
tableView.rowHeight = UITableViewAutomaticDimension;

// save height
- (void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath {
    [cellHeightsDictionary setObject:@(cell.frame.size.height) forKey:indexPath];
}

// give exact height value
- (CGFloat)tableView:(UITableView *)tableView estimatedHeightForRowAtIndexPath:(NSIndexPath *)indexPath {
    NSNumber *height = [cellHeightsDictionary objectForKey:indexPath];
    if (height) return height.doubleValue;
    return UITableViewAutomaticDimension;
}

Comments

धन्यवाद, u वास्तव में मेरा दिन बचाओ :) objc में भी काम करता है

— Artem Z.

इनिशियलाइज़ करना न भूलें cellHeightsDictionary: cellHeightsDictionary = [NSMutableDictionary dictionary];

— Gerharbo

estimatedHeightForRowAtIndexPath:एक दोहरा मान देता है एक *** Assertion failure in -[UISectionRowData refreshWithSection:tableView:tableViewRowData:]त्रुटि का कारण हो सकता है । इसके return floorf(height.floatValue);बजाय इसे ठीक करने के लिए ।

— लीशुआइकोबे

हाय @lgor, मैं एक ही समस्या है और अपने समाधान को लागू करने की कोशिश कर रहा हूँ। समस्या यह है कि मैं अनुमान लगा रहा हूं। HightightForRowAtIndexPath को willDisplayCell से पहले कॉल किया जाता है, इसलिए कोशिका की ऊँचाई की गणना तब नहीं की जाती है जब अनुमानित HHightForRowAtIndexPath कहा जाता है। कोई मदद?

— माधुरी

@ मैधुरी प्रभावी ऊंचाइयों की गणना "ऊँचाईफोर राउटइंडेक्सपैथ" में की जानी चाहिए, जिसे विलडिसप्लेसेल से ठीक पहले स्क्रीन पर प्रत्येक सेल के लिए कहा जाता है, जो अनुमानित राउरहाइट (टेबल रीलोड) में बाद के उपयोग के लिए शब्दकोश में ऊंचाई निर्धारित करेगा।

— डोनिट

Answer 2

स्वीकृत उत्तर का स्विफ्ट 3 संस्करण।

var cellHeights: [IndexPath : CGFloat] = [:]


func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
    cellHeights[indexPath] = cell.frame.size.height
}

func tableView(_ tableView: UITableView, estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {
    return cellHeights[indexPath] ?? 70.0 
}

Comments

धन्यवाद इस महान काम किया! वास्तव में मैं अपने कार्यान्वयन को हटाने में सक्षम था func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {, यह मेरे लिए आवश्यक सभी ऊंचाई गणना को संभालता है।

— नतालिया

लगातार कूदने के साथ कई घंटे संघर्ष करने के बाद मुझे लगा कि मैं UITableViewDelegateअपनी कक्षा में जोड़ना भूल गया हूं। उस प्रोटोकॉल के अनुरूप होना आवश्यक है क्योंकि इसमें ऊपर दिखाया गया willDisplayकार्य है। मुझे आशा है कि मैं किसी को उसी संघर्ष को बचा सकता हूं।

— MJQZ1347

स्विफ्ट जवाब के लिए धन्यवाद। मेरे मामले में, मैं कुछ सुपर अजीब व्यवहार कर रहा था जब पुनः लोड होने पर नीचे से / के पास तालिका दृश्य स्क्रॉल किया गया था। जब भी मेरे पास सेल्फी सेल होगा, मैं अभी से इसका इस्तेमाल करूंगा।

— ट्रेव 14

स्विफ्ट 4.2

— एडम एस

एक जीवन रक्षक। जब डेटा स्रोत में अधिक आइटम जोड़ने की कोशिश कर रहा है तो उपयोगी है। स्क्रीन के केंद्र में नए जोड़े गए कोशिकाओं को कूदने से रोकता है।

— फिलिप बोरबन

Answer 3

छलांग एक खराब अनुमानित ऊंचाई के कारण है। अधिक अनुमानितRowHight वास्तविक ऊँचाई से भिन्न होता है और तालिका अधिक उछल सकती है जब इसे विशेष रूप से पुनः लोड किया जाता है और इसे नीचे स्क्रॉल किया गया होता है। ऐसा इसलिए है क्योंकि तालिका का अनुमानित आकार मौलिक रूप से इसके वास्तविक आकार से भिन्न होता है, जिससे तालिका इसकी सामग्री आकार और ऑफसेट को समायोजित करने के लिए मजबूर होती है। तो अनुमानित ऊंचाई एक यादृच्छिक मूल्य नहीं होनी चाहिए, लेकिन आपको लगता है कि ऊंचाई क्या होने वाली है। मैंने यह भी अनुभव किया है कि जब मैं सेट करता हूं UITableViewAutomaticDimension तो आपकी कोशिकाएं समान होती हैं

func viewDidLoad() {
     super.viewDidLoad()
     tableView.estimatedRowHeight = 100//close to your cell height
}

यदि आपके पास विभिन्न वर्गों में विभिन्न प्रकार की कोशिकाएं हैं तो मुझे लगता है कि बेहतर जगह है

func tableView(tableView: UITableView, estimatedHeightForRowAtIndexPath indexPath: NSIndexPath) -> CGFloat {
     //return different sizes for different cells if you need to
     return 100
}

Comments

धन्यवाद, यह वास्तव में यही है कि मेरा टेबल व्यू इतना उछल गया था।

— लुइस डे डेकर

एक पुराना उत्तर, लेकिन यह 2018 के अनुसार अभी भी वास्तविक है। अन्य सभी उत्तरों के विपरीत, यह एक बार viewDidLoad में अनुमानितRowHeigh की स्थापना का सुझाव देता है, जो तब मदद करता है जब कोशिकाएं समान या बहुत समान ऊंचाई की होती हैं। Thanx। BTW, वैकल्पिक रूप से परिमार्जित RowHeight को इंस्पेक्टर बिल्डर के माध्यम से साइज इंस्पेक्टर> टेबल व्यू> एस्टीमेट में सेट किया जा सकता है।

— विटालि

अधिक सटीक अनुमानित ऊंचाई प्रदान करने से मुझे मदद मिली। मेरे पास एक बहु-खंड समूहीकृत तालिका दृश्य शैली थी, और इसे लागू करना थाtableView(_:estimatedHeightForHeaderInSection:)

— nteissler

Answer 4

@ आईजीआर उत्तर इस मामले में ठीक काम कर रहा है, इसकाSwift-4कोड।

// declaration & initialization  
var cellHeightsDictionary: [IndexPath: CGFloat] = [:]  

निम्नलिखित विधियों में UITableViewDelegate

func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
  // print("Cell height: \(cell.frame.size.height)")
  self.cellHeightsDictionary[indexPath] = cell.frame.size.height
}

func tableView(_ tableView: UITableView, estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {
  if let height =  self.cellHeightsDictionary[indexPath] {
    return height
  }
  return UITableView.automaticDimension
}

Comments

इस समाधान का उपयोग करके पंक्ति प्रविष्टि / विलोपन से कैसे निपटें? शब्दकोश डेटा वास्तविक नहीं है, TableView कूदता है।

— एलेक्सी चेक्कनोव

बहुत अच्छा काम करता है! विशेष रूप से अंतिम सेल पर जब पंक्ति को फिर से लोड करें।

— निंग

Answer 5

मैंने ऊपर दिए गए सभी वर्कअराउंड की कोशिश की है, लेकिन कुछ भी काम नहीं किया।

घंटों बिताने और सभी संभावित निराशाओं से गुजरने के बाद, इसे ठीक करने का एक तरीका निकाला। यह समाधान एक जीवन रक्षक है! एक जादू की तरह काम किया!

स्विफ्ट 4

let lastContentOffset = tableView.contentOffset
tableView.beginUpdates()
tableView.endUpdates()
tableView.layer.removeAllAnimations()
tableView.setContentOffset(lastContentOffset, animated: false)

मैंने इसे एक एक्सटेंशन के रूप में जोड़ा, जिससे कोड को साफ-सुथरा बनाया जा सके और हर बार जब मैं पुनः लोड करना चाहता हूं तो इन सभी लाइनों को लिखने से बचें।

extension UITableView {

    func reloadWithoutAnimation() {
        let lastScrollOffset = contentOffset
        beginUpdates()
        endUpdates()
        layer.removeAllAnimations()
        setContentOffset(lastScrollOffset, animated: false)
    }
}

आखिरकार ..

tableView.reloadWithoutAnimation()

या आप वास्तव में अपनी UITableViewCell awakeFromNib()विधि में इन रेखाओं को जोड़ सकते हैं

layer.shouldRasterize = true
layer.rasterizationScale = UIScreen.main.scale

और सामान्य करो reloadData()

Comments

यह कोई पुनः लोडिंग कैसे करता है? आप इसे कहते हैं reloadWithoutAnimationलेकिन reloadहिस्सा कहाँ है ?

— मैट

@ आप tableView.reloadData()पहले कॉल कर सकते थे और फिर tableView.reloadWithoutAnimation(), यह अभी भी काम करता है।

— सर्जन सिम्हा

महान! ऊपर से किसी ने भी मेरे लिए काम नहीं किया। यहां तक ​​कि सभी ऊंचाइयों और अनुमानित ऊंचाई पूरी तरह से समान हैं। दिलचस्प।

— TY कुचुक

मेरे लिए काम मत करो। यह tableView.endUpdates () पर क्रैश है। क्या कोई मेरी मदत कर सकता है!

— काकाशी

Answer 6

मैं इसे ठीक करने के तरीकों का अधिक उपयोग करता हूं:

नियंत्रक के लिए:

var cellHeights: [IndexPath : CGFloat] = [:]


func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
    cellHeights[indexPath] = cell.frame.size.height
}

func tableView(_ tableView: UITableView, estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {
    return cellHeights[indexPath] ?? 70.0 
}

UITableView के विस्तार के रूप में

extension UITableView {
  func reloadSectionWithouAnimation(section: Int) {
      UIView.performWithoutAnimation {
          let offset = self.contentOffset
          self.reloadSections(IndexSet(integer: section), with: .none)
          self.contentOffset = offset
      }
  }
}

परिणाम है

tableView.reloadSectionWithouAnimation(section: indexPath.section)

Comments

मेरे लिए कुंजी यहाँ उनके UITableView एक्सटेंशन को लागू कर रही थी। बहुत चालाक। धन्यवाद rastislv

— BennTheNerd

पूरी तरह से काम करता है, लेकिन इसमें केवल एक खामी है, आप हेडर, फुटर या रो सम्मिलित करते समय एनीमेशन खो देते हैं।

— सूफियान होसम

पुन: लोड कहाँ किया जाएगा उदाहरण के लिए, उपयोगकर्ता मेरे ऐप में एक छवि पोस्ट कर सकते हैं (जैसे इंस्टाग्राम); मैं आकार बदलने के लिए चित्र प्राप्त कर सकता हूं, लेकिन ज्यादातर मामलों में मुझे ऐसा करने के लिए तालिका सेल ऑफ स्क्रैच को स्क्रॉल करना होगा। मैं चाहता हूं कि तालिका के पुनः लोड होने के बाद सेल सही आकार का हो।

— ल्यूक इरविन

Answer 7

मैंने आज इसमें भाग लिया और देखा:

1. यह वास्तव में केवल iOS 8 है।
2. ओवरराइडिंग cellForRowAtIndexPathमदद नहीं करता है।

फिक्स वास्तव में बहुत आसान था:

ओवरराइड करें estimatedHeightForRowAtIndexPathऔर सुनिश्चित करें कि यह सही मान लौटाता है।

इसके साथ, मेरे UITableViews में सभी अजीब घबराना और कूदना बंद हो गया है।

नोट: मुझे वास्तव में मेरी कोशिकाओं का आकार पता है। केवल दो संभावित मान हैं। अपनी कोशिकाओं को सही मायने में चर-आकार के होते हैं, तो आप कैश करने के लिए चाहते हो सकता है cell.bounds.size.heightसेtableView:willDisplayCell:forRowAtIndexPath:

Comments

फिक्स्ड यह एक उच्च मूल्य के साथ अनुमानित हाईटॉरराउटऑटइंडेक्सपैथ को ओवरराइड कर रहा है, उदाहरण के लिए 300f

— Flappy

@ यह दिलचस्प है कि आपके द्वारा प्रदान किया गया समाधान कैसे काम करता है और अन्य सुझाई गई तकनीकों से छोटा है। इसे उत्तर के रूप में पोस्ट करने पर विचार करें।

— रोहन सानप

Answer 8

आप वास्तव में उपयोग करके reloadRowsAtIndexPaths, केवल कुछ पंक्तियों को पुनः लोड कर सकते हैं , उदा:

tableView.reloadRowsAtIndexPaths(indexPathArray, withRowAnimation: UITableViewRowAnimation.None)

लेकिन, सामान्य तौर पर, आप टेबल सेल की ऊँचाई को भी बदल सकते हैं, जैसे:

tableView.beginUpdates()
tableView.endUpdates()

Comments

मैंने startUpdates / endUpdates विधि की कोशिश की है, लेकिन यह केवल मेरी तालिका की दृश्य पंक्तियों को प्रभावित करता है। मेरे पास अभी भी समस्या है जब मैं स्क्रॉल करता हूं।

— डेविड

@ डेविड संभवत: क्योंकि आप अनुमानित पंक्ति ऊंचाइयों का उपयोग कर रहे हैं।

— लिंडसे स्कॉट

क्या मुझे अपने एस्टिमेटेडRowHeights से छुटकारा पाना चाहिए, और इसके बजाय इसे startUpdates और endUpdates से बदलना चाहिए?

— डेविड

@ डेविड आप कुछ भी "रिप्लेस" नहीं करेंगे, लेकिन यह वास्तव में वांछित व्यवहार पर निर्भर करता है ... यदि आप अनुमानित पंक्तियों की ऊंचाई का उपयोग करना चाहते हैं और तालिका के वर्तमान दृश्य भाग के नीचे इंडेक्स को फिर से लोड करना चाहते हैं, तो आप ऐसा कर सकते हैं मैंने reloadRowsAtIndexPaths

— Lyndsey Scott

ReladRowsAtIndexPaths विधि को आज़माने के साथ मेरा एक मुद्दा यह है कि मैं अनंत स्क्रॉलिंग को लागू कर रहा हूं, इसलिए जब मैं पुनः लोड कर रहा हूं तो यह है क्योंकि अभी मैंने डेटा स्रोत में 15 और पंक्तियाँ जोड़ी हैं। इसका मतलब यह है कि उन पंक्तियों के लिए IndexPaths अभी तक UITableView में मौजूद नहीं हैं

— डेविड

Answer 9

यहाँ थोड़ा छोटा संस्करण है:

func tableView(_ tableView: UITableView, estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {
    return self.cellHeightsDictionary[indexPath] ?? UITableViewAutomaticDimension
}

Answer 10

एक उच्च मूल्य के साथ अनुमानित हाईटॉर रोवरऑटइंडेक्सपैथ को ओवरराइड करना, उदाहरण के लिए 300 एफ

इससे समस्या हल हो जानी चाहिए :)

Answer 11

एक बग है जो मुझे लगता है कि iOS11 में पेश किया गया था।

जब आप एक reloadटेबलव्यू करते हैं तो contentOffSetअप्रत्याशित रूप से बदल जाता है। वास्तव में contentOffsetएक लोड के बाद नहीं बदलना चाहिए। यह गलतफहमी के कारण होता हैUITableViewAutomaticDimension

आप अपने को बचाने के लिए है contentOffSetऔर अपने पुनः लोड समाप्त होने के बाद इसे अपने सहेजे गए मान पर सेट करें।

func reloadTableOnMain(with offset: CGPoint = CGPoint.zero){

    DispatchQueue.main.async { [weak self] () in

        self?.tableView.reloadData()
        self?.tableView.layoutIfNeeded()
        self?.tableView.contentOffset = offset
    }
}

आप इसका उपयोग कैसे करते हैं?

someFunctionThatMakesChangesToYourDatasource()
let offset = tableview.contentOffset
reloadTableOnMain(with: offset)

यह उत्तर यहाँ से लिया गया था

Answer 12

इसने मेरे लिए स्विफ्ट 4 में काम किया:

extension UITableView {

    func reloadWithoutAnimation() {
        let lastScrollOffset = contentOffset
        reloadData()
        layoutIfNeeded()
        setContentOffset(lastScrollOffset, animated: false)
    }
}

Answer 13

इनमें से किसी भी समाधान ने मेरे लिए काम नहीं किया। यहां मैंने स्विफ्ट 4 और एक्सकोड 10.1 के साथ क्या किया ...

ViewDidLoad () में, तालिका की डायनेमिक पंक्ति की ऊँचाई घोषित करें और कोशिकाओं में सही अवरोध बनाएँ ...

tableView.rowHeight = UITableView.automaticDimension

इसके अलावा देखने के लिए (), इस तरह से टेबलव्यू के लिए अपने सभी टेबल व्यू सेल की निब को रजिस्टर करें:

tableView.register(UINib(nibName: "YourTableViewCell", bundle: nil), forCellReuseIdentifier: "YourTableViewCell")
tableView.register(UINib(nibName: "YourSecondTableViewCell", bundle: nil), forCellReuseIdentifier: "YourSecondTableViewCell")
tableView.register(UINib(nibName: "YourThirdTableViewCell", bundle: nil), forCellReuseIdentifier: "YourThirdTableViewCell")

TableView heightForRowAt में, indexPath.row पर प्रत्येक सेल की ऊँचाई के बराबर ऊँचाई लौटें ...

func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {

    if indexPath.row == 0 {
        let cell = Bundle.main.loadNibNamed("YourTableViewCell", owner: self, options: nil)?.first as! YourTableViewCell
        return cell.layer.frame.height
    } else if indexPath.row == 1 {
        let cell = Bundle.main.loadNibNamed("YourSecondTableViewCell", owner: self, options: nil)?.first as! YourSecondTableViewCell
        return cell.layer.frame.height
    } else {
        let cell = Bundle.main.loadNibNamed("YourThirdTableViewCell", owner: self, options: nil)?.first as! YourThirdTableViewCell
        return cell.layer.frame.height
    } 

}

अब प्रत्येक कक्ष के लिए अनुमानित पंक्ति ऊंचाई दे। जैसा कि आप कर सकते हैं सटीक रहें ...

func tableView(_ tableView: UITableView, estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {

    if indexPath.row == 0 {
        return 400 // or whatever YourTableViewCell's height is
    } else if indexPath.row == 1 {
        return 231 // or whatever YourSecondTableViewCell's height is
    } else {
        return 216 // or whatever YourThirdTableViewCell's height is
    } 

}

यह काम करना चाहिए ...

TableView.reloadData () को कॉल करते समय मुझे सामग्री को सहेजने और सेट करने की आवश्यकता नहीं थी

Answer 14

मेरे पास 2 अलग सेल हाइट हैं।

func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
        let cellHeight = CGFloat(checkIsCleanResultSection(index: indexPath.row) ? 130 : 160)
        return Helper.makeDeviceSpecificCommonSize(cellHeight)
    }

के बाद मैंने अनुमान लगाया कि HightForRowAt , और अधिक कूद नहीं था।

func tableView(_ tableView: UITableView, estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {
    let cellHeight = CGFloat(checkIsCleanResultSection(index: indexPath.row) ? 130 : 160)
    return Helper.makeDeviceSpecificCommonSize(cellHeight)
}

Answer 15

cell.layoutSubviews()सेल में लौटने से पहले कॉल करने का प्रयास करें func cellForRowAtIndexPath(_ indexPath: NSIndexPath) -> UITableViewCell?। यह iOS8 में बग के रूप में जाना जाता है।

Answer 16

आप निम्नलिखित का उपयोग कर सकते हैं ViewDidLoad()

tableView.estimatedRowHeight = 0     // if have just tableViewCells <br/>

// use this if you have tableview Header/footer <br/>
tableView.estimatedSectionFooterHeight = 0 <br/>
tableView.estimatedSectionHeaderHeight = 0

Answer 17

मेरे पास यह कूदने वाला व्यवहार था और मैं शुरू में सटीक अनुमानित हेडर ऊंचाई निर्धारित करके इसे कम करने में सक्षम था (क्योंकि मेरे पास केवल 1 संभावित हेडर दृश्य था), लेकिन फिर कूदता अंदर होने लगा हेडर के विशेष रूप , पूरी तालिका को अब और प्रभावित नहीं किया।

यहां जवाबों के बाद, मेरे पास यह सुराग था कि यह एनिमेशन से संबंधित था, इसलिए मैंने पाया कि टेबल व्यू एक स्टैक व्यू के अंदर था, और कभी-कभी हम stackView.layoutIfNeeded()एनीमेशन ब्लॉक के अंदर कॉल करते थे । मेरा अंतिम समाधान यह सुनिश्चित करने के लिए था कि यह कॉल तब तक नहीं होगा जब तक कि "वास्तव में" की आवश्यकता न हो, क्योंकि लेआउट "यदि आवश्यक हो" तो उस संदर्भ में दृश्य व्यवहार था जब "आवश्यक नहीं" भी।

Answer 18

मेरी भी यही समस्या थी। मेरे पास एनीमेशन के बिना पेजेशन और रीलोडिंग डेटा था, लेकिन इसने जंपिंग को रोकने में स्क्रॉल की मदद नहीं की। मेरे पास आईफ़ोन के विभिन्न आकार हैं, स्क्रॉल iphone8 पर उछल नहीं रहा था लेकिन यह iphone7 + पर उछल रहा था

मैंने viewDidLoad फ़ंक्शन पर निम्नलिखित परिवर्तन लागू किए हैं :

    self.myTableView.estimatedRowHeight = 0.0
    self.myTableView.estimatedSectionFooterHeight = 0
    self.myTableView.estimatedSectionHeaderHeight = 0

और मेरी समस्या हल हो गई। मुझे उम्मीद है कि यह आपकी भी मदद करेगा।

Answer 19

इस समस्या को हल करने के लिए एक दृष्टिकोण जो मुझे मिला है

CATransaction.begin()
UIView.setAnimationsEnabled(false)
CATransaction.setCompletionBlock {
   UIView.setAnimationsEnabled(true)
}
tableView.reloadSections([indexPath.section], with: .none)
CATransaction.commit()

Answer 20

वास्तव में मैंने पाया अगर आप reloadRowsएक कूद समस्या पैदा करने का उपयोग करें । तो आप reloadSectionsइस तरह का उपयोग करने की कोशिश करनी चाहिए :

UIView.performWithoutAnimation {
    tableView.reloadSections(NSIndexSet(index: indexPath.section) as IndexSet, with: .none)
}