SwiftSnippetApple
Last updated at 2023-09-08

How to Delete File in Swift using Foundation

ClickUp
Note
AI Status
50%
Last Edit By
Last edited time
Sep 8, 2023 07:26 PM
Metatag
Slug
how-to-delete-file-swift-using-foundation
Writer
Published
Published
Date
Jun 23, 2023
Category
Swift
Snippet
Apple
Besides writing a file, a program usually also deletes it. It can be because the program needs to clean up the disk, delete temporary data, manage caches, or perform other clean-up tasks.
If you use file cleaners on your computer, those applications are the best example of why you need to delete files.
Deleting files can be done programmatically in Swift. Apple has provided the API in the Foundation framework.
In this tutorial, you will learn how to use the Foundation API to delete a file in Swift.

Delete a File using Swift

In Swift, when you need to delete a file, leveraging the FileManager class from the Foundation framework is the way to go. You can effectively delete the file using the removeItem(at:) method.
It is a throwable method, so you need to wrap the invocation using the do-try-catch block.
import Foundation

let path = "/User/Home/path/to/file.txt"

func removeFile() {
    let fileURL = URL(fileURLWithPath: path)
    let fileManager = FileManager.default

    do {
        try fileManager.removeItem(at: fileURL)
        print("File Removed")
    } catch {
        print("Error: \(error)")
    }
}
The above code will delete the file named file.txt from the file system.
  1. URL(fileURLWithPath: "file.txt") creates a URL object representing the file named file.txt.
  1. FileManager.default is the default FileManager instance that provides file management functionality.
  1. try fileManager.removeItem(at: fileURL) is a method call to delete the file represented by the URL object.
  1. The operation is wrapped in a do-catch block to handle any potential errors that may occur during the file deletion process.

Delete a File Asynchronously

There is a chance that your computer already has a lot of unnecessary data that happens to be gigabytes in size. It can be a cache, temporary data created by an application, or an application that you download from the internet.
Do you know how big Xcode is? Xcode is more than 10GB. If you update it manually by downloading the latest version, then you must delete the old one. You can develop a program to automatically download and delete the old Xcode.
Deleting a big file can block your program's responsiveness, especially if it is a UI application. To avoid that, you need to invoke the deletion API asynchronously.
For asynchronous file deletion, utilizing the DispatchQueue with the async method enables you to efficiently delegate the task of file deletion to a designated queue of your choice. That way, if you remove gigabytes of files, you will not block the main thread and not render user interface unresponsive.
Here you can use DispatchQueue.gloabl(qos:.background) to do that.
let fileManager = FileManager.default
let filePath = "/User/Home/path/to/file.txt"

DispatchQueue.global(qos: .background).async {
    do {
        try fileManager.removeItem(atPath: filePath)
    } catch {
        print("Error removing file: \(error)")
    }
}

Unit Testing for File Deletion in Swift

Unit testing is a crucial aspect of software development that helps ensure the reliability and correctness of your code.
In this section, you will cover unit testing for the file deletion operation in Swift. You will create two sets of tests: one for the "happy path" (successful file deletion) and one for the "sad path" (handling errors when deletion fails).

Happy Path: Testing Successful File Deletion

In this scenario, you want to write a unit test that confirms our removeFile function successfully deletes a file when everything goes smoothly.
Setting Up the Test
import XCTest

class FileDeletionTests: XCTestCase {

    // ...

    func testRemoveFileSuccess() {
        // Arrange
        let fileManager = FileManager.default
        let temporaryDirectory = FileManager.default.temporaryDirectory
        let filePath = temporaryDirectory.appendingPathComponent("testFile.txt")

        // Create a temporary test file
        fileManager.createFile(atPath: filePath.path, contents: Data("Test Data".utf8), attributes: nil)

        // Act
        let success = removeFile(at: filePath)

        // Assert
        XCTAssertTrue(success, "File removal should succeed")
        XCTAssertFalse(fileManager.fileExists(atPath: filePath.path), "File should not exist after removal")
    }

    // ...
}
In this test case:
  • You create a temporary test file in the system's temporary directory using FileManager.createFile(atPath:contents:attributes:).
  • You then call the removeFile function to delete the created file.
  • Finally, you use assertions to confirm that the file removal was successful (XCTAssertTrue) and that the file does not exist after deletion (XCTAssertFalse).

Sad Path: Testing Error Handling for File Deletion

In the "sad path" scenario, you want to write a unit test that checks if our code handles errors gracefully when file deletion fails, such as when the file does not exist.
Setting Up the Test
import XCTest

class FileDeletionTests: XCTestCase {

    // ...

    func testRemoveFileFailure() {
        // Arrange
        let nonExistentPath = "/invalid/path/to/nonExistentFile.txt"

        // Act
        let success = removeFile(at: nonExistentPath)

        // Assert
        XCTAssertFalse(success, "File removal should fail for non-existent file")
    }

    // ...
}
In this test case:
  • You provide a non-existent file path as input to the removeFile function.
  • You call the removeFile function.
  • You use an assertion to confirm that the file removal operation failed (XCTAssertFalse) as expected.

Conclusion

In Swift, you can easily delete files using the FileManager class APIs provided by the Foundation framework.
Whether you need synchronous or asynchronous file deletion depends on your specific use case.
Synchronous deletion is straightforward and simple, but it may block the thread, especially for large files.
Asynchronous deletion, on the other hand, allows your application to remain responsive while file removal is in progress.
Choose the method that best fits your application's requirements and provides the desired performance.

Read More:

Write Content of String to a File in Swift
Write Content of Data to a File in Swift
 

Discussion (0)

Related Posts