我只是这样做:

if let myView = UINib.init(nibName: "MyView", bundle: nil).instantiate(withOwner: self)[0] as? MyView {
// Do something with myView
}

此示例使用主包中的 nib“ MyView.xib”中的第一个视图。但是您可以更改索引、 nib 名称或 bundle (默认情况下为 main)。

我过去常常把视图唤醒到 view init 方法中，或者像上面提到的那样创建泛型方法(顺便说一句，它们很聪明) ，但是我现在不这么做了，因为我注意到用例通常是不同的，而且为了覆盖所有的情况，泛型方法变得和使用 UINib.instance 方法一样复杂。

我更喜欢使用工厂对象，通常是使用视图的 ViewController，或者如果视图需要在多个位置使用，则使用专用的工厂对象或视图扩展。

在本例中，ViewController 从 nib 加载视图。 可以更改 nib 文件，以便对同一视图类使用不同的布局。(这不是一个好的代码，它只是说明了这个想法)

class MyViewController {
// Use "MyView-Compact" for compact version
var myViewNibFileName = "MyView-Standard"


lazy var myView: MyView = {
// Be sure the Nib is correct, or it will crash
// We don't want to continue with a wrong view anyway, so ! is ok
UINib.init(nibName: myViewNibFileName, bundle: nil).instantiate(withOwner: self)[0] as! MyView
}()
}

根据洛根的回答做出了更有力的版本

extension UIView {
public class func fromNib(nibName: String? = nil) -> Self {
return fromNib(nibName: nibName, type: self)
}


public class func fromNib<T: UIView>(nibName: String? = nil, type: T.Type) -> T {
return fromNib(nibName: nibName, type: T.self)!
}


public class func fromNib<T: UIView>(nibName: String? = nil, type: T.Type) -> T? {
var view: T?
let name: String


if let nibName = nibName {
name = nibName
} else {
name = self.nibName
}


if let nibViews = nibBundle.loadNibNamed(name, owner: nil, options: nil) {
if nibViews.indices.contains(nibIndex), let tog = nibViews[nibIndex] as? T {
view = tog
}
}


return view
}


public class var nibName: String {
return "\(self)".components(separatedBy: ".").first ?? ""
}


public class var nibIndex: Int {
return 0
}


public class var nibBundle: Bundle {
return Bundle.main
}
}

你可以用

class BaseView: UIView {
override class var nibName: String { return "BaseView" }
weak var delegate: StandardStateViewDelegate?
}


class ChildView: BaseView {
override class var nibIndex: Int { return 1 }
}

如果您希望 Swift UIView 子类完全自包含，并且能够使用 init 或 init (frame:)进行实例化，而不暴露使用 Nib 的实现细节，那么您可以使用协议扩展来实现这一点。该解决方案避免了许多其他解决方案所建议的嵌套 UIView 层次结构。

public class CustomView: UIView {


@IBOutlet weak var nameLabel: UILabel!
@IBOutlet weak var valueLabel: UILabel!


public convenience init() {
self.init(frame: CGRect.zero)
}


public override convenience init(frame: CGRect) {
self.init(internal: nil)
self.frame = frame
}


public required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
commonInit()
}


fileprivate func commonInit() {
}
}


fileprivate protocol _CustomView {
}


extension CustomView: _CustomView {
}


fileprivate extension _CustomView {


// Protocol extension initializer - has the ability to assign to self, unlike
// class initializers. Note that the name of this initializer can be anything
// you like, here we've called it init(internal:)


init(internal: Int?) {
self = Bundle.main.loadNibNamed("CustomView", owner:nil, options:nil)![0] as! Self;
}
}

你可以通过故事板来实现这一点，只需要为视图添加适当的约束即可。你可以通过子类化你自己的任何视图来轻松做到这一点，比如说 BaseView:

目标 C

BaseView.h




/*!
@class BaseView
@discussion Base View for getting view from xibFile
@availability ios7 and later
*/
@interface BaseView : UIView


@end




BaseView.m




#import "BaseView.h"


@implementation BaseView


#pragma mark - Public


- (instancetype)initWithCoder:(NSCoder *)coder
{
self = [super initWithCoder:coder];
if (self) {
[self prepareView];
}
return self;
}


#pragma mark - LifeCycle


- (instancetype)initWithFrame:(CGRect)frame
{
self = [super initWithFrame:frame];
if (self) {
[self prepareView];
}
return self;
}


#pragma mark - Private


- (void)prepareView
{
NSArray *nibsArray = [[NSBundle mainBundle] loadNibNamed:NSStringFromClass([self class]) owner:self options:nil];
UIView *view = [nibsArray firstObject];


view.translatesAutoresizingMaskIntoConstraints = NO;
[self addSubview:view];
[self addConstraintsForView:view];
}


#pragma mark - Add constraints


- (void)addConstraintsForView:(UIView *)view
{
[self addConstraints:@[[NSLayoutConstraint constraintWithItem:view
attribute:NSLayoutAttributeBottom
relatedBy:NSLayoutRelationEqual
toItem:self attribute:NSLayoutAttributeBottom
multiplier:1.0
constant:0],
[NSLayoutConstraint constraintWithItem:view
attribute:NSLayoutAttributeTop
relatedBy:NSLayoutRelationEqual
toItem:self attribute:NSLayoutAttributeTop
multiplier:1.0
constant:0],
[NSLayoutConstraint constraintWithItem:view
attribute:NSLayoutAttributeLeft
relatedBy:NSLayoutRelationEqual
toItem:self attribute:NSLayoutAttributeLeft
multiplier:1.0
constant:0],
[NSLayoutConstraint constraintWithItem:view
attribute:NSLayoutAttributeRight
relatedBy:NSLayoutRelationEqual
toItem:self attribute:NSLayoutAttributeRight
multiplier:1.0
constant:0]
]];
}


@end

Swift 4

import UIKit


class BaseView : UIView {


// MARK: - LifeCycle


required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)


prepareView()
}


override init(frame: CGRect) {
super.init(frame: frame)


prepareView()
}


internal class func xibName() -> String {
return String(describing: self)
}


// MARK: - Private
fileprivate func prepareView() {
let nameForXib = BaseView.xibName()
let nibs = Bundle.main.loadNibNamed(nameForXib, owner: self, options: nil)
if let view = nibs?.first as? UIView {
view.backgroundColor = UIColor.clear
view.translatesAutoresizingMaskIntoConstraints = false
addSubviewWithConstraints(view, offset: false)
}
}
}


UIView+Subview




public extension UIView {
// MARK: - UIView+Extensions


public func addSubviewWithConstraints(_ subview:UIView, offset:Bool = true) {
subview.translatesAutoresizingMaskIntoConstraints = false
let views = [
"subview" : subview
]
addSubview(subview)


var constraints = NSLayoutConstraint.constraints(withVisualFormat: offset ? "H:|-[subview]-|" : "H:|[subview]|", options: [.alignAllLeading, .alignAllTrailing], metrics: nil, views: views)
constraints.append(contentsOf: NSLayoutConstraint.constraints(withVisualFormat: offset ? "V:|-[subview]-|" : "V:|[subview]|", options: [.alignAllTop, .alignAllBottom], metrics: nil, views: views))
NSLayoutConstraint.activate(constraints)
}
}

我提供了如何添加约束的两种变体-常见的一种和可视化格式语言-选择任何你想要的:)

另外，默认情况下假定 xib名称与实现类名称相同。如果没有-只是更改 xibName参数。

如果你从 BaseView子类化你的视图-你可以很容易地把任何视图和指定类在 IB。

最方便的实现。这里需要两个方法，以便直接返回到类的对象，而不是 UIView。

1. ViewId 标记为 同学们，允许覆盖
2. 您的. xib 可以包含顶层的多个视图，这种情况也是 正确处理。

extension UIView {


class var viewId: String {
return String(describing: self)
}


static func instance(from bundle: Bundle? = nil, nibName: String? = nil,
owner: Any? = nil, options: [AnyHashable : Any]? = nil) -> Self? {


return instancePrivate(from: bundle ?? Bundle.main,
nibName: nibName ?? viewId,
owner: owner,
options: options)
}


private static func instancePrivate<T: UIView>(from bundle: Bundle, nibName: String,
owner: Any?, options: [AnyHashable : Any]?) -> T? {


guard
let views = bundle.loadNibNamed(nibName, owner: owner, options: options),
let view = views.first(where: { $0 is T }) as? T else { return nil }


return view
}
}

例如:

guard let customView = CustomView.instance() else { return }


//Here customView has CustomView class type, not UIView.
print(customView is CustomView) // true

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

Swift 4

别忘了写“ . first as? CustomView”。

if let customView = Bundle.main.loadNibNamed("myXib", owner: self, options: nil)?.first as? CustomView {
self.view.addSubview(customView)
}

如果你想在任何地方使用

最佳解决方案是 罗伯特 · 甘梅森的答案。

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

那就这么说吧:

let myCustomView: CustomView = UIView.fromNib()

以下是使用协议和协议扩展(Swift 4.2)以编程方式加载视图的一种简洁且声明性的方法:

protocol XibLoadable {
associatedtype CustomViewType
static func loadFromXib() -> CustomViewType
}


extension XibLoadable where Self: UIView {
static func loadFromXib() -> Self {
let nib = UINib(nibName: "\(self)", bundle: Bundle(for: self))
guard let customView = nib.instantiate(withOwner: self, options: nil).first as? Self else {
// your app should crash if the xib doesn't exist
preconditionFailure("Couldn't load xib for view: \(self)")
}
return customView
}
}

你可以这样使用:

// don't forget you need a xib file too
final class MyView: UIView, XibLoadable { ... }


// and when you want to use it
let viewInstance = MyView.loadFromXib()

一些额外的考虑 :

1. 确保自定义视图的 xib 文件设置了视图的 Custom Class集(以及从那里设置的插座/操作) ，而不是 File Owner 的。
2. 您可以在自定义视图外部或内部使用此协议/扩展。如果在初始化视图时还有其他安装工作，则可能需要在内部使用它。
3. 您的自定义视图类和 xib 文件需要具有相同的名称。

Swift 4-5.1协议扩展

public protocol NibInstantiatable {
    

static func nibName() -> String
    

}


extension NibInstantiatable {
    

static func nibName() -> String {
return String(describing: self)
}
    

}


extension NibInstantiatable where Self: UIView {
    

static func fromNib() -> Self {
        

let bundle = Bundle(for: self)
let nib = bundle.loadNibNamed(nibName(), owner: self, options: nil)
        

return nib!.first as! Self
        

}
    

}

领养

class MyView: UIView, NibInstantiatable {


}

此实现假定 Nib 具有与 UIView 类相同的名称。前女友。MyView.xib.您可以通过在 MyView 实现 nibName ()来修改这种行为，以返回与默认协议扩展实现不同的名称。

在 xib 中，文件所有者是 MyView，根视图类是 MyView。

用法

let view = MyView.fromNib()

  let bundle = Bundle(for: type(of: self))
let views = bundle.loadNibNamed("template", owner: self, options: nil)
self.view.addSubview(views?[0] as! UIView)

我更喜欢下面的分机

extension UIView {
class var instanceFromNib: Self {
return Bundle(for: Self.self)
.loadNibNamed(String(describing: Self.self), owner: nil, options: nil)?.first as! Self
}
}

这个扩展名和顶部应答扩展名的区别在于，你不需要将它存储为常量或变量。

class TitleView: UIView { }


extension UIView {
class var instanceFromNib: Self {
return Bundle(for: Self.self)
.loadNibNamed(String(describing: Self.self), owner: nil, options: nil)?.first as! Self
}
}


self.navigationItem.titleView = TitleView.instanceFromNib

    let nibs = Bundle.main.loadNibNamed("YourView", owner: nil, options: nil)
let shareView = nibs![0] as! ShareView
self.view.addSubview(shareView)

快速5-清洁和易于使用的扩展

[从生产项目复制粘贴]

//
//  Refactored by Essam Mohamed Fahmi.
//


import UIKit


extension UIView
{
static var nib: UINib
{
return UINib(nibName: "\(self)", bundle: nil)
}


static func instantiateFromNib() -> Self?
{
return nib.instantiate() as? Self
}
}


extension UINib
{
func instantiate() -> Any?
{
return instantiate(withOwner: nil, options: nil).first
}
}

用法

let myCustomView: CustomView = .instantiateFromNib()

//使用此类作为超视图

import UIKit


class ViewWithXib: UIView {


func initUI() {}


private func xibSetup() {
let view = loadViewFromNib()
view.frame = bounds
view.autoresizingMask = [UIViewAutoresizing.flexibleWidth, UIViewAutoresizing.flexibleHeight]
addSubview(view)
initUI()
}


private func loadViewFromNib() -> UIView {
let thisName = String(describing: type(of: self))
let view = Bundle(for: self.classForCoder).loadNibNamed(thisName, owner: self, options: nil)?.first as! UIView
return view
}




override init(frame: CGRect) {
super.init(frame: frame)
xibSetup()
}


required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
xibSetup()
}


}

//用途:

class HeaderView: ViewWithXib {
}




let header = HeaderView() // No need to load the view from nib, It will work

更新为 Swift 5

在下面的某个地方定义:

extension UIView {
public class func fromNib<T: UIView>() -> T {
let name = String(describing: Self.self);
guard let nib = Bundle(for: Self.self).loadNibNamed(
name, owner: nil, options: nil)
else {
fatalError("Missing nib-file named: \(name)")
}
return nib.first as! T
}
}

使用如下:

let view: MyCustomView = .fromNib();

它将在与 MyCustomView相同的绑定包中搜索，然后加载 MyCustomView.nib文件(如果文件存在，并将其添加到 project)。

RobertGummeson 的 回答我是完美的，但是当我们尝试在 SPM 或者框架中使用它时，它不起作用。
我已经修改如下，使其工作。

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