How to use NavigationStack in SwiftUI | Bootcamp #62
Summary
TLDRNick在Swift UI训练营的视频中介绍了Swift UI的最新更新,特别是iOS 16中引入的导航栈(Navigation Stack)。他解释了导航栈如何取代了旧的导航视图(Navigation View),并强调了其懒加载(lazy loading)的特性,这使得应用程序在需要时才加载屏幕,从而提高了性能和可扩展性。此外,Nick还展示了如何使用导航目的地(Navigation Destinations)来处理不同类型的数据,并演示了如何通过路径绑定(path binding)来以编程方式操作导航栈,包括一次性推送多个屏幕到导航栈。他鼓励开发者尽快从导航视图迁移到导航栈,因为这是Swift UI和iOS 16中一个重要的进步。
Takeaways
- 📚 Swift UI自发布以来经历了多次更新,现在是时候回顾并增加一些新特性的介绍了。
- 🚀 iOS 16带来了许多新特性,其中导航栈(Navigation Stack)是非常酷的一个,值得分享。
- 🔄 导航栈相比导航视图(Navigation View)提供了更多功能,并且支持懒加载,这在生产级别的可扩展应用中非常重要。
- 🛠️ 在iOS 16及以上版本中,推荐使用导航栈而不是导航视图,因为导航视图已被弃用。
- 📈 导航栈允许我们更灵活地管理导航路径,可以一次性推送多个屏幕到导航路径中。
- 🔗 导航链接(Navigation Link)在导航栈中仍然可以使用,并且可以通过绑定(Binding)来动态控制导航路径。
- 🧩 导航栈支持为不同类型的数据设置多个导航目的地,这对于构建可扩展的应用程序非常有帮助。
- 📝 使用导航栈时,每个目的地视图需要符合哈希协议(Hashable),以便导航栈可以正确处理。
- ➡️ 导航栈的路径(Path)可以绑定到一个状态变量,允许我们以编程方式修改导航路径,实现更高级的导航控制。
- 🔄 导航栈的懒加载特性意味着只有在需要时才会加载屏幕,这有助于提高应用性能并减少不必要的资源消耗。
- 📱 对于初学者和中级开发者来说,导航栈提供了更简单、更高效的方式来处理导航,而无需自己实现复杂的懒加载逻辑。
- ⏪ 如果需要从导航栈返回,它将按照进入的顺序返回,而不是直接回到最初的屏幕,这对于复杂的应用流程非常有用。
Q & A
Swift UI自发布以来有哪些重大更新?
-自Swift UI发布以来,已经有很多更新,特别是在iOS 16中,引入了一些非常酷的新特性。
为什么推荐使用Navigation Stack而不是Navigation View?
-Navigation Stack提供了比Navigation View更多的功能,例如支持iOS 16或以上版本时,推荐使用Navigation Stack,因为它提供了懒加载,可以更高效地加载屏幕。
什么是懒加载(lazy loading),为什么它对应用程序很重要?
-懒加载是一种按需加载资源的技术,只有当需要时才加载屏幕或数据。这对于生产级别的可扩展应用程序非常重要,因为它可以减少不必要的资源消耗,提高应用性能。
在Swift UI中,Navigation Stack如何实现懒加载?
-Navigation Stack通过使用Navigation Destination来实现懒加载,只有当用户实际导航到特定屏幕时,才会初始化和加载该屏幕。
如果我之前使用了Navigation View,我需要立即切换到Navigation Stack吗?
-虽然Navigation View已被弃用,但仍然可以在短期内使用。不过,推荐开发者尽快切换到Navigation Stack,以利用其更高效和更现代的功能。
Navigation Stack是否支持多数据类型的导航目的地?
-是的,Navigation Stack支持多数据类型的导航目的地。开发者可以为不同类型的数据定义不同的导航目的地,这有助于构建更动态和可扩展的应用程序。
Navigation Stack中的path binding是如何工作的?
-path binding允许开发者将Navigation Stack绑定到一个可以动态修改的路径上。这意味着可以通过编程方式向路径中添加或删除目的地,从而实现复杂的导航流程。
如何在Navigation Stack中实现一次性推送多个屏幕?
-通过使用path binding,可以一次性向Navigation Stack的路径中添加多个元素,从而实现一次性推送多个屏幕。这在iOS 15中是不可能的,但Navigation Stack提供了这种能力。
使用Navigation Stack时,如何初始化视图以预设的绑定开始?
-可以通过在视图的状态中设置一个初始的path binding来实现。这样,当视图加载时,Navigation Stack将从预设的路径开始导航。
如果我已经在我的应用程序中使用了Navigation View,我该如何迁移到Navigation Stack?
-可以逐步迁移。首先,将现有的Navigation View替换为Navigation Stack,但保持现有的Navigation Links不变。然后,逐渐将Navigation Links转换为使用Navigation Destinations。
Navigation Stack是否只能在iOS 16或更高版本上使用?
-Navigation Stack是在iOS 16中引入的,因此为了使用Navigation Stack,你的应用程序需要支持iOS 16或更高版本。
Outlines
📚 Swift UI 导航栈介绍
Nick在Swift UI训练营中介绍了Swift UI的新特性,特别是iOS 16中引入的导航栈。他提到虽然导航视图仍然可以使用,但推荐使用新的导航栈,因为它提供了更多的功能和改进,包括懒加载和更好的性能。Nick还解释了导航栈的使用方法,并强调了它与导航视图相比的优势。
🚀 导航栈的懒加载特性
Nick通过一个示例展示了导航栈的懒加载特性,说明了在旧版导航视图中,即使没有点击,所有屏幕都会被预先加载,这可能会影响应用性能。而导航栈仅在用户实际访问时加载屏幕,这样可以显著提高应用程序的响应速度和性能,尤其是在大型应用中。
🔄 导航栈的使用和目的地
Nick演示了如何使用导航栈,并解释了如何通过导航目的地进行屏幕间的跳转。他展示了如何使用`NavigationDestination`修饰符来定义不同类型的数据目的地,并且可以为不同的数据类型设置多个导航目的地,从而使得导航更加灵活和可扩展。
🔗 绑定导航路径
Nick介绍了导航栈中的`path`绑定,它允许开发者以编程方式修改导航路径。通过绑定到一个数组,可以在应用中动态地添加或改变导航目的地。此外,他还提到了如何通过预设的路径绑定来初始化视图,从而在应用启动时直接导航到特定的屏幕。
➡️ 导航栈的高级用法
最后,Nick讨论了导航栈的高级用法,包括如何使用`superSeque`来一次性推送多个屏幕到导航栈。他指出,虽然这种用法在基础应用中不常见,但对于大型和可扩展的应用来说,这是一个非常有用的功能。他还提到了如何自定义和覆盖导航栈路径,尽管这更高级且有些hacky,但他建议大多数应用可能不需要这么做。
Mindmap
Keywords
💡Swift UI
💡iOS 16
💡导航栈(Navigation Stack)
💡懒加载(Lazy Loading)
💡导航链接(Navigation Link)
💡导航视图(NavigationView)
💡数据类型(Data Type)
💡哈希协议(Hashable Protocol)
💡视图结构(View Structure)
💡初始化(Initialization)
💡导航路径(Navigation Path)
Highlights
Swift UI自发布以来经历了许多更新,现在是时候回顾并增加一些新特性的介绍视频。
iOS 16带来了许多酷炫的新特性,特别是导航栈(Navigation Stack)的改进。
导航栈(Navigation Stack)比导航视图(Navigation View)提供了更多的功能和优势。
导航栈允许懒加载(lazy loading),仅在需要时加载屏幕,这对于生产级别的可扩展应用至关重要。
导航栈支持多屏幕同时推送,这是iOS 15所不支持的新功能。
导航栈可以通过路径绑定(path binding)实现动态路由,这在构建大型应用时非常有用。
即使在iOS 16中,导航视图仍然可以工作,但是推荐使用导航栈以获得更好的性能和新特性。
导航栈允许开发者以类型安全的方式定义导航目的地,支持整数和字符串等多种数据类型。
使用导航栈可以避免之前在自定义懒加载导航时遇到的复杂性。
导航栈的路径可以被初始化为预设的绑定,从而在应用启动时直接导航到特定的屏幕。
导航栈的引入是Swift UI在iOS 16中最重要的进步之一,它极大地提高了应用的可扩展性和性能。
通过使用导航栈,开发者可以更简单地实现之前需要复杂自定义代码才能完成的导航功能。
导航栈提供了一种新的方式来处理应用中的导航,使得导航更加灵活和强大。
导航栈的懒加载特性意味着只有在用户实际访问某个屏幕时,该屏幕才会被加载。
导航栈允许开发者为不同的数据类型定义多个导航目的地,从而实现更精细的导航控制。
导航栈的路径绑定可以动态地向导航堆栈中添加新的目的地,支持更复杂的导航场景。
即使对于初学者和中级开发者,导航栈也提供了足够的功能来满足大多数应用的导航需求。
对于需要同时推送多个屏幕的复杂应用场景,导航栈提供了超级跳转(Super Segue)的功能。
Transcripts
all right welcome back everybody my name
is Nick this is swiffel thinking of
course and we're back here in the Swift
UI boot camp playlist this is the
original playlist that I put out on my
Channel about two years ago now and
since then there's been a lot of updates
to Swift UI and I thought it was a good
time to now revisit this playlist and
append a couple videos here of maybe
some of the new features that I've not
yet covered so I know iOS 16 came out
about a year ago now but there's some
really cool features in there that I
really want to share with you guys I'm
going to do that in the next couple
videos there's also been a couple things
that I've now deprecated since I
originally made this playlist I've
gotten a lot of comments on this has
been deprecated what's the new version
and so I'm also going to add on a couple
videos here on showing you the new way
for some of those things that have been
deprecated I'll show you guys the new
way to do that and in those videos I'm
also going to talk a little bit about
why those things have been deprecated
because it's not that Apple's just wants
to change their API it's that they are
making Swift UI better so anything that
has been deprecated it's deprecated not
because it doesn't really work anymore
but because there's a new and better way
to do it and so that's what we're going
to dive into in the next couple videos
this video as you already know though is
the navigation Stack video so the the
probably the biggest improvement from
IOS 16 is the navigation stack prior to
iOS 16 we had the navigation view which
still works in our code but if we are
building Swift UI apps now and we can
support iOS 16 or above we should be
using a navigation stack over navigation
view I'm going to explain this video
firstly obviously how to use it but I'm
also going to explain some of the
benefits of the stack over the view and
I'm not kidding when I say that it is
incredibly powerful the navigation stack
opens us up to so many more features
that we didn't previously have so I am
super excited to share this with you
guys I apologize that I have not covered
this sooner there's just been a lot of
other videos Firebase videos that I
wanted to get through but if you have
not learned how to use it yet I hope
this video helps somebody I am using
navigation stack in all of my apps at
this point it is awesome let's check it
out
welcome back everyone it has been a
while since I've added to this playlist
I am pretty excited most of the stuff
that I've covered in this playlist is
still relevant today although Apple has
made some pretty major updates in iOS
16. I'm sure they're going to make even
bigger updates in iOS 17 and I'm a
little late to the game for 16 but I do
want to still cover them so earlier in
this playlist we covered the navigation
view boot camp and the navigation view
still works but if you're building your
app for iOS 16 or above you should
basically use navigation stack instead
of navigation View
navigation stack is the new version
navigation view is now deprecated and
I'm going to show you in this video how
to use navigation stack and I'm also
going to highlight some of the changes
that make navigation stack actually
better than navigation View
now I'm still using navigation View and
a lot of my own apps I don't think it's
going to be a problem that it's in your
app for at least the foreseeable future
but if you can use navigation stack I
would definitely switch it over again
I'm back here in the swiffle thinking
boot camp the original boot camp on this
channel and I'm going to right click the
Navigator create a new file it'll be a
swift UI View and let's call this one
navigation stack boot camp
go ahead and click create once we're
inside let's get that preview working
all right we are going to delete this
text and let's add a navigation view the
old navigation view that we learned in
an earlier video in this playlist and we
can see that navigation view it will be
deprecated in a future version of iOS so
this is Apple telling us that you can
still use navigation view but it's going
to be devastated so there will be a
point of time in the future where you
won't be allowed to use it anymore
although it probably won't be for a very
long time
because Apple doesn't want to break the
apps that are in the app store today so
they are probably going to keep it
usable at least for the foreseeable
future regardless we should update to
navigation stack as soon as possible
there also is a navigation split view
but I'm not going to cover that I have
actually never used it I think it's more
common on like iPads and larger devices
but navigation stack has a lot to offer
and is what I'm using in pretty much all
of my apps all of my apps right now but
navigation stack is the go-to and
probably the one that you should be
using in most if not all of your apps
but we're gonna start right now with the
navigation View and look at how it's set
up before we get to the navigation stack
so navigation view puts us into a
navigation hierarchy and then once we're
in that hierarchy we can add some text
here let's say hello world
and because we're in the navigation
hierarchy we can add that navigation
title and say maybe nav
boot camp
right and so we can't get this
navigation title we can't get the nav
bar at the top unless we're in a
navigation view this should not be new
to you guys if you followed this
playlist I we've been using this in many
many videos already
so when we're in a navigation view in
order to push to the next screen we use
a navigation link
so I'm going to add one here real quick
so I'll say navigation link
open the parentheses I'm going to go
with the destination and label
completion here
the destination let's just say screen
two
and the label let's just say text that
says maybe click me
all right so I've got it on our screen
here if I click it it pushes to the next
screen and we can go backwards this is
our standard Behavior
and before we move forward I want to
talk a little bit about some of the
limitations that are in this current
setup here so first and foremost this
navigation link allows us to push
forward one screen and one screen only
so I can go to the next screen but I
can't go to screen three four I can't
push multiple screens at the same time
navigation stack we're going to be
allowed to do that
the probably bigger and more important
thing that navigation stack allows us to
do is have basically lazy loading on
these secondary screens
so some of you might not understand what
lazy loading is so I'm going to just do
a quick example of this so first I'm
going to create a struct for the second
screen the second screen that is
currently screen two I'm just going to
create another struct that says my
second screen
it'll be a view and we'll open the
brackets every view needs a body and
let's just put a text screen two in here
and actually let's pass in a integer
we'll say value of type int
and I'm gonna just for now I'm going to
create a custom initializer here
and inside this initializer I'm just
going to print out the screen that is
being initialized so I'm going to print
out init init for screen
and then let's just pass in the value so
this should print out a knit screen one
two three Etc and we'll just put that
value on the screen just so we know
we're going to the right screen
all right so if I put in here my second
screen with a value of one
click this it goes to my screen one and
let's real quick do a four each and
we're going to do a four each Loop so
let's do zero to maybe less than ten of
these and this will be X and I'm just
going to put the navigation link inside
so here we're going to create a very
simple Loop here on 10 items each with a
navigation link and this way each of
those items we will go to the X screen
so let's render this real quick
let me stop the preview let me start it
up again
and they're not loading because we are
not in a v-stack do a v-stack here
actually let's do a scroll view followed
by a v stack and here we go
all right add some spacing of maybe 40.
all right so I got all these buttons
here click me actually put click me with
the X here
oh man getting sloppy Nick all right
click me zero goes to zero click me six
goes to six this is standard Behavior
what I'm going to do now is take this
and make this the first screen in my app
all right and I'm gonna build and run
this to the simulator and before I even
click anything I'm just going to look at
what prints out to my console and I can
see here that we have the init for all
of these screens already created so I
haven't clicked any of these yet but the
initializer for screen 789 has already
ran now it ran twice for each of these
and I'm not concerned that I ran twice
because that's just how the view renders
but what I'm concerned about is the fact
that I'm only on this screen and yet all
nine of these screens have been rendered
in the background
if you follow my crypto app or if you've
been building any apps pretty much prior
to iOS 16 you probably ran into this
problem because these navigation links
are not lazy and so if we had a lot of
maybe this second screen here was like a
big heavy lifting screen if that had a
lot of like download functions or
loading functions we're literally
loading nine extra screens behind the
scenes right now and you can imagine on
a larger app right this could actually
slow down the entire app tremendously we
only want to load the screens and the
things that we need to load when we need
to load them
and so one of the major benefits of
moving to a navigation stack is the
ability to do this in a lazy fashion so
that we only load the screen when we go
to it
and now let's actually jump in and look
at the navigation stack
so to use a navigation stack is actually
quite simple all we need to do is use a
navigation stack instead of a navigation
View
and we can actually still use these
navigation links as is
and it looks like navigation stack is
only available on iOS 16. I'm just going
to make my whole project only compile
for iOS 16 now
just because this is a boot camp
and here we go
let's put this on the simulator again
and we should see that it still works
awesome I'm gonna build and run this to
the simulator again and we do still have
this initializer problem because again
these navigation links are not lazy but
it is good to know that at least that as
we start upgrading our app we can still
use this existing setup without needing
to refactor everything right now right
so if you have this in your app you can
keep that code as is and you can just
change the navigation stack and
gradually start shifting your navigation
links to navigation destinations
all right so firstly I'm just going to
move the navigation title down here
because I don't really want to work with
it
and so all right Nick show us what a
navigation destination is well it's just
another modifier we'll call navigation
destination
and we're going to be working with the
four destination completion here I think
it's much more common than the other one
and it's going to allow us to go to a
destination view for a certain data type
now that data type is going to be pretty
important so I'm going to hold the
option button and click enter here
navigation destination for what type any
type that conforms to the hashable
protocol
well most types by default already
conform to hashable so if you're making
your own model you have to conform to
hashable but we're right now are just
using integers so I'm just going to use
integer dot self and again self is
referring to the type of integer the
type integer destination is basically
where we want to go and obviously we
want to go to my second screen so I'll
click enter here
this hashable value is the selected
value of this type so if we say we're
going to go to integer number four
that's the number that's going to come
through here so I'm just going to call
this the value
and then we'll just go to my second
screen and I'll pass in value
and now we're going to do is instead of
using this navigation link with a
destination and a label we're going to
use just a very simple we're just going
to use a different initializer here
navigation link
we're going to look for the one with a
value again this value is hashable this
value this corresponding value is the
same value that we are putting down here
so navigation link with a value and what
is the value of this navigation link so
when we click on this label so it's
going to be the click me the value is
going to be that X right the value that
we are passing in so we'll just put here
x
that again that in that X is an integer
right so we're looking for integers down
here this all needs to line up with the
same type and the label we'll just put
this here
and let's let this compile real quick so
just a slight change to our code it
looks like it's the exact same in the UI
here if I click on three we go to three
if I click on seven we go to seven but
this time I'm going to build and run
this to the simulator
and I'm going to open up the console
here and what do you know nothing is
printed out to the console so it looks
the exact same but behind the scenes
there's been a tremendous difference
right we did not load all nine of these
screens already so if I click on four
it's going to load four at that time if
I click on seven it's gonna Load 7 at
that time and just this by itself is
enough for us to use navigation stack
over navigation view this is I think
underratedly the biggest advancement to
Swift UI and iOS 16. this lazy loading
of navigation is incredibly important
for production level scalable apps so if
you're not doing this in your apps I
highly recommend this is like the first
thing that probably should be refactored
and this is awesome but of course
there's way more that we can do with the
navigation stack
so let's play around with this a little
bit up here I'm going to add a let's
just say maybe let fruits of type it's
going to be an array of string and let's
just add in apple let's add in the
orange
and let's add in everybody's favorite
b-a-n-a-n-a-s
without the S because there's only one
banana on this list
and
this is an equal sign and here we go all
right so we got an array of fruits let's
loop on these fruits as well so I'm
going to do it maybe let's do it above
these let's just put it here for each
let's loop on the fruits
fruits are not identifiable but they are
hashable so we need to add in that ID so
that we can tell it where the hash value
is the hash value is self which is the
string itself and here we go this will
be each fruit and what do we want to add
here I'm going to add in another
navigation link
this time again I'm going to use the
value label value I'm going to put in
the fruit and the label let's just put
in text fruit
let's just put in text and let's just
add in the fruit
why not let's refresh the canvas we got
Apple orange banana on the screen but
if I click it it's not going to go
now before I tell you guys exactly why
take a second look at this code and try
to debug it yourself try to figure out
why is the The Click me one two nine are
working perfectly but the orange and
banana are not
so pause it if you need to but if not
I'm going to keep moving here so the
reason is because when we edit a
navigation destination we told it look
for values that are integers and anytime
you get an integer go to this screen but
now these fruits are strings right so
they're no longer integers and so
because they're strings we actually need
to add another navigation destination
what destination are we going to for
Strings
and so I'm just going to put down here I
don't think we need to create another
second screen I'm just going to put in
some text that says another screen
and let's put in the the value of the
fruit
and of course this is going to be a
string
it's so it's really cool and kind of
unexpected as a developer that we can
actually stack these navigation
destinations we can literally have
multiple destinations for multiple
different data types and this again it
really helps us for scalable apps
because you might have you know a user
profile model you might have a post
model you might have a you know settings
screen and so now we can really start to
make our screens that our routing at
least Dynamic here so I added this
string destination and just like that I
can now go to the orange screen the
banana screen and I can also go to the
integer screens
so again this is just a huge step up
from the capabilities of the navigation
View
all right the last thing I'm going to do
before we wrap up this video is talk
about the path that we can bind to in a
navigation stack so when you build out a
navigation stack there actually is a
path binding here and we can see that
the path is of type binding to a
navigation path
the navigation path is a little
misleading because a navigation path is
pretty much anything that is hashable so
for example down here our navigation
path is an integer here our navigation
path is a string so it's a little
confusing the first time you use it but
really it's just a binding and then we
have our closure so I'm just going to
delete this bit of code here and use
this path and what are we going to bind
to so let's create up here and add State
private VAR we'll call this stack path
of type and let's just do it with the
strings for a second because we already
have our fruit array let's just say bind
to an array of string
and we'll set it equal to a blank array
I'm just going to bind to it with the
money sign stack path
all right and now it seems like we
didn't add much code but this did change
the actual usage of our app pretty
dramatically already
so this navigation stack meaning the
entire stack is now set up to bind to
destination values for Strings there's
only strings in here there are not
integers in here so even though we have
the destination of an integer and we
have the destination of a string of
course this integer one is now broken
because the the path is overriding any
of the other destinations so if I click
on Orange it's going to work because
those are strings if I click on number
four it's now broken and just to prove
that if I again if I take out this path
and then click on four it works if I put
the path back in and I click on four
it's broken so this is pretty good to
know it's not a bug that's just how it
works
but why would we want to do a stack path
if it's going to limit Us in that
direction well because when we buy the
stack path we can now programmatically
append to this path so when we click on
a string it's actually just adding that
string to this path so if I click on
banana basically the stack path is going
to be an array of one item that has a
string of banana in it but what I'm
going to do up here is actually create
my own button that says maybe a super
Segway
and the action I'm going to call stack
path
dot append and I'm going to append an
element let's just say maybe coconut
all right so here I'm going to Super
segue and it binds to Coconut but why do
I call it super Segway because what we
can actually do is append
an array to this path so I'm going to
append contents of another array
and here I'm going to put in coconut
let's do watermelon
and and let's do maybe mango
so this is insanely cool now we were not
able to do this in iOS 15 but navigation
stack allows us to now push to multiple
screens at the same time
so what this is going to append all
three of these to the stack basically
pushing forward three screens at once
super Segway I'm on Mango Mango is the
third one and so now when I click back
it's not going to go back to that
original screen it's going to first go
to watermelon then it's going to go to
coconut and then we're back
and so if you're just starting you're
building your basic apps this is
probably not a real use case that you're
going to have very often but
but larger scalable apps bigger
companies are going to need this setup
this allows you to push multiple screens
at once into the path
and there are absolutely use cases where
this is like a crucial part of some
applications
so that is all I have for you guys for
the navigation stack there are ways to
kind of override and customize this
stack path so that it can accept
multiple data types but it's much more
advanced it's a little hackier and I
don't want to get into it in this
playlist so for right now I think this
covers pretty much all of your use cases
for your beginner intermediate level
apps generally I do not use the the path
unless I need to do this super segue
basically and most apps honestly don't
need to do that so I've been avoiding it
but if you have that binding there you
can then do that super segue but one
other cool thing that that allows you to
do is actually initialize the view with
a preset binding if you wanted to so you
could do something like an on a pier or
you could even just put it up here you
could just start with maybe you know one
to
three
and so as soon as this screen loads it's
actually starting on the third screen
already you can really get pretty
customizable with this stuff
but that is it for me bottom line here
is if you're using navigation view you
can still use it but get on a path to
refactoring to the navigation stack it's
just it's better it's newer it's more
performant and it's honestly easier to
use because if you follow my crypto app
we did a lot of work to kind of create
our own custom lazy navigation and I'm
not going to go and change that that
course right now I think it's just like
one screen that we really did that on
but this allows us to avoid all that
hackiness completely by just giving us
lazy navigation destinations out of the
box
all right thank you guys for watching as
always I'm Nick this is swiftful
thinking and I'll see you in the next
video
[Music]
Weitere ähnliche Videos ansehen
User Experience and Animations in SwiftUI app | Todo List #5
Create a List of Todo items in SwiftUI | Todo List #1
How to use Toolbar in SwiftUI | Bootcamp #63
Adding an App Icon and Launch Screen to SwiftUI | Todo List #7
How to use Popover modifier in SwiftUI | Bootcamp #69
Adapt SwiftUI app for iPad, Landscape, and Dark Mode | Todo List #6
5.0 / 5 (0 votes)