extension UIView {
    /** Loads instance from nib with the same name. */
    func loadNib() -> UIView {
        let bundle = Bundle(for: type(of: self))
        let nibName = type(of: self).description().components(separatedBy: ".").last!
        let nib = UINib(nibName: nibName, bundle: bundle)
        return nib.instantiate(withOwner: self, options: nil).first as! UIView
    }
}


extension UIViewController {
    static func loadFromNib() -> Self {
        func instantiateFromNib<T: UIViewController>() -> T {
            return T.init(nibName: String(describing: T.self), bundle: nil)
        }

        return instantiateFromNib()
    }
}

//1.Create UIView extension

extension UIView {
    class func initFromNib<T: UIView>() -> T {
        return Bundle.main.loadNibNamed(String(describing: self), owner: nil, options: nil)?[0] as! T
    }
}

//2. Create MyCustomView

class MyCustomView: UIView {

    @IBOutlet weak var messageLabel: UILabel!

    static func instantiate(message: String) -> MyCustomView {
        let view: MyCustomView = initFromNib()
        view.messageLabel.text = message
        return view
    }
}

ref:https://stackoverflow.com/a/52831749/3632832

Safe array:

extension Collection {
    subscript (safe index: Index) -> Element? {
        return indices.contains(index) ? self[index] : nil
    }
}

let data = [1, 3, 4]
data[safe: 1] // Optional(3)
data[safe: 10] // nil

//Fit view to parent

extension UIView {
    func pinEdges(to other: UIView) {
        leadingAnchor.constraint(equalTo: other.leadingAnchor).isActive = true
        trailingAnchor.constraint(equalTo: other.trailingAnchor).isActive = true
        topAnchor.constraint(equalTo: other.topAnchor).isActive = true
        bottomAnchor.constraint(equalTo: other.bottomAnchor).isActive = true
    }
}

func takeScreenshot(view: UIView) -> UIImageView {
        UIGraphicsBeginImageContext(view.frame.size)
        view.layer.renderInContext(UIGraphicsGetCurrentContext())
        let image = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
        UIImageWriteToSavedPhotosAlbum(image, nil, nil, nil)
        
        return UIImageView(image: image)
    }

public extension UITableView {
    
    /**
     Register nibs faster by passing the type - if for some reason the `identifier` is different then it can be passed
     - Parameter type: UITableViewCell.Type
     - Parameter identifier: String?
     */
    func registerCell(type: UITableViewCell.Type, identifier: String? = nil) {
        let cellId = String(describing: type)
        register(UINib(nibName: cellId, bundle: nil), forCellReuseIdentifier: identifier ?? cellId)
    }
    
    func registerHeaderFooterView<T: UITableViewHeaderFooterView>(_ : T.Type) {
        register(UINib(nibName: T.viewIdentifier, bundle: nil), forHeaderFooterViewReuseIdentifier: T.viewIdentifier)
    }
    /**
     DequeueCell by passing the type of UITableViewCell
     - Parameter type: UITableViewCell.Type
     */
    func dequeueCell<T: UITableViewCell>(withType type: UITableViewCell.Type) -> T? {
        return dequeueReusableCell(withIdentifier: type.cellIdentifier) as? T
    }
    
    /**
     DequeueCell by passing the type of UITableViewCell and IndexPath
     - Parameter type: UITableViewCell.Type
     - Parameter indexPath: IndexPath
     */
    func dequeueCell<T: UITableViewCell>(withType type: UITableViewCell.Type, for indexPath: IndexPath) -> T? {
        return dequeueReusableCell(withIdentifier: type.cellIdentifier, for: indexPath) as? T
    }
    
    
    func dequeueReusableCell<T: UITableViewCell>(forIndexPath indexPath: IndexPath) -> T {
        guard let cell = dequeueReusableCell(withIdentifier: T.cellIdentifier, for: indexPath) as? T else {
            fatalError("Could not dequeue cell with identifier: \(T.cellIdentifier)")
        }
        
        return cell
    }
    
    func dequeueHeaderFooterView<T: UITableViewHeaderFooterView>() -> T {
        guard let view = dequeueReusableHeaderFooterView(withIdentifier: T.viewIdentifier) as? T else {
            fatalError("Could not dequeue cell with identifier: \(T.viewIdentifier)")
        }
        
        return view
    }
}

public extension UITableViewCell {

    static var cellIdentifier: String {
        return String(describing: self)
    }

}

extension UITableViewHeaderFooterView {
    static var viewIdentifier: String {
        return String(describing: self)
    }
}

Shadow for CollectionView Cell > content view .

`extension UICollectionViewCell {
func shadowDecorate() {
let radius: CGFloat = 10

    self.contentView.layer.cornerRadius = radius
    // Always mask the inside view
    self.contentView.layer.masksToBounds = true

    self.layer.shadowColor = UIColor.black.cgColor
    self.layer.shadowOffset = CGSize(width: 0, height: 1.0)
    self.layer.shadowRadius = 3.0
    self.layer.shadowOpacity = 0.5
    // Never mask the shadow as it falls outside the view
    self.layer.masksToBounds = false

    // Matching the contentView radius here will keep the shadow
    // in sync with the contentView's rounded shape
    self.layer.cornerRadius = radius
}

}
`

Codable

   let decoder = JSONDecoder()
    do {
        let model = try decoder.decode(TestModel.self, from: data)
        //do something with model ...
    } catch {
        print(error)
    }

//Updated :

    static func parse<T: Codable>(_ model: T.Type,
                                   from apiResponse: [AnyHashable: Any]) -> T? {
         
         if let jsonData = try? JSONSerialization.data(withJSONObject: apiResponse, options: .prettyPrinted) {
             let decoder = JSONDecoder()
             do {
                return try decoder.decode(model.self, from: jsonData)
             }
             catch let error {
                 print("Parsing Error : \(error)")
             }
         }
         return nil
     }

class SelfSizedTableView: UITableView {
  var maxHeight: CGFloat = UIScreen.main.bounds.size.height
  
  override func reloadData() {
    super.reloadData()
    self.invalidateIntrinsicContentSize()
    self.layoutIfNeeded()
  }
  
  override var intrinsicContentSize: CGSize {
    let height = min(contentSize.height, maxHeight)
    return CGSize(width: contentSize.width, height: height)
  }
}

Note: Another aspect to highlight is since our auto layout constraints don’t define the height of the table view, you might see missing constraintswarnings: This warning is easy to fix. Go to the size inspector and set Intrinsic size -> Placeholder:

Ref: https://dushyant37.medium.com/swift-4-recipe-self-sizing-table-view-2635ac3df8ab

Read JSON from Local

static func readJSONFromFile(fileName: String) -> Any?
  {
      var json: Any?
      if let path = Bundle.main.path(forResource: fileName, ofType: "json") {
          do {
              let fileUrl = URL(fileURLWithPath: path)
              // Getting data from JSON file using the file URL
              let data = try Data(contentsOf: fileUrl, options: .mappedIfSafe)
              json = try? JSONSerialization.jsonObject(with: data)
          } catch {
              // Handle error here
          }
      }
      return json
  }

//Print all the installed font

 for family in UIFont.familyNames {
        print("family:", family)
        for font in UIFont.fontNames(forFamilyName: family) {
            print("font:", font)
        }
    }

Line Spacing of UILabel

      extension UILabel {
          var customLineSpace: CGFloat {
              get {
                  return 0
              }
              set {
                  let textAlignment = self.textAlignment
                  let paragraphStyle = NSMutableParagraphStyle()
                  paragraphStyle.lineSpacing = newValue
                  let attributedString = NSAttributedString(string: self.text ?? "", attributes: [NSAttributedString.Key.paragraphStyle: paragraphStyle])
                  self.attributedText = attributedString
                  self.textAlignment = textAlignment
              }
          }
      }

Usage : myLabel.customLineSpace = 14.0

Detect Scrollview reached to End or Top

extension UIScrollView {

	var scrolledToTop: Bool {
		let topEdge = 0 - contentInset.top
		return contentOffset.y <= topEdge
	}

	var scrolledToBottom: Bool {
		let bottomEdge = contentSize.height + contentInset.bottom - bounds.height
		return contentOffset.y >= bottomEdge
	}

}

User Default extension simplified:

extension UserDefaults {
  var onboardingCompleted: Bool {
    get { return bool(forKey: #function) }
    set { set(newValue, forKey: #function) }
  }

  var currentLanguageCode: String {
    get { return string(forKey: #function) ?? "en" }
    set { set(newValue, forKey: #function) }
  }

   var highScore: Int {
    get { return integer(forKey: #function) }
    set { set(newValue, forKey: #function) }
  }
}

    let networkInfo = CTTelephonyNetworkInfo()
    let carrierTypeString = networkInfo.serviceCurrentRadioAccessTechnology!.values.first!
    switch carrierTypeString {
    case CTRadioAccessTechnologyGPRS,CTRadioAccessTechnologyEdge,CTRadioAccessTechnologyCDMA1x: return "2G"
    case CTRadioAccessTechnologyWCDMA,CTRadioAccessTechnologyHSDPA,CTRadioAccessTechnologyHSUPA,CTRadioAccessTechnologyCDMAEVDORev0,CTRadioAccessTechnologyCDMAEVDORevA,CTRadioAccessTechnologyCDMAEVDORevB,CTRadioAccessTechnologyeHRPD: return "3G"
    case CTRadioAccessTechnologyLTE: return "4G"
    default: return ""