पाठ फ़ाइल से स्ट्रिंग पढ़ें और लिखें


298

मुझे एक पाठ फ़ाइल से / के लिए डेटा पढ़ने और लिखने की आवश्यकता है, लेकिन मैं यह पता लगाने में सक्षम नहीं हूं कि कैसे।

मुझे स्विफ्ट की आईबुक में यह नमूना कोड मिला, लेकिन मुझे अभी भी नहीं पता है कि डेटा कैसे लिखना या पढ़ना है।

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."

जवाबों:


547

पढ़ने और लिखने के लिए आपको एक स्थान का उपयोग करना चाहिए जो कि लेखन योग्य है, उदाहरण के लिए दस्तावेज़ निर्देशिका। निम्न कोड दिखाता है कि कैसे एक साधारण स्ट्रिंग को पढ़ना और लिखना है। आप इसे खेल के मैदान पर परख सकते हैं।

स्विफ्ट 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 */}
}

स्विफ्ट 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 */}
}

स्विफ्ट 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
पाठ 2 = String.stringWithContentsOfFile (पथ) // XCode 6.0
मैट फ्रायर

इस समाधान का उपयोग करना काम करता है, लेकिन अगर मैं फ़ाइल खोलता हूं तो इसमें कोई पाठ नहीं है। क्या मुझे कुछ याद आ रहा है?
नूनो गोंकोलेव्स

@Adam इस फ़ाइल को पथ पर क्या है = dir.stringByAppendingPathComponent (फ़ाइल) ??
zbz.lvlv

7
इसे हटा दिया जाना चाहिए, स्विफ्ट के नए संस्करणों के लिए कोड काम नहीं करता है।

1
@ billy_b29 इस पंक्ति के बाद का कोड: //readingठीक यही करता है।
एडम

88

यह मानते हुए कि आपने अपनी टेक्स्ट फ़ाइल data.txtको अपने Xcode- प्रोजेक्ट में स्थानांतरित कर लिया है (Use drag'n'drop और "यदि आवश्यक हो तो कॉपी फ़ाइलों की जाँच करें") का उपयोग आप ऑब्जेक्टिव-सी की तरह ही कर सकते हैं:

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

अपडेट:
बंडल (iOS) से किसी फ़ाइल को पढ़ने के लिए आप इसका उपयोग कर सकते हैं:

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

स्विफ्ट 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)!

स्विफ्ट 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
IOS प्रोजेक्ट्स के लिए, "stringWithContentsOfFile" अनुपलब्ध है (iOS 7 के रूप में पदावनत)
alttag

1
आईओएस प्रोजेट के साथ कुछ नहीं करना है, यह पदावनत है और एक्सकोड 6.1 (मैक ओएस एक्स सहित) के साथ अब काम नहीं करता है
लियो डबस

1
आप स्ट्रिंग का उपयोग कर सकते हैं (contentOfFile: ...)
शिम

1
आईओएस 10 स्विफ्ट 3 के साथ इसी तरह समाधान उपयोग बंडल यहाँ
टाइमलेस

69

Xcode 8.x • स्विफ्ट 3.x या बाद का

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)
}

"ऐसी कोई फ़ाइल नहीं है" की सबसे आम गलतियाँ क्या हैं। क्योंकि मैंने अपने .txt फ़ाइलों को नेविगेटर को प्रोजेक्ट करने के लिए जोड़ा और फिर मैं उन्हें यह संदेश प्राप्त करने की कोशिश करता हूं। (उन्हें डेस्कटॉप पर बनाएं और नाविक को प्रोजेक्ट करने के लिए
घसीटें

56

नई सरल और अनुशंसित विधि: Apple फ़ाइलहैंडलिंग के लिए URL का उपयोग करने की अनुशंसा करता है और अन्य समाधान यहां पदावनत लगते हैं (नीचे टिप्पणियां देखें)। निम्नलिखित URL के साथ पढ़ने और लिखने का नया सरल तरीका है (संभव URL त्रुटियों को संभालना न भूलें):

स्विफ्ट 5+, 4 और 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
क्या आप एक संदर्भ प्रदान कर सकते हैं जहां Apple इस तरह की सिफारिश करता है। या आप थोड़ा और विस्तृत कर सकते हैं कि यह अनुशंसित तरीका क्यों है?
Andrej

6
@Andrej "URL ऑब्जेक्ट्स स्थानीय फ़ाइलों को संदर्भित करने का पसंदीदा तरीका है। फ़ाइल में डेटा पढ़ने या लिखने वाले अधिकांश ऑब्जेक्ट में वे विधियाँ होती हैं जो एक फाइलनाम के रूप में एक pathname के बजाय एक NSURL ऑब्जेक्ट को स्वीकार करती हैं।" डेवलपर
.apple.com

1
आपको NSError के रूप में त्रुटियों को डालने की ज़रूरत नहीं है, या "कैच लेट एरर" का भी उपयोग करें। आप बस पकड़ कर सकते हैं और आपको मुफ्त में त्रुटि चर मिलता है।
cuomo456

@ cuomo456 आपका अधिकार मैं इसे हटा देता हूं, यह पिछले स्विफ्ट बीटा से बचा हुआ है।
सेवर्रिसन

1
@Alshcompiler बनाएँ: सच्चा फ़ाइलनामेगर को निर्देशिका बनाने के लिए सूचित करता है अगर यह पहले से ही नहीं है, तो असफल होने के बजाय
सेवर्रिसन

28

Xcode 8, ऐप बंडल से फ़ाइल पढ़ने के लिए स्विफ्ट 3 तरीका:

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)")
} 

यहां एक सुविधाजनक कॉपी और पेस्ट एक्सटेंशन है

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 ""
    }
    }

उदाहरण के लिए

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

आप लगभग हमेशा लाइनों की एक सरणी चाहते हैं:

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

2
मैंने एक आसान एक्सटेंशन @crashalot में चिपकाया - हटाने के लिए स्वतंत्र महसूस करें, चीयर्स
फेटी

1
@Alshcompiler नहीं! आप किसी फ़ाइल को बंडल में नहीं लिख सकते।
सेवर्रिसन

मैं फ़ाइल से पढ़ने के बारे में बात कर रहा था, यह एकमात्र उत्तर है जो मेरे साथ काम करता है यदि फ़ाइल प्रोजेक्ट फ़ाइलों में है
Alsh संकलक

10

मैं आपको केवल पहला भाग दिखाना चाहता हूं, जो पढ़ा गया है । यहाँ आप कैसे पढ़ सकते हैं:

स्विफ्ट 3:

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

स्विफ्ट 2:

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

5

स्विफ्ट> 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

एडम से ऊपर वर्तमान में स्वीकृत उत्तर में मेरे लिए कुछ त्रुटियां थीं, लेकिन यहां बताया गया है कि कैसे मैंने उनके उत्तर को पुनः प्राप्त किया और मेरे लिए यह काम किया।

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

आप इस उपकरण को न केवल स्विफ्ट में फ़ाइल से पढ़ सकते हैं, बल्कि अपने इनपुट को पार्स भी कर सकते हैं: https://github.com/shoumikhin/StreamScanner

इस तरह से फ़ाइल पथ और डेटा सीमांकक निर्दिष्ट करें:

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
    }
}

उम्मीद है की यह मदद करेगा।


2

मुझे इस तरह से फिर से लिखना पड़ा:

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

2

फ़ंक्शन उदाहरण में, (पढ़ें | लिखो) DocumentsFromFile (...) कुछ फ़ंक्शन रैपर होने से निश्चित रूप से समझ में आता है क्योंकि OSx और iOS में सब कुछ तीन या चार प्रमुख वर्गों की आवश्यकता लगती है त्वरित और संपत्तियों का एक गुच्छा, कॉन्फ़िगर, लिंक, उदाहरण त्वरित, और सेट, केवल 182 देशों में, एक फ़ाइल में "हाय" लिखने के लिए।

हालाँकि, ये उदाहरण वास्तविक प्रोग्राम में उपयोग करने के लिए पर्याप्त नहीं हैं। लिखने का कार्य फ़ाइल को बनाने या लिखने में किसी भी त्रुटि की रिपोर्ट नहीं करता है। पढ़ने पर, मुझे नहीं लगता कि एक त्रुटि को वापस करने के लिए यह एक अच्छा विचार है कि फ़ाइल उस स्ट्रिंग के रूप में मौजूद नहीं है जो उस डेटा को पढ़ने के लिए माना जाता है जो इसमें है। आप जानना चाहेंगे कि यह विफल हो गया और क्यों, कुछ अधिसूचना तंत्र के माध्यम से, एक अपवाद की तरह। फिर, आप कुछ कोड लिख सकते हैं जो कि आउटपुट समस्या है और उपयोगकर्ता को इसे सही करने की अनुमति देता है, या "सही ढंग से" उस बिंदु पर कार्यक्रम को तोड़ देता है।

आप इसमें केवल "त्रुटि फ़ाइल मौजूद नहीं है" के साथ एक स्ट्रिंग लौटना नहीं चाहेंगे। फिर, आपको हर बार कॉलिंग फ़ंक्शन से स्ट्रिंग में त्रुटि को देखना होगा और इसे वहां संभालना होगा। आप वास्तव में यह भी नहीं बता सकते हैं कि क्या त्रुटि स्ट्रिंग वास्तव में एक वास्तविक फ़ाइल से पढ़ी गई थी, या यदि यह आपके कोड से उत्पन्न हुई थी।

आप इस तरह से पढ़ने को स्विफ्ट 2.2 और एक्सकोड 7.3 में भी नहीं कह सकते क्योंकि एनएसएसट्रींग (कंटेंटऑफफाइल ...) एक अपवाद फेंकता है। यह एक संकलित समय त्रुटि है यदि आपके पास इसे पकड़ने और इसके साथ कुछ करने के लिए कोई कोड नहीं है, जैसे कि इसे प्रिंटआउट करने के लिए प्रिंट करें, या बेहतर, त्रुटि पॉपअप विंडो, या stderr। मैंने सुना है कि ऐप्पल कैच और अपवादों से दूर जा रहा है, लेकिन यह एक लंबी चाल है और इसके बिना कोड लिखना संभव नहीं है। मुझे नहीं पता कि त्रुटि का तर्क कहां से आता है, शायद एक पुराना संस्करण, लेकिन NSString.writeTo [फ़ाइल | URL] में वर्तमान में NSError तर्क नहीं है। इन्हें 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

इसके अलावा, जो फ़ाइल मौजूद नहीं है, वह कई संभावित समस्याओं में से एक है, जिसे आपके प्रोग्राम ने फ़ाइल को पढ़ना हो सकता है, जैसे कि अनुमतियाँ समस्या, फ़ाइल का आकार, या कई अन्य समस्याएँ जिनके लिए आप किसी हैंडलर को कोड करने का प्रयास नहीं करना चाहेंगे। उनमें से हर कोई। यह सही है कि यह सब सही है और इसे पकड़ना या प्रिंट करना, या संभालना, एक अपवाद है, अगर कुछ अलग हो जाता है, इसके अलावा, इस बिंदु पर, आपके पास वास्तव में वैसे भी कोई विकल्प नहीं है।

यहाँ मेरे पुनर्लेखन हैं:

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
}

आपकी कई प्रतिक्रियाओं में मुझे लगता है कि आप मेरी बात को नहीं समझ रहे हैं। (या आप परवाह नहीं कर सकते हैं और यह ठीक है)। हालाँकि, स्पष्ट होना, एक अपवाद को फेंकना, और किसी तरह से संभालना जब आप एक ऐसी फ़ाइल की तलाश कर रहे हैं जो वहाँ नहीं है (या एक अन्य मुद्दा है जैसे कि अनुमति) एक स्ट्रिंग को वापस करने से बेहतर है जैसे कि "ERROR: फ़ाइल [फ़ाइल नाम] मौजूद नहीं है "स्ट्रिंग के रूप में आप वास्तव में फ़ाइल से पढ़ने वाले थे। फिर बस वह छपाई। यदि कुछ भी आपको अपवाद विवरण प्रिंट करना चाहिए, तो पढ़ने में विफल होने वाले स्ट्रिंग को नहीं करना चाहिए जो अब इसमें एक त्रुटि है। कार्यक्रम शायद बस जारी नहीं होना चाहिए।
सैम एलन

2

मेरी txt फ़ाइल इस तरह से काम करती है:

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

2

भ्रम से बचने और आसानी से जोड़ने के लिए, मैंने दस्तावेज़ निर्देशिका में फ़ाइलों को स्ट्रिंग पढ़ने और लिखने के लिए दो फ़ंक्शन बनाए हैं। यहाँ कार्य हैं:

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
}

यहाँ उनके उपयोग का एक उदाहरण है:

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.'

उम्मीद है की यह मदद करेगा!

Xcode संस्करण: 6.3.2


2

लेटेस्ट स्विफ्ट 3 कोड
आप टेक्स्ट फाइल से डेटा पढ़ सकते हैं, केवल bellow कोड का उपयोग करें। यह मेरी टेक्स्ट फाइल है

     {
"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)"
           }]

}

आप इस कोड का उपयोग स्विफ्ट 3 में टेक्स्ट जोंस फाइल से डेटा प्राप्त करने में कर सकते हैं

     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

यह लिनक्स पर स्विफ्ट 3.1.1 के साथ काम करता है:

import Foundation

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

1

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

पहले के समाधान सवाल का जवाब देते हैं, लेकिन मेरे मामले में लिखते समय फ़ाइल की पुरानी सामग्री को हटाना समस्या थी।

इसलिए, मैंने पिछली सामग्री को हटाए बिना दस्तावेज़ निर्देशिका में फ़ाइल करने के लिए लिखने के लिए कोड का टुकड़ा बनाया। आपको शायद बेहतर त्रुटि से निपटने की आवश्यकता है, लेकिन मेरा मानना ​​है कि यह अच्छा प्रारंभिक बिंदु है। स्विफ्ट 4. यूसेज:

    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)
    }

सहायक तरीके:

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

स्विफ्ट 3.x - 5.x

सबसे अच्छा उदाहरण Logfileएक एक्सटेंशन के साथ एक स्थानीय बनाना है .txt जो दिखाई और दिखा सकता है"Files App" एक फ़ाइल नाम के रूप में वर्तमान दिनांक और समय साथ

बस इस कोड को info.plist में जोड़ें। इन दोनों सुविधाओं को सक्षम करें

  UIFileSharingEnabled
  LSSupportsOpeningDocumentsInPlace

और नीचे इस समारोह

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

मैंने यह कोशिश की, लेकिन कुछ याद किया होगा। यह मेरे दस्तावेज़ को सहेजता है और इसे फ़ाइल में रखता है: /// var / mobile / कंटेनरों / डेटा / अनुप्रयोग / E4BF1065-3B48-4E53-AC1D-0DC893CCB498 / दस्तावेज़ / लेकिन मैं इसे फ़ाइलों में नहीं ढूँढ सकता।
user3069232

1
मैं इस कुंजी से चूक गया ... <key> CFBundleDisplayName </ key> <string> $ {PRODUCT_NAME} </ string> ने iOS 13 में काम किया, स्विफ्ट 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 स्विफ्ट 3.x । NSKeyedArchiver और NSKeyedUnarchiver का उपयोग करना

दस्तावेजों से फाइल पढ़ना

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")
}

दस्तावेज़ों को फ़ाइल लिखें

NSKeyedArchiver.archiveRootObject(finalDataDict, toFile:(jsonFilePath?.absoluteString)!)
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.