यदि स्विफ्ट में दस्तावेज़ निर्देशिका में कोई फ़ाइल मौजूद है, तो कैसे जांचें?

Question

दस्तावेज़ निर्देशिका में कोई फ़ाइल मौजूद है या नहीं, इसकी जांच कैसे करें Swift?

मैं [ .writeFilePath ]दस्तावेज़ निर्देशिका में एक छवि को बचाने के लिए विधि का उपयोग कर रहा हूं और मैं हर बार एप्लिकेशन लॉन्च होने पर इसे लोड करना चाहता हूं। लेकिन अगर कोई सहेजी गई छवि नहीं है, तो मेरे पास एक डिफ़ॉल्ट छवि है।

लेकिन मैं सिर्फ यह नहीं कर सकता कि [ func fileExistsAtPath(_:) ]समारोह का उपयोग कैसे किया जाए । क्या कोई इसमें दिए गए पथ तर्क के साथ फ़ंक्शन का उपयोग करने का एक उदाहरण दे सकता है।

मेरा मानना ​​है कि मुझे इसमें कोई कोड चिपकाने की आवश्यकता नहीं है क्योंकि यह एक सामान्य प्रश्न है। किसी भी प्रकार के मदद की बहुत सराहना की जाएगी।

चियर्स

Answer 1

स्विफ्ट 4.x संस्करण

    let path = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0] as String
    let url = NSURL(fileURLWithPath: path)
    if let pathComponent = url.appendingPathComponent("nameOfFileHere") {
        let filePath = pathComponent.path
        let fileManager = FileManager.default
        if fileManager.fileExists(atPath: filePath) {
            print("FILE AVAILABLE")
        } else {
            print("FILE NOT AVAILABLE")
        }
    } else {
        print("FILE PATH NOT AVAILABLE")
    }

स्विफ्ट 3.x संस्करण

    let path = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0] as String
    let url = URL(fileURLWithPath: path)

    let filePath = url.appendingPathComponent("nameOfFileHere").path
    let fileManager = FileManager.default
    if fileManager.fileExists(atPath: filePath) {
        print("FILE AVAILABLE")
    } else {
        print("FILE NOT AVAILABLE")
    }

2.x संस्करण स्विफ्ट , URLByAppendingPathComponent का उपयोग करने की आवश्यकता है

    let path = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0] as String
    let url = NSURL(fileURLWithPath: path)
    let filePath = url.URLByAppendingPathComponent("nameOfFileHere").path!
    let fileManager = NSFileManager.defaultManager()
    if fileManager.fileExistsAtPath(filePath) {
        print("FILE AVAILABLE")
    } else {
        print("FILE NOT AVAILABLE")
    }

Comments

ऐसा लगता है कि उत्तर अपडेट किया गया था ताकि निरपेक्ष टिप्पणियां अप्रचलित लगें।

— इफ्रेन

संभवतः उन टिप्पणियों में कहा गया था कि निरपेक्ष स्ट्रिंग एक URL से काम नहीं करता है, लेकिन पथ ऐसा करता है, जो मुझे मिला है!

— सीएमश

Answer 2

नीचे दिए गए कोड की जाँच करें:

स्विफ्ट 1.2

let paths = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0] as String

let getImagePath = paths.stringByAppendingPathComponent("SavedFile.jpg")

let checkValidation = NSFileManager.defaultManager()

if (checkValidation.fileExistsAtPath(getImagePath))
{
    println("FILE AVAILABLE");
}
else
{
    println("FILE NOT AVAILABLE");
}

स्विफ्ट 2.0

let paths = NSURL(fileURLWithPath: NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0])
let getImagePath = paths.URLByAppendingPathComponent("SavedFile.jpg")

let checkValidation = NSFileManager.defaultManager()

if (checkValidation.fileExistsAtPath("\(getImagePath)"))
{
    print("FILE AVAILABLE");
}
else
{
    print("FILE NOT AVAILABLE");
}

Comments

@SaqibOmer स्ट्रिंग के बजाय NSString के रूप में कास्टिंग पथ का प्रयास करें। var paths = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0] as NSString

— भेड़गोबिप

@PREMKUMAR क्यों है कि अजीब स्ट्रिंग प्रक्षेप? आप absoluteStringकन्वर्ट NSURLकरने के लिए उपयोग कर सकते हैं, pathलेकिन बेहतर होगा कि आप पथ को एक स्ट्रिंग ( NSString) के रूप में रखें जैसे कि आप स्विफ्ट 1.2 में करते हैं।

— सुल्तान

मुझे स्विफ्ट 2 के साथ काम करने का यह उत्तर मिला: stackoverflow.com/a/36897617/12/1245231

— petrsyn

Answer 3

आजकल (2016) एप्पल अधिक से अधिक का URL संबंधित एपीआई का उपयोग करने की सिफारिश की NSURL, NSFileManagerआदि

IOS और में दस्तावेजों निर्देशिका प्राप्त करने के लिए स्विफ्ट 2 उपयोग

let documentDirectoryURL = try! NSFileManager.defaultManager().URLForDirectory(.DocumentDirectory, 
                                 inDomain: .UserDomainMask, 
                        appropriateForURL: nil, 
                                   create: true)

try!क्योंकि इस मानक निर्देशिका मौजूद करने के लिए गारंटी है कि इस मामले में सुरक्षित है।

फिर एक sqliteफ़ाइल उदाहरण के लिए उपयुक्त पथ घटक जोड़ें

let databaseURL = documentDirectoryURL.URLByAppendingPathComponent("MyDataBase.sqlite")

अब जाँच करें कि क्या फ़ाइल मौजूद checkResourceIsReachableAndReturnErrorहै NSURL।

let fileExists = databaseURL.checkResourceIsReachableAndReturnError(nil)

यदि आपको त्रुटि की आवश्यकता है तो NSErrorपॉइंटर को पैरामीटर में पास करें।

var error : NSError?
let fileExists = databaseURL.checkResourceIsReachableAndReturnError(&error)
if !fileExists { print(error) }

स्विफ्ट 3+:

let documentDirectoryURL = try! FileManager.default.url(for: .documentDirectory, 
                                in: .userDomainMask, 
                    appropriateFor: nil, 
                            create: true)

let databaseURL = documentDirectoryURL.appendingPathComponent("MyDataBase.sqlite")

checkResourceIsReachableके रूप में चिह्नित किया गया है सकते हैं फेंक

do {
    let fileExists = try databaseURL.checkResourceIsReachable()
    // handle the boolean result
} catch let error as NSError {
    print(error)
}

केवल बूलियन रिटर्न वैल्यू पर विचार करने और त्रुटि को अनदेखा करने के लिए एनआईएल-कोलेसिंग ऑपरेटर का उपयोग करें

let fileExists = (try? databaseURL.checkResourceIsReachable()) ?? false

Comments

मुझे लगता है कि स्विफ्ट 3 में यह अब है checkResourceIsReachable()और बस प्रकार के Boolलिए रिटर्न URL।

— एथन एलन

जो समस्या मुझे मिली वह यह है कि आप कभी भी स्विफ्ट 3 में checkResourceIsReachable () से एक "झूठा" मान प्राप्त नहीं करते हैं, अगर फ़ाइल नहीं है तो सिर्फ एक अपवाद। मैं एक एपीआई का उपयोग करके बहुत खुश नहीं हूं, जहां बहुत सारे कॉल एक साधारण रिटर्न मान के बजाय अपवाद होंगे।

— केंडल हेल्मसटेटर गेलनर

@KendallHelmstetterGelner स्विफ्ट का try - catchपैटर्न अपवाद नहीं है। यह उद्देश्य-सी में अपवादों के साथ तुलनीय नहीं है। यह एक कुशल त्रुटि हैंडलिंग प्रणाली है।

— vadian

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

— केंडल हेल्मसटेटर गेलनर

Answer 4

यह बहुत उपयोगकर्ता के अनुकूल है। बस NSFileManager के defaultManager सिंगलटन के साथ काम करें और फिर fileExistsAtPath()विधि का उपयोग करें , जो बस एक स्ट्रिंग को एक तर्क के रूप में लेता है, और एक Bool देता है, इसे सीधे if स्टेटमेंट में रखने की अनुमति देता है।

let paths = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)
let documentDirectory = paths[0] as! String
let myFilePath = documentDirectory.stringByAppendingPathComponent("nameOfMyFile")

let manager = NSFileManager.defaultManager()
if (manager.fileExistsAtPath(myFilePath)) {
    // it's here!!
}

ध्यान दें कि स्विफ्ट 2 में स्ट्रिंग का डाउनकास्ट आवश्यक नहीं है।

Comments

♦ कृपया मुझे यहां stackoverflow.com/questions/31503283/… मदद करें । मुझे नहीं पता कि किस कोड को लिखना है।

— अलेक्जेंडर खितेव

Answer 5

स्विफ्ट 3 में एक वैकल्पिक / अनुशंसित कोड पैटर्न होगा:

1. FileManager के बजाय URL का उपयोग करें

2. अपवाद हैंडलिंग का उपयोग

   func verifyIfSqliteDBExists(){
       let docsDir     : URL       = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
       let dbPath      : URL       = docsDir.appendingPathComponent("database.sqlite")
   
       do{
           let sqliteExists : Bool = try dbPath.checkResourceIsReachable()
           print("An sqlite database exists at this path :: \(dbPath.path)")
   
       }catch{
           print("SQLite NOT Found at :: \(strDBPath)")
       }
   }

Answer 6

स्विफ्ट 4.2

extension URL    {
    func checkFileExist() -> Bool {
        let path = self.path
        if (FileManager.default.fileExists(atPath: path))   {
            print("FILE AVAILABLE")
            return true
        }else        {
            print("FILE NOT AVAILABLE")
            return false;
        }
    }
}

का उपयोग कर: -

if fileUrl.checkFileExist()
   {
      // Do Something
   }

Answer 7

स्विफ्ट 3 शुरुआती के लाभ के लिए:

1. स्विफ्ट 3 ने अधिकांश नेक्स्टस्टेप सिंटैक्स के साथ दूर किया है
2. तो NSURL, NSFilemanager, NSSearchPathForDirectoriesInDomain का अब उपयोग नहीं किया जाता है
3. इसके बजाय URL और FileManager का उपयोग करें
4. NSSearchPathForDirectoriesInDomain की आवश्यकता नहीं है
5. इसके बजाय FileManager.default.urls का उपयोग करें

यहां यह सत्यापित करने के लिए एक कोड सैंपल दिया गया है कि "डेटाबेस.sqlite" नामक फाइल एप्लिकेशन डॉक्यूमेंट डायरेक्टरी में मौजूद है:

func findIfSqliteDBExists(){

    let docsDir     : URL       = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
    let dbPath      : URL       = docsDir.appendingPathComponent("database.sqlite")
    let strDBPath   : String    = dbPath.path
    let fileManager : FileManager   = FileManager.default

    if fileManager.fileExists(atPath:strDBPath){
        print("An sqlite database exists at this path :: \(strDBPath)")
    }else{
        print("SQLite NOT Found at :: \(strDBPath)")
    }

}

Answer 8

बहुत सरल: यदि आपका पथ URL उदाहरण है, तो 'पथ' विधि द्वारा स्ट्रिंग में कनवर्ट करें।

    let fileManager = FileManager.default
    var isDir: ObjCBool = false
    if fileManager.fileExists(atPath: yourURLPath.path, isDirectory: &isDir) {
        if isDir.boolValue {
            //it's a Directory path
        }else{
            //it's a File path
        }
    }

Answer 9

स्विफ्ट 4 में यह मेरे लिए ठीक काम करता है:

func existingFile(fileName: String) -> Bool {

    let path = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0] as String
    let url = NSURL(fileURLWithPath: path)
    if let pathComponent = url.appendingPathComponent("\(fileName)") {
        let filePath = pathComponent.path
        let fileManager = FileManager.default
        if fileManager.fileExists(atPath: filePath) 

       {

        return true

        } else {

        return false

        }

    } else {

        return false

        }


}

आप इस कॉल के साथ देख सकते हैं:

   if existingFile(fileName: "yourfilename") == true {

            // your code if file exists

           } else {

           // your code if file does not exist

           }

मुझे उम्मीद है कि यह किसी के लिए उपयोगी है। @; -]

Comments

क्या होगा यदि उपयोगकर्ता केवल दस्तावेज़ निर्देशिका की जांच नहीं करना चाहता है? और एक सामान्य रास्ता खोजना चाहते हैं

— जोगेंद्र कुमार

Answer 10

आपको फ़ाइल नाम से पहले "/" स्लैश जोड़ना होगा, या आपको "... / DocumentsFilename .jpg" जैसा रास्ता मिलेगा।

Answer 11

स्विफ्ट 4 उदाहरण:

var filePath: String {
    //manager lets you examine contents of a files and folders in your app.
    let manager = FileManager.default

    //returns an array of urls from our documentDirectory and we take the first
    let url = manager.urls(for: .documentDirectory, in: .userDomainMask).first
    //print("this is the url path in the document directory \(String(describing: url))")

    //creates a new path component and creates a new file called "Data" where we store our data array
    return(url!.appendingPathComponent("Data").path)
}

मैंने अपने लोडडैटा फ़ंक्शन में चेक डाला जिसे मैंने व्यूडलडड में बुलाया।

override func viewDidLoad() {
    super.viewDidLoad()

    loadData()
}

फिर मैंने नीचे लोडडैट को परिभाषित किया।

func loadData() {
    let manager = FileManager.default

    if manager.fileExists(atPath: filePath) {
        print("The file exists!")

        //Do what you need with the file. 
        ourData = NSKeyedUnarchiver.unarchiveObject(withFile: filePath) as! Array<DataObject>         
    } else {
        print("The file DOES NOT exist! Mournful trumpets sound...")
    }
}

Answer 12

स्विफ्ट 5 पर काम करता है

    do {
        let documentDirectory = try FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
        let fileUrl = documentDirectory.appendingPathComponent("userInfo").appendingPathExtension("sqlite3")
        if FileManager.default.fileExists(atPath: fileUrl.path) {
            print("FILE AVAILABLE")
        } else {
            print("FILE NOT AVAILABLE")
        }
    } catch {
        print(error)
    }

जहाँ "userInfo"- फ़ाइल का नाम, और "sqlite3"- फ़ाइल का विस्तार