精华内容
下载资源
问答
  • VBA 读写文本文件

    千次阅读 2019-05-11 16:34:13
    直接采用Open函数+Line input命令 Private Sub txt_read() Dim txt As String Open "D:\dzh.txt" For ... '对文件做任何 I/O 操作之前都必须先打开文件。Open 语句分配一个缓冲区供文件进行 I/O 之用, ...

    直接采用Open函数+Line input命令

      Private Sub txt_read()
               Dim txt As String
                Open "D:\dzh.txt" For Input As #1 '
                '对文件做任何 I/O 操作之前都必须先打开文件。Open 语句分配一个缓冲区供文件进行 I/O 之用,
                '并决定缓冲区所使用的访问方式。
                '打开文件作为数据输入用,文件号为#1
                Do While Not EOF(1)
                    Line Input #1, txt  '从已打开的顺序文件中读出一行并将它分配给 String 变量
                    'Line Input # 语句一次只从文件中读出一个字符,直到遇到回车符 (Chr(13))
                    '或回车–换行符 (Chr(13) + Chr(10)) 为止。回车–换行符将被跳过,而不会被附加到字符串上
                    MsgBox txt
                Loop
                Close #1
        End Sub
        -----------------------------------------------------------------------------------------------
    1、Open 语句 
    打开方式有 
    Input:以读取方式打开。
    Output:以写入方式打开。
    Append:以追加方式,即添加内容到文件末尾打开。
    Binary:以二进制方式打开。
    Random:以随机方式打开,如果未指定方式,则以 Random 方式打开文件。
     Open pathname For mode As [#]filenumber
     Open "c:\a.txt" For Output As #1
    filenumber  是一个有效的文件号,范围在 1 到 511 之间。
    如果 pathname 指定的文件不存在,那么,在用 Append、Binary、Output、或 Random 方式打开文件时,可以建立这一文件。 
    2、Close 语句 
    语法:Close [filenumberlist]
         filenumberlist 参数为一个或多个文件号,若省略 filenumberlist,则将关闭 Open 语句打开的所有活动文件。 
    说明:打开文件后,必须在使用完后关闭文件。
     
    3、EOF 函数 
    语法:EOF(filenumber) 
    功能:返回一个 Integer,它包含 Boolean 值 True,表明已经到达为 Random 或顺序 Input 打开的文件的结尾。
    Open "c:\a.txt"  For Input As #1 ‘以读入方式打开c:\a.txt
    Do While Not EOF(1)  '未到达结尾
              Line Input #1, s1     '读入一行,放入s1变量中
            Loop
            Close #1 
    
    展开全文
  • java使用nio读写文件

    千次阅读 2019-11-16 15:49:45
    IO原理 最近在研究 JAVA NIO 的相关知识,学习NIO...虚拟存储器是硬件异常(缺页异常)、硬件地址翻译、主存、磁盘文件和内核软件的完美交互,它为每个进程提供了一个大的、一致的和私有的地址空间。 虚拟存储器的三大...

    IO原理

    最近在研究 JAVA NIO 的相关知识,学习NIO,就不能提到IO的原理和事项,必经NIO是基于IO进化而来

    IO涉及到的底层的概念大致如下:

    1. 缓冲区操作。2) 内核空间与用户空间。3) 虚拟内存。4) 分页技术

    一,虚拟存储器
    虚拟存储器是硬件异常(缺页异常)、硬件地址翻译、主存、磁盘文件和内核软件的完美交互,它为每个进程提供了一个大的、一致的和私有的地址空间。

    虚拟存储器的三大能力:

    ①将主存看成是一个存储在磁盘上的地址空间的高速缓存。
    ②为每个进程提供了一个一致的地址空间。
    ③保护每个进程的地址空间不被其他进程破坏。

    虚拟内存的两大好处:
    ① 一个以上的虚拟地址可指向同一个物理内存地址。
    ② 虚拟内存空间可大于实际可用的硬件内存。

    二,用户空间与内核空间
    设虚拟地址为32位,那么虚拟地址空间的范围为0~4G。操作系统将这4G分为二部分,将最高的1G字节(虚拟地址范围为:0xC0000000-0xFFFFFFFF)供内核使用,称为内核空间。而将较低的3G字节供各个进程使用,称为用户空间。
    每个进程可以通过系统调用进入内核,因为内核是由所有的进程共享的。对于每一个具体的进程,它看到的都是4G大小的虚拟地址空间,即相当于每个进程都拥有一个4G大小的虚拟地址空间。

    三,IO操作

    一般IO缓冲区操作:

    1. 用户进程使用read()系统调用,要求其用户空间的缓冲区被填满。
    2. 内核向磁盘控制器硬件发命令,要求从磁盘读入数据。
    3. 磁盘控制器以DMA方式(数据不经过CPU)把数据复制到内核缓冲区。
    4. 内核将数据从内核缓冲区复制到用户进程发起read()调用时指定的用户缓冲区。

    在这里插入图片描述

    从上图可以看出:磁盘中的数据是先读取到内核的缓冲区中。然后再从内核的缓冲区复制到用户的缓冲区。为什么会这样呢?

    因为用户空间的进程是不能直接硬件的(操作磁盘控制器)。磁盘是基于块存储的硬件设备,它一次操作固定大小的块,而用户请求请求的可能是任意大小的数据块。因此,将数据从磁盘传递到用户空间,由内核负责数据的分解、再组合。

    内存映射IO:就是复用一个以上的虚拟地址可以指向同一个物理内存地址。将内核空间的缓冲区地址(内核地址空间)映射到物理内存地址区域,将用户空间的缓冲区地址(用户地址空间)也映射到相同的物理内存地址区域。从而数据不需要从内核缓冲区映射的物理内存地址移动到用户缓冲区映射的物理内存地址了。从链路上看,这样的方式明显比上述的IO操作方式要短了,节省出来的路程,就是NIO操作的优势所在

    要求:①用户缓冲区与内核缓冲区必须使用相同的页大小对齐。
    ②缓冲区的大小必须是磁盘控制器块大小(512字节磁盘扇区)的倍数—因为磁盘是基于块存储的硬件设备,一次只能操作固定大小的数据块。

    用户缓冲区按页对齐,会提高IO的效率—这也是为什么在JAVA中new 一个字节数组时,指定的大小为2的倍数(4096)的原因吧。

    在这里插入图片描述

    四,JAVA中的IO,本质上是把数据移进或者移出缓冲区。

    read()和write()系统调用完成的作用是:把内核缓冲区映射的物理内存空间中的数据 拷贝到 用户缓冲区映射的物理内存空间中。

    因此,当使用内存映射IO时,可视为:用户进程直接把文件数据当作内存,也就不需要使用read()或write()系统调用了。

    当发起一个read()系统调用时,根据待读取的数据的位置生成一个虚拟地址(用户进程使用的是虚拟地址),由MMU转换成物理地址,若内核中没有相应的数据,产生一个缺页请求,内核负责页面调入从而将数据从磁盘读取到内核缓冲区映射的物理内存中。对用户程序而言,这一切都是在不知不觉中进行。

    总之,从根本上讲数据从磁盘装入内存是以页为单位通过分页技术装入内存的。

    五,JAVA NIO中的直接缓存和非直接缓存

    直接缓存:不是分配于堆上的存储,位于JVM之外,它不受JAVA的GC管理,相当于内核缓冲区。非直接缓存:建立在JAVA堆上的缓存,受JVM管理,相当于用户缓冲区。

    根据上面第三点,将直接缓存中的数据写入通道的速度要快于非直接缓存。因为,连接到通道的另一端是文件(磁盘,FileChannel)或者网络(Socket通道),这些都是某种形式上的硬件。那么,对于非直接缓存而言,数据从缓冲区传递到硬件,要经过内核缓冲区中转。而对于直接缓存而言,就不需要了,因为直接缓存已经直接映射到内核缓冲区了。

    了解了上述的基本概念后,下面我们分别使用传统的IO方式和NIO方式实现一个文件拷贝的功能,简单对比一下

    IO方式实现文件拷贝:

    	//IO方法实现文件k拷贝
        private static void traditionalCopy(String sourcePath, String destPath) throws Exception {
            File source = new File(sourcePath);
            File dest = new File(destPath);
            if (!dest.exists()) {
                dest.createNewFile();
            }
            FileInputStream fis = new FileInputStream(source);
            FileOutputStream fos = new FileOutputStream(dest);
            byte[] buf = new byte[1024];
            int len = 0;
            while ((len = fis.read(buf)) != -1) {
                fos.write(buf, 0, len);
            }
            fis.close();
            fos.close();
        }
    

    然后我们来测试一下一个比较大的文件拷贝,看看性能如何

    public static void main(String[] args) throws Exception{
            long start = System.currentTimeMillis();
            traditionalCopy("D:\\常用软件\\JDK1.8\\jdk-8u181-linux-x64.tar.gz", "D:\\常用软件\\JDK1.8\\IO.tar.gz");
            long end = System.currentTimeMillis();
            System.out.println("用时为:" + (end-start));
        }
    

    在这里插入图片描述

    在这里插入图片描述

    180M的文件,这个速度也还不算太差,下面我们再尝试使用NIO的方式试一下,提供两种方式的拷贝,

    public void nioCpoy(String source, String target, int allocate) throws IOException{
            ByteBuffer byteBuffer = ByteBuffer.allocate(allocate);
            FileInputStream inputStream = new FileInputStream(source);
            FileChannel inChannel = inputStream.getChannel();
    
            FileOutputStream outputStream = new FileOutputStream(target);
            FileChannel outChannel = outputStream.getChannel();
    
            int length = inChannel.read(byteBuffer);
            while(length != -1){
                byteBuffer.flip();//读取模式转换写入模式
                outChannel.write(byteBuffer);
                byteBuffer.clear(); //清空缓存,等待下次写入
                // 再次读取文本内容
                length = inChannel.read(byteBuffer);
            }
            outputStream.close();
            outChannel.close();
            inputStream.close();
            inChannel.close();
        }
    
    public static void fileChannelCopy(String sfPath, String tfPath) {
    
            File sf = new File(sfPath);
            File tf = new File(tfPath);
            FileInputStream fi = null;
            FileOutputStream fo = null;
            FileChannel in = null;
            FileChannel out = null;
            try{
                fi = new FileInputStream(sf);
                fo = new FileOutputStream(tf);
                in = fi.getChannel();//得到对应的文件通道
                out = fo.getChannel();//得到对应的文件通道
                in.transferTo(0, in.size(), out);//连接两个通道,并且从in通道读取,然后写入out通道
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                try{
                    fi.close();
                    in.close();
                    fo.close();
                    out.close();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    

    测试一下性能如何,运行一下下面的代码,

    public static void main(String[] args) {
            long start = System.currentTimeMillis();
            String sPath = "D:\\常用软件\\JDK1.8\\jdk-8u181-linux-x64.tar.gz";
            String tPath = "D:\\常用软件\\JDK1.8\\NIO.tar.gz";
            fileChannelCopy(sPath,tPath);
            long end = System.currentTimeMillis();
            System.out.println("用时为:" + (end-start));
        }
    

    在这里插入图片描述
    在这里插入图片描述

    这个效率通过简单的对比可以说明问题了,NIO在操作大文件读写时,性能优势就体现出来了,下面附上通过NIO操作文件读写的几个方法,后面做参考使用

    /**
     * NIO读写文件工具类
     */
    public class NIOFileUtil {
    
        private String file;
    
        public String getFile() {
            return file;
        }
    
        public void setFile(String file) {
            this.file = file;
        }
    
        public NIOFileUtil(String file) throws IOException {
            super();
            this.file = file;
        }
    
        /**
         * NIO读取文件
         * @param allocate
         * @throws IOException
         */
        public void read(int allocate) throws IOException {
    
            RandomAccessFile access = new RandomAccessFile(this.file, "r");
    
            //FileInputStream inputStream = new FileInputStream(this.file);
            FileChannel channel = access.getChannel();
            ByteBuffer byteBuffer = ByteBuffer.allocate(allocate);
    
            CharBuffer charBuffer = CharBuffer.allocate(allocate);
            Charset charset = Charset.forName("GBK");
            CharsetDecoder decoder = charset.newDecoder();
            int length = channel.read(byteBuffer);
            while (length != -1) {
                byteBuffer.flip();
                decoder.decode(byteBuffer, charBuffer, true);
                charBuffer.flip();
                System.out.println(charBuffer.toString());
                // 清空缓存
                byteBuffer.clear();
                charBuffer.clear();
                // 再次读取文本内容
                length = channel.read(byteBuffer);
            }
            channel.close();
            if (access != null) {
                access.close();
            }
        }
    
        /**
         * NIO写文件
         * @param context
         * @param allocate
         * @param chartName
         * @throws IOException
         */
        public void write(String context, int allocate, String chartName) throws IOException{
            // FileOutputStream outputStream = new FileOutputStream(this.file); //文件内容覆盖模式 --不推荐
            FileOutputStream outputStream = new FileOutputStream(this.file, true); //文件内容追加模式--推荐
            FileChannel channel = outputStream.getChannel();
            ByteBuffer byteBuffer = ByteBuffer.allocate(allocate);
            byteBuffer.put(context.getBytes(chartName));
            byteBuffer.flip();//读取模式转换为写入模式
            channel.write(byteBuffer);
            channel.close();
            if(outputStream != null){
                outputStream.close();
            }
        }
    
        /**
         * nio事实现文件拷贝
         * @param source
         * @param target
         * @param allocate
         * @throws IOException
         */
        public static void nioCpoy(String source, String target, int allocate) throws IOException{
            ByteBuffer byteBuffer = ByteBuffer.allocate(allocate);
            FileInputStream inputStream = new FileInputStream(source);
            FileChannel inChannel = inputStream.getChannel();
    
            FileOutputStream outputStream = new FileOutputStream(target);
            FileChannel outChannel = outputStream.getChannel();
    
            int length = inChannel.read(byteBuffer);
            while(length != -1){
                byteBuffer.flip();//读取模式转换写入模式
                outChannel.write(byteBuffer);
                byteBuffer.clear(); //清空缓存,等待下次写入
                // 再次读取文本内容
                length = inChannel.read(byteBuffer);
            }
            outputStream.close();
            outChannel.close();
            inputStream.close();
            inChannel.close();
        }
    
        //IO方法实现文件k拷贝
        private static void traditionalCopy(String sourcePath, String destPath) throws Exception {
            File source = new File(sourcePath);
            File dest = new File(destPath);
            if (!dest.exists()) {
                dest.createNewFile();
            }
            FileInputStream fis = new FileInputStream(source);
            FileOutputStream fos = new FileOutputStream(dest);
            byte[] buf = new byte[1024];
            int len = 0;
            while ((len = fis.read(buf)) != -1) {
                fos.write(buf, 0, len);
            }
            fis.close();
            fos.close();
        }
    
        public static void main(String[] args) throws Exception{
            /*long start = System.currentTimeMillis();
            traditionalCopy("D:\\常用软件\\JDK1.8\\jdk-8u181-linux-x64.tar.gz", "D:\\常用软件\\JDK1.8\\IO.tar.gz");
            long end = System.currentTimeMillis();
            System.out.println("用时为:" + (end-start));*/
    
            long start = System.currentTimeMillis();
            nioCpoy("D:\\常用软件\\JDK1.8\\jdk-8u181-linux-x64.tar.gz", "D:\\常用软件\\JDK1.8\\NIO.tar.gz",1024);
            long end = System.currentTimeMillis();
            System.out.println("用时为:" + (end-start));
        }
    
    }
    

    NIO在读写文件上体现出来的性能优势得益于其自身的结构设计,最重要的还是本文开头所讲的关于操作链路上的结构优化设计,掌握这一点原理基本就理解了NIO的实质,本篇到这里就结束了,最后感谢观看!

    展开全文
  • Linux内核中读写文件

    千次阅读 2016-07-11 14:13:56
    Linux内核中读写文件数据的方法     有时候需要在Linuxkernel--大多是在需要调试的驱动程序--中读写文件数据。在kernel中操作文件没有标准库可用,需要利用kernel的一些函数,这些函数主要有: filp_open() ...

    Linux内核中读写文件数据的方法
     
     
    有时候需要在Linuxkernel--大多是在需要调试的驱动程序--中读写文件数据。在kernel中操作文件没有标准库可用,需要利用kernel的一些函数,这些函数主要有: filp_open() filp_close(), vfs_read()vfs_write(),set_fs(),get_fs()等,这些函数在linux/fs.h和asm/uaccess.h头文件中声明。下面介绍主要步骤:


    1. 打开文件


    filp_open()在kernel中可以打开文件,其原形如下:

    strcut file* filp_open(const char* filename, int open_mode, int mode);

    该函数返回strcut file*结构指针,供后继函数操作使用,该返回值用IS_ERR()来检验其有效性。

    参数说明

    filename: 表明要打开或创建文件的名称(包括路径部分)。在内核中打开的文件时需要注意打开的时机,很容易出现需要打开文件的驱动很早就加载并打开文件,但需要打开的文件所在设备还不有挂载到文件系统中,而导致打开失败。

    open_mode: 文件的打开方式,其取值与标准库中的open相应参数类似,可以取O_CREAT,O_RDWR,O_RDONLY等。

    mode:  创建文件时使用,设置创建文件的读写权限,其它情况可以匆略设为0

     

    2. 读写文件

     

    kernel中文件的读写操作可以使用vfs_read()和vfs_write,在使用这两个函数前需要说明一下get_fs()和 set_fs()这两个函数。

    vfs_read() vfs_write()两函数的原形如下:

    ssize_t vfs_read(struct file* filp, char __user* buffer, size_t len, loff_t* pos);

    ssize_t vfs_write(struct file* filp, const char __user* buffer, size_t len, loff_t* pos);

    注意这两个函数的第二个参数buffer,前面都有__user修饰符,这就要求这两个buffer指针都应该指向用空的内存,如果对该参数传递kernel空间的指针,这两个函数都会返回失败-EFAULT。但在Kernel中,我们一般不容易生成用户空间的指针,或者不方便独立使用用户空间内存。要使这两个读写函数使用kernel空间的buffer指针也能正确工作,需要使用set_fs()函数或宏(set_fs()可能是宏定义),如果为函数,其原形如下:

    void set_fs(mm_segment_t fs);

    该函数的作用是改变kernel对内存地址检查的处理方式,其实该函数的参数fs只有两个取值:USER_DS,KERNEL_DS,分别代表用户空间和内核空间,默认情况下,kernel取值为USER_DS,即对用户空间地址检查并做变换。那么要在这种对内存地址做检查变换的函数中使用内核空间地址,就需要使用set_fs(KERNEL_DS)进行设置。get_fs()一般也可能是宏定义,它的作用是取得当前的设置,这两个函数的一般用法为:

    mm_segment_t old_fs;

    old_fs = get_fs();

    set_fs(KERNEL_DS);

    ...... //与内存有关的操作

    set_fs(old_fs);

    还有一些其它的内核函数也有用__user修饰的参数,在kernel中需要用kernel空间的内存代替时,都可以使用类似办法。

    使用vfs_read()和vfs_write()最后需要注意的一点是最后的参数loff_t * pos,pos所指向的值要初始化,表明从文件的什么地方开始读写。

     

    3. 关闭读写文件

     

    int filp_close(struct file*filp, fl_owner_t id);

    该函数的使用很简单,第二个参数一般传递NULL值,也有用current->files作为实参的。

     

    使用以上函数的其它注意点:

     

    1. 其实Linux Kernel组成员不赞成在kernel中独立的读写文件(这样做可能会影响到策略和安全问题),对内核需要的文件内容,最好由应用层配合完成。

    2. 在可加载的kernel module中使用这种方式读写文件可能使模块加载失败,原因是内核可能没有EXPORT你所需要的所有这些函数。

    3.分析以上某些函数的参数可以看出,这些函数的正确运行需要依赖于进程环境,因此,有些函数不能在中断的handle或Kernel中不属于任可进程的代码中执行,否则可能出现崩溃,要避免这种情况发生,可以在kernel中创建内核线程,将这些函数放在线程环境下执行(创建内核线程的方式请参数kernel_thread()函数)。
     

    #include <linux/kernel.h>
    #include <linux/module.h>
    #include <linux/init.h>
    #include <linux/fs.h>
    #include <linux/string.h>
    #include <linux/mm.h>
    #include <linux/syscalls.h>
    #include <asm/unistd.h>
    #include <asm/uaccess.h>

    #define MY_FILE "/root/LogFile"

    char buf[128];
    struct file *file = NULL;



    static int __init init(void)
    {
            mm_segment_t old_fs;
            printk("Hello, I'm the module that intends to write messages to file.\n");


            if(file == NULL)
                    file = filp_open(MY_FILE, O_RDWR | O_APPEND | O_CREAT, 0644);
            if (IS_ERR(file)) {
                    printk("error occured while opening file %s, exiting...\n", MY_FILE);
                    return 0;
            }

            sprintf(buf,"%s", "The Messages.");

            old_fs = get_fs();
            set_fs(KERNEL_DS);
            file->f_op->write(file, (char *)buf, sizeof(buf), &file->f_pos);
            set_fs(old_fs);
            filp_close(file, NULL);  
            file = NULL;
            return 0;
    }

    static void __exit fini(void)
    {
            if(file != NULL)
                    filp_close(file, NULL);
    }

    module_init(init);
    module_exit(fini);
    MODULE_LICENSE("GPL");

     

    在linux内核编程时,进行系统调用(如文件操作)时如果要访问用户空间的参数,可以用set_fs,get_ds等函数实现访问。get_ds获得kernel的内存访问地址范围(IA32是4GB),set_fs是设置当前的地址访问限制值,get_fs是取得当前的地址访问限制值。进程由用户态进入核态,linux进程的task_struct结构中的成员addr_limit也应该由0xBFFFFFFF变为0xFFFFFFFF(addr_limit规定了进程有用户态核内核态情况下的虚拟地址空间访问范围,在用户态,addr_limit成员值是0xBFFFFFFF也就是有3GB的虚拟内存空间,在核心态,是0xFFFFFFFF,范围扩展了1GB)。使用这三个函数是为了安全性。为了保证用户态的地址所指向空间有效,函数会做一些检查工作。 
    如果set_fs(KERNEL_DS),函数将跳过这些检查。
    下面是典型用法:

    //#define __NO_VERSION__
    //#define __KERNEL__
    //#define MODULE
    #define __KERNEL_SYSCALLS__
    #include <linux/unistd.h>;
    #include <linux/init.h>;
    #include <linux/module.h>;
    #include <linux/kernel.h>;
    #include <linux/file.h>;
    #include <linux/fs.h>;
    #include <linux/sched.h>;
    #include <asm/uaccess.h>;
    #include <asm/processor.h>;


    int init_module(void)
    {
             struct file *fp = NULL;
             char buf[100];
             int i;

             for(i=0;i<100;i++)
                     buf[i] = 0;
             printk(KERN_ALERT "Hello ,ftyjl.\n");
             fp = filp_open("/tmp/8899", 3, 0);   //内核的open函数,返回struct file *
             if (fp == NULL)
                     printk(KERN_ALERT "filp_open error ,ftyjl.\n");
             mm_segment_t old_fs=get_fs(); //下面两步,设置当前执行环境为kernel_ds,否则会出错
             set_fs(get_ds());
             fp->f_op->read(fp, buf, 2, &fp->f_pos);   //调用真正的read
             set_fs(old_fs);   //恢复环境
             printk(KERN_ALERT "ftyjl:read[%s]\n", buf);

             printk(KERN_ALERT "end of Hello ,ftyjl.\n");
             return 0;
    }
    void cleanup_module(void)
    {
             printk(KERN_ALERT "Good bye, ftyjl\n");
    }

    MODULE_LICENSE("Proprietary");

     

    转自:http://blog.csdn.net/tommy_wxie/article/details/8193954

    http://blog.csdn.net/zjc0888/article/details/7266730

    展开全文
  • VBA 读写文件

    万次阅读 2010-06-30 14:12:00
    处理文本文件 1、Open 语句 语法:Open pathname For mode [Access access] [lock] As [#]filenumber [Len=reclength] 其中access、lock、reclength为可选参数,一般不用。 mode ...

    处理文本文件

    1、Open 语句

    语法:Open pathname For mode [Access access] [lock] As [#]filenumber [Len=reclength]

    其中access、lock、reclength为可选参数,一般不用。
    mode 指定打开文件的方式。有5种:
    Input:以输 入方式打开,即读取方式。
    Output:以输出方式打开,即写入方式。
    Append:以追加方式打开,即添加内容到文件末尾。
    Binary: 以二进制方式打开。
    Random:以随机方式打开,如果未指定方式,则以 Random 方式打开文件。

    filenumber  是一个有效的文件号,范围在 1 到 511 之间。可以指定,也可使用 FreeFile 函数可得到下一个可用的文件号。

    说明:如果 pathname 指定的文件不存在,那么,在用 Append、Binary、Output、或 Random 方式打开文件时,可以建立这一文件。

    示例:
    Open "F:/TEST.txt" For Input As #1  '以输入方式打开
    Open "F:/TEST.xls" For Binary As #1  '以二进制方式打开

    2、Close 语句

    语法:Close [filenumberlist]
         filenumberlist 参数为一个或多个文件号,若省略 filenumberlist,则将关闭 Open 语句打开的所有活动文件。

    说明:打开文件后,必须在使用完后关闭文件。

    示例:
    Dim I, FileName
    For I = 1 To 3   
        FileName = "TEST" & I    ' 创建文件名。
        Open FileName For Output As #I    ' 打开文件。
        Print #I, "This is a test."    ' 将字符串写入文件。
    Next I
    Close    ' 将三个已打开的文件全部关闭。

    3、Reset 语句

    语法:Reset

    功能:关闭所有用 Open 语句打开的磁盘文件。

    说明:Reset 语句关闭 Open 语句打开的所有活动文件,并将文件缓冲区的所有内容写入磁盘。

    示例:
    Dim FileNumber
    For FileNumber = 1 To 5   
        Open "TEST" & FileNumber For Output As #FileNumber
        Write #FileNumber, "Hello World"    ' 将数据写入文件。
    Next FileNumber
    Reset    ' 关闭文件并将缓冲区内的数据写到磁盘中。

    4、FreeFile 函数

    语法:FreeFile[(rangenumber)]
          参数 rangenumber指定一个范围,以便返回该范围之内的下一个可用文件号。指定 0(缺省值)则返回一个介于 1 – 255 之间的文件号。指定 1 则返回一个介于 256 – 511 之间的文件号。

    功能:提供一个尚未使用的文件号。

    示例:
    Dim fnum As Integer

    fnum = FreeFile

    Open "F:/TEST.txt" For Input As #fnum

    Close #fnum


    5、EOF 函数

    语法:EOF(filenumber)

    功能:返回一个 Integer,它包含 Boolean 值 True,表明已经到达为 Random 或顺序 Input 打开的文件的结尾。

    6、LOF 函数

    语法:LOF(filenumber)

    功能:返回一个 Long,表示用 Open 语句打开的文件的大小,该大小以字节为单位。

    7、Loc 函数

    语法:LOc(filenumber)

    功能:返回一个 Long,在已打开的文件中指定当前读/写位置。


    8、Input # 语句

    语法:Input #filenumber, varlist

    功能:从已打开的顺序文件中读出数据并将数据指定给变量。

    说明:通常用 Write # 将 Input # 语句读出的数据写入文件。为了能够用 Input # 语句将文件的数据正确读入到变量中,在将数据写入文件时,要使用 Write # 语句而不使用 Print # 语句。使用 Write # 语句可以确保将各个单独的数据域正确分隔开。

    示例:
    本示例使用 Input # 语句将文件内的数据读入两个变量中。本示例假设 TESTFILE文件内含数行以 Write # 语句写入的数据;也就是说,每一行数据中的字符串部分都是用双引号括起来,而与数字用逗号隔开,例如,("Hello", 234)。

    Dim MyString, MyNumber
    Open "TESTFILE" For Input As #1      ' 打开输入文件。
    Do While Not EOF(1)       ' 循环至文件尾。
        Input #1, MyString, MyNumber      ' 将数据读入两个变量。
        Debug.Print MyString, MyNumber      ' 在立即窗口中显示数据。
    Loop
    Close #1         ' 关闭文件。

    9、Write # 语句

    语法:Write #filenumber, [outputlist]

    功能:将数据写入顺序文件。

    说明:通常用 Input # 从文件读出 Write # 写入的数据。
    如果省略 outputlist,并在 filenumber 之后加上一个逗号,则会将一个空白行打印到文件中。多个表达式之间可用空白、分号或逗号隔开。空白和分号等效。

    用 Write # 将数据写入文件时将遵循几个通用的约定,使得无论什么区域都可用 Input # 读出并正确解释数据:

    ·在写入数值数据时总使用句号作为十进制分隔符。

    ·对于 Boolean 类型的数据,或者打印 #TRUE# 或者打印 #FALSE#。无论在什么地区,都不将 True 和 False 这两个关键字翻译出来。

    ·使用通用的日期格式将 Date 类型的数据写入文件中。当日期或时间的部件丢失或为零时,只将现有部分写入文件中。

    ·如果 outputlist 的数据为 Empty,则不将任何数据写入文件。但对 Null 数据,则要写入 #NULL#。

    ·如果 outputlist 数据为 Null 数据,则将 #NULL# 写入文件中。

    ·对于 Error 类型的数据,输出看起来与 #ERROR errorcode# 一样。无论在什么地区,都不将关键字 Error 翻译出来。
    与 Print # 语句不同,当要将数据写入文件时,Write # 语句会在项目和用来标记字符串的引号之间插入逗号。没有必要在列表中键入明确的分界符。Write # 语句在将 outputlist 中的最后一个字符写入文件后会插入一个新行字符,即回车换行符,(Chr(13) + Chr(10))。

    示例:
    Open "F:/test.txt" For Output As #1      ' 打开输出文件。
    Write #1, "Hello World", 1234      ' 写入以逗号隔开的数据。
    Write #1,         ' 写入空白行。

    Dim MyBool, MyDate, MyNull, MyError
    ' 赋值 Boolean、Date、Null 及 Error 等。
    MyBool = False : MyDate = #February 12, 1969# : MyNull = Null
    MyError = CVErr(32767)
    ' Boolean 数据以 #TRUE# 或 #FALSE# 的格式写入。
    ' 日期以通用日期格式写入,例如:#1994-07-13# 代表
    ' 1994 年 1 月 13 日。Null 数据以 #NULL# 格式写入。
    ' Error 数据以 #ERROR 错误代号# 的格式写入。
    Write #1, MyBool; " is a Boolean value"
    Write #1, MyDate; " is a date"
    Write #1, MyNull; " is a null value"
    Write #1, MyError; " is an error value"
    Close #1    ' 关闭文件。

    我们可以看到写入的内容为:
    "Hello World",1234

    #FALSE#," is a Boolean value"
    #1969-02-12#," is a date"
    #NULL#," is a null value"
    #ERROR 32767#," is an error value"

    10、Line Input # 语句

    语法:Line Input #filenumber, varname

    功能:从已打开的顺序文件中读出一行并将它分配给 String 变量。

    说明:通常用 Print # 与 Line Input # 语句配合使用。
    Line Input # 语句一次只从文件中读出一个字符,直到遇到回车符 (Chr(13)) 或回车–换行符 (Chr(13) + Chr(10)) 为止。回车–换行符将被跳过,而不会被附加到字符串上。

    示例:
    Dim TextLine
    Open "TESTFILE" For Input As #1     ' 打开文件。
    Do While Not EOF(1)       ' 循环至文件尾。
        Line Input #1, TextLine      ' 读入一行数据并将其赋予某变量。
        Debug.Print TextLine      ' 在立即窗口中显示数据。
    Loop
    Close #1        ' 关闭文件。

    11、Input 函数

    语法:Input(number, [#]filenumber)
    其中number 指定要返回的字符个数。

    功能:返回 String,它包含以 Input 或 Binary 方式打开的文件中的字符。

    说明:通常用 Print # 或 Put 将 Input 函数读出的数据写入文件。Input 函数只用于以 Input 或 Binary 方式打开的文件。
    与 Input # 语句不同,Input 函数返回它所读出的所有字符,包括逗号、回车符、空白列、换行符、引号和前导空格等。

    示例:
    Dim MyChar
    Open "f:/test.txt" For Input As #1
    Do While Not EOF(1)       ' 循环至文件尾。
        MyChar = Input(1, #1)      ' 读入一个字符。
        Debug.Print MyChar      ' 显示到立即窗口。
    Loop
    Close #1

    下面这个函数可以将文本文件的数据一次读入到一个字符串(但是若包含中文时会出错,因为一个中文字占2个字节)。

    Public Function ReadText(FileName As String)

    Dim fnum%, isopen As Boolean
    On Error GoTo erro
    fnum = FreeFile()
    Open FileName For Input As #fnum
    isopen = True
    ReadText = Input(LOF(fnum), fnum)

    erro:
        If isopen Then Close #fnum
        If err Then Debug.Print err.Number, err.Description

    End Function

    12、Print # 语句

    语法:Print #filenumber, [outputlist]

    outputlist 参数的设置如下:
    [{Spc(n) | Tab[(n)]}] [expression] [charpos]

    Spc(n) 用来在输出数据中插入空白字符,而 n 指的是要插入的空白字符数。
    Tab(n) 用来将插入点定位在某一绝对列号上,这里,n 是列号。使用无参数的 Tab 将插入点定位在下一个打印区的起始位置。
    expression 要打印的数值表达式或字符串表达式。
    charpos 指定下一个字符的插入点。使用分号将插入点定位在上一个显示字符之后。用 Tab(n) 将插入点定位在某一绝对的列号上,用无参数的 Tab 将插入点定位在下一个打印区的起始处。如果省略 charpos,则在下一行打印下一个字符。


    功能:将格式化显示的数据写入顺序文件中。

    说明:通常用 Line Input # 或 Input 读出 Print # 在文件中写入的数据。

    示例:
    Open "F:/test.txt" For Output As #1         ' 打开输出文件。
    Print #1, "This is a test"                  ' 将文本数据写入文件。
    Print #1,                                   ' 将空白行写入文件。
    Print #1, "Zone 1"; Tab; "Zone 2"           ' 数据写入两个区(print zones)。
    Print #1, "Hello"; " "; "World"             ' 以空格隔开两个字符串。
    Print #1, Spc(5); "5 leading spaces "       ' 在字符串之前写入五个空格。
    Print #1, Tab(10); "Hello"                  ' 将数据写在第十列。

    ' 赋值 Boolean、Date、Null 及 Error 等。
    Dim MyBool, MyDate, MyNull, MyError
    MyBool = False: MyDate = #2/12/1969#: MyNull = Null
    MyError = CVErr(32767)
    ' True、False、Null 及 Error 会根据系统的地区设置自动转换格式。
    ' 日期将以标准的短式日期的格式显示。
    Print #1, MyBool; " is a Boolean value"
    Print #1, MyDate; " is a date"
    Print #1, MyNull; " is a null value"
    Print #1, MyError; " is an error value"
    Close #1

    以上代码写入的内容如下:
    This is a test

    Zone 1        Zone 2
    Hello World
         5 leading spaces
             Hello
    False is a Boolean value
    1969-2-12  is a date
    Null is a null value
    Error 32767 is an error value

    13、Width # 语句

    语法:Width #filenumber, width
    width 必要。范围在 0–255 之间的数值表达式,在新的一行开始之前,指出在该行上可出现多少字符。如果 width 等于 0,则行的长度不受限制。width 的缺省值为 0。

    功能:将一个输出行的宽度指定给用 Open 语句打开的文件。

    示例:
    Dim I
    Open "f:/TESTFILE.txt" For Output As #1
    Width #1, 5                                 ' 设置输出行宽为 5。
    For I = 0 To 9                              ' 循环 10 次。
        Print #1, Chr(48 + I);                  ' 每行输出五个字符。
    Next I
    Close #1

    以上代码写入的内容如下:
    01234
    56789

     

    (四)处理二进制文件
    打开二进制文件可以使用Open语句的Random和Binary方式打开。二进制文件读写使用Get和Put语句。

    1、Put 语句

    语法:Put [#]filenumber, [recnumber], varname

    recnumber 可选。Variant (Long)。记录号(Random 方式的文件)或字节数(Binary 方式的文件),指明在此处开始写入。

    说明:通常用 Get 将 Put 写入的文件数据读出来。

    示例:
    Dim num As Long, text As String
    num = 12345
    text = "a string"
    Open "f:/data.bin" For Binary As #1     '打开或创建一个二进制文件
    Put #1, , num                           '写入4个字节
    Put #1, , text                          '写入8个字节(字符串长为8)
    Close #1


    2、Get 语句

    语法:Get [#]filenumber, [recnumber], varname

    recnumber 可选。Variant (Long)。记录号(Random 方式的文件)或字节数(Binary 方式的文件),以表示在此处开始读出数据。

    功能:将一个已打开的磁盘文件读入一个变量之中。

    说明:通常用 Put 将 Get 读出的数据写入一个文件。

    示例:读取以上代码写入的内容
    Dim num As Long, text As String
    Open "f:/data.bin" For Binary As #1
    Get #1, , num
    text = Space$(8)                        '准备8个字节的字符串
    Get #1, , text                          '读入
    Debug.Print num, text
    Close #1

    在立即窗口可以看到如下内容:
     12345       a string


    3、Seek 语句

    语法:Seek [#]filenumber, position
    其中position 为介于 1~ 2,147,483,647(相当于 2^31 – 1)之间的数字,指出下一个读写操作将要发生的位置。

    功能:在 Open 语句打开的文件中,设置下一个读/写操作的位置。

    说明:可以用Seek语句指定Get语句的读取位置,但在 Get 及 Put 语句中指定的记录号将覆盖由 Seek 语句指定的文件位置。

    示例:
    Dim MaxSize, NextChar, MyChar
    Open "TESTFILE" For Input As #1     
    MaxSize = LOF(1)       ' 取得文件的总字符数。
    ' 用循环读入所有记录,但是从最后的记录开始往前读。
    For NextChar = MaxSize To 1 Step -1   
        Seek #1, NextChar      ' 设置读写位置。
        MyChar = Input(1, #1)      ' 读入一字符。
    Next NextChar
    Close #1  

    4、Seek 函数

    语法:Seek(filenumber)

    功能:返回一个 Long,在 Open 语句打开的文件中指定当前的读/写位置。

    说明:在使用Get语句读取文件时,必须用LOF函数来判断是否到达文件末尾,而不是用EOF函数。可以使用Seek函数判断当前位置,然后与 LOF的值比较。

    示例:
    Do While Seek(1) < LOF(1)
       '继续读取
       ......
    Loop

     

     

    例子:

    Dim filepath As String
    Dim filenumber As Integer
    Dim contents As String

    Dim comStr As String
    Dim count As Integer
    Dim start As Integer
    Dim i As Integer
    Dim name As String

    filenumber = FreeFile()
    filepath = "c:/scripts/insert.txt"

    count = InputBox("请输入记录的条数")
    start = InputBox("请输入记录开始单元格的行数")
    contents = ""

    comStr = "insert into tml (id,name) values ("
    For i = 1 To count Step 1
        name  = Worksheets(1).Cells(start, 1).Value

        contents = contents &  i  & ",'" & name & "'" & Chr(10)
        start = start + 1
    Next i

    Open filepath For Output As #filenumber
        Print #filenumber, contents
    Close #filenumber

    展开全文
  • Java FileChannel读写文件例子

    千次阅读 2017-03-10 21:42:05
    在Java NIO包中FileChannel是用于读取、写入、映射和操作文件的通道。 下面通过利用FileChannel来进行文件的读写例子 1从txt文件中读取数据并且输出到控制台 public static void main(String[] args) throws ...
  • Java读写文件的编码问题

    千次阅读 2016-01-08 18:53:48
    因此,在读写文件的时候,读入数据流时要指明格式,从数据流出到文件时也要指明编码格式,这样来说一般没什么的问题,因为你用文件原来的格式正确读取到了,然后把流中的数据按照你需要的格式出了,亲测有效。...
  • Linux下的文件读写

    千次阅读 2019-04-01 10:07:40
    应用程序(打开文件)-》各种库(标准库fopen)-》系统调用(open)-》内核(驱动)-》硬件(磁盘)。 系统调用:内核提供给外界访问的接口函数,调用这些函数将使进程进入内核态。 1、UNIX、Linux大部的系统...
  • Java使用RandomAccessFile读写文件

    万次阅读 多人点赞 2015-11-27 14:28:49
    [TOC] 转载自:http://blog.csdn.net/akon_vm/article/details/7429245Java RandomAccessFileRandomAccessFile是用来访问那些保存数据记录的文件的,你就可以用seek( )...但是该类仅限于操作文件。RandomAccessFile不
  • 『GDAL』读写TIFF文件

    千次阅读 2020-08-18 09:47:35
    读写TIFF文件的一种方法
  • 接上篇博客,下面来说第一个问题,VFS是如果打开和读写文件的。 用户读写文件的流程 file-&gt;dentry-&gt;inode-&gt;iops-&gt;address_space-&gt;disk 的流程: 通过struct找到磁盘inode...
  • 如何在QML应用中读写文件

    千次阅读 2015-04-16 10:01:26
    我们知道,在QML应用中,有时我们需要来读写一些文件,但是在我们的QML语言中并没有相应的API接口来供我们做(虽然有API接口来存储设置文件等)。那么我们怎么来做这个事情呢?我们可以通过Qt C++的方法来实现这个...
  • NC文件读写方式

    万次阅读 热门讨论 2017-03-17 13:40:27
    概述NetCDF全称为network Common Data Format,中文译法为“网络通用数据格式”,对程序员来说,它和zip、jpeg、bmp文件格式类似,都是一种文件格式的标准。netcdf文件开始的目的是用于存储气象科学中的数据,现在...
  • jstxt文件

    千次阅读 2010-07-19 20:05:00
    js作为客户端脚本,也有读写文件的功能,但是执行的话需要客户端允许js运行ActiveX,所以个人感觉...数字到txt文件(其实用excel很简单),又不想手动输入,我开始用java个程序给他,但是他没有运行环 <b
  • 使用C++文件流库fstream,以字符串形式读取十六进制文本文件的内容,将这些十六进制数据转换为int型数据,并分类存储
  • 安卓中文件读写-流操作

    千次阅读 2019-06-27 16:12:35
    字节流在操作文件时,即使不关闭资源(close方法),文件也能输出,但是如果字符流不使用close方法的话,则不会输出任何内容,说明字符流用的是缓冲区,并且可以使用flush方法强制进行刷新缓冲区,这时才能在不...
  • 一、相关函数原型  1、构造函数的一种 ... UINT nOpenFlags //文件访问模式 ); 2、写入 virtual void Write(  const void* lpBuf, //指向用户提供的缓冲区,包含将写入文件中的数据  UINT n
  • 在linux内核中读写文件

    万次阅读 2012-11-17 17:38:10
    在用户态,读写文件可以通过read和write这两个系统调用来完成(C库函数实际上是对系统调用的封装)。 但是,在内核态没有这样的系统调用,我们又该如何读写文件呢? 阅读linux内核源码,可以知道陷入内核执行的是实际...
  • C++ 移动和获取文件读写指针

    千次阅读 2020-03-18 08:54:17
    在读写文件时,有时希望直接跳到文件中... ofstream 类和 fstream 类有 seekp 成员函数,可以设置文件写指针的位置。 所谓“位置”,就是指距离文件开头有多少个字节。文件开头的位置是 0。 这两个函数的原型如下:...
  • python 文件读写查找、替换相关简单操作

    万次阅读 多人点赞 2015-11-01 00:14:50
    python 文件读写查找、替换相关简单操作
  • matlab对文件的读写

    千次阅读 2019-05-23 18:37:10
    matlab读取文件函数总结 1. load读取方式 a.基本说明: 只能读取数值数据,不能读取含文本的数据;日期按数值读取。 b.调用方式: a=load(filename); c. 有无分隔符限制: 无需输入分隔符,可...
  • python实现简单的声音文件读写

    千次阅读 2019-07-17 15:23:35
    一、 声音的读与 以下将用到python自带的wave模块进行操作。 声音文件的读取 以下以wav文件为例。 使用wave模块进行声音的读取操作是:wave.open(r"wav文件路径",“rb") ‘rb‘表示命令为只读模式。 wav.open命令...
  • WinCE文件读写操作

    千次阅读 2011-12-15 16:22:06
    WinCE文件读写操作 WinCE对文件操作有两种方式:一种是用WinCE自带的API函数,另一种方法是用MFC类库种的CFile类。 我们先用第一种的操作: 1.  文件的打开 HANDLE CreateFile( LPCTSTR lpFileName,...
  • 使用POI读写word doc文件

    千次阅读 2017-07-28 11:57:19
    目录 1 读word doc文件 1.1 通过WordExtractor读...2 word doc文件    Apache poi的hwpf模块是专门用来对word doc文件进行读写操作的。在hwpf里面我们使用HWPFDocument来表示一个word doc文档。在HWPFDocument
  • 二、需求文件 VS 需求跟踪矩阵 三、确认范围 VS 控制质量 四、确认范围 VS 控制范围 一、WBS 【出处】PMBOK P156,5.4 创建WBS。 WBS是项目团队为实现项目目标、创建所需可交付成果而需要实施的全部工作范围...
  • ModBus用户自定义文件读写功能

    千次阅读 2018-06-24 18:30:04
    ModBus用户自定义文件读写功能 功能分类 公共功能码 是较好地被定义的功能码, 保证是唯一的, MODBUS 组织可改变的, 公开证明的, 具有可用的一致性测试, MB IETF RFC 中证明的, 包含已被定义的公共指配...
  • 关于文件的文本读写和二进制读写

    千次阅读 2012-11-14 16:15:00
    我们都知道,文本文件和二进制文件在计算机上面都是以0,1存储的,那么两者怎么还存在差别呢?我觉得,对于编程人员,文本文件和二进制文件就是一个声明,指明了你应该以什么方式(文本方式/二进制)打开这个文件,用...
  • 毕业论文文件大小超出要求,压缩文件大小。
  • 二进制文件读写(给新手)Fortran

    千次阅读 2011-06-09 00:29:00
    2008/05/17 11:43 一些朋友总是咨询关于二进制文件的读写和转化。这里就我自己的理解说一说。一).一般问题 二进制文件与我们通常使用的文本文件储存方式有根本的不同。这样的不同很难用言语表达,自己亲自看一看...
  • 关于Windows文件读写(提高读写速度)

    千次阅读 2011-11-16 15:59:33
    这几天在研究怎么才能加快windows文件读写速度,搜了很多文章,MSDN也看了不少。稍微给大家分享一下。 限制windows文件读写速度的瓶颈其实最终还是来源于我们硬盘的固有特性,磁盘本身的转速和硬盘的串行化工作...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 782,277
精华内容 312,910
关键字:

怎样写文件范围