GoLang中使用切片进行字符串比较

huangapple
go评论128阅读模式
英文:

GoLang string comparison with Slices

问题

我能够从目录中获取文件和文件夹的列表，我编写了一个名为isDir的函数，如果路径是一个目录，则返回True。

现在我的问题是，我想确保列出的文件夹中没有与切片中的字符串列表匹配的文件夹。我目前的代码可能会跳过第一个匹配，但无论如何都会打印出其他所有内容。我需要处理那些不应该被避免的文件夹。

代码适用于Windows 7/8目录，但如果提供了Linux示例，我应该也能使其工作。

  1. package main
  3. import (
  4.     "fmt"
  5.     "io/ioutil"
  6.     "os"
  7.     "strings"
  8. )
  10. func isDir(pth string) bool {
  11.          fi, err := os.Stat(pth)
  12.          if err != nil {
  13.                  return false
  14.          }
  15.          return fi.Mode().IsDir()
  16. }
  18. func main() {
  19.     gcomputer := "localhost"
  20.     location := fmt.Sprintf("\\\\%s\\c$\\Users\\", gcomputer)
  21.     // 要避免的配置文件
  22.     avoid := []string{"Administrator", "Default", "Public"}
  23.     // 遍历目录（location）中的文件和文件夹，并返回有效的配置文件
  24.     files, _ := ioutil.ReadDir(location)
  25.     for _, f := range files {
  26.         fdir := []string{location, f.Name()}
  27.         dpath := strings.Join(fdir, "")
  29.         if isDir(dpath) {
  30.             shouldAvoid := false
  31.             for _, iavoid := range avoid {
  32.                 if iavoid == f.Name() {
  33.                     shouldAvoid = true
  34.                     break
  35.                 }
  36.             }
  37.             if !shouldAvoid {
  38.                 fmt.Println(dpath)
  39.             }
  40.         }
  41.     }
  42. }

我不介意使用第三方模块，我已经在这个问题上工作了很长时间，开始变得有点冷静，使得理解文档有点困难。任何提示都将不胜感激。谢谢。

英文:

I'm able to get a list of files and folders from a directory, I've written a function called isDir to return True if the path is a directory.

Now my problem is that I want to make sure that none of the folders listed match a list of strings in a slice. The code I have might skip the first match but it will print out everything else anyways. I need to process the folders that aren't to be avoided.

Code is for Windows 7/8 directories but I should be able to get a Linux sample working too should one be provided.

  1. package main
  3. import (
  4.     "fmt"
  5.     "io/ioutil"
  6.     "os"
  7.     "strings"
  8. )
  10. func isDir(pth string) (bool) {
  11.          fi, err := os.Stat(pth)
  12.          if err != nil {
  13.                  return false
  14.          }
  15.          return fi.Mode().IsDir()
  16. }
  18. func main() {
  19. 	gcomputer := "localhost"
  20. 	location := fmt.Sprintf("\\\\%s\\c$\\Users\\", gcomputer)
  21. 	// Profiles to avoid
  22. 	avoid := []string{"Administrator", "Default", "Public"}
  23. 	// walk through files & folders in the directory (location) & return valid profiles
  24. 	files, _ := ioutil.ReadDir(location)
  25. 	for _, f := range files {
  26. 		fdir := []string{location, f.Name()}
  27. 		dpath := strings.Join(fdir, "")
  29. 		if isDir(dpath) {
  30. 			for _, iavoid := range avoid {
  31. 				for iavoid != f.Name() {
  32. 					fmt.Println(dpath)
  33. 					break
  34. 				}
  35. 				break
  36. 			}
  37. 		}
  38. 	}
  39. }

I don't mind using a third-party module, I've been working on this too long and starting to lose my cool, making understanding the docs a bit difficult. Any tips would be appreciated. Thank you.

答案1

得分: 1

如果要避免的字符串列表变得更长，您可能不希望为每个目录迭代它们。我可以建议对@peterSO的答案进行小修改：

  1. package main
  3. import (
  4.     "fmt"
  5.     "io/ioutil"
  6. )
  8. var avoidanceSet = map[string]bool{
  9.     "Administrator": true,
  10.     "Default":      true,
  11.     "Public":       true,
  12. }
  14. func avoid(name string) bool {
  15.     _, inSet := avoidanceSet[name]
  16.     return inSet
  17. }
  19. func main() {
  20.     gcomputer := "localhost"
  21.     location := fmt.Sprintf("\\\\%s\\c$\\Users\\", gcomputer)
  22.     files, err := ioutil.ReadDir(location)
  23.     if err != nil {
  24.         fmt.Println(err)
  25.         return
  26.     }
  27.     for _, f := range files {
  28.         if f.IsDir() && !avoid(f.Name()) {
  29.             dpath := location + f.Name()
  30.             fmt.Println(dpath)
  31.         }
  32.     }
  33. }

这是一个使用Go语言编写的代码示例，它使用一个名为avoidanceSet的映射来存储要避免的字符串。在avoid函数中，它会检查给定的名称是否在avoidanceSet中，如果是，则返回true，否则返回false。在main函数中，它遍历目录中的文件，并根据avoid函数的返回值来确定是否打印目录路径。

英文:

If your list of strings to avoid gets bigger, you might not want to be iterating over them for every directory. Might I suggest a small modification to @peterSO's answer:

<!-- language: golang -->
package main

  1. import (
  2.     &quot;fmt&quot;
  3.     &quot;io/ioutil&quot;
  4. )
  6. var avoidanceSet = map[string]bool{
  7.     &quot;Administrator&quot;: true,
  8.     &quot;Default&quot;: true,
  9.     &quot;Public&quot;: true,
  10. }
  12. func avoid(name string) bool {
  13.     _, inSet := avoidanceSet[name]
  14.     return inSet
  15. }
  17. func main() {
  18.     gcomputer := &quot;localhost&quot;
  19.     location := fmt.Sprintf(&quot;\\\\%s\\c$\\Users\\&quot;, gcomputer)
  20.     files, err := ioutil.ReadDir(location)
  21.     if err != nil {
  22.         fmt.Println(err)
  23.         return
  24.     }
  25.     for _, f := range files {
  26.         if f.IsDir() &amp;&amp; !avoid(f.Name()) {
  27.             dpath := location + f.Name()
  28.             fmt.Println(dpath)
  29.         }
  30.     }
  31. }

答案2

得分: 0

例如，

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"io/ioutil"
  6. )
  8. func avoid(name string) bool {
  9. 	profiles := []string{"Administrator", "Default", "Public"}
  10. 	for _, p := range profiles {
  11. 		if name == p {
  12. 			return true
  13. 		}
  14. 	}
  15. 	return false
  16. }
  18. func main() {
  19. 	gcomputer := "localhost"
  20. 	location := fmt.Sprintf("\\\\%s\\c$\\Users\\", gcomputer)
  21. 	files, err := ioutil.ReadDir(location)
  22. 	if err != nil {
  23. 		fmt.Println(err)
  24. 		return
  25. 	}
  26. 	for _, f := range files {
  27. 		if f.IsDir() && !avoid(f.Name()) {
  28. 			dpath := location + f.Name()
  29. 			fmt.Println(dpath)
  30. 		}
  31. 	}
  32. }
英文:

For example,

  1. package main
  3. import (
  4. 	&quot;fmt&quot;
  5. 	&quot;io/ioutil&quot;
  6. )
  8. func avoid(name string) bool {
  9. 	profiles := []string{&quot;Administrator&quot;, &quot;Default&quot;, &quot;Public&quot;}
  10. 	for _, p := range profiles {
  11. 		if name == p {
  12. 			return true
  13. 		}
  14. 	}
  15. 	return false
  16. }
  18. func main() {
  19. 	gcomputer := &quot;localhost&quot;
  20. 	location := fmt.Sprintf(&quot;\\\\%s\\c$\\Users\\&quot;, gcomputer)
  21. 	files, err := ioutil.ReadDir(location)
  22. 	if err != nil {
  23. 		fmt.Println(err)
  24. 		return
  25. 	}
  26. 	for _, f := range files {
  27. 		if f.IsDir() &amp;&amp; !avoid(f.Name()) {
  28. 			dpath := location + f.Name()
  29. 			fmt.Println(dpath)
  30. 		}
  31. 	}
  32. }

huangapple
  • 本文由 发表于 2015年3月30日 08:46:20
  • 转载请务必保留本文链接：https://go.coder-hub.com/29336792.html
  • go
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定