கோவில் கோப்புகள் மற்றும் கோப்பகங்களுடன் எவ்வாறு தொடர்புகொள்வது

உங்களைப் போன்ற வாசகர்கள் MUO ஐ ஆதரிக்க உதவுகிறார்கள். எங்கள் தளத்தில் உள்ள இணைப்புகளைப் பயன்படுத்தி நீங்கள் வாங்கும் போது, ​​நாங்கள் ஒரு இணை கமிஷனைப் பெறலாம். மேலும் படிக்க.

தரவைச் சேமித்து மீட்டெடுக்க வேண்டிய பயன்பாடுகளுக்கு கோப்புகள் மற்றும் கோப்பகங்களுடன் பணிபுரிவது இன்றியமையாத பணியாகும். பிளாட்ஃபார்ம்-சுயாதீனமான கோப்பு பாதை செயல்பாடுகளுக்கான கோப்பு பாதை தொகுப்பை Go வழங்குகிறது. தொகுப்பு கோப்பு பாதைகளை கையாளும் செயல்பாடுகளை உள்ளடக்கியது மற்றும் இது Windows, Linux மற்றும் macOS உடன் இணக்கமானது.

கோப்பு பாதையை உள்ளடக்கிய செயல்பாடுகள் செல்லுபடியாகும் என்பதை உறுதிப்படுத்த கோப்பு பாதைகளை இணைக்கலாம், பிரிக்கலாம் மற்றும் சுத்தம் செய்யலாம். கோப்பகங்களை நடத்துவதற்கும் கோப்புகளைத் தேடுவதற்கும் தொகுப்பு செயல்பாடுகளைக் கொண்டுள்ளது.

---

---

அன்றைய வீடியோவை உருவாக்கவும்

நடைபயிற்சி அடைவு மரங்கள்

தி நட செயல்பாடு கோப்பு பாதை தொகுப்பு ஒரு அடைவு மரத்தில் நடப்பதற்கும், கோப்புகள் மற்றும் கோப்பகங்கள் வழியாக முன்-ஆர்டர் முறையில் பயணிப்பதற்கும் செயல்பாட்டை வழங்குகிறது. கொடுக்கப்பட்ட ரூட்டிற்கு கீழே உள்ள அனைத்து கோப்பகங்களையும் இது மீண்டும் மீண்டும் பார்வையிடும். நடை செயல்பாடு ஒரு ரூட் கோப்பகத்தையும், பாதை, கோப்பு தகவல் நிகழ்வு மற்றும் பிழை நிகழ்வையும் எடுக்கும் ஒரு செயல்பாட்டையும் எடுக்கும்.

ஒரு ரொப்லாக் பரிசு அட்டையை எப்படி மீட்பது

 package main 
 
import ( 
    "fmt" 
    "path/filepath" 
    "os" 
) 
 
func main() { 
    // Defines the root directory to start the walk 
    root := "." 
 
    // Uses the Walk function to walk the directory tree 
    err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error { 
        if err != nil { 
            return err 
        } 
 
        // Prints the name of each file or directory 
        fmt.Println(path) 
        return nil 
    }) 
 
    // Checks for errors 
    if err != nil { 
        fmt.Printf("Error walking directory tree: %v\n", err) 
    } 
} 

இந்த நிரல் ரூட் கோப்பகத்தை தற்போதைய வேலை கோப்பகமாக வரையறுக்கிறது. தி முக்கிய செயல்பாடு ரூட் கோப்பகத்தில் உள்ள கோப்பகங்கள் வழியாகச் சென்று கோப்புகளின் பெயர்களை அச்சிடுகிறது.

பேட்டர்ன் மேட்சிங் மூலம் கோப்புகளை பொருத்துதல்

நீங்கள் பயன்படுத்தலாம் பொருத்துக ஒரு வடிவத்திற்கு எதிராக கோப்பு பெயர்களை பொருத்துவதற்கான செயல்பாடு. பேட்டர்ன் தொடரியல் பொதுவானதை அடிப்படையாகக் கொண்டது கோப்பு வைல்டு கார்டு தொடரியல், இது மெட்டாகேரக்டர்களைப் பயன்படுத்துகிறது , யூனிக்ஸ் சூழல்களில் குளோப் பேட்டர்ன்கள் என அறியப்படுகிறது.

 package main 
 
import ( 
    "fmt" 
    "path/filepath" 
) 
 
func main() { 
    // Defines the pattern to match 
    pattern := "*.txt" 
 
    // Uses the Match function to match the pattern on files 
    match, err := filepath.Match(pattern, "file.txt") 
 
    if err != nil { 
        fmt.Printf("Error matching pattern: %v\n", err) 
        return 
    } 
 
    // Prints the result of the match 
    if match { 
        fmt.Println("File matches pattern.") 
    } else { 
        fmt.Println("File does not match pattern.") 
    } 
} 

தி முக்கிய செயல்பாடு ஒரு கோப்பு பெயருடன் பொருந்துகிறது *.txt வடிவம் மற்றும் முடிவைப் பொறுத்து ஒரு சரத்தை அச்சிடுகிறது நிபந்தனை அறிக்கை .

சுத்தமான செயல்பாட்டுடன் பாதைகளை சுத்தம் செய்தல்

தி சுத்தமான செயல்பாடு ஒரு கோப்பு பாதையில் செல்கிறது மற்றும் தேவையற்ற பிரிப்பான்கள் மற்றும் அடைவு மாற்றங்களை அகற்றுவதன் மூலம் பாதையின் சுத்தம் செய்யப்பட்ட பதிப்பை வழங்குகிறது. . (தற்போதைய அடைவு) மற்றும் .. (பெற்றோர் அடைவு) பிரிவுகள்.

---

---

ஐபோனில் எனது இருப்பிடத்தை எப்படிப் பகிர்வது

ஒரு பாதையில் தேவையற்ற பிரிப்பான்கள் அல்லது தவறான பிரிவுகள் இருந்தால் அல்லது தற்போதைய வேலை செய்யும் கோப்பகத்திலிருந்து சுயாதீனமான பாதைகளை உருவாக்கினால் பிழைகளைத் தவிர்க்க கோப்பு பாதைகளை சுத்தம் செய்வது பயனுள்ளதாக இருக்கும்.

 package main 
 
import ( 
    "fmt" 
    "path/filepath" 
) 
 
func main() { 
    // Creates a path with redundant separators and invalid segments 
    path := "/foo/bar//baz/.././qux/" 
 
    // Cleans the path 
    cleanPath := filepath.Clean(path) 
 
    // Prints the original and cleaned file paths 
    fmt.Println("Original path:", path) 
    fmt.Println("Cleaned path:", cleanPath) 
} 

தி பாதை மாறி என்பது ஆரம்ப கோப்பு பாதை, மற்றும் சுத்தமான செயல்பாடு சுத்தம் செய்கிறது பாதை மாறி மற்றும் சுத்தம் செய்யப்பட்ட கோப்பு பாதையை வழங்குகிறது. தி முக்கிய செயல்பாடு ஆரம்ப மற்றும் சுத்தமான கோப்பு பாதைகளை அச்சிடுகிறது.

---

---

Go இல் கோப்பு பாதைகளை இணைத்தல் மற்றும் பிரித்தல்

தி சேருங்கள் மற்றும் பிளவு செயல்பாடுகள் கோப்பு பாதைகளை இணைப்பதற்கும் பிரிப்பதற்கும் செயல்பாட்டை வழங்குகிறது.

சேர் செயல்பாடு எத்தனை பாதை கூறுகளை வேண்டுமானாலும் எடுக்கும். இயக்க முறைமைக்கான பொருத்தமான பாதை பிரிப்பானைப் பயன்படுத்தி அந்த உறுப்புகளை இணைப்பதன் விளைவாக இது ஒரு ஒற்றை கோப்பு பாதை சரத்தை வழங்குகிறது. தி சேருங்கள் செயல்பாடு அடிப்படை கோப்பு முறைமையில் இருந்து சுயாதீனமாக கோப்பு பாதைகளை உருவாக்க பயனுள்ளதாக இருக்கும்.

ஃபோட்டோஷாப்பில் லேயரின் அளவை எப்படி மாற்றுவது

 package main 
 
import ( 
    "fmt" 
    "path/filepath" 
) 
 
func main() { 
    // Defines four file paths for the join operation 
    path1 := "folder1" 
    path2 := "folder2" 
    path3 := "subfolder1" 
    path4 := "example.txt" 
 
    // Joins the four file paths together into a single path  
    joinedPath := filepath.Join(path1, path2, path3, path4) 
 
    // Print the unified file path 
    fmt.Println("Joined Path:", joinedPath) 
} 

தி பாதை1 , பாதை2 , மற்றும் பாதை3 மாறிகள் கோப்புறை பெயர்கள், மற்றும் பாதை4 மாறி என்பது ஒரு கோப்பு பெயர். தி சேருங்கள் செயல்பாடு பாதை மாறி பெயர்களை எடுத்து, இணைக்கப்பட்ட கோப்பு பாதையை வழங்குகிறது. தி முக்கிய செயல்பாடு கன்சோலுக்கு இணைக்கப்பட்ட கோப்பு பாதையை அச்சிடுகிறது fmt தொகுப்பு.

தி பிளவு செயல்பாடு ஒரு பாதை சரத்தை எடுத்து, பாதையின் அடைவு மற்றும் கோப்பு பெயர் கூறுகளை வழங்குகிறது. தி பிளவு கோப்பு பெயர்களைப் பிரித்தெடுக்க அல்லது ஒரு கோப்பின் மூலக் கோப்பகத்தைத் தீர்மானிக்க செயல்பாடு பயனுள்ளதாக இருக்கும்.

 package main 
 
import ( 
    "fmt" 
    "path/filepath" 
) 
 
func main() { 
    // Sets the file path for the split operation 
    filePath := "/home/user/documents/example.txt" 
     
    // Use the Split function to split the file path 
    // into its directory and file components 
    dir, file := filepath.Split(filePath) 
     
    // Print the directory and file components 
    fmt.Println("Directory:", dir) 
    fmt.Println("File:", file) 
} 

தி கோப்பு பாதை மாறி என்பது அசல் கோப்பு பாதை, மற்றும் பிளவு செயல்பாடு எடுக்கிறது கோப்பு பாதை மாறி மற்றும் அடைவு மற்றும் கோப்பு பெயர்களை சரங்களாக வழங்குகிறது. தி முக்கிய செயல்பாடு அடைவு மற்றும் கோப்பு பெயர்களை கன்சோலில் அச்சிடுகிறது.

நீங்கள் கோ மூலம் உரை கோப்புகளை கையாளலாம்

கோப்பு முறைமை செயல்பாட்டுடன், உரை கோப்புகள் உட்பட பல கோப்பு வகைகளுடன் பணிபுரிய உதவும் தொகுப்புகளை Go வழங்குகிறது.

நீங்கள் பயன்படுத்தலாம் bufio உரை கோப்புகளில் இடையக உள்ளீடு மற்றும் வெளியீட்டு செயல்பாடுகளுக்கான தொகுப்பு நீ மற்ற செயல்பாடுகளுக்கிடையே கோப்புகளை உருவாக்குவதற்கான தொகுப்பு.