Swift (lenguaje de programación)

Las plataformas compatibles con Swift son los sistemas operativos de Apple ( Darwin , iOS , iPadOS , macOS , tvOS , watchOS ), Linux , Windows , WebAssembly y Android . ^{[ 54 ] [ 55 ]}

Un aspecto clave del diseño de Swift es su capacidad de interoperar con el enorme conjunto de código Objective-C existente desarrollado para productos de Apple durante las décadas anteriores, como Cocoa y los frameworks Cocoa Touch . En las plataformas de Apple, ^{[ 56 ]} se enlaza con la biblioteca de tiempo de ejecución de Objective-C , lo que permite que el código C , Objective-C , C++ y Swift se ejecute dentro de un mismo programa. ^{[ 57 ]}

La sintaxis de Swift es similar a la de los lenguajes de estilo C. El código comienza a ejecutarse en el ámbito global por defecto. ^{[ 80 ]} Alternativamente, el atributo se puede aplicar a una declaración de estructura, clase o enumeración para indicar que contiene el punto de entrada del programa. ^{[ 81 ]}@main

El programa "¡Hola, mundo!" de Swift es:

imprimir ( "¡Hola, mundo!" )

La función utilizada aquí está incluida en la biblioteca estándar de Swift, que está disponible para todos los programas sin necesidad de importar módulos externos. Las sentencias en Swift no tienen que terminar con un punto y coma; sin embargo, se requieren puntos y coma para separar varias sentencias escritas en la misma línea. Los comentarios de una sola línea comienzan con y continúan hasta el final de la línea actual. Los comentarios de varias líneas están contenidos entre los caracteres y . Las constantes ( variables que no se pueden modificar) se declaran con la palabra clave , mientras que las variables declaradas con la palabra clave pueden cambiar. Los valores deben inicializarse antes de leerlos. Las variables pueden inferir su tipo en función del tipo del valor inicial proporcionado. Si el valor inicial se establece después de la declaración del valor, se debe declarar un tipo explícitamente. ^{[ 80 ]}print(_:separator:terminator:)///**/letvar

let highScoreThreshold = 1000 // Una constante de tipo Int. El tipo se infirió en función del valor proporcionado.var currentScore = 980 // Una variable de tipo Int.currentScore = 1200 // El valor de las variables puede cambiar con el tiempo.let playerMessage : String // Una constante con tipo explícito String.Si currentScore > highScoreThreshold {playerMessage = "¡Eres un jugador de primera!"} demás {playerMessage = "Mejor suerte la próxima vez."}print ( playerMessage ) // Imprime "¡Eres un jugador de primera!"

El flujo de control en Swift se gestiona con sentencias if-else , guard y switch , junto con bucles while y for-in . Estas ifsentencias reciben un parámetro booleano y ejecutan el cuerpo de la ifsentencia si la condición es verdadera; de lo contrario, ejecutan el elsecuerpo opcional. La sintaxis proporciona azúcar sintáctico para comprobar la existencia de un valor opcional y desenvolverlo simultáneamente.if-let

sea ​​algúnNúmero = 42Si someNumber % 2 == 0 { // Usa el operador de resto para encontrar el resto de someNumber dividido por 2.print ( " \( someNumber ) es par." )} demás {print ( " \( someNumber ) es impar." )}// Imprime "42 es par."

Las funciones se definen con la funcpalabra clave `function`. Los parámetros de función pueden tener nombres que permiten que las llamadas a funciones se lean como frases. Un guion bajo antes del nombre del parámetro permite omitir la etiqueta del argumento en la llamada. Las funciones pueden usar tuplas para devolver varios datos a la vez.

func constructGreeting ( for name : String ) -> String {devolver "¡Hola \( nombre ) !"}let saludo = construirSaludo ( para : "Craig" )imprimir ( saludo ) // Imprime "¡Hola Craig!"

Las funciones, y las funciones anónimas conocidas como cierres , se pueden asignar a propiedades y pasar por el programa como cualquier otro valor.

func divideByTwo ( _ aNum : Int ) -> Int {devolver unNum / 2}func multiplicarPorDos ( _ aNum : Int ) -> Int {devolver unNum * 2}sea ​​operaciónmatemática = multiplicarPorDosprint ( mathOperation ( 21 )) // Imprime "42"

guardLas sentencias requieren que la condición dada sea verdadera antes de continuar después de la sentencia; de lo contrario, se ejecuta guardel cuerpo de la cláusula proporcionada . La cláusula debe salir del control del bloque de código en el que aparece la sentencia. Las sentencias son útiles para garantizar que se cumplan ciertos requisitos antes de continuar con la ejecución del programa. En particular, se pueden usar para crear una versión sin encapsular de un valor opcional que se garantiza que no será nulo durante el resto del ámbito que la contiene.elseelseguardguard

func divide ( numerador : Int ?, porDenominador denominador : Int ) -> Int ? {guard denominador != 0 else {print ( "No se puede dividir por 0." )devolver cero}guarda el numerador de lo contrario {imprimir ( "El numerador proporcionado es nulo." )devolver cero}Devuelve el numerador / denominador}sea ​​resultado = dividir ( numerador : 3 , porDenominador : 0 )print ( "El resultado de la división es: \( resultado ) " )// Impresiones:// "No se puede dividir por 0."// "El resultado de la división es: nulo."

switchLas sentencias comparan un valor con múltiples valores potenciales y luego ejecutan un bloque de código asociado. switchLas sentencias deben ser exhaustivas, ya sea incluyendo casos para todos los valores posibles o incluyendo un defaultcaso que se ejecute cuando el valor proporcionado no coincida con ninguno de los otros casos. switchLos casos no se ejecutan implícitamente, aunque pueden hacerlo explícitamente con la fallthroughpalabra clave. La coincidencia de patrones se puede usar de varias maneras dentro de switchlas sentencias. Aquí hay un ejemplo de un número entero que se compara con varios rangos potenciales:

sea ​​algúnNúmero = 42cambiar algúnNúmero {caso ..< 0 :imprimir ( " \( algúnNúmero ) negativo." )caso 0 :print ( " \( someNumber ) es 0." )caso 1. .. 9 :print ( " \( algúnNúmero ) mayor que 0, pero menor que 10." )por defecto :print ( " \( someNumber ) es mayor que 9." )}// Imprime "42 es mayor que 9."

for-inLos bucles iteran sobre una secuencia de valores:

let nombres = [ "Will" , "Anna" , "Bart" ]para nombre en nombres {imprimir ( nombre )}// Impresiones:// Voluntad// Anna// Bart

whileLos bucles se repiten mientras la condición booleana dada se evalúe como true:

// Suma todos los números del 1 al 5.var i = 1var resultado = 0mientras i <= 5 { // El bucle ejecuta su cuerpo mientras i sea menor o igual a 5. resultado += i // Sumar i al resultado actual.i += 1 // Incrementa i en 1.}imprimir ( resultado ) // Imprime "15"

Swift admite cierres , que son bloques de funcionalidad autocontenidos que se pueden pasar y usar en el código, ^{[ 82 ]} y también se pueden usar como funciones anónimas . Aquí hay algunos ejemplos:

// El tipo de cierre, definido por sus valores de entrada y salida, se puede especificar fuera del cierre:let closure1 : ( Int , Int ) -> Int = { arg1 , arg2 endevolver arg1 + arg2}// …o dentro de él:let closure2 = { ( arg1 : Int , arg2 : Int ) -> Int indevolver arg1 + arg2}// En la mayoría de los casos, el compilador puede inferir automáticamente el tipo de retorno de la función anónima.let closure3 = { arg1 : Int , arg2 : Int indevolver arg1 + arg2}

Los cierres se pueden asignar a variables y constantes, y se pueden pasar a otras funciones o cierres como parámetros. Los cierres de una sola expresión pueden omitir la returnpalabra clave.

Swift también cuenta con una sintaxis de cierre final, que permite escribir el cierre después de la llamada a la función en lugar de dentro de la lista de parámetros de la función. Los paréntesis pueden omitirse por completo si el cierre es el único parámetro de la función.

// Esta función toma un cierre que no recibe parámetros de entrada y devuelve un entero,// lo evalúa y utiliza el valor de retorno del cierre (un Int) como valor de retorno de la función.func foo ( closure bar : () -> Int ) -> Int {barra de retorno ()}// Sin sintaxis de cierre final:foo ( cierre : { return 1 })// Con sintaxis de cierre final y retorno implícito:foo { 1 }

A partir de la versión 5.3, Swift admite múltiples cierres finales: ^{[ 83 ]}

// Esta función pasa el valor de retorno del primer cierre como parámetro del segundo, // y devuelve el resultado del segundo cierre: func foo ( bar : () -> Int , baz : ( Int ) -> Int ) -> Int { return baz ( bar ()) }// Sin cierres finales: foo ( bar : { return 1 }, baz : { x in return x + 1 })// Con 1 cierre final: foo ( bar : { return 1 }) { x in return x + 1 }// Con 2 cierres finales (solo se omite el nombre del argumento del primer cierre): foo { return 1 } baz : { x in return x + 1 }

Swift proporcionará nombres de argumentos abreviados para cierres en línea, eliminando la necesidad de nombrar explícitamente todos los parámetros de los cierres. ^{[ 84 ]} Los argumentos pueden ser referenciados con los nombres $0, $1, $2, etc.:

let nombres = [ "Josephine" , "Steve" , "Chris" , "Barbara" ]// filter llama a la función anónima dada para cada valor en names. // Se conservan los valores con un recuento de caracteres menor a 6, los demás se descartan. let shortNames = names . filter { $0 . count < 6 }print ( shortNames ) // Imprime "["Steve", "Chris"]"

Los cierres pueden capturar valores de su ámbito circundante. El cierre hará referencia a este valor capturado mientras exista el cierre:

func makeMultiplier ( withMultiple multiple : Int ) -> ( Int ) -> ( Int ) { // Crea y devuelve una función anónima que recibe un Int y devuelve la entrada multiplicada por el valor de multiple. return { $0 * multiple } }let multiplier = makeMultiplier ( withMultiple : 3 ) print ( multiplier ( 3 )) // Imprime "9" print ( multiplier ( 10 )) // Imprime "30"

StringLa biblioteca estándar de Swift incluye tipos compatibles con Unicode Character. Los valores de cadena se pueden inicializar con un literal de cadena, una secuencia de caracteres entre comillas dobles. Las cadenas se pueden concatenar con el +operador:

var someString = "Hola", someString += "mundo!"

La interpolación de cadenas permite crear una nueva cadena a partir de otros valores y expresiones. Los valores escritos entre paréntesis precedidos por una \se insertarán en la cadena literal que los contiene: ^{[ 85 ]}

var currentScore = 980 print ( "Tu puntuación es \( currentScore ) ." )// Imprime "Tu puntuación es 980."

Se puede utilizar un bucle for-in para iterar sobre los caracteres contenidos en una cadena:

para cada carácter en "Swift" { imprimir ( carácter ) } // S // w // i // f // t

Si se importa el framework Foundation, Swift crea un puente invisible entre el tipo String y NSString (la clase String que se usa comúnmente en Objective-C).

Swift admite cinco niveles de control de acceso para símbolos: open, public, internal, fileprivate, y private. A diferencia de muchos lenguajes orientados a objetos, estos controles de acceso ignoran las jerarquías de herencia : privateindica que un símbolo es accesible solo en el ámbito inmediato , fileprivateindica que es accesible solo desde dentro del archivo , internalindica que es accesible dentro del módulo contenedor , publicindica que es accesible desde cualquier módulo y open(solo para clases y sus métodos) indica que la clase puede ser subclaseada fuera del módulo. ^{[ 87 ]}

Una característica importante de Swift son los tipos opcionales , que permiten que las referencias o los valores funcionen de forma similar al patrón común en C , donde un puntero puede referirse a un valor específico o a ningún valor. Esto implica que los tipos no opcionales no pueden provocar un error de puntero nulo ; el compilador puede garantizar que esto no sea posible.

Los tipos opcionales se crean con la Optionalenumeración. Para hacer un Integer que sea anulable, se usaría una declaración similar a . Al igual que en C#, ^{[ 88 ]} Swift también incluye azúcar sintáctico para esto, lo que permite indicar que una variable es opcional colocando un signo de interrogación después del nombre del tipo, . ^{[ 89 ]} Las variables o constantes que están marcadas como opcionales tienen un valor del tipo subyacente o son . Los tipos opcionales envuelven el tipo base, lo que resulta en una instancia diferente. y son tipos fundamentalmente diferentes, el primero es de tipo mientras que el segundo es un que puede contener algún valor.var optionalInteger: Optional<Int>var optionalInteger: Int?nilStringString?StringOptionalString

Para acceder al valor interno, suponiendo que no sea nulo, debe desenvolverse para exponer la instancia interna. Esto se realiza con el !operador:

let myValue = anOptionalInstance ! .someMethod ()

En este caso, el !operador desempaqueta anOptionalInstancepara exponer la instancia interna, permitiendo que se realice la llamada al método sobre ella. Si anOptionalInstancees nulo, se produce un error de puntero nulo, lo que finaliza el programa. Esto se conoce como desempaquetado forzado. Los opcionales se pueden desempaquetar de forma segura mediante el encadenamiento de opcionales, que primero comprueba si la instancia es nula y, si no lo es, la desempaqueta.

let myValue = anOptionalInstance ? .someMethod ()

En este caso, el tiempo de ejecución llama someMethodsolo si anOptionalInstanceno es nulo, suprimiendo el error. Se ?debe colocar un después de cada propiedad opcional. Si alguna de estas propiedades es nula, toda la expresión se evalúa como nula. El origen del término encadenamiento proviene del caso más común en el que se encadenan varias llamadas a métodos/obtenidos. Por ejemplo:

let aTenant = aBuilding.tenantList [ 5 ] let theirLease = aTenant.leaseDetails let leaseStart = theirLease ? .startDate​​​​

se puede reducir a:

let leaseStart = aBuilding . tenantList [ 5 ]. leaseDetails ?. startDate

El uso de opcionales en Swift permite al compilador utilizar el despacho estático porque la acción de desenvolvimiento se llama en una instancia definida (el contenedor), en lugar de ocurrir en un sistema de despacho en tiempo de ejecución.

En muchos lenguajes orientados a objetos, estos se representan internamente en dos partes. El objeto se almacena como un bloque de datos en el montón , mientras que su identificador (o "handle") se representa mediante un puntero . Los objetos se pasan entre métodos copiando el valor del puntero, lo que permite que cualquier usuario con una copia acceda a los mismos datos subyacentes en el montón. En cambio, los tipos básicos como los enteros y los valores de coma flotante se representan directamente; el identificador contiene los datos, no un puntero a ellos, y estos se pasan directamente a los métodos mediante copia. Estos estilos de acceso se denominan paso por referencia en el caso de los objetos y paso por valor para los tipos básicos.

Ambos conceptos tienen sus ventajas y desventajas. Los objetos son útiles cuando los datos son extensos, como la descripción de una ventana o el contenido de un documento. En estos casos, el acceso a esos datos se proporciona copiando un valor de 32 o 64 bits, en lugar de copiar una estructura de datos completa. Sin embargo, los valores más pequeños, como los enteros, tienen el mismo tamaño que los punteros (normalmente ambos ocupan una palabra ), por lo que no hay ninguna ventaja en pasar un puntero en lugar de pasar el valor.

Swift ofrece soporte integrado para objetos que utilizan semántica de paso por referencia o paso por valor; la primera utiliza la classdeclaración y la segunda struct, . Las estructuras en Swift tienen casi todas las mismas características que las clases: métodos, implementación de protocolos y uso de mecanismos de extensión. Por esta razón, Apple denomina a todos los datos genéricamente como instancias , en contraposición a objetos o valores. Sin embargo, las estructuras no admiten herencia. ^{[ 90 ]}

El programador es libre de elegir qué semántica es más apropiada para cada estructura de datos en la aplicación. Las estructuras más grandes, como las ventanas, se definirían como clases, lo que permitiría pasarlas como punteros. Las estructuras más pequeñas, como un punto 2D, se pueden definir como estructuras, que serán de paso por valor y permitirán el acceso directo a sus datos internos sin indirección ni conteo de referencias. La mejora de rendimiento inherente al concepto de paso por valor es tal que Swift utiliza estos tipos para casi todos los tipos de datos comunes, incluidos Inty Double, y tipos normalmente representados por objetos, como Stringy Array. ^{[ 90 ]} El uso de tipos de valor también puede resultar en mejoras de rendimiento significativas en las aplicaciones de usuario. ^{[ 91 ]}

Array, Dictionary, y Settodos utilizan la copia en escritura, de modo que sus datos se copian solo si el programa intenta cambiar un valor en ellos. Esto significa que los distintos accesores tienen, en efecto, un puntero al mismo almacenamiento de datos. Así, aunque los datos se almacenan físicamente como una sola instancia en la memoria, a nivel de la aplicación, estos valores están separados y la separación física se impone mediante la copia en escritura solo cuando es necesario. ^{[ 92 ]}

Las extensiones añaden nueva funcionalidad a un tipo existente, sin necesidad de crear subclases ni siquiera tener acceso al código fuente original. Las extensiones pueden añadir nuevos métodos, inicializadores, propiedades calculadas, subíndices y conformidades de protocolo. ^{[ 93 ]} Un ejemplo podría ser añadir un corrector ortográfico al Stringtipo base, lo que significa que todas las instancias del Stringprograma adquieren la capacidad de realizar la corrección ortográfica. El sistema también se utiliza ampliamente como técnica de organización, permitiendo agrupar código relacionado en extensiones similares a bibliotecas.

Las extensiones se declaran con la extensionpalabra clave.

struct Rectángulo {ancho : Doble​altura : Doble​}Extensión Rectángulo {var área : Doble {devolver altura * ancho}}

Los protocolos garantizan que un tipo específico implemente un conjunto de métodos o propiedades, lo que significa que otras instancias del sistema pueden llamar a esos métodos en cualquier instancia que implemente dicho protocolo. Esto se utiliza a menudo en los lenguajes de programación orientados a objetos modernos como alternativa a la herencia múltiple , aunque las características no son del todo idénticas.

En Objective-C, y en la mayoría de los demás lenguajes que implementan el concepto de protocolo, es responsabilidad del programador asegurar que los métodos requeridos se implementen en cada clase. ^{[ 94 ]} Swift añade la capacidad de agregar estos métodos mediante extensiones y de utilizar programación genérica (genéricos) para implementarlos. En conjunto, esto permite escribir los protocolos una sola vez y admitir una amplia variedad de instancias. Además, el mecanismo de extensión se puede utilizar para agregar conformidad con el protocolo a un objeto que no lo incluya en su definición. ^{[ 95 ]}

Por ejemplo, se podría declarar un protocolo llamado Printable, que garantiza que las instancias que se ajusten al protocolo implementen un requisito descriptionde propiedad y printDetails()método:

// Define un protocolo llamado Printable protocol Printable { var description : String { get } // Requisito de propiedad de solo lectura func printDetails () // Requisito de método }

Este protocolo ahora puede ser adoptado por otros tipos:

// Adoptar el protocolo Printable en una clase class MyClass : Printable { var description : String { return "Una instancia de MyClass" }func printDetails () { print ( descripción ) } }

Las extensiones pueden utilizarse para añadir conformidad con el protocolo a los tipos. Los propios protocolos también pueden extenderse para proporcionar implementaciones predeterminadas de sus requisitos. Los usuarios pueden definir sus propias implementaciones o utilizar la implementación predeterminada.

extensión Printable { // Todas las instancias de Printable recibirán esta implementación, o pueden definir la suya propia. func printDetails () { print ( descripción ) } }// Bool ahora cumple con Printable y hereda la implementación de printDetails() anterior. extensión Bool : Printable { var descripción : String { return "Una instancia de Bool con valor: \( self ) " }}

En Swift, al igual que en muchos lenguajes modernos que admiten interfaces, los protocolos se pueden usar como tipos, lo que significa que las variables y los métodos se pueden definir por protocolo en lugar de por su tipo específico:

func getSomethingPrintable () -> any Printable { return true }var someSortOfPrintableInstance = getSomethingPrintable ( ) print ( someSortOfPrintableInstance.description )​// Imprime "Una instancia de Bool con valor: true"

No importa qué tipo concreto someSortOfPrintableInstancesea, el compilador se asegurará de que cumpla con el protocolo y, por lo tanto, este código es seguro. Esta sintaxis también significa que las colecciones pueden basarse en protocolos, como let printableArray = [any Printable].

Tanto las extensiones como los protocolos se utilizan ampliamente en la biblioteca estándar de Swift; en Swift 5.9, aproximadamente el 1,2 por ciento de todos los símbolos dentro de la biblioteca estándar eran protocolos, y otro 12,3 por ciento eran requisitos de protocolo o implementaciones predeterminadas. ^{[ 96 ]} Por ejemplo, Swift utiliza extensiones para agregar el Equatableprotocolo a muchos de sus tipos básicos, como Strings y Arrays, lo que permite compararlos con el ==operador. El Equatableprotocolo también define esta implementación predeterminada:

func !=< T : Equatable >( lhs : T , rhs : T ) -> Bool

Esta función define un método que funciona en cualquier instancia que cumpla con Equatable, proporcionando un operador de desigualdad . Cualquier instancia, clase o estructura, obtiene automáticamente esta implementación simplemente por cumplir con Equatable. ^{[ 97 ]}

Los protocolos, las extensiones y los genéricos se pueden combinar para crear API sofisticadas. Por ejemplo, las restricciones permiten que los tipos adopten condicionalmente protocolos o métodos en función de las características del tipo que los adopta. Un caso de uso común puede ser agregar un método a los tipos de colección solo cuando los elementos contenidos en la colección sean Equatable:

extensión Array donde Elemento : Equatable {// allEqual estará disponible solo en instancias de Array que contengan elementos Equatable. func allEqual () -> Bool { for element in self { if element != self . first { return false } } return true } }

Swift 5.5 introdujo la concurrencia estructurada en el lenguaje. ^{[ 98 ]} La concurrencia estructurada utiliza la sintaxis Async/await, similar a la de Kotlin, JavaScript y Rust. Una función asíncrona se define con la asyncpalabra clave después de la lista de parámetros. Al llamar a una función asíncrona, la awaitpalabra clave debe escribirse antes de la función para indicar que la ejecución podría suspenderse durante la llamada. Mientras una función está suspendida, el programa puede ejecutar otra función concurrente en el mismo programa. Esta sintaxis permite a los programas señalar claramente los posibles puntos de suspensión y evitar una versión de la Pirámide de la Perdición causada por el uso generalizado anterior de las funciones de devolución de llamada de cierre. ^{[ 99 ]}

func downloadText ( name : String ) async -> String { let result = // ... algún código de descarga asíncrona ... return result }let texto = await downloadText ( "texto1" )

La async letsintaxis permite que varias funciones se ejecuten en paralelo. awaitSe utiliza de nuevo para marcar el punto en el que el programa se suspenderá para esperar a que finalicen las asyncfunciones llamadas anteriormente.

// Cada una de estas llamadas a downloadText se ejecutará en paralelo. async let text1 = downloadText ( name : "text1" ) async let text2 = downloadText ( name : "text2" ) async let text3 = downloadText ( name : "text3" )let textToPrint = await [ text1 , text2 , text3 ] // Suspende hasta que las tres llamadas a downloadText hayan finalizado. print ( textToPrint )

Las tareas y los grupos de tareas se pueden crear explícitamente para generar un número dinámico de tareas secundarias durante la ejecución:

let taskHandle = Task { await downloadText ( name : "someText" ) }let resultado = await taskHandle.valor​​

Swift utiliza el modelo Actor para aislar el estado mutable, permitiendo que diferentes tareas modifiquen el estado compartido de forma segura. Los actores se declaran con la actorpalabra clave `actor` y son tipos de referencia, como las clases. Solo una tarea puede acceder al estado mutable de un actor a la vez. Los actores pueden acceder y modificar su propio estado interno libremente, pero el código que se ejecuta en tareas separadas debe marcar cada acceso con la awaitpalabra clave `actor` para indicar que el código puede suspenderse hasta que otras tareas terminen de acceder al estado del actor.

Directorio de actores { var nombres : [ String ] = [] func add ( nombre : String ) { nombres . append ( nombre ) } }let directorio = Directorio ()// El código se suspende hasta que otras tareas terminen de acceder al actor. await directory . add ( name : "Tucker" ) print ( await directory . names )

En los sistemas Apple, Swift utiliza el mismo entorno de ejecución que el sistema Objective-C existente , pero requiere iOS 7 o macOS 10.9 o superior. También depende de Grand Central Dispatch . ^{[ 100 ]} El código Swift y Objective-C se puede utilizar en un mismo programa y, por extensión, también el C y el C++. A partir de Swift 5.9, el código C++ se puede utilizar directamente desde el código Swift. ^{[ 101 ]} En el caso de Objective-C, Swift tiene un acceso considerable al modelo de objetos y se puede utilizar para crear subclases, extender y utilizar código Objective-C para proporcionar soporte de protocolo. ^{[ 102 ]} Lo contrario no es cierto: una clase Swift no se puede subclasear en Objective-C. ^{[ 103 ]}

Para facilitar el desarrollo de dichos programas y la reutilización de código existente, Xcode 6 y versiones posteriores ofrecen un sistema semiautomatizado que crea y mantiene un archivo de cabecera puente para exponer el código Objective-C a Swift. Este archivo consiste en un archivo de cabecera adicional que simplemente define o importa todos los símbolos Objective-C necesarios para el código Swift del proyecto. En ese momento, Swift puede referirse a los tipos, funciones y variables declarados en esas importaciones como si estuvieran escritos en Swift. El código Objective-C también puede usar código Swift directamente, importando un archivo de cabecera mantenido automáticamente con declaraciones Objective-C de los símbolos Swift del proyecto. Por ejemplo, un archivo Objective-C en un proyecto mixto llamado "MyApp" podría acceder a clases o funciones Swift con el código #import "MyApp-Swift.h". Sin embargo, no todos los símbolos están disponibles a través de este mecanismo: el uso de características específicas de Swift, como tipos genéricos, tipos opcionales que no son objetos, enumeraciones sofisticadas o incluso identificadores Unicode, puede hacer que un símbolo sea inaccesible desde Objective-C. ^{[ 104 ]}

Swift también tiene soporte limitado para atributos , metadatos que lee el entorno de desarrollo y que no necesariamente forman parte del código compilado. Al igual que Objective-C, los atributos usan la @sintaxis, pero el conjunto disponible actualmente es pequeño. Un ejemplo es el @IBOutletatributo, que marca un valor dado en el código como un outlet , disponible para su uso dentro de Interface Builder (IB). Un outlet es un dispositivo que vincula el valor de la visualización en pantalla a un objeto en el código.

En sistemas que no son de Apple, Swift no depende de un entorno de ejecución de Objective-C ni de otras bibliotecas del sistema de Apple; un conjunto de implementaciones de Swift "Corelib" las reemplazan. Estas incluyen "swift-corelibs-foundation" para reemplazar Foundation Kit , "swift-corelibs-libdispatch" para reemplazar Grand Central Dispatch y "swift-corelibs-xctest" para reemplazar las API de XCTest de Xcode . ^{[ 105 ]}

A partir de 2019, con Xcode 11, Apple también ha añadido un nuevo paradigma de interfaz de usuario importante llamado SwiftUI. SwiftUI reemplaza el antiguo paradigma Interface Builder con un nuevo paradigma de desarrollo declarativo. ^{[ 106 ]}

Swift utiliza el Conteo Automático de Referencias (ARC) para gestionar la memoria . Cada instancia de una clase o cierre mantiene un contador de referencias que lleva la cuenta de las referencias que el programa mantiene abiertas. Cuando este contador llega a cero, la instancia se libera. Esta liberación automática elimina la necesidad de un recolector de basura, ya que las instancias se liberan tan pronto como dejan de ser necesarias.

Un ciclo de referencia fuerte puede ocurrir si dos instancias se referencian fuertemente entre sí (por ejemplo, A referencia a B, B referencia a A). Dado que el contador de referencias de ninguna instancia puede llegar a cero, ninguna se libera, lo que resulta en una fuga de memoria . Swift proporciona las palabras clave weaky unownedpara evitar ciclos de referencia fuertes. Estas palabras clave permiten que una instancia sea referenciada sin incrementar su contador de referencias. weakLas referencias deben ser variables opcionales, ya que pueden cambiar y convertirse en nil. ^{[ 107 ]} Intentar acceder a un unownedvalor que ya ha sido liberado resulta en un error en tiempo de ejecución.

Un cierre dentro de una clase también puede crear un ciclo de referencia fuerte al capturar autorreferencias. Las autorreferencias que se consideren débiles o sin propietario pueden indicarse mediante una lista de captura.

clase Persona {let nombre : Cadenaweak var home : Home ? // Definida como una referencia débil para romper el ciclo de referencias. Las referencias débiles no incrementan el contador de referencias de la instancia a la que se refieren.inicializar ( nombre : String ) {nombre = nombre​​}desinit { print ( "Desinicializado \( nombre ) " ) }}clase Inicio {sea ​​dirección : Cadenavar propietario : ¿Persona ?inicializar ( dirección : Cadena , propietario : Persona ?) {dirección propia = dirección​propietario = propietario​​}desinit { print ( "Desinicializado \( dirección ) " ) }}var stacy : Persona ? = Persona ( nombre : "Stacy" )var casa21b : Casa ? = Casa ( dirección : "21b Baker Street" , propietario : stacy )Stacy ?. casa = casa21b // Stacy y casa42b ahora se refieren la una a la otra.stacy = nil // El contador de referencias para stacy ahora es 1, porque house21b todavía mantiene una referencia a ella.house21b = nil // El contador de referencias de house21b cae a 0, lo que a su vez hace que el contador de stacy caiga a 0 porque house21b fue la última instancia que mantuvo una referencia fuerte a stacy.// Impresiones:// Desinicializado 21b Baker Street// Stacy desinicializada

Un elemento clave del sistema Swift es su capacidad para depurarse y ejecutarse de forma limpia dentro del entorno de desarrollo, utilizando un bucle de lectura-evaluación-impresión (REPL), lo que le confiere propiedades interactivas más cercanas a las capacidades de scripting de Python que a las de los lenguajes de programación de sistemas tradicionales . El REPL se ve mejorado aún más con Playgrounds , vistas interactivas que se ejecutan dentro del entorno Xcode o la aplicación Playgrounds y que responden a los cambios de código o del depurador en tiempo real. ^{[ 108 ]} Playgrounds permite a los programadores añadir código Swift junto con documentación en Markdown. Los programadores pueden recorrer el código paso a paso y añadir puntos de interrupción utilizando LLDB, ya sea en una consola o en un IDE como Xcode.