How to use NavigationStack in SwiftUI | Bootcamp #62

Summary

Nick在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

00:00

📚 Swift UI 导航栈介绍

Nick在Swift UI训练营中介绍了Swift UI的新特性，特别是iOS 16中引入的导航栈。他提到虽然导航视图仍然可以使用，但推荐使用新的导航栈，因为它提供了更多的功能和改进，包括懒加载和更好的性能。Nick还解释了导航栈的使用方法，并强调了它与导航视图相比的优势。

05:02

🚀 导航栈的懒加载特性

Nick通过一个示例展示了导航栈的懒加载特性，说明了在旧版导航视图中，即使没有点击，所有屏幕都会被预先加载，这可能会影响应用性能。而导航栈仅在用户实际访问时加载屏幕，这样可以显著提高应用程序的响应速度和性能，尤其是在大型应用中。

10:02

🔄 导航栈的使用和目的地

Nick演示了如何使用导航栈，并解释了如何通过导航目的地进行屏幕间的跳转。他展示了如何使用`NavigationDestination`修饰符来定义不同类型的数据目的地，并且可以为不同的数据类型设置多个导航目的地，从而使得导航更加灵活和可扩展。

15:02

🔗 绑定导航路径

Nick介绍了导航栈中的`path`绑定，它允许开发者以编程方式修改导航路径。通过绑定到一个数组，可以在应用中动态地添加或改变导航目的地。此外，他还提到了如何通过预设的路径绑定来初始化视图，从而在应用启动时直接导航到特定的屏幕。

20:03

➡️ 导航栈的高级用法

最后，Nick讨论了导航栈的高级用法，包括如何使用`superSeque`来一次性推送多个屏幕到导航栈。他指出，虽然这种用法在基础应用中不常见，但对于大型和可扩展的应用来说，这是一个非常有用的功能。他还提到了如何自定义和覆盖导航栈路径，尽管这更高级且有些hacky，但他建议大多数应用可能不需要这么做。

Keywords

💡Swift UI

Swift UI是一个由苹果公司开发的用于构建用户界面的框架，它允许开发者以声明式的方式创建动态和响应式的iOS、iPadOS、macOS、tvOS以及watchOS应用程序界面。在视频中，Swift UI是讨论的核心，因为视频的主题是关于Swift UI的更新和新特性。

💡iOS 16

iOS 16是苹果公司为其移动设备操作系统发布的一个主要版本。视频中提到，iOS 16带来了很多Swift UI的新特性，这些特性是视频讨论的重点之一。

💡导航栈（Navigation Stack）

导航栈是Swift UI中用于管理视图导航层次结构的新方式，它允许更复杂的导航流程，如同时推送多个视图。视频中强调了导航栈比旧的导航视图（NavigationView）更高效，支持懒加载，并提供了更强大的功能。

💡懒加载（Lazy Loading）

懒加载是一种编程技术，意味着直到真正需要某个资源或数据时才会加载它。在Swift UI中，导航栈支持懒加载视图，这可以提高应用程序的性能，因为它避免了提前加载不必要的屏幕。视频中通过一个示例展示了懒加载如何在导航栈中工作。

💡导航链接（Navigation Link）

导航链接是Swift UI中的一个组件，用于在应用程序的不同视图之间进行导航。在视频中，导航链接被用来演示如何在导航视图和导航栈中推动到新的视图。

💡导航视图（NavigationView）

导航视图是Swift UI中的一个组件，用于创建带有导航栏的视图层次结构。然而，视频中提到，尽管导航视图仍然有效，但在iOS 16及以上版本中，推荐使用导航栈，因为导航视图已被弃用。

💡数据类型（Data Type）

数据类型定义了可以在变量或参数中存储的值的种类。在视频中，数据类型对于理解导航目的地（Navigation Destination）如何工作至关重要，因为它们需要是哈希协议的遵守者，如整数或字符串。

💡哈希协议（Hashable Protocol）

哈希协议是Swift中的一个协议，它允许类型被用作字典的键或集合中的元素。在视频中，当创建导航目的地时，需要指定一个符合哈希协议的数据类型，以便Swift UI可以跟踪和比较不同的目的地。

💡视图结构（View Structure）

视图结构指的是在Swift UI中如何组织和嵌套视图组件来创建用户界面。视频中通过创建不同的视图结构来演示如何使用导航栈和导航链接，以及如何通过视图结构来控制应用程序的导航流程。

💡初始化（Initialization）

初始化是编程中的一个概念，指的是对象或结构体在创建时设置其初始状态的过程。视频中通过打印初始化信息来演示视图何时被创建，以及懒加载如何在导航栈中避免不必要的初始化。

💡导航路径（Navigation Path）

导航路径是Swift UI中用于表示导航栈当前状态的一个绑定。在视频中，通过绑定导航路径到一个状态变量，可以控制和监视导航流程，甚至实现通过编程方式修改导航堆栈，如添加多个目的地。

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]