✅ The correct and Simplest Way:

You can set the alpha instead, this will preserve the layout space of the view too, and does not force you to add dummy views like the other answers:

.opacity(isHidden ? 0 : 1)

Demo

💡 Cleaner Way! - Extend original hidden modifier:

Also, you can implement a custom function to get the visibility state as an argument:

extension View {
    func hidden(_ shouldHide: Bool) -> some View {
        opacity(shouldHide ? 0 : 1)
    }
}

Now just pass the bool to the modifier:

DatePicker($datePickerDate)
    .hidden(showDatePicker)

_{Note that unlike the original behavior of the hidden modifier, both of these methods preserve the frame of the hiding view.}

⛔️ Don't use bad practices !!!

All other answers (including the accepted answer by @Jake) use branches instead of dependent code that causes a performance hit.

🛑 Branch example: (from WWDC)

✅ Dependent Code example:

Returning logical SAME view for different states causes the SwiftUI to render engine to re-render and initial a view again and cause a performance hit! (see more at this WWDC session)

The simplest and most common way to hide a view is like the following:

struct ContentView: View {
    @State private var showText = true

    var body: some View {
        VStack {
            Button("Toggle text") {
                showText.toggle()
            }

            if showText {
                Text("Hello World!")
            }
        }
    }
}

This removes the Text view from the hierarchy when showText equals false. If you wish to have an option to preserve the space or want it as a modifier, see below.

I created an extension, so you can use a modifier, like so to hide the view:

Text("Hello World!")
    .isHidden(true)

Or for complete removal:

Text("Label")
    .isHidden(true, remove: true)

The extension below is also available on GitHub here if you want to use Swift Packages: GeorgeElsham/HidingViews.

Here is the code to create the View modifier:

I recommend you use this code in its own file (remember to import SwiftUI):

extension View {
    /// Hide or show the view based on a boolean value.
    ///
    /// Example for visibility:
    ///
    ///     Text("Label")
    ///         .isHidden(true)
    ///
    /// Example for complete removal:
    ///
    ///     Text("Label")
    ///         .isHidden(true, remove: true)
    ///
    /// - Parameters:
    ///   - hidden: Set to `false` to show the view. Set to `true` to hide the view.
    ///   - remove: Boolean value indicating whether or not to remove the view.
    @ViewBuilder func isHidden(_ hidden: Bool, remove: Bool = false) -> some View {
        if hidden {
            if !remove {
                self.hidden()
            }
        } else {
            self
        }
    }
}

Here is the simple way to Show/Hide view in SwiftUI.

1. Add @State variable:

   @State private var showLogo = false
   

2. Add condition like below:

   VStack {
       if showLogo {
           Image(systemName: "house.fill")
               .resizable()
               .frame(width: 100, height: 100, alignment: .center)
               .foregroundColor(Color("LightGreyFont"))
               .padding(.bottom, 20)
       }
       Text("Real State App")
           .font(Font.custom("Montserrat-Regular", size: 30))
   }.padding(.vertical, 25)
   

3. Change state of your @State variable to Show/Hide the view like below:

   Button(action: {
       withAnimation{
           self.showLogo.toggle()
       }
   
   }, label: {
       Text("Login").font(.system(size: 20, weight: .medium, design: .default))
           .frame(minWidth: 0, maxWidth: .infinity, maxHeight: 50)
           .foregroundColor(Color("BlackFont"))
           .cornerRadius(10)
   
   })
   

If you want to preserve space you can also use .opacity(showLogo ? 1 : 0) modifier.

Edit Nov 4 2021

I now prefer another approach over the one in my original answer (below):

There are two possible solutions depending on if you want to keep the original space occupied or make the other views take the space of the one that's hidden.

Keep the space

DatePicker("Choose date", selection: $datePickerDate)
    .opacity(showDatePicker ? 1 : 0)

Even if we are adjusting just opacity here, touching the space where the DatePicker should be when it's hidden doesn't open the calendar.

Don't keep the space

if showDatePicker {
    DatePicker("Choose date", selection: $datePickerDate)
}

Original answer

For whoever needs it in the future, I created a ViewModifier which takes a Bool as parameter so you can bind a boolean value to show and hide the view declaratively by just setting your showDatePicker: Bool variable.

All code snippets require import SwiftUI.

The ViewModifier:

struct Show: ViewModifier {
    let isVisible: Bool

    @ViewBuilder
    func body(content: Content) -> some View {
        if isVisible {
            content
        } else {
            content.hidden()
        }
    }
}

The function:

extension View {
    func show(isVisible: Bool) -> some View {
        ModifiedContent(content: self, modifier: Show(isVisible: isVisible))
    }
}

And you can use it like this:

var datePicker = DatePicker($datePickerDate)
                     .show(isVisible: showDatePicker)

Command-click the view in question and select the Make Conditional option in Beta 5. I did this on one of my views (LiftsCollectionView), and it generated the following:

    if suggestedLayout.size.height > 150 {
      LiftsCollectionView()
    } else {
      EmptyView()
    }

I had the same problem, and I solved it in the following way:

Note: I use binding to hide and/or show dynamically.

1 - Create Modifier

struct HiddenModifier: ViewModifier{
    var isHide:Binding<Bool>
    
    func body(content: Content) -> some View {
        if isHide.wrappedValue{
            content
                .hidden()
        }
        else{
            content
        }
    }
}

2 - Add Modifier to view:

extension View{
    func hiddenModifier(isHide:Binding<Bool>) -> some View{
        return self.modifier(HiddenModifier(isHide: isHide))
    }
}

3 - Use Modifier

struct CheckHiddenView: View {
    @State var hide:Bool = false
    
    var body: some View {
        VStack(spacing: 24){
            Text("Check Hidden")
                .font(.title)
            
            RoundedRectangle(cornerRadius: 20)
                .fill(Color.orange)
                .frame(width: 150, height: 150, alignment: .center)
                .hiddenModifier(hide: $hide)
            
            Button {
                withAnimation {
                    hide.toggle()
                }
                
            } label: {
                Text("Toggle")
            }
            .buttonStyle(.bordered)
            
        }
    }
}

Test

Please review Apple's article Choosing the right way to hide a view.

Contrary to what many other answers here suggest, Apple's article states that a conditional is the correct solution.

The exception is when you want to preserve an empty space where the hidden view used to be. In that case, using .opacity(0) is the correct solution.

.hidden() is only suggested if the visibility of the view is always off. I suspect that's equivalent to .opacity(0), perhaps simply being a clearer expression of intent for exactly the same solution under the hood.

If you do want a modifier to make it convenient to do this, I would offer the following tweak on other people's work:

extension View {
    /// Hide or show a view based on a boolean value.
    ///
    /// Example for hiding while reclaiming space:
    ///
    ///     Text("Label")
    ///         .isHidden(true)
    ///
    /// Example for hiding, but leaving a gap where the hidden item was:
    ///
    ///     Text("Label")
    ///         .isHidden(true, remove: false)
    ///
    /// - Parameters:
    ///   - hidden: whether to hide the view.
    ///   - remove: whether you want to reclaim the space taken by the hidden view.
    @ViewBuilder func isHidden(_ hidden: Bool, remove: Bool = true) -> some View {
        if remove {
            if !hidden {
                self
            }
        } else {
            self.opacity(hidden ? 0 : 1)
        }
    }
}

Arranging the conditional that way has the advantage that, at least in the case where remove is set to false, the structural identity of the hidden view is consistent through animation of the hidden parameter.

On the other hand, if remove is set to true, there is no view in the hidden case, so it's not possible to maintain structural identity. So if you are animating the hidden parameter and remove is true, you might run into some unpleasant animation (depending on where SwiftUI determines is the best guess for the geometry of the removed view). To solve that, the answer, in theory, is to use .matchedGeometryEffect (see this to explore this technique). But I have found matchedGeometryEffect to be buggy, so for now, I would recommend that you turn animation off, and avoid all these headaches.

The following custom modifier works as .hidden() does by both hiding the view and disabling interaction with it.

ViewModifier and View extension func -

import SwiftUI

fileprivate struct HiddenIfModifier: ViewModifier {
  var isHidden: Bool
  
  init(condition: Bool) {
    self.isHidden = condition
  }
  
  func body(content: Content) -> some View {
    content
      // Conditionally changing the parameters of modifiers
      // is more efficient than conditionally applying a modifier
      // (as in Cristina's ViewModifier implementation).
      .opacity(isHidden ? 0 : 1)
      .disabled(isHidden)
  }
}

extension View {
    /// Hides a view conditionally.
    /// - Parameters:
    ///   - condition: Decides if `View` is hidden.
    /// - Returns: The `View`, hidden if `condition` is `true`.
    func hidden(if condition: Bool) -> some View {
        modifier(HiddenIfModifier(condition: condition))
    }
}

Use -

DatePicker($datePickerDate)
  .hidden(if: !self.showDatePicker)

Note - Conditionally applying a modifier is inefficient because swift sees the unmodified and modified views as different types. This causes the view (and it's state) to be destroyed and rebuilt every time the condition changes. This can become an issue for data heavy views like List. Conditionally changing the parameters of modifiers doesn't cause this issue.

SwiftUI’s built-in .hidden() can be enhanced to handle accessibility and interaction better. Here’s a custom extension:

extension View {
    @inlinable nonisolated public func hidden(_ hidden: Bool) -> some View {
        self
            .opacity(hidden ? 0 : 1)
            .disabled(hidden)
            .accessibilityHidden(hidden)
    }
}

Usage:

Text("Hello, World!")
    .hidden(true)

The bad part of the above solution .isHidden(true, remove: true) is onAppear callback will not be called when remove = true.

.opacity(isHidden ? 0 : 1) is definitely the right way.

You also have the opacity modifier on any View:

ActivityIndicator(tint: .black)
   .opacity(self.isLoading ? 1.0 : 0.0)

The following also works even without a placeholder view or calling hidden (iOS13.1 and Swift 5)

struct Foo: View {
    @State var condition: Bool

    var body: some View {
        if self.condition {
            Text("Hello")
        }
    }
}

It's hard to know exactly without peeking at the @ViewBuilder implementation, but when evaluating a conditional, it seems that we are getting an EmptyView if it fails by default.

So this is equivalent to some of the answers here, but it's simpler.

the opacity modifier is good if you want to reserve the space. If however you want to remove the view then my approach would me to simply to only show it if condition is met

if requiredCondition {
 aViewOnlyShownIfConditionRequirmentIsMet()
}

So not even in the view hierarchy. If need be make requiredCondition a @State Variables