Directorio de artículos
Prefacio
Recientemente, he estado aprendiendo Swift y escribiendo proyectos. Siento que el lenguaje es simple y seguro. Después de aprender la sintaxis básica y algunos conocimientos necesarios, debido a que la interfaz de usuario de OC también usa diseño automático, también exploré el diseño automático de Swift. Biblioteca SnapKit , grábalo brevemente.
patio de juegos
Conviene abrir un patio de recreo para practicar la gramática,
a veces algunas cosas no se pueden recopilar y recordar.
var y let-tuplas
import UIKit
var greeting = "Hello, playground"
var str = "hello"
str += "11"
print(str)
var a:Int = 1, b: String = "2", c:Double = 3.0
print(a, b, c)
print("b.count =", b.count, "sss")
var smile = "smile\n"
print(smile)
// 不能数字命名开头
//var 1x = 12;
//print(1x)
// 元组
var person:(name:String, age:Int) = ("iOS", 19)
print(person.name)
var car:(String, Int) = ("Benz", 10000)
var (theName, thePrice) = car
print(theName, thePrice)
// 匿名
// 在Swift语言中，常常使用符号“_”来表示匿名的概念，因此“_”也被称为匿名标识符。
var (theName1, _) = car
var obj: String? // 在普通类型后面添加符号“?”，即可将普通类型包装为Optional类型。
// 在Swift语言中，未做初始化的普通类型是不允许使用的
if obj == nil {
print("!obj")
}
// 在使用“!”进行Optional值的拆包操作时，必须保证要#包的值不为nil，否则程序运行会出错。可以在拆包前使用if语句进行安全判断
//声明obj为String?类型
var obj2: String? = "safe"
if obj != nil {
obj!
}
// if-let结构中也可以同时进行多个Optional类型值的绑定
// 只有所有Optional值都不为nil，绑定才会成功，代码执行才会进入if为真的代码块中
var curObj: Int? = 9
if let temp = curObj {
print(temp)
} else {
curObj = 10;
}
// 当我们明确某个变量初始时为nil，并且在之后使用之前一定会被赋值时，我们可以将其声明为隐式解析的可选值，再对这个变量进行使用，就不需要进行拆包操作了
// 声明obj4为隐式解析的变量
var obj4:Int!
obj4 = 3
// 在使用时，无须再进行拆包操作，Swift会自动帮我们拆包
print(obj4 + 1)
matriz-diccionario-cadena
import UIKit
var greeting = "Hello, playground"
var str = String(describing: Int.self)
var a = Int(1.9)
var my = "jackDao"
// 符串插值方法
// \()”结构可以将其他数据类型转换为字符串类型并且插入字符串数据的相应位置，也可以进行简单的运算逻辑后将结果插入原字符串中
var myself = "my name is \(my)"
print(myself)
MemoryLayout<String>.size //16个字节 获取String类型占用的内存空间
var e:Character = "a"
var e2: [Character] = ["H", "E", "L", "L", "O"]
var e3 = String(e2)
// 使用for-in遍历可以将字符串中的字符拆解出来，这种方法有时十分好用，for-in遍历是Swift语言中一种重要的代码流程结构。String类型默认实现了迭代器相关协议，直接对其进行遍历可以取出字符串中的每一个字符元素
for charceter in e2 {
print(charceter)
}
//判断字符串是否为空
var obj1 = ""
if obj1.isEmpty {
print("字符串为空字符串")
}
// 在比较两个字符串的大小时，会逐个对字符的大小进行比较，直至遇到不相等的字符为止
var cp1 = "comp1", cp2 = "comp2"
if cp1 < cp2 {
print("cp1 is Small")
}
var string2 = "My name is Jaki"
//全部转换为大写
string2 = string2.uppercased() //结果为"MY NAME IS JAKI"
//全部转换为小写
string2 = string2.lowercased() //结果为"my name is jaki"
//检查字符串是否有My前缀
string2.hasPrefix("My")
//检查字符串是否有jaki后缀
string2.hasSuffix("jaki")
var array: Array<Int>
var array2: [Int]
array = []
array2 = Array()
array = [1, 2, 3]
array2 = Array(arrayLiteral: 1, 3, 4)
var array3 = [String](repeating: "Hello", count: 10);
var array4 = Array(repeating: 1, count: 10)
//声明字典[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()
1==2 //等于比较，返回false
1<2 //小于比较，返回true
1>2 //大于比较，返回false
1 != 2 //不等于比较，返回true
1<=2 //小于等于比较，返回true
1>=2 //大于等于比较，返回false
for index in 1...10 {
print(index)
}
var sum = 0
for _ in 1...10 {
sum += 1
}
- La brecha entre el diccionario de Swift y OC todavía es relativamente grande.
swiftCualquier tipo en Swift debe dejar claro su tipo al declararlo. A través del estudio deArrayySet, los lectores deben saber que para los tipos de colección, el tipo de sus elementos internos debe quedar claro cuando declarando Los diccionarios no son una excepción - Hoy probé la interfaz de Zhihu Daily y descubrí que no puede acceder directamente a un elemento en múltiples niveles similar a OC, y se informará un error.
- Se requieren las siguientes operaciones para iterar a través de matrices anidadas en el diccionario, pero aún es difícil lograr un acceso único de varios niveles. Más adelante, aún necesitará aprender la biblioteca JSONModel de Swift, que también es una biblioteca de terceros y debería No será muy diferente de OC.
if let stories = dict["stories"] as? [[String: Any]] {
for story in stories {
if let title = story["title"] as? String {
print("Title: \(title)")
}
if let content = story["content"] as? String {
print("Content: \(content)")
}
if let tags = story["tags"] as? [String] {
for tag in tags {
print("Tag: \(tag)")
}
}
// 其他键值对的访问...
}
}
Cierre
import UIKit
var greeting = "Hello, playground"
// 一个完整的函数包含函数名、参数列表、返回值和函数体，示例如下：
//标准函数，这个函数的功能是计算某个整数的平方
func myFunc(param: Int) -> Int {
return param * param
}
// 将上面函数的功能使用闭包来实现，代码如下：
//闭包的实现方式
let myClosures = {
(param1: Int) -> Int in
return param1 * param1
}
/*闭包在语法上有这样的标准结构：{(参数列表)->返回值in闭包体}。首先闭包的最外层由大括号包围，内部由闭包关键字in来进行分割，关键字in前面为闭包结构的参数列表和返回值，其书写规则与函数一致，关键字in后面为闭包体，用于实现具体功能*/
//对函数进行调用，将返回9
myFunc(param: 3)
//对闭包进行调用，将返回9
myClosures(3)
// 闭包的返回值是可以省略的
//闭包的实现方式
let myClosures2 = {
(param:Int) in
return param * param
}
var x = myClosures2(2)
var x1 = myClosures(2)
// 自定义前缀运算符
prefix operator ++;
prefix func ++(param1: Int) -> Int {
return param1 + 1;
}
var num = 10
++num // num++ error
enumeración
import UIKit
var greeting = "Hello, playground"
enum Surname {
case 赵, 钱, 孙, 李
}
//var sur: Surname
var sur = Surname.孙
clases y objetos
import UIKit
var greeting = "Hello, playground"
struct Car {
var price: Int
var brand: String
var pertol: Int
mutating func addPertol() {
if pertol <= 0 {
pertol += 1
print("add Pertol")
}
}
//在默认情况下，结构体和枚举的实例方法是不允许修改实例属性的，除非将方法标记为mutating。使用mutating关键字修饰的方法可以在方法内部修改实例属性，并且在方法执行完毕后，这些修改将会保持在实例中。
mutating func drive() {
if pertol > 0 {
pertol -= 1
print("drive 10 kilometers")
}
}
}
var car = Car(price: 10000, brand: "Benz", pertol: 5)
print("this \(car.brand) price is \(car.price), have \(car.pertol) pertol")
for _ in 1...10 {
if car.pertol == 0 {
car.addPertol()
} else {
car.drive()
}
}
// 在默认情况下，结构体和枚举的实例方法是不允许修改实例属性的，除非将方法标记为mutating。使用mutating关键字修饰的方法可以在方法内部修改实例属性，并且在方法执行完毕后，这些修改将会保持在实例中。
// 对引用类型进行比较操作，应使用等同运算符“===”
// Array、String、Dictionary、Set这些数据类型都是采用结构体来实现的，这点和Objective-C有着很大的区别。因此，在Swift语言中，Array、String、Dictionary、Set在数据传递时总是会被复制
Atributos
import UIKit
// 监听
var greeting = "Hello, playground"
class Teacher {
var name: String {
willSet(new) {
print("将要设施的新名字:\(new)")
} didSet(old) {
print("旧名字\(old)")
}
}
var age: Int
init(name: String, age: Int) {
self.name = name
self.age = age
}
}
var teacher = Teacher(name: "jackLi", age: 19)
teacher.name = "lyt"
// 对比类属性，Swift语言中的类方法也是通过static和class关键字来声明的，static关键字声明的类方法又被称为静态方法，其不能被子类覆写，而class关键字声明的类方法可以被类的子类覆写
amable
import UIKit
var greeting = "Hello, playground"
// 对于有继承关系的类，类型检查有如下原则：子类实例进行父类类型的检查可以检查成功。父类实例进行子类类型的检查不可以检查成功。
var str = "Hello ios"
if str is String {
print("greeting is String")
}
// 其实如果数组中的元素是不同类型，并且这些类型没有一个共同的基类，那么开发者可以使用AnyObject来作为引用类型的通用类型
// AnyObject是通用的引用类型
class myClassOne {
}
class myClassTwo {
}
class myClassthree {
}
var c1 = myClassOne()
var c2 = myClassTwo()
var c3 = myClassthree()
var classArray: Array<AnyObject> = [c1, c2, c3]
for objclass in classArray {
print(objclass)
}
// 在Swift语言中还提供了一种更加通用的类型Any，它可以用来描述任意类型，包括值类型和引用类型
print("anyClass")
var anyClassArray: Array<Any> = [c1, c2, c3, (1, 1), "anyType"]
for objclass in anyClassArray {
print(objclass)
}
interfaz de usuario
La diferencia con OC es más concisa.
En primer lugar, el lenguaje no tiene un archivo de interfaz al principio. La interfaz y la implementación están en un solo archivo, y puedo hacer referencia a ciertos ViewControllers en algunas interfaces sin escribir archivos de encabezado, a menos que existan bibliotecas específicas de terceros.
Carga lenta
- Continuando con la idea de carga diferida
- La sintaxis es simple y directa + la palabra clave lazy requiere var pero no let
- Simplemente llame al método de forma anónima en el método de inicio superior
lazy var mainBackImageView: UIImageView = {
let image1: UIImage = UIImage(named: "MainBack.png")!
let imageView: UIImageView = UIImageView(image: image1)
self.addSubview(imageView)
imageView.snp .makeConstraints {
make in
make.width.equalTo(SIZE_WIDTH + 17)
make.height.equalTo(SIZE_HEIGHT + 17)
make.left.equalTo(-7)
make.top.equalTo(-7)
}
return imageView
}()
archivo global
Cuando trabajaba en Swift, originalmente usé macros para definir el tamaño de la pantalla, etc., y luego descubrí el archivo global.
El contenido definido en un archivo global se puede utilizar en varios archivos y se puede acceder a él en cualquier momento.
- Por ejemplo, definí algunos colores de fondo, largo y ancho para usar en algunos proyectos en el archivo global.
- Hoy, cuando estaba escribiendo una notificación para pasar valor, descubrí que puedo definir el nombre aquí, lo cual es bastante conveniente.
Cómo utilizar el kit de ajuste
Al igual que el uso anterior de bibliotecas de terceros, se pueden utilizar después de descargar el pod.
No se siente diferente de la mampostería.
topytopMargin
En SnapKit, topy topMarginse utilizan dos propiedades de restricción diferentes para establecer el margen superior de una vista.
-
topAtributos:topLa propiedad representa la distancia del margen superior de la vista en relación con el margen superior de su vista de supervisión o de referencia.- Se calcula restringido en relación con el margen superior real de la vista de supervisión o de referencia.
- A menudo, al establecer restricciones, es necesario establecer la distancia entre el margen superior de una vista y su vista principal o de referencia en un valor específico.
-
topMarginAtributos:topMarginLa propiedad representa la distancia del margen superior de la vista en relación con los márgenes de diseño de su supervista.- Está restringido en relación con los márgenes de diseño de la supervisión.
- En comparación con
toplos atributos,topMarginlos atributos tienen en cuenta la influencia de los márgenes del diseño, lo que hace que la posición de la vista sea más adaptable y flexible. - En algunos diseños, especialmente cuando se utiliza AutoLayout y diseño de márgenes, el uso
topMarginde la propiedad puede manejar mejor los cambios y ajustes de los márgenes.
En general, toplas propiedades están restringidas según el margen superior real de la vista, mientras que topMarginlas propiedades están restringidas según los márgenes de diseño de la vista principal. Según sus necesidades de diseño y escenarios de uso, elija las propiedades adecuadas para establecer las restricciones del margen superior de la vista.
No creo que haya mucha diferencia, he estado usando top sin ningún problema.
Resumir
Los diccionarios, matrices y tuplas de Swift no se utilizan mucho al escribir proyectos. Parece haber muchos problemas con los diccionarios, incluido cómo leer en múltiples capas sin informar errores. Todavía hay diferencias entre ellos y OC. Voy a resumir después de estudiarlos.