2019-02-02 16:18:25 +08:00
|
|
|
// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
|
2017-12-29 16:03:30 +08:00
|
|
|
//
|
|
|
|
// 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,
|
2019-02-02 16:18:25 +08:00
|
|
|
// You can obtain one at https://github.com/gogf/gf.
|
2017-12-29 16:03:30 +08:00
|
|
|
|
2019-01-15 23:27:47 +08:00
|
|
|
// Package gfile provides easy-to-use operations for file system.
|
2017-11-23 10:21:28 +08:00
|
|
|
package gfile
|
|
|
|
|
|
|
|
import (
|
2020-03-04 17:29:23 +08:00
|
|
|
"github.com/gogf/gf/text/gstr"
|
2019-04-22 22:33:11 +08:00
|
|
|
"os"
|
|
|
|
"os/exec"
|
|
|
|
"path/filepath"
|
|
|
|
"strings"
|
|
|
|
"time"
|
2019-07-08 11:37:02 +08:00
|
|
|
|
2019-07-29 21:01:19 +08:00
|
|
|
"github.com/gogf/gf/container/gtype"
|
|
|
|
"github.com/gogf/gf/util/gconv"
|
2017-11-23 10:21:28 +08:00
|
|
|
)
|
|
|
|
|
2020-07-30 20:57:08 +08:00
|
|
|
var (
|
2019-09-11 21:19:45 +08:00
|
|
|
// Separator for file system.
|
2020-07-30 20:57:08 +08:00
|
|
|
// It here defines the separator as variable
|
|
|
|
// to allow it modified by developer if necessary.
|
2019-09-11 21:19:45 +08:00
|
|
|
Separator = string(filepath.Separator)
|
2017-11-23 10:21:28 +08:00
|
|
|
|
2020-05-16 00:50:01 +08:00
|
|
|
// DefaultPerm is the default perm for file opening.
|
|
|
|
DefaultPermOpen = os.FileMode(0666)
|
|
|
|
|
|
|
|
// DefaultPermCopy is the default perm for file/folder copy.
|
|
|
|
DefaultPermCopy = os.FileMode(0777)
|
2020-03-07 19:31:33 +08:00
|
|
|
|
2019-06-19 09:06:52 +08:00
|
|
|
// The absolute file path for main package.
|
|
|
|
// It can be only checked and set once.
|
|
|
|
mainPkgPath = gtype.NewString()
|
2020-03-07 19:31:33 +08:00
|
|
|
|
|
|
|
// selfPath is the current running binary path.
|
|
|
|
// As it is most commonly used, it is so defined as an internal package variable.
|
|
|
|
selfPath = ""
|
|
|
|
|
2019-12-11 21:22:41 +08:00
|
|
|
// Temporary directory of system.
|
|
|
|
tempDir = "/tmp"
|
2018-08-21 21:18:56 +08:00
|
|
|
)
|
2018-05-03 16:12:01 +08:00
|
|
|
|
2019-12-11 21:22:41 +08:00
|
|
|
func init() {
|
2020-03-07 19:31:33 +08:00
|
|
|
// Initialize internal package variable: tempDir.
|
2020-04-30 16:53:47 +08:00
|
|
|
if Separator != "/" || !Exists(tempDir) {
|
2019-12-11 21:22:41 +08:00
|
|
|
tempDir = os.TempDir()
|
|
|
|
}
|
2020-03-07 19:31:33 +08:00
|
|
|
// Initialize internal package variable: selfPath.
|
2020-03-07 20:28:00 +08:00
|
|
|
selfPath, _ = exec.LookPath(os.Args[0])
|
2020-03-07 19:31:33 +08:00
|
|
|
if selfPath != "" {
|
|
|
|
selfPath, _ = filepath.Abs(selfPath)
|
|
|
|
}
|
|
|
|
if selfPath == "" {
|
|
|
|
selfPath, _ = filepath.Abs(os.Args[0])
|
|
|
|
}
|
2019-12-11 21:22:41 +08:00
|
|
|
}
|
|
|
|
|
2019-05-23 21:58:04 +08:00
|
|
|
// Mkdir creates directories recursively with given <path>.
|
|
|
|
// The parameter <path> is suggested to be absolute path.
|
2017-11-23 10:21:28 +08:00
|
|
|
func Mkdir(path string) error {
|
2019-06-19 09:06:52 +08:00
|
|
|
err := os.MkdirAll(path, os.ModePerm)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2019-05-23 21:58:04 +08:00
|
|
|
// Create creates file with given <path> recursively.
|
|
|
|
// The parameter <path> is suggested to be absolute path.
|
2019-02-15 21:30:35 +08:00
|
|
|
func Create(path string) (*os.File, error) {
|
2019-06-19 09:06:52 +08:00
|
|
|
dir := Dir(path)
|
|
|
|
if !Exists(dir) {
|
2020-03-04 17:29:23 +08:00
|
|
|
if err := Mkdir(dir); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
return os.Create(path)
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2020-03-07 19:31:33 +08:00
|
|
|
// Open opens file/directory READONLY.
|
2017-11-23 10:21:28 +08:00
|
|
|
func Open(path string) (*os.File, error) {
|
2019-06-19 09:06:52 +08:00
|
|
|
return os.Open(path)
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2020-03-07 19:31:33 +08:00
|
|
|
// OpenFile opens file/directory with custom <flag> and <perm>.
|
|
|
|
// The parameter <flag> is like: O_RDONLY, O_RDWR, O_RDWR|O_CREATE|O_TRUNC, etc.
|
2019-02-15 21:30:35 +08:00
|
|
|
func OpenFile(path string, flag int, perm os.FileMode) (*os.File, error) {
|
2019-06-19 09:06:52 +08:00
|
|
|
return os.OpenFile(path, flag, perm)
|
2019-02-15 21:30:35 +08:00
|
|
|
}
|
|
|
|
|
2020-03-07 19:31:33 +08:00
|
|
|
// OpenWithFlag opens file/directory with default perm and custom <flag>.
|
|
|
|
// The default <perm> is 0666.
|
|
|
|
// The parameter <flag> is like: O_RDONLY, O_RDWR, O_RDWR|O_CREATE|O_TRUNC, etc.
|
2017-11-23 10:21:28 +08:00
|
|
|
func OpenWithFlag(path string, flag int) (*os.File, error) {
|
2020-05-16 00:50:01 +08:00
|
|
|
f, err := os.OpenFile(path, flag, DefaultPermOpen)
|
2019-06-19 09:06:52 +08:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return f, nil
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2020-03-07 19:31:33 +08:00
|
|
|
// OpenWithFlagPerm opens file/directory with custom <flag> and <perm>.
|
|
|
|
// The parameter <flag> is like: O_RDONLY, O_RDWR, O_RDWR|O_CREATE|O_TRUNC, etc.
|
|
|
|
// The parameter <perm> is like: 0600, 0666, 0777, etc.
|
2019-09-11 21:19:45 +08:00
|
|
|
func OpenWithFlagPerm(path string, flag int, perm os.FileMode) (*os.File, error) {
|
2020-03-07 19:31:33 +08:00
|
|
|
f, err := os.OpenFile(path, flag, perm)
|
2019-06-19 09:06:52 +08:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return f, nil
|
2018-10-22 18:58:11 +08:00
|
|
|
}
|
|
|
|
|
2019-09-09 22:56:54 +08:00
|
|
|
// Join joins string array paths with file separator of current system.
|
|
|
|
func Join(paths ...string) string {
|
2020-03-04 17:29:23 +08:00
|
|
|
var s string
|
|
|
|
for _, path := range paths {
|
|
|
|
if s != "" {
|
|
|
|
s += Separator
|
|
|
|
}
|
|
|
|
s += gstr.TrimRight(path, Separator)
|
|
|
|
}
|
|
|
|
return s
|
2019-09-09 22:56:54 +08:00
|
|
|
}
|
|
|
|
|
2019-05-23 21:58:04 +08:00
|
|
|
// Exists checks whether given <path> exist.
|
2017-11-23 10:21:28 +08:00
|
|
|
func Exists(path string) bool {
|
2019-12-25 21:22:06 +08:00
|
|
|
if stat, err := os.Stat(path); stat != nil && !os.IsNotExist(err) {
|
2019-06-19 09:06:52 +08:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
return false
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2019-05-23 21:58:04 +08:00
|
|
|
// IsDir checks whether given <path> a directory.
|
2020-05-16 14:06:35 +08:00
|
|
|
// Note that it returns false if the <path> does not exist.
|
2017-11-23 10:21:28 +08:00
|
|
|
func IsDir(path string) bool {
|
2019-06-19 09:06:52 +08:00
|
|
|
s, err := os.Stat(path)
|
|
|
|
if err != nil {
|
2020-05-16 14:06:35 +08:00
|
|
|
return false
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
return s.IsDir()
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2019-05-23 21:58:04 +08:00
|
|
|
// Pwd returns absolute path of current working directory.
|
2020-05-16 14:06:35 +08:00
|
|
|
// Note that it returns an empty string if retrieving current
|
|
|
|
// working directory failed.
|
2018-08-14 19:53:31 +08:00
|
|
|
func Pwd() string {
|
2020-05-15 21:51:03 +08:00
|
|
|
path, err := os.Getwd()
|
|
|
|
if err != nil {
|
2020-05-16 14:06:35 +08:00
|
|
|
return ""
|
2020-05-15 21:51:03 +08:00
|
|
|
}
|
2019-06-19 09:06:52 +08:00
|
|
|
return path
|
2018-08-14 19:53:31 +08:00
|
|
|
}
|
|
|
|
|
2019-11-28 23:19:37 +08:00
|
|
|
// Chdir changes the current working directory to the named directory.
|
|
|
|
// If there is an error, it will be of type *PathError.
|
|
|
|
func Chdir(dir string) error {
|
|
|
|
return os.Chdir(dir)
|
|
|
|
}
|
|
|
|
|
2019-05-23 21:58:04 +08:00
|
|
|
// IsFile checks whether given <path> a file, which means it's not a directory.
|
2020-05-16 14:06:35 +08:00
|
|
|
// Note that it returns false if the <path> does not exist.
|
2017-11-23 10:21:28 +08:00
|
|
|
func IsFile(path string) bool {
|
2019-06-19 09:06:52 +08:00
|
|
|
s, err := os.Stat(path)
|
|
|
|
if err != nil {
|
2020-05-16 14:06:35 +08:00
|
|
|
return false
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
return !s.IsDir()
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2019-05-23 21:58:04 +08:00
|
|
|
// Alias of Stat.
|
2019-03-12 00:24:31 +08:00
|
|
|
// See Stat.
|
|
|
|
func Info(path string) (os.FileInfo, error) {
|
2019-06-19 09:06:52 +08:00
|
|
|
return Stat(path)
|
2019-03-12 00:24:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Stat returns a FileInfo describing the named file.
|
2019-02-15 21:30:35 +08:00
|
|
|
// If there is an error, it will be of type *PathError.
|
2019-03-12 00:24:31 +08:00
|
|
|
func Stat(path string) (os.FileInfo, error) {
|
2019-06-19 09:06:52 +08:00
|
|
|
return os.Stat(path)
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2019-05-23 21:58:04 +08:00
|
|
|
// Move renames (moves) <src> to <dst> path.
|
2020-03-26 20:58:57 +08:00
|
|
|
// If <dst> already exists and is not a directory, it'll be replaced.
|
2017-11-23 10:21:28 +08:00
|
|
|
func Move(src string, dst string) error {
|
2019-06-19 09:06:52 +08:00
|
|
|
return os.Rename(src, dst)
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2020-03-26 20:58:57 +08:00
|
|
|
// Rename is alias of Move.
|
2019-05-23 21:58:04 +08:00
|
|
|
// See Move.
|
2017-11-23 10:21:28 +08:00
|
|
|
func Rename(src string, dst string) error {
|
2019-06-19 09:06:52 +08:00
|
|
|
return Move(src, dst)
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2019-05-23 21:58:04 +08:00
|
|
|
// DirNames returns sub-file names of given directory <path>.
|
2019-10-31 23:37:33 +08:00
|
|
|
// Note that the returned names are NOT absolute paths.
|
2018-09-18 18:57:34 +08:00
|
|
|
func DirNames(path string) ([]string, error) {
|
2019-06-19 09:06:52 +08:00
|
|
|
f, err := os.Open(path)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
list, err := f.Readdirnames(-1)
|
|
|
|
f.Close()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return list, nil
|
2018-09-18 18:57:34 +08:00
|
|
|
}
|
|
|
|
|
2019-02-15 21:30:35 +08:00
|
|
|
// Glob returns the names of all files matching pattern or nil
|
|
|
|
// if there is no matching file. The syntax of patterns is the same
|
|
|
|
// as in Match. The pattern may describe hierarchical names such as
|
|
|
|
// /usr/*/bin/ed (assuming the Separator is '/').
|
|
|
|
//
|
|
|
|
// Glob ignores file system errors such as I/O errors reading directories.
|
|
|
|
// The only possible returned error is ErrBadPattern, when pattern
|
|
|
|
// is malformed.
|
2019-06-19 09:06:52 +08:00
|
|
|
func Glob(pattern string, onlyNames ...bool) ([]string, error) {
|
|
|
|
if list, err := filepath.Glob(pattern); err == nil {
|
|
|
|
if len(onlyNames) > 0 && onlyNames[0] && len(list) > 0 {
|
|
|
|
array := make([]string, len(list))
|
|
|
|
for k, v := range list {
|
|
|
|
array[k] = Basename(v)
|
|
|
|
}
|
|
|
|
return array, nil
|
|
|
|
}
|
|
|
|
return list, nil
|
|
|
|
} else {
|
|
|
|
return nil, err
|
|
|
|
}
|
2018-06-19 15:17:58 +08:00
|
|
|
}
|
|
|
|
|
2019-05-23 21:58:04 +08:00
|
|
|
// Remove deletes all file/directory with <path> parameter.
|
|
|
|
// If parameter <path> is directory, it deletes it recursively.
|
2017-11-23 10:21:28 +08:00
|
|
|
func Remove(path string) error {
|
2019-06-19 09:06:52 +08:00
|
|
|
return os.RemoveAll(path)
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2019-05-23 21:58:04 +08:00
|
|
|
// IsReadable checks whether given <path> is readable.
|
2017-11-23 10:21:28 +08:00
|
|
|
func IsReadable(path string) bool {
|
2019-06-19 09:06:52 +08:00
|
|
|
result := true
|
2020-05-16 00:50:01 +08:00
|
|
|
file, err := os.OpenFile(path, os.O_RDONLY, DefaultPermOpen)
|
2019-06-19 09:06:52 +08:00
|
|
|
if err != nil {
|
|
|
|
result = false
|
|
|
|
}
|
|
|
|
file.Close()
|
|
|
|
return result
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2019-05-23 21:58:04 +08:00
|
|
|
// IsWritable checks whether given <path> is writable.
|
2019-02-15 21:30:35 +08:00
|
|
|
//
|
2019-12-28 13:55:05 +08:00
|
|
|
// TODO improve performance; use golang.org/x/sys to cross-plat-form
|
2017-11-23 10:21:28 +08:00
|
|
|
func IsWritable(path string) bool {
|
2019-06-19 09:06:52 +08:00
|
|
|
result := true
|
|
|
|
if IsDir(path) {
|
|
|
|
// If it's a directory, create a temporary file to test whether it's writable.
|
|
|
|
tmpFile := strings.TrimRight(path, Separator) + Separator + gconv.String(time.Now().UnixNano())
|
|
|
|
if f, err := Create(tmpFile); err != nil || !Exists(tmpFile) {
|
|
|
|
result = false
|
|
|
|
} else {
|
|
|
|
f.Close()
|
|
|
|
Remove(tmpFile)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// 如果是文件,那么判断文件是否可打开
|
2020-05-16 00:50:01 +08:00
|
|
|
file, err := os.OpenFile(path, os.O_WRONLY, DefaultPermOpen)
|
2019-06-19 09:06:52 +08:00
|
|
|
if err != nil {
|
|
|
|
result = false
|
|
|
|
}
|
|
|
|
file.Close()
|
|
|
|
}
|
|
|
|
return result
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2019-02-15 21:30:35 +08:00
|
|
|
// See os.Chmod.
|
2017-11-23 10:21:28 +08:00
|
|
|
func Chmod(path string, mode os.FileMode) error {
|
2019-06-19 09:06:52 +08:00
|
|
|
return os.Chmod(path, mode)
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2019-07-26 23:01:12 +08:00
|
|
|
// Abs returns an absolute representation of path.
|
|
|
|
// If the path is not absolute it will be joined with the current
|
|
|
|
// working directory to turn it into an absolute path. The absolute
|
|
|
|
// path name for a given file is not guaranteed to be unique.
|
|
|
|
// Abs calls Clean on the result.
|
|
|
|
func Abs(path string) string {
|
|
|
|
p, _ := filepath.Abs(path)
|
|
|
|
return p
|
|
|
|
}
|
|
|
|
|
2019-05-23 21:58:04 +08:00
|
|
|
// RealPath converts the given <path> to its absolute path
|
|
|
|
// and checks if the file path exists.
|
|
|
|
// If the file does not exist, return an empty string.
|
2017-11-23 10:21:28 +08:00
|
|
|
func RealPath(path string) string {
|
2019-06-19 09:06:52 +08:00
|
|
|
p, err := filepath.Abs(path)
|
|
|
|
if err != nil {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
if !Exists(p) {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return p
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2019-05-23 21:58:04 +08:00
|
|
|
// SelfPath returns absolute file path of current running process(binary).
|
2017-11-23 10:21:28 +08:00
|
|
|
func SelfPath() string {
|
2020-03-07 19:31:33 +08:00
|
|
|
return selfPath
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2019-07-19 13:32:44 +08:00
|
|
|
// SelfName returns file name of current running process(binary).
|
|
|
|
func SelfName() string {
|
|
|
|
return Basename(SelfPath())
|
|
|
|
}
|
|
|
|
|
2019-05-23 21:58:04 +08:00
|
|
|
// SelfDir returns absolute directory path of current running process(binary).
|
2017-11-23 10:21:28 +08:00
|
|
|
func SelfDir() string {
|
2019-06-19 09:06:52 +08:00
|
|
|
return filepath.Dir(SelfPath())
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2020-03-15 19:32:26 +08:00
|
|
|
// Basename returns the last element of path, which contains file extension.
|
2019-05-23 21:58:04 +08:00
|
|
|
// Trailing path separators are removed before extracting the last element.
|
|
|
|
// If the path is empty, Base returns ".".
|
2019-07-24 14:48:16 +08:00
|
|
|
// If the path consists entirely of separators, Basename returns a single separator.
|
2020-05-15 21:51:03 +08:00
|
|
|
// Example:
|
|
|
|
// /var/www/file.js -> file.js
|
|
|
|
// file.js -> file.js
|
2017-11-23 10:21:28 +08:00
|
|
|
func Basename(path string) string {
|
2019-06-19 09:06:52 +08:00
|
|
|
return filepath.Base(path)
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2020-03-15 19:32:26 +08:00
|
|
|
// Name returns the last element of path without file extension.
|
2020-05-15 21:51:03 +08:00
|
|
|
// Example:
|
|
|
|
// /var/www/file.js -> file
|
|
|
|
// file.js -> file
|
2019-07-24 14:48:16 +08:00
|
|
|
func Name(path string) string {
|
|
|
|
base := filepath.Base(path)
|
|
|
|
if i := strings.LastIndexByte(base, '.'); i != -1 {
|
|
|
|
return base[:i]
|
|
|
|
}
|
|
|
|
return base
|
|
|
|
}
|
|
|
|
|
2019-05-23 21:58:04 +08:00
|
|
|
// Dir returns all but the last element of path, typically the path's directory.
|
|
|
|
// After dropping the final element, Dir calls Clean on the path and trailing
|
|
|
|
// slashes are removed.
|
|
|
|
// If the path is empty, Dir returns ".".
|
|
|
|
// If the path consists entirely of separators, Dir returns a single separator.
|
|
|
|
// The returned path does not end in a separator unless it is the root directory.
|
2017-11-23 10:21:28 +08:00
|
|
|
func Dir(path string) string {
|
2019-06-19 09:06:52 +08:00
|
|
|
return filepath.Dir(path)
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2019-09-05 19:22:11 +08:00
|
|
|
// IsEmpty checks whether the given <path> is empty.
|
|
|
|
// If <path> is a folder, it checks if there's any file under it.
|
|
|
|
// If <path> is a file, it checks if the file size is zero.
|
2019-09-05 20:00:01 +08:00
|
|
|
//
|
|
|
|
// Note that it returns true if <path> does not exist.
|
2019-09-05 19:22:11 +08:00
|
|
|
func IsEmpty(path string) bool {
|
|
|
|
stat, err := Stat(path)
|
|
|
|
if err != nil {
|
2019-09-05 20:00:01 +08:00
|
|
|
return true
|
2019-09-05 19:22:11 +08:00
|
|
|
}
|
|
|
|
if stat.IsDir() {
|
|
|
|
file, err := os.Open(path)
|
|
|
|
if err != nil {
|
2019-09-05 20:00:01 +08:00
|
|
|
return true
|
2019-09-05 19:22:11 +08:00
|
|
|
}
|
|
|
|
defer file.Close()
|
|
|
|
names, err := file.Readdirnames(-1)
|
|
|
|
if err != nil {
|
2019-09-05 20:00:01 +08:00
|
|
|
return true
|
2019-09-05 19:22:11 +08:00
|
|
|
}
|
|
|
|
return len(names) == 0
|
|
|
|
} else {
|
|
|
|
return stat.Size() == 0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-23 21:58:04 +08:00
|
|
|
// Ext returns the file name extension used by path.
|
|
|
|
// The extension is the suffix beginning at the final dot
|
|
|
|
// in the final element of path; it is empty if there is
|
|
|
|
// no dot.
|
2019-02-15 21:30:35 +08:00
|
|
|
//
|
2019-05-23 21:58:04 +08:00
|
|
|
// Note: the result contains symbol '.'.
|
2017-11-23 10:21:28 +08:00
|
|
|
func Ext(path string) string {
|
2019-09-23 16:21:19 +08:00
|
|
|
ext := filepath.Ext(path)
|
|
|
|
if p := strings.IndexByte(ext, '?'); p != -1 {
|
|
|
|
ext = ext[0:p]
|
|
|
|
}
|
|
|
|
return ext
|
|
|
|
}
|
|
|
|
|
|
|
|
// ExtName is like function Ext, which returns the file name extension used by path,
|
|
|
|
// but the result does not contains symbol '.'.
|
|
|
|
func ExtName(path string) string {
|
|
|
|
return strings.TrimLeft(Ext(path), ".")
|
2017-11-23 10:21:28 +08:00
|
|
|
}
|
|
|
|
|
2020-03-28 00:37:23 +08:00
|
|
|
// TempDir retrieves and returns the temporary directory of current system.
|
|
|
|
// It return "/tmp" is current in *nix system, or else it returns os.TempDir().
|
2020-05-14 20:32:01 +08:00
|
|
|
//
|
2020-03-28 00:37:23 +08:00
|
|
|
// The optional parameter <names> specifies the its sub-folders/sub-files,
|
|
|
|
// which will be joined with current system separator and returned with the path.
|
|
|
|
func TempDir(names ...string) string {
|
|
|
|
path := tempDir
|
|
|
|
for _, name := range names {
|
|
|
|
path += Separator + name
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
2020-03-28 00:37:23 +08:00
|
|
|
return path
|
2019-01-30 21:27:03 +08:00
|
|
|
}
|