blocks|key|2292952|text|您需要添加一个ScrollView并设置键盘大小的底部填充，以便在键盘出现时内容能够滚动。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2292953|要获取键盘大小，您需要使用NotificationCenter注册键盘事件。您可以使用自定义类来执行此操作：|2292954|import+SwiftUI
import+Combine

final+class+KeyboardResponder:+BindableObject+{
++++let+didChange+=+PassthroughSubject<CGFloat,+Never>()

++++private+var+_center:+NotificationCenter
++++private(set)+var+currentHeight:+CGFloat+=+0+{
++++++++didSet+{
++++++++++++didChange.send(currentHeight)
++++++++}
++++}

++++init(center:+NotificationCenter+=+.default)+{
++++++++_center+=+center
++++++++_center.addObserver(self,+selector:+#selector(keyBoardWillShow(notification:)),+name:+UIResponder.keyboardWillShowNotification,+object:+nil)
++++++++_center.addObserver(self,+selector:+#selector(keyBoardWillHide(notification:)),+name:+UIResponder.keyboardWillHideNotification,+object:+nil)
++++}

++++deinit+{
++++++++_center.removeObserver(self)
++++}

++++@objc+func+keyBoardWillShow(notification:+Notification)+{
++++++++print("keyboard+will+show")
++++++++if+let+keyboardSize+=+(notification.userInfo?[UIResponder.keyboardFrameBeginUserInfoKey]+as?+NSValue)?.cgRectValue+{
++++++++++++currentHeight+=+keyboardSize.height
++++++++}
++++}

++++@objc+func+keyBoardWillHide(notification:+Notification)+{
++++++++print("keyboard+will+hide")
++++++++currentHeight+=+0
++++}
}|code-block|syntax|javascript|2292955|BindableObject一致性将允许您将此类用作State并触发视图更新。如果需要，请查看BindableObject的教程：SwiftUI+tutorial|2292956|完成后，您需要配置一个ScrollView，以便在出现键盘时减小它的大小。为了方便起见，我将这个ScrollView封装到某种组件中：|2292957|struct+KeyboardScrollView<Content:+View>:+View+{
++++@State+var+keyboard+=+KeyboardResponder()
++++private+var+content:+Content

++++init(@ViewBuilder+content:+()+->+Content)+{
++++++++self.content+=+content()
++++}

++++var+body:+some+View+{
++++++++ScrollView+{
++++++++++++VStack+{
++++++++++++++++content
++++++++++++}
++++++++}
++++++++.padding(.bottom,+keyboard.currentHeight)
++++}
}|2292958|您现在要做的就是将您的内容嵌入到自定义ScrollView中。|2292959|struct+ContentView+:+View+{
++++@State+var+textfieldText:+String+=+""

++++var+body:+some+View+{
++++++++KeyboardScrollView+{
++++++++++++ForEach(0...10)+{+index+in
++++++++++++++++TextField(self.$textfieldText,+placeholder:+Text("TextField\(index)"))+{
++++++++++++++++++++//+Hide+keyboard+when+uses+tap+return+button+on+keyboard.
++++++++++++++++++++self.endEditing(true)
++++++++++++++++}
++++++++++++}
++++++++}
++++}

++++private+func+endEditing(_+force:+Bool)+{
++++++++UIApplication.shared.keyWindow?.endEditing(true)
++++}
}|2292960|编辑：当键盘隐藏时，滚动行为真的很奇怪。也许使用动画来更新填充可以解决这个问题，或者您应该考虑使用padding以外的其他工具来调整滚动视图的大小。|BOLD|2292961|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.apple.com/tutorials/swiftui/handling-user-input^0|7|A|0|D|I|0|0|0|E|Q|5|1B|E|1T|G|0|0|B|A|1C|A|0|0|J|A|0|0|0|3|1D|7|0^^$0|@$1|2|3|4|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1D|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@$9|1L|A|1M|1|1N]]|E|$]]|$1|O|3|P|5|6|7|1O|8|@$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|J|7|1T|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|1U|8|@$9|1V|A|1W|B|C]]|D|@]|E|$]]|$1|U|3|V|5|J|7|1X|8|@]|D|@]|E|$K|L]]|$1|W|3|X|5|6|7|1Y|8|@$9|1Z|A|20|B|Y]|$9|21|A|22|B|C]]|D|@]|E|$]]|$1|Z|3|-4|5|6|7|23|8|@]|D|@]|E|$]]]|10|$11|$5|12|13|14|E|$15|16]]]]

You need to add a <code>ScrollView</code> and set a bottom padding of the size of the keyboard so the content will be able to scroll when the keyboard appears.

To get the keyboard size, you will need to use the <code>NotificationCenter</code> to register for keyboards event. You can use a custom class to do so:

<pre><code>import SwiftUI
import Combine

final class KeyboardResponder: BindableObject {
 let didChange = PassthroughSubject&lt;CGFloat, Never&gt;()

 private var _center: NotificationCenter
 private(set) var currentHeight: CGFloat = 0 {
 didSet {
 didChange.send(currentHeight)
 }
 }

 init(center: NotificationCenter = .default) {
 _center = center
 _center.addObserver(self, selector: #selector(keyBoardWillShow(notification:)), name: UIResponder.keyboardWillShowNotification, object: nil)
 _center.addObserver(self, selector: #selector(keyBoardWillHide(notification:)), name: UIResponder.keyboardWillHideNotification, object: nil)
 }

 deinit {
 _center.removeObserver(self)
 }

 @objc func keyBoardWillShow(notification: Notification) {
 print("keyboard will show")
 if let keyboardSize = (notification.userInfo?[UIResponder.keyboardFrameBeginUserInfoKey] as? NSValue)?.cgRectValue {
 currentHeight = keyboardSize.height
 }
 }

 @objc func keyBoardWillHide(notification: Notification) {
 print("keyboard will hide")
 currentHeight = 0
 }
}
</code></pre>

The <code>BindableObject</code> conformance will allow you to use this class as a <code>State</code> and trigger the view update. If needed look at the tutorial for <code>BindableObject</code>: <a href="https://developer.apple.com/tutorials/swiftui/handling-user-input" rel="noreferrer">SwiftUI tutorial</a>

When you get that, you need to configure a <code>ScrollView</code> to reduce its size when the keyboard appear. For convenience I wrapped this <code>ScrollView</code> into some kind of component:

<pre><code>struct KeyboardScrollView&lt;Content: View&gt;: View {
 @State var keyboard = KeyboardResponder()
 private var content: Content

 init(@ViewBuilder content: () -&gt; Content) {
 self.content = content()
 }

 var body: some View {
 ScrollView {
 VStack {
 content
 }
 }
 .padding(.bottom, keyboard.currentHeight)
 }
}
</code></pre>

All you have to do now is to embed your content inside the custom <code>ScrollView</code>.

<pre><code>struct ContentView : View {
 @State var textfieldText: String = ""

 var body: some View {
 KeyboardScrollView {
 ForEach(0...10) { index in
 TextField(self.$textfieldText, placeholder: Text("TextField\(index)")) {
 // Hide keyboard when uses tap return button on keyboard.
 self.endEditing(true)
 }
 }
 }
 }

 private func endEditing(_ force: Bool) {
 UIApplication.shared.keyWindow?.endEditing(true)
 }
}
</code></pre>

Edit:
The scroll behaviour is really weird when the keyboard is hiding. Maybe using an animation to update the padding would fix this, or you should consider using something else than the <code>padding</code> to adjust the scroll view size.

blocks|key|2505752|text|为Xcode更新的代码，beta+7。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2505753|您不需要填充、ScrollViews或列表来实现这一点。尽管这个解决方案也会和他们合作得很好。我在这里列举了两个例子。|2505754|第一个按钮将all+textField向上移动(如果其中任何一个出现键盘的话)。但只有在需要的情况下。如果键盘不隐藏文本字段，它们将不会移动。|2505755|在第二个示例中，视图的移动仅仅是为了避免隐藏活动的文本字段。|2505756|这两个示例使用了在末尾找到的相同公共代码：GeometryGetter和KeyboardGuardian|2505757|第一个示例(显示所有文本字段)|2505758|​|2505759|📷|atomic|2505760|2505761|struct+ContentView:+View+{
++++@ObservedObject+private+var+kGuardian+=+KeyboardGuardian(textFieldCount:+1)
++++@State+private+var+name+=+Array<String>.init(repeating:+"",+count:+3)

++++var+body:+some+View+{

++++++++VStack+{
++++++++++++Group+{
++++++++++++++++Text("Some+filler+text").font(.largeTitle)
++++++++++++++++Text("Some+filler+text").font(.largeTitle)
++++++++++++}

++++++++++++TextField("enter+text+#1",+text:+$name[0])
++++++++++++++++.textFieldStyle(RoundedBorderTextFieldStyle())

++++++++++++TextField("enter+text+#2",+text:+$name[1])
++++++++++++++++.textFieldStyle(RoundedBorderTextFieldStyle())

++++++++++++TextField("enter+text+#3",+text:+$name[2])
++++++++++++++++.textFieldStyle(RoundedBorderTextFieldStyle())
++++++++++++++++.background(GeometryGetter(rect:+$kGuardian.rects[0]))

++++++++}.offset(y:+kGuardian.slide).animation(.easeInOut(duration:+1.0))
++++}

}|code-block|syntax|javascript|2505762|第二个示例(仅显示活动字段)|2505763|2505764|2505765|2505766|struct+ContentView:+View+{
++++@ObservedObject+private+var+kGuardian+=+KeyboardGuardian(textFieldCount:+3)
++++@State+private+var+name+=+Array<String>.init(repeating:+"",+count:+3)

++++var+body:+some+View+{

++++++++VStack+{
++++++++++++Group+{
++++++++++++++++Text("Some+filler+text").font(.largeTitle)
++++++++++++++++Text("Some+filler+text").font(.largeTitle)
++++++++++++}

++++++++++++TextField("text+#1",+text:+$name[0],+onEditingChanged:+{+if+$0+{+self.kGuardian.showField+=+0+}+})
++++++++++++++++.textFieldStyle(RoundedBorderTextFieldStyle())
++++++++++++++++.background(GeometryGetter(rect:+$kGuardian.rects[0]))

++++++++++++TextField("text+#2",+text:+$name[1],+onEditingChanged:+{+if+$0+{+self.kGuardian.showField+=+1+}+})
++++++++++++++++.textFieldStyle(RoundedBorderTextFieldStyle())
++++++++++++++++.background(GeometryGetter(rect:+$kGuardian.rects[1]))

++++++++++++TextField("text+#3",+text:+$name[2],+onEditingChanged:+{+if+$0+{+self.kGuardian.showField+=+2+}+})
++++++++++++++++.textFieldStyle(RoundedBorderTextFieldStyle())
++++++++++++++++.background(GeometryGetter(rect:+$kGuardian.rects[2]))

++++++++++++}.offset(y:+kGuardian.slide).animation(.easeInOut(duration:+1.0))
++++}.onAppear+{+self.kGuardian.addObserver()+}+
.onDisappear+{+self.kGuardian.removeObserver()+}

}|2505767|GeometryGetter|2505768|这是一个吸收了其父视图的大小和位置的视图。为了实现这一点，需要在.background修饰符内部调用它。这是一个非常强大的修饰符，不仅仅是装饰视图背景的一种方式。在将视图传递给.background(+MyView+())时，MyView将获取修改后的视图作为父视图。通过使用GeometryReader，视图可以知道父对象的几何图形。|2505769|例如：Text("hello").background(GeometryGetter(rect:+$bounds))将使用文本视图的大小和位置填充可变边界，并使用全局坐标空间。|CODE|2505770|struct+GeometryGetter:+View+{
++++@Binding+var+rect:+CGRect

++++var+body:+some+View+{
++++++++GeometryReader+{+geometry+in
++++++++++++Group+{+()+->+AnyView+in
++++++++++++++++DispatchQueue.main.async+{
++++++++++++++++++++self.rect+=+geometry.frame(in:+.global)
++++++++++++++++}

++++++++++++++++return+AnyView(Color.clear)
++++++++++++}
++++++++}
++++}
}|2505771|更新我添加了DispatchQueue.main.async，以避免在呈现视图时修改视图状态的可能性。*|2505772|KeyboardGuardian|2505773|KeyboardGuardian的目的是跟踪键盘显示/隐藏事件，并计算需要移动视图的空间。|2505774|更新：我修改了KeyboardGuardian，以便在用户从一个字段切换到另一个字段时刷新幻灯片|2505775|import+SwiftUI
import+Combine

final+class+KeyboardGuardian:+ObservableObject+{
++++public+var+rects:+Array<CGRect>
++++public+var+keyboardRect:+CGRect+=+CGRect()

++++//+keyboardWillShow+notification+may+be+posted+repeatedly,
++++//+this+flag+makes+sure+we+only+act+once+per+keyboard+appearance
++++public+var+keyboardIsHidden+=+true

++++@Published+var+slide:+CGFloat+=+0

++++var+showField:+Int+=+0+{
++++++++didSet+{
++++++++++++updateSlide()
++++++++}
++++}

++++init(textFieldCount:+Int)+{
++++++++self.rects+=+Array<CGRect>(repeating:+CGRect(),+count:+textFieldCount)

++++}

++++func+addObserver()+{
NotificationCenter.default.addObserver(self,+selector:+#selector(keyBoardWillShow(notification:)),+name:+UIResponder.keyboardWillShowNotification,+object:+nil)
++++++++NotificationCenter.default.addObserver(self,+selector:+#selector(keyBoardDidHide(notification:)),+name:+UIResponder.keyboardDidHideNotification,+object:+nil)
}

func+removeObserver()+{
+NotificationCenter.default.removeObserver(self)
}

++++deinit+{
++++++++NotificationCenter.default.removeObserver(self)
++++}



++++@objc+func+keyBoardWillShow(notification:+Notification)+{
++++++++if+keyboardIsHidden+{
++++++++++++keyboardIsHidden+=+false
++++++++++++if+let+rect+=+notification.userInfo?["UIKeyboardFrameEndUserInfoKey"]+as?+CGRect+{
++++++++++++++++keyboardRect+=+rect
++++++++++++++++updateSlide()
++++++++++++}
++++++++}
++++}

++++@objc+func+keyBoardDidHide(notification:+Notification)+{
++++++++keyboardIsHidden+=+true
++++++++updateSlide()
++++}

++++func+updateSlide()+{
++++++++if+keyboardIsHidden+{
++++++++++++slide+=+0
++++++++}+else+{
++++++++++++let+tfRect+=+self.rects[self.showField]
++++++++++++let+diff+=+keyboardRect.minY+-+tfRect.maxY

++++++++++++if+diff+>+0+{
++++++++++++++++slide+%2B=+diff
++++++++++++}+else+{
++++++++++++++++slide+%2B=+min(diff,+0)
++++++++++++}

++++++++}
++++}
}|2505776|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/5a8bd49101ae9b3ddb1d8d05fcdbe056.gif|imageAlt|1|https://ask.qcloudimg.com/http-save/yehe-900000/099cde31c3b79f3f987f4b85d75665cd.gif^0|9|A|0|0|0|0|L|E|10|G|0|0|0|0|1|0|0|0|0|0|0|0|1|1|0|0|0|0|0|3|1J|0|0|0|2|0|0|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|21|8|@$9|22|A|23|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|24|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|25|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|26|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|27|8|@$9|28|A|29|B|C]|$9|2A|A|2B|B|C]]|D|@]|E|$]]|$1|N|3|O|5|6|7|2C|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|2D|8|@]|D|@]|E|$]]|$1|R|3|S|5|T|7|2E|8|@]|D|@$9|2F|A|2G|1|2H]]|E|$]]|$1|U|3|Q|5|6|7|2I|8|@]|D|@]|E|$]]|$1|V|3|W|5|X|7|2J|8|@]|D|@]|E|$Y|Z]]|$1|10|3|11|5|6|7|2K|8|@]|D|@]|E|$]]|$1|12|3|Q|5|6|7|2L|8|@]|D|@]|E|$]]|$1|13|3|S|5|T|7|2M|8|@]|D|@$9|2N|A|2O|1|2P]]|E|$]]|$1|14|3|Q|5|6|7|2Q|8|@]|D|@]|E|$]]|$1|15|3|16|5|X|7|2R|8|@]|D|@]|E|$Y|Z]]|$1|17|3|18|5|6|7|2S|8|@]|D|@]|E|$]]|$1|19|3|1A|5|6|7|2T|8|@]|D|@]|E|$]]|$1|1B|3|1C|5|6|7|2U|8|@$9|2V|A|2W|B|1D]]|D|@]|E|$]]|$1|1E|3|1F|5|X|7|2X|8|@]|D|@]|E|$Y|Z]]|$1|1G|3|1H|5|6|7|2Y|8|@$9|2Z|A|30|B|C]]|D|@]|E|$]]|$1|1I|3|1J|5|6|7|31|8|@]|D|@]|E|$]]|$1|1K|3|1L|5|6|7|32|8|@]|D|@]|E|$]]|$1|1M|3|1N|5|6|7|33|8|@$9|34|A|35|B|C]]|D|@]|E|$]]|$1|1O|3|1P|5|X|7|36|8|@]|D|@]|E|$Y|Z]]|$1|1Q|3|-4|5|6|7|37|8|@]|D|@]|E|$]]]|1R|$1S|$5|1T|1U|1V|E|$1W|1X|1Y|-4]]|1Z|$5|1T|1U|1V|E|$1W|20|1Y|-4]]]]

Code updated for the Xcode, beta 7.

You do not need padding, ScrollViews or Lists to achieve this. Although this solution will play nice with them too. I am including two examples here.

The first one moves all textField up, if the keyboard appears for any of them. But only if needed. If the keyboard doesn't hide the textfields, they will not move.

In the second example, the view only moves enough just to avoid hiding the active textfield.

Both examples use the same common code found at the end: GeometryGetter and KeyboardGuardian

<h2>First Example (show all textfields)</h2>

<a href="https://i.stack.imgur.com/PCHw5.gif" rel="noreferrer"><img src="https://i.stack.imgur.com/PCHw5.gif" alt="When the keyboard is opened, the 3 textfields are moved up enough to keep then all visible"></a>

<pre class="lang-swift prettyprint-override"><code>struct ContentView: View {
 @ObservedObject private var kGuardian = KeyboardGuardian(textFieldCount: 1)
 @State private var name = Array&lt;String&gt;.init(repeating: "", count: 3)

 var body: some View {

 VStack {
 Group {
 Text("Some filler text").font(.largeTitle)
 Text("Some filler text").font(.largeTitle)
 }

 TextField("enter text #1", text: $name[0])
 .textFieldStyle(RoundedBorderTextFieldStyle())

 TextField("enter text #2", text: $name[1])
 .textFieldStyle(RoundedBorderTextFieldStyle())

 TextField("enter text #3", text: $name[2])
 .textFieldStyle(RoundedBorderTextFieldStyle())
 .background(GeometryGetter(rect: $kGuardian.rects[0]))

 }.offset(y: kGuardian.slide).animation(.easeInOut(duration: 1.0))
 }

}
</code></pre>

<h2>Second Example (show only the active field)</h2>

<a href="https://i.stack.imgur.com/GT5Ij.gif" rel="noreferrer"><img src="https://i.stack.imgur.com/GT5Ij.gif" alt="When each text field is clicked, the view is only moved up enough to make the clicked text field visible."></a>

<pre class="lang-swift prettyprint-override"><code>struct ContentView: View {
 @ObservedObject private var kGuardian = KeyboardGuardian(textFieldCount: 3)
 @State private var name = Array&lt;String&gt;.init(repeating: "", count: 3)

 var body: some View {

 VStack {
 Group {
 Text("Some filler text").font(.largeTitle)
 Text("Some filler text").font(.largeTitle)
 }

 TextField("text #1", text: $name[0], onEditingChanged: { if $0 { self.kGuardian.showField = 0 } })
 .textFieldStyle(RoundedBorderTextFieldStyle())
 .background(GeometryGetter(rect: $kGuardian.rects[0]))

 TextField("text #2", text: $name[1], onEditingChanged: { if $0 { self.kGuardian.showField = 1 } })
 .textFieldStyle(RoundedBorderTextFieldStyle())
 .background(GeometryGetter(rect: $kGuardian.rects[1]))

 TextField("text #3", text: $name[2], onEditingChanged: { if $0 { self.kGuardian.showField = 2 } })
 .textFieldStyle(RoundedBorderTextFieldStyle())
 .background(GeometryGetter(rect: $kGuardian.rects[2]))

 }.offset(y: kGuardian.slide).animation(.easeInOut(duration: 1.0))
 }.onAppear { self.kGuardian.addObserver() } 
.onDisappear { self.kGuardian.removeObserver() }

}
</code></pre>

<h2>GeometryGetter</h2>

This is a view that absorbs the size and position of its parent view. In order to achieve that, it is called inside the .background modifier. This is a very powerful modifier, not just a way to decorate the background of a view. When passing a view to .background(MyView()), MyView is getting the modified view as the parent. Using GeometryReader is what makes it possible for the view to know the geometry of the parent.

For example: <code>Text("hello").background(GeometryGetter(rect: $bounds))</code> will fill variable bounds, with the size and position of the Text view, and using the global coordinate space.

<pre class="lang-swift prettyprint-override"><code>struct GeometryGetter: View {
 @Binding var rect: CGRect

 var body: some View {
 GeometryReader { geometry in
 Group { () -&gt; AnyView in
 DispatchQueue.main.async {
 self.rect = geometry.frame(in: .global)
 }

 return AnyView(Color.clear)
 }
 }
 }
}
</code></pre>

Update I added the DispatchQueue.main.async, to avoid the possibility of modifying the state of the view while it is being rendered.***

<h2>KeyboardGuardian</h2>

The purpose of KeyboardGuardian, is to keep track of keyboard show/hide events and calculate how much space the view needs to be shifted.

Update: I modified KeyboardGuardian to refresh the slide, when the user tabs from one field to another

<pre class="lang-swift prettyprint-override"><code>import SwiftUI
import Combine

final class KeyboardGuardian: ObservableObject {
 public var rects: Array&lt;CGRect&gt;
 public var keyboardRect: CGRect = CGRect()

 // keyboardWillShow notification may be posted repeatedly,
 // this flag makes sure we only act once per keyboard appearance
 public var keyboardIsHidden = true

 @Published var slide: CGFloat = 0

 var showField: Int = 0 {
 didSet {
 updateSlide()
 }
 }

 init(textFieldCount: Int) {
 self.rects = Array&lt;CGRect&gt;(repeating: CGRect(), count: textFieldCount)

 }

 func addObserver() {
NotificationCenter.default.addObserver(self, selector: #selector(keyBoardWillShow(notification:)), name: UIResponder.keyboardWillShowNotification, object: nil)
 NotificationCenter.default.addObserver(self, selector: #selector(keyBoardDidHide(notification:)), name: UIResponder.keyboardDidHideNotification, object: nil)
}

func removeObserver() {
 NotificationCenter.default.removeObserver(self)
}

 deinit {
 NotificationCenter.default.removeObserver(self)
 }



 @objc func keyBoardWillShow(notification: Notification) {
 if keyboardIsHidden {
 keyboardIsHidden = false
 if let rect = notification.userInfo?["UIKeyboardFrameEndUserInfoKey"] as? CGRect {
 keyboardRect = rect
 updateSlide()
 }
 }
 }

 @objc func keyBoardDidHide(notification: Notification) {
 keyboardIsHidden = true
 updateSlide()
 }

 func updateSlide() {
 if keyboardIsHidden {
 slide = 0
 } else {
 let tfRect = self.rects[self.showField]
 let diff = keyboardRect.minY - tfRect.maxY

 if diff &gt; 0 {
 slide += diff
 } else {
 slide += min(diff, 0)
 }

 }
 }
}
</code></pre>

blocks|key|2505972|text|对于这个问题，我得到的最优雅的回答类似于拉斐尔的解决方案。创建一个类来侦听键盘事件。不使用键盘大小来修改填充，而是返回键盘大小的负值，并使用.offset(y:)修饰符来调整最外层视图容器的偏移量。它的动画效果很好，可以在任何视图下工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2505973|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The most elegant answer I've managed to this is similar to rraphael's solution. Create a class to listen for keyboard events. Instead of using the keyboard size to modify padding though, return a negative value of the keyboard size, and use the .offset(y:) modifier to adjust the the outer most view containers's offset. It animates well enough, and works with any view.

blocks|key|2293684|text|我创建了一个视图，当键盘出现时，它可以包装任何其他视图以缩小它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2293685|这相当简单。我们为键盘显示/隐藏事件创建发布器，然后使用onReceive订阅它们。我们使用该结果在键盘后面创建一个键盘大小的矩形。|offset|length|style|CODE|2293686|struct+KeyboardHost<Content:+View>:+View+{
++++let+view:+Content

++++@State+private+var+keyboardHeight:+CGFloat+=+0

++++private+let+showPublisher+=+NotificationCenter.Publisher.init(
++++++++center:+.default,
++++++++name:+UIResponder.keyboardWillShowNotification
++++).map+{+(notification)+->+CGFloat+in
++++++++if+let+rect+=+notification.userInfo?["UIKeyboardFrameEndUserInfoKey"]+as?+CGRect+{
++++++++++++return+rect.size.height
++++++++}+else+{
++++++++++++return+0
++++++++}
++++}

++++private+let+hidePublisher+=+NotificationCenter.Publisher.init(
++++++++center:+.default,
++++++++name:+UIResponder.keyboardWillHideNotification
++++).map+{_+->+CGFloat+in+0}

++++//+Like+HStack+or+VStack,+the+only+parameter+is+the+view+that+this+view+should+layout.
++++//+(It+takes+one+view+rather+than+the+multiple+views+that+Stacks+can+take)
++++init(@ViewBuilder+content:+()+->+Content)+{
++++++++view+=+content()
++++}

++++var+body:+some+View+{
++++++++VStack+{
++++++++++++view
++++++++++++Rectangle()
++++++++++++++++.frame(height:+keyboardHeight)
++++++++++++++++.animation(.default)
++++++++++++++++.foregroundColor(.clear)
++++++++}.onReceive(showPublisher.merge(with:+hidePublisher))+{+(height)+in
++++++++++++self.keyboardHeight+=+height
++++++++}
++++}
}|code-block|syntax|javascript|2293687|然后，您可以像这样使用视图：|2293688|var+body:+some+View+{
++++KeyboardHost+{
++++++++viewIncludingKeyboard()
++++}
}|2293689|要向上移动视图的内容而不是缩小它，可以将填充或偏移添加到view中，而不是将其放在带有矩形的VStack中。|2293690|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.apple.com/documentation/swiftui/view/3278619-onreceive^0|0|S|9|S|9|0|0|0|0|0|S|4|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@$D|12|E|13|F|G]]|9|@$D|14|E|15|1|16]]|A|$]]|$1|H|3|I|5|J|7|17|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|18|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|19|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1A|8|@$D|1B|E|1C|F|G]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

I created a View that can wrap any other view to shrink it when the keyboard appears.

It's pretty simple. We create publishers for keyboard show/hide events and then subscribe to them using <a href="https://developer.apple.com/documentation/swiftui/view/3278619-onreceive" rel="noreferrer"><code>onReceive</code></a>. We use the result of that to create a keyboard-sized rectangle behind the keyboard.

<pre><code>struct KeyboardHost&lt;Content: View&gt;: View {
 let view: Content

 @State private var keyboardHeight: CGFloat = 0

 private let showPublisher = NotificationCenter.Publisher.init(
 center: .default,
 name: UIResponder.keyboardWillShowNotification
 ).map { (notification) -&gt; CGFloat in
 if let rect = notification.userInfo?["UIKeyboardFrameEndUserInfoKey"] as? CGRect {
 return rect.size.height
 } else {
 return 0
 }
 }

 private let hidePublisher = NotificationCenter.Publisher.init(
 center: .default,
 name: UIResponder.keyboardWillHideNotification
 ).map {_ -&gt; CGFloat in 0}

 // Like HStack or VStack, the only parameter is the view that this view should layout.
 // (It takes one view rather than the multiple views that Stacks can take)
 init(@ViewBuilder content: () -&gt; Content) {
 view = content()
 }

 var body: some View {
 VStack {
 view
 Rectangle()
 .frame(height: keyboardHeight)
 .animation(.default)
 .foregroundColor(.clear)
 }.onReceive(showPublisher.merge(with: hidePublisher)) { (height) in
 self.keyboardHeight = height
 }
 }
}
</code></pre>

You can then use the view like so:

<pre><code>var body: some View {
 KeyboardHost {
 viewIncludingKeyboard()
 }
}
</code></pre>

To move the content of the view up rather than shrinking it, padding or offset can be added to <code>view</code> rather than putting it in a VStack with a rectangle.

blocks|key|2506039|text|这是根据@kontiki构建的内容改编的。我在Beta8/+GM+seed下的一个应用程序中运行它，其中需要滚动的字段是NavigationView中表单的一部分。下面是KeyboardGuardian：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2506040|//
//++KeyboardGuardian.swift
//
//++https://stackoverflow.com/questions/56491881/move-textfield-up-when-thekeyboard-has-appeared-by-using-swiftui-ios
//

import+SwiftUI
import+Combine

///+The+purpose+of+KeyboardGuardian,+is+to+keep+track+of+keyboard+show/hide+events+and
///+calculate+how+much+space+the+view+needs+to+be+shifted.
final+class+KeyboardGuardian:+ObservableObject+{
++++let+objectWillChange+=+ObservableObjectPublisher()+//+PassthroughSubject<Void,+Never>()

++++public+var+rects:+Array<CGRect>
++++public+var+keyboardRect:+CGRect+=+CGRect()

++++//+keyboardWillShow+notification+may+be+posted+repeatedly,
++++//+this+flag+makes+sure+we+only+act+once+per+keyboard+appearance
++++private+var+keyboardIsHidden+=+true

++++var+slide:+CGFloat+=+0+{
++++++++didSet+{
++++++++++++objectWillChange.send()
++++++++}
++++}

++++public+var+showField:+Int+=+0+{
++++++++didSet+{
++++++++++++updateSlide()
++++++++}
++++}

++++init(textFieldCount:+Int)+{
++++++++self.rects+=+Array<CGRect>(repeating:+CGRect(),+count:+textFieldCount)

++++++++NotificationCenter.default.addObserver(self,+selector:+#selector(keyBoardWillShow(notification:)),+name:+UIResponder.keyboardWillShowNotification,+object:+nil)
++++++++NotificationCenter.default.addObserver(self,+selector:+#selector(keyBoardDidHide(notification:)),+name:+UIResponder.keyboardDidHideNotification,+object:+nil)

++++}

++++@objc+func+keyBoardWillShow(notification:+Notification)+{
++++++++if+keyboardIsHidden+{
++++++++++++keyboardIsHidden+=+false
++++++++++++if+let+rect+=+notification.userInfo?["UIKeyboardFrameEndUserInfoKey"]+as?+CGRect+{
++++++++++++++++keyboardRect+=+rect
++++++++++++++++updateSlide()
++++++++++++}
++++++++}
++++}

++++@objc+func+keyBoardDidHide(notification:+Notification)+{
++++++++keyboardIsHidden+=+true
++++++++updateSlide()
++++}

++++func+updateSlide()+{
++++++++if+keyboardIsHidden+{
++++++++++++slide+=+0
++++++++}+else+{
++++++++++++slide+=+-keyboardRect.size.height
++++++++}
++++}
}|code-block|syntax|javascript|2506041|然后，我使用一个枚举来跟踪rects数组中的槽和总数：|2506042|enum+KeyboardSlots:+Int+{
++++case+kLogPath
++++case+kLogThreshold
++++case+kDisplayClip
++++case+kPingInterval
++++case+count
}|2506043|KeyboardSlots.count.rawValue是必需的数组容量；rawValue等其他参数提供了用于.background(GeometryGetter)调用的适当索引。|offset|length|style|CODE|2506044|有了这个设置，视图就可以通过下面的代码获得KeyboardGuardian：|2506045|@ObservedObject+private+var+kGuardian+=+KeyboardGuardian(textFieldCount:+SettingsFormBody.KeyboardSlots.count.rawValue)|2506046|实际的运动是这样的：|2506047|.offset(y:+kGuardian.slide).animation(.easeInOut(duration:+1))|2506048|附着到视图。在我的例子中，它被连接到整个NavigationView上，所以当键盘出现时，整个组装就会滑动起来。|2506049|我还没有解决用SwiftUI在十进制键盘上获得完成工具栏或回车键的问题，所以我用它把它隐藏在其他地方的点击上：|2506050|struct+DismissingKeyboard:+ViewModifier+{
++++func+body(content:+Content)+->+some+View+{
++++++++content
++++++++++++.onTapGesture+{
++++++++++++++++let+keyWindow+=+UIApplication.shared.connectedScenes
++++++++++++++++++++++++.filter({$0.activationState+==+.foregroundActive})
++++++++++++++++++++++++.map({$0+as?+UIWindowScene})
++++++++++++++++++++++++.compactMap({$0})
++++++++++++++++++++++++.first?.windows
++++++++++++++++++++++++.filter({$0.isKeyWindow}).first
++++++++++++++++keyWindow?.endEditing(true)++++++++++++++++++++
++++++++}
++++}
}|2506051|您可以将其附加到视图，作为|2506052|.modifier(DismissingKeyboard())|2506053|有些视图(例如，选择器)不喜欢附加修饰符，因此您可能需要在附加修饰符时稍微细粒度一些，而不是仅仅将其放在最外面的视图上。|2506054|非常感谢@kontiki的辛勤工作。您仍然需要上面的GeometryGetter+(不，我也没有完成将其转换为使用首选项的工作)，如他在示例中所示。|2506055|entityMap^0|0|0|0|0|0|S|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1G|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1I|8|@$M|1J|N|1K|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1L|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1N|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1O|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|1P|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|12|3|13|5|D|7|1R|8|@]|9|@]|A|$E|F]]|$1|14|3|15|5|6|7|1S|8|@]|9|@]|A|$]]|$1|16|3|17|5|D|7|1T|8|@]|9|@]|A|$E|F]]|$1|18|3|19|5|6|7|1U|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|1V|8|@]|9|@]|A|$]]|$1|1C|3|-4|5|6|7|1W|8|@]|9|@]|A|$]]]|1D|$]]

This is adapted from what @kontiki built. I have it running in an app under beta 8 / GM seed, where the field needing scrolled is part of a form inside a NavigationView. Here's KeyboardGuardian:

<pre><code>//
// KeyboardGuardian.swift
//
// https://stackoverflow.com/questions/56491881/move-textfield-up-when-thekeyboard-has-appeared-by-using-swiftui-ios
//

import SwiftUI
import Combine

/// The purpose of KeyboardGuardian, is to keep track of keyboard show/hide events and
/// calculate how much space the view needs to be shifted.
final class KeyboardGuardian: ObservableObject {
 let objectWillChange = ObservableObjectPublisher() // PassthroughSubject&lt;Void, Never&gt;()

 public var rects: Array&lt;CGRect&gt;
 public var keyboardRect: CGRect = CGRect()

 // keyboardWillShow notification may be posted repeatedly,
 // this flag makes sure we only act once per keyboard appearance
 private var keyboardIsHidden = true

 var slide: CGFloat = 0 {
 didSet {
 objectWillChange.send()
 }
 }

 public var showField: Int = 0 {
 didSet {
 updateSlide()
 }
 }

 init(textFieldCount: Int) {
 self.rects = Array&lt;CGRect&gt;(repeating: CGRect(), count: textFieldCount)

 NotificationCenter.default.addObserver(self, selector: #selector(keyBoardWillShow(notification:)), name: UIResponder.keyboardWillShowNotification, object: nil)
 NotificationCenter.default.addObserver(self, selector: #selector(keyBoardDidHide(notification:)), name: UIResponder.keyboardDidHideNotification, object: nil)

 }

 @objc func keyBoardWillShow(notification: Notification) {
 if keyboardIsHidden {
 keyboardIsHidden = false
 if let rect = notification.userInfo?["UIKeyboardFrameEndUserInfoKey"] as? CGRect {
 keyboardRect = rect
 updateSlide()
 }
 }
 }

 @objc func keyBoardDidHide(notification: Notification) {
 keyboardIsHidden = true
 updateSlide()
 }

 func updateSlide() {
 if keyboardIsHidden {
 slide = 0
 } else {
 slide = -keyboardRect.size.height
 }
 }
}
</code></pre>

Then, I used an enum to track the slots in the rects array and the total number:

<pre><code>enum KeyboardSlots: Int {
 case kLogPath
 case kLogThreshold
 case kDisplayClip
 case kPingInterval
 case count
}
</code></pre>

<code>KeyboardSlots.count.rawValue</code> is the necessary array capacity; the others as rawValue give the appropriate index you'll use for .background(GeometryGetter) calls.

With that set up, views get at the KeyboardGuardian with this:

<pre><code>@ObservedObject private var kGuardian = KeyboardGuardian(textFieldCount: SettingsFormBody.KeyboardSlots.count.rawValue)
</code></pre>

The actual movement is like this:

<pre><code>.offset(y: kGuardian.slide).animation(.easeInOut(duration: 1))
</code></pre>

attached to the view. In my case, it's attached to the entire NavigationView, so the complete assembly slides up as the keyboard appears.

I haven't solved the problem of getting a Done toolbar or a return key on a decimal keyboard with SwiftUI, so instead I'm using this to hide it on a tap elsewhere:

<pre><code>struct DismissingKeyboard: ViewModifier {
 func body(content: Content) -&gt; some View {
 content
 .onTapGesture {
 let keyWindow = UIApplication.shared.connectedScenes
 .filter({$0.activationState == .foregroundActive})
 .map({$0 as? UIWindowScene})
 .compactMap({$0})
 .first?.windows
 .filter({$0.isKeyWindow}).first
 keyWindow?.endEditing(true) 
 }
 }
}
</code></pre>

You attach it to a view as

<pre><code>.modifier(DismissingKeyboard())
</code></pre>

Some views (e.g., pickers) don't like having that attached, so you may need to be somewhat granular in how you attach the modifier rather than just slapping it on the outermost view.

Many thanks to @kontiki for the hard work. You'll still need his GeometryGetter above (nope, I didn't do the work to convert it to use preferences either) as he illustrates in his examples.

blocks|key|2506191|text|我使用了本杰明·金德尔的答案作为起点，但我有几个问题想要解决。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2506192|2506193|这里的大多数答案都不涉及键盘改变框架的问题，所以如果用户在屏幕上使用键盘旋转设备，答案就会失效。|ordered-list-item|2506194|我不希望多个发布者有相似但不同的地图闭包，所以我将所有三个键盘通知链接到一个发布者中。无可否认，这是一条很长的链，但每一步都是非常好用的straightforward.|2506195|I提供了init函数，该函数接受@ViewBuilder，这样您就可以像使用任何其他视图一样使用KeyboardHost视图，并在尾部闭包中传递内容，而不是将内容视图作为参数传递给init.|offset|length|style|CODE|2506196|As+Tae和fdelafuente注释中建议的我换出了用于调整底部padding.|2506197|Instead的Rectangle，使用硬编码的"UIKeyboardFrameEndUserInfoKey“字符串我想使用UIWindow中提供的字符串作为fdelafuente|2506198|2506199|把所有这些放在一起我有：|2506200|struct+KeyboardHost<Content>:+View++where+Content:+View+{
++++var+content:+Content

++++///+The+current+height+of+the+keyboard+rect.
++++@State+private+var+keyboardHeight+=+CGFloat(0)

++++///+A+publisher+that+combines+all+of+the+relevant+keyboard+changing+notifications+and+maps+them+into+a+`CGFloat`+representing+the+new+height+of+the
++++///+keyboard+rect.
++++private+let+keyboardChangePublisher+=+NotificationCenter.Publisher(center:+.default,
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++name:+UIResponder.keyboardWillShowNotification)
++++++++.merge(with:+NotificationCenter.Publisher(center:+.default,
++++++++++++++++++++++++++++++++++++++++++++++++++name:+UIResponder.keyboardWillChangeFrameNotification))
++++++++.merge(with:+NotificationCenter.Publisher(center:+.default,
++++++++++++++++++++++++++++++++++++++++++++++++++name:+UIResponder.keyboardWillHideNotification)
++++++++++++//+But+we+don't+want+to+pass+the+keyboard+rect+from+keyboardWillHide,+so+strip+the+userInfo+out+before
++++++++++++//+passing+the+notification+on.
++++++++++++.map+{+Notification(name:+$0.name,+object:+$0.object,+userInfo:+nil)+})
++++++++//+Now+map+the+merged+notification+stream+into+a+height+value.
++++++++.map+{+($0.userInfo?[UIWindow.keyboardFrameEndUserInfoKey]+as?+CGRect+??+.zero).size.height+}
++++++++//+If+you+want+to+debug+the+notifications,+swap+this+in+for+the+final+map+call+above.
//++++++++.map+{+(note)+->+CGFloat+in
//++++++++++++let+height+=+(note.userInfo?[UIWindow.keyboardFrameEndUserInfoKey]+as?+CGRect+??+.zero).size.height
//
//++++++++++++print("Received+\(note.name.rawValue)+with+height+\(height)")
//++++++++++++return+height
//++++}

++++var+body:+some+View+{
++++++++content
++++++++++++.onReceive(keyboardChangePublisher)+{+self.keyboardHeight+=+$0+}
++++++++++++.padding(.bottom,+keyboardHeight)
++++++++++++.animation(.default)
++++}

++++init(@ViewBuilder+_+content:+@escaping+()+->+Content)+{
++++++++self.content+=+content()
++++}
}

struct+KeyboardHost_Previews:+PreviewProvider+{
++++static+var+previews:+some+View+{
++++++++KeyboardHost+{
++++++++++++TextField("TextField",+text:+.constant("Preview+text+field"))
++++++++}
++++}
}|code-block|syntax|javascript|2506201|entityMap^0|0|0|0|0|4|4|G|C|1C|C|2I|4|0|0|8|9|1Q|8|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|13|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|14|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|15|8|@$J|16|K|17|L|M]|$J|18|K|19|L|M]|$J|1A|K|1B|L|M]|$J|1C|K|1D|L|M]]|9|@]|A|$]]|$1|N|3|O|5|E|7|1E|8|@]|9|@]|A|$]]|$1|P|3|Q|5|E|7|1F|8|@$J|1G|K|1H|L|M]|$J|1I|K|1J|L|M]]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1L|8|@]|9|@]|A|$]]|$1|U|3|V|5|W|7|1M|8|@]|9|@]|A|$X|Y]]|$1|Z|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|10|$]]

I used Benjamin Kindle's answer as as starting point, but I had a few issues I wanted to address.

<ol>
<li>Most of the answers here do not deal with the keyboard changing its frame, so they break if the user rotates the device with the keyboard onscreen. Adding <code>keyboardWillChangeFrameNotification</code> to the list of notifications processed addresses this.</li>
<li>I didn't want multiple publishers with similar-but-different map closures, so I chained all three keyboard notifications into a single publisher. It's admittedly a long chain but each step is pretty straightforward.</li>
<li>I provided the <code>init</code> function that accepts a <code>@ViewBuilder</code> so that you can use the <code>KeyboardHost</code> view like any other View and simply pass your content in a trailing closure, as opposed to passing the content view as a parameter to <code>init</code>.</li>
<li>As Tae and fdelafuente suggested in comments I swapped out the <code>Rectangle</code> for adjusting the bottom padding.</li>
<li>Instead of using the hard-coded "UIKeyboardFrameEndUserInfoKey" string I wanted to use the strings provided in <code>UIWindow</code> as <code>UIWindow.keyboardFrameEndUserInfoKey</code>.</li>
</ol>

Pulling that all together I have:

<pre><code>struct KeyboardHost&lt;Content&gt;: View where Content: View {
 var content: Content

 /// The current height of the keyboard rect.
 @State private var keyboardHeight = CGFloat(0)

 /// A publisher that combines all of the relevant keyboard changing notifications and maps them into a `CGFloat` representing the new height of the
 /// keyboard rect.
 private let keyboardChangePublisher = NotificationCenter.Publisher(center: .default,
 name: UIResponder.keyboardWillShowNotification)
 .merge(with: NotificationCenter.Publisher(center: .default,
 name: UIResponder.keyboardWillChangeFrameNotification))
 .merge(with: NotificationCenter.Publisher(center: .default,
 name: UIResponder.keyboardWillHideNotification)
 // But we don't want to pass the keyboard rect from keyboardWillHide, so strip the userInfo out before
 // passing the notification on.
 .map { Notification(name: $0.name, object: $0.object, userInfo: nil) })
 // Now map the merged notification stream into a height value.
 .map { ($0.userInfo?[UIWindow.keyboardFrameEndUserInfoKey] as? CGRect ?? .zero).size.height }
 // If you want to debug the notifications, swap this in for the final map call above.
// .map { (note) -&gt; CGFloat in
// let height = (note.userInfo?[UIWindow.keyboardFrameEndUserInfoKey] as? CGRect ?? .zero).size.height
//
// print("Received \(note.name.rawValue) with height \(height)")
// return height
// }

 var body: some View {
 content
 .onReceive(keyboardChangePublisher) { self.keyboardHeight = $0 }
 .padding(.bottom, keyboardHeight)
 .animation(.default)
 }

 init(@ViewBuilder _ content: @escaping () -&gt; Content) {
 self.content = content()
 }
}

struct KeyboardHost_Previews: PreviewProvider {
 static var previews: some View {
 KeyboardHost {
 TextField("TextField", text: .constant("Preview text field"))
 }
 }
}

</code></pre>

blocks|key|2506209|text|为了在@rraphael的解决方案的基础上构建，我将其转换为可用于今天的xcode11+swiftUI支持。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2506210|import+SwiftUI

final+class+KeyboardResponder:+ObservableObject+{
++++private+var+notificationCenter:+NotificationCenter
++++@Published+private(set)+var+currentHeight:+CGFloat+=+0

++++init(center:+NotificationCenter+=+.default)+{
++++++++notificationCenter+=+center
++++++++notificationCenter.addObserver(self,+selector:+#selector(keyBoardWillShow(notification:)),+name:+UIResponder.keyboardWillShowNotification,+object:+nil)
++++++++notificationCenter.addObserver(self,+selector:+#selector(keyBoardWillHide(notification:)),+name:+UIResponder.keyboardWillHideNotification,+object:+nil)
++++}

++++deinit+{
++++++++notificationCenter.removeObserver(self)
++++}

++++@objc+func+keyBoardWillShow(notification:+Notification)+{
++++++++if+let+keyboardSize+=+(notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey]+as?+NSValue)?.cgRectValue+{
++++++++++++currentHeight+=+keyboardSize.height
++++++++}
++++}

++++@objc+func+keyBoardWillHide(notification:+Notification)+{
++++++++currentHeight+=+0
++++}
}|code-block|syntax|javascript|2506211|用法：|2506212|struct+ContentView:+View+{
++++@ObservedObject+private+var+keyboard+=+KeyboardResponder()
++++@State+private+var+textFieldInput:+String+=+""

++++var+body:+some+View+{
++++++++VStack+{
++++++++++++HStack+{
++++++++++++++++TextField("uMessage",+text:+$textFieldInput)
++++++++++++}
++++++++}.padding()
++++++++.padding(.bottom,+keyboard.currentHeight)
++++++++.edgesIgnoringSafeArea(.bottom)
++++++++.animation(.easeOut(duration:+0.16))
++++}
}|2506213|发布的currentHeight将触发UI重新渲染，并在键盘显示时将TextField向上移动，在关闭时向下移动。然而，我没有使用ScrollView。|offset|length|style|CODE|2506214|entityMap^0|0|0|0|0|3|D|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

To build off of @rraphael 's solution, I converted it to be usable by today's xcode11 swiftUI support.

<pre><code>import SwiftUI

final class KeyboardResponder: ObservableObject {
 private var notificationCenter: NotificationCenter
 @Published private(set) var currentHeight: CGFloat = 0

 init(center: NotificationCenter = .default) {
 notificationCenter = center
 notificationCenter.addObserver(self, selector: #selector(keyBoardWillShow(notification:)), name: UIResponder.keyboardWillShowNotification, object: nil)
 notificationCenter.addObserver(self, selector: #selector(keyBoardWillHide(notification:)), name: UIResponder.keyboardWillHideNotification, object: nil)
 }

 deinit {
 notificationCenter.removeObserver(self)
 }

 @objc func keyBoardWillShow(notification: Notification) {
 if let keyboardSize = (notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue {
 currentHeight = keyboardSize.height
 }
 }

 @objc func keyBoardWillHide(notification: Notification) {
 currentHeight = 0
 }
}
</code></pre>

Usage:

<pre><code>struct ContentView: View {
 @ObservedObject private var keyboard = KeyboardResponder()
 @State private var textFieldInput: String = ""

 var body: some View {
 VStack {
 HStack {
 TextField("uMessage", text: $textFieldInput)
 }
 }.padding()
 .padding(.bottom, keyboard.currentHeight)
 .edgesIgnoringSafeArea(.bottom)
 .animation(.easeOut(duration: 0.16))
 }
}
</code></pre>

The published <code>currentHeight</code> will trigger a UI re-render and move your TextField up when the keyboard shows, and back down when dismissed. However I didn't use a ScrollView.

blocks|key|2506216|text|我不确定SwiftUI的转换/动画API是否已经完成，但您可以将CGAffineTransform与.transformEffect一起使用|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2506217|创建一个具有发布属性的可观察键盘对象，如下所示：|2506218|++++final+class+KeyboardResponder:+ObservableObject+{
++++private+var+notificationCenter:+NotificationCenter
++++@Published+var+readyToAppear+=+false

++++init(center:+NotificationCenter+=+.default)+{
++++++++notificationCenter+=+center
++++++++notificationCenter.addObserver(self,+selector:+#selector(keyBoardWillShow(notification:)),+name:+UIResponder.keyboardWillShowNotification,+object:+nil)
++++++++notificationCenter.addObserver(self,+selector:+#selector(keyBoardWillHide(notification:)),+name:+UIResponder.keyboardWillHideNotification,+object:+nil)
++++}

++++deinit+{
++++++++notificationCenter.removeObserver(self)
++++}

++++@objc+func+keyBoardWillShow(notification:+Notification)+{
++++++++readyToAppear+=+true
++++}

++++@objc+func+keyBoardWillHide(notification:+Notification)+{
++++++++readyToAppear+=+false
++++}

}|code-block|syntax|javascript|2506219|然后，您可以使用该属性重新排列视图，如下所示：|2506220|++++struct+ContentView+:+View+{
++++@State+var+textfieldText:+String+=+""
++++@ObservedObject+private+var+keyboard+=+KeyboardResponder()

++++var+body:+some+View+{
++++++++return+self.buildContent()
++++}

++++func+buildContent()+->+some+View+{
++++++++let+mainStack+=+VStack+{
++++++++++++TextField("TextField1",+text:+self.$textfieldText)
++++++++++++TextField("TextField2",+text:+self.$textfieldText)
++++++++++++TextField("TextField3",+text:+self.$textfieldText)
++++++++++++TextField("TextField4",+text:+self.$textfieldText)
++++++++++++TextField("TextField5",+text:+self.$textfieldText)
++++++++++++TextField("TextField6",+text:+self.$textfieldText)
++++++++++++TextField("TextField7",+text:+self.$textfieldText)
++++++++}
++++++++return+Group{
++++++++++++if+self.keyboard.readyToAppear+{
++++++++++++++++mainStack.transformEffect(CGAffineTransform(translationX:+0,+y:+-200))
++++++++++++++++++++.animation(.spring())
++++++++++++}+else+{
++++++++++++++++mainStack
++++++++++++}
++++++++}
++++}
}|2506221|或者更简单|2506222|VStack+{
++++++++TextField("TextField1",+text:+self.$textfieldText)
++++++++TextField("TextField2",+text:+self.$textfieldText)
++++++++TextField("TextField3",+text:+self.$textfieldText)
++++++++TextField("TextField4",+text:+self.$textfieldText)
++++++++TextField("TextField5",+text:+self.$textfieldText)
++++++++TextField("TextField6",+text:+self.$textfieldText)
++++++++TextField("TextField7",+text:+self.$textfieldText)
++++}.transformEffect(keyboard.readyToAppear+?+CGAffineTransform(translationX:+0,+y:+-50)+:+.identity)
++++++++++++.animation(.spring())|2506223|entityMap^0|W|H|1E|G|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|13|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|15|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|U|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|V|$]]

I'm not sure if the transition / animation API for SwiftUI is complete, but you could use <code>CGAffineTransform</code> with <code>.transformEffect</code>

Create an observable keyboard object with a published property like this:

<pre><code> final class KeyboardResponder: ObservableObject {
 private var notificationCenter: NotificationCenter
 @Published var readyToAppear = false

 init(center: NotificationCenter = .default) {
 notificationCenter = center
 notificationCenter.addObserver(self, selector: #selector(keyBoardWillShow(notification:)), name: UIResponder.keyboardWillShowNotification, object: nil)
 notificationCenter.addObserver(self, selector: #selector(keyBoardWillHide(notification:)), name: UIResponder.keyboardWillHideNotification, object: nil)
 }

 deinit {
 notificationCenter.removeObserver(self)
 }

 @objc func keyBoardWillShow(notification: Notification) {
 readyToAppear = true
 }

 @objc func keyBoardWillHide(notification: Notification) {
 readyToAppear = false
 }

}
</code></pre>

then you could use that property to rearrange your view like this:

<pre><code> struct ContentView : View {
 @State var textfieldText: String = ""
 @ObservedObject private var keyboard = KeyboardResponder()

 var body: some View {
 return self.buildContent()
 }

 func buildContent() -&gt; some View {
 let mainStack = VStack {
 TextField("TextField1", text: self.$textfieldText)
 TextField("TextField2", text: self.$textfieldText)
 TextField("TextField3", text: self.$textfieldText)
 TextField("TextField4", text: self.$textfieldText)
 TextField("TextField5", text: self.$textfieldText)
 TextField("TextField6", text: self.$textfieldText)
 TextField("TextField7", text: self.$textfieldText)
 }
 return Group{
 if self.keyboard.readyToAppear {
 mainStack.transformEffect(CGAffineTransform(translationX: 0, y: -200))
 .animation(.spring())
 } else {
 mainStack
 }
 }
 }
}
</code></pre>

or simpler

<pre><code>VStack {
 TextField("TextField1", text: self.$textfieldText)
 TextField("TextField2", text: self.$textfieldText)
 TextField("TextField3", text: self.$textfieldText)
 TextField("TextField4", text: self.$textfieldText)
 TextField("TextField5", text: self.$textfieldText)
 TextField("TextField6", text: self.$textfieldText)
 TextField("TextField7", text: self.$textfieldText)
 }.transformEffect(keyboard.readyToAppear ? CGAffineTransform(translationX: 0, y: -50) : .identity)
 .animation(.spring())
</code></pre>

blocks|key|2506230|text|我已经创建了一个非常简单易用的视图修饰符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2506231|使用下面的代码添加一个Swift文件，并将此修饰符添加到您的视图中：|2506232|.keyboardResponsive()|code-block|syntax|javascript|2506233|import+SwiftUI

struct+KeyboardResponsiveModifier:+ViewModifier+{
++@State+private+var+offset:+CGFloat+=+0

++func+body(content:+Content)+->+some+View+{
++++content
++++++.padding(.bottom,+offset)
++++++.onAppear+{
++++++++NotificationCenter.default.addObserver(forName:+UIResponder.keyboardWillShowNotification,+object:+nil,+queue:+.main)+{+notif+in
++++++++++let+value+=+notif.userInfo![UIResponder.keyboardFrameEndUserInfoKey]+as!+CGRect
++++++++++let+height+=+value.height
++++++++++let+bottomInset+=+UIApplication.shared.windows.first?.safeAreaInsets.bottom
++++++++++self.offset+=+height+-+(bottomInset+??+0)
++++++++}

++++++++NotificationCenter.default.addObserver(forName:+UIResponder.keyboardWillHideNotification,+object:+nil,+queue:+.main)+{+notif+in
++++++++++self.offset+=+0
++++++++}
++++}
++}
}

extension+View+{
++func+keyboardResponsive()+->+ModifiedContent<Self,+KeyboardResponsiveModifier>+{
++++return+modifier(KeyboardResponsiveModifier())
++}
}|2506234|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|F|7|P|8|@]|9|@]|A|$G|H]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I have created a really simple to use view modifier.

Add a Swift file with the code below and simply add this modifier to your views:

<pre><code>.keyboardResponsive()
</code></pre>

<pre><code>import SwiftUI

struct KeyboardResponsiveModifier: ViewModifier {
 @State private var offset: CGFloat = 0

 func body(content: Content) -&gt; some View {
 content
 .padding(.bottom, offset)
 .onAppear {
 NotificationCenter.default.addObserver(forName: UIResponder.keyboardWillShowNotification, object: nil, queue: .main) { notif in
 let value = notif.userInfo![UIResponder.keyboardFrameEndUserInfoKey] as! CGRect
 let height = value.height
 let bottomInset = UIApplication.shared.windows.first?.safeAreaInsets.bottom
 self.offset = height - (bottomInset ?? 0)
 }

 NotificationCenter.default.addObserver(forName: UIResponder.keyboardWillHideNotification, object: nil, queue: .main) { notif in
 self.offset = 0
 }
 }
 }
}

extension View {
 func keyboardResponsive() -&gt; ModifiedContent&lt;Self, KeyboardResponsiveModifier&gt; {
 return modifier(KeyboardResponsiveModifier())
 }
}

</code></pre>

blocks|key|2293924|text|答案从此处复制：TextField+always+on+keyboard+top+with+SwiftUI|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2293925|我尝试过不同的方法，但没有一种对我有效。下面的这个是唯一一个可以在不同设备上工作的。|2293926|在文件中添加此扩展名：|2293927|import+SwiftUI
import+Combine

extension+View+{
++++func+keyboardSensible(_+offsetValue:+Binding<CGFloat>)+->+some+View+{
++++++++
++++++++return+self
++++++++++++.padding(.bottom,+offsetValue.wrappedValue)
++++++++++++.animation(.spring())
++++++++++++.onAppear+{
++++++++++++++++NotificationCenter.default.addObserver(forName:+UIResponder.keyboardWillShowNotification,+object:+nil,+queue:+.main)+{+notification+in
++++++++++++++++++++
++++++++++++++++++++let+keyWindow+=+UIApplication.shared.connectedScenes
++++++++++++++++++++++++.filter({$0.activationState+==+.foregroundActive})
++++++++++++++++++++++++.map({$0+as?+UIWindowScene})
++++++++++++++++++++++++.compactMap({$0})
++++++++++++++++++++++++.first?.windows
++++++++++++++++++++++++.filter({$0.isKeyWindow}).first
++++++++++++++++++++
++++++++++++++++++++let+bottom+=+keyWindow?.safeAreaInsets.bottom+??+0
++++++++++++++++++++
++++++++++++++++++++let+value+=+notification.userInfo![UIResponder.keyboardFrameEndUserInfoKey]+as!+CGRect
++++++++++++++++++++let+height+=+value.height
++++++++++++++++++++
++++++++++++++++++++offsetValue.wrappedValue+=+height+-+bottom
++++++++++++++++}
++++++++++++++++
++++++++++++++++NotificationCenter.default.addObserver(forName:+UIResponder.keyboardWillHideNotification,+object:+nil,+queue:+.main)+{+_+in
++++++++++++++++++++offsetValue.wrappedValue+=+0
++++++++++++++++}
++++++++}
++++}
}|code-block|syntax|javascript|2293928|在您的视图中，您需要一个变量来绑定offsetValue：|2293929|struct+IncomeView:+View+{

++@State+private+var+offsetValue:+CGFloat+=+0.0

++var+body:+some+View+{+
++++
++++VStack+{
+++++//...+++++++
++++}
++++.keyboardSensible($offsetValue)
++}
}|2293930|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/57497477/textfield-always-on-keyboard-top-with-swiftui/59723601#59723601^0|8|19|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|C|$]]|$1|O|3|P|5|J|7|16|8|@]|9|@]|C|$K|L]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

Answer copied from here: <a href="https://stackoverflow.com/questions/57497477/textfield-always-on-keyboard-top-with-swiftui/59723601#59723601">TextField always on keyboard top with SwiftUI</a>
I've tried different approaches, and none of them worked for me. This one below is the only one that worked for different devices.
Add this extension in a file:
<pre><code>import SwiftUI
import Combine

extension View {
 func keyboardSensible(_ offsetValue: Binding&lt;CGFloat&gt;) -&gt; some View {
 
 return self
 .padding(.bottom, offsetValue.wrappedValue)
 .animation(.spring())
 .onAppear {
 NotificationCenter.default.addObserver(forName: UIResponder.keyboardWillShowNotification, object: nil, queue: .main) { notification in
 
 let keyWindow = UIApplication.shared.connectedScenes
 .filter({$0.activationState == .foregroundActive})
 .map({$0 as? UIWindowScene})
 .compactMap({$0})
 .first?.windows
 .filter({$0.isKeyWindow}).first
 
 let bottom = keyWindow?.safeAreaInsets.bottom ?? 0
 
 let value = notification.userInfo![UIResponder.keyboardFrameEndUserInfoKey] as! CGRect
 let height = value.height
 
 offsetValue.wrappedValue = height - bottom
 }
 
 NotificationCenter.default.addObserver(forName: UIResponder.keyboardWillHideNotification, object: nil, queue: .main) { _ in
 offsetValue.wrappedValue = 0
 }
 }
 }
}
</code></pre>
In your view, you need a variable to bind offsetValue:
<pre><code>struct IncomeView: View {

 @State private var offsetValue: CGFloat = 0.0

 var body: some View { 
 
 VStack {
 //... 
 }
 .keyboardSensible($offsetValue)
 }
}
</code></pre>

blocks|key|2506555|text|处理TabView的|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2506556|我喜欢Benjamin+Kindle's+answer，但它不支持TabViews。下面是我对他处理TabViews的代码所做的调整：|2506557|2506558|向UITabView添加了一个扩展，用于在设置帧时存储tabView的大小。我们可以将其存储在静态变量中，因为在一个项目中通常只有一个tabView+(如果您的项目有多个，则需要进行调整)。|ordered-list-item|2506559|2506560|extension+UITabBar+{

++++static+var+size:+CGSize+=+.zero

++++open+override+var+frame:+CGRect+{
++++++++get+{
++++++++++++super.frame
++++++++}+set+{
++++++++++++UITabBar.size+=+newValue.size
++++++++++++super.frame+=+newValue
++++++++}
++++}
}|code-block|syntax|javascript|2506561|2506562|您需要更改他在KeyboardHost视图底部的onReceive，以适应选项卡栏的高度：|2506563|2506564|.onReceive(showPublisher.merge(with:+hidePublisher))+{+(height)+in
++++++++++++self.keyboardHeight+=+max(height+-+UITabBar.size.height,+0)
++++++++}|2506565|2506566|，就是这样！超级简单。|2506567|2506568|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/57235093/4441541^0|2|7|0|3|O|0|0|0|1|9|0|0|0|0|7|C|O|9|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1C|8|@]|D|@$9|1D|A|1E|1|1F]]|E|$]]|$1|H|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]|$1|M|3|N|5|O|7|1L|8|@]|D|@]|E|$P|Q]]|$1|R|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]|$1|S|3|T|5|K|7|1N|8|@$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1S|8|@]|D|@]|E|$]]|$1|V|3|W|5|O|7|1T|8|@]|D|@]|E|$P|Q]]|$1|X|3|-4|5|6|7|1U|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|K|7|1V|8|@]|D|@]|E|$]]|$1|10|3|-4|5|6|7|1W|8|@]|D|@]|E|$]]|$1|11|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]]|12|$13|$5|14|15|16|E|$17|18]]]]

<h2>Handling <code>TabView</code>'s</h2>

I like <a href="https://stackoverflow.com/a/57235093/4441541">Benjamin Kindle's answer</a> but it doesn't support TabViews.
Here is my adjustment to his code for handling TabViews:

<ol>
<li>Add an extension to <code>UITabView</code> to store the size of the tabView when it's frame is set. 
We can store this in a static variable because there is usually only one tabView in a project (if yours has more than one, then you'll need to adjust).</li>
</ol>

<pre><code>extension UITabBar {

 static var size: CGSize = .zero

 open override var frame: CGRect {
 get {
 super.frame
 } set {
 UITabBar.size = newValue.size
 super.frame = newValue
 }
 }
}
</code></pre>

<ol start="2">
<li>You'll need to change his <code>onReceive</code> at the bottom of the <code>KeyboardHost</code> view to account for the Tab Bar's height:</li>
</ol>

<pre><code>.onReceive(showPublisher.merge(with: hidePublisher)) { (height) in
 self.keyboardHeight = max(height - UITabBar.size.height, 0)
 }
</code></pre>

<ol start="3">
<li>And that's it! Super simple . </li>
</ol>

blocks|key|2506570|text|我尝试了许多建议的解决方案，尽管它们在大多数情况下都有效，但我遇到了一些问题-主要是安全区域(我在TabView的选项卡中有一个表单)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2506571|我最终组合了几种不同的解决方案，并使用GeometryReader来获得特定视图的安全区域底部嵌入，并在填充的计算中使用它：|2506572|import+SwiftUI
import+Combine

struct+AdaptsToKeyboard:+ViewModifier+{
++++@State+var+currentHeight:+CGFloat+=+0
++++
++++func+body(content:+Content)+->+some+View+{
++++++++GeometryReader+{+geometry+in
++++++++++++content
++++++++++++++++.padding(.bottom,+self.currentHeight)
++++++++++++++++.onAppear(perform:+{
++++++++++++++++++++NotificationCenter.Publisher(center:+NotificationCenter.default,+name:+UIResponder.keyboardWillShowNotification)
++++++++++++++++++++++++.merge(with:+NotificationCenter.Publisher(center:+NotificationCenter.default,+name:+UIResponder.keyboardWillChangeFrameNotification))
++++++++++++++++++++++++.compactMap+{+notification+in
++++++++++++++++++++++++++++withAnimation(.easeOut(duration:+0.16))+{
++++++++++++++++++++++++++++++++notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey]+as?+CGRect
++++++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++++++.map+{+rect+in
++++++++++++++++++++++++rect.height+-+geometry.safeAreaInsets.bottom
++++++++++++++++++++}
++++++++++++++++++++.subscribe(Subscribers.Assign(object:+self,+keyPath:+\.currentHeight))
++++++++++++++++++++
++++++++++++++++++++NotificationCenter.Publisher(center:+NotificationCenter.default,+name:+UIResponder.keyboardWillHideNotification)
++++++++++++++++++++++++.compactMap+{+notification+in
++++++++++++++++++++++++++++CGFloat.zero
++++++++++++++++++++}
++++++++++++++++++++.subscribe(Subscribers.Assign(object:+self,+keyPath:+\.currentHeight))
++++++++++++++++})
++++++++}
++++}
}

extension+View+{
++++func+adaptsToKeyboard()+->+some+View+{
++++++++return+modifier(AdaptsToKeyboard())
++++}
}|code-block|syntax|javascript|2506573|用法：|2506574|struct+MyView:+View+{
++++var+body:+some+View+{
++++++++Form+{...}
++++++++.adaptsToKeyboard()
++++}
}|2506575|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|$]]

I tried many of the proposed solutions, and even though they work in most cases, I had some issues - mainly with safe area (I have a Form inside TabView's tab).
I ended up combining few different solutions, and using GeometryReader in order to get specific view's safe area bottom inset and use it in padding's calculation:
<pre><code>import SwiftUI
import Combine

struct AdaptsToKeyboard: ViewModifier {
 @State var currentHeight: CGFloat = 0
 
 func body(content: Content) -&gt; some View {
 GeometryReader { geometry in
 content
 .padding(.bottom, self.currentHeight)
 .onAppear(perform: {
 NotificationCenter.Publisher(center: NotificationCenter.default, name: UIResponder.keyboardWillShowNotification)
 .merge(with: NotificationCenter.Publisher(center: NotificationCenter.default, name: UIResponder.keyboardWillChangeFrameNotification))
 .compactMap { notification in
 withAnimation(.easeOut(duration: 0.16)) {
 notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect
 }
 }
 .map { rect in
 rect.height - geometry.safeAreaInsets.bottom
 }
 .subscribe(Subscribers.Assign(object: self, keyPath: \.currentHeight))
 
 NotificationCenter.Publisher(center: NotificationCenter.default, name: UIResponder.keyboardWillHideNotification)
 .compactMap { notification in
 CGFloat.zero
 }
 .subscribe(Subscribers.Assign(object: self, keyPath: \.currentHeight))
 })
 }
 }
}

extension View {
 func adaptsToKeyboard() -&gt; some View {
 return modifier(AdaptsToKeyboard())
 }
}
</code></pre>
Usage:
<pre><code>struct MyView: View {
 var body: some View {
 Form {...}
 .adaptsToKeyboard()
 }
}
</code></pre>

blocks|key|2294187|text|或者，您可以只使用IQKeyBoardManagerSwift|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2294188|并且可以有选择地将其添加到您的应用程序代理中，以隐藏工具栏，并在单击键盘以外的任何视图时隐藏键盘。|2294189|IQKeyboardManager.shared.enableAutoToolbar+=+false
IQKeyboardManager.shared.shouldShowToolbarPlaceholder+=+false
IQKeyboardManager.shared.shouldResignOnTouchOutside+=+true
IQKeyboardManager.shared.previousNextDisplayMode+=+.alwaysHide|code-block|syntax|javascript|2294190|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/hackiftekhar/IQKeyboardManager^0|9|M|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Or
You can just use <a href="https://github.com/hackiftekhar/IQKeyboardManager" rel="nofollow noreferrer">IQKeyBoardManagerSwift</a>
and can optionally add this to your app delegate to hide the toolbar and enable hiding of keyboard on click on any view other then keyboard.
<pre><code>IQKeyboardManager.shared.enableAutoToolbar = false
IQKeyboardManager.shared.shouldShowToolbarPlaceholder = false
IQKeyboardManager.shared.shouldResignOnTouchOutside = true
IQKeyboardManager.shared.previousNextDisplayMode = .alwaysHide
</code></pre>

blocks|key|2506618|text|我采用了一种完全不同的方法，通过扩展UIHostingController并调整其additionalSafeAreaInsets|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2506619|class+MyHostingController<Content:+View>:+UIHostingController<Content>+{
++++override+init(rootView:+Content)+{
++++++++super.init(rootView:+rootView)
++++}

++++@objc+required+dynamic+init?(coder+aDecoder:+NSCoder)+{
++++++++fatalError("init(coder:)+has+not+been+implemented")
++++}

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

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

++++@objc+func+keyboardDidShow(_+notification:+Notification)+{
++++++++guard+let+info:[AnyHashable:+Any]+=+notification.userInfo,
++++++++++++let+frame+=+info[UIResponder.keyboardFrameEndUserInfoKey]+as?+CGRect+else+{
++++++++++++++++return
++++++++}

++++++++//+set+the+additionalSafeAreaInsets
++++++++let+adjustHeight+=+frame.height+-+(self.view.safeAreaInsets.bottom+-+self.additionalSafeAreaInsets.bottom)
++++++++self.additionalSafeAreaInsets+=+UIEdgeInsets(top:+0,+left:+0,+bottom:+adjustHeight,+right:+0)

++++++++//+now+try+to+find+a+UIResponder+inside+a+ScrollView,+and+scroll
++++++++//+the+firstResponder+into+view
++++++++DispatchQueue.main.asyncAfter(deadline:+DispatchTime.now()+%2B+0.1)+{+
++++++++++++if+let+firstResponder+=+UIResponder.findFirstResponder()+as?+UIView,
++++++++++++++++let+scrollView+=+firstResponder.parentScrollView()+{
++++++++++++++++//+translate+the+firstResponder's+frame+into+the+scrollView's+coordinate+system,
++++++++++++++++//+with+a+little+vertical+padding
++++++++++++++++let+rect+=+firstResponder.convert(firstResponder.frame,+to:+scrollView)
++++++++++++++++++++.insetBy(dx:+0,+dy:+-15)
++++++++++++++++scrollView.scrollRectToVisible(rect,+animated:+true)
++++++++++++}
++++++++}
++++}

++++@objc+func+keyboardWillHide()+{
++++++++self.additionalSafeAreaInsets+=+UIEdgeInsets(top:+0,+left:+0,+bottom:+0,+right:+0)
++++}
}

///+IUResponder+extension+for+finding+the+current+first+responder
extension+UIResponder+{
++++private+struct+StaticFirstResponder+{
++++++++static+weak+var+firstResponder:+UIResponder?
++++}

++++///+find+the+current+first+responder,+or+nil
++++static+func+findFirstResponder()+->+UIResponder?+{
++++++++StaticFirstResponder.firstResponder+=+nil
++++++++UIApplication.shared.sendAction(
++++++++++++#selector(UIResponder.trap),
++++++++++++to:+nil,+from:+nil,+for:+nil)
++++++++return+StaticFirstResponder.firstResponder
++++}

++++@objc+private+func+trap()+{
++++++++StaticFirstResponder.firstResponder+=+self
++++}
}

///+UIView+extension+for+finding+the+receiver's+parent+UIScrollView
extension+UIView+{
++++func+parentScrollView()+->+UIScrollView?+{
++++++++if+let+scrollView+=+self.superview+as?+UIScrollView+{
++++++++++++return+scrollView
++++++++}

++++++++return+superview?.parentScrollView()
++++}
}|code-block|syntax|javascript|2506620|然后将SceneDelegate更改为使用MyHostingController而不是UIHostingController。|2506621|完成后，我就不需要担心SwiftUI代码中的键盘了。|2506622|(注意:我还没有充分利用这一点，还不能完全理解这样做的任何影响！)|2506623|entityMap^0|I|J|15|O|0|0|3|D|L|J|17|J|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|15|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|16|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|R|$]]

I took a totally different approach, by extending <code>UIHostingController</code> and adjusting its <code>additionalSafeAreaInsets</code>:

<pre><code>class MyHostingController&lt;Content: View&gt;: UIHostingController&lt;Content&gt; {
 override init(rootView: Content) {
 super.init(rootView: rootView)
 }

 @objc required dynamic init?(coder aDecoder: NSCoder) {
 fatalError("init(coder:) has not been implemented")
 }

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

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

 @objc func keyboardDidShow(_ notification: Notification) {
 guard let info:[AnyHashable: Any] = notification.userInfo,
 let frame = info[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect else {
 return
 }

 // set the additionalSafeAreaInsets
 let adjustHeight = frame.height - (self.view.safeAreaInsets.bottom - self.additionalSafeAreaInsets.bottom)
 self.additionalSafeAreaInsets = UIEdgeInsets(top: 0, left: 0, bottom: adjustHeight, right: 0)

 // now try to find a UIResponder inside a ScrollView, and scroll
 // the firstResponder into view
 DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 0.1) { 
 if let firstResponder = UIResponder.findFirstResponder() as? UIView,
 let scrollView = firstResponder.parentScrollView() {
 // translate the firstResponder's frame into the scrollView's coordinate system,
 // with a little vertical padding
 let rect = firstResponder.convert(firstResponder.frame, to: scrollView)
 .insetBy(dx: 0, dy: -15)
 scrollView.scrollRectToVisible(rect, animated: true)
 }
 }
 }

 @objc func keyboardWillHide() {
 self.additionalSafeAreaInsets = UIEdgeInsets(top: 0, left: 0, bottom: 0, right: 0)
 }
}

/// IUResponder extension for finding the current first responder
extension UIResponder {
 private struct StaticFirstResponder {
 static weak var firstResponder: UIResponder?
 }

 /// find the current first responder, or nil
 static func findFirstResponder() -&gt; UIResponder? {
 StaticFirstResponder.firstResponder = nil
 UIApplication.shared.sendAction(
 #selector(UIResponder.trap),
 to: nil, from: nil, for: nil)
 return StaticFirstResponder.firstResponder
 }

 @objc private func trap() {
 StaticFirstResponder.firstResponder = self
 }
}

/// UIView extension for finding the receiver's parent UIScrollView
extension UIView {
 func parentScrollView() -&gt; UIScrollView? {
 if let scrollView = self.superview as? UIScrollView {
 return scrollView
 }

 return superview?.parentScrollView()
 }
}
</code></pre>

Then change <code>SceneDelegate</code> to use <code>MyHostingController</code> instead of <code>UIHostingController</code>.

When that's done, I don't need to worry about the keyboard inside my SwiftUI code.

(Note: I haven't used this enough, yet, to fully understand any implications of doing this!)

blocks|key|2294247|text|上面的一些解决方案有一些问题，并不一定是“最干净”的方法。正因为如此，我为下面的实现修改了一些东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2294248|extension+View+{
++++func+onKeyboard(_+keyboardYOffset:+Binding<CGFloat>)+->+some+View+{
++++++++return+ModifiedContent(content:+self,+modifier:+KeyboardModifier(keyboardYOffset))
++++}
}

struct+KeyboardModifier:+ViewModifier+{
++++@Binding+var+keyboardYOffset:+CGFloat
++++let+keyboardWillAppearPublisher+=+NotificationCenter.default.publisher(for:+UIResponder.keyboardWillShowNotification)
++++let+keyboardWillHidePublisher+=+NotificationCenter.default.publisher(for:+UIResponder.keyboardWillHideNotification)

++++init(_+offset:+Binding<CGFloat>)+{
++++++++_keyboardYOffset+=+offset
++++}

++++func+body(content:+Content)+->+some+View+{
++++++++return+content.offset(x:+0,+y:+-$keyboardYOffset.wrappedValue)
++++++++++++.animation(.easeInOut(duration:+0.33))
++++++++++++.onReceive(keyboardWillAppearPublisher)+{+notification+in
++++++++++++++++let+keyWindow+=+UIApplication.shared.connectedScenes
++++++++++++++++++++.filter+{+$0.activationState+==+.foregroundActive+}
++++++++++++++++++++.map+{+$0+as?+UIWindowScene+}
++++++++++++++++++++.compactMap+{+$0+}
++++++++++++++++++++.first?.windows
++++++++++++++++++++.filter+{+$0.isKeyWindow+}
++++++++++++++++++++.first

++++++++++++++++let+yOffset+=+keyWindow?.safeAreaInsets.bottom+??+0

++++++++++++++++let+keyboardFrame+=+(notification.userInfo![UIResponder.keyboardFrameEndUserInfoKey]+as?+NSValue)?.cgRectValue+??+.zero

++++++++++++++++self.$keyboardYOffset.wrappedValue+=+keyboardFrame.height+-+yOffset
++++++++}.onReceive(keyboardWillHidePublisher)+{+_+in
++++++++++++self.$keyboardYOffset.wrappedValue+=+0
++++++++}
++++}
}|code-block|syntax|javascript|2294249|struct+RegisterView:+View+{
++++@State+var+name+=+""
++++@State+var+keyboardYOffset:+CGFloat+=+0

++++var+body:+some+View+{

++++++++VStack+{
++++++++++++WelcomeMessageView()
++++++++++++TextField("Type+your+name...",+text:+$name).bordered()
++++++++}.onKeyboard($keyboardYOffset)
++++++++++++.background(WelcomeBackgroundImage())
++++++++++++.padding()
++++}
}|2294250|我想要一种更干净的方法，并在如何偏移内容时将责任转移到构造的视图(而不是修饰符)，但似乎我无法让发布者在将偏移代码移动到视图时正确触发……|2294251|还要注意，在这种情况下必须使用Publisher，因为final+class目前会导致未知的异常崩溃(即使它满足接口要求)，并且在应用偏移代码时，ScrollView是最好的方法。|offset|length|style|CODE|2294252|entityMap^0|0|0|0|0|R|B|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

A few of the solutions above had some issues and weren't necessarily the "cleanest" approach. Because of this, I've modified a few things for the implementation below.

<pre><code>extension View {
 func onKeyboard(_ keyboardYOffset: Binding&lt;CGFloat&gt;) -&gt; some View {
 return ModifiedContent(content: self, modifier: KeyboardModifier(keyboardYOffset))
 }
}

struct KeyboardModifier: ViewModifier {
 @Binding var keyboardYOffset: CGFloat
 let keyboardWillAppearPublisher = NotificationCenter.default.publisher(for: UIResponder.keyboardWillShowNotification)
 let keyboardWillHidePublisher = NotificationCenter.default.publisher(for: UIResponder.keyboardWillHideNotification)

 init(_ offset: Binding&lt;CGFloat&gt;) {
 _keyboardYOffset = offset
 }

 func body(content: Content) -&gt; some View {
 return content.offset(x: 0, y: -$keyboardYOffset.wrappedValue)
 .animation(.easeInOut(duration: 0.33))
 .onReceive(keyboardWillAppearPublisher) { notification in
 let keyWindow = UIApplication.shared.connectedScenes
 .filter { $0.activationState == .foregroundActive }
 .map { $0 as? UIWindowScene }
 .compactMap { $0 }
 .first?.windows
 .filter { $0.isKeyWindow }
 .first

 let yOffset = keyWindow?.safeAreaInsets.bottom ?? 0

 let keyboardFrame = (notification.userInfo![UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue ?? .zero

 self.$keyboardYOffset.wrappedValue = keyboardFrame.height - yOffset
 }.onReceive(keyboardWillHidePublisher) { _ in
 self.$keyboardYOffset.wrappedValue = 0
 }
 }
}
</code></pre>

<pre><code>struct RegisterView: View {
 @State var name = ""
 @State var keyboardYOffset: CGFloat = 0

 var body: some View {

 VStack {
 WelcomeMessageView()
 TextField("Type your name...", text: $name).bordered()
 }.onKeyboard($keyboardYOffset)
 .background(WelcomeBackgroundImage())
 .padding()
 }
}
</code></pre>

I would have liked a cleaner approach and to move responsibility to the constructed view (not the modifier) in how to offset the content, but it would seem I couldn't get the publishers to properly trigger when moving the offset code to the view....

Also note that Publishers had to be used in this instance as <code>final class</code> currently causes unknown exception crashes (even though it meets interface requirements) and a ScrollView overall is the best approach when applying offset code.

blocks|key|2506653|text|这就是我在SwiftUI中处理键盘的方式。要记住的是，它是在它所附加的VStack上进行计算的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2506654|您可以在视图上将其用作修改器。这样：|2506655|struct+LogInView:+View+{

++var+body:+some+View+{
++++VStack+{
++++++//+Your+View
++++}
++++.modifier(KeyboardModifier())
++}
}|code-block|syntax|javascript|2506656|因此，要得到这个修饰符，首先，创建一个UIResponder的扩展，以获取VStack中选定的TextField位置：|2506657|import+UIKit

//+MARK:+Retrieve+TextField+first+responder+for+keyboard
extension+UIResponder+{

++private+static+weak+var+currentResponder:+UIResponder?

++static+var+currentFirstResponder:+UIResponder?+{
++++currentResponder+=+nil
++++UIApplication.shared.sendAction(#selector(UIResponder.findFirstResponder),
++++++++++++++++++++++++++++++++++++to:+nil,+from:+nil,+for:+nil)
++++return+currentResponder
++}

++@objc+private+func+findFirstResponder(_+sender:+Any)+{
++++UIResponder.currentResponder+=+self
++}

++//+Frame+of+the+superview
++var+globalFrame:+CGRect?+{
++++guard+let+view+=+self+as?+UIView+else+{+return+nil+}
++++return+view.superview?.convert(view.frame,+to:+nil)
++}
}|2506658|现在，您可以使用Combine创建KeyboardModifier，以避免键盘隐藏TextField：|2506659|import+SwiftUI
import+Combine

//+MARK:+Keyboard+show/hide+VStack+offset+modifier
struct+KeyboardModifier:+ViewModifier+{

++@State+var+offset:+CGFloat+=+.zero
++@State+var+subscription+=+Set<AnyCancellable>()

++func+body(content:+Content)+->+some+View+{
++++GeometryReader+{+geometry+in
++++++content
++++++++.padding(.bottom,+self.offset)
++++++++.animation(.spring(response:+0.4,+dampingFraction:+0.5,+blendDuration:+1))
++++++++.onAppear+{

++++++++++NotificationCenter.default.publisher(for:+UIResponder.keyboardWillHideNotification)
++++++++++++.handleEvents(receiveOutput:+{+_+in+self.offset+=+0+})
++++++++++++.sink+{+_+in+}
++++++++++++.store(in:+&self.subscription)

++++++++++NotificationCenter.default.publisher(for:+UIResponder.keyboardWillChangeFrameNotification)
++++++++++++.map(\.userInfo)
++++++++++++.compactMap+{+($0?[UIResponder.keyboardFrameEndUserInfoKey]+as?+CGRect)?.size.height+}
++++++++++++.sink(receiveValue:+{+keyboardHeight+in
++++++++++++++let+keyboardTop+=+geometry.frame(in:+.global).height+-+keyboardHeight
++++++++++++++let+textFieldBottom+=+UIResponder.currentFirstResponder?.globalFrame?.maxY+??+0
++++++++++++++self.offset+=+max(0,+textFieldBottom+-+keyboardTop+*+2+-+geometry.safeAreaInsets.bottom)+})
++++++++.store(in:+&self.subscription)+}
++++++++.onDisappear+{
++++++++++//+Dismiss+keyboard
++++++++++UIApplication.shared.windows
++++++++++++.first+{+$0.isKeyWindow+}?
++++++++++++.endEditing(true)

++++++++++self.subscription.removeAll()+}
++++}
++}
}|2506660|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|$]]

This is the way I handle the keyboard in SwiftUI. The thing to remember is that it is making the calculations on the VStack to which it is attached. 

You use it on a View as a Modifier. This way: 

<pre><code>struct LogInView: View {

 var body: some View {
 VStack {
 // Your View
 }
 .modifier(KeyboardModifier())
 }
}
</code></pre>

So to come to this modifier, first, create an extension of UIResponder to get the selected TextField position in the VStack:

<pre><code>import UIKit

// MARK: Retrieve TextField first responder for keyboard
extension UIResponder {

 private static weak var currentResponder: UIResponder?

 static var currentFirstResponder: UIResponder? {
 currentResponder = nil
 UIApplication.shared.sendAction(#selector(UIResponder.findFirstResponder),
 to: nil, from: nil, for: nil)
 return currentResponder
 }

 @objc private func findFirstResponder(_ sender: Any) {
 UIResponder.currentResponder = self
 }

 // Frame of the superview
 var globalFrame: CGRect? {
 guard let view = self as? UIView else { return nil }
 return view.superview?.convert(view.frame, to: nil)
 }
}
</code></pre>

You can now create the KeyboardModifier using Combine to avoid a keyboard hiding a TextField:

<pre><code>import SwiftUI
import Combine

// MARK: Keyboard show/hide VStack offset modifier
struct KeyboardModifier: ViewModifier {

 @State var offset: CGFloat = .zero
 @State var subscription = Set&lt;AnyCancellable&gt;()

 func body(content: Content) -&gt; some View {
 GeometryReader { geometry in
 content
 .padding(.bottom, self.offset)
 .animation(.spring(response: 0.4, dampingFraction: 0.5, blendDuration: 1))
 .onAppear {

 NotificationCenter.default.publisher(for: UIResponder.keyboardWillHideNotification)
 .handleEvents(receiveOutput: { _ in self.offset = 0 })
 .sink { _ in }
 .store(in: &amp;self.subscription)

 NotificationCenter.default.publisher(for: UIResponder.keyboardWillChangeFrameNotification)
 .map(\.userInfo)
 .compactMap { ($0?[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect)?.size.height }
 .sink(receiveValue: { keyboardHeight in
 let keyboardTop = geometry.frame(in: .global).height - keyboardHeight
 let textFieldBottom = UIResponder.currentFirstResponder?.globalFrame?.maxY ?? 0
 self.offset = max(0, textFieldBottom - keyboardTop * 2 - geometry.safeAreaInsets.bottom) })
 .store(in: &amp;self.subscription) }
 .onDisappear {
 // Dismiss keyboard
 UIApplication.shared.windows
 .first { $0.isKeyWindow }?
 .endEditing(true)

 self.subscription.removeAll() }
 }
 }
}
</code></pre>

blocks|key|2294289|text|老实说，这些答案中的很多似乎真的很夸张。如果你使用的是SwiftUI，那么你也可以使用Combine。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2294290|如下所示创建一个KeyboardResponder，然后您就可以像前面演示的那样使用了。|offset|length|style|CODE|2294291|针对iOS+14进行了更新。|2294292|import+Combine
import+UIKit

final+class+KeyboardResponder:+ObservableObject+{

++++@Published+var+keyboardHeight:+CGFloat+=+0

++++init()+{
++++++++NotificationCenter.default.publisher(for:+UIResponder.keyboardWillChangeFrameNotification)
++++++++++++.compactMap+{+notification+in
++++++++++++++++(notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey]+as?+NSValue)?.cgRectValue.height
++++++++++++}
++++++++++++.receive(on:+DispatchQueue.main)
++++++++++++.assign(to:+\.keyboardHeight)
++++}
}


struct+ExampleView:+View+{
++++@ObservedObject+private+var+keyboardResponder+=+KeyboardResponder()
++++@State+private+var+text:+String+=+""

++++var+body:+some+View+{
++++++++VStack+{
++++++++++++Text(text)
++++++++++++Spacer()
++++++++++++TextField("Example",+text:+$text)
++++++++}
++++++++.padding(.bottom,+keyboardResponder.keyboardHeight)
++++}
}|code-block|syntax|javascript|2294293|entityMap^0|0|8|H|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|U|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|V|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

A lot of these answer's just seem really bloated to be honest. If you are using SwiftUI then you may as well make use of Combine as well.
Create a <code>KeyboardResponder</code> as shown below, then you can use as previously demonstrated.
Updated for iOS 14.
<pre><code>import Combine
import UIKit

final class KeyboardResponder: ObservableObject {

 @Published var keyboardHeight: CGFloat = 0

 init() {
 NotificationCenter.default.publisher(for: UIResponder.keyboardWillChangeFrameNotification)
 .compactMap { notification in
 (notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue)?.cgRectValue.height
 }
 .receive(on: DispatchQueue.main)
 .assign(to: \.keyboardHeight)
 }
}


struct ExampleView: View {
 @ObservedObject private var keyboardResponder = KeyboardResponder()
 @State private var text: String = &quot;&quot;

 var body: some View {
 VStack {
 Text(text)
 Spacer()
 TextField(&quot;Example&quot;, text: $text)
 }
 .padding(.bottom, keyboardResponder.keyboardHeight)
 }
}
</code></pre>

blocks|key|2506790|text|我检查了现有的解决方案，并将其重构为一个方便的SPM包，该包提供了一个.keyboardAware()修饰符：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2506791|KeyboardAwareSwiftUI|2506792|​|2506793|📷|atomic|2506794|2506795|示例：|2506796|struct+KeyboardAwareView:+View+{
++++@State+var+text+=+"example"

++++var+body:+some+View+{
++++++++NavigationView+{
++++++++++++ScrollView+{
++++++++++++++++VStack(alignment:+.leading)+{
++++++++++++++++++++ForEach(0+..<+20)+{+i+in
++++++++++++++++++++++++Text("Text+\(i):")
++++++++++++++++++++++++TextField("Text",+text:+self.$text)
++++++++++++++++++++++++++++.textFieldStyle(RoundedBorderTextFieldStyle())
++++++++++++++++++++++++++++.padding(.bottom,+10)
++++++++++++++++++++}
++++++++++++++++}
++++++++++++++++.padding()
++++++++++++}
++++++++++++.keyboardAware()++//+<---+the+view+modifier
++++++++++++.navigationBarTitle("Keyboard+Example")
++++++++}

++++}
}|code-block|syntax|javascript|2506797|来源：|2506798|import+UIKit
import+SwiftUI

public+class+KeyboardInfo:+ObservableObject+{

++++public+static+var+shared+=+KeyboardInfo()

++++@Published+public+var+height:+CGFloat+=+0

++++private+init()+{
++++++++NotificationCenter.default.addObserver(self,+selector:+#selector(self.keyboardChanged),+name:+UIApplication.keyboardWillShowNotification,+object:+nil)
++++++++NotificationCenter.default.addObserver(self,+selector:+#selector(self.keyboardChanged),+name:+UIResponder.keyboardWillHideNotification,+object:+nil)
++++++++NotificationCenter.default.addObserver(self,+selector:+#selector(self.keyboardChanged),+name:+UIResponder.keyboardWillChangeFrameNotification,+object:+nil)
++++}

++++@objc+func+keyboardChanged(notification:+Notification)+{
++++++++if+notification.name+==+UIApplication.keyboardWillHideNotification+{
++++++++++++self.height+=+0
++++++++}+else+{
++++++++++++self.height+=+(notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey]+as?+CGRect)?.height+??+0
++++++++}
++++}

}

struct+KeyboardAware:+ViewModifier+{
++++@ObservedObject+private+var+keyboard+=+KeyboardInfo.shared

++++func+body(content:+Content)+->+some+View+{
++++++++content
++++++++++++.padding(.bottom,+self.keyboard.height)
++++++++++++.edgesIgnoringSafeArea(self.keyboard.height+>+0+?+.bottom+:+[])
++++++++++++.animation(.easeOut)
++++}
}

extension+View+{
++++public+func+keyboardAware()+->+some+View+{
++++++++ModifiedContent(content:+self,+modifier:+KeyboardAware())
++++}
}|2506799|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/ralfebert/KeyboardAwareSwiftUI|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/43034916b19070cac09beeb7e7cc25b4.png|imageAlt^0|Z|G|0|0|K|0|0|0|0|1|1|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1F|8|@]|D|@$9|1G|A|1H|1|1I]]|E|$]]|$1|H|3|I|5|6|7|1J|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1K|8|@]|D|@$9|1L|A|1M|1|1N]]|E|$]]|$1|M|3|I|5|6|7|1O|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1P|8|@]|D|@]|E|$]]|$1|P|3|Q|5|R|7|1Q|8|@]|D|@]|E|$S|T]]|$1|U|3|V|5|6|7|1R|8|@]|D|@]|E|$]]|$1|W|3|X|5|R|7|1S|8|@]|D|@]|E|$S|T]]|$1|Y|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]]|Z|$10|$5|11|12|13|E|$14|15]]|16|$5|17|12|18|E|$19|1A|1B|-4]]]]

I reviewed and refactored the existing solutions into a handy SPM package that provides a <code>.keyboardAware()</code> modifier:

<a href="https://github.com/ralfebert/KeyboardAwareSwiftUI" rel="noreferrer">KeyboardAwareSwiftUI</a>

<img src="https://i.stack.imgur.com/XMBhl.png" width="200"/>

Example:

<pre class="lang-swift prettyprint-override"><code>struct KeyboardAwareView: View {
 @State var text = "example"

 var body: some View {
 NavigationView {
 ScrollView {
 VStack(alignment: .leading) {
 ForEach(0 ..&lt; 20) { i in
 Text("Text \(i):")
 TextField("Text", text: self.$text)
 .textFieldStyle(RoundedBorderTextFieldStyle())
 .padding(.bottom, 10)
 }
 }
 .padding()
 }
 .keyboardAware() // &lt;--- the view modifier
 .navigationBarTitle("Keyboard Example")
 }

 }
}
</code></pre>

Source:

<pre class="lang-swift prettyprint-override"><code>import UIKit
import SwiftUI

public class KeyboardInfo: ObservableObject {

 public static var shared = KeyboardInfo()

 @Published public var height: CGFloat = 0

 private init() {
 NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardChanged), name: UIApplication.keyboardWillShowNotification, object: nil)
 NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardChanged), name: UIResponder.keyboardWillHideNotification, object: nil)
 NotificationCenter.default.addObserver(self, selector: #selector(self.keyboardChanged), name: UIResponder.keyboardWillChangeFrameNotification, object: nil)
 }

 @objc func keyboardChanged(notification: Notification) {
 if notification.name == UIApplication.keyboardWillHideNotification {
 self.height = 0
 } else {
 self.height = (notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect)?.height ?? 0
 }
 }

}

struct KeyboardAware: ViewModifier {
 @ObservedObject private var keyboard = KeyboardInfo.shared

 func body(content: Content) -&gt; some View {
 content
 .padding(.bottom, self.keyboard.height)
 .edgesIgnoringSafeArea(self.keyboard.height &gt; 0 ? .bottom : [])
 .animation(.easeOut)
 }
}

extension View {
 public func keyboardAware() -&gt; some View {
 ModifiedContent(content: self, modifier: KeyboardAware())
 }
}
</code></pre>

blocks|key|2506825|text|用法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2506826|import+SwiftUI

var+body:+some+View+{
++++ScrollView+{
++++++++VStack+{
++++++++++/*
++++++++++TextField()
++++++++++*/
++++++++}
++++}.keyboardSpace()
}|code-block|syntax|javascript|2506827|代码：|2506828|import+SwiftUI
import+Combine

let+keyboardSpaceD+=+KeyboardSpace()
extension+View+{
++++func+keyboardSpace()+->+some+View+{
++++++++modifier(KeyboardSpace.Space(data:+keyboardSpaceD))
++++}
}

class+KeyboardSpace:+ObservableObject+{
++++var+sub:+AnyCancellable?
++++
++++@Published+var+currentHeight:+CGFloat+=+0
++++var+heightIn:+CGFloat+=+0+{
++++++++didSet+{
++++++++++++withAnimation+{
++++++++++++++++if+UIWindow.keyWindow+!=+nil+{
++++++++++++++++++++//fix+notification+when+switching+from+another+app+with+keyboard
++++++++++++++++++++self.currentHeight+=+heightIn
++++++++++++++++}
++++++++++++}
++++++++}
++++}
++++
++++init()+{
++++++++subscribeToKeyboardEvents()
++++}
++++
++++private+let+keyboardWillOpen+=+NotificationCenter.default
++++++++.publisher(for:+UIResponder.keyboardWillShowNotification)
++++++++.map+{+$0.userInfo![UIResponder.keyboardFrameEndUserInfoKey]+as!+CGRect+}
++++++++.map+{+$0.height+-+(UIWindow.keyWindow?.safeAreaInsets.bottom+??+0)+}
++++
++++private+let+keyboardWillHide+=++NotificationCenter.default
++++++++.publisher(for:+UIResponder.keyboardWillHideNotification)
++++++++.map+{+_+in+CGFloat.zero+}
++++
++++private+func+subscribeToKeyboardEvents()+{
++++++++sub?.cancel()
++++++++sub+=+Publishers.Merge(keyboardWillOpen,+keyboardWillHide)
++++++++++++.subscribe(on:+RunLoop.main)
++++++++++++.assign(to:+\.self.heightIn,+on:+self)
++++}
++++
++++deinit+{
++++++++sub?.cancel()
++++}
++++
++++struct+Space:+ViewModifier+{
++++++++@ObservedObject+var+data:+KeyboardSpace
++++++++
++++++++func+body(content:+Content)+->+some+View+{
++++++++++++VStack(spacing:+0)+{
++++++++++++++++content
++++++++++++++++
++++++++++++++++Rectangle()
++++++++++++++++++++.foregroundColor(Color(.clear))
++++++++++++++++++++.frame(height:+data.currentHeight)
++++++++++++++++++++.frame(maxWidth:+.greatestFiniteMagnitude)

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

extension+UIWindow+{
++++static+var+keyWindow:+UIWindow?+{
++++++++let+keyWindow+=+UIApplication.shared.connectedScenes
++++++++++++.filter({$0.activationState+==+.foregroundActive})
++++++++++++.map({$0+as?+UIWindowScene})
++++++++++++.compactMap({$0})
++++++++++++.first?.windows
++++++++++++.filter({$0.isKeyWindow}).first
++++++++return+keyWindow
++++}
}|2506829|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|$]]

Usage:
<pre><code>import SwiftUI

var body: some View {
 ScrollView {
 VStack {
 /*
 TextField()
 */
 }
 }.keyboardSpace()
}
</code></pre>
Code:
<pre><code>import SwiftUI
import Combine

let keyboardSpaceD = KeyboardSpace()
extension View {
 func keyboardSpace() -&gt; some View {
 modifier(KeyboardSpace.Space(data: keyboardSpaceD))
 }
}

class KeyboardSpace: ObservableObject {
 var sub: AnyCancellable?
 
 @Published var currentHeight: CGFloat = 0
 var heightIn: CGFloat = 0 {
 didSet {
 withAnimation {
 if UIWindow.keyWindow != nil {
 //fix notification when switching from another app with keyboard
 self.currentHeight = heightIn
 }
 }
 }
 }
 
 init() {
 subscribeToKeyboardEvents()
 }
 
 private let keyboardWillOpen = NotificationCenter.default
 .publisher(for: UIResponder.keyboardWillShowNotification)
 .map { $0.userInfo![UIResponder.keyboardFrameEndUserInfoKey] as! CGRect }
 .map { $0.height - (UIWindow.keyWindow?.safeAreaInsets.bottom ?? 0) }
 
 private let keyboardWillHide = NotificationCenter.default
 .publisher(for: UIResponder.keyboardWillHideNotification)
 .map { _ in CGFloat.zero }
 
 private func subscribeToKeyboardEvents() {
 sub?.cancel()
 sub = Publishers.Merge(keyboardWillOpen, keyboardWillHide)
 .subscribe(on: RunLoop.main)
 .assign(to: \.self.heightIn, on: self)
 }
 
 deinit {
 sub?.cancel()
 }
 
 struct Space: ViewModifier {
 @ObservedObject var data: KeyboardSpace
 
 func body(content: Content) -&gt; some View {
 VStack(spacing: 0) {
 content
 
 Rectangle()
 .foregroundColor(Color(.clear))
 .frame(height: data.currentHeight)
 .frame(maxWidth: .greatestFiniteMagnitude)

 }
 }
 }
}

extension UIWindow {
 static var keyWindow: UIWindow? {
 let keyWindow = UIApplication.shared.connectedScenes
 .filter({$0.activationState == .foregroundActive})
 .map({$0 as? UIWindowScene})
 .compactMap({$0})
 .first?.windows
 .filter({$0.isKeyWindow}).first
 return keyWindow
 }
}
</code></pre>

blocks|key|2506845|text|至于iOS+14+(测试版4)，它的工作原理非常简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2506846|var+body:+some+View+{
++++VStack+{
++++++++TextField(...)
++++}
++++.padding(.bottom,+0)
}|code-block|syntax|javascript|2506847|并且视图的大小调整到键盘的顶部。当然，使用frame(.maxHeight：...)可以进行更多的改进等等。你会弄清楚的。|2506848|不幸的是，iPad上的浮动键盘在移动时仍然会产生问题。但是上面提到的解决方案也会，它仍然是测试版，我希望他们能弄清楚。|2506849|Thx+Apple，终于！|2506850|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

As for iOS 14 (beta 4) it works quite simple:
<pre><code>var body: some View {
 VStack {
 TextField(...)
 }
 .padding(.bottom, 0)
}
</code></pre>
And the size of the view adjusts to the top of the keyboard.
There are certainly more refinements possible with
frame(.maxHeight: ...) etc.
You will figure it out.
Unfortunately the floating keyboard on iPad still causes problems when moved.
But the above mentioned solutions would too,
and it's still beta, I hope they will figure it out.
Thx Apple, finally!

blocks|key|2294585|text|Xcode12beta4添加了一个新的视图修饰符ignoresSafeArea，您现在可以使用它来避免使用键盘。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2294586|.ignoresSafeArea([],+edges:+[])|2294587|这样可以避免键盘和所有安全区域边缘。如果不想避免，可以将第一个参数设置为.keyboard。它有一些怪癖，至少在我的视图层次结构设置中是这样，但这似乎是苹果希望我们避免使用键盘的方式。|2294588|entityMap^0|O|F|0|0|V|0|10|9|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|K|$]]

Xcode 12 beta 4 adds a new view modifier <code>ignoresSafeArea</code> that you can now use to avoid the keyboard.
<code>.ignoresSafeArea([], edges: [])</code>
This avoids the keyboard and all safe area edges. You can set the first parameter to <code>.keyboard</code> if you don’t want it avoided. There are some quirks to it, at least in my view hierarchy setup, but it does seem that this is the way Apple wants us to avoid the keyboard.

blocks|key|2294901|text|正如Mark+Krenek和Heiko所指出的，苹果似乎终于在Xcode12beta4中解决了这个问题。根据2020年8月18日发布的Xcode12和beta+5的发布说明，"Form，List，+TextEditor不再隐藏键盘后面的内容。(66172025)“。我只是下载了它，并在beta+5模拟器+(iPhone+SE2)中进行了快速测试，并在几天前启动的一个应用程序中使用了一个表单容器。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2294902|它现在对TextField“就行了”。SwiftUI将自动为封装窗体提供适当的底部填充，以便为键盘腾出空间。它会自动将窗体向上滚动，在键盘上方显示TextField。当键盘出现时，ScrollView容器现在也可以很好地工作。|2294903|然而，正如АндрейПервушин在一条评论中指出的那样，TextEditor存在问题。Beta+5和6将自动为封装窗体提供适当的底部填充，以便为键盘腾出空间。但它不会自动向上滚动窗体。键盘将覆盖TextEditor。因此，与TextField不同的是，用户必须滚动表单才能看到TextEditor。我会提交一份错误报告。也许Beta+7可以解决这个问题。所以关闭…|2294904|https://developer.apple.com/documentation/ios-ipados-release-notes/ios-ipados-14-beta-release-notes/|2294905|entityMap|0|LINK|mutability|MUTABLE|url^0|2Q|2T|0|0|35|0|0|15|0|0|2S|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|11|8|@]|D|@$9|12|A|13|1|14]]|E|$]]|$1|L|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|M|$N|$5|O|P|Q|E|$R|K]]]]

As Mark Krenek and Heiko have pointed out, Apple seemed to be addressing this issue at long last in Xcode 12 beta 4. Things are moving quickly. According to the release notes for Xcode 12 beta 5 published August 18, 2020 &quot;Form, List, and TextEditor no longer hide content behind the keyboard. (66172025)&quot;. I just download it and gave it a quick test in the beta 5 simulator (iPhone SE2) with a Form container in an app I started a a few days ago.
It now &quot;just works&quot; for a TextField. SwiftUI will automatically provide the appropriate bottom padding to the encapsulating Form to make room for the keyboard. And it will automatically scroll the Form up to display the TextField just above the keyboard. The ScrollView container now behaves nicely when the keyboard comes up as well.
However, as Андрей Первушин pointed out in a comment, there is a problem with TextEditor. Beta 5 &amp; 6 will automatically provide the appropriate bottom padding to the encapsulating Form to make room for the keyboard. But it will NOT automatically scroll the Form up. The keyboard will cover the TextEditor. So unlike TextField, the user has to scroll the Form to make the TextEditor visible. I will file a bug report. Perhaps Beta 7 will fix it. So close …
<a href="https://developer.apple.com/documentation/ios-ipados-release-notes/ios-ipados-14-beta-release-notes/" rel="nofollow noreferrer">https://developer.apple.com/documentation/ios-ipados-release-notes/ios-ipados-14-beta-release-notes/</a>

blocks|key|2295332|text|从iOS+14.2开始，如果TextField有足够的移动空间，默认情况下它们是键盘感知的。例如，如果它在一个带有Spacer的VStack中(看看下面没有修饰符的旧演示代码)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|2295333|2295334|⚠️对于%2BiOS14.2，以下代码似乎不能按预期工作|2295335|Xcode+12+(至iOS+14.2)+-单行代码|2295336|将此修饰符添加到TextField|2295337|.ignoresSafeArea(.keyboard,+edges:+.bottom)|code-block|syntax|javascript|2295338|​|2295339|📷|atomic|2295340|2295341|苹果增加了键盘作为安全区域，所以你可以像其他区域一样使用它来移动任何带有键盘的+View。|2295342|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/71e1ac4d8b01e06c273428d6fb6291b7.gif|imageAlt^0|E|9|1L|6|1S|6|22|4|0|0|0|0|Q|0|8|9|0|0|0|0|1|0|0|0|14|4|14|4|0^^$0|@$1|2|3|4|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|D]]|E|@]|F|$]]|$1|G|3|-4|5|6|7|1I|8|@]|E|@]|F|$]]|$1|H|3|I|5|6|7|1J|8|@]|E|@]|F|$]]|$1|J|3|K|5|6|7|1K|8|@$9|1L|A|1M|B|D]]|E|@]|F|$]]|$1|L|3|M|5|6|7|1N|8|@$9|1O|A|1P|B|C]]|E|@]|F|$]]|$1|N|3|O|5|P|7|1Q|8|@]|E|@]|F|$Q|R]]|$1|S|3|T|5|6|7|1R|8|@]|E|@]|F|$]]|$1|U|3|V|5|W|7|1S|8|@]|E|@$9|1T|A|1U|1|1V]]|F|$]]|$1|X|3|T|5|6|7|1W|8|@]|E|@]|F|$]]|$1|Y|3|Z|5|6|7|1X|8|@$9|1Y|A|1Z|B|D]|$9|20|A|21|B|C]]|E|@]|F|$]]|$1|10|3|-4|5|6|7|22|8|@]|E|@]|F|$]]]|11|$12|$5|13|14|15|F|$16|17|18|-4]]]]

From iOS 14.2, <code>TextField</code>s are keyboard aware by default if they have enough space to move. For example, if it is in a <code>VStack</code> with a <code>Spacer</code> (Look at the old demo code below without the modifier)
<hr />
⚠️ It seems the following code is not working as expected for +iOS 14.2
Xcode 12 (to iOS 14.2) - One line code
Add this modifier to the <code>TextField</code>
<pre><code>.ignoresSafeArea(.keyboard, edges: .bottom)
</code></pre>
<a href="https://i.stack.imgur.com/aReXj.gif" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/aReXj.gif" alt="Demo" /></a>
Apple added the keyboard as a region for the safe area, so you can use it to move any <code>View</code> with the keyboard like other regions.

blocks|key|2507675|text|我的观点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2507676|struct+AddContactView:+View+{
++++
++++@Environment(\.presentationMode)+var+presentationMode+:+Binding<PresentationMode>
++++
++++@ObservedObject+var+addContactVM+=+AddContactVM()
++++
++++@State+private+var+offsetValue:+CGFloat+=+0.0
++++
++++@State+var+firstName+:+String
++++@State+var+lastName+:+String
++++@State+var+sipAddress+:+String
++++@State+var+phoneNumber+:+String
++++@State+var+emailID+:+String
++++
++
++++var+body:+some+View+{
++++++++
++++++++
++++++++VStack{
++++++++++++
++++++++++++Header(title:+StringConstants.ADD_CONTACT)+{
++++++++++++++++
++++++++++++++++self.presentationMode.wrappedValue.dismiss()
++++++++++++}
++++++++++++
+++++++++++ScrollView(Axis.Set.vertical,+showsIndicators:+false){
++++++++++++
++++++++++++Image("contactAvatar")
++++++++++++++++.padding(.top,+80)
++++++++++++++++.padding(.bottom,+100)
++++++++++++++++//.padding(.vertical,+100)
++++++++++++++++//.frame(width:+60,height+:+60).aspectRatio(1,+contentMode:+.fit)
++++++++++++
++++++++++++VStack(alignment:+.center,+spacing:+0)+{
++++++++++++++++
++++++++++++++++
++++++++++++++++TextFieldBorder(placeHolder:+StringConstants.FIRST_NAME,+currentText:+firstName,+imageName:+nil)
++++++++++++++++
++++++++++++++++TextFieldBorder(placeHolder:+StringConstants.LAST_NAME,+currentText:+lastName,+imageName:+nil)
++++++++++++++++
++++++++++++++++TextFieldBorder(placeHolder:+StringConstants.SIP_ADDRESS,+currentText:+sipAddress,+imageName:+"sipPhone")
++++++++++++++++TextFieldBorder(placeHolder:+StringConstants.PHONE_NUMBER,+currentText:+phoneNumber,+imageName:+"phoneIcon")
++++++++++++++++TextFieldBorder(placeHolder:+StringConstants.EMAILID,+currentText:+emailID,+imageName:+"email")
++++++++++++++++

++++++++++++}
++++++++++++
+++++++++++Spacer()
++++++++++++
++++++++}
++++++++.padding(.horizontal,+20)
++++++++
++++++++++++
++++++++}
++++++++.padding(.bottom,+self.addContactVM.bottomPadding)
++++++++.onAppear+{
++++++++++++
++++++++++++NotificationCenter.default.addObserver(self.addContactVM,+selector:+#selector(self.addContactVM.keyboardWillShow(_:)),+name:+UIResponder.keyboardWillShowNotification,+object:+nil)
++++++++++++
+++++++++++++NotificationCenter.default.addObserver(self.addContactVM,+selector:+#selector(self.addContactVM.keyboardWillHide(_:)),+name:+UIResponder.keyboardWillHideNotification,+object:+nil)
++++++++}
++++++++
++++}
}|code-block|syntax|javascript|2507677|我的虚拟机：|2507678|class+AddContactVM+:+ObservableObject{
++++
++++@Published+var+contact+:+Contact+=+Contact(id:+"",+firstName:+"",+lastName:+"",+phoneNumbers:+[],+isAvatarAvailable:+false,+avatar:+nil,+emailID:+"")
++++
++++@Published+var+bottomPadding+:+CGFloat+=+0.0
++++
++++@objc++func+keyboardWillShow(_+notification+:+Notification){
++++++++
++++++++if+let+keyboardFrame:+NSValue+=+notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey]+as?+NSValue+{
++++++++++++let+keyboardRectangle+=+keyboardFrame.cgRectValue
++++++++++++let+keyboardHeight+=+keyboardRectangle.height
++++++++++++self.bottomPadding+=+keyboardHeight
++++++++}
++++++++
++++}
++++
++++@objc++func+keyboardWillHide(_+notification+:+Notification){
++++++++
++++++++
++++++++self.bottomPadding+=+0.0
++++++++
++++}
++++
}|2507679|基本上，根据键盘高度来管理底部填充。|2507680|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

My View:
<pre><code>struct AddContactView: View {
 
 @Environment(\.presentationMode) var presentationMode : Binding&lt;PresentationMode&gt;
 
 @ObservedObject var addContactVM = AddContactVM()
 
 @State private var offsetValue: CGFloat = 0.0
 
 @State var firstName : String
 @State var lastName : String
 @State var sipAddress : String
 @State var phoneNumber : String
 @State var emailID : String
 
 
 var body: some View {
 
 
 VStack{
 
 Header(title: StringConstants.ADD_CONTACT) {
 
 self.presentationMode.wrappedValue.dismiss()
 }
 
 ScrollView(Axis.Set.vertical, showsIndicators: false){
 
 Image(&quot;contactAvatar&quot;)
 .padding(.top, 80)
 .padding(.bottom, 100)
 //.padding(.vertical, 100)
 //.frame(width: 60,height : 60).aspectRatio(1, contentMode: .fit)
 
 VStack(alignment: .center, spacing: 0) {
 
 
 TextFieldBorder(placeHolder: StringConstants.FIRST_NAME, currentText: firstName, imageName: nil)
 
 TextFieldBorder(placeHolder: StringConstants.LAST_NAME, currentText: lastName, imageName: nil)
 
 TextFieldBorder(placeHolder: StringConstants.SIP_ADDRESS, currentText: sipAddress, imageName: &quot;sipPhone&quot;)
 TextFieldBorder(placeHolder: StringConstants.PHONE_NUMBER, currentText: phoneNumber, imageName: &quot;phoneIcon&quot;)
 TextFieldBorder(placeHolder: StringConstants.EMAILID, currentText: emailID, imageName: &quot;email&quot;)
 

 }
 
 Spacer()
 
 }
 .padding(.horizontal, 20)
 
 
 }
 .padding(.bottom, self.addContactVM.bottomPadding)
 .onAppear {
 
 NotificationCenter.default.addObserver(self.addContactVM, selector: #selector(self.addContactVM.keyboardWillShow(_:)), name: UIResponder.keyboardWillShowNotification, object: nil)
 
 NotificationCenter.default.addObserver(self.addContactVM, selector: #selector(self.addContactVM.keyboardWillHide(_:)), name: UIResponder.keyboardWillHideNotification, object: nil)
 }
 
 }
}
</code></pre>
My VM:
<pre><code>class AddContactVM : ObservableObject{
 
 @Published var contact : Contact = Contact(id: &quot;&quot;, firstName: &quot;&quot;, lastName: &quot;&quot;, phoneNumbers: [], isAvatarAvailable: false, avatar: nil, emailID: &quot;&quot;)
 
 @Published var bottomPadding : CGFloat = 0.0
 
 @objc func keyboardWillShow(_ notification : Notification){
 
 if let keyboardFrame: NSValue = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue {
 let keyboardRectangle = keyboardFrame.cgRectValue
 let keyboardHeight = keyboardRectangle.height
 self.bottomPadding = keyboardHeight
 }
 
 }
 
 @objc func keyboardWillHide(_ notification : Notification){
 
 
 self.bottomPadding = 0.0
 
 }
 
}
</code></pre>
Basically, Managing bottom padding based on keyboard height.

I have seven <code>TextField</code> inside my main <code>ContentView</code>. When user open keyboard some of the <code>TextField</code> are hidden under the keyboard frame. So I want to move all <code>TextField</code> up respectively when the keyboard has appeared.

I have used the below code to add <code>TextField</code> on the screen.

<pre><code>struct ContentView : View {
 @State var textfieldText: String = ""

 var body: some View {
 VStack {
 TextField($textfieldText, placeholder: Text("TextField1"))
 TextField($textfieldText, placeholder: Text("TextField2"))
 TextField($textfieldText, placeholder: Text("TextField3"))
 TextField($textfieldText, placeholder: Text("TextField4"))
 TextField($textfieldText, placeholder: Text("TextField5"))
 TextField($textfieldText, placeholder: Text("TextField6"))
 TextField($textfieldText, placeholder: Text("TextField6"))
 TextField($textfieldText, placeholder: Text("TextField7"))
 }
 }
}
</code></pre>

Output:

<a href="https://i.stack.imgur.com/HDO4g.png" rel="noreferrer"><img src="https://i.stack.imgur.com/HDO4g.png" alt="Output"></a>

Move TextField up when the keyboard has appeared in SwiftUI

虚拟机

容器

Swift

Xcode

我的主ContentView中有七个TextField。当用户打开键盘时，一些TextField隐藏在键盘框架下。因此，当键盘出现时，我想将所有TextField分别向上移动。我使用下面的代码在屏幕上添加了TextField。struct ContentView : View {    @State var textf...

问当键盘出现在SwiftUI中时，将TextField上移
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问当键盘出现在SwiftUI中时，将TextField上移EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问当键盘出现在SwiftUI中时，将TextField上移
EN