Xcode [Apple]
Xcode 15 allows you to preview your iOS app’s user interface as you build it. Here’s how to use it to see how your app appears to users.
Xcode 15 introduced UI Previews which allow you to view what your user interface will look like as you build it in SwiftUI.
In particular Xcode added the #Preview macro that allows you to define how previews will appear for any view or view you add to your SwiftUI app.
In Swift and in C-based languages, a macro is a compiler directive that tells the compiler something special is coming and to treat code defined in the macro as a special case at compile time.
When you compile your code the compiler translates any macros it finds into code based on what’s inside the macro. Macros allow you to define a block of code once, and then reuse it multiple times in an app.
SwiftUI allows you to define your app using text, and text definitions of views, as opposed to AppKit’s older Interface Builder visual views. By using SwiftUI and previews you can type your code into the Xcode editor pane on the left, and see its preview in the Xcode simulator on the right.
As you type and change your SwiftUI code, the UI preview changes in real time to show you your view.
This has the big advantage of allowing you to see what your app will look like without having to run the compile/build/run cycle each time you make a code change.
Typically in SwiftUI, you can define the ContentView of a View using a Swift struct. For example:
struct ContentView: View {Below that, by default you can define #Preview macro as simply returning the ContentView, which Xcode will use to display the view in its preview pane:
This is the default #Preview macro you should supply for your view to appear in the preview pane in Xcode. You can also add more code to your #Preview macro for each view to further customize how Xcode will display your view.
When you compile your code, the Swift compiler actually expands the #Preview macro to the Swift statement “Preview(_:body:)” which takes an optional name, and a ViewBuilder as parameters.
A ViewBuilder is defined by the Swift @ViewBuilder keyword, which indicates to Swift what follows are some UI elements to display.
If you want to define several #Preview macros in the same source file, you can pass in a name as a Swift String to differentiate each:
ContentView(someInput: true)
The SwiftUI documentation also has a page which explains the #Preview macro and also talks about how to use a ViewBuilder along with it.
In general, you should define one #Preview macro for each custom view you define in a SwiftUI source file.
If you don’t use a #Preview macro for each custom view you create then you’ll need to provide a Preview Provider protocol for each view – which is a slightly more involved process and requires a bit more code.
We covered Preview Providers in a previous article which we mention below so we don’t cover them again here.
Once you have your #Preview macros defined in your code for each of your views, you can display the Xcode preview canvas by selecting Editor->Canvas from the main Xcode menu bar.
Show the Canvas from the Editor menu.
In general, in Swift, a view in an app is defined by the Swift class View, which is synonymous with a UIView in Objective-C or an NSView for macOS apps in Objective-C.
Each Swift View can contain one or more subviews in its ContentView. The ContentView is the view that gets displayed onscreen when your app runs.
Actually, in Swift, a View is defined as both a struct and a protocol on a structure, not as a class. In Swift, structs are more flexible than classes but can be made to behave like classes while adding additional data and behaviors more easily.
A protocol is a set of methods or properties defined for a structure or class that you must implement.
To provide a custom view in Swift, you declare a type that conforms to the View protocol, and implements the required body computed property to provide the content of your view.
In this example we define a custom struct named MyView which inherits from the Apple class View, and which conforms to the View protocol by defining the computed property body (also as a View) which has a single Text subview with the text “Hello, World!” in it.
When this struct runs, a single Text view is displayed with the text “Hello, World!” In the user interface.
Apple provides various predefined views (such as Text), which you can use in your view’s body to create your UI.
In the Xcode Preview canvas, when you change any of the code in the MyView struct, the canvas updates the view in real-time to show you your changes.
The upshot of using Xcode previews is you can see your UI in Xcode as you type – without having to build and run your app. This saves huge amounts of time during development.
SwiftUI and Previews make development easier and lighter – and greatly reduce the number of steps needed to assemble a UI in code.
For a complete discussion of how views work in Xcode, see Apple’s SwiftUI documentation section View fundamentals.
Documentation and resources
Apple has a twenty-seven-minute video from WWDC ’23 called “Build programmatic UI with Xcode Previews” which summarizes how to use Xcode Previews to see your UI as you build it.
Apple has a complete guide in the Xcode docs on how to preview your UI as you develop it in Xcode titled “Previewing your app’s interface in Xcode.”
Also, see our previous article “How to use Xcode Previews to see how your app appears as you make it.”
Xcode [Apple]
Xcode 15 te permite previsualizar la interfaz de usuario de tu aplicación iOS mientras la construyes. Aquí te mostramos cómo usarla para ver cómo aparece tu app para los usuarios.
Xcode 15 introdujo Previews de IU que te permiten ver cómo se verá tu interfaz de usuario a medida que la construyes en SwiftUI.
En particular, Xcode añadió el macro #Preview que te permite definir cómo aparecerán las previsualizaciones de cualquier vista que añadas a tu app SwiftUI.
En Swift y en los lenguajes basados en C, un macro es una directiva del compilador que le indica al compilador que algo especial está por venir y que trate el código definido en el macro como un caso especial en tiempo de compilación.
Cuando compilas tu código, el compilador traduce cualquier macro que encuentre en código en base a lo que está dentro del macro. Los macros te permiten definir un bloque de código una vez y luego reutilizarlo múltiples veces en una app.
SwiftUI te permite definir tu app usando texto y definiciones de vistas, en lugar de las vistas visuales más antiguas del Interface Builder de AppKit. Al usar SwiftUI y previsualizaciones, puedes escribir tu código en el panel del editor de Xcode a la izquierda y ver su previsualización en el simulador de Xcode a la derecha.
A medida que escribes y cambias tu código de SwiftUI, la previsualización de UI cambia en tiempo real para mostrarte tu vista.
Esto tiene la gran ventaja de permitirte ver cómo se verá tu app sin tener que ejecutar el ciclo de compilación/construcción/ejecución cada vez que hagas un cambio en el código.
Típicamente en SwiftUI, puedes definir el ContentView de una Vista usando un struct de Swift. Por ejemplo:
struct ContentView: View {Debajo de eso, por defecto puedes definir el macro #Preview simplemente devolviendo el ContentView, el cual Xcode usará para mostrar la vista en su panel de previsualización:
Este es el macro #Preview por defecto que debes proporcionar para que tu vista aparezca en el panel de previsualización en Xcode. También puedes añadir más código a tu macro #Preview para cada vista para personalizar aún más cómo Xcode mostrará tu vista.
Cuando compilas tu código, el compilador de Swift expande realmente el macro #Preview a la instrucción Swift “Preview(_:body:)” que toma un nombre opcional y un ViewBuilder como parámetros.
Un ViewBuilder se define por la palabra clave Swift @ViewBuilder, la cual indica a Swift que lo que sigue son algunos elementos de UI a mostrar.
Si deseas definir varios macros #Preview en el mismo archivo fuente, puedes pasar un nombre como una cadena de Swift para diferenciar cada uno:
ContentView(someInput: true)
La documentación de SwiftUI también tiene una página que explica el macro #Preview y también habla sobre cómo utilizar un ViewBuilder junto con él.
En general, debes definir un macro #Preview para cada vista personalizada que definas en un archivo fuente de SwiftUI.
Si no utilizas un macro #Preview para cada vista personalizada que creas, entonces necesitarás proporcionar un protocolo de Proveedor de Previsualización para cada vista, lo cual es un proceso un poco más complicado y requiere un poco más de código.
Cubrimos los Proveedores de Previsualización en un artículo anterior que mencionamos abajo para no repetirlos aquí.
Una vez que hayas definido tus macros #Preview en tu código para cada una de tus vistas, puedes mostrar el lienzo de previsualización de Xcode seleccionando Editor->Lienzo en la barra de menú principal de Xcode.
Muestra el Lienzo desde el menú Editor.
En general, en Swift, una vista en una app está definida por la clase View de Swift, que es sinónimo de una UIView en Objective-C o de un NSView para apps de macOS en Objective-C.
Cada Vista de Swift puede contener una o más subvistas en su ContentView. El ContentView es la vista que se muestra en pantalla cuando se ejecuta tu app.
De hecho, en Swift, una Vista se define tanto como un struct como un protocolo en una estructura, no como una clase. En Swift, los structs son más flexibles que las clases pero se pueden hacer que se comporten como clases mientras se añaden datos y comportamientos adicionales más fácilmente.
Un protocolo es un conjunto de métodos o propiedades definidos para una estructura o clase que debes implementar.
Para proporcionar una vista personalizada en Swift, declaras un tipo que cumple con el protocolo View, e implementas la propiedad computada requerida body para proporcionar el contenido de tu vista.
En este ejemplo definimos un struct personalizado llamado MyView que hereda de la clase View de Apple, y que cumple con el protocolo View definiendo la propiedad computada body (también como View) que tiene una sola subvista Text con el texto “¡Hola, Mundo!” en ella.
Cuando se ejecuta este struct, se muestra una sola vista de Text con el texto “¡Hola, Mundo!” en la interfaz de usuario.
Apple proporciona varias vistas predefinidas (como Text), que puedes usar en el cuerpo de tu vista para crear tu interfaz de usuario.
En el lienzo de previsualización de Xcode, cuando cambias cualquier parte del código en el struct MyView, el lienzo actualiza la vista en tiempo real para mostrarte tus cambios.
La ventaja de usar previsualizaciones de Xcode es que puedes ver tu interfaz de usuario en Xcode mientras escribes, sin necesidad de compilar y ejecutar tu app. Esto ahorra una gran cantidad de tiempo durante el desarrollo.
SwiftUI y las previsualizaciones hacen que el desarrollo sea más fácil y ligero, y reducen enormemente la cantidad de pasos necesarios para ensamblar una interfaz de usuario en código.
Para obtener una discusión completa sobre cómo funcionan las vistas en Xcode, consulta la sección de fundamentos de Vista de la documentación de SwiftUI de Apple.
Documentación y recursos
Apple tiene un video de veintisiete minutos de la WWDC ’23 llamado “Construir una interfaz de usuario programáticamente con previsualizaciones de Xcode” que resume cómo utilizar las previsualizaciones de Xcode para ver tu interfaz de usuario mientras la construyes.
Apple tiene una guía completa en la documentación de Xcode sobre cómo previsualizar tu interfaz de usuario mientras la desarrollas en Xcode titulada “Previsualización de la interfaz de la app en Xcode”.
También, consulta nuestro artículo anterior “Cómo utilizar las previsualizaciones de Xcode para ver cómo aparece tu app mientras la creas”.