Directorio de artículos
prefacio
浅学一下Swift，这篇笔记做个记录
herramientas de desarrollo
Todavía es Xcode, por lo que no presentaré mucho sobre Xcode.
Variables y constantes
La palabra clave let y la palabra clave var se utilizan para representar constantes y variables respectivamente. Ya sea let o var, la función es tomar un nombre para un valor específico. Este método se llama declaración del valor. Dentro del alcance efectivo del valor, los desarrolladores pueden usar estos nombres para obtener valores específicos.Existen dos conceptos básicos en programación: valor y expresión.
Se entiende que la magnitud es el resultado. 3 es un valor entero y la cadena hola es un valor de cadena.
Una expresión puede entenderse como un proceso de cálculo, y el resultado es una magnitud. 1+2 es una expresión cuyo resultado es la magnitud 3.
hola+mundo también es una expresión cuyo resultado es la magnitud hola mundo.
La mayoría de las expresiones consisten en cantidades y operadores.
Definición y uso de variables y constantes
//引入UIKit框架
import UIKit
//定义一个变量，赋值为字符串“hello，playground”
var greeting = "Hello, playground"
//定义一个变量，赋值为字符串“hello，playground”
var greeting = "Hello, playground"
//这句代码和下面这句代码等效
//声明字符串变量
var str: String
//对字符串变量str进行赋值
str = "hello,playground"
//量值的打印
print(str)
//在使用常量或者变量时，开发者可以直接通过名称来调用对应的量值，
str = "newValue"
//在str后追加hello
str = str + "hello"
Swift también admite la declaración de múltiples constantes o variables en la misma declaración de línea, pero debe seguir el principio de tipo claro
var a = 1, b = 2, c = "string"
var a2 : Int = 1, b2 : Float = 2.9, c2 : String = "string"
Si se declaran varias variables en la misma línea de código y no se proporciona ningún valor inicial, el tipo se puede especificar especificando el tipo de la última variable como un todo.
var one, two, three : Int
Las var uno, dos y tres declaradas en el código anterior son todas variables de tipo Int
(1) El lenguaje Swift es un lenguaje muy rápido y conciso. Permite a los desarrolladores omitir puntos y comas y separar automáticamente las declaraciones con líneas nuevas. Al mismo tiempo, admite la escritura de varias oraciones de código en una línea. En este caso, se requieren puntos y comas. para separar sentencias. Por ejemplo:
var str:String;str = "hola, patio de recreo";print(str)
(2) La inferencia de tipos del lenguaje Swift es una característica muy buena del compilador Xcode. En el desarrollo real, los desarrolladores deberían aprovechar en lo posible esta característica.
(3) Si necesita modificar el valor de la variable, puede reasignar directamente la variable. Cabe señalar que el tipo del valor asignado debe ser consistente con el tipo de la variable.
Convenciones de nomenclatura para variables y constantes
En el lenguaje Swift, las reglas de nomenclatura para constantes y variables son muy amplias y pueden incluir caracteres y números Unicode. Cabe señalar que las palabras clave reservadas no se pueden usar como nombres de constantes o variables, como let y var. value name declarar. Además, los nombres de constantes y variables no pueden comenzar con números, y no se pueden usar símbolos como espacios, símbolos matemáticos, tabuladores y flechas en los nombres.
También puede usar números intercalados para nombrar, y tenga en cuenta que los números no se pueden usar al principio:
//Los nombres que contienen números var pen2 = "pen"
también se pueden nombrar con guiones bajos: //Los nombres con guiones bajos
var swift = "swift"
Aunque Swift admite una amplia gama de métodos de nomenclatura, en el desarrollo real, un buen estilo de nomenclatura puede mejorar en gran medida la eficiencia de la codificación y la legibilidad del código. La documentación oficial del lenguaje Swift utiliza nombres de mayúsculas y minúsculas. El llamado nombre de joroba se refiere al empalme de nombres con palabras. La primera letra del nombre generalmente está en minúscula, y la primera letra de cada palabra después de eso está en mayúscula, y las otras letras están en minúscula. El ejemplo es el siguiente : //Hump naming var nombre de usuario = "Hun
Shao
"
(1) Unicode (unicode, código universal, código único) es un estándar de la industria en el campo de la informática, incluidos juegos de caracteres, esquemas de codificación, etc. Unicode se creó para resolver las limitaciones de los esquemas de codificación de caracteres tradicionales. Establece una codificación binaria única y unificada para cada carácter en cada idioma para cumplir con los requisitos de procesamiento y conversión de texto entre idiomas y plataformas. Unicode comenzó la investigación y el desarrollo en 1990 y se anunció oficialmente en 1994.
(2) La asignación de nombres en Swift también tiene algunas reglas habituales, por ejemplo, la primera letra de los atributos de valor estará en minúsculas y la primera letra de los nombres de clases, objetos y estructuras estará en mayúsculas.
(3) Si realmente necesita usar palabras clave reservadas para nombrar, puede usar 符号迚行包装，但是除非 万不得已，开収中尽量不要使用这种斱式命名，包装示例如下: //用预留关键字迚行命名 var var` = 2
nota
Los comentarios de una sola línea y los comentarios de varias líneas son los mismos que los comentarios de OC.
Pero Swift puede anidar anotaciones.
//单行注释//注释中的注释 /*
多行注释
/*
*/
注释 注释 */
Conozca los tipos de datos básicos
Los datos enteros en el lenguaje Swift se dividen en datos enteros con signo y datos enteros sin signo. Los llamados firmados y no firmados, el entendimiento popular es que hay signos y no hay signos.
Para enteros sin signo, Swift proporciona tipos de datos de 5 tipos y 4 espacios de almacenamiento, y los 4 espacios de almacenamiento ocupan 8 bits, 16 bits, 32 bits y 64 bits de memoria respectivamente. Use la herramienta de desarrollo Xcode para crear un nuevo Playground, asígnele el nombre BasicDataType y escriba el siguiente código de demostración:
Para enteros sin signo, Swift proporciona 5 tipos de tipos de datos con 4 espacios de almacenamiento, y los 4 espacios de almacenamiento ocupan 8 bits de memoria. -bit, 32 bits y 64 bits. Use la herramienta de desarrollo de Xcode para crear un nuevo Playground, asígnele el nombre BasicDataType y escriba el siguiente código de demostración:
//8 位无符号整型数的最大值 255
var a1 = UInt8.max
//16 位无符号整型数的最大值 65535
var a2 = UInt16.max
//32 位无符号整型数的最大值 4294967295
var a3 = UInt32.max
//64 位无符号整型数的最大值 18446744073709551615
var a4 = UInt64.max
Se crean 4 variables a1, a2, a3, a4 en el código anterior. En el lenguaje Swift, el tipo de datos entero se implementa en forma de estructura y el atributo max puede obtener el valor máximo del tipo actual. Los lectores pueden tener dudas, ¿qué tipo se debe elegir para expresar enteros sin signo en el desarrollo real?Como se mencionó anteriormente, en realidad hay cinco enteros sin signo en el lenguaje Swift, y uno es de tipo UInt, este tipo de compilador se adaptará automáticamente, es UInt64 en una máquina de 64 bits y UInt32 en una máquina de 32 bits, el código de ejemplo es el siguiente:
var a6 = MemoryLayout<UInt>.size
MemoryLayout es una enumeración definida en la biblioteca estándar de Swift. Como su nombre lo indica, se utiliza para obtener información relacionada con la memoria. MemoryLayout es un uso genérico. Llamar a su propiedad de tamaño puede obtener la cantidad de bytes de espacio de memoria ocupados por un determinado dato. tipo.
Los datos enteros con signo son muy similares a los datos enteros sin signo, excepto que el primer bit binario es un bit de signo, que no se incluye en los cálculos numéricos. El código de ejemplo es el siguiente:
var maxInt8 = Int8.max //127
var mimInt8 = Int8.min //-128
var maxInt16 = Int16.max //32767
var minInt16 = Int16.min //-32768
var maxInt32 = Int32.max //2147483647
var minInt32 = Int32.min //-2147483648
var maxInt64 = Int64.max //9223372036854775807 var minInt64 = Int64.min //-9223372036854775808 var intSize = sizeof(Int) //8位
En correspondencia con el atributo max, el atributo min se utiliza para obtener el valor mínimo de los datos enteros.
datos de coma flotante
var b = MemoryLayout<Float>.size
var b1 = MemoryLayout<Float32>.size
var b2 = MemoryLayout<Float64>.size
var b3 = MemoryLayout<Float80>.size
var c = MemoryLayout<Double>.size
//4字节
//4字节
//8字节
//16字节
//8字节
El lenguaje Swift admite el uso de notación científica para representar números. En decimal, use e para representar 10 a la n-ésima potencia. En hexadecimal, use p para representar 2 a la n-ésima potencia. El código de ejemplo es el siguiente:
var suma = 1.25e3 //1.25*(10^3) = 1250 var sol2 = 0x1p3 //1*(2^3) = 8
También hay una característica muy interesante en el lenguaje Swift, ya sea que se trate de datos enteros o datos de punto flotante, puede agregar cualquier número de 0 antes del número para llenar el número de dígitos, o puede agregar un guión bajo al número para separar, y luego Para aumentar la legibilidad, estas operaciones no afectarán el valor original, pero mejorarán la facilidad de programación para los desarrolladores y harán que la estructura del código sea más clara. Los ejemplos son los siguientes:
var num1 = 001.23 //1.23
var num2 = 1_000 //1000
var num3 = 1_000.1_ 001 //1000.1001
datos booleanos
El tipo booleano a menudo se denomina tipo lógico. Los lectores familiarizados con el lenguaje de programación Objective-C pueden entender que en el lenguaje Objective-C, el tipo booleano no es un tipo booleano lógico en sentido estricto. Cero y no se pueden usar en Objetivo C. Cero para expresar falso lógico y verdadero lógico. Es diferente en el lenguaje Swift, el tipo Bool del lenguaje Swift es muy estricto, solo hay dos valores de verdadero y falso, que representan verdadero y falso respectivamente. De manera similar, en el enunciado condicional del lenguaje Swift y el enunciado que requiere juicio lógico, el valor de la expresión condicional utilizada también debe ser de tipo Bool.
Dos tipos de datos primitivos especiales
El lenguaje Swift también admite dos tipos de datos básicos especiales, a saber, el tipo de tupla y el tipo de valor opcional. Las tuplas se usan muy comúnmente en el desarrollo real. Los desarrolladores pueden usar tuplas para crear tipos de datos personalizados con cualquier combinación de tipos de datos; los tipos de valores opcionales son una característica importante del lenguaje Swift. A través de los tipos de valores opcionales, se llevó a cabo un control estricto de los valores logarítmicos del lenguaje Swift. fuera por el aire.
tupla
Las tuplas son uno de los tipos de datos importantes en el lenguaje Swift. Las tuplas permiten que algunos tipos no relacionados se combinen libremente en nuevos tipos de colección. El lenguaje Objective-C no admite tipos de datos como tuplas, lo que causará problemas a los desarrolladores en muchos casos. Análogo a una situación en la vida, el tipo de tupla es similar al paquete en la vida diaria. Ahora, varias industrias de servicios han lanzado muchos paquetes distintivos para que los clientes elijan, a fin de brindarles un servicio integral. Las tuplas proporcionan una estructura de programación de este tipo. Imagine una situación en la programación: un producto tiene un nombre y un precio. El uso de tuplas puede simular muy bien este tipo de producto. Los ejemplos son los siguientes:
//创建钢笔元组类型，其中有两种类型，字符串类型的名称和整数类型的价钱
var pen : (name : String, pricr : Int) = ("钢笔", 2)
El código anterior especifica los nombres de los parámetros al crear la tupla, es decir, el parámetro de nombre es nombre y el parámetro de precio es precio. Los desarrolladores pueden usar estos nombres de parámetros para obtener los valores de cada parámetro en la tupla.
var name = pen.name
var price = pen.price
Al crear una tupla, no necesita especificar el nombre del parámetro, y la tupla asignará automáticamente un subíndice a cada parámetro, y el valor del subíndice aumentará secuencialmente desde 0
var car : (String, Int) = ("奔驰", 20000000)
var carName = car.0
var carPrice = car.1
Después de crear la instancia de tupla, los desarrolladores también pueden descomponerla especificando variables o constantes,
//不指定参数名称的元组
var car : (String, Int) = ("奔驰", 2000000)
//进行元组的分解
var (theName, thePrice) = car
//此时theName变量被赋值为“奔驰“, thePrice被赋值为2000000
print(theName, thePrice)
El código anterior descompone cada elemento componente del coche de instancia de tupla en variables específicas.Hay un punto al que los lectores deben prestar atención.Las variables descompuestas deben corresponder a los elementos de la tupla uno por uno (el número es igual), de lo contrario el compilador cometerá un error.
La función print() es una función de impresión. La función print() puede recibir múltiples parámetros, que pueden estar separados por . A veces, es posible que los
desarrolladores no necesiten obtener los valores de todos los elementos en una instancia de tupla. En este caso, en En este caso, los desarrolladores también pueden recibir de forma anónima algunos elementos que no necesitan ser adquiridos, como se muestra en los siguientes ejemplos:
//不指定参数名称的元组
var car : (String, Int) = ("奔驰", 2000000)
//进行元组的分解，将Int型参数进行匿名
var (theName, _) = car
//此时theName被赋值为“奔驰”
print(theName)
En el lenguaje Swift, el símbolo " " se usa a menudo para representar el concepto anónimo, por lo que " " también se denomina identificador anónimo. El código anterior en realidad descompone solo el primer elemento (tipo String) en el carro de tuplas.
Aunque las tuplas son muy convenientes de usar, solo son adecuadas para la combinación de datos simples.Para datos con estructuras complejas, se deben usar estructuras o clases para realizarlas.
tipo de valor opcional
El tipo de valor opcional (tipo opcional) es un tipo único de lenguaje Swift. En primer lugar, el lenguaje Swift es un lenguaje que pone gran énfasis en la seguridad de tipos. Cuando un desarrollador usa una determinada variable, el compilador hará todo lo posible para garantizar la claridad del tipo y el valor de la variable para reducir los factores incontrolables en la programación. . Sin embargo, en la programación real, cualquier tipo de variable encontrará una situación en la que el valor está vacío. No existe ningún mecanismo en el lenguaje Objective-C para monitorear y administrar específicamente las variables que están vacías. La seguridad del programa está controlada manualmente por el desarrollador. . El lenguaje Swift proporciona un método de ajuste para realizar un ajuste opcional en tipos comunes para realizar el seguimiento de valores nulos.
En el lenguaje Swift, si utiliza una variable a la que no se le ha asignado un valor, el programa informará directamente de un error y dejará de ejecutarse. Los lectores pueden pensar que si a una variable no se le asigna un valor inicial cuando se declara, se le puede asignar un valor más adelante en el programa, entonces, ¿qué debemos hacer para este escenario de aplicación de "declaración primero y luego asignación"? C, este problema es fácil de resolver, solo necesita juzgar si la variable es nula cuando la usa. ¿Es posible hacer lo mismo en Swift?Utilice el siguiente código para probar:
En el lenguaje Swift, si utiliza una variable no asignada, el programa informará directamente un error y dejará de ejecutarse. Los lectores pueden pensar que si a una variable no se le asigna un valor inicial cuando se declara, se le puede asignar un valor más adelante en el programa, entonces, ¿qué debemos hacer para este escenario de aplicación de "declaración primero y luego asignación"? C, este problema es fácil de resolver, solo necesita juzgar si la variable es nula cuando la usa. ¿Es posible hacer lo mismo en Swift?Utilice el siguiente código para experimentar:
var obj:String
if obj==nil {
}
Después de escribir el código anterior, puede ver que la herramienta Xcode aún arroja un mensaje de error. De hecho, en el lenguaje Swift, los tipos ordinarios que no se han inicializado no se pueden usar, incluso si se usan para el procesamiento de juicio nulo. Por supuesto, no es posible realizar operaciones de comparación con 0. Este mecanismo reduce en gran medida la incontrolabilidad del código. Por lo tanto, los desarrolladores deben asegurarse de que las variables se inicialicen antes de su uso, el código es el siguiente:
var obj0 : String
obj0 = "HS"
print(obj0)
Sin embargo, el enfoque anterior no se usa comúnmente en el desarrollo real. Si una variable puede ser nula lógicamente, el desarrollador debe envolverla como un tipo Opcional. Reescriba el código anterior de la siguiente manera:
var obj : String?
if obj == nil {
}
En este punto, el código debería ejecutarse normalmente. Analizando el código anterior, al declarar la variable obj, aquí se declara de tipo String?,Agregue el símbolo "?" después del tipo ordinario para envolver el tipo ordinario en un tipo opcional.
El tipo Opcional no existe de forma independiente. Siempre se adjunta a un tipo de datos específico. El tipo de datos específico puede ser un tipo de datos básico, una estructura o una clase. El tipo opcional tiene solo dos valores, que los lectores pueden entender como:
- Si la magnitud correspondiente a su tipo de adjunto tiene un valor concreto, es un envoltorio para el valor concreto.
- Es nulo si la magnitud correspondiente a su tipo de vinculación no tiene un valor específico.
- El lector nulo en el tipo Opcional también puede entenderse como un valor que representa vacío
El tipo Optional es un tipo de empaquetado para los tipos ordinarios, por lo que debe desempaquetarse cuando se usa, y el desempaquetado usará el operador "!" en Swift. Los dos operadores "?" y "!" son una pesadilla para muchos principiantes del lenguaje Swift. Si los lectores entienden el tipo Opcional, será mucho más fácil entender y usar estos dos operadores. En primer lugar, cabe señalar que el símbolo "?" puede aparecer después del tipo o después de la instancia. Si aparece después del tipo, representa el tipo Opcional correspondiente a este tipo. Si aparece después de la instancia, representa opcional La llamada de la cadena se introducirá en detalle en los siguientes capítulos. El símbolo "!" también puede aparecer detrás del tipo y la instancia. Aparece después del tipo y representa una estructura gramatical analizada implícitamente, que se presentará en capítulos posteriores; aparece después de la instancia y representa el desempaquetado de la operación de instancia de tipo opcional. Los ejemplos son los siguientes:
//声明obj为String？类型
var obj : String? = "HS"
//进行拆包操作
obj!
Los lectores deben prestar atención, al usar "!" para desempaquetar el valor opcional, debe asegurarse de que el valor que se desempaquetará no sea nulo, de lo contrario, el programa se ejecutará incorrectamente. Puede usar la declaración if para hacer un juicio de seguridad antes de desempacar.El ejemplo es el siguiente:
var obj : String? = "HS"
if obj != nil {
obj!
}
Si obj tiene un valor, la estructura if-let creará una constante temporal tmp para recibir el valor desempaquetado de obj y ejecutará el bloque de código correspondiente cuando if sea verdadero En el bloque de código ejecutado, los desarrolladores pueden usar directamente el desempaquetado El empaquetado el valor obj es tmp. Si obj es nulo, ingresará al bloque de código donde if es falso, y el desarrollador puede reasignar obj para usarlo en el bloque de código else. Esta estructura if-let en realidad completa los tres procesos de juzgar, desempaquetar y vincular el valor desempaquetado a una constante temporal.
En la estructura if-let, también se pueden enlazar múltiples valores del tipo Opcional al mismo tiempo, separados por comas, los ejemplos son los siguientes:
//if-let多Optional值绑定
var obj1 : Int? = 1
var obj2 : Int? = 2
if let tmp1 = obj1, let tmp2 = obj2 {
print(tmp1, tmp2)
}
Al vincular varios valores del tipo Opcional al mismo tiempo, el enlace tendrá éxito solo si todos los valores Opcionales no son nulos, y la ejecución del código ingresará al bloque de código si es verdadero.
//if-let多Optional值绑定
var obj1 : Int? = 1
var obj2 : Int? = 2
if let tmp1 = obj1, let tmp2 = obj2, tmp1 < tmp2 {
print(tmp1, tmp2)
}
El código anterior solo ingresará al bloque de código si es verdadero cuando obj1 no es nulo, obj2 no es nulo y el valor de desempaquetado correspondiente a obj1 es más pequeño que el valor de desempaquetado correspondiente a obj2, es decir, imprime el valor tmp1 y tmp2 enlazado.
Para una variable de tipo de valor opcional, necesitamos desempaquetarla cada vez que la usamos, lo cual es relativamente problemático De hecho, hay otra sintaxis en Swift: análisis implícito. El análisis implícito es adecuado para tal escenario: cuando aclaramos que una variable es inicialmente nula y se le debe asignar un valor antes de que se use más tarde, podemos declararla como un valor opcional para el análisis implícito y luego realizar Uso, allí no es necesario realizar operaciones de desempaquetado, por ejemplo, el siguiente código generará un error de tiempo de ejecución:
Compilará errores, porque obj4 no está desempaquetado
//声明obj4为隐式解析的变量
var obj4 : Int!
obj4 = 3
//使用时，无须再进行拆包操作，Swift会自动帮我们拆包
print(obj4 + 1)
alias el tipo
Los lenguajes como C, C++ y Objective-C proporcionan palabras clave como typedef para tomar un alias para un tipo determinado. En el
lenguaje Swift, la palabra clave typealias se usa para lograr el mismo efecto. Los ejemplos son los siguientes:
//为Int类型取一个别名Price
typealias Price = Int
//使用Price代替Int， 效果完全一样
var penPrice : Price = 100
El código anterior toma el alias Price para el tipo Int. En el uso posterior, el tipo Price es exactamente el mismo que el tipo Int. En el desarrollo real, el uso flexible de typealias para alias del tipo puede optimizar la legibilidad del código.
simulacro de entrevista
(1) Los símbolos "?" y "!" son dos símbolos muy comunes en los proyectos de Swift. Describa brevemente su comprensión de ellos. Sugerencias para responder a los puntos clave: 1 En primer lugar, comprenda los dos aspectos de tipo e instancia, "?" aparece después del tipo para indicar el tipo opcional y aparece después de la instancia para indicar la llamada en cadena opcional
. "!" Aparecer después del tipo significa un análisis implícito predeterminado y aparecer después de la instancia significa un desempaquetado forzado. 2 Estos dos símbolos están relacionados con el tipo Opcional en Swift. El tipo Opcional es una
forma en que el lenguaje Swift enfatiza la seguridad. Si una variable puede estar vacía debe determinarse lógicamente, en lugar de ser impredecible e incontrolable. 3La combinación de la estructura if-let y el valor de tipo opcional puede escribir un código lógico elegante y seguro.
Contenido básico de comprensión:
tenga una comprensión profunda del tipo Opcional en Swift. (2) ¿Cuáles son las ventajas de decimal, binario, octal y hexadecimal, y en qué escenarios se utilizan? Consejos para responder los puntos clave: 1. Las ventajas del sistema decimal No hace falta decir que casi todos los cálculos matemáticos en la vida diaria usan el sistema decimal
. 2 Binary es la forma más conveniente para que las computadoras entiendan el sistema base. Los estados de nivel alto y bajo son muy fáciles de representar binarios 0 y 1, y también es la forma más
estable de almacenar datos en la computadora. 3 Octal y hexadecimal son en realidad métodos de agregación binaria. En octal, cada dígito puede representar
3 bits en binario, y en hexadecimal, cada dígito puede representar 4 bits en binario, lo que acorta considerablemente la longitud del número binario y es legible. El hexadecimal se usa a menudo para representar datos de color.
Contenido básico de comprensión:
el principio de la base y el método de conversión.
(3) ¿Hay solo dos tipos de datos, var y let, en el lenguaje Swift?
Consejos para responder puntos clave: 1. Esta proposición es muy incorrecta. En Swift, var y let no son tipos de datos, sino dos métodos para declarar variables .
Modo. 2Swift es un tipo de datos fuerte, al igual que C, C++, Objective-C, Java y otros lenguajes, cuando se declaran las variables, sus datos Análisis de ejemplo:
el
tipo ya se ha determinado, a veces no lo especificamos explícitamente, porque Xcode tiene Función de inferencia automática de tipos. Los tipos de datos en 3Swift incluyen tipos de datos básicos y tipos de datos de referencia, y los tipos de datos básicos incluyen números enteros, tipos de punto flotante,
tipos booleanos, tuplas, etc.
Contenido básico de comprensión:
comprender el significado de los tipos de datos, comprender la relación entre las variables y los tipos de datos, y comprender la función de inferencia automática de tipos de Xcode.
Tipos de caracteres, cadenas y colecciones
En el desarrollo de programas es fundamental el uso de cadenas, que es un tipo de datos muy importante en la programación, de hecho, las cadenas también son una colección de caracteres. Algunos lenguajes no tienen un tipo de cadena independiente, como el lenguaje C, que a menudo usa matrices de caracteres como tipos de cadena.El lenguaje Objective-C encapsula el tipo de cadena orientada a objetos NSString y encapsula una gran cantidad de métodos relacionados en él. . Y Swift es un lenguaje que debilita los punteros, proporciona tipo de cadena y tipo de carácter para describir cadenas y caracteres.
tipo de cadena
Como sugiere el nombre, el tipo de cadena es una combinación de una cadena de caracteres, que se usa ampliamente en el desarrollo. La lógica de la escena, como el nombre del producto, la clase del estudiante y la letra de la música, deben ser procesado a través de la cadena.
var str = "hello, world"
var str = ""
El valor de una variable de cadena es una cadena vacía y el valor de una variable de cadena es nulo son dos conceptos completamente diferentes, si a una variable de tipo opcional no se le asigna un valor, es nulo, si se le asigna una cadena vacía, es no nulo. .
En el lenguaje Swift, el tipo String es en realidad una estructura. De hecho, la estructura también implementa los tipos entero, de punto flotante y booleano aprendidos en los capítulos anteriores. La estructura en el lenguaje Swift es muy poderosa y puede definir propiedades y métodos como una clase.
var str : String = "Hello, playground"
print(str)
str = ""
print(str)
str = String()
print(str)
str = String("hello")
print(str)
str = String(666)
print(str)
str = String(6.66)
print(str)
str = String("a")
print(str)
str = String(false)
print(str)
str = String(describing: (1, 2.0, true))
print(str)
str = String(describing: [1, 2, 3])
print(str)
str = String(format: "我是%@", "会少")
print(str)
El tipo String proporciona muchos métodos de construcción sobrecargados y los desarrolladores pueden pasar diferentes tipos de parámetros para construir la cadena requerida. De hecho, el tipo String en el lenguaje Swift proporciona una amplia gama de métodos de construcción, e incluso otros tipos se pueden
convertir en cadenas a través de métodos de construcción, como se muestra en los siguientes ejemplos:
var str : String = "Hello, playground"
print(str)
str = String(describing: Int.self)
print(str)
var a = Int(1.5)
print(a)
var b = Float(a)
print(b)
combinación de cuerdas
El tipo String en Swift implementa la sobrecarga del operador "+", es decir, los desarrolladores pueden usar directamente el símbolo "+" para
concatenar varias combinaciones de cadenas en una nueva cadena.
var c1 = "Hello"
var c2 = "world"
var c3 = c1 + " " + c2
print(c3)
A través del operador de suma, los desarrolladores pueden combinar fácilmente variables de cadena. A veces, los desarrolladores necesitan insertar otra cadena en medio de una cadena. Además de usar el método de construcción con formato, Swift también proporciona un método de interpolación de cadenas muy conveniente.
Interpolación de cadenas usando ()
var d = "Hello\(123)"
print(d)
var d2 = "Hello\(d)"
print(d2)
var d3 = "Hello\(1 + 2)"
print(d3)
La estructura "()" puede convertir otros tipos de datos en tipos de cadena e insertarlos en la posición correspondiente de los datos de la cadena, o insertar el resultado en la cadena original después de realizar una operación lógica simple. Este método es muy conveniente para la cadena. El formato es ampliamente utilizado en el desarrollo.
tipo de caracter
El tipo de carácter se usa para representar un solo carácter, como los caracteres numéricos, los caracteres ingleses, los caracteres de símbolos y los caracteres chinos, etc. se pueden representar mediante el tipo de carácter,
y los caracteres de la cadena también se pueden descomponer recorriendo la cadena.
Similar a Char en lenguaje C, Character se usa en lenguaje Swift para describir tipos de caracteres, y tanto el tipo de carácter como el tipo de cadena ocupan 16 bytes de espacio de memoria. En Swift se puede utilizar la enumeración MemoryLayout para obtener el espacio de memoria que ocupa un determinado tipo, y su unidad son los bytes, el ejemplo es el siguiente:
print(MemoryLayout<String>.size)
El carácter se usa para describir un carácter. Combinamos un grupo de caracteres en una matriz para construir una cadena. Los ejemplos son los siguientes
:
var e : Character = "a"
var e2 : [Character] = ["H", "E", "L", "L", "O"]
var e3 = String(e2)
print(e, e2, e3)
Use for-in traversal para desensamblar los caracteres en la cadena. Este método a veces es muy útil. For-in traversal es una estructura de flujo de código importante en el lenguaje Swift. El tipo String implementa el protocolo relacionado con el iterador de forma predeterminada. Recorrerlo directamente puede extraer cada elemento de carácter en la cadena. El código de ejemplo es el siguiente:
let name = "China"
for character in name {
print(character)
}
La estructura for-in es una estructura de bucle importante. En el código de muestra anterior, la palabra clave in debe ser un tipo iterable, y la palabra clave in está precedida por los elementos tomados del iterador para cada bucle. El tipo se infiere automáticamente por el compilador de Xcode
Personaje de escape
El lenguaje Swift es similar al lenguaje C. Además de algunos caracteres visibles convencionales, también proporciona algunos caracteres de escape de propósito especial, que
pueden expresar significados específicos a través de combinaciones de símbolos especiales. Los ejemplos son los siguientes:
- \0: Marca de espacio de visualización útil.
- \: utilizado para representar una barra invertida
- \t: use 杢 para representar caracteres de tabulación.
- \n: utilice 杢 para representar un carácter de nueva línea.
- \r: utilice 杢 para representar el carácter de retorno de carro.
- ': use 杢 para representar una comilla simple
- ": use 杢 para representar comillas dobles.
- \u{}: Crea personajes con códigos Unicode.
Entre ellos, \u{} se usa para crear caracteres a través de códigos Unicode, solo complete los códigos Unicode entre llaves, el ejemplo es el siguiente: //Use códigos Unicode para crear caracteres, ¡el carácter representado por Unicode es 21! " \u
{veintiuno}"
Métodos comunes en tipo de cadena
El tipo String del lenguaje Swift encapsula muchas propiedades y métodos prácticos, como la inspección de cadenas, las operaciones de adición, inserción y eliminación de caracteres, y las estadísticas de conteo de caracteres. El uso competente de estos atributos y métodos puede permitir a los desarrolladores manejar datos con facilidad en la programación.
Como se mencionó anteriormente, el valor de una variable de cadena es una cadena vacía y el valor de una variable de cadena está vacía son dos conceptos diferentes.La instancia del tipo String utiliza el método isEmpty para determinar si el valor de la cadena es una cadena vacía.
var obj1 = ""
if obj1.isEmpty {
print("字符串为空字符串")
}
Hay otra forma de juzgar si una variable de cadena es una cadena vacía, es decir, cuando el número de caracteres en la variable de cadena es 0, la cadena también se puede considerar como una cadena vacía, es decir, a través del atributo de recuento de la cadena Determinar si el número de caracteres es 0
var obj1 = ""
if obj1.count == 0 {
print("字符串为空字符串")
}
Además de usar "+" para concatenar directamente instancias de tipo String, también puede usar operadores de comparación
var com1 = "30a"
var com2 = "31a"
if com1 == com2 {
print("com1 = com2")
}
if com1 < com2 {
print("com1 < com2")
}
Al comparar el tamaño de dos cadenas, el tamaño de los caracteres se comparará uno por uno hasta que se encuentre un carácter diferente. El código de muestra anterior se puede entender de la siguiente manera: primero compare el primer carácter de la cadena com1 y la cadena com2, si son iguales, luego compare el segundo carácter, y así sucesivamente. Dado que el cuarto carácter (2) de com2 es mayor que el cuarto carácter (1) de com1, la cadena com2 es más grande que la cadena com1.
var string = "Hello - Swift"
var startIndex = string.startIndex
var endIndex = string.endIndex
print(string)
print(startIndex)
print(endIndex)
var char = string[string.index(after: startIndex)]
var char2 = string[string.index(before: string.endIndex)]
print(char)
print(char2)
Cabe señalar aquí que los valores obtenidos por startIndex y endIndex son del tipo Index, no de tipos enteros. No se pueden sumar o restar directamente, y se debe usar el método correspondiente para mover el subíndice. El índice (después de El método :) se usa para obtener el subíndice actual
. El siguiente subíndice, el método index(before:) se usa para obtener el subíndice anterior del subíndice actual. También puede interceptar una determinada subcadena en la cadena pasando el rango de subíndice
var string = "Hello - Swift"
var startIndex = string.startIndex
var endIndex = string.endIndex
var subString = string[startIndex...string.index(startIndex, offsetBy: 4)]
var subString2 = string[string.index(endIndex, offsetBy: -5)..<endIndex]
print(string)
print(startIndex)
print(endIndex)
print(subString)
print(subString2)
En el código de muestra anterior, "..." es un operador de rango, que se presentará en detalle en los siguientes capítulos. El parámetro offsetBy se pasa en el número de dígitos para mover el subíndice. Si se le pasa un número positivo , el subíndice se moverá hacia atrás el número correspondiente de dígitos. Si se le pasa un número negativo, el subíndice avanzará el número correspondiente de dígitos. Es muy conveniente usar este método para interceptar cadenas. El tipo String también encapsula algunos métodos, que pueden ayudar a los desarrolladores a realizar operaciones de manera conveniente, como agregar, insertar, reemplazar y eliminar cadenas.
var string = "Hello - Swift"
//获取某个子串在父串中的范围
var range = string.range(of: "Hello")
//追加一个字符，此时 string = "Hello-Swfit!"
string.append(Character("!"))
//追加字符串操作，此时string = "Hello-Swift! Hello-World"
string.append(" Hello-World")
//在指定位置插入一个字符，此时string = "Hello-Swift!~ Hello-World"
string.insert("~", at: string.index(string.startIndex, offsetBy: 12))
//在指定位置插入一组字符，此时string = "Hello-Swift!~~~~ Hello-World"
string.insert(contentsOf: ["~","~","~"], at: string.index(string.startIndex,
offsetBy: 12))
//在指定范围替换一个字符串，此时string = "Hi-Swift!~~~~ Hello-World"
string.replaceSubrange(string.startIndex...string.index(string.startIndex,
offsetBy: 4), with: "Hi")
//在指定位置删除一个字符，此时string = "Hi-Swift!~~~~ Hello-Worl"
string.remove(at: string.index(before:string.endIndex)) //删除指定范围的字符，此时string = "Swift!~~~~ Hello-Worl"
string.removeSubrange(string.startIndex...string.index(string.startIndex, offsetBy: 2))
//删除所有字符，此时string = ""
string.removeAll()
var string2 = "My name is Jaki"
print(string2)
//全部转换为大写
string2 = string2.uppercased()
print(string2)
//全部转换为小写
string2 = string2.lowercased()
print(string2)
//检查字符串是否有 My 前缀
string2.hasPrefix("My")
//检查字符串是否有 jaki 后缀
string2.hasSuffix("jaki")
tipo de colección
Hay tres tipos de colección proporcionados en el lenguaje Swift: matriz (Array), colección (Set) y diccionario (Dictionary). El tipo de matriz es una colección ordenada, y los datos que se colocan en ella tienen un número, y el número comienza desde 0 y aumenta secuencialmente. A través del número, los desarrolladores pueden encontrar el valor correspondiente en la matriz Array. Una colección es un conjunto de datos desordenados, y los datos almacenados en ella no tienen número. Los desarrolladores pueden usar el método transversal para obtener todos los datos que contiene. Una colección es una estructura de mapeo clave-valor, en la que cada valor almacenado debe corresponder a una clave específica, y la clave no se puede repetir, los desarrolladores pueden obtener directamente el valor correspondiente a través de la clave. Una imagen de ejemplo en la documentación de desarrollo oficial de Swift puede describir claramente las similitudes y diferencias de estos tres tipos de colección.
Tipo de matriz (matriz)
Los elementos que se pueden almacenar en la matriz no son solo números, puede almacenar cualquier tipo de datos, pero todos los tipos de datos deben estar unificados. En el desarrollo real, el tipo de elementos en la matriz determina el tipo de la matriz
//Int整形数组
var array1 : [Int]
var array2 : Array<Int>
Las dos líneas de código anteriores declaran una instancia de una matriz de tipo Int. Hay dos formas de crear una matriz: una es usar el método constructor de la matriz para crearla y la otra es usar corchetes para crearla. rápidamente.
var array1 : [Int]
var array2 : Array<Int>
//创建空数组
array1 = []
array2 = Array()
//创建整形数组
array1 = [1, 2, 3]
//通过一组元素创建数组
array2 = Array(arrayLiteral: 1, 2, 3)
Al igual que el tipo String, una matriz vacía no significa que la variable sea nula, sino que los elementos de la matriz están vacíos. En Swift, solo las variables del tipo Opcional pueden ser nulas.
En el lenguaje Swift, los arreglos se implementan usando estructuras. Para arreglos con una gran cantidad de elementos repetidos, los desarrolladores pueden usar directamente métodos abreviados para crear
//创建大量有相同元素的数组
//创建有10个String类型元素的数组，并且每个元素都为字符串“Hello”
var array3 = [String](repeating: "Hello", count: 10)
print(array3)
//创建有10个Int类型元素的数组，并且每个元素都是1
var array4 = Array(repeating: 1, count: 10)
print(array4)
Los lectores deben tener en cuenta que el tipo de matriz debe especificarse cuando se declara, pero el desarrollador no necesariamente necesita especificar el tipo explícitamente.Si el valor inicial también se establece cuando se declara la matriz, el compilador inferirá automáticamente el valor de la matriz según el tipo de asignación. Type
Array El operador de suma también está sobrecargado en la matriz. Los desarrolladores pueden usar "+" para agregar dos matrices. El resultado de la suma es empalmar los elementos de la segunda matriz en la parte posterior de la primera matriz. Cabe señalar que los tipos de matriz agregados deben ser los mismos
var array5 = [1, 2, 3] + [4, 5, 6]
print(array5)
El arreglo proporciona muchos métodos para que los desarrolladores obtengan la información relevante de la instancia del arreglo o agreguen, eliminen, modifiquen y verifiquen el arreglo.
print(array.count)
if array.isEmpty {
print("array为空数组")
}
var a = array[0]
print(a)
var subArray = array[0...3]
print(subArray)
var b = array.first
print(b)
var c = array.last
print(c)
array[0] = 0
print(array)
array[0...3] = [1, 2, 3, 4]
print(array)
array.append(10)
print(array)
array.append(contentsOf: [11, 12, 13])
print(array)
array.insert(0, at: 0)
print(array)
array.insert(contentsOf: [-2, -1], at: 0)
print(array)
array.remove(at: 1)
print(array)
array.removeFirst()
print(array)
array.removeLast()
print(array)
array.removeFirst(2)
print(array)
array.removeLast(2)
print(array)
array.removeSubrange(0...2)
print(array)
array.replaceSubrange(0...2, with: [0, 1])
print(array)
array.removeAll()
print(array)
if array.contains(1) {
print(true)
}
print(array)
Cabe señalar aquí que solo cuando la instancia de matriz es una variable, se pueden usar métodos como agregar, eliminar y modificar, y las operaciones relacionadas con la modificación no se pueden realizar en matrices constantes.
//Int型数组
let arrayLet = [0, 1, 2, 3, 4]
//（Int， Int）型数组
let arrayLet2 = [(1, 2), (2, 3), (3, 4)]
//直接遍历数组
for item in arrayLet {
print(item)
}
//进行数组枚举遍历
for item in arrayLet.enumerated() {
print(item)
}
//进行数组角标遍历
for index in arrayLet2.indices {
print(arrayLet2[index], separator:"")
}
Las instancias de matriz se pueden atravesar directamente. Todavía existen algunas diferencias entre la estructura for-in en Swift y la estructura for-in en Objective-C. La estructura for-in en Swift atravesará en orden al atravesar la matriz. También hay un método enumerado () en la instancia de matriz, que devuelve un conjunto de tuplas y devuelve el subíndice y los elementos correspondientes de la matriz. Los desarrolladores también pueden obtener los elementos de la matriz recorriendo los subíndices de la matriz. A diferencia del tipo String, los subíndices de la matriz pueden ser de tipo Int, mientras que los subíndices de String son estrictamente del tipo Index. Tenga en cuenta aquí, No te confundas.
Hay un atributo de índices en el tipo de matriz, que devolverá un rango (Rango), que es el rango del subíndice de la matriz.
El tipo de matriz también proporciona una función de clasificación. Si los elementos de la matriz son datos enteros, puede utilizar el método sorted(by:) proporcionado por el sistema para realizar la operación de clasificación. Si se trata de algún tipo personalizado, el desarrollador también puede configure el método sorted(by:) pasa en el parámetro de cierre para implementar una nueva regla de clasificación, que se describirá en detalle en los siguientes capítulos. El código de ejemplo para el método de clasificación de la matriz es el siguiente:
var arraySort = [1, 3, 5, 6, 7]
arraySort = arraySort.sorted(by: >)
print(arraySort)
arraySort = arraySort.sorted(by: <)
print(arraySort)
print(arraySort.max())
print(arraySort.min())
Tipo de colección (conjunto)
El tipo de colección no presta atención al orden de los elementos, pero los elementos que contiene no se pueden repetir, y los lectores también pueden entenderlo como una colección desordenada. Al igual que una matriz, una colección debe especificar su tipo al declararla, o asignarle un valor inicial, para que el compilador pueda inferir el tipo de la colección por sí mismo.
var set1 : Set<Int> = [1, 2, 3, 4]
var set2 = Set(arrayLiteral: 1, 2, 3, 4)
var a = set1[set1.startIndex]
var b = set1[set1.index(after: set1.startIndex)]
var c = set1[set1.index(set1.startIndex, offsetBy: 3)]
print(a, b, c)
Dado que la colección no presta atención al orden de los elementos en ella, no tiene sentido que la colección obtenga el valor por subíndice, pero el tipo de colección todavía admite el subíndice para obtener los elementos en ella. Cabe señalar que la operación de subíndice de la colección es
irreversible. La operación solo puede retroceder, no avanzar.
El siguiente método puede obtener información en la instancia de colección
//获取元素个数
set1.count
//判断集合是否为空集合
if set1.isEmpty {
print("集合为空") }
//判断集合中是否包含某个元素
if set1.contains(1){
print("集合包含") }
//获取集合中的最大值
set1.max()
//获取集合中的最小值
set1.min()
Las colecciones también admiten operaciones de adición, eliminación, modificación y consulta.
//向集合中插入一个元素
set1.insert(5)
//移除集合中的某个元素
set1.remove(1)
//移除集合中的第一个元素
set1.removeFirst() //移除集合中某个位置的元素
set1.remove(at: set1.firstIndex(of: 3)!)
//移除集合中所有的元素
set1.removeAll()
Cuando se utiliza el método remove(at:) para eliminar un elemento en una posición determinada de la colección, es necesario pasar el valor del subíndice de un elemento de la colección, y el valor del subíndice de un elemento específico se puede obtener a través de firstIndex( of:) método de la instancia de colección. Cabe señalar que este método devolverá un valor opcional del tipo Opcional, porque el elemento que se encuentra puede no existir y el desarrollador debe desempaquetarlo cuando lo use.
Además de la diferencia entre conjuntos y matrices ordenados y no ordenados, los conjuntos también tienen una característica única: pueden realizar operaciones matemáticas, como operaciones de intersección, operaciones de unión y operaciones de complemento. Una imagen en el documento de desarrollo oficial de Swift muestra la escena cuando el conjunto realiza operaciones matemáticas. 
Se puede ver que el conjunto admite cuatro tipos de operaciones matemáticas, a saber, operación de intersección (intersección), operación de diferencia simétrica (complemento de intersección), unión (unión) ) operación y resta (conjunto de complementos) operación. El resultado de la operación intersección es la intersección de dos conjuntos El resultado de la operación complemento de la intersección es la unión del conjunto a y el conjunto b excepto la intersección del conjunto a y el conjunto b El resultado de la unión La operación es la unión de los dos conjuntos.El resultado de la operación con conjuntos es el conjunto a menos la intersección del conjunto a y el conjunto b. Los códigos de ejemplo para las cuatro operaciones anteriores son los siguientes:
var set3:Set<Int> = [1,2,3,4]
var set4:Set<Int> = [1,2,5,6] //返回交集 {1，2}
var setInter = set3.intersection(set4) //返回交集的补集{3，4，5，6}
var setEx = set3.symmetricDifference(set4) //返回并集{1，2，3，4，5，6}
var setUni = set3.union(set4) //返回第二个集合的补集{3，4}
var setSub = set3.subtracting(set4)
Utilice el operador de comparación "==" para comparar si dos colecciones son iguales. Cuando todos los elementos de las dos colecciones son iguales, las dos colecciones son iguales. La colección también proporciona algunos métodos para juzgar la relación entre las colecciones.
var set5:Set = [1,2]
var set6:Set = [2,3]
var set7:Set = [1,2,3]
var set8:Set = [1,2,3]
//判断是否是某个集合的子集，set5 是 set7 的子集，返回 ture
set5.isSubset(of: set7)
//判断是否是某个集合的超集，set7 是 set5 的超集，返回 ture
set7.isSuperset(of: set5)
//判断是否是某个集合的真子集，set5 是 set7 的真子集，返回 ture
set5.isStrictSubset(of: set7) //判断是否是某个集合的真超集，set7 不是 set8 的真超集，返回 false
set7.isStrictSuperset(of: set8)
De manera similar a una matriz, una colección también puede obtener todos los datos de la colección mediante un recorrido for-in. Se puede recorrer de tres maneras: elementos transversales, enumeración de colecciones transversales y subíndices de colecciones transversales. La enumeración de conjunto devolverá una tupla, en la que el subíndice de conjunto y su valor correspondiente se devuelven juntos
//遍历元素
for item in set7 {
print(item)
}
//遍历集合的枚举
for item in set7.enumerated() {
print(item)
}
//遍历集合的下标
for index in set7.indices {
print(set7[index])
}
Aunque la colección no enfatiza el orden de los elementos, al atravesar, los desarrolladores pueden ordenarlos antes de recorrer
for item in set7.sorted(by: >) {
print(item)
}
Tipo de diccionario (diccionario)
Cuando se utiliza un diccionario, un índice encuentra un resultado.Este
modo de almacenamiento de datos se denomina modo de mapeo de clave-valor, es decir, un cierto valor se puede encontrar a través de una determinada clave.
//声明字典[param1:param2]，这种结构用于表示字典类型，param1 为键类型，param2 为值类型
var dic1:[Int:String]
//这种方式和[:]效果一样，dic2 与 dic1 为相同的类型
var dic2:Dictionary<Int,String>
//字典创建与赋值
dic1 = [1:"1",2:"2",3:"3"]
dic2 = Dictionary(dictionaryLiteral: (1,"1"),(2,"2"),(3,"3")) //在创建字典时，也可以不显式声明字典的类型，可以通过赋初值的方式来使编译器自动推断
var dic3 = ["1":"one"]
//创建空字典
var dic4:[Int:Int] = [:]
var dic5:Dictionary<Int,Int> = Dictionary()
Los diccionarios usan claves para encontrar valores específicos. Los valores se pueden repetir en un diccionario, pero las claves deben ser únicas. Esto garantiza que una clave determinada pueda encontrar un valor determinado y, si el desarrollador crea claves duplicadas en el diccionario, el compilador también informará un error.
El tipo de diccionario también admite el uso de isEmpty y count para determinar si está vacío y obtener la cantidad de elementos.
//获取字典中的元素个数
dic1.count
//判断字典是否为空
if dic4.isEmpty{
print("字典为空")
}
El valor correspondiente a la modificación se puede obtener a través de una clave específica
//通过键操作值 //获取值
dic1[2]
//修改值
dic1[1]="0"
//添加一对新的键值
dic1[4] = "4"
El dic1[1]="0" y dic1[4]="4" en el código anterior en realidad completan la misma operación, que se puede entender de la siguiente manera: al asignar un valor a una clave, si la clave existe, será be La actualización del valor, si la clave no existe, se agregará un nuevo par de clave y valor. Sin embargo, en desarrollo, en muchos casos, es necesario actualizar una clave existente. Si la clave no existe, no se agregará ningún nuevo par clave-valor. Para lograr este efecto, puede utilizar el método de actualización de clave-valor de el diccionario
//对键值进行更新
dic1.updateValue("1", forKey: 1)
El método updateValue(value:forkey:) se usa para actualizar un par clave-valor existente, donde el primer parámetro es el nuevo valor y el segundo parámetro es la clave que se actualizará. Este método devolverá un valor de tipo Opcional cuando se ejecute. Si la clave existe en el diccionario, la actualización se realizará correctamente y el valor anterior de la clave se envolverá en un valor Opcional y se devolverá. Si la clave no existe, se devolverá cero. En desarrollo, la estructura if-let se usa a menudo para manejar
if let oldValue = dic1.updateValue("One", forKey: 1) {
print("Old Value is \(oldValue)")
}
De hecho, cuando el valor del diccionario se obtiene a través de la clave, también se devuelve un valor Opcional. Si la clave no existe, el valor Opcional es nulo, por lo que la estructura if-let también se puede utilizar para garantizar la seguridad de el programa.
//通过键获取的数据也将返回Optional类型的值，也可以使用
if let if let value = dic2[1] {
print("The Value is \(value)") }
下面的方法可以实现对字典中键值对的删除操作:
//通过键删除某个键值对
dic1.removeValue(forKey: 1)
//删除所有键值对
dic1.removeAll()
Al recorrer un diccionario, puede recorrer la colección de todas las claves en el diccionario, o puede recorrer la colección de todos los valores en el diccionario. Puede obtener todas las claves y todos los valores del diccionario a través de el atributo de claves y el atributo de valores de la instancia del diccionario.
//通过键来遍历字典
for item in dic2.keys {
print(item)
}
//通过值来遍历字典
for item in dic2.values {
print(item)
}
//直接遍历字典
for item in dic2 {
print(item)
}
for (key,value) in dic2 {
print("\(key):\(value)")
}
También puede atravesar directamente la instancia del diccionario, y la clave y el valor de un diccionario envolvente de tipo tupla se devolverán durante el recorrido.
Al atravesar claves o valores de diccionario, también admite la clasificación transversal
for item in dic2.keys.dic2.keys.sorted(by: >) {
print(dic2[item]!)
}
Operadores básicos y control de flujo de programa
- Operador unario: un operador unario actúa sobre un operando, que puede aparecer delante del operando, como los operadores positivo y negativo "+" y "-", y el operador lógico NOT "!".
- Operadores binarios: Los operadores binarios actúan entre dos operandos, como los operadores de suma y resta "+" y "-".
- Operador ternario: el operador ternario actúa sobre tres operandos. Los operadores ternarios clásicos incluyen operadores de signo de interrogación y de signo y, que
pueden realizar fácilmente estructuras simples de juicio y selección.
//字符串赋值
var str = "Hello, playground" //整型赋值
var count = 5
//元组赋值
var group = (1,2,"12")
//Bool 赋值
var bol = true
Si desea asignar los valores en una tupla al valor especificado a su vez, Swift también admite el uso de la sintaxis de asignación de desestructuración para la asignación
Los operadores de asignación se utilizan para pasar valores, y el resultado es que a la cantidad se le asigna un valor específico. Los operadores de igualdad se utilizan para operaciones de comparación, que devuelven un valor lógico de tipo Bool
Desde la versión 2.2 del lenguaje Swift, se eliminaron el operador de incremento automático "++" y el operador de decremento automático "–".
Estos dos operadores no se pueden usar en la versión actual del lenguaje Swift.
operador coalescente nulo
El tipo de valor opcional es una característica única del lenguaje Swift, y el operador de fusión nulo es un operador diseñado para el tipo de valor opcional
var q:Int? = 8
var value:Int
if q != nil {
value = q!
} else {
value = 0
}
El ejemplo anterior es una estructura simple de selección if-else Usando el operador condicional (operador ternario) presentado en la Sección 4.1.5, el código anterior se puede abreviar de la siguiente manera
var q:Int? = 8
var value:Int
value = (q != nil) ? (q!) : 0
El código reescrito usando el operador condicional es mucho más simple. El lenguaje Swift también proporciona un operador coalescente nulo para manejar de manera más concisa la estructura de selección condicional de este valor de tipo opcional. El operador coalescente nulo está representado por "??", y el código anterior puede reescribirse como sigue:
//空合并运算符
var q:Int? = 8
var value:Int value = q ?? 0
El operador coalescente nulo "??" es un operador binario, y el código reescrito usando el operador coalescente nulo es más conciso. Requiere dos operandos. El primer operando debe ser un valor opcional. Si el valor opcional no es nulo, se desempaquetará y se usará como resultado de la operación de fusión nula. Si el valor de este Optional es nil, el segundo operando se devuelve como resultado de la operación de fusión nula. Es conveniente usar el operador coalescente nulo para manejar la lógica de selección sobre valores opcionales
operador de intervalo
Además de admitir la estructura Range para describir el rango, Swift también proporciona un operador de intervalo para expresar el intervalo del rango de forma rápida e intuitiva.
//创建范围 >=0 且<=10 的闭区间
var range1 = 0...10
//创建范围>=0 且<10 的半开区间
var range2 = 0..<10
También puede usar el operador "~=" para verificar si un número está contenido en un rango
//8 是否在 range1 中
print(range1 ~= 8) //输出 true
Los operadores de intervalo se usan comúnmente en estructuras de bucle for-in. Los desarrolladores suelen usar operadores de intervalo para definir el número de bucles. Los ejemplos son los siguientes:
//a...b 为闭区间写法
for index in 0...3 {
print(index)
}
//a..<b 为左闭右开区间
for index in 0..<3 {
print(index)
}
En la estructura del bucle for-in, si la palabra clave in va seguida de una colección, la variable index obtendrá automáticamente los elementos de la colección; si la palabra clave in va seguida de un rango, el índice obtenido se recorre de izquierda a derecha. número de índices de rango a alcanzar.
estructura de bucle
estructura de bucle for-in
Los lectores no son ajenos a la estructura for-in, y muchos de los contenidos presentados en los capítulos anteriores utilizan la estructura for-in para demostración. Si el lector comprende el lenguaje C/Objective-C, debe tenerse en cuenta aquí que la estructura de bucle for-in también es compatible con el lenguaje C/Objective-C, pero se denomina recorrido rápido y las operaciones de bucle se realizan con él. están fuera de servicio. La estructura for-in en el lenguaje Swift es mucho más poderosa, puede realizar un recorrido de bucle desordenado y también puede realizar un recorrido de bucle ordenado.
//将打印 1，2，3，4，5
for index in 1...5 {
print(index) }
La estructura for-in requiere dos parámetros. El segundo parámetro puede ser una instancia de un tipo de colección o un intervalo de rango. El primer parámetro es un parámetro de captura. Los elementos recorridos desde el segundo parámetro cada vez que se le asignarán, y los desarrolladores pueden usarlo directamente en la estructura de bucle.
Al realizar un recorrido de bucle for-in, los desarrolladores no necesitan capturar los valores recorridos y pueden usar parámetros anónimos para recibirlos.Swift usa el símbolo "_" para representar parámetros anónimos.
//如果不需要获取循环中的循环次序，可以使用如下方式 var sum=0;
for _ in 1...3 {
sum += 1 }
El recorrido de colecciones es uno de los escenarios de uso común de bucles for-in, que se han presentado en detalle en los capítulos anteriores que explican los tipos de colección.
//遍历集合类型
var collection1:Array = [1,2,3,4]
var collection2:Dictionary = [1:1,2:2,3:4,4:4] var collection3:Set = [1,2,3,4]
for obj in collection1 {
print(obj) }
for (key , value) in collection2 {
print(key,value)
}
for obj in collection3 {
print(obj) }
estructura de bucle condicional while y repeat-while
Las estructuras while y repeat-while también son compatibles con el lenguaje C/Objective-C, y las funciones son básicamente las mismas, pero el lenguaje Swift cambia la estructura do-while a repeat-while.
En desarrollo, a menudo existe la necesidad de circulación condicional, como simular el proceso de almacenamiento de agua en una piscina, almacenar 1/10 del agua cada vez y detener el almacenamiento de agua cuando está lleno. La estructura de ciclo while puede ser muy conveniente para crear este tipo de código de ciclo
var i=0
//当 i 不小于 10 时跳出循环 while i<10 {
print("while",i) //进行 i 的自增加 i+=1
}
En la estructura del ciclo while, después de la palabra clave while, debe completar un valor lógico o una expresión con un valor lógico como resultado de la condición del ciclo. Si el valor lógico es verdadero, el programa ingresará al cuerpo del ciclo while. bucle. Después de que se ejecuta el código del cuerpo del ciclo, se juzga la condición del ciclo. Si la condición del ciclo sigue siendo verdadera, se ingresará nuevamente el cuerpo del ciclo; de lo contrario, el ciclo finaliza. Dado que el ciclo while juzga si ingresar al cuerpo del ciclo en función de la condición del ciclo, si la condición del ciclo siempre es verdadera, se repetirá infinitamente. Por lo tanto, al usar el ciclo while, los desarrolladores deben prestar atención para modificar la condición del ciclo en el ciclo. cuerpo y modificar El resultado es que la condición del bucle no se cumple, de lo contrario se producirá un bucle infinito.
//使用 Switch 语句进行元组的匹配
var tuple = (0,0)
switch tuple {
//进行完全匹配
case (0,1):
print("Sure")
//进行选择性匹配
case (_,1):
print("Sim")
//进行元组元素的范围匹配
case(0...3,0...3):
print("SIM")
default:
print("") }
Como se muestra en el código anterior, hay 3 formas de elegir al emparejar tuplas: la primera forma es la coincidencia exacta, es decir, todos los elementos de la tupla deben ser completamente iguales antes de que la coincidencia sea exitosa; la segunda forma es la coincidencia opcional, que Es decir, el desarrollador solo necesita especificar algunos elementos en la tupla para la coincidencia, y los elementos que no necesitan ser afectados pueden ser reemplazados por identificadores de parámetros anónimos. De esta manera, siempre que los parámetros especificados sean iguales, la coincidencia es exitoso; el tercero El primer método es la coincidencia de rango, es decir, el rango especificado por la posición correspondiente contiene el valor de la posición correspondiente de la tupla que debe coincidir, incluso si la coincidencia es exitosa. El segundo método de coincidencia se puede combinar con el tercer método de coincidencia.
La cláusula de caso en el lenguaje Swift también puede capturar los parámetros de la tupla de cambio, y los parámetros capturados se pueden usar directamente en el bloque de código de caso correspondiente. Esto está en desarrollo El código escrito se puede simplificar en
var tuple = (1,0) //进行数据绑定
switch tuple {
//对元组中的第一个元素进行捕获
case (let a,1):
print(a)
case (let b,0):
print(b)
//捕获元组中的两个元素，let(a,b) 与 (let a,let b)意义相同
case let(a,b):
print(a,b)
default:
print("")
}
Los lectores aquí deben prestar atención a que los elementos que se van a capturar no pueden desempeñar un papel coincidente. Por ejemplo, hay dos elementos en la tupla. Si la condición del caso es (sea a, 1), el segundo elemento de la tupla coincidirá. al hacer coincidir el parámetro, si la coincidencia es exitosa, el valor del primer parámetro de la tupla se pasará a la constante a, y en este caso se ejecutará el bloque de código En este bloque de código, el desarrollador puede usar directamente la constante a. Por lo tanto, el elemento que se va a capturar en realidad actúa como un identificador anónimo al hacer la coincidencia, como la cláusula del tercer caso en el código anterior, su condición es let(a,b), de hecho, esta condición siempre se emparejará con éxito. Además, si el desarrollador captura todos los elementos de la tupla, en términos de rendimiento del código, puede escribirse como (let a, let b), o puede capturar directamente toda la tupla como let(a, b). las formas solo son diferentes en la escritura, y no hay diferencia en el uso.
var tuple = (0,0) //进行数据绑定
//对于进行了数据捕获的 Switch-case 结构，可以使用 where 关键字来进行条件判断
switch tuple {
case (let a,1):
print(a)
//当元组中的两个元素都等于 0 时才匹配成功，并且捕获第一个元素的值
case (let b,0) where b==0:
print(b) //当元组中的两个元素相同时，才会进入下面的case
case let(a,b) where a==b:
print(a,b)
default:
print("")
}
Declaración de salto de flujo en lenguaje Swift
La declaración de salto puede interrumpir la estructura del bucle por adelantado y también puede controlar artificialmente el salto de la estructura seleccionada, lo que hace que la ejecución del código sea más flexible y modificable. Swift proporciona una gran cantidad de declaraciones de salto de proceso para que las usen los desarrolladores. La familiaridad con la estructura y las características de estas declaraciones puede mejorar en gran medida la eficiencia del desarrollo. Las declaraciones de salto de flujo que se proporcionan en Swift incluyen principalmente declaraciones de continuar, romper, fallar, devolver, lanzar y guardar
continuar utilizadas en la estructura del bucle, cuya función es omitir este bucle e iniciar el siguiente directamente. Cabe señalar aquí que la función de continuar no es saltar fuera de la estructura del bucle, sino omitir este bucle y ejecutar directamente el siguiente ciclo.
for index in 0...9 {
if index == 6 {
continue
}
print("第\(index)次循环")
}
El alcance de la operación predeterminada de la instrucción continue incluye directamente su estructura de bucle. Si hay varias capas de estructuras de bucle anidadas en el código, la instrucción continue omitirá este bucle. Entonces, si desea omitir este ciclo, pero salte directamente a la capa de estructura de ciclo especificada por el desarrollador
MyLabel:for indexI in 0...2 {
for indexJ in 0...2 {
if indexI == 1 {
continue MyLabel
}
print("第\(indexI)\(indexJ)次循环")
}
}
El código anterior crea una estructura de bucle de dos capas. La instrucción continue se usa en el bucle interno para saltar, MyLabel es la etiqueta del bucle externo, por lo que el salto continuo aquí saltará fuera del bucle externo cuando indexI sea igual a 1 , e inicie directamente la operación de bucle con indexI igual a 2.
La sentencia break es una sentencia de interrupción, que también se puede utilizar en una estructura de bucle. A diferencia de la sentencia continue, la sentencia break interrumpirá directamente la estructura de bucle que la contiene directamente, es decir, cuando la estructura de bucle es una capa, si el bucle no se ha ejecutado, entonces se omitirán todos los bucles posteriores. Si hay varias capas de estructura de bucle, el programa interrumpirá directamente la estructura de bucle que lo contiene directamente y continuará ejecutando la estructura de bucle fuera de la estructura de bucle.
for index in 0...9 {
if index == 6 {
break
}
print("第\(index)次循环")
}
El código anterior usa una declaración de interrupción para interrumpir cuando el índice es igual a 6, y se omitirá toda la información de impresión después del quinto ciclo. La declaración de ruptura romperá la estructura de bucle que la contiene directamente de forma predeterminada, y también puede usar la etiqueta especificada para romper la estructura de bucle especificada
MyLabel:for indexI in 0...2 {
for indexJ in 0...2 {
if indexI == 1 {
break MyLabel
}
print("第\(indexI)\(indexJ)次循环")
}
}
La instrucción break también se puede utilizar en la estructura switch. En la estructura del interruptor, la instrucción break interrumpirá directamente todos los procesos de coincidencia posteriores y saltará directamente fuera de la estructura del interruptor. En el lenguaje Swift, la estructura de coincidencia de selección de caso de conmutación tiene como valor predeterminado la operación de interrupción, por lo que los desarrolladores no necesitan agregar manualmente el código de interrupción. La declaración fallthrough
es una declaración de control de flujo única en Swift. Como se mencionó anteriormente, cuando la case en el lenguaje Swift Después de que la estructura coincida con un caso, interrumpirá automáticamente la operación de coincidencia de todos los casos posteriores. Si la estructura switch-case no interrumpe automáticamente la operación en el desarrollo real, puede usar la declaración fallthrough
var tuple = (0,0)
switch tuple {
case (0,0):
print("Sure")
//fallthrough 会继续执行下面的 case
fallthrough
case (_,0):
print("Sim")
fallthrough
case(0...3,0...3):
print("SIM")
default:
print("")
}
La declaración de retorno debe ser muy familiar para el lector.Se usa en una función para devolver un valor de resultado, y también se puede usar para terminar una función que no devuelve un tipo de valor antes de tiempo. Por supuesto, los escenarios de aplicación de la declaración de devolución no se limitan a funciones, y la devolución también se puede usar en cierres para devolver
//有返回值函数的返回
func myFunc()->Int{
return 0
}
//无返回值函数的返回
func myFunc(){
return
}
La sentencia throw se utiliza para lanzar excepciones.Si la excepción lanzada por la sentencia throw no se detecta y procesa, el programa también se interrumpirá.
//定义异常类型
enum MyError:Error{
case errorOne
case errorTwo
}
func newFunc() throws{
//抛出异常
throw MyError.errorOne
}
La declaración de estructura guard-else es una nueva estructura gramatical agregada después de Swift 2.0. El equipo de Swift la creó para aclarar la estructura y la lógica del código. En el desarrollo real, especialmente en la escritura de funciones, a menudo se encuentra este escenario: cuando los parámetros cumplen una determinada condición, la función se puede ejecutar normalmente; de lo contrario, la ejecución de la función finaliza directamente mediante el retorno, si no utiliza estructura guard-else
Aplicación básica de funciones.
Estructura gramatical de los cierres
