Una variable es un contenedor con nombre que se utiliza para almacenar un valor. Ahora cada valor tiene un tipo al que pertenece y se conoce como tipo de datos. Un tipo de datos es una clasificación de datos que le dice al compilador cómo un programador quiere usar los datos. Los tipos de datos se pueden clasificar en términos generales en tres categorías: tipos de datos primitivos, definidos por el usuario y derivados. Para utilizar un valor entero, Swift proporciona datos int, para utilizar un valor decimal, Swift proporciona un tipo de datos flotante o doble, y para utilizar una colección de letras, Swift proporciona un tipo de datos de string. La mayoría de los idiomas proporcionan una palabra clave con la que podemos referir tipos de datos con otros nombres o alias también. En Swift, tenemos la palabra clave «typealias» para referirnos a un tipo de datos con otro nombre.
Escriba el alias en Swift
Swift proporciona una funcionalidad mediante la cual podemos referirnos a un tipo de datos con otro nombre o alias. Básicamente proporciona un nuevo nombre al tipo existente y siempre recuerda que no crea un nuevo tipo. Swift proporciona una palabra clave «typealias» que es similar a la palabra clave «typedef» en C++. Podemos definir más de un alias u otro nombre para un tipo de dato en Swift. La sintaxis general para typealias se da a continuación,
Sintaxis:
typealias myDataType = tipo de datos
Aquí, typealias es una palabra clave, dataType es un tipo de datos primitivo, definido por el usuario o complejo, y myAlias es un alias para dataType, es decir, ahora podemos llamar a datatype con el nombre myDataType. En Swift, en términos generales, podemos definir un alias para los siguientes tipos de datos:
1. Escriba alias para tipos de datos primitivos
Swift proporciona una palabra clave con la que podemos referirnos a tipos de datos primitivos con un alias u otro nombre. Por ejemplo, podemos referirnos al tipo de datos Int usando myInt, Float usando myFloat, Double usando myDouble. Internamente, typealias no crea nuevos tipos de datos para los tipos de datos existentes. Simplemente proporciona los nombres alternativos para los tipos existentes.
Sintaxis:
typealias myDataType = tipo de datos
Aquí, typealias es una palabra clave, dataType es uno de los tipos de datos primitivos, Int, Float, Double, etc., myDataType es un alias para dataType, es decir, ahora podemos llamar a datatype con el nombre myDataType
Ejemplo:
En el siguiente programa, hemos usado un alias u otro nombre para tipos de datos primitivos como,
- myInt para Int
- myFloat para flotar
- myDouble para el doble
- myCharacter para personaje
- miString para String
Swift
// Swift program to illustrate typealias
// for primitive data types
// myInt is an alias to Int
// After this statement using Int or
// myInt is equivalent
typealias myInt = Int
// myFloat is an alias to Float
// After this statement using Float or
// myFloat is equivalent
typealias myFloat = Float
// myDouble is an alias to Double
// After this statement using Double or
// myDouble is equivalent
typealias myDouble = Double
// myCharacter is an alias to Character
// After this statement using Character or
// myCharacter is equivalent
typealias myCharacter = Character
// myDouble is an alias to String
// After this statement using String or
// myString is equivalent
typealias myString = String
// Declaring integerNumber of Int type
// myInt is an alias for Int
var integerNumber : myInt
// Initializing the variable
integerNumber = 5
// Print the value represented by integerNumber
print("integerNumber:", integerNumber)
// Declaring floatNumber of Float type
// myFloat is an alias for Float
var floatNumber : myFloat
// Initializing the variable
floatNumber = 5.12345
// Print the value represented by floatNumber
print("floatNumber:", floatNumber)
// Declaring doubleNumber of Double type
// myDouble is an alias for Double
var doubleNumber : myDouble
// Initializing the variable
doubleNumber = 5.123456789
// Print the value represented by doubleNumber
print("doubleNumber:", doubleNumber)
// Declaring character of Character type
// myCharacter is an alias for Character
var character : myCharacter
// Initializing the variable
character = "A"
// Print the value represented by character
print("character:", character)
// Declaring character of Int type
// myInt is an alias for Int
var string : myString
// Initializing the variable
string = "GeeksforGeeks"
// Print the value represented by string
print("string:", string)
Producción:
integerNumber: 5 floatNumber: 5.12345 doubleNumber: 5.123456789 character: A string: GeeksforGeeks
2. Escriba alias para tipos de datos definidos por el usuario
Swift proporciona una funcionalidad mediante la cual podemos referir tipos de datos definidos por el usuario con un alias u otro nombre. Por ejemplo, podemos referirnos al tipo de datos Array<Int> usando arrayInt, Array<Float>, usando arrayFloat, Array<Double> usando arrayDouble. Internamente, typealias no crea nuevos tipos de datos para los tipos de datos existentes definidos por el usuario. Simplemente proporciona los nombres alternativos para los tipos definidos por el usuario existentes.
Sintaxis:
typealias myDataType = tipo de datos
Aquí, dataType es uno de los tipos de datos definidos por el usuario, Array<Int>, Array<Float>, Array<Double>, etc., myDataType es un alias para dataType, es decir, ahora podemos llamar a datatype con el nombre myDataType
Ejemplo:
En el siguiente programa estamos creando una estructura de tipo «Empleado « . Contiene dos variables, una de tipo string y la otra de tipo Int. La variable de tipo string almacena el nombre del empleado y el tipo Int almacena el número de identidad del empleado. Hemos usado otros nombres para los tipos de datos definidos por el usuario como «empleados» para «Array<Employee>» donde «Employee» es un tipo de datos de estructura.
Swift
// Swift program to illustrate typealias for
// user-defined and derived data types
// Defining a structure
struct Employee
{
// Declaring a variable of string type
var employeeName: String
// Declaring a variable of int type
var employeeId: Int
// Defining a custom constructor
init(employeeName: String, employeeId: Int)
{
// Initializing data members with the parameters
// passed to the constructor
self.employeeName = employeeName
self.employeeId = employeeId
}
}
// Defining a class
class ComplexNumber
{
var realPart: Double
var imaginaryPart: Double
init(realPart: Double, imaginaryPart: Double)
{
self.realPart = realPart
self.imaginaryPart = imaginaryPart
}
}
// Defining alias to "Array<Employee>"
// After this statement using employees or
// Array<Employee> is equivalent
typealias employees = Array<Employee>
// myArray is an array of type Employee
var myArray: employees = []
// Instantiate an object of structure
var employee1 = Employee(employeeName: "Bhuwanesh",
employeeId: 131478)
// Instantiate another object of structure
var employee2 = Employee(employeeName: "Harshit",
employeeId: 256478)
// Instantiate another object of structure
var employee3 = Employee(employeeName: "Hitesh",
employeeId: 371948)
// Append Employee objects in the array
myArray.append(employee1)
myArray.append(employee2)
myArray.append(employee3)
// Print array elements
for element in myArray
{
print("Employee Name :", element.employeeName,
",", "Employee Id :" , element.employeeId);
}
Producción:
Employee Name : Bhuwanesh , Employee Id : 131478 Employee Name : Harshit , Employee Id : 256478 Employee Name : Hitesh , Employee Id : 371948
3. Escriba alias para tipos de datos complejos
Los tipos de datos complejos son tipos de datos que constan de más de un tipo de datos primitivo. También podemos especificar un alias de tipo para tipos de datos complejos. Por ejemplo, podemos referirnos a (Int, Int) -> (Int) como «intIntInt», (Int, Int) -> (Bool) como «intIntBool», etc. Al igual que otros tipos de datos, internamente, typealias no crea nuevos tipos de datos para tipos de datos complejos existentes. Simplemente proporciona los nombres alternativos para los tipos de datos complejos existentes.
Sintaxis:
typealias myDataType = complexDataType
Aquí, complexDataType es uno de los tipos de datos complejos, (Int) -> (Int), (Int) -> (Float), (Float) -> (Float), etc., myDataType es un alias de dataType, es decir, ahora podemos llamar al tipo de datos con el nombre myDataType
Ejemplo:
En el siguiente programa, estamos multiplicando dos números enteros y estamos asignando la función definida (para multiplicar dos números enteros) a un tipo de datos complejo. hemos usado otro nombre o alias para tipos de datos complejos como, «functionType» para «(Int, Int) -> Int».
Swift
// Swift program to illustrate type alias for complex types
// Alias to function type (Int, Int) -> Int
// After this statement using (Int, Int) -> Int or
// functionType is equivalent
typealias functionType = (Int, Int) -> Int
// Function to multiply variables
func multiply( a: Int, b: Int) -> Int {
return a * b
}
// Assigning multiply function to myFunction
var myfunction: functionType = multiply
// Initializing variables
var myNumber1: Int = 7
var myNumber2: Int = 8
// Calling function through variable
var answer = myfunction(myNumber1, myNumber2)
// Print the value represented by the answer
print("Multiplication of", myNumber1,
"and", myNumber2, "is", answer)
Producción:
Multiplication of 7 and 8 is 56