goframe gfile用法

置顶 已于 2024-07-15 15:29:17 修改
阅读量133 收藏
点赞数 6
文章标签： golang
于 2024-07-15 14:39:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leijmdas/article/details/140438437
版权

        GoFrame 的  gfile  模块提供了一套丰富的文件和目录操作方法，使得文件系统的操作变得更加简单易用。以下是一些  gfile  的常用方法及其用法：

1. 获取绝对路径：使用  Abs  函数可以获取给定路径的绝对表示形式，如果路径不是绝对路径，它会与当前工作目录联接以转换为绝对路径 。


2. 获取文件名： Basename  函数可以返回路径的最后一个元素，即文件名，包括文件扩展名 。

3. 复制文件或目录： Copy  函数用于复制文件或目录，它支持不同情况下的复制操作，例如复制单个文件或整个目录 。

4. 获取文件扩展名： Ext  函数返回文件的扩展名，包括点（ . ），而  ExtName  函数返回的扩展名则不包含点 。

5. 格式化文件大小： FormatSize  函数可以将文件大小转换为更易于阅读的格式 。

6. 读取文件内容： GetBytes  函数可以读取文件的全部内容，并以字节切片的形式返回 。

7. 读取文件的一部分内容： GetBytesByTwoOffsets  函数可以根据给定的起始和结束位置读取文件的一部分内容 。

8. 打开文件： Open  函数以只读模式打开文件或目录，而  OpenFile  和  OpenWithFlag  函数允许使用自定义的标志和权限来打开文件或目录 。

9. 获取特定字符的文件偏移量： GetNextCharOffsetByPath  函数可以根据给定的字符和起始位置返回文件中的偏移量 。

        这些方法提供了对文件系统进行操作的便利性，隐藏了底层实现的复杂性，使得开发者可以更专注于业务逻辑的实现。更多详细的使用示例和高级用法，可以查阅 GoFrame 的官方文档和接口文档 。

// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.

package gfile_test

import (
    "os"
    "path/filepath"
    "strings"
    "testing"

    "github.com/gogf/gf/v2/os/gfile"
    "github.com/gogf/gf/v2/os/gtime"
    "github.com/gogf/gf/v2/test/gtest"
    "github.com/gogf/gf/v2/util/gconv"
)

func Test_IsDir(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       paths := "/testfile"
       createDir(paths)
       defer delTestFiles(paths)

       t.Assert(gfile.IsDir(testpath()+paths), true)
       t.Assert(gfile.IsDir("./testfile2"), false)
       t.Assert(gfile.IsDir("./testfile/tt.txt"), false)
       t.Assert(gfile.IsDir(""), false)
    })
}

func Test_IsEmpty(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       path := "/testdir_" + gconv.String(gtime.TimestampNano())
       createDir(path)
       defer delTestFiles(path)

       t.Assert(gfile.IsEmpty(testpath()+path), true)
       t.Assert(gfile.IsEmpty(testpath()+path+gfile.Separator+"test.txt"), true)
    })
    gtest.C(t, func(t *gtest.T) {
       path := "/testfile_" + gconv.String(gtime.TimestampNano())
       createTestFile(path, "")
       defer delTestFiles(path)

       t.Assert(gfile.IsEmpty(testpath()+path), true)
    })
    gtest.C(t, func(t *gtest.T) {
       path := "/testfile_" + gconv.String(gtime.TimestampNano())
       createTestFile(path, "1")
       defer delTestFiles(path)

       t.Assert(gfile.IsEmpty(testpath()+path), false)
    })
}

func Test_Create(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          err       error
          filepaths []string
          fileobj   *os.File
       )
       filepaths = append(filepaths, "/testfile_cc1.txt")
       filepaths = append(filepaths, "/testfile_cc2.txt")
       for _, v := range filepaths {
          fileobj, err = gfile.Create(testpath() + v)
          defer delTestFiles(v)
          fileobj.Close()
          t.AssertNil(err)
       }
    })

    gtest.C(t, func(t *gtest.T) {
       tmpPath := gfile.Join(gfile.Temp(), "test/testfile_cc1.txt")
       fileobj, err := gfile.Create(tmpPath)
       defer gfile.Remove(tmpPath)
       t.AssertNE(fileobj, nil)
       t.AssertNil(err)
       fileobj.Close()
    })
}

func Test_Open(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          err     error
          files   []string
          flags   []bool
          fileobj *os.File
       )

       file1 := "/testfile_nc1.txt"
       createTestFile(file1, "")
       defer delTestFiles(file1)

       files = append(files, file1)
       flags = append(flags, true)

       files = append(files, "./testfile/file1/c1.txt")
       flags = append(flags, false)

       for k, v := range files {
          fileobj, err = gfile.Open(testpath() + v)
          fileobj.Close()
          if flags[k] {
             t.AssertNil(err)
          } else {
             t.AssertNE(err, nil)
          }

       }

    })
}

func Test_OpenFile(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          err     error
          files   []string
          flags   []bool
          fileobj *os.File
       )

       files = append(files, "./testfile/file1/nc1.txt")
       flags = append(flags, false)

       f1 := "/testfile_tt.txt"
       createTestFile(f1, "")
       defer delTestFiles(f1)

       files = append(files, f1)
       flags = append(flags, true)

       for k, v := range files {
          fileobj, err = gfile.OpenFile(testpath()+v, os.O_RDWR, 0666)
          fileobj.Close()
          if flags[k] {
             t.AssertNil(err)
          } else {
             t.AssertNE(err, nil)
          }

       }

    })
}

func Test_OpenWithFlag(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          err     error
          files   []string
          flags   []bool
          fileobj *os.File
       )

       file1 := "/testfile_t1.txt"
       createTestFile(file1, "")
       defer delTestFiles(file1)
       files = append(files, file1)
       flags = append(flags, true)

       files = append(files, "/testfiless/dirfiles/t1_no.txt")
       flags = append(flags, false)

       for k, v := range files {
          fileobj, err = gfile.OpenWithFlag(testpath()+v, os.O_RDWR)
          fileobj.Close()
          if flags[k] {
             t.AssertNil(err)
          } else {
             t.AssertNE(err, nil)
          }

       }

    })
}

func Test_OpenWithFlagPerm(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          err     error
          files   []string
          flags   []bool
          fileobj *os.File
       )
       file1 := "/testfile_nc1.txt"
       createTestFile(file1, "")
       defer delTestFiles(file1)
       files = append(files, file1)
       flags = append(flags, true)

       files = append(files, "/testfileyy/tt.txt")
       flags = append(flags, false)

       for k, v := range files {
          fileobj, err = gfile.OpenWithFlagPerm(testpath()+v, os.O_RDWR, 0666)
          fileobj.Close()
          if flags[k] {
             t.AssertNil(err)
          } else {
             t.AssertNE(err, nil)
          }

       }

    })
}

func Test_Exists(t *testing.T) {

    gtest.C(t, func(t *gtest.T) {
       var (
          flag  bool
          files []string
          flags []bool
       )

       file1 := "/testfile_GetContents.txt"
       createTestFile(file1, "")
       defer delTestFiles(file1)

       files = append(files, file1)
       flags = append(flags, true)

       files = append(files, "./testfile/havefile1/tt_no.txt")
       flags = append(flags, false)

       for k, v := range files {
          flag = gfile.Exists(testpath() + v)
          if flags[k] {
             t.Assert(flag, true)
          } else {
             t.Assert(flag, false)
          }

       }

    })
}

func Test_Pwd(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       paths, err := os.Getwd()
       t.AssertNil(err)
       t.Assert(gfile.Pwd(), paths)

    })
}

func Test_IsFile(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          flag  bool
          files []string
          flags []bool
       )

       file1 := "/testfile_tt.txt"
       createTestFile(file1, "")
       defer delTestFiles(file1)
       files = append(files, file1)
       flags = append(flags, true)

       dir1 := "/testfiless"
       createDir(dir1)
       defer delTestFiles(dir1)
       files = append(files, dir1)
       flags = append(flags, false)

       files = append(files, "./testfiledd/tt1.txt")
       flags = append(flags, false)

       for k, v := range files {
          flag = gfile.IsFile(testpath() + v)
          if flags[k] {
             t.Assert(flag, true)
          } else {
             t.Assert(flag, false)
          }

       }

    })
}

func Test_Info(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          err    error
          paths  string = "/testfile_t1.txt"
          files  os.FileInfo
          files2 os.FileInfo
       )

       createTestFile(paths, "")
       defer delTestFiles(paths)
       files, err = gfile.Stat(testpath() + paths)
       t.AssertNil(err)

       files2, err = os.Stat(testpath() + paths)
       t.AssertNil(err)

       t.Assert(files, files2)

    })
}

func Test_Move(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          paths     string = "/ovetest"
          filepaths string = "/testfile_ttn1.txt"
          topath    string = "/testfile_ttn2.txt"
       )
       createDir("/ovetest")
       createTestFile(paths+filepaths, "a")

       defer delTestFiles(paths)

       yfile := testpath() + paths + filepaths
       tofile := testpath() + paths + topath

       t.Assert(gfile.Move(yfile, tofile), nil)

       // 检查移动后的文件是否真实存在
       _, err := os.Stat(tofile)
       t.Assert(os.IsNotExist(err), false)

    })
}

func Test_Rename(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          paths  string = "/testfiles"
          ypath  string = "/testfilettm1.txt"
          topath string = "/testfilettm2.txt"
       )
       createDir(paths)
       createTestFile(paths+ypath, "a")
       defer delTestFiles(paths)

       ypath = testpath() + paths + ypath
       topath = testpath() + paths + topath

       t.Assert(gfile.Rename(ypath, topath), nil)
       t.Assert(gfile.IsFile(topath), true)

       t.AssertNE(gfile.Rename("", ""), nil)

    })

}

func Test_DirNames(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          paths    string = "/testdirs"
          err      error
          readlist []string
       )
       havelist := []string{
          "t1.txt",
          "t2.txt",
       }

       // 创建测试文件
       createDir(paths)
       for _, v := range havelist {
          createTestFile(paths+"/"+v, "")
       }
       defer delTestFiles(paths)

       readlist, err = gfile.DirNames(testpath() + paths)

       t.AssertNil(err)
       t.AssertIN(readlist, havelist)

       _, err = gfile.DirNames("")
       t.AssertNE(err, nil)

    })
}

func Test_Glob(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          paths      string = "/testfiles/*.txt"
          dirpath    string = "/testfiles"
          err        error
          resultlist []string
       )

       havelist1 := []string{
          "t1.txt",
          "t2.txt",
       }

       havelist2 := []string{
          testpath() + "/testfiles/t1.txt",
          testpath() + "/testfiles/t2.txt",
       }

       // ===============================构建测试文件
       createDir(dirpath)
       for _, v := range havelist1 {
          createTestFile(dirpath+"/"+v, "")
       }
       defer delTestFiles(dirpath)

       resultlist, err = gfile.Glob(testpath()+paths, true)
       t.AssertNil(err)
       t.Assert(resultlist, havelist1)

       resultlist, err = gfile.Glob(testpath()+paths, false)

       t.AssertNil(err)
       t.Assert(formatpaths(resultlist), formatpaths(havelist2))

       _, err = gfile.Glob("", true)
       t.AssertNil(err)

    })
}

func Test_Remove(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          paths string = "/testfile_t1.txt"
       )
       createTestFile(paths, "")
       t.Assert(gfile.Remove(testpath()+paths), nil)

       t.Assert(gfile.Remove(""), nil)

       defer delTestFiles(paths)

    })
}

func Test_IsReadable(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          paths1 string = "/testfile_GetContents.txt"
          paths2 string = "./testfile_GetContents_no.txt"
       )

       createTestFile(paths1, "")
       defer delTestFiles(paths1)

       t.Assert(gfile.IsReadable(testpath()+paths1), true)
       t.Assert(gfile.IsReadable(paths2), false)

    })
}

func Test_IsWritable(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          paths1 string = "/testfile_GetContents.txt"
          paths2 string = "./testfile_GetContents_no.txt"
       )

       createTestFile(paths1, "")
       defer delTestFiles(paths1)
       t.Assert(gfile.IsWritable(testpath()+paths1), true)
       t.Assert(gfile.IsWritable(paths2), false)

    })
}

func Test_Chmod(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          paths1 string = "/testfile_GetContents.txt"
          paths2 string = "./testfile_GetContents_no.txt"
       )
       createTestFile(paths1, "")
       defer delTestFiles(paths1)

       t.Assert(gfile.Chmod(testpath()+paths1, 0777), nil)
       t.AssertNE(gfile.Chmod(paths2, 0777), nil)

    })
}

// 获取绝对目录地址
func Test_RealPath(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          paths1    string = "/testfile_files"
          readlPath string

          tempstr string
       )

       createDir(paths1)
       defer delTestFiles(paths1)

       readlPath = gfile.RealPath("./")

       tempstr, _ = filepath.Abs("./")

       t.Assert(readlPath, tempstr)

       t.Assert(gfile.RealPath("./nodirs"), "")

    })
}

// 获取当前执行文件的目录
func Test_SelfPath(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          paths1    string
          readlPath string
          tempstr   string
       )
       readlPath = gfile.SelfPath()
       readlPath = filepath.ToSlash(readlPath)

       tempstr, _ = filepath.Abs(os.Args[0])
       paths1 = filepath.ToSlash(tempstr)
       paths1 = strings.Replace(paths1, "./", "/", 1)

       t.Assert(readlPath, paths1)

    })
}

func Test_SelfDir(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          paths1    string
          readlPath string
          tempstr   string
       )
       readlPath = gfile.SelfDir()

       tempstr, _ = filepath.Abs(os.Args[0])
       paths1 = filepath.Dir(tempstr)

       t.Assert(readlPath, paths1)

    })
}

func Test_Basename(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          paths1    string = "/testfilerr_GetContents.txt"
          readlPath string
       )

       createTestFile(paths1, "")
       defer delTestFiles(paths1)

       readlPath = gfile.Basename(testpath() + paths1)
       t.Assert(readlPath, "testfilerr_GetContents.txt")

    })
}

func Test_Dir(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          paths1    string = "/testfiless"
          readlPath string
       )
       createDir(paths1)
       defer delTestFiles(paths1)

       readlPath = gfile.Dir(testpath() + paths1)

       t.Assert(readlPath, testpath())

       t.Assert(len(gfile.Dir(".")) > 0, true)
    })
}

func Test_Ext(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          paths1   string = "/testfile_GetContents.txt"
          dirpath1        = "/testdirs"
       )
       createTestFile(paths1, "")
       defer delTestFiles(paths1)

       createDir(dirpath1)
       defer delTestFiles(dirpath1)

       t.Assert(gfile.Ext(testpath()+paths1), ".txt")
       t.Assert(gfile.Ext(testpath()+dirpath1), "")
    })

    gtest.C(t, func(t *gtest.T) {
       t.Assert(gfile.Ext("/var/www/test.js"), ".js")
       t.Assert(gfile.Ext("/var/www/test.min.js"), ".js")
       t.Assert(gfile.Ext("/var/www/test.js?1"), ".js")
       t.Assert(gfile.Ext("/var/www/test.min.js?v1"), ".js")
    })
}

func Test_ExtName(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       t.Assert(gfile.ExtName("/var/www/test.js"), "js")
       t.Assert(gfile.ExtName("/var/www/test.min.js"), "js")
       t.Assert(gfile.ExtName("/var/www/test.js?v=1"), "js")
       t.Assert(gfile.ExtName("/var/www/test.min.js?v=1"), "js")
    })
}

func Test_TempDir(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       t.Assert(gfile.Temp(), os.TempDir())
    })
}

func Test_Mkdir(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          tpath string = "/testfile/createdir"
          err   error
       )

       defer delTestFiles("/testfile")

       err = gfile.Mkdir(testpath() + tpath)
       t.AssertNil(err)

       err = gfile.Mkdir("")
       t.AssertNE(err, nil)

       err = gfile.Mkdir(testpath() + tpath + "2/t1")
       t.AssertNil(err)

    })
}

func Test_Stat(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       var (
          tpath1   = "/testfile_t1.txt"
          tpath2   = "./testfile_t1_no.txt"
          err      error
          fileiofo os.FileInfo
       )

       createTestFile(tpath1, "a")
       defer delTestFiles(tpath1)

       fileiofo, err = gfile.Stat(testpath() + tpath1)
       t.AssertNil(err)

       t.Assert(fileiofo.Size(), 1)

       _, err = gfile.Stat(tpath2)
       t.AssertNE(err, nil)

    })
}

func Test_MainPkgPath(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       reads := gfile.MainPkgPath()
       t.Assert(reads, "")
    })
}

func Test_SelfName(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       t.Assert(len(gfile.SelfName()) > 0, true)
    })
}

func Test_MTimestamp(t *testing.T) {
    gtest.C(t, func(t *gtest.T) {
       t.Assert(gfile.MTimestamp(gfile.Temp()) > 0, true)
    })
}
leijmdas
关注
  • 6
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
详谈tensorflow gfile文件的用法
09-18
【TensorFlow gfile 文件操作模块...需要注意的是，当涉及到跨平台或分布式文件系统时，使用tf.gfile可以确保兼容性和一致性。此外，由于gfile不涉及线程锁，因此在多线程环境中的并发文件访问可能需要额外的同步措施。
Go-gfile是一个基于WebRTC的文件直接传输软件
08-14
gfile是一个基于WebRTC的文件直接传输软件
gfile报错.docx
07-30
例如，原来使用`tf.gfile.Open()`来打开文件的代码，现在应该改为使用`tf.io.gfile.GFile()`（在`tf.io.gfile`未被移除时）或者直接使用`open()`函数。对于文件操作，如读取、写入等，可以采用以下方式： ```python...
gfile：通过WebRTC直接传输文件
02-03
用法 发件人 gfile send --file filename 运行命令 将显示一个以base64编码的 ，并将其发送到远程客户端 按照说明将客户端的SDP发送到您的流程 文件传输应开始 接收者 # SDP being the base64 SDP gotten from the ...
Go 语言返回组装数据
qq_51110402的博客
07-14 108
【代码】Go 语言返回组装数据。
使用Go编写的持续下行测速脚本，快速消耗流量且不伤硬盘
坐公交也用券
07-10 519
使用go语言编写的持续下行测速脚本,可用于任意平台使用,通过指定URL清单文本文件自动遍历测速,支持多线程,支持多平台。
Go语言指针及不支持语法汇总
最新发布
json_li的博客
07-14 124
本文为Go语言中指针定义和示例及不支持语法汇总。
Golang：数据科学领域中的高性能并发编程新星
XiaoqiangClub的博客
07-12 99
Golang：数据科学领域中的高性能并发编程新星
一个使用Go语言和现代Web技术构建跨平台桌面应用程序开源项目
yunmoon的博客
07-10 1057
Wails作为一个桥梁，连接强大的Go后端逻辑与丰富的Web前端界面，允许开发者利用两者的最佳特性来开发应用。
【Go系列】 Go语言数据结构
u013379032的博客
07-11 738
定义常量与变量类似，不过使用的关键字是const。const name = "天气真好"在 Go 语言中，常量可以是布尔型、字符串或数字类型。
Golang 高频面试题 && 答案
Lushengshi的博客
07-10 860
在探讨Go语言的并发安全性时，让我们首先理解其核心概念：并发安全性意味着即使在多任务并行执行的环境下，程序也能保持其逻辑的正确性和数据的一致性，避免诸如数据竞争、死锁或活锁等并发问题的出现。通道是并发安全的数据结构。通过这些方法，Go语言的开发者可以构建出既高效又安全的并发程序，确保在多任务环境中程序的稳定性和可靠性。例如，要移除切片中的第三个元素，可以使用切片的切片操作将切片分为两部分，并将第三个元素从中间移除。数组的元素类型和长度是数组类型的一部分，因此不同长度或不同元素类型的数组是不同的类型。
【Go系列】 Struct与interface
u013379032的博客
07-12 742
structAge intimport ("fmt""math"c.Scale(2)在上面的例子中，Area方法是一个值接收者方法，它返回圆的面积。Scale方法是一个指针接收者方法，它修改圆的半径。interfaceGo语言的设计哲学与传统的面向对象语言不同，它不提供传统的继承机制，而是使用组合（embedding）和接口来实现代码复用和多态。
【Golang】使用go mod vendor的情况
tr6666的博客
07-12 349
如果你的项目有大量的依赖，那么将这些依赖包含在你的代码库中可能会使代码库变得非常大，这可能会导致一些问题，例如增加克隆代码库的时间，或者使版本控制系统变得缓慢。如果你在没有网络连接的环境中开发，例如在飞机上或者在网络受限的公司环境中，那么vendor目录可以帮助你在没有网络连接的情况下构建和测试你的项目。如果你的项目使用了CI/CD系统，那么这些系统通常会在每次构建时从头开始，这意味着它们会自动下载所有的依赖，你不需要在你的代码库中包含这些依赖。总的来说，是否需要使用vendor目录取决于你的具体情况。
golang 什么是内存逃逸？
2401_82869454的博客
07-12 440
golang程序变量会携带有一组校验数据，用来证明它的整个生命周期是否在运行时完全可知。如果变量通过了这些校验，它就可以在栈上分配。否则就说它逃逸了，必须在堆上分配。在方法内把局部变量指针返回 局部变量原本应该在栈中分配，在栈中回收。但是由于返回时被外部引用，因此其生命周期大于栈，则溢出。发送指针或带有指针的值到 channel 中。在编译时，是没有办法知道哪个 goroutine 会在 channel 上接收数据。所以编译器没法知道变量什么时候才会被释放。在一个切片上存储指针或带指针的值。
go-redis源码解析：连接池原理
xidianhuihui的专栏
07-09 1005
redis也是通过hook执行命令，initHooks时，会将redis的hook放在第一个通过hook调用到process方法，process方法内部再调用_process。
GO语言中的接口（interface）
lp15929801907的博客
07-13 693
在Go语言中，接口（interface）是方法的集合，它允许我们定义一组方法但不实现它们，任何类型只要实现了这些方法，就被认为是实现了该接口。接口更重要的作用在于多态实现，它允许程序以多态的方式处理不同类型的值。接口体现了程序设计的多态和高内聚、低耦合的思想。
为什么go语言里从前端接收到的参数是数字28546.123456，但是不能使用float32只能使用float64呢？
琳琳的博客
07-10 350
如果你的数字超过了 `float32` 的精度范围，或者你需要更高的精度，那么使用 `float64` 会更安全。4. **内存使用**：虽然 `float64` 比 `float32` 占用更多的内存（分别是 8 字节和 4 字节），但在现代计算机上，这种差异通常可以忽略不计，除非你在处理大量数据或内存使用是关键因素。6. **显式转换**：如果你确实需要将 `float64` 转换为 `float32`，你可以使用类型转换，但请注意这可能会导致精度损失。
gosnmp库 - GetBulk() | Walk()
一去二三里...的博客
07-10 309
gosnmp所实现的SNMP协议的另外的两个操作——GetBulk，Walk
Golang | Leetcode Golang题解之第230题二叉搜索树中第K小的元素
weixin_66442839的博客
07-12 346
Golang | Leetcode Golang题解之第230题二叉搜索树中第K小的元素
tf.gfile.GFile
05-14
`tf.gfile.GFile` 是 TensorFlow 中的一个文件操作类，用于读写文件。其主要作用是在不同操作系统之间提供一致的文件操作接口，支持本地文件系统和 Google Cloud Storage 等云存储系统。 `tf.gfile.GFile` 类的使用方法类似于 Python 内置的 `open` 函数，可以用来读取或写入文件，也可以进行文件的复制、移动、删除等操作。 例如，以下代码使用 `tf.gfile.GFile` 类打开一个文本文件并读取其中的内容： ```python import tensorflow as tf with tf.gfile.GFile('example.txt', 'r') as f: content = f.read() print(content) ``` 其中，`'example.txt'` 是要读取的文件名，`'r'` 表示以只读模式打开文件。读取文件内容后，可以用 `print` 函数输出到控制台。 需要注意的是，`tf.gfile.GFile` 类在读写文件时使用了 TensorFlow 的分布式文件系统，因此可能会比 Python 内置的 `open` 函数慢。如果只需要在本地读写文件，可以使用 Python 内置的文件操作函数来提高效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

leijmdas

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值