Swift学习笔记24-从OC到Swift
·
MARK/TODO/FIXME注释
MARK、TODD、FIXME都是注释
MARK:类似OC中的#pragma mark
MARK:- 类似于OC中的#pragma mark -
TODO:用于标记未完成的任务
FIXME:用于标记待修复的问题
条件编译：在什么操作系统/CPU架构/模拟器/Swift版本下编译
//条件编译:在某些条件下才编译
//操作系统:macOS, iOS, tvOS, watchOS, Linux, Android, Windows, FreeBSD
#if os(macOS) || os(iOS) //||是或的意思，其中一个满足就可以编译
#elseif arch(x86_64) || arch(arm64) //CPU架构：i386\\x86_64\\arm\\arm64
#elseif swift(<5) && swift(>=3)//swift版本
#elseif targetEnvironment(simulator) //模拟器
#elseif canImport(Foundation)//可以导入某模块
#else
#endif
#if DEBUG //debug模式 如果定义了 DEBUG 条件，下面的代码将被编译和执行。
#else//release模式 如果没有定义 DEBUG，则执行 #else 后的代码。
#endif // 结束条件编译块。
#if TEST
print("test")
#endif
#if OTHER
print("other")
#endif
//打印
func log<T>(_ msg:T,
file: NSString = #file,
line: Int = #line,
fn: String = #function) {
#if DEBUG
let prefix = "\\(file.lastPathComponent)_\\(line)_\\(fn):"
print(prefix, msg)
#endif
}
系统版本检测
//系统版本检测
if #available(iOS 10, macOS 10.12, *) {//这是一个API用于检测系统版本
//对于iOS平台，只在iOS10及以上版本执行
//对于macOS平台，只在macOS 10.12及以上版本执行
//最后的*表示在其他所有平台都执行
}
//API可用性说明
@available(iOS 10, macOS 10.15, *) //就是控制版本的
class Person {}
struct Student {
@available(*, unavailable, renamed: "study")
func study_() {}
func study() {}
@available(iOS, deprecated: 11)
@available(macOS, deprecated: 10.12)
func run(){}
}
更多用法：https://docs.swift.org/swift-book/ReferenceManual/Attributes.html
iOS程序的入口 在AppDelegate上面默认有个@UIAppicationMain标记，这表示编译器自动生成入口代码(Main函数代码)，自动设置AppDelegate为APP的代理 也可以删掉@UIApplicationMain，自定义入口代码：新建一个main.swift文件。
@UIApplicationMain 的作用:
在 AppDelegate 类上方使用 @UIApplicationMain 标记，表示这个类是应用的入口点。 编译器会自动生成一个名为 main 的函数，负责启动应用并设置应用的生命周期。 AppDelegate 的角色:AppDelegate 是 iOS 应用的核心，它负责处理应用的生命周期事件（如启动、进入后台、进入前台等）。 该类中的方法会在适当的时刻被系统调用，允许开发者在这些事件发生时执行特定的代码。
Swift调用OC
在Swift里创建一个OC文件，注意要在cocoa class里创建，并选择OC，默认勾选所有，就会出现两个OC文件，一个后缀为.h,一个后缀为.m。系统就会额外自动创建一个桥接头文件，名字默认为{targetName}-Bridging-Header.h
这是Swift文件↓(main)
//
// main.swift
// class24-2
//
// Created by sakiko on 2026/4/10.
//
import Foundation
print("Hello, World!")
print("Hello, World!")
var p = MJPerson(age: 10, name: "Jack")
p.age = 18
p.name = "Rose"
p.run()//18 Rose -run
p.name = "Rose"
p.run()
p.eat("Apple", other: "Water")//18 Rose -eat Apple Water
MJPerson.run()//Person +run
MJPerson.eat("Pizza", other: "Banana")//Person +eat Pizza Banana
print(sum(10, 20))//30
/*C语言
int sum(int a, int b) {
return a + b;
}
*/
//Swift
//如果C语言暴露给Swift的函数名和Swift中的其他函数名冲突了，可以用@_silgen_name修改C函数名
@_silgen_name("sum") func swift_sum(_ v1: Int32, _ v2: Int) -> Int32
print(swift_sum(10, 20))
这是OC文件.h
//
// MJPerson.h
// class24-2
//
// Created by sakiko on 2026/4/10.
//
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
int sum(int a, int b);
@interface MJPerson : NSObject
@property (nonatomic, assign) NSInteger age;
@property (nonatomic, copy) NSString *name;
- (instancetype)initWithAge: (NSInteger)age name:(NSString *)name;
+ (instancetype)personWithAge:(NSInteger)age name:(NSString *)name;
- (void)run;
+ (void)run;
-(void)eat: (NSString *)food other:(NSString *)other;
+(void)eat: (NSString *)food other:(NSString *)other;
@end
NS_ASSUME_NONNULL_END
这是OC文件.m
//
// MJPerson.m
// class24-2
//
// Created by sakiko on 2026/4/10.
//
#import "MJPerson.h"
NS_ASSUME_NONNULL_BEGIN
@implementation MJPerson
- (instancetype)initWithAge:(NSInteger)age name:(NSString *)name {
if (self = [super init]) {
self.age = age;
self.name = name;
}
return self;
}
+ (instancetype)personWithAge:(NSInteger)age name:(NSString *)name {
return [[self alloc] initWithAge:age name:name];
}
+ (void)run { NSLog(@"Person +run");}
- (void)run { NSLog(@"%zd %@ -run", _age, _name); }
+ (void)eat:(NSString *)food other:(NSString *)other { NSLog(@"Person +eat %@ %@", food, other); }
- (void)eat:(NSString *)food other:(NSString *)other {NSLog(@"%zd %@ -eat %@ %@", _age, _name, food, other);}
@end
int sum(int a, int b) {return a + b;}
NS_ASSUME_NONNULL_END
OC调用Swift
这是OC文件，名字是main.m，在OC里创建Swift文件会自动生成头文件。头文件的文件名是{targetName}-Swift.h
可以通过@objc重命名暴露给OC的符号名（类名、属性名、函数名等）
//
// main.m
// class25
//
// Created by sakiko on 2026/4/11.
//
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here...
NSLog(@"Hello, World!");
}
return EXIT_SUCCESS;
}
#import "class25-Swift.h"
int sum(int a, int b) {
Car *c = [[Car alloc] initWithPrice:10.5 band:@"BMW"];
c.band = @"Bently";
c.price = 108.5;
[c run];
[c test];
[Car run];
return a + b;
}
这是头文件：其实就是连接两种语言的文件，在这里写入一些文件
//
// Use this file to import your target's public headers that you would like to expose to Swift.
//
//这是在OC中创建Swift文件时会自动创建的头文件
@interface Car : NSObject //这个NSObject是必须要用到的库，创建文件的时候就要选的
@property(nonatomic) double price;
@property(nonatomic, copy)NSString * _Nonnull band;
- (nonnull instancetype)initWithPrice:(double)price band:(NSString * _Nonnull)bamd OBJC_DESIGNATED_INITIALIZER;
- (void)run;
+ (void)run;
- (nonnull instancetype)init SWIFT _UNAVAILABLE;
- (nonnull instancetype)new SWIFT _UNAVAILABLE_MSG("-init is unavailable");
@end
@interface Car (SWIFT_EXTENSION(class25_Swift))
- (void)test;
@end
这是OC中的Swift文件，命名为Car.swift
Swift中依然可以使用选择器
//
// Car.swift
// class25
//
// Created by sakiko on 2026/4/11.
//
import Cocoa
import Foundation
@objcMembers class Car: NSObject { //使用@objcMemers修饰类，代表默认所有成员都会暴露给OC(包括扩展中定义的成员)
var price: Double//最终是否成功暴露，还需要考虑成员自身的访问级别
var band: String
init(price: Double, band: String) {
self.price = price
self.band = band
}
@objc(drive) //可以通过@objc重命名Swift暴露给OC的符号名(类名、属性名、函数名等)
func run() { print(price, band, "run") }
static func run() { print("Car run") }
}
extension Car {
// @objc(exec:v2:) /这有错误，我也不知道为什么错了，总之注释一下。。。
func test() { print(price, band, "test") }
}
/*这有错误，我也不知道为什么错了，总之注释一下。。。
MJCar *c = [[MJCar alloc] initWithPrice:10.5 band:@"BMW"];
c.name = @"Bently";
c.price = 108.5;
[c drive];
[c exec:10 v2:20];
[MJCar run];
*/
//Swift中依然可以使用选择器，使用#selector(name)定义一个选择器
//必须是被@objcMemers或@objc修饰的方法才可以定义选择器
//选择器是用于标识和调用对象方法的一种机制，特别是在 Objective-C 和 Swift 之间交互时非常常用。
@objcMembers class Person: NSObject {
func test1(v1: Int) { print("test1") }
func test2(v1: Int, v2: Int) { print("test2(v1:v2:)")}
func test2(_ v1: Double, _ v2: Double) { print("test2(_:_:)")}
func run() {
perform(#selector(test1))//使用选择器调用 test1 方法
perform(#selector(test1(v1:)))//使用选择器调用带参数的 test1 方法
perform(#selector(test2(v1:v2:)))//使用选择器调用带参数的 test1 方法
perform(#selector(test2(_:_:)))//使用选择器调用带两个双精度参数的 test2 方法
perform(#selector(test2 as (Double, Double) -> Void))//// 调用选择器，指向的方法类型
}
}
//String
//Swift的字符串类型和跟OC的NSString，在API设计上有较大差异
String和SubString及字符串插入移除、相关协议
//
// main.swift
// class24_String这部分是第24课的String部分
//
// Created by sakiko on 2026/4/13.
//
import Foundation
print("Hello, World!")
var emptyStr1 = ""
var emptyStr2 = String()
var str: String = "1"
str.append("_2")
str = str + "_3"
str += "_4"
str = "\(str)_5"
print(str.count)
print(str)//1_2_3_4_5
var str2 = "123456"
print(str2.hasPrefix("123"))
print(str2.hasSuffix("456"))
//是否有前缀和是否有后缀的意思，好像不难理解
//String的插入和删除
var str3 = "1_2"
//字符串插入：
//使用insert(contentsOf)...at或insert...at来插入
str3.insert("_", at: str3.endIndex)
//在结尾插入一个下划线的意思,insert就是插入的意思,一般都是insert...at这样用的
str3.insert(contentsOf: "3_4", at: str3.endIndex)
//在结尾插入"3_4"的意思
str3.insert(contentsOf:"666",at: str3.index(after: str3.startIndex))
//在str3的起始索引之后插入 "666"，结果是1666_2_3_4
str3.insert(contentsOf: "888", at: str3.index(before: str3.endIndex))
//在str3的结尾索引之前插入"888"，结果是1666_2_3_8884
str3.insert(contentsOf: "hello", at: str3.index(str3.startIndex, offsetBy: 4))
//在str3的起始索引的第 4 个字符之后插入 "hello"，结果是1666hello_2_3_8884
print(str3) //1666hello_2_3_8884
/*
参数类型：
insert(contentsOf:)：可以接受完整的字符串（多个字符）。
insert(_:)：只接受一个单独的字符。
插入范围：
insert(contentsOf:)：适用于需要将一段文本插入到字符串中的场合。
insert(_:)：适用于只需插入一个字符的简单情况。
*/
//字符串删除：
//使用remove和removeAll(删除某部分的全部),removeSubrange来删除字符串
str3.remove(at: str3.firstIndex(of: "1")!)
//移除了str3的起始索引中的1
print(str3)//666hello_2_3_8884
str3.removeAll { $0 == "6" }
//删除字符串中所有字符为 "6" 的字符
print(str3)//hello_2_3_8884
var range = str3.index(str3.endIndex, offsetBy: -4)..<str3.index(before: str3.endIndex)//指定了要移除的范围
//..< 表示半开区间，这意味着范围包括开始索引，但不包括结束索引。
//str.index(str3.endIndex, offsetBy: -4)会从 endIndex 向回移动 4 个字符，因此会得到字符 '3' 的位置
//str3.index(before: str3.endIndex)这个方法是获取 endIndex 之前的索引，意味着它返回的是最后一个字符的索引，即指向字符 '4' 的位置
//参数offsetBy:这个参数允许你以 startIndex 为基准，偏移一个指定的数量。
str3.removeSubrange(range)//removeSubrange是用来移除字符串的,移除了这两个位置之间的部分("_888")。
print(str3) //hello_2_3_4
//Substring：是 String 类型的子集，但其类型为 Substring
//String可以通过下标、prefix、suffix等截取子串，子串类型不是String，而是Substring
var str4 = "1_2_3_4_5"
var substr4_1 = str4.prefix(3)//截取了前三位
print(substr4_1)//1_2
var substr4_2 = str4.suffix(3)//截取了后三位
print(substr4_2)//4_5
var range_str4 = str4.startIndex..<str4.index(str4.startIndex, offsetBy: 3)
var substr4_3 = str4[range_str4]
//截取str4第一个索引和第一个索引之后三个(含第一个）之间的部分
print(substr4_3) //1_2
print(substr4_3.base)//base就是基础字符串的意思
//Substring 共享其基础字符串的存储。通过 base 获取基础字符串时，实际上是对原始字符串的一种引用。
var str4_1 = String(substr4_3) //把Substring类型转换为String类型
//当Substring发生修改或转为String时，会分配新的内存存储字符串数据
//String与Character
for c in "jack" {// c是Character类型，所以这里就是遍历每一个字母的意思
print(c)
}
var str5 = "jack"
var c = str5[str5.startIndex]
print(c)//c,取str5的第一个索引
//String相关的协议
// BidirectionalCollection协议包含的部分内容：
//定义:该协议表示支持双向迭代的集合类型。即，集合中的元素可以在前向和反向都进行遍历。
/*1.startIndex(第一个索引), endIndex属性(最后一个索引)、index方法(确定特定字符或子字符串在字符串中的具体位置)
2.String、Array都遵守了这个协议 */
//RangeReplaceableCollection协议包含的部分内容：
//定义: 该协议表示一种可用来替换集合元素的集合类型。这意味着可以通过插入、替换或删除来修改集合中的元素。
/*1.append(添加字符串到后面), insert(插入字符串), remove(移除字符串)方法
2.String, Array都遵守了这个协议 */
//Dictionary, Set也有实现上述协议中声明的一些方法，只是没有遵守上述协议(Set 是一种数据结构，用于存储唯一的元素集合。与数组（Array）不同，集合不允许重复的元素。)
//多行String
let str_1234 = """
1
"2"
3
'4'
"""
print(str_1234)
/*
1
"2"
3
'4'*/
//想要显示三个引号，却不转义，是做不到的。
//如果要显示三个引号，至少转义一个引号。
let str_quote = """
Escaping the first quote \"""
Escaping two quotes \"\""
EScaping all three quotes \"\"\"
"""
print(str_quote)
/*
Escaping the first quote """
Escaping two quotes """
EScaping all three quotes """
*/
//缩进以结尾的3引号为对齐线
let str_12345 = """
1
2
3
4
"""
//三个引号(""")用于定义多行字符串。这种方式允许你在字符串中包含换行符，而无需使用转义字符。
//String 与 NSString
//String与NSString之间可以随时随地桥接转换
//如果String的API太复杂难用，可以考虑将String转为NSString
var str_Jack: String = "jack"
var str_Rose: NSString = "rose"
var str_Jack1 = str_Jack as NSString //将String转换为NSString
var str_Rose1 = str_Rose as String //将NSString转换为String
var str_5 = str_Jack1.substring(with: NSRange(location: 0, length: 2))
//NSRange: NSRange 是表示对象中某个范围的结构体，常用于Foundation框架中。
//同时用到了substring(with:) 方法，它需要一个 NSRange 参数来指定要提取的子字符串的范围。
//location 是范围的起始位置。
//length 是要提取的字符长度。
print(str_5)//ja(起始0长度2)
//String使用==运算符
//NSString使用isEqual方法，也可以使用 == 运算符(本质上还是调用isEqual方法)
//Swift、OC桥接转换表
/*
左Swift 右OC（简单来说就是带OC不带Mutable的都是不可变的，加上了的就是可变的)
String <-> NSString
String <- NSMutableString
可将 Objective-C 中的 NSMutableString（可变字符串）转换为 Swift 中的 String。这通常用于需要动态修改字符串的场景。
Array <-> NSArray
说明 Swift 中的 Array 和 Objective-C 中的 NSArray 之间可以相互转换。NSArray 是不可变的，而 Swift 的 Array 是可变的
Array <- NSMutableArray
说明可以将OC中的 NSMutableArray（可变数组）转换为 Swift 中的 Array。这样可以在 Swift 中动态修改数组
Dictionary <-> NSDictionary
Dictionary <- NSMutableDictionary
Set <-> NSSet
说明 Swift 中的 Set 和 Objective-C 中的 NSSet 可以相互转换。NSSet 是不可变的，而 Swift 的 Set 是可变的
Set <- NSMutableSet
说明可以将 Objective-C 中的 NSMutableDictionary（可变字典）转换为 Swift 中的 Dictionary。这允许在 Swift 中动态地修改字典
*/
只能被class继承的协议、可选协议、dynamic
//只能被class继承的协议：
protocol Runnable_anyo: AnyObject {}
protocol Runnable_cla: class {}
@objc protocol Runnable_pro {}
//被@objc修饰的协议，还可以暴露给OC去遵守实现,完全没看懂？？？
//可选协议：可以通过@objc定义可选协议，这种协议只能被class遵守
@objc protocol Runnable {
func run1()
@objc optional func run2()
func run3()
}
class Dog: Runnable {
func run3() {print("Dog run3")}
func run1() {print("Dog run1")}
}
var d = Dog()
d.run1()//Dog run1
d.run3()//Dog run3
//dynamic：被@objc dynamic 修饰的内容会具有动态性，调用方法会走runtime的流程
//Swift 中的 @objc dynamic 修饰符使得类或方法可以在运行时动态解析，类似于 OC的动态特性。这意味着这些方法在调用时不会直接通过编译时的静态链接，而是通过运行时的消息机制调用。（灵活但速度比较慢）
class Dog2: NSObject {
@objc dynamic func test1() {}//动态调用
func test2() {}
}
var d2 = Dog2()
d2.test1()
d2.test2()KVC\KVO(非常重要)
Swift支持KVC和KVO的条件：
1.属性所在的类、监听器最终继承自NSObject
2.用@objc dynamic修饰对应的属性
KVC数字监听:用于通过字符串来操作属性，灵活且动态。
定义：KVC 是一种通过【字符串键】来【访问对象属性】的机制。你可以用键（属性名）来设值和取值，而不需要直接通过属性访问。
示例：使用 setValue(_:forKey:) 设置属性值，使用 value(forKey:) 获取属性值。
KVO对象监听:用于监控属性的变化，能够在属性值改变时得到通知。
定义：KVO 是一种机制，用于观察对象属性的变化。当属性值发生改变时，可以接收到通知。
示例：在需要观察的对象上添加观察者，重写 observeValue(forKeyPath:of:change:context:) 方法来处理变化通知。
KVO举例1：
class Observer_KVO: NSObject {
//继承自NSObject 。这是一个为监听器,不要取名叫Observer，这是系统类
override func observeValue(forKeyPath keyPath: String?,
//重写这个方法，这是准备进行KVO的操作
of object: Any?,//第二个参数，表示观察的对象。
change: [NSKeyValueChangeKey : Any]?,
context: UnsafeMutableRawPointer?) {
print("observeValue", change?[.newKey] as Any)
}
}
NSKeyValueChangeKey 是一个与KVO相关的枚举，常用于在观察对象的属性变化时指示变化的具体信息。具体来说，它用于表示更改的类型或状态，帮助观察者理解属性值发生了什么变化。
KVC、KVO举例2：
class Person: NSObject {
@objc dynamic var age: Int = 0 //这个监听器是围绕age展开的，观察的是age的变化
var observer: Observer1 = Observer1()
//创建一个 Observer1 类型的实例 observer，用于监听 Person 类的属性变化
override init(){
//重写初始化器，首先调用父类的初始化器以确保父类属性得到正确初始化
super.init()
self.addObserver(observer,
//这是正在进行KVO，就是addObserver这一段是建立监听的手段。这是核心，重中之重！
forKeyPath: "age",
//为observer添加监听，查看age属性的变化。
//指定只获取新值（.new）选项，context 设置为 nil。
options: .new,
context: nil)
}
deinit {
self.removeObserver(observer,//removeObserver是移除监听的意思。
forKeyPath: "age")//在类实例被销毁时，移除observer对age属性的观察，以防止内存泄漏。
}
}
var p = Person()//创建一个 Person 类型的实例 p
p.age = 20 //observeValue Optional(20)
//当 age 属性被设置为 20 时，监听器的observeValue 方法将被调用，输出新的值。
p.setValue(25, forKey: "age") //observeValue Optional(25)
//这是KVC通过 setValue(_:forKey:) 方法进行属性访问。
Block方式的KVO：
闭包长这样：
//闭包,↓这就是一个闭包
func a1(_ v1: Int, _ v2: Int) -> Int{ v1 + v2 }
var a3 = {
(v1: Int, v2: Int) -> Int in
return v1 + v2
}
let sum = {(v1:Int, v2: Int) -> Int in
return v1 + v2 }
//大概就是:某变量/常量 = {(参数)-> (数据类型)函数内容与返回值}
Block长这样：其实就是OC版的闭包。（封装后的闭包就是block）
^返回类型(^参数类型)(参数) {
一些代码
}
块（Block） 是在 Objective-C 中的一种封装代码的方式，使用 ^ 符号。 OC代码，Block举例:
typedef int (^MultiplyBlock)(int, int);
- (void)calculateProduct {
MultiplyBlock multiplyBlock = ^int(int a, int b) {
return a * b; // 返回两个数字的积
};
int result = multiplyBlock(4, 6); // 传入参数 4 和 6
NSLog(@"结果是: %d", result); // 输出 "结果是: 24"
}
Block方式的KVO
//block方式的KVO
func naddObserver(forKeyPath: Int, options: Int, content: Int, v4: Int) -> Int{
return forKeyPath + options + content + v4
}
naddObserver(forKeyPath: 1,
options: 2,
content: 3,
v4: 4)
class Person : NSObject {
@objc dynamic var age: Int = 0
var observation: NSKeyValueObservation?
override init() {//重写初始化器
super.init()//加载父类的初始化器
observation = observe(\\Person.age, options: .new) { //这是一个闭包，其实和上面的KVO模式是一样的，只不过用的是闭包
(person, change) in
print(change.newValue as Any)
}
}
}
资源名管理(不重要可跳过)
//
// ViewController.swift
// class24_name1
//
// Created by sakiko on 2026/4/13.
//
import UIKit
//资源名管理：参考了Android的资源名管理方式
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad() //系统启动的时候会启动，要写在这里面
let img = UIImage(named: "pamu") //创建一个图片，这里要和图片的名字一样，图片放在Assets。
let btn = UIButton(type: .custom)//创建一个按钮
btn.setTitle("添加", for: .normal)
btn.setImage(img, for: .normal)
btn.frame = .init(origin: .init(x: 100, y: 60), size: .init(width: 60, height: 60))
// performSegue(withIdentifier: "login_main", sender: self)
let img1 = UIImage(named: Btn_R.image.logo.rawValue)//要加上named:和rawValue,下面也是
let btn1 = UIButton(type: .custom)
btn1.setTitle(Btn_R.string.add.rawValue, for: .normal)
// performSegue(withIdentifier: Btn_R.segue.login_main.rawValue, sender: self)
view.addSubview(btn)
view.addSubview(btn)
// Do any additional setup after loading the view.
}
}
多线程开发：待学习
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。
更多推荐
4
0- 0
已为社区贡献2条内容
所有评论(0)