Swift UIImage尺寸管理终极指南获取调整优化内存占用解决卡顿问题打造流畅用户体验

威震华夏关云长

引言

在iOS应用开发中，图片是UI设计中不可或缺的元素。然而，不恰当的图片处理方式可能导致内存占用过高、界面卡顿，甚至应用崩溃。本文将全面介绍如何在Swift中高效管理UIImage的尺寸，从而优化内存使用，解决性能问题，为用户提供流畅的体验。

UIImage基础

UIImage是iOS开发中用于表示图像的核心类。了解UIImage的基本特性对于有效管理图片尺寸至关重要。

2. // 创建一个简单的UIImage实例
3. let image = UIImage(named: "example_image")

复制代码

每个UIImage对象都包含图像数据以及与其关联的元数据，如尺寸、缩放比例和方向。以下是UIImage的一些关键属性：

2. if let image = UIImage(named: "example_image") {
3.     // 图片的尺寸（以点为单位）
4.     let size = image.size
5.     print("Image size: \(size.width) x \(size.height)")
6.    
7.     // 图片的缩放比例
8.     let scale = image.scale
9.     print("Image scale: \(scale)")
10.    
11.     // 图片的实际像素尺寸
12.     let pixelSize = CGSize(width: size.width * scale, height: size.height * scale)
13.     print("Image pixel size: \(pixelSize.width) x \(pixelSize.height)")
14.    
15.     // 图片的方向
16.     let orientation = image.imageOrientation
17.     print("Image orientation: \(orientation.rawValue)")
18. }

复制代码

获取图片尺寸

获取图片尺寸是图片处理的第一步。Swift提供了多种方式来获取图片尺寸信息。

从资源文件获取图片尺寸

2. // 方法1：直接创建UIImage并获取尺寸
3. if let image = UIImage(named: "example_image") {
4.     let size = image.size
5.     print("Image size: \(size.width) x \(size.height)")
6. }
8. // 方法2：通过UIImageAsset获取（适用于多分辨率图片）
9. if let asset = UIImageAsset(named: "example_image") {
10.     let image = asset.image(with: UITraitCollection(displayScale: UIScreen.main.scale))
11.     let size = image.size
12.     print("Image size: \(size.width) x \(size.height)")
13. }

复制代码

从文件URL获取图片尺寸

2. func imageSize(at url: URL) -> CGSize? {
3.     // 使用CGImageSource获取图片信息而不完全加载图片
4.     guard let source = CGImageSourceCreateWithURL(url, nil),
5.           let metadata = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [String: Any] else {
6.         return nil
7.     }
8.    
9.     // 获取像素尺寸
10.     let pixelWidth = metadata[kCGImagePropertyPixelWidth as String] as? CGFloat ?? 0
11.     let pixelHeight = metadata[kCGImagePropertyPixelHeight as String] as? CGFloat ?? 0
12.    
13.     // 获取图片的DPI（用于计算逻辑尺寸）
14.     let dpiWidth = metadata[kCGImagePropertyDPIWidth as String] as? CGFloat ?? 72
15.     let dpiHeight = metadata[kCGImagePropertyDPIHeight as String] as? CGFloat ?? 72
16.    
17.     // 计算逻辑尺寸（点）
18.     let pointWidth = pixelWidth * 72 / dpiWidth
19.     let pointHeight = pixelHeight * 72 / dpiHeight
20.    
21.     return CGSize(width: pointWidth, height: pointHeight)
22. }
24. // 使用示例
25. if let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first {
26.     let imageURL = documentsURL.appendingPathComponent("example.jpg")
27.     if let size = imageSize(at: imageURL) {
28.         print("Image size: \(size.width) x \(size.height)")
29.     }
30. }

复制代码

从网络获取图片尺寸

2. import ImageIO
4. func getImageSizeFromURL(_ url: URL, completion: @escaping (CGSize?) -> Void) {
5.     let task = URLSession.shared.dataTask(with: url) { data, response, error in
6.         guard let data = data, error == nil else {
7.             completion(nil)
8.             return
9.         }
10.         
11.         // 使用CGImageSource获取图片信息而不完全解码图片
12.         if let source = CGImageSourceCreateWithData(data as CFData, nil),
13.            let metadata = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [String: Any] {
14.             
15.             let pixelWidth = metadata[kCGImagePropertyPixelWidth as String] as? CGFloat ?? 0
16.             let pixelHeight = metadata[kCGImagePropertyPixelHeight as String] as? CGFloat ?? 0
17.             
18.             DispatchQueue.main.async {
19.                 completion(CGSize(width: pixelWidth, height: pixelHeight))
20.             }
21.         } else {
22.             DispatchQueue.main.async {
23.                 completion(nil)
24.             }
25.         }
26.     }
27.     task.resume()
28. }
30. // 使用示例
31. if let url = URL(string: "https://example.com/image.jpg") {
32.     getImageSizeFromURL(url) { size in
33.         if let size = size {
34.             print("Image size: \(size.width) x \(size.height)")
35.         } else {
36.             print("Failed to get image size")
37.         }
38.     }
39. }

复制代码

图片尺寸调整

调整图片尺寸是优化内存使用和提升性能的关键步骤。以下是几种常见的图片尺寸调整方法。

简单的尺寸调整

2. extension UIImage {
3.     func resized(to size: CGSize) -> UIImage? {
4.         UIGraphicsBeginImageContextWithOptions(size, false, scale)
5.         defer { UIGraphicsEndImageContext() }
6.         
7.         draw(in: CGRect(origin: .zero, size: size))
8.         return UIGraphicsGetImageFromCurrentImageContext()
9.     }
10.    
11.     func resized(toWidth width: CGFloat) -> UIImage? {
12.         let height = width * (size.height / size.width)
13.         return resized(to: CGSize(width: width, height: height))
14.     }
15.    
16.     func resized(toHeight height: CGFloat) -> UIImage? {
17.         let width = height * (size.width / size.height)
18.         return resized(to: CGSize(width: width, height: height))
19.     }
20. }
22. // 使用示例
23. if let originalImage = UIImage(named: "large_image") {
24.     // 调整到指定尺寸
25.     if let resizedImage = originalImage.resized(to: CGSize(width: 200, height: 200)) {
26.         // 使用调整后的图片
27.     }
28.    
29.     // 按宽度调整，保持宽高比
30.     if let widthResizedImage = originalImage.resized(toWidth: 300) {
31.         // 使用调整后的图片
32.     }
33.    
34.     // 按高度调整，保持宽高比
35.     if let heightResizedImage = originalImage.resized(toHeight: 300) {
36.         // 使用调整后的图片
37.     }
38. }

复制代码

高质量的尺寸调整

2. extension UIImage {
3.     func highQualityResized(to size: CGSize) -> UIImage? {
4.         let renderer = UIGraphicsImageRenderer(size: size)
5.         return renderer.image { _ in
6.             self.draw(in: CGRect(origin: .zero, size: size))
7.         }
8.     }
9.    
10.     func highQualityResized(toWidth width: CGFloat) -> UIImage? {
11.         let height = width * (size.height / size.width)
12.         return highQualityResized(to: CGSize(width: width, height: height))
13.     }
14.    
15.     func highQualityResized(toHeight height: CGFloat) -> UIImage? {
16.         let width = height * (size.width / size.height)
17.         return highQualityResized(to: CGSize(width: width, height: height))
18.     }
19. }
21. // 使用示例
22. if let originalImage = UIImage(named: "large_image") {
23.     if let highQualityResizedImage = originalImage.highQualityResized(toWidth: 300) {
24.         // 使用高质量调整后的图片
25.     }
26. }

复制代码

使用Core Image进行高级调整

2. import CoreImage
3. import CoreImage.CIFilterBuiltins
5. extension UIImage {
6.     func resizedUsingCoreImage(to size: CGSize) -> UIImage? {
7.         guard let cgImage = self.cgImage else { return nil }
8.         
9.         let ciImage = CIImage(cgImage: cgImage)
10.         let context = CIContext()
11.         
12.         // 计算缩放比例
13.         let scaleX = size.width / self.size.width
14.         let scaleY = size.height / self.size.height
15.         
16.         // 创建变换并应用缩放
17.         let transform = CGAffineTransform(scaleX: scaleX, y: scaleY)
18.         let scaledImage = ciImage.transformed(by: transform)
19.         
20.         // 渲染结果
21.         if let outputCGImage = context.createCGImage(scaledImage, from: scaledImage.extent) {
22.             return UIImage(cgImage: outputCGImage, scale: self.scale, orientation: self.imageOrientation)
23.         }
24.         
25.         return nil
26.     }
27.    
28.     func resizedUsingCoreImage(toWidth width: CGFloat) -> UIImage? {
29.         let height = width * (size.height / size.width)
30.         return resizedUsingCoreImage(to: CGSize(width: width, height: height))
31.     }
32. }
34. // 使用示例
35. if let originalImage = UIImage(named: "large_image") {
36.     if let coreImageResized = originalImage.resizedUsingCoreImage(toWidth: 300) {
37.         // 使用Core Image调整后的图片
38.     }
39. }

复制代码

使用vImage进行高性能调整

2. import Accelerate
4. extension UIImage {
5.     func resizedUsingvImage(to size: CGSize) -> UIImage? {
6.         guard let cgImage = self.cgImage else { return nil }
7.         
8.         var sourceBuffer = vImage_Buffer()
9.         defer {
10.             if sourceBuffer.data != nil {
11.                 free(sourceBuffer.data)
12.             }
13.         }
14.         
15.         var destinationBuffer = vImage_Buffer()
16.         defer {
17.             if destinationBuffer.data != nil {
18.                 free(destinationBuffer.data)
19.             }
20.         }
21.         
22.         var format = vImage_CGImageFormat(bitsPerComponent: 8,
23.                                          bitsPerPixel: 32,
24.                                          colorSpace: CGColorSpaceCreateDeviceRGB(),
25.                                          bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.first.rawValue),
26.                                          version: 0,
27.                                          decode: nil,
28.                                          renderingIntent: .defaultIntent)
29.         
30.         var error = vImageBuffer_InitWithCGImage(&sourceBuffer, &format, nil, cgImage, .noFlags)
31.         guard error == kvImageNoError else { return nil }
32.         
33.         error = vImageBuffer_Init(&destinationBuffer, vImagePixelCount(size.height), vImagePixelCount(size.width), format.bitsPerPixel, .noFlags)
34.         guard error == kvImageNoError else { return nil }
35.         
36.         // 执行缩放
37.         error = vImageScale_ARGB8888(&sourceBuffer, &destinationBuffer, nil, .noFlags)
38.         guard error == kvImageNoError else { return nil }
39.         
40.         // 创建输出图像
41.         guard let resizedCGImage = vImageCreateCGImageFromBuffer(&destinationBuffer, &format, nil, nil, .noFlags, &error)?.takeRetainedValue(),
42.               error == kvImageNoError else {
43.             return nil
44.         }
45.         
46.         return UIImage(cgImage: resizedCGImage, scale: self.scale, orientation: self.imageOrientation)
47.     }
48. }
50. // 使用示例
51. if let originalImage = UIImage(named: "large_image") {
52.     if let vImageResized = originalImage.resizedUsingvImage(to: CGSize(width: 300, height: 300)) {
53.         // 使用vImage调整后的图片
54.     }
55. }

复制代码

内存优化

优化UIImage的内存占用对于防止应用崩溃和提升性能至关重要。以下是几种优化内存使用的方法。

计算图片内存占用

2. extension UIImage {
3.     var estimatedMemoryUsage: Int {
4.         // 计算图片的字节大小
5.         let bytesPerPixel = 4 // 假设每个像素使用4字节(RGBA)
6.         let widthInPixels = Int(size.width * scale)
7.         let heightInPixels = Int(size.height * scale)
8.         return widthInPixels * heightInPixels * bytesPerPixel
9.     }
10. }
12. // 使用示例
13. if let image = UIImage(named: "large_image") {
14.     let memoryUsage = image.estimatedMemoryUsage
15.     print("Estimated memory usage: \(memoryUsage / (1024 * 1024)) MB")
16. }

复制代码

使用适当格式的图片

2. // PNG格式 - 适合带有透明度的图片
3. func loadPNGImage(named name: String) -> UIImage? {
4.     return UIImage(named: name)
5. }
7. // JPEG格式 - 适合照片类图片，可以压缩
8. func loadJPEGImage(named name: String, compressionQuality: CGFloat = 0.8) -> UIImage? {
9.     guard let imagePath = Bundle.main.path(forResource: name, ofType: "jpg"),
10.           let imageData = try? Data(contentsOf: URL(fileURLWithPath: imagePath)),
11.           let image = UIImage(data: imageData) else {
12.         return nil
13.     }
14.     return image
15. }
17. // WebP格式 - 更高效的图片格式，需要第三方库支持
18. func loadWebPImage(named name: String) -> UIImage? {
19.     // 这里需要使用第三方库如SDWebImage或Kingfisher来加载WebP图片
20.     // 示例代码假设使用SDWebImage
21.     if let imagePath = Bundle.main.path(forResource: name, ofType: "webp") {
22.         return SDWebImageManager.shared.imageCache?.imageFromDiskCache(forKey: imagePath)
23.     }
24.     return nil
25. }

复制代码

使用图像降采样

2. extension UIImage {
3.     func downsample(to size: CGSize, scale: CGFloat = UIScreen.main.scale) -> UIImage? {
4.         guard let imageData = self.jpegData(compressionQuality: 1.0) ?? self.pngData() else { return nil }
5.         
6.         let imageSourceOptions = [kCGImageSourceShouldCache: false] as CFDictionary
7.         guard let imageSource = CGImageSourceCreateWithData(imageData as CFData, imageSourceOptions) else { return nil }
8.         
9.         let maxDimensionInPixels = max(size.width, size.height) * scale
10.         
11.         let downsampleOptions = [
12.             kCGImageSourceCreateThumbnailFromImageAlways: true,
13.             kCGImageSourceShouldCacheImmediately: true,
14.             kCGImageSourceCreateThumbnailWithTransform: true,
15.             kCGImageSourceThumbnailMaxPixelSize: maxDimensionInPixels
16.         ] as CFDictionary
17.         
18.         guard let downsampledImage = CGImageSourceCreateThumbnailAtIndex(imageSource, 0, downsampleOptions) else { return nil }
19.         
20.         return UIImage(cgImage: downsampledImage, scale: scale, orientation: self.imageOrientation)
21.     }
22. }
24. // 使用示例
25. if let originalImage = UIImage(named: "large_image") {
26.     if let downsampledImage = originalImage.downsample(to: CGSize(width: 200, height: 200)) {
27.         // 使用降采样后的图片
28.         print("Original image memory usage: \(originalImage.estimatedMemoryUsage / (1024 * 1024)) MB")
29.         print("Downsampled image memory usage: \(downsampledImage.estimatedMemoryUsage / (1024 * 1024)) MB")
30.     }
31. }

复制代码

使用图像池和缓存策略

2. class ImageManager {
3.     static let shared = ImageManager()
4.     private var imageCache = NSCache<NSString, UIImage>()
5.    
6.     private init() {
7.         // 设置缓存限制
8.         let memoryCapacity = 100 * 1024 * 1024 // 100MB
9.         let preferredMemoryCapacity = 50 * 1024 * 1024 // 50MB
10.         imageCache.totalCostLimit = memoryCapacity
11.         imageCache.countLimit = 50 // 最多缓存50张图片
12.         
13.         // 监听内存警告
14.         NotificationCenter.default.addObserver(
15.             self,
16.             selector: #selector(clearCache),
17.             name: UIApplication.didReceiveMemoryWarningNotification,
18.             object: nil
19.         )
20.     }
21.    
22.     @objc private func clearCache() {
23.         imageCache.removeAllObjects()
24.     }
25.    
26.     func loadImage(named name: String, size: CGSize? = nil) -> UIImage? {
27.         let cacheKey = "\(name)-\(size?.width ?? 0)-\(size?.height ?? 0)" as NSString
28.         
29.         // 检查缓存
30.         if let cachedImage = imageCache.object(forKey: cacheKey) {
31.             return cachedImage
32.         }
33.         
34.         // 加载图片
35.         guard var image = UIImage(named: name) else { return nil }
36.         
37.         // 调整尺寸
38.         if let size = size {
39.             image = image.resized(to: size) ?? image
40.         }
41.         
42.         // 缓存图片
43.         imageCache.setObject(image, forKey: cacheKey, cost: image.estimatedMemoryUsage)
44.         
45.         return image
46.     }
47.    
48.     func preloadImages(names: [String], size: CGSize? = nil) {
49.         DispatchQueue.global(qos: .background).async {
50.             for name in names {
51.                 _ = self.loadImage(named: name, size: size)
52.             }
53.         }
54.     }
55. }
57. // 使用示例
58. let imageManager = ImageManager.shared
60. // 加载图片
61. if let image = imageManager.loadImage(named: "example_image", size: CGSize(width: 200, height: 200)) {
62.     // 使用图片
63. }
65. // 预加载图片
66. imageManager.preloadImages(names: ["image1", "image2", "image3"], size: CGSize(width: 100, height: 100))

复制代码

解决卡顿问题

图片处理中的卡顿问题通常是由于主线程阻塞或内存压力导致的。以下是几种解决卡顿问题的方法。

异步图片加载和处理

2. class AsyncImageLoader {
3.     static let shared = AsyncImageLoader()
4.     private var imageCache = NSCache<NSString, UIImage>()
5.     private var taskCache = [NSString: URLSessionDataTask]()
6.    
7.     private init() {
8.         imageCache.totalCostLimit = 100 * 1024 * 1024 // 100MB
9.         NotificationCenter.default.addObserver(
10.             self,
11.             selector: #selector(clearCache),
12.             name: UIApplication.didReceiveMemoryWarningNotification,
13.             object: nil
14.         )
15.     }
16.    
17.     @objc private func clearCache() {
18.         imageCache.removeAllObjects()
19.         taskCache.values.forEach { $0.cancel() }
20.         taskCache.removeAll()
21.     }
22.    
23.     func loadImage(from url: URL, size: CGSize? = nil, completion: @escaping (UIImage?) -> Void) {
24.         let cacheKey = url.absoluteString as NSString
25.         
26.         // 检查缓存
27.         if let cachedImage = imageCache.object(forKey: cacheKey) {
28.             completion(cachedImage)
29.             return
30.         }
31.         
32.         // 检查是否有正在进行的任务
33.         if let existingTask = taskCache[cacheKey] {
34.             // 如果已有任务在加载此图片，则不再创建新任务
35.             return
36.         }
37.         
38.         // 创建并启动数据任务
39.         let task = URLSession.shared.dataTask(with: url) { [weak self] data, response, error in
40.             guard let self = self else { return }
41.             
42.             // 移除任务缓存
43.             self.taskCache.removeValue(forKey: cacheKey)
44.             
45.             guard let data = data, error == nil, let image = UIImage(data: data) else {
46.                 DispatchQueue.main.async {
47.                     completion(nil)
48.                 }
49.                 return
50.             }
51.             
52.             // 调整尺寸
53.             var finalImage = image
54.             if let size = size {
55.                 finalImage = image.resized(to: size) ?? image
56.             }
57.             
58.             // 缓存图片
59.             self.imageCache.setObject(finalImage, forKey: cacheKey, cost: finalImage.estimatedMemoryUsage)
60.             
61.             DispatchQueue.main.async {
62.                 completion(finalImage)
63.             }
64.         }
65.         
66.         // 缓存任务
67.         taskCache[cacheKey] = task
68.         task.resume()
69.     }
70.    
71.     func cancelLoad(for url: URL) {
72.         let cacheKey = url.absoluteString as NSString
73.         taskCache[cacheKey]?.cancel()
74.         taskCache.removeValue(forKey: cacheKey)
75.     }
76. }
78. // 使用示例
79. let loader = AsyncImageLoader.shared
81. if let url = URL(string: "https://example.com/image.jpg") {
82.     loader.loadImage(from: url, size: CGSize(width: 200, height: 200)) { image in
83.         if let image = image {
84.             // 在主线程更新UI
85.             DispatchQueue.main.async {
86.                 self.imageView.image = image
87.             }
88.         }
89.     }
90. }

复制代码

使用预加载和懒加载策略

2. class ImagePreloader {
3.     static let shared = ImagePreloader()
4.     private var preloadQueue = DispatchQueue(label: "com.example.imagePreloader", qos: .background)
5.     private var imageCache = NSCache<NSString, UIImage>()
6.    
7.     private init() {
8.         imageCache.totalCostLimit = 100 * 1024 * 1024 // 100MB
9.         NotificationCenter.default.addObserver(
10.             self,
11.             selector: #selector(clearCache),
12.             name: UIApplication.didReceiveMemoryWarningNotification,
13.             object: nil
14.         )
15.     }
16.    
17.     @objc private func clearCache() {
18.         imageCache.removeAllObjects()
19.     }
20.    
21.     func preloadImages(from urls: [URL], size: CGSize? = nil) {
22.         preloadQueue.async {
23.             for url in urls {
24.                 let cacheKey = url.absoluteString as NSString
25.                
26.                 // 如果图片已经在缓存中，则跳过
27.                 if self.imageCache.object(forKey: cacheKey) != nil {
28.                     continue
29.                 }
30.                
31.                 // 下载图片
32.                 if let data = try? Data(contentsOf: url),
33.                    var image = UIImage(data: data) {
34.                     
35.                     // 调整尺寸
36.                     if let size = size {
37.                         image = image.resized(to: size) ?? image
38.                     }
39.                     
40.                     // 缓存图片
41.                     self.imageCache.setObject(image, forKey: cacheKey, cost: image.estimatedMemoryUsage)
42.                 }
43.             }
44.         }
45.     }
46.    
47.     func getImage(for url: URL) -> UIImage? {
48.         let cacheKey = url.absoluteString as NSString
49.         return imageCache.object(forKey: cacheKey)
50.     }
51. }
53. // 使用示例
54. let preloader = ImagePreloader.shared
56. // 预加载图片
57. let imageUrls = [
58.     URL(string: "https://example.com/image1.jpg")!,
59.     URL(string: "https://example.com/image2.jpg")!,
60.     URL(string: "https://example.com/image3.jpg")!
61. ]
62. preloader.preloadImages(from: imageUrls, size: CGSize(width: 200, height: 200))
64. // 在需要时获取图片
65. if let url = URL(string: "https://example.com/image1.jpg"),
66.    let preloadedImage = preloader.getImage(for: url) {
67.     imageView.image = preloadedImage
68. }

复制代码

使用占位图和渐进式加载

2. class ProgressiveImageLoader {
3.     static let shared = ProgressiveImageLoader()
4.     private var imageCache = NSCache<NSString, UIImage>()
5.    
6.     private init() {
7.         imageCache.totalCostLimit = 100 * 1024 * 1024 // 100MB
8.         NotificationCenter.default.addObserver(
9.             self,
10.             selector: #selector(clearCache),
11.             name: UIApplication.didReceiveMemoryWarningNotification,
12.             object: nil
13.         )
14.     }
15.    
16.     @objc private func clearCache() {
17.         imageCache.removeAllObjects()
18.     }
19.    
20.     func loadImageWithPlaceholder(
21.         from url: URL,
22.         placeholder: UIImage? = nil,
23.         size: CGSize? = nil,
24.         completion: @escaping (UIImage?) -> Void
25.     ) {
26.         let cacheKey = url.absoluteString as NSString
27.         
28.         // 检查缓存
29.         if let cachedImage = imageCache.object(forKey: cacheKey) {
30.             completion(cachedImage)
31.             return
32.         }
33.         
34.         // 先显示占位图
35.         DispatchQueue.main.async {
36.             completion(placeholder)
37.         }
38.         
39.         // 异步加载图片
40.         DispatchQueue.global(qos: .background).async { [weak self] in
41.             guard let self = self else { return }
42.             
43.             if let data = try? Data(contentsOf: url),
44.                var image = UIImage(data: data) {
45.                
46.                 // 调整尺寸
47.                 if let size = size {
48.                     image = image.resized(to: size) ?? image
49.                 }
50.                
51.                 // 缓存图片
52.                 self.imageCache.setObject(image, forKey: cacheKey, cost: image.estimatedMemoryUsage)
53.                
54.                 DispatchQueue.main.async {
55.                     completion(image)
56.                 }
57.             } else {
58.                 DispatchQueue.main.async {
59.                     completion(placeholder)
60.                 }
61.             }
62.         }
63.     }
64. }
66. // 使用示例
67. let loader = ProgressiveImageLoader.shared
68. let placeholder = UIImage(named: "placeholder")
70. if let url = URL(string: "https://example.com/image.jpg") {
71.     loader.loadImageWithPlaceholder(
72.         from: url,
73.         placeholder: placeholder,
74.         size: CGSize(width: 200, height: 200)
75.     ) { image in
76.         self.imageView.image = image
77.     }
78. }

复制代码

使用图像解码优化

2. extension UIImage {
3.     func decodedImage() -> UIImage? {
4.         guard let cgImage = cgImage else { return nil }
5.         
6.         let size = CGSize(width: cgImage.width, height: cgImage.height)
7.         let colorSpace = CGColorSpaceCreateDeviceRGB()
8.         let context = CGContext(
9.             data: nil,
10.             width: Int(size.width),
11.             height: Int(size.height),
12.             bitsPerComponent: 8,
13.             bytesPerRow: 0,
14.             space: colorSpace,
15.             bitmapInfo: CGImageAlphaInfo.noneSkipFirst.rawValue
16.         )
17.         
18.         context?.draw(cgImage, in: CGRect(origin: .zero, size: size))
19.         
20.         guard let decodedImage = context?.makeImage() else { return nil }
21.         
22.         return UIImage(cgImage: decodedImage, scale: scale, orientation: imageOrientation)
23.     }
24. }
26. class OptimizedImageLoader {
27.     static let shared = OptimizedImageLoader()
28.     private var imageCache = NSCache<NSString, UIImage>()
29.     private let processingQueue = DispatchQueue(label: "com.example.imageProcessing", qos: .userInitiated)
30.    
31.     private init() {
32.         imageCache.totalCostLimit = 100 * 1024 * 1024 // 100MB
33.         NotificationCenter.default.addObserver(
34.             self,
35.             selector: #selector(clearCache),
36.             name: UIApplication.didReceiveMemoryWarningNotification,
37.             object: nil
38.         )
39.     }
40.    
41.     @objc private func clearCache() {
42.         imageCache.removeAllObjects()
43.     }
44.    
45.     func loadAndDecodeImage(
46.         from url: URL,
47.         size: CGSize? = nil,
48.         completion: @escaping (UIImage?) -> Void
49.     ) {
50.         let cacheKey = url.absoluteString as NSString
51.         
52.         // 检查缓存
53.         if let cachedImage = imageCache.object(forKey: cacheKey) {
54.             completion(cachedImage)
55.             return
56.         }
57.         
58.         // 异步加载和解码图片
59.         processingQueue.async { [weak self] in
60.             guard let self = self else { return }
61.             
62.             if let data = try? Data(contentsOf: url),
63.                var image = UIImage(data: data)?.decodedImage() {
64.                
65.                 // 调整尺寸
66.                 if let size = size {
67.                     image = image.resized(to: size) ?? image
68.                 }
69.                
70.                 // 缓存图片
71.                 self.imageCache.setObject(image, forKey: cacheKey, cost: image.estimatedMemoryUsage)
72.                
73.                 DispatchQueue.main.async {
74.                     completion(image)
75.                 }
76.             } else {
77.                 DispatchQueue.main.async {
78.                     completion(nil)
79.                 }
80.             }
81.         }
82.     }
83. }
85. // 使用示例
86. let loader = OptimizedImageLoader.shared
88. if let url = URL(string: "https://example.com/image.jpg") {
89.     loader.loadAndDecodeImage(from: url, size: CGSize(width: 200, height: 200)) { image in
90.         self.imageView.image = image
91.     }
92. }

复制代码

打造流畅用户体验

除了技术层面的优化，用户体验也是图片处理的重要考量因素。以下是几种提升用户体验的方法。

实现平滑的图片过渡效果

2. extension UIImageView {
3.     func setImageWithTransition(
4.         _ newImage: UIImage?,
5.         duration: TimeInterval = 0.3,
6.         options: UIView.AnimationOptions = .transitionCrossDissolve
7.     ) {
8.         UIView.transition(
9.             with: self,
10.             duration: duration,
11.             options: options,
12.             animations: {
13.                 self.image = newImage
14.             },
15.             completion: nil
16.         )
17.     }
18. }
20. // 使用示例
21. if let url = URL(string: "https://example.com/image.jpg") {
22.     AsyncImageLoader.shared.loadImage(from: url, size: CGSize(width: 200, height: 200)) { image in
23.         self.imageView.setImageWithTransition(image)
24.     }
25. }

复制代码

实现图片淡入效果

2. extension UIImageView {
3.     func setImageWithFade(_ newImage: UIImage?, duration: TimeInterval = 0.5) {
4.         image = newImage
5.         alpha = 0
6.         
7.         UIView.animate(withDuration: duration) {
8.             self.alpha = 1
9.         }
10.     }
11. }
13. // 使用示例
14. if let url = URL(string: "https://example.com/image.jpg") {
15.     AsyncImageLoader.shared.loadImage(from: url, size: CGSize(width: 200, height: 200)) { image in
16.         self.imageView.setImageWithFade(image)
17.     }
18. }

复制代码

实现渐进式图片加载

2. class ProgressiveImageView: UIImageView {
3.     private var currentTask: URLSessionDataTask?
4.    
5.     func loadProgressiveImage(from url: URL, placeholder: UIImage? = nil) {
6.         // 取消之前的任务
7.         currentTask?.cancel()
8.         
9.         // 设置占位图
10.         image = placeholder
11.         
12.         // 创建请求
13.         let request = URLRequest(url: url)
14.         
15.         // 创建数据任务
16.         currentTask = URLSession.shared.dataTask(with: request) { [weak self] data, response, error in
17.             guard let self = self, let data = data, error == nil else {
18.                 return
19.             }
20.             
21.             // 在后台队列处理图片
22.             DispatchQueue.global(qos: .userInitiated).async {
23.                 if let image = UIImage(data: data) {
24.                     DispatchQueue.main.async {
25.                         self.setImageWithTransition(image)
26.                     }
27.                 }
28.             }
29.         }
30.         
31.         // 启动任务
32.         currentTask?.resume()
33.     }
34.    
35.     func cancelLoad() {
36.         currentTask?.cancel()
37.         currentTask = nil
38.     }
39. }
41. // 使用示例
42. let progressiveImageView = ProgressiveImageView()
43. if let url = URL(string: "https://example.com/image.jpg") {
44.     progressiveImageView.loadProgressiveImage(from: url, placeholder: UIImage(named: "placeholder"))
45. }

复制代码

实现图片预加载和缓存策略

2. class SmartImageCache {
3.     static let shared = SmartImageCache()
4.     private var memoryCache = NSCache<NSString, UIImage>()
5.     private var diskCache: URLCache
6.     private let fileManager = FileManager.default
7.     private let cachePath: URL
8.    
9.     private init() {
10.         // 内存缓存设置
11.         memoryCache.totalCostLimit = 100 * 1024 * 1024 // 100MB
12.         memoryCache.countLimit = 50 // 最多缓存50张图片
13.         
14.         // 磁盘缓存设置
15.         let diskCapacity = 500 * 1024 * 1024 // 500MB
16.         diskCache = URLCache(memoryCapacity: 0, diskCapacity: diskCapacity, diskPath: nil)
17.         
18.         // 创建缓存目录
19.         if let cachesURL = fileManager.urls(for: .cachesDirectory, in: .userDomainMask).first {
20.             cachePath = cachesURL.appendingPathComponent("ImageCache")
21.             
22.             try? fileManager.createDirectory(at: cachePath, withIntermediateDirectories: true, attributes: nil)
23.         } else {
24.             cachePath = URL(fileURLWithPath: NSTemporaryDirectory())
25.         }
26.         
27.         // 监听内存警告
28.         NotificationCenter.default.addObserver(
29.             self,
30.             selector: #selector(clearMemoryCache),
31.             name: UIApplication.didReceiveMemoryWarningNotification,
32.             object: nil
33.         )
34.     }
35.    
36.     @objc private func clearMemoryCache() {
37.         memoryCache.removeAllObjects()
38.     }
39.    
40.     // 获取图片
41.     func image(for url: URL, completion: @escaping (UIImage?) -> Void) {
42.         let cacheKey = url.absoluteString as NSString
43.         
44.         // 检查内存缓存
45.         if let cachedImage = memoryCache.object(forKey: cacheKey) {
46.             completion(cachedImage)
47.             return
48.         }
49.         
50.         // 检查磁盘缓存
51.         if let cachedResponse = diskCache.cachedResponse(for: URLRequest(url: url)),
52.            let image = UIImage(data: cachedResponse.data) {
53.             // 存入内存缓存
54.             memoryCache.setObject(image, forKey: cacheKey, cost: image.estimatedMemoryUsage)
55.             completion(image)
56.             return
57.         }
58.         
59.         // 从网络加载
60.         downloadImage(from: url) { [weak self] image in
61.             guard let self = self, let image = image else {
62.                 completion(nil)
63.                 return
64.             }
65.             
66.             // 存入内存缓存
67.             self.memoryCache.setObject(image, forKey: cacheKey, cost: image.estimatedMemoryUsage)
68.             
69.             // 存入磁盘缓存
70.             if let data = image.jpegData(compressionQuality: 0.8) {
71.                 let response = URLResponse(url: url, mimeType: "image/jpeg", expectedContentLength: data.count, textEncodingName: nil)
72.                 let cachedResponse = CachedURLResponse(response: response, data: data)
73.                 self.diskCache.storeCachedResponse(cachedResponse, for: URLRequest(url: url))
74.             }
75.             
76.             completion(image)
77.         }
78.     }
79.    
80.     // 下载图片
81.     private func downloadImage(from url: URL, completion: @escaping (UIImage?) -> Void) {
82.         URLSession.shared.dataTask(with: url) { data, response, error in
83.             guard let data = data, error == nil else {
84.                 DispatchQueue.main.async {
85.                     completion(nil)
86.                 }
87.                 return
88.             }
89.             
90.             let image = UIImage(data: data)
91.             DispatchQueue.main.async {
92.                 completion(image)
93.             }
94.         }.resume()
95.     }
96.    
97.     // 预加载图片
98.     func preloadImages(from urls: [URL]) {
99.         DispatchQueue.global(qos: .background).async {
100.             for url in urls {
101.                 _ = self.image(for: url) { _ in }
102.             }
103.         }
104.     }
105.    
106.     // 清除所有缓存
107.     func clearAllCache() {
108.         clearMemoryCache()
109.         diskCache.removeAllCachedResponses()
110.         
111.         try? fileManager.removeItem(at: cachePath)
112.         try? fileManager.createDirectory(at: cachePath, withIntermediateDirectories: true, attributes: nil)
113.     }
114. }
116. // 使用示例
117. let smartCache = SmartImageCache.shared
119. // 加载图片
120. if let url = URL(string: "https://example.com/image.jpg") {
121.     smartCache.image(for: url) { image in
122.         if let image = image {
123.             self.imageView.image = image
124.         }
125.     }
126. }
128. // 预加载图片
129. let imageUrls = [
130.     URL(string: "https://example.com/image1.jpg")!,
131.     URL(string: "https://example.com/image2.jpg")!,
132.     URL(string: "https://example.com/image3.jpg")!
133. ]
134. smartCache.preloadImages(from: imageUrls)

复制代码

实现图片懒加载和优先级加载

2. enum ImageLoadPriority {
3.     case high
4.     case normal
5.     case low
6. }
8. class PriorityImageLoader {
9.     static let shared = PriorityImageLoader()
10.     private var highPriorityQueue = OperationQueue()
11.     private var normalPriorityQueue = OperationQueue()
12.     private var lowPriorityQueue = OperationQueue()
13.     private var imageCache = NSCache<NSString, UIImage>()
14.    
15.     private init() {
16.         // 配置队列
17.         highPriorityQueue.qualityOfService = .userInitiated
18.         normalPriorityQueue.qualityOfService = .utility
19.         lowPriorityQueue.qualityOfService = .background
20.         
21.         // 设置最大并发操作数
22.         highPriorityQueue.maxConcurrentOperationCount = 2
23.         normalPriorityQueue.maxConcurrentOperationCount = 3
24.         lowPriorityQueue.maxConcurrentOperationCount = 5
25.         
26.         // 配置缓存
27.         imageCache.totalCostLimit = 100 * 1024 * 1024 // 100MB
28.         NotificationCenter.default.addObserver(
29.             self,
30.             selector: #selector(clearCache),
31.             name: UIApplication.didReceiveMemoryWarningNotification,
32.             object: nil
33.         )
34.     }
35.    
36.     @objc private func clearCache() {
37.         imageCache.removeAllObjects()
38.     }
39.    
40.     func loadImage(
41.         from url: URL,
42.         size: CGSize? = nil,
43.         priority: ImageLoadPriority = .normal,
44.         completion: @escaping (UIImage?) -> Void
45.     ) {
46.         let cacheKey = url.absoluteString as NSString
47.         
48.         // 检查缓存
49.         if let cachedImage = imageCache.object(forKey: cacheKey) {
50.             completion(cachedImage)
51.             return
52.         }
53.         
54.         // 创建操作
55.         let operation = BlockOperation { [weak self] in
56.             guard let self = self else { return }
57.             
58.             if let data = try? Data(contentsOf: url),
59.                var image = UIImage(data: data) {
60.                
61.                 // 调整尺寸
62.                 if let size = size {
63.                     image = image.resized(to: size) ?? image
64.                 }
65.                
66.                 // 缓存图片
67.                 self.imageCache.setObject(image, forKey: cacheKey, cost: image.estimatedMemoryUsage)
68.                
69.                 DispatchQueue.main.async {
70.                     completion(image)
71.                 }
72.             } else {
73.                 DispatchQueue.main.async {
74.                     completion(nil)
75.                 }
76.             }
77.         }
78.         
79.         // 根据优先级添加到相应队列
80.         switch priority {
81.         case .high:
82.             highPriorityQueue.addOperation(operation)
83.         case .normal:
84.             normalPriorityQueue.addOperation(operation)
85.         case .low:
86.             lowPriorityQueue.addOperation(operation)
87.         }
88.     }
89.    
90.     func cancelAllOperations() {
91.         highPriorityQueue.cancelAllOperations()
92.         normalPriorityQueue.cancelAllOperations()
93.         lowPriorityQueue.cancelAllOperations()
94.     }
95. }
97. // 使用示例
98. let loader = PriorityImageLoader.shared
100. // 加载高优先级图片
101. if let url = URL(string: "https://example.com/important_image.jpg") {
102.     loader.loadImage(from: url, priority: .high) { image in
103.         if let image = image {
104.             self.imageView.image = image
105.         }
106.     }
107. }
109. // 加载普通优先级图片
110. if let url = URL(string: "https://example.com/normal_image.jpg") {
111.     loader.loadImage(from: url, priority: .normal) { image in
112.         if let image = image {
113.             self.secondaryImageView.image = image
114.         }
115.     }
116. }
118. // 加载低优先级图片
119. if let url = URL(string: "https://example.com/background_image.jpg") {
120.     loader.loadImage(from: url, priority: .low) { image in
121.         if let image = image {
122.             self.backgroundImageView.image = image
123.         }
124.     }
125. }

复制代码

总结

在Swift中有效管理UIImage的尺寸对于优化内存使用和提升应用性能至关重要。本文介绍了多种获取、调整和优化图片尺寸的方法，以及如何解决卡顿问题和打造流畅的用户体验。

关键要点包括：

1. 获取图片尺寸：了解如何从不同来源获取图片尺寸信息，包括资源文件、文件URL和网络。
2. 调整图片尺寸：掌握多种图片尺寸调整方法，包括简单调整、高质量调整、使用Core Image和使用vImage进行高性能调整。
3. 内存优化：通过计算图片内存占用、使用适当格式的图片、图像降采样和缓存策略来优化内存使用。
4. 解决卡顿问题：使用异步图片加载和处理、预加载和懒加载策略、占位图和渐进式加载以及图像解码优化来解决卡顿问题。
5. 打造流畅用户体验：实现平滑的图片过渡效果、图片淡入效果、渐进式图片加载、图片预加载和缓存策略以及图片懒加载和优先级加载。

获取图片尺寸：了解如何从不同来源获取图片尺寸信息，包括资源文件、文件URL和网络。

调整图片尺寸：掌握多种图片尺寸调整方法，包括简单调整、高质量调整、使用Core Image和使用vImage进行高性能调整。

内存优化：通过计算图片内存占用、使用适当格式的图片、图像降采样和缓存策略来优化内存使用。

解决卡顿问题：使用异步图片加载和处理、预加载和懒加载策略、占位图和渐进式加载以及图像解码优化来解决卡顿问题。

打造流畅用户体验：实现平滑的图片过渡效果、图片淡入效果、渐进式图片加载、图片预加载和缓存策略以及图片懒加载和优先级加载。

通过合理应用这些技术，你可以显著提升iOS应用的图片处理性能，减少内存占用，避免卡顿问题，为用户提供流畅的体验。记住，最佳实践往往是根据具体应用场景和需求来选择合适的策略，而不是盲目追求最复杂或最高性能的解决方案。