转载

编程语言对比手册－纵向版[-文件-]

语言对比手册是我一直想写的一个系列:经过认真思考，我决定从纵向和横行两个方面

来比较Java，Kotlin，Javascript，C++，Python，Dart，六种语言。

纵向版按知识点进行划分，总篇数不定，横向版按语言进行划分，共6篇。其中:

Java基于jdk8
Kotlin基于jdk8
JavaScript基于node11.10.1，使用ES6+
C++基于C++14
Python基于Python 3.7.2
Dart基于Dart2.1.0
复制代码

文件操作是作为每个编程语言必备的模块，本文将看一下六种语言对文件的操作

一、Java版

1.创建文件夹： `G:/Out/language/java/应龙.txt`

/**
  * 创建文件
  *
  * @param path 文件路径
  */
 private static void mkFile(String path) {
     File file = new File(path);//1.创建文件
     if (file.exists()) {//2.判断文件是否存在
         return;
     }
     File parent = file.getParentFile();//3.获取父文件
     if (!parent.exists()) {
         if (!parent.mkdirs()) {//4.创建父文件
             return;
         }
     }
     try {
         file.createNewFile();//5.创建文件
     } catch (IOException e) {
         e.printStackTrace();
     }
 }

|-- 使用
String path = "G:/Out/language/java/应龙.txt";
mkFile(path);
复制代码

2.写入字符文件

/**
 * 字符流插入
 *
 * @param path    路径
 * @param content 内容
 */
private static void writeStr(String path, String content) {
    File file = new File(path);
    FileWriter fw = null;   
    try {
        fw = new FileWriter(file);//创建字符输出流 
        fw.write(content);//写入字符串
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (fw != null) {
                fw.close();//关流
            }
        } catch (IOException e1) {
            e1.printStackTrace();
        }
    }
}

|-- 使用
String path = "G:/Out/language/java/应龙.txt";
String content = "应龙----张风捷特烈/n" +
        "一游小池两岁月，洗却凡世几闲尘。/n" +
        "时逢雷霆风会雨，应乘扶摇化入云。";
writeStr(path, content);
复制代码

3.写入字符文件并制定字符集

/**
 * 使用字符编码写入
 * @param path 路径
 * @param content 内容
 * @param encoding 编码
 */
private static void writeStrEncode(String path, String content, String encoding) {
    OutputStreamWriter osw = null;
    try {
        FileOutputStream fos = new FileOutputStream(path);
        osw = new OutputStreamWriter(fos, encoding);
        osw.write(content);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (osw != null) {
                osw.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

|-- 使用
 String pathGBK = "G:/Out/language/java/应龙-GBK.txt";
 String pathUTF8 = "G:/Out/language/java/应龙-UTF8.txt";
 mkFile(path);
 String content = "应龙----张风捷特烈/n" +
         "一游小池两岁月，洗却凡世几闲尘。/n" +
         "时逢雷霆风会雨，应乘扶摇化入云。";
writeStrEncode(pathGBK, content, "GBK");
writeStrEncode(pathUTF8, content, "UTF-8");
复制代码

4.读取字符文件并制定字符集

/**
 * 读取字符文件
 * @param path 路径
 * @param encoding 编码格式
 * @return 文件字符内容
 */
private static String readStrEncode(String path, String encoding) {
    InputStreamReader isr = null;
    try {
        FileInputStream fis = new FileInputStream(path);
        isr = new InputStreamReader(fis, encoding);
        StringBuilder sb = new StringBuilder();
        int len = 0;
        char[] buf = new char[1024];
        while ((len = isr.read(buf)) != -1) {
            sb.append(new String(buf, 0, len));
        }
       return sb.toString();
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        try {
            if (isr != null) {
                isr.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return null;
}

|-- 使用
String result = readStrEncode(pathUTF8, "UTF-8");
//String result = readStrEncode(pathUTF8, "GBK");
System.out.println(result);
复制代码

5.文件操作

|-- 遍历language文件夹---------------------------------------------
/**
 * 扫描文件夹
 * @param dir 文件夹
 */
private static void scan(String dir) {
    File fileDir = new File(dir);
    File[] files = fileDir.listFiles();
    for (File file : files) {
        System.out.println(file.getAbsolutePath());
        if (file.isDirectory()) {
            scan(file.getAbsolutePath());
        }
    }
}

|-- 重命名-----------------------------------------------------------
String path = "G:/Out/language/java/应龙.txt";
File file = new File(path);
File dest = new File(file.getParent(), "应龙-temp.txt");
file.renameTo(dest);

|-- 获取磁盘空间----------------------------------------------------
long space = dest.getUsableSpace();//获取该磁盘可用大小
System.out.println(space * 1.f / 1024 / 1024 / 1024 + "G");//260.25247G
long freeSpace = dest.getFreeSpace();//同上
System.out.println(freeSpace * 1.f / 1024 / 1024 / 1024 + "G");//260.25247G
long totalSpace = dest.getTotalSpace();//获取该磁盘总大小
System.out.println(totalSpace * 1.f / 1024 / 1024 / 1024 + "G");//316.00098G

|-- 修改日期-----------------------------------------------------
String time = new SimpleDateFormat("yyyy/MM/dd a hh:mm:ss ")
        .format(dest.lastModified());
System.out.println(time);

|--删除文件-----------------------------------------------
dest.delete();//删除文件
复制代码

6.读写权限相关

|-- 写相关
File fileUTF8 = new File(pathUTF8);
fileUTF8.setWritable(false);//不可写
fileUTF8.setWritable(true);//可读
fileUTF8.canWrite();//是否可写--false

|-- 写相关
fileUTF8.canRead();//是否可读--true
fileUTF8.setReadable(false);//不可写读
fileUTF8.setReadable(true);//可读
fileUTF8.setReadOnly();//只读
复制代码

二、Kotlin版

1.创建文件

/**
 * 创建文件
 *
 * @param path 文件路径
 */
private fun mkFile(path: String) {
    val file = File(path)//1.创建文件
    if (file.exists()) {//2.判断文件是否存在
        return
    }
    val parent = file.parentFile//3.获取父文件
    if (!parent.exists()) {
        if (!parent.mkdirs()) {//4.创建父文件
            return
        }
    }
    try {
        file.createNewFile()//5.创建文件
    } catch (e: IOException) {
        e.printStackTrace()
    }
}

|-- 使用
val path = "G:/Out/language/kotlin/应龙.txt"
mkFile(path)
复制代码

2.写入字符文件

挺爽的，简洁明了。当然用java的api也是可以的

val content = "应龙----张风捷特烈/n" +
"一游小池两岁月，洗却凡世几闲尘。/n" +
        "时逢雷霆风会雨，应乘扶摇化入云。";
val file = File(path)
file.writeText(content)
复制代码

3.写入字符文件并制定字符集

Charset默认竟然只有这几个，但看一下源码，可以用 Charset.forName 来创建 Charset

//指定编码写入
 String content = "应龙----张风捷特烈/n" +
         "一游小池两岁月，洗却凡世几闲尘。/n" +
         "时逢雷霆风会雨，应乘扶摇化入云。";
val pathGBK = "G:/Out/language/kotlin/应龙-GBK.txt"
val pathUTF8 = "G:/Out/language/kotlin/应龙-UTF8.txt"

val gbk = Charset.forName("GBK")//创建Charset
File(pathGBK).writeText(content, gbk)
File(pathUTF8).writeText(content, Charsets.UTF_8)
复制代码

4.读取字符文件并制定字符集

感觉蛮爽的，各种花式玩法

|------ 一次读完
val pathUTF8 = "G:/Out/language/kotlin/应龙-UTF8.txt"
val result = File(pathUTF8).readText(Charsets.UTF_8)
//val result = File(pathUTF8).readText(Charset.forName("GBK"))
println(result)

//|--------按行读取
File(pathUTF8).forEachLine {
    println(it)
}

//|--------读取几行
File(pathUTF8).readLines().take(2).forEach{
    println(it)
}

//|------File直接各种开流，注意它们的类型
val fileUTF8 = File(pathUTF8)
val isr = fileUTF8.reader(Charsets.UTF_8)//InputStreamReader
val osw = fileUTF8.writer(Charsets.UTF_8)//OutputStreamWriter
val fis = fileUTF8.inputStream()//FileInputStream
val fos = fileUTF8.outputStream()//FileOutputStream
val br = fileUTF8.bufferedReader(Charsets.UTF_8)//BufferedReader
val bw = fileUTF8.bufferedWriter(Charsets.UTF_8)//BufferedWriter
val pw = fileUTF8.printWriter(Charsets.UTF_8)//PrintWriter
复制代码

5.文件操作

|-- 遍历language文件夹---------------------------------------------
val dir = "G:/Out/language";
File(dir).walk().maxDepth(2)//深度
        .filter {it.absolutePath.contains("kotlin")}//过滤
        .forEach { println(it.absolutePath)//操作
}

|-- 重命名-----------------------------------------------------------
val file = File(path)
val dest = File(file.parent, "应龙-temp.txt")
file.renameTo(dest)

|-- 获取磁盘空间----------------------------------------------------
val space = dest.usableSpace//获取该磁盘可用大小
println((space * 1f / 1024f / 1024f / 1024f).toString() + "G")//260.25247G
val freeSpace = dest.freeSpace//同上
println((freeSpace * 1f / 1024f / 1024f / 1024f).toString() + "G")//260.25247G
val totalSpace = dest.totalSpace//获取该磁盘总大小
println((totalSpace * 1f / 1024f / 1024f / 1024f).toString() + "G")//316.00098G

|-- 修改日期-----------------------------------------------------
val time = SimpleDateFormat("yyyy/MM/dd a hh:mm:ss ")
        .format(dest.lastModified())
println(time)

|--删除文件-----------------------------------------------
dest.delete();//删除文件
复制代码

6.读写权限相关

|-- 写相关
val fileUTF8 = File(pathUTF8)
fileUTF8.setWritable(false)//不可写
fileUTF8.setWritable(true)//可读
fileUTF8.canWrite()//是否可写--false

|-- 写相关
fileUTF8.canRead();//是否可读--true
fileUTF8.setReadable(false);//不可写读
fileUTF8.setReadable(true);//可读
fileUTF8.setReadOnly();//只读
复制代码

三、JavaScript版

1.创建文件

|-- 创建文件夹--------------------------------------
|-- {recursive: true}表示可递归创建
const fs = require("fs");
let path = "G:/Out/language/javascript";
fs.mkdir(path, {recursive: true}, function (err) {
    if (err) {
        console.log(err);
    }
    console.log("创建ok");
});

|-- 创建文件--------------------------------------
fs.writeFile(path + "/应龙.txt", "", (err) => {
    if (err) throw err;
    console.log('文件创建完成');
});
复制代码

2.写入字符文件

writeFile的同步异步

let content = "应龙----张风捷特烈/n" +
    "一游小池两岁月，洗却凡世几闲尘。/n" +
    "时逢雷霆风会雨，应乘扶摇化入云。";
    
|--- 异步写入
fs.writeFile(path + "/应龙.txt", content, (err) => {
    if (err) throw err;
    console.log('文件已保存');
})

|--- 同步写入
fs.writeFileSync(path + "/应龙.txt","writeFileSync");
复制代码

3.写入字符文件并制定字符集

默认node不支持GBK...,可通过：第三方模块iconv-lite来转换编码

//指定编码写入
 String content = "应龙----张风捷特烈/n" +
         "一游小池两岁月，洗却凡世几闲尘。/n" +
         "时逢雷霆风会雨，应乘扶摇化入云。";
         
fs.writeFile(path + "/应龙-UTF8.txt", content, {encoding: 'utf8'}, (err) => {
    if (err) throw err;
    console.log('文件已保存');
});
复制代码

4.读取字符文件并制定字符集

|--- 异步读取
fs.readFile(path + "/应龙.txt", (err, data) => {
    if (err) throw err;
    console.log(data.toString());
});

|--- 同步读取
let data = fs.readFileSync(path + "/应龙.txt").toString();
console.log(data);

|--- open方法+read(文件描述符,缓冲区,缓冲区偏移量,字节数，起始位置，回调函数)+close
let buf = new Buffer.alloc(1024);
fs.open(pathDir + "/应龙-temp.txt", "r+", (err, fd) => {
    if (err) throw err;
    fs.read(fd, buf, 0, buf.length, 0, (err, bytes, buffer) => {
        console.log(bytes);//字节长度
        console.log(buffer.toString());//数据
        fs.close(fd, function (err) {// 关闭文件
            if (err) throw err;
            console.log("文件关闭成功");
        });
    })
});
复制代码

5.文件操作

|-- 文件状态--异步---------------------------------------------
fs.stat(path + "/应龙.txt", function (err, stats) {
    if (err) {
        return console.error(err);
    }
    console.log(stats);
    //Stats {
    //   dev: 3540543445,
    //   mode: 33206,
    //   nlink: 1,
    //   uid: 0,
    //   gid: 0,
    //   rdev: 0,
    //   blksize: undefined,
    //   ino: 1688849860264802,
    //   size: 123,
    //   blocks: undefined,
    //   atimeMs: 1551622765220.3064,
    //   mtimeMs: 1551624397905.7507,
    //   ctimeMs: 1551624397905.7507,
    //   birthtimeMs: 1551622765220.3064,
    //   atime: 2019-03-03T14:19:25.220Z,
    //   mtime: 2019-03-03T14:46:37.906Z,
    //   ctime: 2019-03-03T14:46:37.906Z,
    //   birthtime: 2019-03-03T14:19:25.220Z }
});

|-- 文件状态--同步---------------------------------------------
let stat = fs.statSync(path + "/应龙.txt");
console.log(stat);


|-- 遍历language文件夹---------------------------------------------
fileList("G:/Out/language",file=>{
    console.log(file);
});
/**
 * 文件遍历方法
 * @param filePath 需要遍历的文件路径
 */
function fileList(filePath,cbk) {
    fs.readdir(filePath, (err, files) => {//读取当前文件夹
            if (err) throw err;
            files.forEach(filename => {//遍历文件列表
                let file = path.join(filePath, filename);//文件路径拼合
                fs.stat(file, function (eror, stats) {//获取fs.Stats对象
                    if (err) throw err;
                    let isFile = stats.isFile();//是文件
                    let isDir = stats.isDirectory();//是文件夹
                    if (isFile) {
                        cbk(file);
                    }
                    if (isDir) {
                        fileList(file,cbk);//递归，如果是文件夹，就继续遍历该文件夹下面的文件
                    }
                })
            });
        }
    )
}

|-- 重命名-----------------------------------------------------------
fs.rename('G:/Out/language/javascript/应龙.txt', 'G:/Out/language/javascript/应龙-temp.txt', (err) => {
    if (err) throw err;
    console.log('重命名完成');
});

|--删除文件-----------------------------------------------
fs.unlink('G:/Out/language/javascript/应龙-temp.txt', (err) => {
    if (err) throw err;
    console.log('删除完成');
});
复制代码

6.读写权限相关

函数的options 参数的 flag 字段是控制读写权限的，下面的当做常识，了解一下

方法很多，就不一一说了，比较生疏的，需要的时候还是看看API，还是很有必要的

'a' - 打开文件用于追加。如果文件不存在，则创建该文件。
'ax' - 与 'a' 相似，但如果路径存在则失败。
'a+' - 打开文件用于读取和追加。如果文件不存在，则创建该文件。
'ax+' - 与 'a+' 相似，但如果路径存在则失败。
'as' - 以同步模式打开文件用于追加。如果文件不存在，则创建该文件。
'as+' - 以同步模式打开文件用于读取和追加。如果文件不存在，则创建该文件。

'r' - 打开文件用于读取。如果文件不存在，则会发生异常。
'r+' - 打开文件用于读取和写入。如果文件不存在，则会发生异常。
'rs' - 以同步的方式读取文件。
'rs+' - 以同步模式打开文件用于读取和写入。指示操作系统绕开本地文件系统缓存。

'w' - 打开文件用于写入。如果文件不存在则创建文件，如果文件存在则截断文件。
'wx' - 与 'w' 相似，但如果路径存在则失败。
'w+' - 打开文件用于读取和写入。如果文件不存在则创建文件，如果文件存在则截断文件。
'wx+' - 与 'w+' 相似，但如果路径存在则失败。
复制代码

四、C++版

1.创建文件：

|-- 创建文件夹--------------------------------------
#include <direct.h>
/**
 * 创建多级目录
 * @param pDirPath  文件夹路径
 * @return 
 */
int mkDirs(char *pDirPath) {
    int i = 0;
    int iRet;
    int iLen;
    char *pszDir;
    if (nullptr == pDirPath) {
        return 0;
    }
    pszDir = strdup(pDirPath);
    iLen = static_cast<int>(strlen(pszDir));
    // 创建中间目录
    for (i = 0; i < iLen; i++) {
        if (pszDir[i] == '//' || pszDir[i] == '/') {
            pszDir[i] = '/0';
            iRet = _access(pszDir, 0);//如果不存在,创建
            if (iRet != 0) {
                iRet = _mkdir(pszDir);
                if (iRet != 0) {
                    return -1;
                }
            }
            pszDir[i] = '/';
        }
    }
    iRet = _mkdir(pszDir);
    free(pszDir);
    return iRet;
}

|-- 创建文件--------------------------------------
#include <fstream>
ofstream file("G:/Out/language/c++/dragon.txt");
复制代码

2.写入字符文件

char *content = "应龙----张风捷特烈/n 一游小池两岁月，洗却凡世几闲尘。/n 时逢雷霆风会雨，应乘扶摇化入云。";
ofstream file("G:/Out/language/c++/dragon.txt");
if (file.is_open()) {
    file << content;
    file.close();
}
复制代码

3.写入字符文件并制定字符集

目前本人关于C++的知识有限，关于字符集相关的可见：此篇：

暂略

4.读取字符文件

ifstream file("G:/Out/language/c++/dragon.txt");
char buffer[1024];
while (!file.eof()) {
    file.getline(buffer, 100);
    cout << buffer << endl;
}
复制代码

5.文件操作

遍历文件夹部分参考文章

|-- 遍历language文件夹---------------------------------------------
/**
 * 遍历文件夹
 * @param dir 
 */
void scan(const char *dir) {
    intptr_t handle;
    _finddata_t findData;
    handle = _findfirst(dir, &findData);    // 查找目录中的第一个文件
    if (handle == -1) {
        cout << "Failed to find first file!/n";
        return;
    }
    do {
        if (findData.attrib & _A_SUBDIR
            && !(strcmp(findData.name, ".") == 0
                 || strcmp(findData.name, "..") == 0
        )) {    // 是否是子目录并且不为"."或".."
            cout << findData.name << "/t<dir>-----------------------/n";
            string subdir(dir);
            subdir.insert(subdir.find("*"), string(findData.name) + "//");
            cout << subdir << endl;
            scan(subdir.c_str());//递归遍历子文件夹
        } else {
            for (int i = 0; i < 4; ++i)
                cout << "-";
            cout << findData.name << "/t" << findData.size << endl;
        }
    } while (_findnext(handle, &findData) == 0);// 查找目录中的下一个文件
    _findclose(handle); // 关闭搜索句柄
}

|-- 使用
string inPath = "G:/Out/language/*";//遍历文件夹下的所有文件
scan(inPath.c_str());

|-- 重命名-----------------------------------------------------------
string path = "G:/Out/language/c++/dragon.txt";
string dest = "G:/Out/language/c++/dragon-temp.txt";
rename(path.c_str(), dest.c_str());

|--删除文件-----------------------------------------------
if (!_access(dest.c_str(), 0)) {
    SetFileAttributes(dest.c_str(), 0);////去掉文件只读属性
    if (DeleteFile(dest.c_str())) {
        cout << dest.c_str() << " 已成功删除." << endl;
    } else {
        cout << dest.c_str() << " 无法删除:" << endl;
    }
} else {
    cout << dest.c_str() << " 不存在,无法删除." << endl;
}
复制代码

6.读写权限相关

暂略

五、Python版

1.创建文件：

|-- 创建文件--------------------------------------
#创建文件 支持多级目录下文件
def create(name):
    parent = os.path.dirname(name)
    if not os.path.exists(parent):
        os.makedirs(parent)  # 创建父文件夹
    if not os.path.exists(name):  # 如果文件不存在
        f = open(name, 'w')
        f.close()
        print(name + " created.")
    else:
        print(name + " already existed.")
    return
    
|-- 使用
filePath = "G:/Out/language/python/6/7/4/5/6/应龙.txt"
create(filePath)
复制代码

2.写入字符文件

content = """应龙----张风捷特烈
一游小池两岁月，洗却凡世几闲尘。
时逢雷霆风会雨，应乘扶摇化入云。"""
    f = open(filePath, "w", encoding="utf-8")  # 只读方式打开：w。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
    f.write(content)
    # f.flush()  # 需调用，刷新缓冲区 或关闭
    f.close()
    
    
复制代码

3.写入字符文件并制定字符集

filePathGBK = "G:/Out/language/python/6/7/4/5/6/应龙-GBK.txt"
content = """应龙----张风捷特烈
一游小池两岁月，洗却凡世几闲尘。
时逢雷霆风会雨，应乘扶摇化入云。"""

f = open(filePathGBK, "w", encoding="gbk") 
f.write(content)
# f.flush()  # 需调用，刷新缓冲区 或关闭
f.close()
复制代码

4.读取字符文件并制定字符集

|--- 一段一段读
 f = open(filePath, encoding="utf-8")  # 默认只读方式打开：r
 print(f.readline())  # 应龙----张风捷特烈
 print(f.readline(5))  # 一游小池两
 print(f.readline(5))  # 岁月，洗却
 print(f.read(4))  # 凡世几闲

|--- 返回所有行的列表
f = open(filePath, encoding="utf-8")  # 默认只读方式打开：r
readlines = f.readlines() #<class 'list'>
print(readlines[0])  # 应龙----张风捷特烈
print(readlines[1])  # 一游小池两岁月，洗却凡世几闲尘。
print(readlines[2])  # 时逢雷霆风会雨，应乘扶摇化入云。

|--- 迭代遍历
f = open(filePath, encoding="utf-8")
for line in iter(f):  # 迭代遍历
    print(line)
复制代码

5.文件操作

|-- 文件信息---------------------------------------------
f1 = open(filePath)
print(f1.fileno())  # 4 文件描述符
print(f1.mode)  # r 文件打开模式
print(f1.closed)  # False 文件是否关闭
print(f1.encoding)  # cp936 文件编码
print(f1.name)  # G:/Out/language/python/6/7/4/5/6/应龙.txt 文件名称
f1.close()

print(os.path.exists(filePath))  # True 是否存在
print(os.path.isdir(filePath))  # False 是否是文件夹
print(os.path.isfile(filePath))  # True 是否是文件
print(os.path.getsize(filePath))  # 125 文件大小
print(os.path.basename(filePath))  # 应龙.txt
print(os.path.dirname(filePath))  # G:/Out/language/python/6/7/4/5/6

print(os.stat(filePath))
#os.stat_result(
# st_mode=33206,
# st_ino=2533274790397459,
#  st_dev=3540543445,
# st_nlink=1,
# st_uid=0,
# st_gid=0,
# st_size=133,
# st_atime=1551668005,
# st_mtime=1551668005,
# st_ctime=1551667969)

|-- 文件状态--同步---------------------------------------------
let stat = fs.statSync(path + "/应龙.txt");
console.log(stat);


|-- 遍历language文件夹---------------------------------------------
# 扫描文件加下所有文件
def scan(dir):
    if os.path.exists(dir):
        lists = os.listdir(dir)
        for i in range(0,len(lists)):
            sonPath = os.path.join(dir, lists[i])
            print(sonPath)
            if os.path.isdir(sonPath):
                scan(sonPath)
|--使用
scan("G:/Out/language")

|-- 重命名-----------------------------------------------------------
filePath = "G:/Out/language/python/6/7/4/5/6/应龙.txt"
destPath = "G:/Out/language/python/6/7/4/5/6/应龙-temp.txt"
os.rename(filePath,destPath)

|--删除文件-----------------------------------------------
os.remove(destPath)
复制代码

6.读写权限相关

# 文件打开方式
# r: 只读          --文件的指针将会放在文件的开头。这是默认模式。
# rb:二进制只读。   --文件指针将会放在文件的开头。这是默认模式。
# r+:读写。        --文件指针将会放在文件的开头。
# rb+:二进制读写。  --文件指针将会放在文件的开头。

# w: 只写          --如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件
# wb:二进制只读。   --如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件
# w+:读写。        --如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件
# wb+:二进制读写。  --如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件

# a: 追加。        --如果该文件已存在，文件指针将会放在文件的结尾。新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
# ab:二进制追加。
# a+:追加读写。
# ab+:二进制追加读写。

 print(os.access(filePath, os.F_OK))  # True 是否存在
 print(os.access(filePath, os.R_OK))  # True 读权限
 print(os.access(filePath, os.W_OK))  # True 写权限
 print(os.access(filePath, os.X_OK))  # True 执行权限
复制代码

六、Dart版

1.创建文件

|-- 异步创建文件 --------------------------------------
 File(filePath).create(recursive: true).then((file) {
   print("创建完成");
 });
 
|-- 异步创建文件 --------------------------------------
void create(String filePath) async {
  var file = File(filePath);
  if (await file.exists()) {
    return;
  }
  await file.create(recursive: true);
  print("创建完成");
}

|-- 同步创建
File(filePath).createSync(recursive: true);

|-- 使用
filePath = "G:/Out/language/python/6/7/4/5/6/应龙.txt"

复制代码

2.写入字符文件

就演示一下异步的，同步的要简单些，直接用就行了

const content = "应龙----张风捷特烈/n" + "一游小池两岁月，洗却凡世几闲尘。/n" + "时逢雷霆风会雨，应乘扶摇化入云。";
File(filePath).writeAsString(content).then((file) {
  print("写入成功!");
});
复制代码

3.写入字符文件并制定字符集

瞟了一下源码，貌似木有gbk

//指定编码写入
 String content = "应龙----张风捷特烈/n" +
         "一游小池两岁月，洗却凡世几闲尘。/n" +
         "时逢雷霆风会雨，应乘扶摇化入云。";
val pathISO8859 = "G:/Out/language/kotlin/应龙-ISO8859.txt"

File(pathISO8859)
    .writeAsString("Hello Dart", encoding: Encoding.getByName("iso_8859-1:1987"))
    .then((file) {
  print("写入成功!");
});
复制代码

4.读取字符文件并制定字符集

File(pathGBK)
    .readAsString(encoding: Encoding.getByName("iso_8859-1:1987"))
    .then((str) {
  print(str);
});
复制代码

5.文件操作

|-- 信息
file.exists();//是否存在
file.length(); //文件大小(字节)
file.lastModified(); //最后修改时间
file.parent.path; //获取父文件夹的路径


|-- 遍历language文件夹---------------------------------------------
 var dir = Directory(r"G:/Out/language");//递归列出所有文件
 var list = dir.list(recursive: true);
 list.forEach((fs){
   print(fs.path);
 });

|-- 重命名-----------------------------------------------------------
var srcPath = r"G:/Out/language/dart/6/7/4/5/6/应龙.txt";
var destPath = r"G:/Out/language/dart/6/7/4/5/6/应龙-temp.txt";
File(srcPath).rename(destPath);

|--删除文件-----------------------------------------------
File(destPath).delete();
复制代码

关于各语言认识深浅不一，如有错误，欢迎批评指正。