blocks|key|68099|text|将此代码添加到视图控制器中。就像一种护身符。只需调整这些值即可。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|68100|override+func+viewDidLoad()+{
++++super.viewDidLoad()++++++++
++++NotificationCenter.default.addObserver(self,+selector:+#selector(keyboardWillShow),+name:NSNotification.Name.UIKeyboardWillShow,+object:+nil);
++++NotificationCenter.default.addObserver(self,+selector:+#selector(keyboardWillHide),+name:NSNotification.Name.UIKeyboardWillHide,+object:+nil);
}

@objc+func+keyboardWillShow(sender:+NSNotification)+{
++++self.view.frame.origin.y+-=+150
}
@objc+func+keyboardWillHide(sender:+NSNotification)+{
++++self.view.frame.origin.y+%2B=+150
}|code-block|syntax|javascript|68101|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Add this to your viewcontroller. Works like a charm. Just adjust the values.

<pre><code>override func viewDidLoad() {
 super.viewDidLoad() 
 NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillShow), name:NSNotification.Name.UIKeyboardWillShow, object: nil);
 NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillHide), name:NSNotification.Name.UIKeyboardWillHide, object: nil);
}

@objc func keyboardWillShow(sender: NSNotification) {
 self.view.frame.origin.y -= 150
}
@objc func keyboardWillHide(sender: NSNotification) {
 self.view.frame.origin.y += 150
}
</code></pre>

blocks|key|68144|text|这里有一个解决方案，不需要处理从一个textField到另一个的切换：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|68145|override+func+viewDidLoad()+{
++++++++super.viewDidLoad()
++++++++NSNotificationCenter.defaultCenter().addObserver(self,+selector:+Selector("keyboardWillShow:"),+name:+UIKeyboardWillShowNotification,+object:+nil)
++++++++NSNotificationCenter.defaultCenter().addObserver(self,+selector:+Selector("keyboardWillHide:"),+name:+UIKeyboardWillHideNotification,+object:+nil)++++++++++++
++++}+++

func+keyboardWillShow(notification:+NSNotification)+{++++++++++++
++++if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameEndUserInfoKey]+as?+NSValue)?.CGRectValue()+{
++++++++self.view.frame.origin.y+-=+keyboardSize.height
++++}++++++++++++
}

func+keyboardWillHide(notification:+NSNotification)+{
++++self.view.frame.origin.y+=+0
}|code-block|syntax|javascript|68146|要解决此问题，请将两个函数keyboardWillShow/Hide替换为以下内容：|offset|length|style|CODE|68147|func+keyboardWillShow(notification:+NSNotification)+{++++++++
++++if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameEndUserInfoKey]+as?+NSValue)?.CGRectValue()+{
++++++++if+view.frame.origin.y+==+0+{
++++++++++++self.view.frame.origin.y+-=+keyboardSize.height
++++++++}
++++}++++++++
}

func+keyboardWillHide(notification:+NSNotification)+{
++++if+view.frame.origin.y+!=+0+{
++++++++self.view.frame.origin.y+=+0
++++}
}|68148|Swift+3.0：|68149|override+func+viewDidLoad()+{
++++super.viewDidLoad()++++++++++++
++++NotificationCenter.default.addObserver(self,+selector:+#selector(ViewController.keyboardWillShow),+name:+NSNotification.Name.UIKeyboardWillShow,+object:+nil)
++++NotificationCenter.default.addObserver(self,+selector:+#selector(ViewController.keyboardWillHide),+name:+NSNotification.Name.UIKeyboardWillHide,+object:+nil)++++
}

@objc+func+keyboardWillShow(notification:+NSNotification)+{++++++++
++++if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameEndUserInfoKey]+as?+NSValue)?.cgRectValue+{
++++++++if+self.view.frame.origin.y+==+0+{
++++++++++++self.view.frame.origin.y+-=+keyboardSize.height
++++++++}
++++}++++++++
}

@objc+func+keyboardWillHide(notification:+NSNotification)+{
++++if+self.view.frame.origin.y+!=+0+{
++++++++self.view.frame.origin.y+=+0
++++}
}|68150|Swift+4.0：|68151|override+func+viewDidLoad()+{
++++super.viewDidLoad()++++++++++++
++++NotificationCenter.default.addObserver(self,+selector:+#selector(ViewController.keyboardWillShow),+name:+NSNotification.Name.UIKeyboardWillShow,+object:+nil)
++++NotificationCenter.default.addObserver(self,+selector:+#selector(ViewController.keyboardWillHide),+name:+NSNotification.Name.UIKeyboardWillHide,+object:+nil)++++
}

@objc+func+keyboardWillShow(notification:+NSNotification)+{++++++++
++++if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameEndUserInfoKey]+as?+NSValue)?.cgRectValue+{
++++++++if+self.view.frame.origin.y+==+0+{
++++++++++++self.view.frame.origin.y+-=+keyboardSize.height
++++++++}
++++}++++++++
}

@objc+func+keyboardWillHide(notification:+NSNotification)+{
++++if+self.view.frame.origin.y+!=+0+{
++++++++self.view.frame.origin.y+=+0
++++}
}|68152|Swift+4.2：|68153|override+func+viewDidLoad()+{
++++super.viewDidLoad()++++++++++++
++++NotificationCenter.default.addObserver(self,+selector:+#selector(keyboardWillShow),+name:+UIResponder.keyboardWillShowNotification,+object:+nil)
++++NotificationCenter.default.addObserver(self,+selector:+#selector(keyboardWillHide),+name:+UIResponder.keyboardWillHideNotification,+object:+nil)
}

@objc+func+keyboardWillShow(notification:+NSNotification)+{
++++if+let+keyboardSize+=+(notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey]+as?+NSValue)?.cgRectValue+{
++++++++if+self.view.frame.origin.y+==+0+{
++++++++++++self.view.frame.origin.y+-=+keyboardSize.height
++++++++}
++++}
}

@objc+func+keyboardWillHide(notification:+NSNotification)+{
++++if+self.view.frame.origin.y+!=+0+{
++++++++self.view.frame.origin.y+=+0
++++}
}|68154|entityMap^0|0|0|D|L|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@$I|15|J|16|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

Here is a solution, without handling the switch from one textField to another:
<pre><code>override func viewDidLoad() {
 super.viewDidLoad()
 NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector(&quot;keyboardWillShow:&quot;), name: UIKeyboardWillShowNotification, object: nil)
 NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector(&quot;keyboardWillHide:&quot;), name: UIKeyboardWillHideNotification, object: nil) 
 } 

func keyboardWillShow(notification: NSNotification) { 
 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.CGRectValue() {
 self.view.frame.origin.y -= keyboardSize.height
 } 
}

func keyboardWillHide(notification: NSNotification) {
 self.view.frame.origin.y = 0
}
</code></pre>
To solve this, replace the two functions <code>keyboardWillShow/Hide</code> with these:
<pre><code>func keyboardWillShow(notification: NSNotification) { 
 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.CGRectValue() {
 if view.frame.origin.y == 0 {
 self.view.frame.origin.y -= keyboardSize.height
 }
 } 
}

func keyboardWillHide(notification: NSNotification) {
 if view.frame.origin.y != 0 {
 self.view.frame.origin.y = 0
 }
}
</code></pre>
<h3>Swift 3.0:</h3>
<pre><code>override func viewDidLoad() {
 super.viewDidLoad() 
 NotificationCenter.default.addObserver(self, selector: #selector(ViewController.keyboardWillShow), name: NSNotification.Name.UIKeyboardWillShow, object: nil)
 NotificationCenter.default.addObserver(self, selector: #selector(ViewController.keyboardWillHide), name: NSNotification.Name.UIKeyboardWillHide, object: nil) 
}

@objc func keyboardWillShow(notification: NSNotification) { 
 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {
 if self.view.frame.origin.y == 0 {
 self.view.frame.origin.y -= keyboardSize.height
 }
 } 
}

@objc func keyboardWillHide(notification: NSNotification) {
 if self.view.frame.origin.y != 0 {
 self.view.frame.origin.y = 0
 }
}
 
</code></pre>
<h3>Swift 4.0:</h3>
<pre><code>override func viewDidLoad() {
 super.viewDidLoad() 
 NotificationCenter.default.addObserver(self, selector: #selector(ViewController.keyboardWillShow), name: NSNotification.Name.UIKeyboardWillShow, object: nil)
 NotificationCenter.default.addObserver(self, selector: #selector(ViewController.keyboardWillHide), name: NSNotification.Name.UIKeyboardWillHide, object: nil) 
}

@objc func keyboardWillShow(notification: NSNotification) { 
 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {
 if self.view.frame.origin.y == 0 {
 self.view.frame.origin.y -= keyboardSize.height
 }
 } 
}

@objc func keyboardWillHide(notification: NSNotification) {
 if self.view.frame.origin.y != 0 {
 self.view.frame.origin.y = 0
 }
}
</code></pre>
<h3>Swift 4.2:</h3>
<pre><code>override func viewDidLoad() {
 super.viewDidLoad() 
 NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillShow), name: UIResponder.keyboardWillShowNotification, object: nil)
 NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillHide), name: UIResponder.keyboardWillHideNotification, object: nil)
}

@objc func keyboardWillShow(notification: NSNotification) {
 if let keyboardSize = (notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {
 if self.view.frame.origin.y == 0 {
 self.view.frame.origin.y -= keyboardSize.height
 }
 }
}

@objc func keyboardWillHide(notification: NSNotification) {
 if self.view.frame.origin.y != 0 {
 self.view.frame.origin.y = 0
 }
}
</code></pre>

blocks|key|68214|text|我注意到，其他答案涉及从视图中剪切一些顶部。如果您想在不剪切任何内容的情况下简单地调整视图的大小，只需尝试此方法:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|68215|func+keyboardWillShow(notification:+NSNotification)+{
++++if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.CGRectValue()+{
++++++++self.view.setTranslatesAutoresizingMaskIntoConstraints(true)
++++++++self.view.frame+=+CGRectMake(self.view.frame.origin.x,+self.view.frame.origin.y,+self.view.frame.size.width,+self.view.frame.height+-+keyboardSize.height)
++++}
}

func+keyboardWillHide(notification:+NSNotification)+{
++++if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.CGRectValue()+{
++++++++self.collectionView.setTranslatesAutoresizingMaskIntoConstraints(false)
++++++++self.view.frame+=+CGRectMake(self.view.frame.origin.x,+self.view.frame.origin.y,+self.view.frame.size.width,+self.view.frame.height+%2B+keyboardSize.height)
++++}
}|code-block|syntax|javascript|68216|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I noticed that the other answers involved cutting some of the top from the view. If you want to simply resize the view without cutting any content, just try this method :)

<pre><code>func keyboardWillShow(notification: NSNotification) {
 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
 self.view.setTranslatesAutoresizingMaskIntoConstraints(true)
 self.view.frame = CGRectMake(self.view.frame.origin.x, self.view.frame.origin.y, self.view.frame.size.width, self.view.frame.height - keyboardSize.height)
 }
}

func keyboardWillHide(notification: NSNotification) {
 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
 self.collectionView.setTranslatesAutoresizingMaskIntoConstraints(false)
 self.view.frame = CGRectMake(self.view.frame.origin.x, self.view.frame.origin.y, self.view.frame.size.width, self.view.frame.height + keyboardSize.height)
 }
}
</code></pre>

blocks|key|4574749|text|已为Swift+3更新...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4574750|正如其他人所说，您需要在控制器的viewDidLoad()方法中添加通知观察器，如下所示：|4574751|NotificationCenter.default.addObserver(forName:+.UIKeyboardWillShow,+object:+nil,+queue:+nil)
++++{+notification+in
++++self.keyboardWillShow(notification)
++++}

NotificationCenter.default.addObserver(forName:+.UIKeyboardWillHide,+object:+nil,+queue:+nil)
++++{+notification+in
++++self.keyboardWillHide(notification)
++++}

NotificationCenter.default.addObserver(forName:+.UIKeyboardDidShow,+object:+nil,+queue:+nil)
++++{+_+in
++++self.enableUserInteraction()
++++}

NotificationCenter.default.addObserver(forName:+.UIKeyboardDidHide,+object:+nil,+queue:+nil)
++++{+_+in
++++self.enableUserInteraction()
++++}|code-block|syntax|javascript|4574752|记得在适当的地方删除你的观察者(我是在viewWillDisappear()方法中做的)|4574753|NotificationCenter.default.removeObserver(self,+name:+.UIKeyboardWillShow,+object:+nil)
NotificationCenter.default.removeObserver(self,+name:+.UIKeyboardWillHide,+object:+nil)
NotificationCenter.default.removeObserver(self,+name:+.UIKeyboardDidShow,+object:+nil)
NotificationCenter.default.removeObserver(self,+name:+.UIKeyboardDidHide,+object:+nil)|4574754|然后，实现您的show和hide方法-注意告诉应用程序忽略交互事件(beginIgnoringInteractionEvents)的代码行。这一点很重要，因为如果没有它，用户可能会在字段甚至滚动视图上点击，并导致第二次移动，从而导致可怕的UI故障。在键盘显示和隐藏之前忽略交互事件可以防止出现这种情况：|4574755|func+keyboardWillShow(notification:+Notification)
++++{
++++if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.cgRectValue
++++++++{
++++++++UIApplication.shared.beginIgnoringInteractionEvents()
++++++++self.view.frame.origin.y+-=+keyboardSize.height
++++++++//+add+this+line+if+you+are+shifting+a+scrollView,+as+in+a+chat+application
++++++++self.timelineCollectionView.contentInset.top+%2B=+keyboardSize.height
++++++++}
++++}

func+keyboardWillHide(notification:+Notification)
++++{
++++if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.cgRectValue
++++++++{
++++++++UIApplication.shared.beginIgnoringInteractionEvents()
++++++++self.view.frame.origin.y+%2B=+keyboardSize.height
++++++++//+add+this+line+if+you+are+shifting+a+scrollView,+as+in+a+chat+application
++++++++self.timelineCollectionView.contentInset.top+-=+keyboardSize.height
++++++++}
++++}|4574756|最后，重新启用用户交互(请记住，此方法在键盘didShow或didHide之后触发)：|4574757|func+enableUserInteraction()
++++{
++++UIApplication.shared.endIgnoringInteractionEvents()
++++}|4574758|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Updated for Swift 3...

As others have said, you need to add notification observers in your controller's viewDidLoad() method, like so:

<pre><code>NotificationCenter.default.addObserver(forName: .UIKeyboardWillShow, object: nil, queue: nil)
 { notification in
 self.keyboardWillShow(notification)
 }

NotificationCenter.default.addObserver(forName: .UIKeyboardWillHide, object: nil, queue: nil)
 { notification in
 self.keyboardWillHide(notification)
 }

NotificationCenter.default.addObserver(forName: .UIKeyboardDidShow, object: nil, queue: nil)
 { _ in
 self.enableUserInteraction()
 }

NotificationCenter.default.addObserver(forName: .UIKeyboardDidHide, object: nil, queue: nil)
 { _ in
 self.enableUserInteraction()
 }
</code></pre>

Remember to remove your observers where appropriate (I do it in the viewWillDisappear() method)

<pre><code>NotificationCenter.default.removeObserver(self, name: .UIKeyboardWillShow, object: nil)
NotificationCenter.default.removeObserver(self, name: .UIKeyboardWillHide, object: nil)
NotificationCenter.default.removeObserver(self, name: .UIKeyboardDidShow, object: nil)
NotificationCenter.default.removeObserver(self, name: .UIKeyboardDidHide, object: nil)
</code></pre>

Then, implement your show and hide methods - notice the line that tells the app to ignore interaction events (beginIgnoringInteractionEvents). This is important since without it, the user could tap on a field or even a scrollview and cause the shift to occur a second time, resulting in a terrible UI glitch. Ignoring interaction events prior to the keyboard showing and hiding will prevent this:

<pre><code>func keyboardWillShow(notification: Notification)
 {
 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue
 {
 UIApplication.shared.beginIgnoringInteractionEvents()
 self.view.frame.origin.y -= keyboardSize.height
 // add this line if you are shifting a scrollView, as in a chat application
 self.timelineCollectionView.contentInset.top += keyboardSize.height
 }
 }

func keyboardWillHide(notification: Notification)
 {
 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue
 {
 UIApplication.shared.beginIgnoringInteractionEvents()
 self.view.frame.origin.y += keyboardSize.height
 // add this line if you are shifting a scrollView, as in a chat application
 self.timelineCollectionView.contentInset.top -= keyboardSize.height
 }
 }
</code></pre>

Lastly, re-enable user interactions (remember, this method fires after the keyboard didShow or didHide):

<pre><code>func enableUserInteraction()
 {
 UIApplication.shared.endIgnoringInteractionEvents()
 }
</code></pre>

blocks|key|68373|text|我看到所有答案都是通过键盘高度的值来移动视图本身的。好吧，我有一个详细的答案，如果你使用约束，也就是autolayout，它可以通过改变约束的值(例如底部或顶部约束)来移动视图，或者你可以使用键盘大小值。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|68374|在本例中，我使用了从文本字段到底部布局视图的底部约束，初始值为175。|68375|@IBOutlet+weak+var+bottomConstraint:+NSLayoutConstraint!

override+func+viewDidLoad()+{
++++super.viewDidLoad()++++++++
++++NSNotificationCenter.defaultCenter().addObserver(self,+selector:+Selector("keyboardWillShow:"),+name:UIKeyboardWillShowNotification,+object:+nil);
++++NSNotificationCenter.defaultCenter().addObserver(self,+selector:+Selector("keyboardWillHide:"),+name:UIKeyboardWillHideNotification,+object:+nil);
}

func+keyboardWillShow(notification:+NSNotification)+{
++++//To+retrieve+keyboard+size,+uncomment+following+line
++++//let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.CGRectValue()
++++bottomConstraint.constant+=+260
++++UIView.animateWithDuration(0.3)+{
++++++++self.view.layoutIfNeeded()
++++}
}

func+keyboardWillHide(notification:+NSNotification)+{
++++//To+retrieve+keyboard+size,+uncomment+following+line
++++//let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.CGRectValue()
++++bottomConstraint.constant+=+175
++++UIView.animateWithDuration(0.3)+{
++++++++self.view.layoutIfNeeded()
++++}
}|code-block|syntax|javascript|68376|entityMap^0|1E|A|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

I see all answers are moving the view itself by the value of the keyboard height. Well, I have an elaborate answer, which could be useful if you are using constraints i.e <code>autolayout</code>, that moves a view by changing its constraint value (bottom or top constraints for example) by a predefined value or you can use keyboard size value.

In this example, I use bottom constraint from the textfield to Bottom Layout View with initial value of 175.

<pre><code>@IBOutlet weak var bottomConstraint: NSLayoutConstraint!

override func viewDidLoad() {
 super.viewDidLoad() 
 NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillShow:"), name:UIKeyboardWillShowNotification, object: nil);
 NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillHide:"), name:UIKeyboardWillHideNotification, object: nil);
}

func keyboardWillShow(notification: NSNotification) {
 //To retrieve keyboard size, uncomment following line
 //let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue()
 bottomConstraint.constant = 260
 UIView.animateWithDuration(0.3) {
 self.view.layoutIfNeeded()
 }
}

func keyboardWillHide(notification: NSNotification) {
 //To retrieve keyboard size, uncomment following line
 //let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue()
 bottomConstraint.constant = 175
 UIView.animateWithDuration(0.3) {
 self.view.layoutIfNeeded()
 }
}
</code></pre>

blocks|key|68422|text|这个视频教程是最好的。7分钟的时间，这将是非常有意义的。这是一个简单的解决方案，用于当您有多个文本字段，并希望滚动视图在点击特定文本字段时移动"x“像素量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|68423|https://youtu.be/VuiPGJOEBH4|offset|length|68424|只需执行以下步骤：|68425|在一个被限制到视图边缘的滚动视图中-Place你的所有文本字段。|68426|-Connect所有的文本字段和滚动视图作为视图控制器的委托。|68427|使用IBOutlet对所有文本字段和滚动视图执行-Connect操作。|68428|class+ViewController:+UIViewController,+UITextFieldDelegate+{|code-block|syntax|javascript|68429|-Add+UITextFieldDelegate协议到您的班级|68430|@IBOutlet+var+stateAddress:+UITextField!
@IBOutlet+var+zipAddress:+UITextField!
@IBOutlet+var+phoneNumber:+UITextField!
@IBOutlet+var+vetEmailAddress:+UITextField!++++
@IBOutlet+weak+var+scrollView:+UIScrollView!|68431|-Add+UITextFieldDelegate方法到你的swift文件：|68432|func+textFieldShouldReturn(textField:+UITextField)+->+Bool+{

++++textField.resignFirstResponder()
++++return+true
}


func+textFieldDidBeginEditing(textField:+UITextField)+{

++++if+(textField+==+self.stateAddress)+{
++++++++scrollView.setContentOffset(CGPointMake(0,+25),+animated:+true)
++++}
++++else+if+(textField+==+self.zipAddress)+{
++++++++scrollView.setContentOffset(CGPointMake(0,+57),+animated:+true)
++++}
++++else+if+(textField+==+self.phoneNumber)+{
++++++++scrollView.setContentOffset(CGPointMake(0,+112),+animated:+true)
++++}
++++else+if+(textField+==+self.vetEmailAddress)+{
++++++++scrollView.setContentOffset(CGPointMake(0,+142),+animated:+true)
++++}
}

func+textFieldDidEndEditing(textField:+UITextField)+{

++++scrollView.setContentOffset(CGPointMake(0,+0),+animated:+true)
}|68433|第一种方法只是激活键盘上的return按钮来关闭键盘。第二种是当你点击任何特定的文本字段，然后设置滚动视图滚动距离的y偏移量(我的偏移量是基于我的视图控制器上的y位置25,57,112,142)。最后一个选项是，当你离开键盘时，滚动视图会回到原来的位置。|68434|我用这种方式使我的视图像素完美！|68435|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|S|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1C|8|@]|9|@$D|1D|E|1E|1|1F]]|A|$]]|$1|F|3|G|5|6|7|1G|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1H|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1I|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1J|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|1K|8|@]|9|@]|A|$Q|R]]|$1|S|3|T|5|6|7|1L|8|@]|9|@]|A|$]]|$1|U|3|V|5|P|7|1M|8|@]|9|@]|A|$Q|R]]|$1|W|3|X|5|6|7|1N|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|P|7|1O|8|@]|9|@]|A|$Q|R]]|$1|10|3|11|5|6|7|1P|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]]|15|$16|$5|17|18|19|A|$1A|C]]]]

this video tutorial is the best. 7 mins long and it'll just make so much sense. Such a simple solution for when you have multiple text fields and want the scroll view to move "x" amount of pixels when that specific textfield is tapped.

<a href="https://youtu.be/VuiPGJOEBH4" rel="nofollow">https://youtu.be/VuiPGJOEBH4</a>

Just these steps:

-Place all your textfields within a scrollview that is constrained to the edges of the view. 

-Connect all the textfields and scroll view as delegates to the view controller.

-Connect all textfields and scroll view with an IBOutlet.

<pre><code>class ViewController: UIViewController, UITextFieldDelegate {
</code></pre>

-Add UITextFieldDelegate protocol to your class

<pre><code>@IBOutlet var stateAddress: UITextField!
@IBOutlet var zipAddress: UITextField!
@IBOutlet var phoneNumber: UITextField!
@IBOutlet var vetEmailAddress: UITextField! 
@IBOutlet weak var scrollView: UIScrollView!
</code></pre>

-Add UITextFieldDelegate methods to your swift file:

<pre><code>func textFieldShouldReturn(textField: UITextField) -&gt; Bool {

 textField.resignFirstResponder()
 return true
}


func textFieldDidBeginEditing(textField: UITextField) {

 if (textField == self.stateAddress) {
 scrollView.setContentOffset(CGPointMake(0, 25), animated: true)
 }
 else if (textField == self.zipAddress) {
 scrollView.setContentOffset(CGPointMake(0, 57), animated: true)
 }
 else if (textField == self.phoneNumber) {
 scrollView.setContentOffset(CGPointMake(0, 112), animated: true)
 }
 else if (textField == self.vetEmailAddress) {
 scrollView.setContentOffset(CGPointMake(0, 142), animated: true)
 }
}

func textFieldDidEndEditing(textField: UITextField) {

 scrollView.setContentOffset(CGPointMake(0, 0), animated: true)
}
</code></pre>

The first method just activates the return button on the keyboard to dismiss the keyboard. The second is when you tap into whatever specific textfield then setting the y offset of how far your scrollview scrolls (mine is based off of the y location on my view controllers 25,57,112,142). The last says when you tap away from the keyboard the scrollview goes back to original location.

I made my view pixel perfect this way!

blocks|key|4574947|text|这是我的解决方案(实际上，这段代码适用于视图中只有几个文本字段的情况，也适用于只有一个文本字段的情况)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4574948|class+MyViewController:+UIViewController,+UITextFieldDelegate+{

@IBOutlet+weak+var+firstTextField:+UITextField!
@IBOutlet+weak+var+secondTextField:+UITextField!

var+activeTextField:+UITextField!
var+viewWasMoved:+Bool+=+false


override+func+viewDidLoad()+{
++++super.viewDidLoad()
++++NSNotificationCenter.defaultCenter().addObserver(self,+selector:+#selector(PrintViewController.keyboardWillShow(_:)),+name:+UIKeyboardWillShowNotification,+object:+nil)
++++NSNotificationCenter.defaultCenter().addObserver(self,+selector:+#selector(PrintViewController.keyboardWillHide(_:)),+name:+UIKeyboardWillHideNotification,+object:+nil)
}

override+func+viewDidDisappear(animated:+Bool)+{
++++super.viewWillDisappear(animated)
++++NSNotificationCenter.defaultCenter().removeObserver(self)
}

func+textFieldDidBeginEditing(textField:+UITextField)+{
++++self.activeTextField+=+textField
}

func+textFieldDidEndEditing(textField:+UITextField)+{
++++self.activeTextField+=+nil
}

func+textFieldShouldReturn(textField:+UITextField)+->+Bool+{
++++textField.resignFirstResponder()
++++return+true
}


func+keyboardWillShow(notification:+NSNotification)+{

++++let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.CGRectValue()

++++var+aRect:+CGRect+=+self.view.frame
++++aRect.size.height+-=+keyboardSize!.height

++++let+activeTextFieldRect:+CGRect?+=+activeTextField?.frame
++++let+activeTextFieldOrigin:+CGPoint?+=+activeTextFieldRect?.origin

++++if+(!CGRectContainsPoint(aRect,+activeTextFieldOrigin!))+{
++++++++self.viewWasMoved+=+true
++++++++self.view.frame.origin.y+-=+keyboardSize!.height
++++}+else+{
++++++++self.viewWasMoved+=+false
++++}
}

func+keyboardWillHide(notification:+NSNotification)+{
++++if+(self.viewWasMoved)+{
++++++++if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.CGRectValue()+{
++++++++++++self.view.frame.origin.y+%2B=+keyboardSize.height
++++++++}
++++}
}|code-block|syntax|javascript|4574949|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is my solution (actually this code is for the case when you have few textfields in your view, this works also for the case when you have one textfield)

<pre><code>class MyViewController: UIViewController, UITextFieldDelegate {

@IBOutlet weak var firstTextField: UITextField!
@IBOutlet weak var secondTextField: UITextField!

var activeTextField: UITextField!
var viewWasMoved: Bool = false


override func viewDidLoad() {
 super.viewDidLoad()
 NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(PrintViewController.keyboardWillShow(_:)), name: UIKeyboardWillShowNotification, object: nil)
 NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(PrintViewController.keyboardWillHide(_:)), name: UIKeyboardWillHideNotification, object: nil)
}

override func viewDidDisappear(animated: Bool) {
 super.viewWillDisappear(animated)
 NSNotificationCenter.defaultCenter().removeObserver(self)
}

func textFieldDidBeginEditing(textField: UITextField) {
 self.activeTextField = textField
}

func textFieldDidEndEditing(textField: UITextField) {
 self.activeTextField = nil
}

func textFieldShouldReturn(textField: UITextField) -&gt; Bool {
 textField.resignFirstResponder()
 return true
}


func keyboardWillShow(notification: NSNotification) {

 let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue()

 var aRect: CGRect = self.view.frame
 aRect.size.height -= keyboardSize!.height

 let activeTextFieldRect: CGRect? = activeTextField?.frame
 let activeTextFieldOrigin: CGPoint? = activeTextFieldRect?.origin

 if (!CGRectContainsPoint(aRect, activeTextFieldOrigin!)) {
 self.viewWasMoved = true
 self.view.frame.origin.y -= keyboardSize!.height
 } else {
 self.viewWasMoved = false
 }
}

func keyboardWillHide(notification: NSNotification) {
 if (self.viewWasMoved) {
 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
 self.view.frame.origin.y += keyboardSize.height
 }
 }
}
</code></pre>

blocks|key|68474|text|func+keyboardWillShow(notification:+NSNotification)+{

++++if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.CGRectValue()+{
++++++++self.view.frame.origin.y+=+self.view.frame.height+-+(self.view.frame.height+%2B+keyboardSize.height)
++++}

}

func+keyboardWillHide(notification:+NSNotification)+{
++++++++self.view.frame.origin.y+=+0
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|68475|它必须更稳定|unstyled|68476|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>func keyboardWillShow(notification: NSNotification) {

 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
 self.view.frame.origin.y = self.view.frame.height - (self.view.frame.height + keyboardSize.height)
 }

}

func keyboardWillHide(notification: NSNotification) {
 self.view.frame.origin.y = 0
}
</code></pre>

it must be more stable

blocks|key|4574958|text|+override+func+viewWillAppear(animated:+Bool)
+{
+super.viewWillAppear(animated)

+NSNotificationCenter.defaultCenter().addObserver(self,+selector:+"keyboardWillShow:",+name:+UIKeyboardWillShowNotification,+object:+nil)
+NSNotificationCenter.defaultCenter().addObserver(self,+selector:+"keyboardWillHide:",+name:+UIKeyboardWillHideNotification,+object:+nil)

+}

+//+MARK:+-+keyboard
+func+keyboardWillShow(notification:+NSNotification)+
{

if+let+userInfo+=+notification.userInfo+{
if+let+keyboardSize+=+(userInfo[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.CGRectValue()+{
let+contentInsets+=+self.tblView.contentInset+as+UIEdgeInsets
self.tblView.contentInset+=+UIEdgeInsets(top:+contentInsets.top,+left:+contentInsets.left,+bottom:+keyboardSize.height,+right:contentInsets.right)
++++++++++++++++++++//+...
++++++++++++++++}+else+{
++++++++++++++++++++//+no+UIKeyboardFrameBeginUserInfoKey+entry+in+userInfo
++++++++++++++++}
++++++++++++}+else+{
++++++++++++++++//+no+userInfo+dictionary+in+notification
++++++++++++}
++++++++}

func+keyboardWillHide(notification:+NSNotification)+
{
let+contentInsets+=+self.tblView.contentInset+as+UIEdgeInsets
self.tblView.contentInset+=+UIEdgeInsets(top:+contentInsets.top,+left:+contentInsets.left,+bottom:+0,+right:contentInsets.right)
+}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4574959|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> override func viewWillAppear(animated: Bool)
 {
 super.viewWillAppear(animated)

 NSNotificationCenter.defaultCenter().addObserver(self, selector: "keyboardWillShow:", name: UIKeyboardWillShowNotification, object: nil)
 NSNotificationCenter.defaultCenter().addObserver(self, selector: "keyboardWillHide:", name: UIKeyboardWillHideNotification, object: nil)

 }

 // MARK: - keyboard
 func keyboardWillShow(notification: NSNotification) 
{

if let userInfo = notification.userInfo {
if let keyboardSize = (userInfo[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
let contentInsets = self.tblView.contentInset as UIEdgeInsets
self.tblView.contentInset = UIEdgeInsets(top: contentInsets.top, left: contentInsets.left, bottom: keyboardSize.height, right:contentInsets.right)
 // ...
 } else {
 // no UIKeyboardFrameBeginUserInfoKey entry in userInfo
 }
 } else {
 // no userInfo dictionary in notification
 }
 }

func keyboardWillHide(notification: NSNotification) 
{
let contentInsets = self.tblView.contentInset as UIEdgeInsets
self.tblView.contentInset = UIEdgeInsets(top: contentInsets.top, left: contentInsets.left, bottom: 0, right:contentInsets.right)
 }
</code></pre>

blocks|key|68502|text|使用以下代码在单击的UITextField上向上查看|type|unstyled|depth|inlineStyleRanges|entityRanges|data|68503|func+textFieldDidBeginEditing(textField:+UITextField)+{
++++ViewUpanimateMoving(true,+upValue:+100)
}
func+textFieldDidEndEditing(textField:+UITextField)+{
++++ViewUpanimateMoving(false,+upValue:+100)
}
func+ViewUpanimateMoving+(up:Bool,+upValue+:CGFloat){
++++var+durationMovement:NSTimeInterval+=+0.3
++++var+movement:CGFloat+=+(+up+?+-upValue+:+upValue)
++++UIView.beginAnimations(+"animateView",+context:+nil)
++++UIView.setAnimationBeginsFromCurrentState(true)
++++UIView.setAnimationDuration(durationMovement)
++++self.view.frame+=+CGRectOffset(self.view.frame,+0,++movement)
++++UIView.commitAnimations()
}|code-block|syntax|javascript|68504|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Use following code for view Up on UITextField Clicked 

<pre><code>func textFieldDidBeginEditing(textField: UITextField) {
 ViewUpanimateMoving(true, upValue: 100)
}
func textFieldDidEndEditing(textField: UITextField) {
 ViewUpanimateMoving(false, upValue: 100)
}
func ViewUpanimateMoving (up:Bool, upValue :CGFloat){
 var durationMovement:NSTimeInterval = 0.3
 var movement:CGFloat = ( up ? -upValue : upValue)
 UIView.beginAnimations( "animateView", context: nil)
 UIView.setAnimationBeginsFromCurrentState(true)
 UIView.setAnimationDuration(durationMovement)
 self.view.frame = CGRectOffset(self.view.frame, 0, movement)
 UIView.commitAnimations()
}
</code></pre>

blocks|key|68538|text|如果你在同一个VC上有两个或多个文本字段，用户点击其中一个，然后点击另一个，而没有调用函数keyboardWillHide，视图将再次向上移动，这是不必要的，因为您将拥有键盘，一个具有键盘高度的空白区域，然后是视图，使用我编辑的答案中的代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|68539|override+func+viewDidLoad()+{+++++++
++++super.viewDidLoad()
++++NSNotificationCenter.defaultCenter().addObserver(self,+selector:+Selector("keyboardWillShow:"),+name:+UIKeyboardWillShowNotification,+object:+nil)
++++NSNotificationCenter.defaultCenter().addObserver(self,+selector:+Selector("keyboardWillHide:"),+name:+UIKeyboardWillHideNotification,+object:+nil)
}

func+keyboardWillShow(notification:+NSNotification)+{
++++if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.CGRectValue()+{
++++++++self.view.frame.origin.y+-=+keyboardSize.height
++++}
}

func+keyboardWillHide(notification:+NSNotification)+{
++++if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.CGRectValue()+{
++++++++self.view.frame.origin.y+%2B=+keyboardSize.height
++++}
}|code-block|syntax|javascript|68540|要解决此问题，请将两个函数"KeyboardWillShow/Hide“替换为：|68541|func+keyboardWillShow(notification:+NSNotification)+{
+if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.CGRectValue()+{
++++if+view.frame.origin.y+==+0{
++++++++self.view.frame.origin.y+-=+keyboardSize.height
++++++++}
++++}
}

func+keyboardWillHide(notification:+NSNotification)+{
++++if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.CGRectValue()+{
++++++++if+view.frame.origin.y+!=+0+{
++++++++++++self.view.frame.origin.y+%2B=+keyboardSize.height
++++++++}
++++}
}|68542|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you have 2 or more text fields on the same VC, and the user taps on one of them and then taps on the other one, without calling the function keyboardWillHide, the view is going upwards one more time, which is not necessary, because you'll have the keyboard, a blank space which has the height of the keyboard, and then the view, using the code in the answer I edited:

<pre><code>override func viewDidLoad() { 
 super.viewDidLoad()
 NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillShow:"), name: UIKeyboardWillShowNotification, object: nil)
 NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("keyboardWillHide:"), name: UIKeyboardWillHideNotification, object: nil)
}

func keyboardWillShow(notification: NSNotification) {
 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
 self.view.frame.origin.y -= keyboardSize.height
 }
}

func keyboardWillHide(notification: NSNotification) {
 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
 self.view.frame.origin.y += keyboardSize.height
 }
}
</code></pre>

To solve this, replace the two functions "KeyboardWillShow/Hide" to these:

<pre><code>func keyboardWillShow(notification: NSNotification) {
 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
 if view.frame.origin.y == 0{
 self.view.frame.origin.y -= keyboardSize.height
 }
 }
}

func keyboardWillHide(notification: NSNotification) {
 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.CGRectValue() {
 if view.frame.origin.y != 0 {
 self.view.frame.origin.y += keyboardSize.height
 }
 }
}
</code></pre>

blocks|key|4575010|text|func+registerForKeyboardNotifications()
++++{
++++++++//Keyboard
++++++++NSNotificationCenter.defaultCenter().addObserver(self,+selector:+#selector(keyboardWasShown),+name:+UIKeyboardDidShowNotification,+object:+nil)
++++++++NSNotificationCenter.defaultCenter().addObserver(self,+selector:+#selector(keyboardWillBeHidden),+name:+UIKeyboardDidHideNotification,+object:+nil)


++++}
++++func+deregisterFromKeyboardNotifications(){

++++++++NSNotificationCenter.defaultCenter().removeObserver(self,+name:+UIKeyboardWillShowNotification,+object:+nil)
++++++++NSNotificationCenter.defaultCenter().removeObserver(self,+name:+UIKeyboardWillHideNotification,+object:+nil)

++++}
++++func+keyboardWasShown(notification:+NSNotification){

++++++++let+userInfo:+NSDictionary+=+notification.userInfo!
++++++++let+keyboardInfoFrame+=+userInfo.objectForKey(UIKeyboardFrameEndUserInfoKey)?.CGRectValue()

++++++++let+windowFrame:CGRect+=+(UIApplication.sharedApplication().keyWindow!.convertRect(self.view.frame,+fromView:self.view))

++++++++let+keyboardFrame+=+CGRectIntersection(windowFrame,+keyboardInfoFrame!)

++++++++let+coveredFrame+=+UIApplication.sharedApplication().keyWindow!.convertRect(keyboardFrame,+toView:self.view)

++++++++let+contentInsets+=+UIEdgeInsetsMake(0,+0,+(coveredFrame.size.height),+0.0)
++++++++self.scrollViewInAddCase+.contentInset+=+contentInsets;
++++++++self.scrollViewInAddCase.scrollIndicatorInsets+=+contentInsets;
++++++++self.scrollViewInAddCase.contentSize+=+CGSizeMake((self.scrollViewInAddCase.contentSize.width),+(self.scrollViewInAddCase.contentSize.height))

++++}
++++/**
+++++this+method+will+fire+when+keyboard+was+hidden

+++++-+parameter+notification:+contains+keyboard+details
+++++*/
++++func+keyboardWillBeHidden+(notification:+NSNotification)+{

++++++++self.scrollViewInAddCase.contentInset+=+UIEdgeInsetsZero
++++++++self.scrollViewInAddCase.scrollIndicatorInsets+=+UIEdgeInsetsZero

++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4575011|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>func registerForKeyboardNotifications()
 {
 //Keyboard
 NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(keyboardWasShown), name: UIKeyboardDidShowNotification, object: nil)
 NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(keyboardWillBeHidden), name: UIKeyboardDidHideNotification, object: nil)


 }
 func deregisterFromKeyboardNotifications(){

 NSNotificationCenter.defaultCenter().removeObserver(self, name: UIKeyboardWillShowNotification, object: nil)
 NSNotificationCenter.defaultCenter().removeObserver(self, name: UIKeyboardWillHideNotification, object: nil)

 }
 func keyboardWasShown(notification: NSNotification){

 let userInfo: NSDictionary = notification.userInfo!
 let keyboardInfoFrame = userInfo.objectForKey(UIKeyboardFrameEndUserInfoKey)?.CGRectValue()

 let windowFrame:CGRect = (UIApplication.sharedApplication().keyWindow!.convertRect(self.view.frame, fromView:self.view))

 let keyboardFrame = CGRectIntersection(windowFrame, keyboardInfoFrame!)

 let coveredFrame = UIApplication.sharedApplication().keyWindow!.convertRect(keyboardFrame, toView:self.view)

 let contentInsets = UIEdgeInsetsMake(0, 0, (coveredFrame.size.height), 0.0)
 self.scrollViewInAddCase .contentInset = contentInsets;
 self.scrollViewInAddCase.scrollIndicatorInsets = contentInsets;
 self.scrollViewInAddCase.contentSize = CGSizeMake((self.scrollViewInAddCase.contentSize.width), (self.scrollViewInAddCase.contentSize.height))

 }
 /**
 this method will fire when keyboard was hidden

 - parameter notification: contains keyboard details
 */
 func keyboardWillBeHidden (notification: NSNotification) {

 self.scrollViewInAddCase.contentInset = UIEdgeInsetsZero
 self.scrollViewInAddCase.scrollIndicatorInsets = UIEdgeInsetsZero

 }
</code></pre>

blocks|key|68584|text|swift+3.0在viewDidLoad()中插入，this->|type|unstyled|depth|inlineStyleRanges|entityRanges|data|68585|{|68586|view.addSubview(Your_messageInputConteinerView)|68587|++++view.addConstraintWithFormat(format:+"H:%7C[v0]%7C",+views:Your_messageInputConteinerView)

++++view.addConstraintWithFormat(format:+"V:[v0(48)]",+views:Your_messageInputConteinerView)|code-block|syntax|javascript|68588|对象(自身，选择器：#selector(handleKeyboardNotification(notification:))，名称:+NSNotification.Name.UIKeyboardWillShow，NotificationCenter.default.addObserver:+nil)|68589|对象(自身，选择器：#selector(handleKeyboardNotification(notification:))，名称：.UIKeyboardWillHide，NotificationCenter.default.addObserver:+nil)|68590|bottomConstraint+=+NSLayoutConstraint(item:+Your_messageInputConteinerView,+attribute:+.bottom,+relatedBy:+.equal,+toItem:+view,+attribute:+.bottom,+multiplier:+1,+constant:+0)

view.addConstraint(bottomConstraint!)|68591|}|68592|函数handleKeyboardNotification(notification:Notification){|68593|if+let+userInfo+=+notification.userInfo+{

++++if+let+keyBoardFrame+=+(userInfo[UIKeyboardFrameEndUserInfoKey]+as?+NSValue)?.cgRectValue{

++++++++print(keyBoardFrame)

++++++++if+bottomConstraint?.constant+!=+CGFloat(0)+{
++++++++++++++++bottomConstraint?.constant+=+0
++++++++++++++++return
++++++++++++}
+++++bottomConstraint?.constant+=+-keyBoardFrame.height
+++++++++++++++++++++++++++or
++++++++self.view.frame.origin.y+=+-keyBoardFrame.height
++++}
}|68594|68595|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|12|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|13|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|14|8|@]|9|@]|A|$]]|$1|O|3|P|5|H|7|15|8|@]|9|@]|A|$I|J]]|$1|Q|3|R|5|6|7|16|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|17|8|@]|9|@]|A|$]]|$1|U|3|V|5|H|7|18|8|@]|9|@]|A|$I|J]]|$1|W|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|X|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|Y|$]]

swift 3.0 insert in viewDidLoad(), this->

{

view.addSubview(Your_messageInputConteinerView)

<pre><code> view.addConstraintWithFormat(format: "H:|[v0]|", views:Your_messageInputConteinerView)

 view.addConstraintWithFormat(format: "V:[v0(48)]", views:Your_messageInputConteinerView)
</code></pre>

NotificationCenter.default.addObserver(self, selector: #selector(handleKeyboardNotification(notification:)), name: NSNotification.Name.UIKeyboardWillShow, object: nil)

NotificationCenter.default.addObserver(self, selector: #selector(handleKeyboardNotification(notification:)), name: .UIKeyboardWillHide, object: nil)

<pre><code>bottomConstraint = NSLayoutConstraint(item: Your_messageInputConteinerView, attribute: .bottom, relatedBy: .equal, toItem: view, attribute: .bottom, multiplier: 1, constant: 0)

view.addConstraint(bottomConstraint!)
</code></pre>

}

func handleKeyboardNotification(notification:Notification){

<pre><code>if let userInfo = notification.userInfo {

 if let keyBoardFrame = (userInfo[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue{

 print(keyBoardFrame)

 if bottomConstraint?.constant != CGFloat(0) {
 bottomConstraint?.constant = 0
 return
 }
 bottomConstraint?.constant = -keyBoardFrame.height
 or
 self.view.frame.origin.y = -keyBoardFrame.height
 }
}
</code></pre>

}

blocks|key|4575065|text|Swift+3代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4575066|var+activeField:+UITextField?

override+func+viewDidLoad()+{
++++super.viewDidLoad()

++++NotificationCenter.default.addObserver(self,+selector:+#selector(ProfileViewController.keyboardWillShow),+name:+NSNotification.Name.UIKeyboardWillShow,+object:+nil)
++++NotificationCenter.default.addObserver(self,+selector:+#selector(ProfileViewController.keyboardWillHide),+name:+NSNotification.Name.UIKeyboardWillHide,+object:+nil)
}

func+textFieldDidBeginEditing(_+textField:+UITextField){
++++activeField+=+textField
}

func+textFieldDidEndEditing(_+textField:+UITextField){
++++activeField+=+nil
}

func+keyboardWillShow(notification:+NSNotification)+{
++++if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.cgRectValue+{
++++++++if+(self.activeField?.frame.origin.y)!+>=+keyboardSize.height+{
++++++++++++self.view.frame.origin.y+=+keyboardSize.height+-+(self.activeField?.frame.origin.y)!
++++++++}+else+{
++++++++++++self.view.frame.origin.y+=+0
++++++++}
++++}
}

func+keyboardWillHide(notification:+NSNotification)+{
++++self.view.frame.origin.y+=+0
}|code-block|syntax|javascript|4575067|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Swift 3 code

<pre><code>var activeField: UITextField?

override func viewDidLoad() {
 super.viewDidLoad()

 NotificationCenter.default.addObserver(self, selector: #selector(ProfileViewController.keyboardWillShow), name: NSNotification.Name.UIKeyboardWillShow, object: nil)
 NotificationCenter.default.addObserver(self, selector: #selector(ProfileViewController.keyboardWillHide), name: NSNotification.Name.UIKeyboardWillHide, object: nil)
}

func textFieldDidBeginEditing(_ textField: UITextField){
 activeField = textField
}

func textFieldDidEndEditing(_ textField: UITextField){
 activeField = nil
}

func keyboardWillShow(notification: NSNotification) {
 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
 if (self.activeField?.frame.origin.y)! &gt;= keyboardSize.height {
 self.view.frame.origin.y = keyboardSize.height - (self.activeField?.frame.origin.y)!
 } else {
 self.view.frame.origin.y = 0
 }
 }
}

func keyboardWillHide(notification: NSNotification) {
 self.view.frame.origin.y = 0
}
</code></pre>

blocks|key|68627|text|我已经阅读了答案，并通过以下几行代码解决了我的问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|68628|class+ViewController:+UIViewController,+UITextFieldDelegate+{

++@IBOutlet+weak+var+titleField:+UITextField!
++@IBOutlet+weak+var+priceField:+UITextField!
++@IBOutlet+weak+var+detailsField:+UTtextField!

++override+func+viewDidLoad()+{
+++super.viewDidLoad()
//+Do+not+to+forget+to+set+the+delegate+otherwise+the+textFieldShouldReturn(_:)
//+won't+work+and+the+keyboard+will+never+be+hidden.
+++priceField.delegate+=+self
+++titleField.delegate+=+self
+++detailsField.delegate+=+self

+++NotificationCenter.default.addObserver(self,+selector:+#selector(keyboardWillShow),
+name:+NSNotification.Name.UIKeyboardWillShow,+object:+nil)

+++NotificationCenter.default.addObserver(self,+selector:+#selector(keyboardWillHide),
+name:+NSNotification.Name.UIKeyboardWillHide,+object:+nil)
++}

+++func+textFieldShouldReturn(_+textField:+UITextField)+->+Bool+{
++++++self.view.endEditing(true)
++++++return+false
+++}

+func+keyboardWillShow(notification:+NSNotification)+{
+++var+translation:CGFloat+=+0
+++if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.cgRectValue+{
+++++if+detailsField.isEditing{
+++++++translation+=+CGFloat(-keyboardSize.height)
+++++}else+if+priceField.isEditing{
+++++++translation+=+CGFloat(-keyboardSize.height+/+3.8)
+++++}
+++}
++++UIView.animate(withDuration:+0.2)+{
+++self.view.transform+=+CGAffineTransform(translationX:+0,+y:+translation)
++++}
++}


+func+keyboardWillHide(notification:+NSNotification)+{
++++UIView.animate(withDuration:+0.2)+{
+++++self.view.transform+=+CGAffineTransform(translationX:+0,+y:+0)
++++}+
++}
}|code-block|syntax|javascript|68629|我有几个UITextFields，并希望视图向上移动不同的取决于哪个textField被点击。|68630|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

i've read answers and solved my problem by this lines of code:

<pre><code>class ViewController: UIViewController, UITextFieldDelegate {

 @IBOutlet weak var titleField: UITextField!
 @IBOutlet weak var priceField: UITextField!
 @IBOutlet weak var detailsField: UTtextField!

 override func viewDidLoad() {
 super.viewDidLoad()
// Do not to forget to set the delegate otherwise the textFieldShouldReturn(_:)
// won't work and the keyboard will never be hidden.
 priceField.delegate = self
 titleField.delegate = self
 detailsField.delegate = self

 NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillShow),
 name: NSNotification.Name.UIKeyboardWillShow, object: nil)

 NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillHide),
 name: NSNotification.Name.UIKeyboardWillHide, object: nil)
 }

 func textFieldShouldReturn(_ textField: UITextField) -&gt; Bool {
 self.view.endEditing(true)
 return false
 }

 func keyboardWillShow(notification: NSNotification) {
 var translation:CGFloat = 0
 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
 if detailsField.isEditing{
 translation = CGFloat(-keyboardSize.height)
 }else if priceField.isEditing{
 translation = CGFloat(-keyboardSize.height / 3.8)
 }
 }
 UIView.animate(withDuration: 0.2) {
 self.view.transform = CGAffineTransform(translationX: 0, y: translation)
 }
 }


 func keyboardWillHide(notification: NSNotification) {
 UIView.animate(withDuration: 0.2) {
 self.view.transform = CGAffineTransform(translationX: 0, y: 0)
 } 
 }
}
</code></pre>

I have a few UITextFields and want the view to move up differently depending on which textField is tapped.

blocks|key|4575138|text|对于Swift+3，我创建了一个UIViewController子类，因为我需要所有视图控制器中的常量行为。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4575139|class+SomeClassVC:+UIViewController+{

++//MARK:+-+Lifecycle
++override+func+viewDidLoad()+{
++++super.viewDidLoad()

++++addKeyboardObservers()
++}

++override+func+viewWillDisappear(_+animated:+Bool)+{
++++super.viewWillDisappear(animated)

++++removeKeyboardObservers()
++}

++//MARK:+-+Overrides
++override+func+touchesBegan(_+touches:+Set<UITouch>,+with+event:+UIEvent?)+{
++++view.endEditing(true)
++}

++//MARK:+-+Help
++func+addKeyboardObservers()+{
++++NotificationCenter.default.addObserver(self,+selector:+#selector(self.keyboardWillShow),+name:+NSNotification.Name.UIKeyboardWillShow,+object:+nil)
++++NotificationCenter.default.addObserver(self,+selector:+#selector(self.keyboardWillHide),+name:+NSNotification.Name.UIKeyboardWillHide,+object:+nil)
++}

++func+removeKeyboardObservers()+{
++++NotificationCenter.default.removeObserver(self,+name:+NSNotification.Name.UIKeyboardWillShow,+object:+self.view.window)
++++NotificationCenter.default.removeObserver(self,+name:+NSNotification.Name.UIKeyboardWillHide,+object:+self.view.window)
++}

++func+keyboardWillShow(notification:+NSNotification)+{
++++let+keyboardHeight+=+(notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.cgRectValue.height
++++UIView.animate(withDuration:+0.1,+animations:+{+()+->+Void+in
++++++self.view.window?.frame.origin.y+=+-1+*+keyboardHeight!
++++++self.view.layoutIfNeeded()
++++})
++}

++func+keyboardWillHide(notification:+NSNotification)+{
++++UIView.animate(withDuration:+0.1,+animations:+{+()+->+Void+in
++++++self.view.window?.frame.origin.y+=+0
++++++self.view.layoutIfNeeded()
++++})
++}

++func+resignTextFieldFirstResponders()+{
++++for+textField+in+self.view.subviews+where+textField+is+UITextField+{
++++++textField.resignFirstResponder()
++++}
++}

++func+resignAllFirstResponders()+{
++++++view.endEditing(true)
++}
}|code-block|syntax|javascript|4575140|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For Swift 3, I made a UIViewController subclass since I needed constant behavior in all View Controllers. 

<pre><code>class SomeClassVC: UIViewController {

 //MARK: - Lifecycle
 override func viewDidLoad() {
 super.viewDidLoad()

 addKeyboardObservers()
 }

 override func viewWillDisappear(_ animated: Bool) {
 super.viewWillDisappear(animated)

 removeKeyboardObservers()
 }

 //MARK: - Overrides
 override func touchesBegan(_ touches: Set&lt;UITouch&gt;, with event: UIEvent?) {
 view.endEditing(true)
 }

 //MARK: - Help
 func addKeyboardObservers() {
 NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardWillShow), name: NSNotification.Name.UIKeyboardWillShow, object: nil)
 NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardWillHide), name: NSNotification.Name.UIKeyboardWillHide, object: nil)
 }

 func removeKeyboardObservers() {
 NotificationCenter.default.removeObserver(self, name: NSNotification.Name.UIKeyboardWillShow, object: self.view.window)
 NotificationCenter.default.removeObserver(self, name: NSNotification.Name.UIKeyboardWillHide, object: self.view.window)
 }

 func keyboardWillShow(notification: NSNotification) {
 let keyboardHeight = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue.height
 UIView.animate(withDuration: 0.1, animations: { () -&gt; Void in
 self.view.window?.frame.origin.y = -1 * keyboardHeight!
 self.view.layoutIfNeeded()
 })
 }

 func keyboardWillHide(notification: NSNotification) {
 UIView.animate(withDuration: 0.1, animations: { () -&gt; Void in
 self.view.window?.frame.origin.y = 0
 self.view.layoutIfNeeded()
 })
 }

 func resignTextFieldFirstResponders() {
 for textField in self.view.subviews where textField is UITextField {
 textField.resignFirstResponder()
 }
 }

 func resignAllFirstResponders() {
 view.endEditing(true)
 }
}
</code></pre>

blocks|key|4575178|text|对于初学者，我的两点建议是:在上面的示例中，有人更改了坐标，其他人使用了“自动调整掩码”，以及其他约束：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4575179|正如苹果公司所说，不要将这三种逻辑混为一谈。如果你在Storyboard中有约束，不要试图改变x/y。它肯定不起作用。|4575180|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

My two cents for beginners:
in above samples someone changes coordinates, other uses "autoresizing mask", and other constraints:

As Apple says, do not mix these 3 types of logic.
If You have constraints in Storyboard, do not try to change x/y. It definitively not work.

blocks|key|68727|text|func+keyboardWillHide(notification:+NSNotification)+{
++++if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.cgRectValue+{
++++++++if+self.view.frame.origin.y+!=+0{
+++++++++++//+self.view.frame.origin.y+%2B=+keyboardSize.height
++++++++++++self.view.frame.origin.y+=+0
++++++++}
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|68728|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>func keyboardWillHide(notification: NSNotification) {
 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
 if self.view.frame.origin.y != 0{
 // self.view.frame.origin.y += keyboardSize.height
 self.view.frame.origin.y = 0
 }
 }
}
</code></pre>

blocks|key|68786|text|它100%25完美地回答了所有人打开键盘时更新Tableview高度的问题|type|unstyled|depth|inlineStyleRanges|entityRanges|data|68787|对于Swift4.2|68788|+++override+func+viewDidLoad()+{
++++++super.viewDidLoad()
++++++NotificationCenter.default.addObserver(self,+selector:+#selector(RecipeVC.keyboardWillShow),+name:+UIResponder.keyboardWillShowNotification,+object:+nil)

++++++NotificationCenter.default.addObserver(self,+selector:+#selector(RecipeVC.keyboardWillHide),+name:+UIResponder.keyboardWillHideNotification,+object:+nil)
+++}

+++@objc+func+keyboardWillShow(notification:+NSNotification)+{
++++if+((notification.userInfo?[UIResponder.keyboardFrameBeginUserInfoKey]+as?+NSValue)?.cgRectValue)+!=+nil+{

++++++++var+userInfo+=+notification.userInfo!
++++++++var+keyboardFrame:CGRect+=+(userInfo[UIResponder.keyboardFrameEndUserInfoKey]+as!+NSValue).cgRectValue
++++++++keyboardFrame+=+self.view.convert(keyboardFrame,+from:+nil)

++++++++var+contentInset:UIEdgeInsets+=+self.tbl.contentInset
++++++++++contentInset.bottom+=+keyboardFrame.size.height
++++++++++self.tbl.contentInset+=+contentInset
++++}
}

+++@objc+func+keyboardWillHide(notification:+NSNotification)+{
++++if+((notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey]+as?+NSValue)?.cgRectValue)+!=+nil+{
++++++++let+contentInset:UIEdgeInsets+=+UIEdgeInsets(top:+0,+left:+0,+bottom:+0,+right:+0)
++++++++self.tbl.contentInset+=+contentInset
++++}
}|code-block|syntax|javascript|68789|Swift3.2|68790|++++override+func+viewDidLoad()+{
++++++++++super.viewDidLoad()

+++++++++++NotificationCenter.default.addObserver(self,+selector:+#selector(RecipeVC.keyboardWillShow),+name:+NSNotification.Name.UIKeyboardWillShow,+object:+nil)

+++++++++++NotificationCenter.default.addObserver(self,+selector:+#selector(RecipeVC.keyboardWillHide),+name:+NSNotification.Name.UIKeyboardWillHide,+object:+nil)
++++}
++++func+keyboardWillShow(notification:+NSNotification)+{
+++++++++if+((notification.userInfo?[UIKeyboardFrameBeginUserInfoKey]+as?+NSValue)?.cgRectValue)+!=+nil+{
+++++++++//self.view.frame.origin.y+-=+keyboardSize.height
+++++++++var+userInfo+=+notification.userInfo!
+++++++++var+keyboardFrame:CGRect+=+(userInfo[UIKeyboardFrameEndUserInfoKey]+as!+NSValue).cgRectValue
++++++++++keyboardFrame+=+self.view.convert(keyboardFrame,+from:+nil)

++++++++++var+contentInset:UIEdgeInsets+=+self.tbl.contentInset
++++++++++contentInset.bottom+=+keyboardFrame.size.height
++++++++++self.tbl.contentInset+=+contentInset

+++++++}
++++}

++++func+keyboardWillHide(notification:+NSNotification)+{
+++++++++if+((notification.userInfo?[UIKeyboardFrameEndUserInfoKey]+as?+NSValue)?.cgRectValue)+!=+nil+{
+++++++++let+contentInset:UIEdgeInsets+=+UIEdgeInsets(top:+0,+left:+0,+bottom:+0,+right:+0)
+++++++++self.tbl.contentInset+=+contentInset
+++++++++}
++++}|68791|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

its 100% Perfect Answer For all Guy's Update Tableview Height when open Keyboard 

For Swift4.2

<pre><code> override func viewDidLoad() {
 super.viewDidLoad()
 NotificationCenter.default.addObserver(self, selector: #selector(RecipeVC.keyboardWillShow), name: UIResponder.keyboardWillShowNotification, object: nil)

 NotificationCenter.default.addObserver(self, selector: #selector(RecipeVC.keyboardWillHide), name: UIResponder.keyboardWillHideNotification, object: nil)
 }

 @objc func keyboardWillShow(notification: NSNotification) {
 if ((notification.userInfo?[UIResponder.keyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue) != nil {

 var userInfo = notification.userInfo!
 var keyboardFrame:CGRect = (userInfo[UIResponder.keyboardFrameEndUserInfoKey] as! NSValue).cgRectValue
 keyboardFrame = self.view.convert(keyboardFrame, from: nil)

 var contentInset:UIEdgeInsets = self.tbl.contentInset
 contentInset.bottom = keyboardFrame.size.height
 self.tbl.contentInset = contentInset
 }
}

 @objc func keyboardWillHide(notification: NSNotification) {
 if ((notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue) != nil {
 let contentInset:UIEdgeInsets = UIEdgeInsets(top: 0, left: 0, bottom: 0, right: 0)
 self.tbl.contentInset = contentInset
 }
}
</code></pre>

Swift3.2

<pre><code> override func viewDidLoad() {
 super.viewDidLoad()

 NotificationCenter.default.addObserver(self, selector: #selector(RecipeVC.keyboardWillShow), name: NSNotification.Name.UIKeyboardWillShow, object: nil)

 NotificationCenter.default.addObserver(self, selector: #selector(RecipeVC.keyboardWillHide), name: NSNotification.Name.UIKeyboardWillHide, object: nil)
 }
 func keyboardWillShow(notification: NSNotification) {
 if ((notification.userInfo?[UIKeyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue) != nil {
 //self.view.frame.origin.y -= keyboardSize.height
 var userInfo = notification.userInfo!
 var keyboardFrame:CGRect = (userInfo[UIKeyboardFrameEndUserInfoKey] as! NSValue).cgRectValue
 keyboardFrame = self.view.convert(keyboardFrame, from: nil)

 var contentInset:UIEdgeInsets = self.tbl.contentInset
 contentInset.bottom = keyboardFrame.size.height
 self.tbl.contentInset = contentInset

 }
 }

 func keyboardWillHide(notification: NSNotification) {
 if ((notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue) != nil {
 let contentInset:UIEdgeInsets = UIEdgeInsets(top: 0, left: 0, bottom: 0, right: 0)
 self.tbl.contentInset = contentInset
 }
 }
</code></pre>

blocks|key|4575270|text|@Boris的解决方案非常好，但视图有时可能会被破坏。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4575271|为了获得完美的对齐效果，请使用以下代码|4575272|override+func+viewDidLoad()+{
super.viewDidLoad()++++++++++++
NotificationCenter.default.addObserver(self,+selector:+#selector(ViewController.keyboardWillShow),+name:+NSNotification.Name.UIKeyboardWillShow,+object:+nil)
NotificationCenter.default.addObserver(self,+selector:+#selector(ViewController.keyboardWillHide),+name:+NSNotification.Name.UIKeyboardWillHide,+object:+nil)}|code-block|syntax|javascript|4575273|功能：|4575274|@objc+func+keyboardWillShow(notification:+NSNotification)+{++++++++
if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameEndUserInfoKey]+as?+NSValue)?.cgRectValue+{
++++if+self.view.frame.origin.y+==+0{
++++++++self.view.frame.origin.y+-=+keyboardSize.height
++++}
}}++++|4575275|和,|4575276|@objc+func+keyboardWillHide(notification:+NSNotification)+{
if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameEndUserInfoKey]+as?+NSValue)?.cgRectValue+{
++++if+self.view.frame.origin.y+!=+0{
++++++++self.view.frame.origin.y+=+0+
++++}
}+}|4575277|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

@Boris's solution is VERY good but the view can sometimes be corrupted.

For the perfect alignment, use the below code

<pre><code>override func viewDidLoad() {
super.viewDidLoad() 
NotificationCenter.default.addObserver(self, selector: #selector(ViewController.keyboardWillShow), name: NSNotification.Name.UIKeyboardWillShow, object: nil)
NotificationCenter.default.addObserver(self, selector: #selector(ViewController.keyboardWillHide), name: NSNotification.Name.UIKeyboardWillHide, object: nil)}
</code></pre>

Functions:

<pre><code>@objc func keyboardWillShow(notification: NSNotification) { 
if let keyboardSize = (notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {
 if self.view.frame.origin.y == 0{
 self.view.frame.origin.y -= keyboardSize.height
 }
}} 
</code></pre>

And,

<pre><code>@objc func keyboardWillHide(notification: NSNotification) {
if let keyboardSize = (notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {
 if self.view.frame.origin.y != 0{
 self.view.frame.origin.y = 0 
 }
} }
</code></pre>

blocks|key|4575279|text|对我很管用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4575280|override+func+viewDidLoad()+{

++++++++super.viewDidLoad()

++++++++NotificationCenter.default.addObserver(self,+selector:+#selector(self.keyboardWillShow),+name:+NSNotification.Name.UIKeyboardWillShow,+object:+nil)
++++++++NotificationCenter.default.addObserver(self,+selector:+#selector(self.keyboardWillHide),+name:+NSNotification.Name.UIKeyboardWillHide,+object:+nil)
}

+var+isScroll+=+false


@objc+func+keyboardWillShow(sender:+NSNotification)+{
++++if(+!isScroll++){
++++++++self.view.frame.origin.y+-=+150
++++++++isScroll+=+true
++++}
}
@objc+func+keyboardWillHide(sender:+NSNotification)+{
++++if(+isScroll++){
++++++++self.view.frame.origin.y+%2B=+150
++++++++isScroll+=+false
++++}
}|code-block|syntax|javascript|4575281|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

works for me

<pre><code>override func viewDidLoad() {

 super.viewDidLoad()

 NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardWillShow), name: NSNotification.Name.UIKeyboardWillShow, object: nil)
 NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardWillHide), name: NSNotification.Name.UIKeyboardWillHide, object: nil)
}

 var isScroll = false


@objc func keyboardWillShow(sender: NSNotification) {
 if( !isScroll ){
 self.view.frame.origin.y -= 150
 isScroll = true
 }
}
@objc func keyboardWillHide(sender: NSNotification) {
 if( isScroll ){
 self.view.frame.origin.y += 150
 isScroll = false
 }
}
</code></pre>

blocks|key|4575289|text|这个实现(Swift+4)将为您提供最接近Android默认行为的行为。即:当活动的文本字段在键盘下方时，向上移动视图，当用户切换到另一个视图时，不关闭键盘，相应地移动视图。记得调用setTextFieldDelegates()。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4575290|public+class+DelegateProxy:+NSObject,+UITextFieldDelegate+{

++private+static+let+instance+=+DelegateProxies()

++weak+var+activeTextField:+UITextField?
++var+offset:+CGFloat+=+0
++weak+var+vc:+UIViewController?
++var+keyboardHeight:+CGFloat+=+0

++public+static+func+getDelegate(root:+UIViewController)+->+DelegateProxies+{
++++instance.vc+=+root
++++return+instance
++}

++public+static+func+getDelegate()+->+DelegateProxies+{
++++return+instance
++}

++public+func+textFieldShouldReturn(_+textField:+UITextField)+->+Bool+{
++++textField.resignFirstResponder()
++++return+true
++}


++public+func+textFieldShouldBeginEditing(_+textField:+UITextField)+->+Bool+{

++++self.activeTextField+=+textField

++++let+globalPointY:+CGFloat+=+(textField.superview?.convert(textField.frame.origin,+to:+nil).y+??+CGFloat(0))+%2B+textField.frame.height


++++offset+=+UIScreen.main.bounds.height+-+globalPointY

++++if+keyboardHeight+>+0+{
++++++++vc?.moveViewUp(offsetFromKeyboard:+keyboardHeight+-+offset)
++++}

++++return+true
++}
}


extension+UIViewController+{

++private+func+setTextFieldDelegates(parentView:+UIView)+{
++++for+child+in+parentView.subviews+{
++++++++setTextFieldDelegates(parentView:+child)
++++++++(child+as?+UITextField)?.delegate+=+DelegateProxies.getDelegate(root:+self)
++++}
++}

++func+registerAutoResizeOnKeyboardAppear(){
++++NotificationCenter.default.addObserver(self,+selector:+#selector(keyboardWillShow),+name:+NSNotification.Name.UIKeyboardWillShow,+object:+nil)
++++NotificationCenter.default.addObserver(self,+selector:+#selector(keyboardWillHide),+name:+NSNotification.Name.UIKeyboardWillHide,+object:+nil)
++}

++func+unregisterAutoResizeOnKeyboard(){
++++NotificationCenter.default.removeObserver(self,+name:+NSNotification.Name.UIKeyboardWillShow,+object:+nil)
++++NotificationCenter.default.removeObserver(self,+name:+NSNotification.Name.UIKeyboardWillHide,+object:+nil)
++}

++@objc+func+keyboardWillShow(notification:+NSNotification)+{

++++if+let+keyboardSize+=+(notification.userInfo?[UIKeyboardFrameEndUserInfoKey]+as?+NSValue)?.cgRectValue+{
++++++++let+offsetFromKeyboard+=+keyboardSize.height+-+DelegateProxies.getDelegate().offset
++++++++DelegateProxies.getDelegate().keyboardHeight+=+keyboardSize.height

++++++++moveViewUp(offsetFromKeyboard:+offsetFromKeyboard)
++++}
++}

++func+moveViewUp(offsetFromKeyboard:+CGFloat){
++++print("offset+from+keyboard:+\(offsetFromKeyboard)")

++++let+moveOffset+=+offsetFromKeyboard+%2B+8

++++if+offsetFromKeyboard+>+0+{
++++++++self.view.frame.origin.y+=+-moveOffset
++++}

++++if+offsetFromKeyboard+<+0+&&+view.frame.origin.y+<+0+{
++++++++self.view.frame.origin.y+%2B=+-moveOffset
++++++++if+self.view.frame.origin.y+>+0{
++++++++++++self.view.frame.origin.y+=+0
++++++++}
++++}
++}

++@objc+func+keyboardWillHide(notification:+NSNotification)+{
++++self.view.frame.origin.y+=+0
++}
}|code-block|syntax|javascript|4575291|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This implementation (Swift 4) will give you the behaviour that comes closest to the default behaviour of Android. Ie: moves the view up when the active textfield is under the keyboard and moves accordingly when the user switches to another view without closing the keyboard. Remember to call setTextFieldDelegates().

<pre><code>public class DelegateProxy: NSObject, UITextFieldDelegate {

 private static let instance = DelegateProxies()

 weak var activeTextField: UITextField?
 var offset: CGFloat = 0
 weak var vc: UIViewController?
 var keyboardHeight: CGFloat = 0

 public static func getDelegate(root: UIViewController) -&gt; DelegateProxies {
 instance.vc = root
 return instance
 }

 public static func getDelegate() -&gt; DelegateProxies {
 return instance
 }

 public func textFieldShouldReturn(_ textField: UITextField) -&gt; Bool {
 textField.resignFirstResponder()
 return true
 }


 public func textFieldShouldBeginEditing(_ textField: UITextField) -&gt; Bool {

 self.activeTextField = textField

 let globalPointY: CGFloat = (textField.superview?.convert(textField.frame.origin, to: nil).y ?? CGFloat(0)) + textField.frame.height


 offset = UIScreen.main.bounds.height - globalPointY

 if keyboardHeight &gt; 0 {
 vc?.moveViewUp(offsetFromKeyboard: keyboardHeight - offset)
 }

 return true
 }
}


extension UIViewController {

 private func setTextFieldDelegates(parentView: UIView) {
 for child in parentView.subviews {
 setTextFieldDelegates(parentView: child)
 (child as? UITextField)?.delegate = DelegateProxies.getDelegate(root: self)
 }
 }

 func registerAutoResizeOnKeyboardAppear(){
 NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillShow), name: NSNotification.Name.UIKeyboardWillShow, object: nil)
 NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillHide), name: NSNotification.Name.UIKeyboardWillHide, object: nil)
 }

 func unregisterAutoResizeOnKeyboard(){
 NotificationCenter.default.removeObserver(self, name: NSNotification.Name.UIKeyboardWillShow, object: nil)
 NotificationCenter.default.removeObserver(self, name: NSNotification.Name.UIKeyboardWillHide, object: nil)
 }

 @objc func keyboardWillShow(notification: NSNotification) {

 if let keyboardSize = (notification.userInfo?[UIKeyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {
 let offsetFromKeyboard = keyboardSize.height - DelegateProxies.getDelegate().offset
 DelegateProxies.getDelegate().keyboardHeight = keyboardSize.height

 moveViewUp(offsetFromKeyboard: offsetFromKeyboard)
 }
 }

 func moveViewUp(offsetFromKeyboard: CGFloat){
 print("offset from keyboard: \(offsetFromKeyboard)")

 let moveOffset = offsetFromKeyboard + 8

 if offsetFromKeyboard &gt; 0 {
 self.view.frame.origin.y = -moveOffset
 }

 if offsetFromKeyboard &lt; 0 &amp;&amp; view.frame.origin.y &lt; 0 {
 self.view.frame.origin.y += -moveOffset
 if self.view.frame.origin.y &gt; 0{
 self.view.frame.origin.y = 0
 }
 }
 }

 @objc func keyboardWillHide(notification: NSNotification) {
 self.view.frame.origin.y = 0
 }
}
</code></pre>

blocks|key|68838|text|移动视图的原点是一种幼稚的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|68839|这里有一个更好的解决方案:当键盘出现时调整视图的高度。|68840|let+viewHeight+=+self.view.frame.height

++++override+func+viewDidLoad()+{
++++++++super.viewDidLoad()

++++++++NotificationCenter.default.addObserver(self,+selector:+#selector(keyboardWillShow),+name:+UIResponder.keyboardWillShowNotification,+object:+nil)
++++++++NotificationCenter.default.addObserver(self,+selector:+#selector(keyboardWillHide),+name:+UIResponder.keyboardWillHideNotification,+object:+nil)
++++}

++++@objc+func+keyboardWillShow(notification:+NSNotification)+{
++++++++if+let+keyboardSize+=+(notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey]+as?+NSValue)?.cgRectValue+{
++++++++++++if+self.view.frame.height+==+self.viewHeight{
++++++++++++++++self.view.frame+=+CGRect(x:+0,+y:+0,+width:+self.view.frame.width,+height:+self.view.frame.height+-+keyboardSize.height)
++++++++++++}

++++++++}
++++}

++++@objc+func+keyboardWillHide(notification:+NSNotification)+{
++++++++if+let+keyboardSize+=+(notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey]+as?+NSValue)?.cgRectValue+{

++++++++++++self.view.frame+=+CGRect(x:+0,+y:+0,+width:+self.view.frame.width,+height:+self.view.frame.height+%2B+keyboardSize.height)
++++++++}
++++}|code-block|syntax|javascript|68841|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Moving origin of the view is a naive approach.

Here is the better solution: Adjust the height of the view when the keyboard appears.

<pre><code>let viewHeight = self.view.frame.height

 override func viewDidLoad() {
 super.viewDidLoad()

 NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillShow), name: UIResponder.keyboardWillShowNotification, object: nil)
 NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillHide), name: UIResponder.keyboardWillHideNotification, object: nil)
 }

 @objc func keyboardWillShow(notification: NSNotification) {
 if let keyboardSize = (notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {
 if self.view.frame.height == self.viewHeight{
 self.view.frame = CGRect(x: 0, y: 0, width: self.view.frame.width, height: self.view.frame.height - keyboardSize.height)
 }

 }
 }

 @objc func keyboardWillHide(notification: NSNotification) {
 if let keyboardSize = (notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {

 self.view.frame = CGRect(x: 0, y: 0, width: self.view.frame.width, height: self.view.frame.height + keyboardSize.height)
 }
 }
</code></pre>

I have an app that has a text field on the lower half of the view.
This means that when I go to type in the text field the keyboard covers the textfield.

How would I go about moving the view upwards while typing so I can see what i'm typing and then moving it back down to its original place when the keyboard disappears?

I've looked everywhere but all the solutions appear to be in Obj-C which I can't quite convert just yet.

Any help would be greatly appreciated.

Move view with keyboard using Swift

Android

Swift

我有一个应用程序，在视图的下半部分有一个文本字段。这意味着，当我在文本字段中键入内容时，键盘会覆盖文本字段。如何在键入时向上移动视图，以便可以看到正在键入的内容，然后在键盘消失时将其移回原来的位置？我已经到处找过了，但是所有的解决方案似乎都在Obj-C中，我现在还不能完全转换。任何帮助都将不胜感激。

问使用Swift使用键盘移动视图
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用Swift使用键盘移动视图EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用Swift使用键盘移动视图
EN