Leggi e scrivi una stringa dal file di testo


298

Devo leggere e scrivere dati su / da un file di testo, ma non sono stato in grado di capire come.

Ho trovato questo codice di esempio nell'iBook di Swift, ma non so ancora come scrivere o leggere i dati.

import Cocoa

class DataImporter
{
    /*
    DataImporter is a class to import data from an external file.
    The class is assumed to take a non-trivial amount of time to initialize.
    */
    var fileName = "data.txt"
    // the DataImporter class would provide data importing functionality here
}

class DataManager
{
    @lazy var importer = DataImporter()
    var data = String[]()
    // the DataManager class would provide data management functionality here
}

let manager = DataManager()
manager.data += "Some data"
manager.data += "Some more data"
// the DataImporter instance for the importer property has not yet been created”

println(manager.importer.fileName)
// the DataImporter instance for the importer property has now been created
// prints "data.txt”



var str = "Hello World in Swift Language."

Risposte:


548

Per leggere e scrivere è necessario utilizzare una posizione che sia scrivibile, ad esempio la directory dei documenti. Il codice seguente mostra come leggere e scrivere una stringa semplice. Puoi provarlo in un parco giochi.

Swift 3.x - 5.x

let file = "file.txt" //this is the file. we will write to and read from it

let text = "some text" //just a text

if let dir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first {

    let fileURL = dir.appendingPathComponent(file)

    //writing
    do {
        try text.write(to: fileURL, atomically: false, encoding: .utf8)
    }
    catch {/* error handling here */}

    //reading
    do {
        let text2 = try String(contentsOf: fileURL, encoding: .utf8)
    }
    catch {/* error handling here */}
}

Swift 2.2

let file = "file.txt" //this is the file. we will write to and read from it

let text = "some text" //just a text

if let dir = NSSearchPathForDirectoriesInDomains(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomainMask.AllDomainsMask, true).first {
    let path = NSURL(fileURLWithPath: dir).URLByAppendingPathComponent(file)

    //writing
    do {
        try text.writeToURL(path, atomically: false, encoding: NSUTF8StringEncoding)
    }
    catch {/* error handling here */}

    //reading
    do {
        let text2 = try NSString(contentsOfURL: path, encoding: NSUTF8StringEncoding)
    }
    catch {/* error handling here */}
}

Swift 1.x

let file = "file.txt"

if let dirs : [String] = NSSearchPathForDirectoriesInDomains(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomainMask.AllDomainsMask, true) as? [String] {
    let dir = dirs[0] //documents directory
    let path = dir.stringByAppendingPathComponent(file);
    let text = "some text"

    //writing
    text.writeToFile(path, atomically: false, encoding: NSUTF8StringEncoding, error: nil);

    //reading
    let text2 = String(contentsOfFile: path, encoding: NSUTF8StringEncoding, error: nil)
}

2
let text2 = String.stringWithContentsOfFile (path) // XCode 6.0
Matt Frear,

L'uso di questa soluzione funziona, ma se apro il file non contiene testo. Mi sto perdendo qualcosa?
Nuno Gonçalves,

@Adam Che cos'è questo file in let path = dir.stringByAppendingPathComponent (file) ;?
zbz.lvlv,

7
Questo dovrebbe essere rimosso, il codice non funziona per le nuove versioni di Swift.

1
@ billy_b29 Il codice dopo questa riga: //readingfa esattamente questo.
Adam,

88

Supponendo che tu abbia spostato il tuo file di testo data.txtnel tuo progetto Xcode (Usa drag'n'drop e seleziona "Copia file se necessario") puoi fare quanto segue proprio come in Objective-C:

let bundle = NSBundle.mainBundle()
let path = bundle.pathForResource("data", ofType: "txt")        
let content = NSString.stringWithContentsOfFile(path) as String

println(content) // prints the content of data.txt

Aggiornamento:
per leggere un file da Bundle (iOS) è possibile utilizzare:

let path = NSBundle.mainBundle().pathForResource("FileName", ofType: "txt")
var text = String(contentsOfFile: path!, encoding: NSUTF8StringEncoding, error: nil)!
println(text)

Aggiornamento per Swift 3:

let path = Bundle.main.path(forResource: "data", ofType: "txt") // file path for file "data.txt"
var text = String(contentsOfFile: path!, encoding: NSUTF8StringEncoding, error: nil)!

Per Swift 5

let path = Bundle.main.path(forResource: "ListAlertJson", ofType: "txt") // file path for file "data.txt"
let string = try String(contentsOfFile: path!, encoding: String.Encoding.utf8)

3
Per i progetti iOS, "stringWithContentsOfFile" non è disponibile (obsoleto a partire da iOS 7)
alttag

1
Niente a che vedere con i progetti iOS, è obsoleto e non funziona più con Xcode 6.1 (incluso Mac OS X)
Leo Dabus,

1
puoi usare String (contentsOfFile: ...)
shim

1
soluzione simile usa il bundle con iOS 10 Swift 3 qui
Timeless

69

Xcode 8.x • Swift 3.x o successivo

do {
    // get the documents folder url
    if let documentDirectory = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first {
        // create the destination url for the text file to be saved
        let fileURL = documentDirectory.appendingPathComponent("file.txt")
        // define the string/text to be saved
        let text = "Hello World !!!"
        // writing to disk 
        // Note: if you set atomically to true it will overwrite the file if it exists without a warning
        try text.write(to: fileURL, atomically: false, encoding: .utf8)
        print("saving was successful")
        // any posterior code goes here
        // reading from disk
        let savedText = try String(contentsOf: fileURL)
        print("savedText:", savedText)   // "Hello World !!!\n"
    }
} catch {
    print("error:", error)
}

Quali sono gli errori più comuni di "Non esiste un file del genere." Perché ho aggiunto i miei file .txt a Project Navigator e quindi provo ad aprirli, ricevo questo messaggio. (Crearli sul desktop e trascinarli nel navigatore del progetto)
Darvydas,

56

Nuovo metodo più semplice e consigliato: Apple consiglia di utilizzare gli URL per la gestione dei file e le altre soluzioni qui sembrano deprecate (vedi commenti sotto). Di seguito è riportato il nuovo modo semplice di leggere e scrivere con gli URL (non dimenticare di gestire i possibili errori URL):

Swift 5+, 4 e 3.1

import Foundation  // Needed for those pasting into Playground

let fileName = "Test"
let dir = try? FileManager.default.url(for: .documentDirectory, 
      in: .userDomainMask, appropriateFor: nil, create: true)

// If the directory was found, we write a file to it and read it back
if let fileURL = dir?.appendingPathComponent(fileName).appendingPathExtension("txt") {

    // Write to the file named Test
    let outString = "Write this text to the file"
    do {
        try outString.write(to: fileURL, atomically: true, encoding: .utf8)
    } catch {
        print("Failed writing to URL: \(fileURL), Error: " + error.localizedDescription)
    }

    // Then reading it back from the file
    var inString = ""
    do {
        inString = try String(contentsOf: fileURL)
    } catch {
        print("Failed reading from URL: \(fileURL), Error: " + error.localizedDescription)
    }
    print("Read from the file: \(inString)")
}

1
Puoi fornire un riferimento dove Apple consiglia in questo modo. Oppure puoi approfondire un po 'di più sul perché questo è il modo raccomandato?
Andrej

6
@Andrej "Gli oggetti URL sono il modo preferito per fare riferimento ai file locali. La maggior parte degli oggetti che leggono o scrivono dati in un file hanno metodi che accettano un oggetto NSURL invece di un nome percorso come riferimento al file." developer.apple.com/library/ios/documentation/Cocoa/Reference/…
Sverrisson

1
Non è necessario eseguire il cast degli errori come NSError o utilizzare "catch let error". Puoi semplicemente catturare e ottenere la variabile di errore gratuitamente.
cuomo456,

@ cuomo456 alla tua destra lo rimuovo, è un residuo della precedente beta di Swift.
Sverrisson,

1
@Alshcompiler The create: true informa FileManager a creare la directory se non è già lì, invece di fallire
Sverrisson

28

Xcode 8, Swift 3 modo per leggere il file dal bundle dell'app:

if let path = Bundle.main.path(forResource: filename, ofType: nil) {
    do {
        let text = try String(contentsOfFile: path, encoding: String.Encoding.utf8)
        print(text)
    } catch {
        printError("Failed to read text from \(filename)")
    }
} else {
    printError("Failed to load file from app bundle \(filename)")
} 

Ecco una comoda estensione copia e incolla

public extension String {
    func contentsOrBlank()->String {
        if let path = Bundle.main.path(forResource:self , ofType: nil) {
            do {
                let text = try String(contentsOfFile:path, encoding: String.Encoding.utf8)
                return text
                } catch { print("Failed to read text from bundle file \(self)") }
        } else { print("Failed to load file from bundle \(self)") }
        return ""
    }
    }

Per esempio

let t = "yourFile.txt".contentsOrBlank()

Quasi sempre vuoi una serie di linee:

let r:[String] = "yourFile.txt"
     .contentsOrBlank()
     .characters
     .split(separator: "\n", omittingEmptySubsequences:ignore)
     .map(String.init)

2
Ho incollato in una pratica estensione @crashalot - sentiti libero di cancellare, evviva
Fattie

1
@Alshcompiler NO! Non puoi SCRIVERE un file nel bundle.
Sverrisson,

Stavo parlando di leggere da un file, è l'unica risposta che ha funzionato con me se il file è nei file di progetto
compilatore Alsh

10

Voglio mostrarti solo la prima parte, che viene letta . Ecco come puoi leggere semplicemente:

Swift 3:

let s = try String(contentsOfFile: Bundle.main.path(forResource: "myFile", ofType: "txt")!)

Swift 2:

let s = try! String(contentsOfFile: NSBundle.mainBundle().pathForResource("myFile", ofType: "txt")!)

5

Il modo più semplice per leggere un file in Swift> 4.0

 let path = Bundle.main.path(forResource: "data", ofType: "txt") // file path for file "data.txt"
        do {
            var text = try String(contentsOfFile: path!)
        }
        catch(_){print("error")}
    }

3

La risposta attualmente accettata sopra da Adam ha avuto alcuni errori per me, ma ecco come ho rielaborato la sua risposta e fatto funzionare questo per me.

let file = "file.txt"

let dirs: [String]? = NSSearchPathForDirectoriesInDomains(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomainMask.AllDomainsMask, true) as? [String]

if (dirs != nil) {
    let directories:[String] = dirs!
    let dirs = directories[0]; //documents directory
    let path = dirs.stringByAppendingPathComponent(file);
    let text = "some text"

    //writing
    text.writeToFile(path, atomically: false, encoding: NSUTF8StringEncoding, error: nil);

    //reading
     var error:NSError?

    //reading
    let text2 = String(contentsOfFile: path, encoding:NSUTF8StringEncoding, error: &error)

    if let theError = error {
        print("\(theError.localizedDescription)")
    }
}

3

È possibile che questo strumento sia utile non solo per leggere da file in Swift ma anche per analizzare il proprio input: https://github.com/shoumikhin/StreamScanner

Basta specificare il percorso del file e i delimitatori di dati come questo:

import StreamScanner

if let input = NSFileHandle(forReadingAtPath: "/file/path")
{
    let scanner = StreamScanner(source: input, delimiters: NSCharacterSet(charactersInString: ":\n"))  //separate data by colons and newlines

    while let field: String = scanner.read()
    {
        //use field
    }
}

Spero che questo ti aiuti.


2

Ho dovuto ricodificare in questo modo:

let path = NSBundle.mainBundle().pathForResource("Output_5", ofType: "xml")
let text = try? NSString(contentsOfFile: path! as String, encoding: NSUTF8StringEncoding)
print(text)

2

Nell'esempio di funzione, (leggi | scrivi) DocumentsFromFile (...) avere alcuni wrapper di funzioni sembra certamente logico poiché tutto in OSx e iOS sembra aver bisogno di tre o quattro classi principali istanziate e un mucchio di proprietà, configurate, collegate, istanziato e impostato, solo per scrivere "Ciao" in un file, in 182 paesi.

Tuttavia, questi esempi non sono abbastanza completi da utilizzare in un vero programma. La funzione di scrittura non segnala alcun errore durante la creazione o la scrittura nel file. Sulla lettura, non penso sia una buona idea restituire un errore che il file non esiste come stringa che dovrebbe contenere i dati letti. Vorresti sapere che non è riuscito e perché, attraverso un meccanismo di notifica, come un'eccezione. Quindi, è possibile scrivere un codice che emetta qual è il problema e consente all'utente di risolverlo, oppure "correttamente" interrompe il programma in quel punto.

Non si vorrebbe semplicemente restituire una stringa con un "File di errore non esiste" in essa. Quindi, dovresti cercare l'errore nella stringa dalla funzione di chiamata ogni volta e gestirlo lì. Probabilmente non puoi davvero dire se la stringa di errore è stata effettivamente letta da un file reale o se è stata prodotta dal tuo codice.

Non puoi nemmeno chiamare la lettura in questo modo in swift 2.2 e Xcode 7.3 perché NSString (contentsOfFile ...) genera un'eccezione. È un errore di compilazione se non si dispone di codice per catturarlo e fare qualcosa con esso, come stamparlo su stdout o, meglio, una finestra popup di errore o stderr. Ho sentito che Apple si sta allontanando dal tentativo di cattura ed eccezioni, ma sarà una lunga mossa e non è possibile scrivere codice senza questo. Non so da dove provenga l'argomento & error, forse una versione precedente, ma NSString.writeTo [File | URL] al momento non ha un argomento NSError. Sono definiti in questo modo in NSString.h:

public func writeToURL(url: NSURL, atomically useAuxiliaryFile: Bool, encoding enc: UInt) throws
public func writeToFile(path: String, atomically useAuxiliaryFile: Bool, encoding enc: UInt) throws
public convenience init(contentsOfURL url: NSURL, encoding enc: UInt) throws
public convenience init(contentsOfFile path: String, encoding enc: UInt) throws

Inoltre, il file inesistente è solo uno dei numerosi problemi che il tuo programma potrebbe avere leggendo un file, come un problema di autorizzazioni, la dimensione del file o numerosi altri problemi per i quali non vorresti nemmeno provare a codificare un gestore ognuno di loro. È meglio supporre che sia tutto corretto e catturare e stampare, o gestire, un'eccezione se qualcosa va storto, inoltre, a questo punto, non hai davvero scelta comunque.

Ecco le mie riscritture:

func writeToDocumentsFile(fileName:String,value:String) {

    let documentsPath = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0] as NSString!
    let path = documentsPath.stringByAppendingPathComponent(fileName)

    do {
        try value.writeToFile(path, atomically: true, encoding: NSUTF8StringEncoding)
    } catch let error as NSError {
        print("ERROR : writing to file \(path) : \(error.localizedDescription)")
    }

}

func readFromDocumentsFile(fileName:String) -> String {

    let documentsPath = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0] as NSString
    let path = documentsPath.stringByAppendingPathComponent(fileName)

    var readText : String = ""

    do {
        try readText = NSString(contentsOfFile: path, encoding: NSUTF8StringEncoding) as String
    }
    catch let error as NSError {
        print("ERROR : reading from file \(fileName) : \(error.localizedDescription)")
    }
    return readText
}

In molte delle tue risposte penso che tu non stia afferrando il mio punto. (o potrebbe non interessarti e va bene). Tuttavia, per essere chiari, generare un'eccezione e gestirla in qualche modo quando si cerca un file che non è presente (o presenta un altro problema come un'autorizzazione) è molto meglio che restituire una stringa come "ERRORE: File [nome file] non esiste "come la stringa che dovevi effettivamente leggere dal file. Quindi stampandolo. Semmai dovresti stampare i dettagli dell'eccezione, non la stringa di lettura non riuscita che ora contiene un errore. Il programma probabilmente non dovrebbe semplicemente continuare.
Sam Allen,

2

Per il mio file txt funziona in questo modo:

let myFileURL = NSBundle.mainBundle().URLForResource("listacomuni", withExtension: "txt")!
let myText = try! String(contentsOfURL: myFileURL, encoding: NSISOLatin1StringEncoding)
print(String(myText))

2

Per evitare confusione e aggiungere facilità, ho creato due funzioni per leggere e scrivere stringhe su file nella directory dei documenti. Ecco le funzioni:

func writeToDocumentsFile(fileName:String,value:String) {
    let documentsPath = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0] as! NSString
    let path = documentsPath.stringByAppendingPathComponent(fileName)
    var error:NSError?
    value.writeToFile(path, atomically: true, encoding: NSUTF8StringEncoding, error: &error)
}

func readFromDocumentsFile(fileName:String) -> String {
    let documentsPath = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0] as! NSString
    let path = documentsPath.stringByAppendingPathComponent(fileName)
    var checkValidation = NSFileManager.defaultManager()
    var error:NSError?
    var file:String

    if checkValidation.fileExistsAtPath(path) {
        file = NSString(contentsOfFile: path, encoding: NSUTF8StringEncoding, error: nil) as! String
    } else {
        file = "*ERROR* \(fileName) does not exist."
    }

    return file
}

Ecco un esempio del loro uso:

writeToDocumentsFile("MyText.txt","Hello world!")

let value = readFromDocumentsFile("MyText.txt")
println(value)  //Would output 'Hello world!'

let otherValue = readFromDocumentsFile("SomeText.txt")
println(otherValue)  //Would output '*ERROR* SomeText.txt does not exist.'

Spero che questo ti aiuti!

Versione Xcode: 6.3.2


2

Codice swift3 più recente
Puoi leggere i dati dal file di testo solo usando il codice qui sotto Questo mio file di testo

     {
"NumberOfSlices": "8",
"NrScenes": "5",
"Scenes": [{
           "dataType": "label1",
           "image":"http://is3.mzstatic.com/image/thumb/Purple19/v4/6e/81/31/6e8131cf-2092-3cd3-534c-28e129897ca9/mzl.syvaewyp.png/53x53bb-85.png",

           "value": "Hello",
           "color": "(UIColor.red)"
           }, {
           "dataType": "label2",
           "image":"http://is1.mzstatic.com/image/thumb/Purple71/v4/6c/4c/c1/6c4cc1bc-8f94-7b13-f3aa-84c41443caf3/mzl.hcqvmrix.png/53x53bb-85.png",
           "value": "Hi There",
           "color": "(UIColor.blue)"
           }, {
           "dataType": "label3",
           "image":"http://is1.mzstatic.com/image/thumb/Purple71/v4/6c/4c/c1/6c4cc1bc-8f94-7b13-f3aa-84c41443caf3/mzl.hcqvmrix.png/53x53bb-85.png",

           "value": "hi how r u ",
           "color": "(UIColor.green)"
           }, {
           "dataType": "label4",
           "image":"http://is1.mzstatic.com/image/thumb/Purple71/v4/6c/4c/c1/6c4cc1bc-8f94-7b13-f3aa-84c41443caf3/mzl.hcqvmrix.png/53x53bb-85.png",
           "value": "what are u doing  ",
           "color": "(UIColor.purple)"
           }, {
           "dataType": "label5",
          "image":"http://is1.mzstatic.com/image/thumb/Purple71/v4/6c/4c/c1/6c4cc1bc-8f94-7b13-f3aa-84c41443caf3/mzl.hcqvmrix.png/53x53bb-85.png",
           "value": "how many times ",
           "color": "(UIColor.white)"
           }, {
           "dataType": "label6",
           "image":"http://is1.mzstatic.com/image/thumb/Purple71/v4/5a/f3/06/5af306b0-7cac-1808-f440-bab7a0d18ec0/mzl.towjvmpm.png/53x53bb-85.png",
           "value": "hi how r u ",
           "color": "(UIColor.blue)"
           }, {
           "dataType": "label7",
           "image":"http://is5.mzstatic.com/image/thumb/Purple71/v4/a8/dc/eb/a8dceb29-6daf-ca0f-d037-df9f34cdc476/mzl.ukhhsxik.png/53x53bb-85.png",
           "value": "hi how r u ",
           "color": "(UIColor.gry)"
           }, {
           "dataType": "label8",
           "image":"http://is2.mzstatic.com/image/thumb/Purple71/v4/15/23/e0/1523e03c-fff2-291e-80a7-73f35d45c7e5/mzl.zejcvahm.png/53x53bb-85.png",
           "value": "hi how r u ",
           "color": "(UIColor.brown)"
           }]

}

Puoi usare questo codice per ottenere dati dal file json di testo in swift3

     let filePath = Bundle.main.path(forResource: "nameoftheyourjsonTextfile", ofType: "json")


    let contentData = FileManager.default.contents(atPath: filePath!)
    let content = NSString(data: contentData!, encoding: String.Encoding.utf8.rawValue) as? String

    print(content)
    let json = try! JSONSerialization.jsonObject(with: contentData!) as! NSDictionary
    print(json)
    let app = json.object(forKey: "Scenes") as! NSArray!
    let _ : NSDictionary
    for dict in app! {
        let colorNam = (dict as AnyObject).object(forKey: "color") as! String
        print("colors are \(colorNam)")

       // let colour = UIColor(hexString: colorNam) {
       // colorsArray.append(colour.cgColor)
       // colorsArray.append(colorNam  as! UIColor)

        let value = (dict as AnyObject).object(forKey: "value") as! String
        print("the values are \(value)")
        valuesArray.append(value)

        let images = (dict as AnyObject).object(forKey: "image") as! String
        let url = URL(string: images as String)
        let data = try? Data(contentsOf: url!)
        print(data)
        let image1 = UIImage(data: data!)! as UIImage
        imagesArray.append(image1)
         print(image1)
            }

2

Funziona con Swift 3.1.1 su Linux:

import Foundation

let s = try! String(contentsOfFile: "yo", encoding: .utf8)

1

scrivi in ​​ViewDidLoad

var error: NSError?
var paths = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, NSSearchPathDomainMask.UserDomainMask, true)
var documentsDirectory = paths.first as String
var dataPath = documentsDirectory.stringByAppendingPathComponent("MyFolder")

if !NSFileManager.defaultManager().fileExistsAtPath(dataPath) {
    NSFileManager.defaultManager().createDirectoryAtPath(dataPath, withIntermediateDirectories: false, attributes: nil, error: &error)
} else {
    println("not creted or exist")
}

func listDocumentDirectoryfiles() -> [String] {
    if let documentDirectory = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true).first as? String {
        let myFilePath = documentDirectory.stringByAppendingPathComponent("MyFolder")
        return NSFileManager.defaultManager().contentsOfDirectoryAtPath(myFilePath, error: nil) as [String]
    }
    return []
}

1

Le soluzioni precedenti rispondono alla domanda, ma nel mio caso l'eliminazione del vecchio contenuto del file durante la scrittura era un problema.

Quindi, ho creato un pezzo di codice per scrivere su un file nella directory dei documenti senza eliminare il contenuto precedente. Probabilmente hai bisogno di una migliore gestione degli errori, ma credo che sia un buon punto di partenza. Swift 4. Utilizzo:

    let filename = "test.txt"
    createOrOverwriteEmptyFileInDocuments(filename: filename)
    if let handle = getHandleForFileInDocuments(filename: filename) {
        writeString(string: "aaa", fileHandle: handle)
        writeString(string: "bbb", fileHandle: handle)
        writeString(string: "\n", fileHandle: handle)
        writeString(string: "ccc", fileHandle: handle)
    }

Metodi di supporto:

func createOrOverwriteEmptyFileInDocuments(filename: String){
    guard let dir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first else {
        debugPrint("ERROR IN createOrOverwriteEmptyFileInDocuments")
        return
    }
    let fileURL = dir.appendingPathComponent(filename)
    do {
        try "".write(to: fileURL, atomically: true, encoding: .utf8)
    }
    catch {
        debugPrint("ERROR WRITING STRING: " + error.localizedDescription)
    }
    debugPrint("FILE CREATED: " + fileURL.absoluteString)
}

private func writeString(string: String, fileHandle: FileHandle){
    let data = string.data(using: String.Encoding.utf8)
    guard let dataU = data else {
        debugPrint("ERROR WRITING STRING: " + string)
        return
    }
    fileHandle.seekToEndOfFile()
    fileHandle.write(dataU)
}

private func getHandleForFileInDocuments(filename: String)->FileHandle?{
    guard let dir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first else {
        debugPrint("ERROR OPENING FILE")
        return nil
    }
    let fileURL = dir.appendingPathComponent(filename)
    do {
        let fileHandle: FileHandle? = try FileHandle(forWritingTo: fileURL)
        return fileHandle
    }
    catch {
        debugPrint("ERROR OPENING FILE: " + error.localizedDescription)
        return nil
    }
}

1

Swift 3.x - 5.x

Il miglior esempio è quello di creare un locale Logfilecon un'estensione .txt che può essere visualizzato e mostrato "Files App"con la data e l'ora correnti come Nome file

basta aggiungere questo codice in info.plist abilitare queste due funzionalità

  UIFileSharingEnabled
  LSSupportsOpeningDocumentsInPlace

e questa funzione di seguito

var logfileName : String = ""
func getTodayString() -> String{

    let date = Date()
    let calender = Calendar.current
    let components = calender.dateComponents([.year,.month,.day,.hour,.minute,.second], from: date)

    let year = components.year
    let month = components.month
    let day = components.day
    let hour = components.hour
    let minute = components.minute
    let second = components.second

    let today_string = String(year!) + "-" + String(month!) + "-" + String(day!) + "-" + String(hour!)  + "" + String(minute!) + "" +  String(second!)+".txt"

    return today_string

}

func LogCreator(){
    logfileName = getTodayString()

    print("LogCreator: Logfile Generated Named: \(logfileName)")

    let file = logfileName //this is the file. we will write to and read from it

    let text = "some text" //just a text

    if let dir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first {

        let fileURL = dir.appendingPathComponent(file)
        let documentPath = NSSearchPathForDirectoriesInDomains(.documentDirectory,.userDomainMask, true)[0]
        print("LogCreator: The Logs are Stored at location \(documentPath)")


        //writing
        do {
            try text.write(to: fileURL, atomically: false, encoding: .utf8)
        }
        catch {/* error handling here */}

        //reading
        do {
            let text2 = try String(contentsOf: fileURL, encoding: .utf8)
            print("LogCreator: The Detail log are :-\(text2)")
        }
        catch {/* error handling here */}
    }
}


  [1]: https://i.stack.imgur.com/4eg12.png

Ci ho provato, ma devo aver perso qualcosa. Salva il mio documento e lo mette nel file: /// var / mobile / Containers / Data / Application / E4BF1065-3B48-4E53-AC1D-0DC893CCB498 / Documents / ma non riesco a trovarlo nei file.
user3069232

1
Ho perso QUESTA chiave ... <key> CFBundleDisplayName </key> <stringa> $ {PRODUCT_NAME} </string> ha funzionato su iOS 13, Swift 5
user3069232

0
 func writeToDocumentsFile(fileName:String,value:String) {
    let documentsPath = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0] as NSString
    let path = documentsPath.appendingPathComponent(fileName)
    do{
    try value.write(toFile: path, atomically: true, encoding: String.Encoding.utf8)
}catch{
    }
    }

func readFromDocumentsFile(fileName:String) -> String {
    let documentsPath = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0] as NSString
    let path = documentsPath.appendingPathComponent(fileName)
    let checkValidation = FileManager.default
    var file:String

    if checkValidation.fileExists(atPath: path) {
        do{
       try file = NSString(contentsOfFile: path, encoding: String.Encoding.utf8.rawValue) as String
        }catch{
            file = ""
        }
        } else {
        file = ""
    }

    return file
}

0

Xcode 8.3.2 Swift 3.x . Utilizzo di NSKeyedArchiver e NSKeyedUnarchiver

Lettura di file da documenti

let documentsDirectoryPathString = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true).first!
let documentsDirectoryPath = NSURL(string: documentsDirectoryPathString)!
let jsonFilePath = documentsDirectoryPath.appendingPathComponent("Filename.json")

let fileManager = FileManager.default
var isDirectory: ObjCBool = false

if fileManager.fileExists(atPath: (jsonFilePath?.absoluteString)!, isDirectory: &isDirectory) {

let finalDataDict = NSKeyedUnarchiver.unarchiveObject(withFile: (jsonFilePath?.absoluteString)!) as! [String: Any]
}
else{
     print("File does not exists")
}

Scrivi file nei documenti

NSKeyedArchiver.archiveRootObject(finalDataDict, toFile:(jsonFilePath?.absoluteString)!)
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.