当前位置：首页 > 教学文档 > 教案>教案：文件的操作

教案：文件的操作

2024-12-31 08:34:03 收藏本文下载本文

“灵芝”通过精心收集，向本站投稿了20篇教案：文件的操作，下面是小编为大家整理后的教案：文件的操作，仅供大家参考借鉴，希望大家喜欢，并能积极分享!

教案：文件的操作

篇1：教案：文件的操作

我选的这节课是泰山版小学信息技术第二册(上)的第一单元”计算机的初步”中的第7课”文件的操作”

单元价值地位:本单元是小学信息技术学科知识的基础部分,对学生初步掌握一些计算机的基本知识和技能,进一步激发他们的学习兴趣,增强他们的信息意识,具有十分重要的作用。

单元目标：要求学生掌握计算机硬件、软件的基本知识，WIN98操作系统的桌面组成，窗口，文件夹和文件有关操作。教学内容包括；“认识计算机”、“计算机的硬件”、“计算机的软件”、“视窗WINDOWS”、“文件资料的管理”、“文件夹的使用”、“文件的`操作”。

单元教学过程（）：理论部分，我采用“先学后教“的方法，先高计出层次分明的思考问题，再引导学生认真阅读教材，用 “自己学得的知识”解决实际问题，并提供让学生“各抒己见”的机会。最后，我通过课堂小结使教学内容系统完整化。上机部分，以“建构主义”为理论指导，使用辅助教学软件或课件来创设情境，以电脑为意义建构工具，通过动手实践、合作探索、交流反馈、总结规范等环节，激发兴趣，增长知识，培养技能。教学中，我还灵活运用任务驱动，讲练结合等方式提高教学效率。

单元评价：采用自我评价、个人评价、教师评价三种方式。评价项目中行为习惯占40%，随堂练习占60%，随堂练习中又分为“你能行”“你完成了会更棒”“我们边玩边学”。最后让学生谈自己的收获。

篇2：教案：文件的操作

诸由前妙完小曲娜

一、教材分析：本课以人物对话形式引出文件操作与文件夹操作一样，可以有新建、复制、移动、删除等操作。本课进一步熟练菜单及按钮操作。文件选定及复制是本课教学重点。本课能进一步使学生掌握计算机基本知识和技能，进一步激发学生学习的兴趣，增强他们的信息意识。

二、学情分析：小学生知识形成的特点是：直观感知——实践操作——形成表象——构建新知。学习本课时，其中复制文件，移动文件，文件重命名等操作与第六课中文件夹的相应操作类同，学生已具备了一定的操作能力，但对文件建立及复制还是第一次接触。教学中，我注重给予学生创造性发展的天地，采用“知识迁移”与“任务驱动”结合的教学方法。在“任务驱动”下，以“知识迁移”方式进行，由学生交流、总结操作方法，教师进行归纳，规范操作方法。

三、教学目标设计：

知识与技能——学会文件基本操作，掌握选定一个和多个文件的方法；掌握删除、复制和移动文件的操作方法；能够理解移动与复制的区别。

能力和方法——增强学生利用信息技术自主学习能力，培养学生自主操作能力，合作学习和创新思维能力。

情感态度和价值观——培养学生对信息技术的热爱和良好的兴趣。

四、教学过程（）设计：

内容安排

教师活动

学生活动

设计意图

备注

导入新课

出示讨论话题：“机灵从计算机C盘的My Document文件夹里找到了她喜欢的图画文件，想把图画文件保存到软盘上带回家。可是“机灵”不会操作，我们大家一起帮她好吗？今天我们学习文件操作。

先设置情境，提出问题，引起学生探究的兴趣。讨论时注意纪律。

创设情境，为导入新课作准备，引起学生思考。

学生此时充满了兴趣。

学习

新

知

一．任务驱动：

出示学习任务：1、会选定文件，对文件进行复制、移动、删除和重命名。2、观察复制文件和移动文件的区别。

二．直观教学

（一）选定文件

1、情境设置：在C盘的My Documents文件夹中，机灵要选中图1.bmp 图3.bmp 图5.bmp这三个文件，怎么办？

2．师边讲边演示：（1）首先要选中这三个文件，但是

单击鼠标每次只能选中一个文件，这时按下Ctrl键不放，再单击图1.bmp图3.bmp 图5.bmp文件，松开Ctrl键，再单击文件。

（2）对选定连续的文件，可以单击第一个文件，然后按住Shift键不放，再单击最后一个文件，松开Shift键，则全部文件被选定。

3．选中文件，对文件进行复制、移动、删除等操作。这些操作和我们上节课学过的对文件夹的操作很相似，你能试着操作一下吗？

4．引导观察复制和移动文件有什么区别。

5．重命名文件，怎么操作呢？轻轻按一下右键，你就知道啦。

明白自己这节课的学习任务

生认真思考，带着任务，学习新课内容。

生操作，看到选定的文件变成蓝色。

生分组操作、讨论观察。

学生分组操作，自己发现如何对文件复制、移动、删除等方法。

生思考分析，在小组内讨论。

生在师引导下进行重命名的操作。注意发现规则，总结。

2—3名学生上台演示反馈。（鼓励学生采用多种方法）

让生明确目标，带着任务学习。

利用知识迁移，易于让学生自主探究，增强主动学习的欲望。

培养观察、比较、探索的合作学习的能力。

通过实践操作把理论知识转变为学生的技能。做好“补差”工作，让每名学生都能完成任务。

小结

学生成果展示（选定，复制，移动，重命名，删除文件）各组演示对单个或多个文件的各种操作。

反馈及小结；机灵想把C盘上的My Documents文件夹中的图2.bmp图4.bmp复制到软盘中，怎么办？

学生汇报学习情况。

生回答问题。

“提优”表扬优秀的学生，鼓励其他学生，向他们学习。

实施效果：90%生能较熟练地对文件进行操作，进行选定，删除，复制和移动，以及重命名，知道移动和复制文件的区别。

课后反思：1.创设情境，引发疑问。

上课伊始，创设“问题讨论”情境，充分调动学生的学习兴趣，寓教于实际问题中，把学习知识与生活实际联系起来，激发求知欲，使学生很快进入学习状态。

2．知识迁移，精讲多练。

信息技术课主要目的是培养学生使用信息，处理信息的能力，在本课中我精练地讲解了本课内容，加上朗诵示范，多让学生操作，去实践，去发现，去操作，去创新。同时不断引导学生发现利用已学知识迁移，形成新知。最后，“提优补差”，让每名学生完成本节学习任务。

3．任务驱动，自主体验。

新课教学中，出示学习任务激励学生，让学生带任务学习，以学生为主体，教师为主导，组织利用探索的方式学习，交流，讨论得出结论。通过操作实践去检验知识，并将其内化为自己人的技能，使每个学生得到个性化的体验空间，以自己的方式完成了学习任务。

篇3：小学信息技术第一课文件操作教案

小学信息技术第一课文件操作教案

学习目标：

1、了解文件夹的作用和基本概念；

2、学会建立文件夹；

3、掌握文件和文件夹的复制、移动和重命名操作。

教学重点：

1、学会建立文件夹；

2、掌握文件和文件夹的复制、移动和重命名操作。

教学难点：

掌握文件和文件夹的复制、移动和重命名操作

教学过程：

小明想要在计算机中建立起自己的文件夹，这样使用起来就方便多了。

一、建立新文件夹

在C盘中创建一个新文件夹。

1、双击“我的电脑”图标，打开“我的电脑”窗口；

2、在“我的'电脑”窗口双击（C：），打开“WINXPC：”窗口；

3、单击“文件”菜单，将指针指向“新建”，在出现的子菜单中单击“文件夹”命令；窗口中出现一个“新建文件夹图标”。

二、文件夹的重命名

1、选定“新建文件夹”；

2、单击“文件”菜单中的“重命名”命令；

3、在“新建文件夹”框中输入“小明文件夹”，并按回车键。

三、移动文件夹

小明想把保存在“我的文档”中的“房子”文件移动到“小明文件夹”中。

1、选定“房子”文件；

2、单击“编辑”菜单中的“剪切”命令；

3、打开“小明文件夹”窗口，单击“编辑”菜单中的“粘贴”命令；窗口中显示“房子”文件，表明文件已被移动。

四、复制文件

1、选定要复制的文件“房子”；

2、单击“编辑”菜单中的“复制”命令；

3、将软盘插入软盘驱动器，打开“我的电脑”窗口，再双击软盘驱动器；

4、单击“编辑”菜单中的“粘贴”命令，窗口中显示复制的文件。

议一议：

文件的复制和移动操作有什么区别？

练一练：

在E：盘建立一个“我的作业”文件夹，然后把C盘上的“小明文件夹”移到里面；

将保存在磁盘中的画图文件复制到“我的作业”文件夹中。

文献摘抄：

如果需要同时选取多个文件，可以按住键盘上的CTRL键，再依次单击所要选取的文件，这些文件反色显示，表示都被选取。

要选取连续排列的多个文件，可以先单击么一个文件，然后按住SHIFT，再单击最后一个文件，松开SHIFT键。

如果要撤消选取的文件，可单击选取的文件旁边的空白处。

教后小记：

第二课时练习

练习上节课所学内容

篇4：python文件操作

一、python中对文件、文件夹操作时经常用到的os模块和shutil模块常用方法，

1.得到当前工作目录，即当前Python脚本工作的目录路径: os.getcwd

2.返回指定目录下的所有文件和目录名:os.listdir()

3.函数用来删除一个文件:os.remove()

4.删除多个目录：os.removedirs（r“c：\python”）

5.检验给出的路径是否是一个文件：os.path.isfile()

6.检验给出的路径是否是一个目录：os.path.isdir()

7.判断是否是绝对路径：os.path.isabs()

8.检验给出的路径是否真地存:os.path.exists()

9.返回一个路径的目录名和文件名:os.path.split() eg os.path.split(‘/home/swaroop/byte/code/poem.txt‘) 结果：(‘/home/swaroop/byte/code‘, ‘poem.txt‘)

10.分离扩展名：os.path.splitext()

11.获取路径名：os.path.dirname()

12.获取文件名：os.path.basename()

13.运行shell命令: os.system()

14.读取和设置环境变量:os.getenv() 与os.putenv()

15.给出当前平台使用的行终止符:os.linesep Windows使用‘\r\n‘，Linux使用‘\n‘而Mac使用‘\r‘

16.指示你正在使用的平台：os.name 对于Windows，它是‘nt‘，而对于Linux/Unix用户，它是‘posix‘

17.重命名：os.rename（old， new）

18.创建多级目录：os.makedirs（r“c：\python\test”）

19.创建单个目录：os.mkdir（“test”）

20.获取文件属性：os.stat（file）

21.修改文件权限与时间戳：os.chmod（file）

22.终止当前进程：os.exit

23.获取文件大小：os.path.getsize（filename）

二、文件操作方法大全：

1.os.mknod(“test.txt”) #创建空文件

2.fp = open(“test.txt”,w) #直接打开一个文件，如果文件不存在则创建文件

3.关于open 模式：

复制代码代码如下:w：以写方式打开，

a：以追加模式打开 (从 EOF 开始, 必要时创建新文件)

r+：以读写模式打开

w+：以读写模式打开 (参见 w )

a+：以读写模式打开 (参见 a )

rb：以二进制读模式打开

wb：以二进制写模式打开 (参见 w )

ab：以二进制追加模式打开 (参见 a )

rb+：以二进制读写模式打开 (参见 r+ )

wb+：以二进制读写模式打开 (参见 w+ )

ab+：以二进制读写模式打开 (参见 a+ )

fp.read([size]) #size为读取的长度，以byte为单位

fp.readline([size]) #读一行，如果定义了size，有可能返回的只是一行的一部分

fp.readlines([size]) #把文件每一行作为一个list的一个成员，并返回这个list，

其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。

fp.write(str) #把str写到文件中，write()并不会在str后加上一个换行符

fp.writelines(seq)#把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入，不会在每行后面加上任何东西。

fp.close() #关闭文件。python会在一个文件不用后自动关闭文件，不过这一功能没有保证，最好还是养成自己关闭的习惯。如果一个文件在关闭后还对其进行操作会产生ValueError

fp.flush() #把缓冲区的内容写入硬盘

fp.fileno() #返回一个长整型的”文件标签“

fp.isatty() #文件是否是一个终端设备文件（unix系统中的）

fp.tell() #返回文件操作标记的当前位置，以文件的开头为原点

fp.next() #返回下一行，并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时，就是调用next()函数来实现遍历的。

fp.seek(offset[,whence])#将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。但如果提供了whence参数就不一定了，whence可以为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意，如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。

fp.truncate([size]) #把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大，依据系统的不同可能是不改变文件，也可能是用0把文件补到相应的大小，也可能是以一些随机的内容加上去。

三、目录操作方法大全

1.创建目录

os.mkdir(“file”)

2.复制文件：

shutil.copyfile(“oldfile”,“newfile”) #oldfile和newfile都只能是文件

shutil.copy(“oldfile”,“newfile”)#oldfile只能是文件夹，newfile可以是文件，也可以是目标目录

3.复制文件夹：

4.shutil.copytree(“olddir”,“newdir”) #olddir和newdir都只能是目录，且newdir必须不存在

5.重命名文件（目录）

os.rename(“oldname”,“newname”) #文件或目录都是使用这条命令

6.移动文件（目录）

shutil.move(“oldpos”,“newpos”)

7.删除文件

os.remove(“file”)

8.删除目录

os.rmdir(“dir”) #只能删除空目录

shutil.rmtree(“dir”)#空目录、有内容的目录都可以删

9.转换目录

os.chdir(“path”) #换路径

篇5：ExcelVBA文件的操作

在我们日常使用Excel的时候，不仅会用到当前Excel文件的数据，还经常需要访问其他的数据文件，这些数据文件可能是Excel文件、文本文件或数据库文件等。经常有朋友会问如何在vba代码里操作这些数据文件？本文就系统地介绍一下在Excel中应用VBA操作数据文件的方法。本文主要介绍四种常用的方法：1、利用Excel对象来处理文件；2、利用VBA文件处理语句来处理文件；3、利用FileSystemObject对象来处理文件；4、利用API函数来处理文件。当然对于数据库文件，还可以利用ADO＋SQL的方法操作，不过论坛已经有前辈详细介绍过此类方法，本文就不再重复了。

一、利用Excel对象来处理文件

利用Excel对象自带的方法来操作文件是最方便，也是最简单的。我们主要利用Workbooks集合和Workbook对象的方法来操作文件。

1、打开Excel文件

我们可以用Workbooks.Open方法打开一个Excel工作簿。Workbooks.Open(FileName, UpdateLinks, ReadOnly, Format, Password, WriteResPassword, IgnoreReadOnlyRecommended, Origin, Delimiter, Editable, Notify, Converter, AddToMru, Local, CorruptLoad)其中FileName是必选的参数，表示要打开的工作簿名，如果没有指定路径，则代表当前路径，

另外14个是可选参数，除了密码参数，其他的一般很少用。具体的含义可以参看VBA的帮助。

例：

Workbooks.Open F:\test.xls

可以打开F盘的test.xls文件。

2、打开文本文件

使用Open方法也可以打开文本文件，但建议使用OpenText方法。此方法是载入一个文本文件，并将其作为包含单个工作表的工作簿进行分列处理，然后在此工作表中放入经过分列处理的文本文件数据。完整语法如下：

Workbooks.OpenText(FileName, Origin, StartRow, DataType, TextQualifier, ConsecutiveDelimiter, Tab, Semicolon, Comma, Space, Other, OtherChar, FieldInfo, TextVisualLayout, DecimalSeparator, ThousandsSeparator, TrailingMinusNumbers, Local)关于以上参数的具体含义可以参看VBA的帮助，这里就不重复了。在实际的编程中，一般无需对这些复杂的参数进行处理。可以通过录制宏来得到打开一个文本文件的VBA代码。具体方法就是选择文件打开，然后选择打开文本文件，就会出现文本导入向导，一步一步执行完，直到文本打开后，停止录制。

篇6：二十二、文件操作基本常识

由于程序中经常有大量对文件的输入输出操作，它经常构成了程序的主要部分，因而C语言提供了很多输入输出的函数，它们分别用于两种类型文件输入输出系统：即由ANSI标准定义的缓冲文件(也称标准文件(流)输入输出(I/O)系统)；另一类是ANSI标准中没有定义的非缓冲文件(也称非标准文件(流)输入输出(I/O)系统)，

我们已经熟悉了通过键盘和显示器进行输入输出的一些函数，如scanf,printf()等等，这些通过控制台(键盘、显示器等)进行I/O的操作，可以看作标准文件输入输出系统的一些特例，实际上在标准输入输出系统中的一些函数，有关文件的参数(文件结构指针或称流指针),只要用标准设备的流指针代替，这些标准输入输出函数即成为控制台I/O函数。在任何程序执行时，C系统都定义了5个标准设备文件可供使用。自动打开的5个标准设备文件的文件结构指针(在标准I/O系统中)和文件代号将有一个规定值：

设备标准文件I/O系统中的流指针名非标准文件……

键盘(标准输入) stdin 0

显示器(标准输出) stdout 1

显示器(标准错误) stderr 2

串行口(标准辅助) stdoux 3

打印机(标准打印) stdprn 4

这样，不论在标准文件系统还是非标准文件系统中，文件结构只要用上述的流指针或文件代号代替，则这些函数也均适用于控制台设备。

一、文本流和二进制流

在C中引入了流(stream)的概念。它将数据的输入输出看作是数据的流入和流出，这样不管是磁盘文件或者是物理设备(打印机、显示器、键盘等),都可看作一种流的源和目的，视他们为同一种东西，而不管其具体的物理结构，即对他们的操作，就是数据的流入和流出。这种把数据的输入输出操作对象，抽象化为一种流，而不管它的具体结构的方法很有利于编程，而涉及流的输出操作函数可用于各种对象，与其具体的实体无关，即具有通用性。

在C中流可分为两大类，即文本流(text stream)和二进制流(binary stream)。所谓文本流是指在流中流动的数据是以字符形式出现。在文本流中，'\n'被换成回车CR和换行LF的代码0DH和0AH。而当输出时，则0DH和0AH本换成'\n'。

二进制流是指流动的是二进制数字序列，若流中有字符，则用一个字节的二进制ASCII码表示，若是数字，则用一个字节的二进制数表示。在流入流出时，对\n符号不进行变换。例如这个数，在文本流中用其ASCII码表示为：

'2' '0' '0' '1'

| | | |

50 48 48 49

共占4字节。而在二进制流中则表示为：00000111 11010001 用十六进制就是07D1。只占两字节。

由此看出，二进制流比文本流节省空间，且不用进行对\n的转换，这样可以大大加快流的速度，提高效率。因而，对于含有大量数字信息的数字流，可以采用二进制流的方式；对于含有大量字符信息的流，则采用文本流的方式。

二、流和文件

在C语言中流就是一种文件形式，它实际上就表示一个文件或设备(从广义上讲，设备也是一种文件)。把流当作文件总觉得不习惯，因而有人称这种和流等同的文件为流式文件，流的输入输出也称为文件的输入输出操作。当流到磁盘而成为文件时，意味着要启动磁盘写入操作，这样流入一个字符(文本流)或流入一个字节(二进制流)均要启动磁盘操作，将大大降低传输效率(磁盘是慢速设备)，且降低磁盘的使用寿命，

为此，C语言在输入输出的使用使用了缓冲技术，即在内存为输入的磁盘文件开辟了一个缓冲区(缺省为512字节),当流到该缓冲区装满后，再启动磁盘一次，将缓冲区内容装到磁盘文件中去。读取文件也是类似。

在C语言中将此种文件输入输出操作称为标准输入输出，或称流式输入输出(因这种输入输出操作是ANSI C推荐的标准)。还有一种是不带缓冲文件输入输出，称为非标准文件输入输出或低级输入输出，它将由DOS直接管理。关于这两种输入输出文件系统下节将会介绍。

三、文件FILE的数据结构

typedef struct

{

short level;

unsigned flags;

char fd;

unsigned char hold;

short bsize;

unsigned char *buffer;

unsigned char *curp;

unsigned istemp;

short token;

}FILE;

这是Turbo C中使用的定义(在stdio.h文件中),不同的C编译器，可能使用不同的定义，但基本含义变化不会太大。

flags: 是一个10位的标志字，其具体含义如下：

位代表符号含义

0 _F_READ 读

1 _F_WRIT 写

2 _F_BUF 由fclose释放缓冲区

3 _F_LBUF 行缓冲

4 _F_ERR 出错标志

5 _F_EOF EOF文件尾标志

6 _F_BIN 二进制方式

7 _F_IN 在进行输入

8 _F_OUT 在进行输出

9 _F_TERM 文件是一个终端

其他各字段内容以及flags字段内各位所的功能，请参照其他一些资料。这里不多说了，它目前并不是我们要求的内容。

应该注意，不要把文件指针和FILE结构指针混为一谈，它们代表两个不同的地址。文件指针指出了对文件当前读写的数据位置，而FILE结构指针是指出了打开文件所对应的FILE结构在内存中的地址，这个指针它实际本身也包含了文件指针的信息。流指针中的各字段是供C语言内部使用的，用户不应该存取它的任何字段。

我们已经熟悉了通过键盘和显示器进行输入输出的一些函数，如scanf(),printf()等等，这些通过控制台(键盘、显示器等)进行I/O的操作，可以看作标准文件输入输出系统的一些特例，实际上在标准输入输出系统中的一些函数，有关文件的参数(文件结构指针或称流指针),只要用标准设备的流指针代替，这些标准输入输出函数即成为控制台I/O函数。在任何程序执行时，C系统都定义了5个标准设备文件可供使用。自动打开的5个标准设备文件的文件结构指针(在标准I/O系统中)和文件代号将有一个规定值：

设备标准文件I/O系统中的流指针名非标准文件……

篇7：Word文件操作技巧

您正在看的Word教程是:Word文件操作技巧!

Word文件操作技巧:实现Word个性模板

用Word建立的文件默认页面是A4大小，即宽210毫米、高297毫米，但是有时由于工作的需要，我们不希望用A4大小的纸张，这样每次都必须打开页面设置对话框进行设置，同时，Word中默认生成的文档文件是不自动缩进的，必须使用手工调整它们的缩进，非常麻烦。其实，巧妙利用Word的模板文件功能可以设置Word的默认页面大小和自动缩进，从而实现个性模板。

①进入WordXP的模板文件夹，在Windows9x和WindowsMe下为C:\\Windows\\ApplicationData\\Microsoft\\Templates文件夹下，而在Windows和WindowsNT上为C:\\DocumentsandSettings\\用户名\\ApplicationData\\Microsoft\\Templates文件夹下（此文件夹为隐藏文件夹，你必须对文件夹选项进行设置才能够进入，详见Windows手册），你会看到在此文件夹中有一个normal.dot文件，此文件就是Word的默认模板文件。双击它，系统就会自动调用WordXP打开它。

②单击文件页面设置，调出页面设置对话框，将页面大小及上下左右边距设置自己所需的值，如图5所示。笔者经常使用它来写作，每次左右拖动滚动条来查看文章不太方便，所以把宽度设置小了一些，为15厘米，高度不变，仍为24厘米。

③单击格式段落，在段落设置对话框中选择缩进和间距标签，点击特殊格式下拉框，选择首行缩进，并设置度量值为0.7厘米（相当于两个汉字字符），即设置每段自动缩进两格（中国人用中文的特色）。

④单击文件保存命令，选择保存类型为文档模板文件，由于此时normal.dot原模板已经启动，所以无法直接保存为normal.dot文件。在此，笔者将它保存为normal1.dot文件。

⑤再次进入C:\\Windows\\ApplicationData\\Microsoft\\Templates文件夹下，这时会看到两个模板文件normal.dot和normal1.dot。选中normal.dot文件（老模板文件），按下F2键，选择重命名，将它重新命名为oldnormal.dot文件，按照此法再将新的模板文件normal1.dot重命名为normal.dot文件，

⑥上面的制作步骤完成后，使用起来就方便多了。单击快捷栏上的新建图标或直接按Ctrl+N快捷键即可以用你刚才的设置来进行文件处理了。

Word文件操作技巧:一次保存多个文件在WPS2000/Office中有一个保存所有文件命令，这个命令非常有用，只要执行该命令，即相当于将所有的文件进行存盘操作，免去了一个文件窗口一个文件窗口切换、存盘之苦。其实，我们也可以在Word中一次保存多个文件：只要在要保存文件时按下Shift键就可以发现，原来的保存命令已经变成了全部保存命令了，此时单击这个命令相当于WPS2000中的保存所有文件命令，即一次性将所有打开的文件进行存盘。

Word文件操作技巧:合并Word文件

我们在使用Word制作文档时，经常要与别人合作，一般情况下，我们都是把别人的文件拷贝过来打印，这虽然方便，但是不利于文件的管理。试着单击插入菜单下的文件命令，在弹出的窗口中选择Word文件，再找到同事的文件，点击插入钮。怎么样？同事的文件是不是已经历历在目了，而且图片、表格、字体、字号、格式都丝毫没有任何变化！

Word文件操作技巧:更改文件默认存盘格式

在Word默认情况下，我们都将文件存为Word的DOC格式，但是有时候我们出于特殊的需要，如投稿时需要TXT格式、多媒体软件中需要RTF格式等。把Word文档存为其余的格式固然很方便，只要单击文件另存为命令，然后在保存对话框中选择欲保存的类型再点击保存钮就行了。但是，每次这样做未免有些麻烦。其实，只要我们单击工具选项，打开设置窗口，点击保存标签，在将Word文件保存为下拉框中的Word文件（*.doc）改为自己想要的格式，以后每次存盘时，Word就会自动将文件存为你所预先设定的格式了。

Word文件操作技巧:修复文件

遇到过突然停电而自己的文件没有保存、文件找到却无法打开的情况吗？那时候的你一定比失恋更痛苦！其实，在Word中设计了一个修复程序，只不过它比较隐蔽，你没有注意罢了，巧妙地使用它说不定还能够把你的工作成果给恢复过来呢。请点击文件打开，在打开文件对话框中的文件类型下拉框中选择从任意文件中恢复文本项（请将鼠标向下拖动，否则无法看到这个项目），再点击原先打不开的文件，耐心等待一会儿凡是能够被恢复的文本都会出现在Word窗口中，这时候就麻烦你按一下存盘图标吧！

篇8：[DELPHI]文件、目录操作

关于文件、目录操作]

◇[DELPHI]简单的剪贴板操作

richedit1.selectall;

richedit1.copytoclipboard;

richedit1.cuttoclipboard;

edit1.pastefromclipboard;

篇9：[DELPHI]文件、目录操作

Chdir(''c:\abcdir'');转到目录

Mkdir(''dirname'');建立目录

Rmdir(''dirname'');删除目录

GetCurrentDir;//取当前目录名,无''\''

Getdir(0,s);//取工作目录名s:=''c:\abcdir'';

Deletfile(''abc.txt'');//删除文件

Renamefile(''old.txt'',''new.txt'');//文件更名

ExtractFilename(filelistbox1.filename);//取文件名

ExtractFileExt(filelistbox1.filename);//取文件后缀

篇10：Java文件操作详解Java

输入输出流在Java中，我们把能够读取一个字节序列的对象称作一个输入流;而我们把够写一个字节序列称作一个输出流，它们分别由抽象类 InputStream和OutputStream类表示。因为面向字节的流不方便用来处理存储为Unicode（每个字符使用两个字节)的信息。所以Jav

输入输出流

在Java中，我们把能够读取一个字节序列的对象称作一个输入流;而我们把够写一个字节序列称作一个输出流。它们分别由抽象类 InputStream和OutputStream类表示。因为面向字节的流不方便用来处理存储为Unicode（每个字符使用两个字节)的信息。所以Java 引入了用来处理Unicode字符的类层次，这些类派生自抽象类Reader和Writer，它们用于读写双字节的Unicode字符，而不是单字节字符。

Java.io包简介

JDK标准帮助文档是这样解释Java.io包的，通过数据流、序列和文件系统为系统提供输入输出。

InputStream类和OutputStream类

InputStream类是所有输入数据流的父类，它是一个抽象类，定义了所有输入数据流都具有的共通特性。

java.io.InputStream的方法如下：

public abstract readthrows IOException

读取一个字节并返回该字节，如果到输入源的末则返回-1。一个具体的输入流类需要重载此方法，以提供有用的功能。例如：在FileInputStream类中，该方法从一个文件读取一个字节。

public int read(byte[] b)throws IOException

把数据读入到一个字节数据中，并返回实际读取的字节数目。如果遇到流末则返回-1，该方法最多读取b.length个字节。

public abstract int read(byte[] b,int off,int len)throws IOException

把数据读入到一个字节数组中并返回实际读取的字节数目。如果遇到流的末尾则的返回-1。其中参数off表示第一个字节在b中的位置，len表示读取的最大字节数。

public long skip(long n)throws IOException

略过N个字节不读取，会返回实际略过的字节数目。因为数据流中剩下的数据可能不到N 个字节那么多，所以此时返回值会小于N。

public int available()throws IOException

read方法(包括后面要讲的OutputStream类的Write方法)都能够阴塞一个线程，直到字节被实际读取或写入。这意味着如果一个流不能立即被读或被写

* Created on -3-10

* To change the template for this generated file go to

* Window>Preferences>Java>Code Generation>Code and Comments

package mytestfiles;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.PrintWriter;

/**

* @author zhangqinglin

* To change the template for this generated type comment go to

* Window>Preferences>Java>Code Generation>Code and Comments

public class Files

{

public static void main(String[] args) throws IOException

{

Files f = new Files();

// System.out.println(f.readFile(“f:\\LinkFile.java”));

// f.readAllFile(“f:\\”,“LinkFile.java”);

// f.readLineFile(“f:\\”,“LinkFile.java”);

// System.out.println(f.fileIsNull(“f:\\”,“122.txt”));

// f.readFolderByFile(“F:\\PDF”);

// System.out.println(f.createAndDeleteFolder(“ss”,“f:\\”));

// System.out.println(f.createAndDeleteFile(“f:\\ss\\”,“TestFile.dat”));

String[] ss = new String[50];

for(int i=0;i

{

ss[i] = “信息技术和互联网(计算机软硬件,通讯) ”+i;

}

f.writeFile(“f:\\ss\\”,“TestFile.txt”,ss);

}

/**

* 文件的写入

* @param filePath(文件路径)

* @param fileName(文件名)

* @param args[]

* @throws IOException

public void writeFile(String filePath,String fileName,String[] args) throws IOException

{

FileWriter fw = new FileWriter(filePath+fileName);

PrintWriter ut=new PrintWriter(fw);

for(int i=0;i

{

out.write(args[i]);

out.println();

out.flush();

}

fw.close();

out.close();

}

/**

* 文件的写入

* @param filePath(文件路径)

* @param fileName(文件名)

* @param args

* @throws IOException

public void writeFile(String filePath,String fileName,String args) throws IOException

{

FileWriter fw = new FileWriter(filePath+fileName);

fw.write(args);

fw.close();

}

/**

* 创建与删除文件

* @param filePath

* @param fileName

* @return 创建成功返回true

* @throws IOException

public boolean createAndDeleteFile(String filePath,String fileName) throws IOException

{

boolean result = false;

File file = new File(filePath,fileName);

if(file.exists())

{

file.delete();

result = true;

System.out.println(“文件已经删除！”);

}

else

{

file.createNewFile();

result = true;

System.out.println(“文件已经创建！”);

}

return result;

}

/**

* 创建和删除目录

* @param folderName

* @param filePath

* @return 删除成功返回true

public boolean createAndDeleteFolder(String folderName,String filePath)

{

boolean result = false;

try

{

File file = new File(filePath+folderName);

if(file.exists())

{

file.delete();

System.out.println(“目录已经存在，已删除!”);

result = true;

}

else

{

file.mkdir();

System.out.println(“目录不存在，已经建立!”);

result = true;

}

catch(Exception ex)

{

result = false;

System.out.println(“CreateAndDeleteFolder is error:”+ex);

}

return result;

}

/**

* @param filePath

public void readFolderByFile(String filePath)

{

File file = new File(filePath);

File[] tempFile = file.listFiles();

for(int i = 0;i

{

if(tempFile[i].isFile())

{

System.out.println(“File : ”+tempFile[i].getName());

}

if(tempFile[i].isDirectory())

{

System.out.println(“Directory : ”+tempFile[i].getName());

}

/**

* 检查文件中是否为一个空

* @param filePath

* @param fileName

* @return 为空返回true

* @throws IOException

public boolean fileIsNull(String filePath,String fileName) throws IOException

{

boolean result = false;

FileReader fr = new FileReader(filePath+fileName);

if(fr.read() == -1)

{

result = true;

System.out.println(fileName+“ 文件中没有数据!”);

}

else

{

System.out.println(fileName+“ 文件中有数据!”);

}

fr.close();

return result;

}

/**

* 读取文件中的所有内容

* @param filePath

* @param fileName

* @throws IOException

public void readAllFile(String filePath,String fileName) throws IOException

{

FileReader fr = new FileReader(filePath+fileName);

int count = fr.read();

while(count != -1)

{

System.out.print((char)count);

count = fr.read();

if(count == 13)

{

fr.skip(1);

}

fr.close();

}

/**

* 一行一行的读取文件中的数据

* @param filePath

* @param fileName

* @throws IOException

public void readLineFile(String filePath,String fileName) throws IOException

{

FileReader fr = new FileReader(filePath+fileName);

BufferedReader br = new BufferedReader(fr);

String line = br.readLine();

while(line != null)

{

System.out.println(line);

line = br.readLine();

}

br.close();

fr.close();

}

原文转自：www.ltesting.net

篇11：PPT幻灯文件打包操作

将所有需要放映的Powerpoint演示文稿文件及演示文稿查看器一并“打包”，这样更便于操作者在各种环境中进行放映操作，Powerpoint中的文件打包操作大家都比较熟悉，但Powerpoint的界面有所不同，这里我们做一些介绍。

Powerpoint2003的PPT文件打包操作如下：

点击菜单“文件—打包向导”，按照提示一路“YSE”下去就可以了，当然，如果你要在没有安装POWERPOINT的机子上播放的话，你在打包的时候要选择相应的打包类型。

Powerpoint2007的PPT文件打包操作如下：

一、打包到文件夹

启动Powerpoint 2007，打开相应的演示文稿，单击“Office按钮”，在随后出现的快捷菜单中，依次选择“发布-CD数据包”选项，在随后弹出的对话框中，单击“确定”按钮。

单击上述“确定”按钮后，打开“打包成CD”对话框，单击其中的“选项”按钮。打开如下图所示的“选项”对话框，根据需要设置相应的选项属性，并单击“确定”按钮返回到“打包成CD”对话框。如果需要将多份演示文稿一并打包，则可以单击其中的“添加文件”按钮，打开“添加文件”对话框，将相应的文件添加即可，

在“将CD命名为”右侧的方框中输入文件夹名称，再单击“复制到文件夹”按钮，打开“复制到文件夹”对话框。

通过单击其中的“浏览”按钮，为打包的文件确定一个保存位置，然后单击“确定”按钮，在随后出现的如下图所示的对话框中，单击其中的“是(Y)”按钮，将链接的文件打包到文件夹中。

打包完成后，返回到“打包成CD”对话框，单击其中的“关闭”按钮退出即可。

二、打包文件的使用

将上述打包后的文件夹复制移动到其他电脑中并进入该文件夹，如下图所示。

双击其中的PPTVIEW.EXE文件，启动演示文稿查看器，选中需要放映的演示文稿，即可进入演示放映状态。三、手动添加其他演示文稿

在上述打包操作过程中，通过“添加文件”按钮将其他演示文稿文件添加到播放列表中，其实在完成打包且复制到文件夹的操作后，也可以利用手动方式将其他演示文稿文件添加到播放列表中：

将需要添加的演示文稿文件复制到上述打包文件夹中。

进入打包后的文件夹，双击其中的playlist.txt文件将其打开，输入其他演示文稿的文件名称，再单击“保存”退出即可。

篇12：python操作xml文件示例

热点排行

Python入门教程超详细1小时学会

python 中文乱码问题深入分析

比较详细Python正则表达式操作指

Python字符串的encode与decode研

Python open读写文件实现脚本

Python enumerate遍历数组示例应

Python 深入理解yield

Python+Django在windows下的开发

python 文件和路径操作函数小结

python 字符串split的用法分享

篇13：Word文件管理操作技巧

为了发挥Word 的强大功能，建议你在使用时试试以下的技巧，灵活运用这些技巧，可以使你迅速成为Word高手（这里我们以Word XP为例，其他版本请参考操作），

今天我们介绍Word 实用操作技巧的第二部分——文件管理类。

1、从文档中删除文档创建者的个人资料

如果不想让别人知道是谁创建或修改了文档，可以在Word XP中这样做：选择“工具”/选项，然后点击“安全性”标签，在隐私选项小节下选择“保存时从此文件中删除个人信息”检查框。

当该文档下次存盘时，Word XP 就会删除其中的个人资料，或者用一些通用的资料取代个人资料。被删除的个人资料包括：属性对话框中的名字、管理器和公司以及对文档作出修改的作者的名字、每次存盘时的名字清单。

2、将Word文档转换为图片

利用Word XP，无需专门的图形编辑器就可以将Word文档转换为图片，方法是：先将编辑的文件存为doc 格式，然后关闭之；接着在Word XP中新建一个文件，打开资源管理器，把刚才存盘的那个文件拖到新建的文件中，就可以将Word文档转换为图片啦，

3、复制文件不经过剪贴板

方法是：用鼠标选中复制的对象（包括文字和图片），按住Ctrl键的同时，用鼠标左键把对象拖曳至目的地即可。

4、插入图标的技巧

单击菜单“插入/对象”，弹出一个对话框，然后将“显示为图标”打钩，在“对象类别”中选取要插入的对象，按确定即可。如不满意图标的样式，你可以单击“更改图标”进行修改。

5、使所有文档都显示在一个窗口中

方法是：选择“工具/选项，点击“视图”按钮，清除“任务栏中的窗口”选项的检查框（右图），然后点击“确定”，就大功告成了。

6、快速计数

Word XP中新引入的“字数统计“工具条可以加快单词、字符、行、页和段落的计数。如果需要控制文档中的词汇数，这个功能是很有用的。

要显示该工具条，选择“视图”/工具栏/字数统计。

要对一个文档中的单词进行计数（还可以对文档中的字符、行、页和段落进行计数），只需点击工具条中空白域右侧的小箭头儿，从菜单中选择“单词”，该空白域就会显示出文档中的单词数。

使用“字数统计”工具条还可以对几个单词或特定的内容在文档中出现的次数进行计数，选择想对之计数的文本，并点击“重新计数”按钮即可。

篇14：Python 文件操作实现代码

热点排行

Python入门教程超详细1小时学会

python 中文乱码问题深入分析

比较详细Python正则表达式操作指

Python字符串的encode与decode研

Python open读写文件实现脚本

Python enumerate遍历数组示例应

Python 深入理解yield

Python+Django在windows下的开发

python 文件和路径操作函数小结

python 字符串split的用法分享

篇15：Python文件和目录操作详解

这篇文章主要介绍了Python文件和目录操作详解,本文讲解了文件的打开和创建、文件的读取、文件的写入、内容查找替换等内容,需要的朋友可以参考下

一、文件的打开和创建

1、打开

代码如下:

open(file,mode):

>>>fo = open(‘test.txt‘, ‘r‘)

>>>fo.read()

‘hello\n‘

>>>fo.close()

file(file,mode):

>>>f = file(‘test.txt‘, ‘r‘)

>>>f.read()

‘hello\n‘

>>>f.close()

mode可取值：

2、创建

用w/w+/a/a+模式打开即可，

二、文件的读取

1、String = FileObject.read([size])

代码如下:

>>>fr = open(‘test.txt‘)

>>>fr.read()

‘hello\nworld\n‘

or:

代码如下:

>>>for i in open(‘test.txt‘):

... print i

...

hello

world

2、String = FileObject.readline([size])

代码如下:

>>>f = open(‘test.txt‘)

>>>f.readline()

‘hello\n‘

>>>f.readline()

‘world\n‘

>>>f.readline()

‘‘

或者可以用next

3、List = FileObject.readlines([size])

代码如下:

>>>f = open(‘test.txt‘)

>>>f.readlines()

[‘hello\n‘, ‘world\n‘]

三、文件的写入

1、write(string)

代码如下:

>>>f = open(‘test.txt‘, ‘a‘)

>>>f.write(‘hello\nworld‘)

#‘hello\nworld‘

2、writelines(list)

代码如下:

>>>l = [‘a‘,‘b‘,‘c‘]

>>>f=open(‘test.txt‘,‘a‘)

>>>f.writelines(l)

#‘hello\nworldabc‘

注：writelines相当于调用了多次write，不会自动添加换行(\n)符

四、内容查找替换

1、FileObject.seek(offset, mode)

offset：偏移量

mode：

0表示将文件指针指向从文件头部到“偏移量”字节处，

1表示将文件指针指向从文件当前位置向后移动“偏移量”字节，

2表示将文件指针指向从文件尾部向前移动“偏移量”字节。

代码如下:

>>>f=open(‘test.txt‘)

>>>f.read()

‘hello\nworldabc‘

>>>f.read()

‘‘

>>>f.seek(0,0)

>>>f.read()

‘hello\nworldabc‘

>>>f.close()

2、flush：提交更新，即在文件关闭之前把内存中的内容强制写入文件（一般是文件关闭后写入）

3、文件查找：遍历行进行查找

代码如下:

#!/usr/bin/python

import re

search=‘hello world‘

file=‘test.txt‘

count = 0

f = open(file)

for l in f.readlines():

li = re.findall(search,l)

if len(li) >0:

count += len(li)

print ”Search “ + str(count) + ” \“” + search + “\”“

f.close()

4、文件内容替换：遍历行进行替换

替换到新文件demo：

代码如下:

#!/usr/bin/python

s=‘hello‘

f=‘test.txt‘

rs=‘ten‘

rf=‘test2.txt‘

fh = open(of)

newl=[]

for l in ofh.readlines():

nl = l.replace(os,rs)

newl.append(nl)

rfh = open(rf,‘w+‘)

rfh.writelines(newl)

ofh.close()

rfh.close()

替换到原文件demo:

代码如下:

[server@localserver file]$ cat test.txt

abc

hello

world

hello world

helloworld

hello hello world

[server@localserver file]$ cat fr.py

#!/usr/bin/python

s=‘hello‘

file=‘test.txt‘

rs=‘ten‘

f = open(file, ‘r+‘)

s=f.read()

f.seek(0,0)

f.close()

f = open(file, ‘w+‘)

f.write(s.replace(os,rs))

f.close()

[server@localserver file] python fr.py

[server@localserver file]$ cat test.txt

abc

ten

world

ten world

tenworld

ten ten world

这里采用了重建文件的办法，

或用 fileinput 模块直接在原文件上修改：

代码如下:

#!/usr/bin/python

import fileinput

s=‘hello‘

file=‘test.txt‘

rs=‘ten‘

for line in fileinput.input(file, inplace=True):

print line.replace(os,rs).replace(‘\n‘,‘‘)

注意，这里删除了\n是因为print时会写入换行。

五、文件及目录操作

一般是借助OS模块实现

1、mkdir(path[,mode=0777])：创建目录，相当于mkdir

代码如下:

>>>import os

>>>os.mkdir(‘tt‘)

2、makedirs(name[, mode=511])：创建多级目录，相当于mkdir -p

3、rmdir(path)：删除目录，相当于rm

4、removedirs(path)：删除多级目录，相当于rm -rf

5、listdir(path)：列出目录中文件和文件夹，相当于ls

6、getcwd()：获取当前路径，相当于pwd

7、chdir(path)：切换目录，相当于cd

8、rename(src, dst)：重命名

9、shutil.copyfile(str,dst)：复制文件（要引入shutil模块）

10、path.splitext(filename)：获取文件路径和扩展名

代码如下:

>>>import os

>>>fileName, fileExtension = os.path.splitext(‘/path/to/somefile.ext‘)

>>>fileName

‘/path/to/somefile‘

>>>fileExtension

‘.ext‘

11、walk(top, topdown=True, nerror=None)：遍历目录

代码如下:

>>>import os

>>>g = os.walk(‘a‘)

>>>g.next()

(‘a‘, [‘b‘], [])

>>>g.next()

(‘a/b‘, [‘f‘, ‘c‘], [])

>>>g.next()

(‘a/b/f‘, [], [‘3.txt‘])

>>>g.next()

(‘a/b/c‘, [‘d‘, ‘e‘], [])

>>>g.next()

(‘a/b/c/d‘, [], [‘1.txt‘])

>>>g.next()

(‘a/b/c/e‘, [], [‘2.txt‘])

walk返回的是一个生成器，生成器中的内容是：当前目录，目录列表，文件列表

python自己递归实现文件遍历：

代码如下:

#!/usr/bin/python

import os

def dirList(path):

filelist = os.listdir(path)

fpath = os.getcwd()

allfile = []

for filename in filelist:

filepath = os.path.abspath(os.path.join(path, filename))

if os.path.isdir(filepath):

allfile.extend(dirList(filepath))

else:

allfile.append(filepath)

return allfile

files = dirList(‘a‘)

print files

篇16：Python 文件读写操作实例详解

热点排行

Python入门教程超详细1小时学会

python 中文乱码问题深入分析

比较详细Python正则表达式操作指

Python字符串的encode与decode研

Python open读写文件实现脚本

Python enumerate遍历数组示例应

Python 深入理解yield

Python+Django在windows下的开发

python 文件和路径操作函数小结

python 字符串split的用法分享

篇17：PHP之文件目录基础操作

我们知道，临时声明的变量是保存在内存中的，即便是静态变量，在脚本运行完毕后也会被释放掉，so，想长久保存一个变量的内容，方法之一就是写到文件中，放到硬盘或服务器上，为此文件操作就必须很熟悉，

1.文件的属性信息获取

首先文件具有类型，在Linux下边，有block（块设备，如磁盘分区、CD-ROM）、char（以字符为输入的设备，如键盘、打印机）、dir（目录类型，目录也是文件的一种）、fifo（命名管道，解释是将信息从一个进程传到另一个进程）、file（普通的文件）、link（链接，类似win下边的快捷方式）、unknow（未知类型）7大类，在win下边，只有3类：file、dir和unknown。Linux渣表示一定要好好搞一下Linux-_-，人家完全是为Linux而生。

关于类型的获取有这么几个函数：filetype：获取类型； is_file：判断为是否是正常文件； is_link：判断是否是链接。

关于属性的获取有这么几个函数：

file_exists：判断文件或目录是否存在；

filesize：获取文件大小；

is_readable、is_writable、is_executable ：是否可读、可写、可执行；

filectime、filemtime、fileatime：获取文件的创建时间（create）、修改时间（modify）、访问时间（access），均返回时间戳；

stat：获取文件的一些基本信息，返回一个索引与关联混合数组。

比如，可以这样判断文件类型：

复制代码

function getFileType($path){ // 获取文件类型

switch(filetype($path)){

case 'file': return 'ordinary file';

case 'dir': return 'directory';

case 'block': return 'block device file';

case 'char': return 'transfer device base on char';

case 'fifo': return 'named pipes';

case 'link': return 'symbol link';

default: return 'unknown type';

}

复制代码

filesize返回的是以字节为单位的数据，如果是大文件数字或很大，可以对数字先处理一下，代码如下

复制代码

// 处理文件大小

function getSize($path = '', $size = -1){

if($path !== null && $size == -1){ // 只传路径就计算大小，也可以使之只处理数字

$size = filesize($path);

}

if($size >= pow(2, 40)){

return round($size/pow(2, 40), 2).'TB';

}

else if($size >= pow(2, 30)){

return round($size/pow(2, 30), 2).'GB';

}

else if($size >= pow(2, 20)){

return round($size/pow(2, 20), 2).'MB';

}

else if($size >= pow(2, 10)){

return round($size/pow(2, 10), 2).'KB';

}

else{

return round($size, 2).'Byte';

}

复制代码

现在综合来获取一下文件信息，代码如下：

复制代码

function getFileInfo($path){

if(!file_exists($path)){ // 判断文件是否存在

echo 'file not exists!

return;

}

if(is_file($path)){ // 是文件，打印基础文件名

echo basename($path).' is a file

}

if(is_dir($path)){ // 是目录，返回目录

echo dirname($path).' is a directory

}

echo 'file type:'.getFileType($path).'

'; // 获取文件类型

echo 'file size:'.getSize($path).'

'; // 获取文件大小

if(is_readable($path)){ // 是否可读

echo basename($path).' is readable

}

if(is_writeable($path)){ // 是否可写

echo basename($path).' is writeable

}

if(is_executable($path)){ // 是否可执行

echo basename($path).' is executable

}

// touch函数可以修改这些时间

echo 'file create time: '.date('Y-m-d H:i:s', filectime($path)).'

'; // 创建时间

echo 'file modify time: '.date('Y-m-d H:i:s', filemtime($path)).'

'; // 修改时间

echo 'last access time: '.date('Y-m-d H:i:s', fileatime($path)).'

'; // 上次访问时间

echo 'file owner: '.fileowner($path).'

'; // 文件拥有者

echo 'file permission: '.substr(sprintf('%o', (fileperms($path))), -4).'

'; // 文件权限，八进制输出

echo 'file group: '.filegroup($path).'

'; // 文件所在的组

}

复制代码

效果如下：

代码中还用到了文件权限、所在组等函数，有必要解释下（说的不对请修正）。一个文件的权限分为可读可写可执行，一般这样表示：rwx，字母对应的表示可读可写可执行，从前往后规定值为4、2、1，三个值相加的结果最大为7，因此0666用的是八进制表示，这样看起来就很方便。为7则表示这个文件具备这三个权限，那为什么打印的是0666呢？我们都知道，进入windows下面是有一个用户的，在Linux下边，与windows类似，也是有一个用户登录进去，因此一个文件可能为该用户所有，一个用户它还有自己所在的组，以及该系统中还有其他组（猜想这样分应该是管理上的需要），因此对于0666，对于第一个6，表示该用户对该文件的权限，第二个6表示该用户所在的组对该文件的权限，第三个6表示其他的组所具有的权限（这样就不用一一去区分除本组外其他的用户了），6就知道该文件是可读可写的（win下可执行都知道是.exe文件）。

2.目录操作

目录的读取，opendir：打开一个目录，返回一个句柄，指向该目录中的内容，如果把目录中的内容看成一个有顺序的数据，比如按顺序的排列的数组，这个句柄就指向这个数组的开头，事实上，系统会把该目录中的内容按照字典排序，无论是文件还是子目录。readdir：读取下一个目录内容，返回文件名，并自动指向该目录中的下一个文件/目录，所以读取一个目录中的内容，不包括子目录中的内容，需要一个循环来控制，在读取完后，还要关闭句柄变量，C语言读取文件时也是这样，打开就有关闭。以我的机子举例：

复制代码

// 目录的读取

$dir = 'F:/';

echo 'details in '.$dir.'

if(is_dir($dir)){

if(($handle = opendir($dir)) == false){ // 获取目录句柄

echo 'open dir failed';

return;

}

while(($name = readdir($handle)) != false){ // 循环读取该目录下内容

$filepath = $dir.'/'.$name;

echo 'name: '.$name.' type: '.filetype($filepath).'

}

closedir($handle); // 关闭目录句柄

}

else{

echo $dir.' is not a directory';

}

复制代码

效果如下：

可以看到实际上，系统给目录中内容进行了忽略大小写的字典排序。

目录的大小计算，我们知道文件的大小可以由filesize取得，但是php中没有专门计算目录大小的函数。当然php中有计算硬盘大小的函数disk_total_space（计算硬盘总空间）、disk_free_space（计算硬盘可用空间），但是我试了下disk_free_space，貌似计算得不对。正因为有filesize计算文件的大小，因此，需要用到递归，当是目录时，进去继续计算子目录的大小，如果是文件，获取到文件大小并加上返回，代码如下：

复制代码

// 目录大小计算

function getDirSize($dirpath){

$size = 0;

if(false != ($handle = opendir($dirpath))){

while(false != ($file = readdir($handle))){

if($file == '.' || $file == '..') //注意过滤目录中自带的点和点点

continue;

$filepath = $dirpath.'/'.$file; // 前面要接上路径

if(is_file($filepath)){ // 是文件计算大小

$size += filesize($filepath);

}

else if(is_dir($filepath)){ // 是目录继续计算该目录下的文件

$size += getDirSize($filepath);

}

else{

$size += 0;

}

closedir($handle);

}

return $size;

}

$dirsize = 'F:/size';

$size = getDirSize($dirsize);

echo 'dir size: '.getSize(null, $size).'

'; // 调用前面的数据处理函数

复制代码

我在F盘建了个size文件，随便弄了点子目录和文档，效果如下，左边是程序求得，右边是右键查看文件夹属性得到的，用以对比，

目录的新建和删除，主要用到，mkdir：新建一个目录，rmdir：删除一个非空目录，注意只能是非空，代码如下：

复制代码

// 目录的新建和删除

$newDirPath = 'F:/newDir';

if(true == @mkdir($newDirPath, 0777, true)){ // 加@是因为文件已存在时php本身可能会抛出一个warning

echo 'create directory '.$newDirPath.' successfully

}

else{

if(file_exists($newDirPath))

echo 'directory '.$newDirPath.' has existed

else

echo 'create directory '.$newDirPath.' failed

}

if(true == @rmdir('F:/aaa')) //只能删除非空目录，如果删除不存在的目录自动抛出warning

echo 'remove successfully

复制代码

那么问题来了，如果要删除一个非空目录咋办，又得自己写了，思想仍然是递归，因为php只提供了删除文件函数unlink，所以在删除一个目录时，先opendir，再进入，如果是文件直接删除，如果是目录，继续进入使用该方法处理，当然还可已返回一个bool变量表示删除是否成功，代码如下：

复制代码

// 删除文件 unlink

function clearDir($dirpath){

if(file_exists($dirpath)){

if(false != ($handle = opendir($dirpath))){

while(false != ($name = readdir($handle))){

if($name == '.' || $name == '..')

continue;

$filename = $dirpath.'/'.$name;

if(is_dir($filename))

clearDir($filename);

if(is_file($filename))

@unlink($filename);

}

closedir($handle);

rmdir($dirpath);

}

else{

return false;

}

else{

return false;

}

return true;

}

复制代码

在这里不得不说遇到的一个大坑，就是 . 和 .. 这两个鬼玩意儿（点和点点），在操作系统中的每一个文件夹下边，都会有 . 和 .. ，它们表示当前目录和当前目录的上级目录，可恶的是前面在读取目录时居然没显示，导致递归函数成了死循环，因为 . 和 .. 在每一个目录的最前面，必然会先读到它俩，若不过滤，首先读到 . ，它表示本目录，然后又递归进入本目录...这俩是操作系统下面的默认有的，它们是本目录与上级目录的连接符。

通过计算目录的大小和删除非空目录的代码，写复制和剪切目录就非常容易，非常相似的递归思想，需要用到复制文件函数copy，文件移动函数rename，这个挺有趣，rename，字面上是重命名，但是重命名到另一个目录中不就是剪切了么-_-

3.文件读写

php的某些文件读取操作跟C语言非常像，所以也比较简单，步骤就是先打开文件获取句柄，检查错误，然后读写处理，然后关闭，养成打开处理完后就关闭的好习惯，记得在C语言中的文件不关闭的话，打开两次是会报错滴，不知道记错没，所以严格点的程序都有非常多的处理，比如先验证文件存在，然后验证可读可写性，然后先关闭一下，然后再打开，打开时还得再检查打开错了没......在打开文件时，就要选择打开文件的模式，它决定了我们读还是写文件，当然是对需要这样操作的函数有用。

写文件，写文件函数只有fwrite、fputs、file_put_contents少数几个，其中fwrite与fputs效果一样，file_put_contents是一次性向文件写入一些内容，它就不需要指定打开模式，同时它也可以是附加或者覆盖现有文件内容，比如：

复制代码

// 写 fwrite(别名fputs)

$filepath = 'F:/10m.txt';

function writeSome($filepath){

if(($handle = fopen($filepath, 'r+')) == true){

for($i=0; $i<10; $i++)

fwrite($handle, $i.” write something\r\n“); // windws以\r\n作为换行符

fclose($handle);

}

file_put_contents($filepath, 'use file_put_contents function', FILE_APPEND); // 附加内容

复制代码

读文件，读文件的函数多些，有fread（读取指定个字节）、fgetc（读取一个）、fgets（读取一行）、file（全部读取，按行分配到一个数组中返回）、file_get_contents（默认读取全部返回字符串）、readfile（直接将文件中内容输出到缓存，效果就是直接在浏览器上输出），伴随着fread、fget、fgets运行，文件指针会自动往后走。因此连续读最好是循环控制。读到文件末尾怎么办，EOF标识指示到达文件末尾，最好用feof检测是否到文件末尾。不多说，看代码：

复制代码

// fread读取

function readSome($filepath){

if(($handle = @fopen($filepath, 'r')) == true){

while(!feof($handle)){ // 判断是否到达文件末尾

$str = fread($handle, 10); // fread读取时，文件指针自动向后移动

echo $str.'

}

复制代码

如果想要读取方式更灵活，就要配合fseek、rewind使用，它们可以移动文件指针到具体位置，fseek十分灵活，可以直接移到开头或末尾，或从当前位置往前或后移动，读取想要的内容，ftell还可告知当前位置，比如：

复制代码

function readFun($filepath){

if(($handle = @fopen($filepath, 'r')) != false){

echo 'current position: '.ftell($handle).'

'; // 输出文件当前文件指针位置，以字节算，0表示开头

$str = fread($handle, 3); // 读取3个字节，同时指针自动后移3个字节

echo 'read content: '.$str.'

echo 'current position: '.ftell($handle).'

fseek($handle, 5, SEEK_CUR); // 将文件指针从当前位置后移5个字节

echo 'current position: '.ftell($handle).'

$str = fread($handle, 5);

echo 'read content: '.$str.'

echo 'current position: '.ftell($handle).'

rewind($handle); // 返回文件开头

echo 'current position: '.ftell($handle).'

fseek($handle, 0, SEEK_END); // 移到文件末尾

echo 'current position: '.ftell($handle).'

fclose($handle); // 关闭文件

}

篇18：sed命令针对文件操作详解

Linux的简单shell脚本中修改文件操作

1.Sed简介

sed 是一种在线编辑器，它一次处理一行内容，处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（patternspace），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾。文件内容并没有改变，除非你使用重定向存储输出。Sed主要用来自动编辑一个或多个文件；简化对文件的反复操作；编写转换程序等。

2.定址

可以通过定址来定位你所希望编辑的行，该地址用数字构成，用逗号分隔的两个行数表示以这两行为起止的行的范围（包括行数表示的那两行）。如1，3表示1，2，3行，美元符号($)表示最后一行。范围可以通过数据，正则表达式或者二者结合的方式确定。

3.Sed命令格式

调用sed命令有两种形式：

sed[options]'command'file(s)

sed[options]-fscriptfilefile(s)

4.常见的Sed命令

在当前行后面加入一行文本。

blable

分支到脚本中带有标记的地方，如果分支不存在则分支到脚本的末尾。

用新的文本改变本行的文本。

从模板块（Patternspace）位置删除行。

删除模板块的第一行。

在当前行上面插入文本。

拷贝模板块的内容到内存中的缓冲区。

追加模板块的内容到内存中的缓冲区

获得内存缓冲区的内容，并替代当前模板块中的文本。

获得内存缓冲区的内容，并追加到当前模板块文本的后面。

列表不能打印字符的清单。

读取下一个输入行，用下一个命令处理新的行而不是用第一个命令。

追加下一个输入行到模板块后面并在二者间嵌入一个新行，改变当前行号码。

打印模板块的行。

P（大写）

打印模板块的第一行。

退出Sed。

rfile

从file中读行。

tlabel

if分支，从最后一行开始，条件一旦满足或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾。

Tlabel

错误分支，从最后一行开始，一旦发生错误或者T，t命令，将导致分支到带有标号的命令处，或者到脚本的末尾。

wfile

写并追加模板块到file末尾。

Wfile

写并追加模板块的第一行到file末尾。

表示后面的命令对所有没有被选定的行发生作用。

s/re/string

用string替换正则表达式re。

打印当前行号码。

把注释扩展到下一个换行符以前。

以下的是替换标记

g表示行内全面替换。

p表示打印行。

w表示把行写入一个文件。

x表示互换模板块中的文本和缓冲区中的文本。

y表示把一个字符翻译为另外的字符（但是不用于正则表达式）

5.命令选项

-ecommand,--expression_r=command

允许多台编辑。

-h,--help

打印帮助，并显示bug列表的地址。

-n,--quiet,--silent

取消默认输出。

-f,--filer=script-file

引导sed脚本文件名。

-V,--version

打印版本和版权信息。

6.元字符集

锚定行的开始如：/^sed/匹配所有以sed开头的行。

锚定行的结束如：/sed$/匹配所有以sed结尾的行。

匹配一个非换行符的字符如：/s.d/匹配s后接一个任意字符，然后是d。

匹配零或多个字符如：，love这成**love**。

锚定单词的开始，如:/>

锚定单词的结束，如/love>/匹配包含以love结尾的单词的行。

x{m}

重复字符x，m次，如：/0{5}/匹配包含5个o的行。

x{m,}

重复字符x,至少m次，如：/o{5,}/匹配至少有5个o的行，

x{m,n}

重复字符x，至少m次，不多于n次，如：/o{5,10}/匹配5--10个o的行。

7.举例说明

删除：d命令

$sed'2d'example-----删除example文件的第二行。

$sed'2,$d'example-----删除example文件的第二行到末尾所有行。

$sed'$d'example-----删除example文件的最后一行。

$sed'/test/'dexample-----删除example文件所有包含test的行。

替换：s命令

$sed's/test/mytest/g'example-----在整行范围内把test替换为mytest。如果没有g标记，则只有每行第一个匹配的test被替换成mytest。

$sed-n's/^test/mytest/p'example-----(-n)选项和p标志一起使用表示只打印那些发生替换的行。也就是说，如果某一行开头的test被替换成mytest，就打印它。

$sed's/^192.168.0.1/&localhost/'example-----&符号表示替换换字符串中被找到的部份。所有以192.168.0.1开头的行都会被替换成它自已加localhost，变成192.168.0.1localhost。

$sed-n's/(love)able/1rs/p'example-----love被标记为1，所有loveable会被替换成lovers，而且替换的行会被打印出来。

$sed's#10#100#g'example-----不论什么字符，紧跟着s命令的都被认为是新的分隔符，所以，“#”在这里是分隔符，代替了默认的“/”分隔符。表示把所有10替换成100。

选定行的范围：逗号

$sed-n'/test/,/check/p'example-----所有在模板test和check所确定的范围内的行都被打印。

$sed-n'5,/^test/p'example-----打印从第五行开始到第一个包含以test开始的行之间的所有行。

$sed'/test/,/check/s/$/sedtest/'example-----对于模板test和west之间的行，每行的末尾用字符串sedtest替换。

多点编辑：e命令

$sed-e'1,5d'-e's/test/check/'example-----(-e)选项允许在同一行里执行多条命令。如例子所示，第一条命令删除1至5行，第二条命令用check替换test。命令的执行顺序对结果有影响。如果两个命令都是替换命令，那么第一个替换命令将影响第二个替换命令的结果。

$sed--expression='s/test/check/'--expression='/love/d'example-----一个比-e更好的命令是--expression。它能给sed表达式赋值。

从文件读入：r命令

$sed'/test/rfile'example-----file里的内容被读进来，显示在与test匹配的行后面，如果匹配多行，则file的内容将显示在所有匹配行的下面。

写入文件：w命令

$sed-n'/test/wfile'example-----在example中所有包含test的行都被写入file里。

追加命令：a命令

$sed'/^test/a\thisisaexample'example-----'thisisaexample'被追加到以test开头的行后面，sed要求命令a后面有一个反斜杠。

插入：i命令

sed'/test/i\abcde'example-------abcde 入到包含test的行的前面。

下一个：n命令

$sed'/test/{n;s/aa/bb/;}'example-----如果test被匹配，则移动到匹配行的下一行，替换这一行的aa，变为bb，并打印该行，然后继续。

变形：y命令

$sed'1,10y/abcde/ABCDE/'example-----把1--10行内所有abcde转变为大写，注意，正则表达式元字符不能使用这个命令。也就是说，被替换的字符串要与替换的字符串的长度相同。

退出：q命令

$sed'10q'example-----打印完第10行后，退出sed。

保持和获取：h命令和G命令

$sed-e'/test/h'-e'$G‘example----- 在sed处理文件的时候，每一行都被保存在一个叫模式空间的临时缓冲区中，除非行被删除或者输出被取消，否则所有被处理的行都将打印在屏幕上。接着模式空间被清空，并存入新的一行等待处理。在这个例子里，匹配test的行被找到后，将存入模式空间，h命令将其复制并存入一个称为保持缓存区的特殊缓冲区内。第二条语句的意思是，当到达最后一行后，G命令取出保持缓冲区的行，然后把它放回模式空间中，且追加到现在已经存在于模式空间中的行的末尾。在这个例子中就是追加到最后一行。简单来说，若使用的是H命令，则任何包含test的行都被复制并追加到该文件的末尾，若是h命令，则只有最后一个包含test的行被复制并追加到该文件的末尾。

保持和互换：h命令和x命令

$sed-e'/test/h'-e'/check/x'example-----互换模式空间和保持缓冲区的内容。也就是用前面包含test的行去替换包含check的行，而并不是互换两行。

7.脚本

Sed脚本是一个sed的命令清单，启动Sed时以-f选项引导脚本文件名。Sed对于脚本中输入的命令非常挑剔，在命令的末尾不能有任何空白或文本，如果在一行中有多个命令，要用分号分隔。以#开头的行为注释行，且不能跨行。

篇19：androidSDCard文件操作类FileHelper（超完整）

FileHelper.java类

packagecom.east.framework.file;

importjava.io.File;

importjava.io.FileInputStream;

importjava.io.FileOutputStream;

importjava.io.IOException;

importjava.io.InputStream;

importjava.io.OutputStream;

importandroid.content.Context;

importandroid.os.Environment;

importandroid.os.StatFs;

publicclassFileHelper {

privateContextcontext;

privateStringSDPATH;//SD卡路径

privateStringFILESPATH;//文件路径

publicFileHelper(Context context) {

this.context= context;

SDPATH= Environment.getExternalStorageDirectory.getPath() +”//“;

FILESPATH=this.context.getFilesDir().getPath() +”//“;

}

/**判断SDCard是否存在？是否可以进行读写*/

publicbooleanSDCardState(){

if(Environment.getExternalStorageState().equals(

Environment.MEDIA_MOUNTED)){//表示SDCard存在并且可以读写

returntrue;

}else{

returnfalse;

}

/**获取SDCard文件路径*/

publicString SDCardPath(){

if(SDCardState()){//如果SDCard存在并且可以读写

SDPATH= Environment.getExternalStorageDirectory().getPath();

returnSDPATH;

}else{

returnnull;

}

/**获取SDCard总容量大小(MB)*/

publiclongSDCardTotal(){

if(null!= SDCardPath()&&SDCardPath().equals(”“)){

StatFs statfs =newStatFs(SDCardPath());

//获取SDCard的Block总数

longtotalBlocks = statfs.getBlockCount();

//获取每个block的大小

longblockSize = statfs.getBlockSize();

//计算SDCard总容量大小MB

longSDtotalSize = totalBlocks*blockSize/1024/1024;

returnSDtotalSize;

}else{

return0;

}

/**

*在SD卡上创建目录

*@paramdirName

*要创建的目录名

*@return创建得到的目录

publicFile createSDDir(String dirName) {

File dir =newFile(SDPATH+ dirName);

dir.mkdir();

returndir;

}

/**

*删除SD卡上的目录

*@paramdirName

publicbooleandelSDDir(String dirName) {

File dir =newFile(SDPATH+ dirName);

returndelDir(dir);

}

/**

*在SD卡上创建文件

*@throwsIOException

publicFile createSDFile(String fileName)throwsIOException {

File file =newFile(SDPATH+ fileName);

file.createNewFile();

returnfile;

}

/**

*判断文件是否已经存在

*@paramfileName

*要检查的文件名

*@returnboolean, true表示存在，false表示不存在

publicbooleanisFileExist(String fileName) {

File file =newFile(SDPATH+ fileName);

returnfile.exists();

}

/**

*删除SD卡上的文件

*@paramfileName

publicbooleandelSDFile(String fileName) {

File file =newFile(SDPATH+ fileName);

if(file ==null|| !file.exists() || file.isDirectory())

returnfalse;

file.delete();

returntrue;

}

/**

*修改SD卡上的文件或目录名

*@paramfileName

publicbooleanrenameSDFile(String oldfileName, String newFileName) {

File leFile =newFile(SDPATH+ oldfileName);

File newFile =newFile(SDPATH+ newFileName);

returnoleFile.renameTo(newFile);

}

/**

*拷贝SD卡上的单个文件

*@parampath

*@throwsIOException

publicbooleancopySDFileTo(String srcFileName, String destFileName)

throwsIOException {

File srcFile =newFile(SDPATH+ srcFileName);

File destFile =newFile(SDPATH+ destFileName);

returncopyFileTo(srcFile, destFile);

}

/**

*拷贝SD卡上指定目录的所有文件

*@paramsrcDirName

*@paramdestDirName

*@return

*@throwsIOException

publicbooleancopySDFilesTo(String srcDirName, String destDirName)

throwsIOException {

File srcDir =newFile(SDPATH+ srcDirName);

File destDir =newFile(SDPATH+ destDirName);

returncopyFilesTo(srcDir, destDir);

}

/**

*移动SD卡上的单个文件

*@paramsrcFileName

*@paramdestFileName

*@return

*@throwsIOException

publicbooleanmoveSDFileTo(String srcFileName, String destFileName)

throwsIOException {

File srcFile =newFile(SDPATH+ srcFileName);

File destFile =newFile(SDPATH+ destFileName);

returnmoveFileTo(srcFile, destFile);

}

/**

*移动SD卡上的指定目录的所有文件

*@paramsrcDirName

*@paramdestDirName

*@return

*@throwsIOException

publicbooleanmoveSDFilesTo(String srcDirName, String destDirName)

throwsIOException {

File srcDir =newFile(SDPATH+ srcDirName);

File destDir =newFile(SDPATH+ destDirName);

returnmoveFilesTo(srcDir, destDir);

}

/**

*将文件写入sd卡，如:writeSDFile(”test.txt“);

publicOutput writeSDFile(String fileName)throwsIOException {

File file =newFile(SDPATH+ fileName);

FileOutputStream fos =newFileOutputStream(file);

returnnewOutput(fos);

}

/**

*在原有文件上继续写文件。如:appendSDFile(”test.txt“);

publicOutput appendSDFile(String fileName)throwsIOException {

File file =newFile(SDPATH+ fileName);

FileOutputStream fos =newFileOutputStream(file,true);

returnnewOutput(fos);

}

/**

*从SD卡读取文件。如:readSDFile(”test.txt“);

publicInput readSDFile(String fileName)throwsIOException {

File file =newFile(SDPATH+ fileName);

FileInputStream fis =newFileInputStream(file);

returnnewInput(fis);

}

/**

*建立私有文件

*@paramfileName

*@return

*@throwsIOException

publicFile creatDataFile(String fileName)throwsIOException {

File file =newFile(FILESPATH+ fileName);

file.createNewFile();

returnfile;

}

/**

*建立私有目录

*@paramdirName

*@return

publicFile creatDataDir(String dirName) {

File dir =newFile(FILESPATH+ dirName);

dir.mkdir();

returndir;

}

/**

*删除私有文件

*@paramfileName

*@return

publicbooleandelDataFile(String fileName) {

File file =newFile(FILESPATH+ fileName);

returndelFile(file);

}

/**

*删除私有目录

*@paramdirName

*@return

publicbooleandelDataDir(String dirName) {

File file =newFile(FILESPATH+ dirName);

returndelDir(file);

}

/**

*更改私有文件名

*@paramoldName

*@paramnewName

*@return

publicbooleanrenameDataFile(String oldName, String newName) {

File ldFile =newFile(FILESPATH+ oldName);

File newFile =newFile(FILESPATH+ newName);

returnoldFile.renameTo(newFile);

}

/**

*在私有目录下进行文件复制

*@paramsrcFileName

*：包含路径及文件名

*@paramdestFileName

*@return

*@throwsIOException

publicbooleancopyDataFileTo(String srcFileName, String destFileName)

throwsIOException {

File srcFile =newFile(FILESPATH+ srcFileName);

File destFile =newFile(FILESPATH+ destFileName);

returncopyFileTo(srcFile, destFile);

}

/**

*@paramsrcDirName

*@paramdestDirName

*@return

*@throwsIOException

publicbooleancopyDataFilesTo(String srcDirName, String destDirName)

throwsIOException {

File srcDir =newFile(FILESPATH+ srcDirName);

File destDir =newFile(FILESPATH+ destDirName);

returncopyFilesTo(srcDir, destDir);

}

/**

*移动私有目录下的单个文件

*@paramsrcFileName

*@paramdestFileName

*@return

*@throwsIOException

publicbooleanmoveDataFileTo(String srcFileName, String destFileName)

throwsIOException {

File srcFile =newFile(FILESPATH+ srcFileName);

File destFile =newFile(FILESPATH+ destFileName);

returnmoveFileTo(srcFile, destFile);

}

/**

*@paramsrcDirName

*@paramdestDirName

*@return

*@throwsIOException

publicbooleanmoveDataFilesTo(String srcDirName, String destDirName)

throwsIOException {

File srcDir =newFile(FILESPATH+ srcDirName);

File destDir =newFile(FILESPATH+ destDirName);

returnmoveFilesTo(srcDir, destDir);

}

/**

*将文件写入应用私有的files目录。如:writeFile(”test.txt“);

publicOutput wirteFile(String fileName)throwsIOException {

OutputStream s =context.openFileOutput(fileName,

Context.MODE_WORLD_WRITEABLE);

returnnewOutput(os);

}

/**

*在原有文件上继续写文件。如:appendFile(”test.txt“);

publicOutput appendFile(String fileName)throwsIOException {

OutputStream s =context.openFileOutput(fileName, Context.MODE_APPEND);

returnnewOutput(os);

}

/**

*从应用的私有目录files读取文件。如:readFile(”test.txt“);

publicInput readFile(String fileName)throwsIOException {

InputStream is =context.openFileInput(fileName);

returnnewInput(is);

}

/**

*将一个输入流中的内容写入到SD卡上生成文件

*@parampath

*文件目录

*@paramfileName

*文件名

*@paraminputStream

*字节输入流

*@return得到的文件

publicFile writeToSDCard(String path, String fileName,

InputStream inputStream) {

File file =null;

OutputStream utput =null;

try{

createSDDir(path);

file = createSDFile(path + fileName);

utput =newFileOutputStream(file);

bytebuffer [] =newbyte[4 * 1024];

while((inputStream.read(buffer)) != -1){

output.write(buffer);

}

output.flush();

}

catch(Exception e){

e.printStackTrace();

}

finally{

try{

output.close();

}

catch(Exception e){

e.printStackTrace();

}

returnfile;

}

/**

*删除一个文件

*@paramfile

*@return

publicbooleandelFile(File file) {

if(file.isDirectory())

returnfalse;

returnfile.delete();

}

/**

*@paramdir

publicbooleandelDir(File dir) {

if(dir ==null|| !dir.exists() || dir.isFile()) {

returnfalse;

}

for(File file : dir.listFiles()) {

if(file.isFile()) {

file.delete();

}elseif(file.isDirectory()) {

delDir(file);//递归

}

dir.delete();

returntrue;

}

/**

*拷贝一个文件,srcFile源文件，destFile目标文件

*@parampath

*@throwsIOException

publicbooleancopyFileTo(File srcFile, File destFile)throwsIOException {

if(srcFile.isDirectory() || destFile.isDirectory())

returnfalse;//判断是否是文件

FileInputStream fis =newFileInputStream(srcFile);

FileOutputStream fos =newFileOutputStream(destFile);

intreadLen = 0;

byte[] buf =newbyte[1024];

while((readLen = fis.read(buf)) != -1) {

fos.write(buf, 0, readLen);

}

fos.flush();

fos.close();

fis.close();

returntrue;

}

/**

*@paramsrcDir

*@paramdestDir

*@return

*@throwsIOException

publicbooleancopyFilesTo(File srcDir, File destDir)throwsIOException {

if(!srcDir.isDirectory() || !destDir.isDirectory())

returnfalse;//判断是否是目录

if(!destDir.exists())

returnfalse;//判断目标目录是否存在

File[] srcFiles = srcDir.listFiles();

for(inti = 0; i < srcFiles.length; i++) {

if(srcFiles[i].isFile()) {

//获得目标文件

File destFile =newFile(destDir.getPath() +”//“

+ srcFiles[i].getName());

copyFileTo(srcFiles[i], destFile);

}elseif(srcFiles[i].isDirectory()) {

File theDestDir =newFile(destDir.getPath() +”//“

+ srcFiles[i].getName());

copyFilesTo(srcFiles[i], theDestDir);

}

returntrue;

}

/**

*移动一个文件

*@paramsrcFile

*@paramdestFile

*@return

*@throwsIOException

publicbooleanmoveFileTo(File srcFile, File destFile)throwsIOException {

booleaniscopy = copyFileTo(srcFile, destFile);

if(!iscopy)

returnfalse;

delFile(srcFile);

returntrue;

}

/**

*@paramsrcDir

*@paramdestDir

*@return

*@throwsIOException

publicbooleanmoveFilesTo(File srcDir, File destDir)throwsIOException {

if(!srcDir.isDirectory() || !destDir.isDirectory()) {

returnfalse;

}

File[] srcDirFiles = srcDir.listFiles();

for(inti = 0; i < srcDirFiles.length; i++) {

if(srcDirFiles[i].isFile()) {

File neDestFile =newFile(destDir.getPath() +”//“

+ srcDirFiles[i].getName());

moveFileTo(srcDirFiles[i], oneDestFile);

delFile(srcDirFiles[i]);

}elseif(srcDirFiles[i].isDirectory()) {

File neDestFile =newFile(destDir.getPath() +”//“

+ srcDirFiles[i].getName());

moveFilesTo(srcDirFiles[i], oneDestFile);

delDir(srcDirFiles[i]);

}

returntrue;

}

Input.java帮助类

packagecom.sinous.framework.file;

importjava.io.ByteArrayOutputStream;

importjava.io.EOFException;

importjava.io.IOException;

importjava.io.InputStream;

importjava.io.UTFDataFormatException;

publicclassInputextendsInputStream {

privatestaticfinalintDEFAULT_BUFFER_SIZE= 1024;

privatebyte[]buf;

privateintpos;

privateintcount;

privateInputStreamin;

publicInput(InputStream in) {

this(in,DEFAULT_BUFFER_SIZE);

}

publicInput(InputStream in,intbufferSize) {

this.in= in;

buf=newbyte[bufferSize];

}

publicvoidclose()throwsIOException {

buf=null;

in.close();

}

publicintread()throwsIOException {

if(pos>=count||pos>=buf.length) {

pos= 0;

count=in.read(buf, 0,DEFAULT_BUFFER_SIZE);

}

if(pos>=count) {

return-1;

}

returnbuf[pos++] & 0xff;

}

publicintread(byte[] b)throwsIOException {

returnread(b, 0, b.length);

}

publicintread(byte[] b,intoff,intlen)throwsIOException {

intremain =count-pos;

if(remain >= (len - off)) {

System.arraycopy(buf,pos, b, off, len);

pos+= len;

returnlen;

}else{

if(remain >0) {

System.arraycopy(buf,pos, b, off, remain);

pos+= remain;

intnewRemain = len - remain;

byte[] remainData =newbyte[newRemain];

intrd =in.read(remainData, 0, newRemain);

System.arraycopy(remainData, 0, b, off + remain, rd);

returnremain + rd;

}else{

intrd =in.read(b, off, len);

returnrd;

}

publicbooleanreadBoolean()throwsIOException {

intch = read();

if(ch < 0) {

thrownewEOFException();

}

return(ch != 0);

}

publicintreadUnsignedByte()throwsIOException {

intch = read();

if(ch < 0) {

thrownewEOFException();

}

returnch;

}

publicintreadUnsignedShort()throwsIOException {

intch1 = read();

intch2 = read();

if((ch1 | ch2) < 0) {

thrownewEOFException();

}

return(ch1 << 8) + (ch2 << 0);

}

publicshortreadShort()throwsIOException {

intch1 = read();

intch2 = read();

if((ch1 | ch2) < 0) {

thrownewEOFException();

}

return(short) ((ch1 << 8) + (ch2 << 0));

}

publiccharreadChar()throwsIOException {

intch1 = read();

intch2 = read();

if((ch1 | ch2) < 0) {

thrownewEOFException();

}

return(char) ((ch1 << 8) + (ch2 << 0));

}

publicintreadInt()throwsIOException {

intch1 = read();

intch2 = read();

intch3 = read();

intch4 = read();

if((ch1 | ch2 | ch3 | ch4) < 0) {

thrownewEOFException();

}

return((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));

}

publiclongreadLong()throwsIOException {

return((long) (readInt()) << 32) + (readInt() & 0xFFFFFFFFL);

}

publicfloatreadFloat()throwsIOException {

returnFloat.intBitsToFloat(readInt());

}

publicdoublereadDouble()throwsIOException {

returnDouble.longBitsToDouble(readLong());

}

publicString readUTF8()throwsIOException {

intutflen = readUnsignedShort();

if(utflen <= 0) {

return”“;

}

charstr[] =newchar[utflen];

bytebytearr[] =newbyte[utflen];

intc, char2, char3;

intcount = 0;

intstrlen = 0;

read(bytearr);

while(count < utflen) {

c = (int) bytearr[count] & 0xff;

switch(c >>4) {

case0:

case1:

case2:

case3:

case4:

case5:

case6:

case7:

/* 0xxxxxxx */

count++;

str[strlen++] = (char) c;

break;

case12:

case13:

/* 110xxxxx10xxxxxx*/

count += 2;

if(count >utflen) {

thrownewUTFDataFormatException();

}

char2 = (int) bytearr[count - 1];

if((char2 & 0xC0) != 0x80) {

thrownewUTFDataFormatException();

}

str[strlen++] = (char) (((c & 0x1F) << 6) | (char2 & 0x3F));

break;

case14:

/* 1110xxxx10xxxxxx10xxxxxx*/

count += 3;

if(count >utflen) {

thrownewUTFDataFormatException();

}

char2 = (int) bytearr[count - 2];

char3 = (int) bytearr[count - 1];

if(((char2 & 0xC0) != 0x80) || ((char3 & 0xC0) != 0x80)) {

thrownewUTFDataFormatException();

}

str[strlen++] = (char) (((c & 0x0F) << 12)

| ((char2 & 0x3F) << 6) | ((char3 & 0x3F) << 0));

break;

default:

/* 10xxxxxx, 1111xxxx*/

thrownewUTFDataFormatException();

}

// The number of chars produced may be less thanutflen

returnnewString(str, 0, strlen);

}

publicSerializable readSerializable()throwsIOException {

String className = readUTF8();

Serializable serializable =null;

try{

serializable = (Serializable) Class.forName(className).newInstance();

serializable.deserialize(this);

}catch(Exception e) {

thrownewIOException(e.toString());

}

returnserializable;

}

publicbyte[] readAll()throwsIOException {

ByteArrayOutputStream baos =newByteArrayOutputStream();

intch;

byte[] buffer =newbyte[1024];

while((ch =in.read(buffer)) != -1) {

baos.write(buffer, 0, ch);

}

byte[] ret = baos.toByteArray();

baos.close();

returnret;

}

Output.java帮助类

packagecom.sinous.framework.file;

importjava.io.IOException;

importjava.io.OutputStream;

importjava.io.UTFDataFormatException;

publicclassOutputextendsOutputStream {

privatestaticfinalintDEFAULT_BUFFER_SIZE= 1024;

privatebyte[]buf;

privateintcount;

privateOutputStreamout;

publicOutput(OutputStream out) {

this(out,DEFAULT_BUFFER_SIZE);

}

publicOutput(OutputStream out,intbufferSize) {

this.out= out;

buf=newbyte[bufferSize];

}

privatevoidflushBuffer()throwsIOException {

if(count>0) {

out.write(buf, 0,count);

count= 0;

}

publicvoidflush()throwsIOException {

flushBuffer();

out.flush();

}

publicvoidclose()throwsIOException {

flush();

buf=null;

out.close();

}

publicvoidwrite(intb)throwsIOException{

if(count>=buf.length) {

flushBuffer();

}

buf[count++] = (byte) b;

}

publicvoidwrite(byte[] b)throwsIOException {

write(b, 0, b.length);

}

publicvoidwrite(byte[] b,intoff,intlen)throwsIOException {

if(len >=buf.length) {

flushBuffer();

out.write(b, off, len);

return;

}elseif(len >buf.length-count) {

flushBuffer();

}

System.arraycopy(b, off,buf,count, len);

count+= len;

}

publicvoidwriteBoolean(booleanv)throwsIOException {

write(v ? 1 : 0);

}

publicvoidwriteShort(intv)throwsIOException {

write((v >>>8) & 0xFF);

write(v & 0xFF);

}

publicvoidwriteChar(intv)throwsIOException {

write((v >>>8) & 0xFF);

write(v & 0xFF);

}

publicvoidwriteInt(intv)throwsIOException {

write((v >>>24) & 0xFF);

write((v >>>16) & 0xFF);

write((v >>>8) & 0xFF);

write(v & 0xFF);

}

publicvoidwriteLong(longv)throwsIOException {

write((int) (v >>>56) & 0xFF);

write((int) (v >>>48) & 0xFF);

write((int) (v >>>40) & 0xFF);

write((int) (v >>>32) & 0xFF);

write((int) (v >>>24) & 0xFF);

write((int) (v >>>16) & 0xFF);

write((int) (v >>>8) & 0xFF);

write((int) v & 0xFF);

}

publicvoidwriteFloat(floatv)throwsIOException {

writeInt(Float.floatToIntBits(v));

}

publicvoidwriteDouble(doublev)throwsIOException {

writeLong(Double.doubleToLongBits(v));

}

publicvoidwriteUTF8(String str)throwsIOException {

if(str ==null) {

str =”";

}

intstrlen = str.length();

intutflen = 0;

char[] charr =newchar[strlen];

intc, count = 0;

str.getChars(0, strlen, charr, 0);

for(inti = 0; i < strlen; i++) {

c = charr[i];

if((c >= 0x0001) && (c <= 0x007F)) {

utflen++;

}elseif(c >0x07FF) {

utflen += 3;

}else{

utflen += 2;

}

if(utflen >65535) {

thrownewUTFDataFormatException();

}

byte[] bytearr =newbyte[utflen + 2];

bytearr[count++] = (byte) ((utflen >>>8) & 0xFF);

bytearr[count++] = (byte) ((utflen >>>0) & 0xFF);

for(inti = 0; i < strlen; i++) {

c = charr[i];

if((c >= 0x0001) && (c <= 0x007F)) {

bytearr[count++] = (byte) c;

}elseif(c >0x07FF) {

bytearr[count++] = (byte) (0xE0 | ((c >>12) & 0x0F));

bytearr[count++] = (byte) (0x80 | ((c >>6) & 0x3F));

bytearr[count++] = (byte) (0x80 | ((c >>0) & 0x3F));

}else{

bytearr[count++] = (byte) (0xC0 | ((c >>6) & 0x1F));

bytearr[count++] = (byte) (0x80 | ((c >>0) & 0x3F));

}

write(bytearr);

}

publicvoidwriteSerializable(Serializable serializable)throwsIOException {

writeUTF8(serializable.getClass().getName());

serializable.serialize(this);

}

Serializable.java序列化接口

packagecom.sinous.framework.file;

importjava.io.IOException;

publicinterfaceSerializable{

publicvoidserialize(Output out)throwsIOException;

publicvoiddeserialize(Input in)throwsIOException;

}

篇20：《表格操作》教案

《表格操作》教案

《表格操作》教案一、教学目标 1、知识目标了解表格各组成部分概念；了解“设计”和“布局”选项卡；掌握在Word2007中插入或删除表格；掌握插入或删除单元格、行、列；掌握拆分或合并单元格 2、过程与方法（1）通过教师的讲解让学生了解表格的一些基础知识。（2）通过演示讲解让学生熟悉表格的基本操作。（3）通过学生自主练习，同学间合作探究等方法，促进学生初步学会制作简单的履历表。 3、情感态度与价值观（1）认真看教师演示培养学生听课能力，提高学生记忆力。（2）学生自主练习提高学生解决问题，分析问题的能力。（3）学生完成任务能给学生自身带来成就感，学习积极性相应提高。（4）培养学生严谨的思维习惯，激发学习热情。（5）培养学生良好的审美观，在设置美化表格的同时，发现美，创造美。二、教学重难点 1、教学重点 “设计”和“布局”选项卡；插入或删除单元格、行、列；拆分或合并单元格 2、教学难点插入或删除单元格、行、列；拆分或合并单元格三、教学方法和手段讲解法：通过教师的讲解，使学生对表格的相关基本知识有所了解，帮助学生理解记忆，巩固知识。演示法：教师的演示帮助学生把系统的理论知识形象化，具体化，在观看教师的演示的过程中，学生对表格中具体的基本操作做了一定的记忆与理解，自己动手起来也就更加得心应手了。任务驱动法：学生光光观看教师的演示是远远不够的，计算机应用基础就是一门应用的课程，要学会学以致用。经过前面教师的讲解与演示，学生再加以自己动手操作，巩固起来就容易多了。学生带着任务操作练习，通过和学生讨论，向教师请教等方法，只要认真实验，掌握本节课内容并不难。四、教学过程 1、教学引入：自荐书是求职者的告白，表达了求职者的求职意愿，而个人简历则是求职过程中不可或缺的，它反映了求职人员的基本情况和能力，是应聘方决定是否聘用的重要依据。小丫深知个人简历的重要性，因此在完成自荐书后，马上开始用Word2007中的表格功能制作个人简历。我们看看她是怎么制作个人简历的.。 2、新课讲授：制作简历之前，我们先来学习一下表格的基本组成要素。表格最基本的单位是单元格，若干个单元格构成了表格的行和列。我们可以看书本P134图5-22.（移动控点、缩放控点、合并后的单元格）。【几句话带过，不做详细介绍，穿插在练习中讲解。】接下来，我们再来认识一下表格制作家族中两位关键成员――“设计”和“布局”选项卡。【通过讲解让学生了解这些按钮组件的功能和位置，以便学生设置制作时快速找到。】好，我们现在就来实践一下，制作一份个人简历：步骤1、新建空白文档步骤2、插入空白表格步骤3、编辑表格（1）输入表格的基本信息（2）合并部分单元格（3）拆分部分单元格（4）插入标题行和内容行 3、学生练习游戏：大家来找茬（对照值日表成品，找出两者的不同点，并将值日表初稿修整成成品的模样。）游戏：大家来找茬星期一星期二星期三星期四星期五单周扫教室蒋柔怡章伶冯依妮林寥寥张佳佳陈巧玲杨珊珊陆琳琦彭贵华王雨微单周拖地郭雅倩王美巧林瑶瑶林康康王茹陈灵红蔡丽丽林婉晓程雨涵陈雨微单周黑板垃圾毛威林潘玲佳王静意杨涵钧厉芷含单周走廊瓷砖刘颖楠赵顺华蔡盼盼金煜璐王希S 林沅静王蒙萨双周扫教室拖地黑板垃圾走廊瓷砖詹玲希毛晶晶陈伟梦周慧琪王玲玲胡晓媛项婷媚颜莎莎陈思雨杨茜国张宁宁张丁蔺王雅贝郑晗琪刘佳乐林温馨张升王晨雅童贤微汪爱妮应佳丁骊遐李仙聪夏天琪郑佳敏阮梦柳王碧鸿王竞瑶丁云豪翁佳琦赵露依陈诗琦【涉及知识：合并单元格、拆分单元格、插入标题行、删除行】【教师巡查，释疑】 4、学生上交作业，教师抽查点评。 5、课堂小结

【教案：文件的操作】相关文章：

1.python操作xml文件示例

2.《表格操作》教案

3.Perl小技巧：文件操作自动测试脚本语言

4.python中os操作文件及文件路径实例

9.计算机等级考试二级VB考点：常用文件操作语句和函数

10.文件范本