https://www.cnblogs.com/pengwangguoyh/articles/3223072.html
 
1)文本文件：这类文件以文本的ASCII码形式存储在计算机中。它是以"行"为基本结构的一种信息组织和存储方式。 
 2)二进制文件：这类文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它们，只有通过相应的软件才能将其显示出来。二进制文件一般是可执行程序、图形、图像、声音等等。
 
 
 
C++标准库提供了基于输入/输出流机制的文件操作，叫做文件流(File Stream)。打开文件的时候，可以用参数制定按照二进制方式还是文本方式。
 
然而，可能与你的想象不同的是，这里的二进制或者文本与文件的格式并没有任何关系，而是文件流操作时对数据的表达方式。
 
文本方式和二进制方式的最大区别在于文本方式对于'\n'换行符的理解不同，在DOS平台下，该字符会被展开成<CR>< LF>两个控制字符(相当于"\r\n")，在ASCII字符集下是0DH,0AH，而在UNIX平台下，仅仅是<LF>，不会展开。而在二进制方式下，不管是什么平台，'\n'都是精确的<LF>。
 
而类似于一个数学上的数字128，会在文件中以什么样的格式存储，是以数字形式存储(80H)，还是对应的可读文本('1','2','8')，却和文件流的打开方式无关。
 
在C++的文件流中，使用的术语叫做格式化输入输出操作和无格式化操作，前者也就是<<和>>运算符，将数字按照可读文本存储，后者是get/put成员函数，直接存储数字格式。
 
 
 
一、文本文件与二进制文件的定义
 
    大家都知道计算机的存储在物理上是二进制的，所以文本文件与二进制文件的区别并不是物理上的，而是逻辑上的。这两者只是在编码层次上有差异。简单来说，文本文件是基于字符编码的文件，常见的编码有ASCII编码，UNICODE编码等等。二进制文件是基于值编码的文件，你可以根据具体应用，指定某个值是什么意思（这样一个过程，可以看作是自定义编码。
 
    从上面可以看出文本文件基本上是定长编码的(也有非定长的编码如UTF-8)。而二进制文件可看成是变长编码的，因为是值编码嘛，多少个比特代表一个值，完全由你决定。大家可能对BMP文件比较熟悉，就拿它举例子吧，其头部是较为固定长度的文件头信息，前2字节用来记录文件为BMP格式，接下来的8个字节用来记录文件长度，再接下来的4字节用来记录bmp文件头的长度。
 
二、文本文件与二进制文件的存取  
 
　　文本工具打开一个文件的过程是怎样的呢？拿记事本来说，它首先读取文件物理上所对应的二进制比特流，然后按照你所选择的解码方式来解释这个流，然后将解释结果显示出来。一般来说，你选取的解码方式会是ASCII码形式（ASCII码的一个字符是８个比特），接下来，它8个比特8个比特地来解释这个文件流。例如对于这么一个文件流"01000000_01000001_01000010_01000011"(下划线''_''，为了增强可读性手动添加的)，第一个8比特''01000000''按ASCII码来解码的话，所对应的字符是字符''A''，同理其它3个8比特可分别解码为''BCD''，即这个文件流可解释成“ABCD”，然后记事本就将这个“ABCD”显示在屏幕上。
 
    事实上，世界上任何东西要与其他东西通信会话，都存在一个既定的协议，既定的编码。人与人之间通过文字联络，汉字“妈”代表生你的那个人，这就是一种既定的编码。但注意到这样一种情况，汉字“妈”在日本文字里有可能是你生下的那个人，所以当一个中国人Ａ与日本Ｂ之间用“妈”这个字进行交流，出现误解就很正常的。用记事本打开二进制文件与上面的情况类似。记事本无论打开什么文件都按既定的字符编码工作（如ASCII码），所以当他打开二进制文件时，出现乱码也是很必然的一件事情了，解码和译码不对应嘛。例如文件流''00000000_00000000_00000000_00000001''可能在二进制文件中对应的是一个四字节的整数int 1，在记事本里解释就变成了"NULL_NULL_NULL_SOH"这四个控制符。
 
    文本文件的存储与其读取基本上是个逆过程。而二进制文件的存取显然与文本文件的存取差不多，只是编／解码方式不同而已，也不再叙述。
 
三、文本文件与二进制文件的优缺点
 
    因为文本文件与二进制文件的区别仅仅是编码上不同，所以他们的优缺点就是编码的优缺点，这个找本编码的书来看看就比较清楚了。一般认为，文本文件编码基于字符定长，译码容易些；二进制文件编码是变长的，所以它灵活，存储利用率要高些，译码难一些（不同的二进制文件格式，有不同的译码方式）。关于空间利用率，想想看，二进制文件甚至可以用一个比特来代表一个意思(位操作)，而文本文件任何一个意思至少是一个字符．
 
    在windows下,文本文件不一定是一ASCII来存贮的,因为ASCII码只能表示128的标识,你打开一个txt文档,然后另存为,有个选项是编码,可以选择存贮格式,一般来说UTF-8编码格式兼容性要好一些.而二进制用的计算机原始语言,不存贮兼容性.    很多书上还认为，文本文件的可读性要好些，存储要花费转换时间(读写要编译码)，而二进制文件可读性差，存储不存在转换时间（读写不要编解码，直接写值）．这里的可读性是从软件使用者角度来说的，因为我们用通用的记事本工具就几乎可以浏览所有文本文件，所以说文本文件可读性好；而读写一个具体的二进制文件需要一个具体的文件解码器，所以说二进制文件可读性差，比如读BMP文件，必须用读图软件．
 
    而这里的存储转换时间应该是从编程的角度来说的，因为有些操作系统如windows需要对回车换行符进行转换(将''\n''，换成''\r\n''，所以文件读写时，操作系统需要一个一个字符的检查当前字符是不是''\n''或''\r\n'').这个在存储转换在Linux操作系统中并不需要，当然，当在两个不同的操作系统上共享文件时，这种存储转换又可能出来(如Linux系统和Windows系统共享文本文件)。关于这个转换怎样进行，我将在下一篇文章《Linux文本文件与Windows文本文件间的转换》给出^_^
 
四、Ｃ的文本读写和二进制读写
 
    应该说Ｃ的文本读写与二进制的读写是一个编程层次上的问题，与具体的操作系统有关，所以＂用文本方式读写的文件一定是文本文件，用二进制读写的文件一定是二进制文件"这类观点是错误的．下面的讲述非明确指出操作系统类型，都暗指windows．
 
    Ｃ的文本方读写与二进制读写的差别仅仅体现在回车换行符的处理上．文本方式写时，每遇到一个''\n''(0AH换行符)，它将其换成''\r\n''(0D0AH，回车换行)，然后再写入文件；当文本读取时，它每遇到一个''\r\n''将其反变化为''\n''，然后送到读缓冲区．正因为文本方式有''\n''－－''\r\n''之间的转换，其存在转换耗时．二进制读写时，其不存在任何转换，直接将写缓冲区中数据写入文件．
 
    总地来说，从编程的角度来说，Ｃ中文本或二进制读写都是缓冲区与文件中二进制流的交互，只是文本读写时有回车换行的转换．所以当写缓冲区中无换行符''\n''(0AH)，文本写与二进制写的结果是一样的，同理，当文件中不存在''\r\n''(0DH0AH)时，文本读与二进制读的结果一样．
 
五、实例
 
Ｃ的文本读写和二进制读写     应该说Ｃ的文本读写与二进制的读写是一个编程层次上的问题，与具体的操作系统有关，所以＂用文本方式读写的文件一定是文本文件，用二进制读写的文件一定是二进制文件"这类观点是错误的．下面的讲述非明确指出操作系统类型，都暗指windows．
 
    Ｃ的文本方读写与二进制读写的差别仅仅体现在回车换行符的处理上．文本方式写时，每遇到一个''\n''(0AH换行符)，它将其换成''\r \n''(0D0AH，回车换行)，然后再写入文件；当文本读取时，它每遇到一个''\r\n''将其反变化为''\n''，然后送到读缓冲区．二进制读写时，其不存在任何转换，直接将写缓冲区中数据写入文件．对于内容为 “Ab123\r\n" (41 62 31 32 33 0D 0A)的文件,
 
 
 
pf1 = fopen("f:\\1.txt","r");// 或者pf1 = fopen("f:\\1.txt","rb");
for(int i=0;i <6;i++)
{
   fread(&a[i],1,1,pf1);
   printf("%0X ",a[i]);
}
fclose(pf1);//关闭文件
 
 
 
 
 
 
 
的结果分别为： 41 62 31 32 33 0A          和     41 62 31 32 33 0D  5678的存储形式为：ASCII码：   　00110101   00110110   00110111   00111000  （四个字节） 5678的存储形式为：二进制：      00010110   00101110  （两个字节） 二进制文件和文本文件的唯一差异就是前者含有一些非标准输出的ASCII码。0x01就是非标准输出的ASCII码，
 
0x61就是标准输出的ASCII码。）
 
 
 
 
 
 
 
一. 基本知识：
 --------------------------------------------------转----------------------------------------------------
1. 二进制文件与文本文件的区别：
 将文件看作是由一个一个字节(byte) 组成的， 那么文本文件中的每个字节的最高位都是0，也就是说文本文件使用了一个字节中的七位来表示所有的信息，而二进制文件则是将字节中的所有位都用上了。这就是两者的区别；接着，第二个问题就是文件按照文本方式或者二进制方式打开，两者会有什么不同呢？其实不管是二进制文件也好，还是文本文件也好，都是一连串的0和1，但是打开方式不同，对于这些0和1的处理也就不同。如果按照文本方式打开，在打开的时候会进行translate，将每个字节转换成ASCII码，而以按照二进制方式打开的话，则不会进行任何的translate；最后就是文本文件和二进制文件在编辑的时候，使用的方式也是不同的。譬如，你在记事本中进行文本编辑的时候，你进行编辑的最小单位是字节(byte)；而对二进制文件进行编辑的话，最小单位则是位(bit)，当然我们都不会直接通过手工的方式对二进制文件进行编辑了。

 从文件编码的方式来看，文件可分为ASCII码文件和二进制码文件两种：
 ASCII文件也称为文本文件，这种文件在磁盘中存放时每个字符对应一个字节，用于存放对应的ASCII码。例如，数5678的存储形式为： 
 ASCII码：　00110101 00110110 00110111 00111000 
 ↓ 　↓ 　 　　　↓ 　　↓
 十进制码： 5　　　　　6　 　7　 　 　　8 

 共占用4个字节。ASCII码文件可在屏幕上按字符显示，例如源程序文件就是ASCII文件，用DOS命令TYPE可显示文件的内容。由于是按字符显示，因此能读懂文件内容。

 二进制文件是按二进制的编码方式来存放文件的。例如，数5678的存储形式为：00010110 00101110 只占二个字节。二进制文件虽然也可在屏幕上显示，但其内容无法读懂。C系统在处理这些文件时，并不区分类型，都看成是字符流，按字节进行处理。输入输出字符流的开始和结束只由程序控制而不受物理符号(如回车符)的控制。因此也把这种文件称作“流式文件”。 

2. 文本模式(textmode)和二进制模式(binarymode)有什么区别? 

 流可以分为两种类型：文本流和二进制流。文本流是解释性的，最长可达255个字符，其中回车/换行将被转换为换行符“\n”，（如果以"文本"方式打开一个文件，那么在读字符的时候，系统会把所有的"\r\n"序列转成"\n"，在写入时把"\n"转成"\r\n" ）。二进制流是非解释性的，一次处理一个字符，并且不转换字符。

 注：
 
 
 
\n一般会操作系统被翻译成"行的结束"，即LF(Line-Feed)
 \r会被翻译成"回车"，即CR(Cariage-Return)
 对于文本文件的新行，在UNIX上，一般用\n(LF)来表示，Mac上用\r(CR)来表示，
 Windows上是用\n\r(CR-LF)来表示。 

 通常，文本流用来读写标准的文本文件，或者将字符输出到屏幕或打印机，或者接受键盘的输入；而二进制流用来读写二进制文件(例如图形或字处理文档)，或者读取鼠标输入，或者读写调制解调器。如果用文本方式打开二进制文件，会把“0D 0A”自动变换成“\n”来存在内存中。写入的时候反向处理。而二进制方式打开的话，就不会有这个过程。但是，Unicode/UTF/UCS格式的文件，必须用二进制方式打开和读写。
 
 
 
---------------------------------------------------------------------------------------------------------

 上述基础其实大可以略过，简言之，对用户来说：在 matlab 中存储成为二进制还是文本文件取决于fopen的方式，如果用wt，则存储为文本文件，这样用记事本打开就可以正常显示了；如果用w则存储为二进制文件，这样用记事本打开会出现小黑方块，要正常显示的话，可以用写字板或UltraEdit等工具打开。

二. Matlab的I/O文件操作使用技巧和总结:

1. Matlab 支持的I/O文件（对应“取/存”操作）类型：（所有文件I/O程序不需要特殊的工具箱）
http://www.mathworks.com/support/tech-notes/1100/1102.html

 （注：从上表可以看到，matlab不支持doc格式的文档存取（因为doc文档包含很多格式控制符），请改用txt或者dat格式）

2. Matlab 的I/O文件指南：
http://www.mathworks.com/support/tech-notes/1600/1602.html


 以下是部分对应的中文译文：
 --------------------------------------------------------------转----------------------------------------
 本技术支持指南主要处理：ASCII, binary, and MAT files.
 要得到MATLAB中可用来读写各种文件格式的完全函数列表，可以键入以下命令：
 help iofun

MATLAB中有两种文件I/O程序：high level and low level.
High level routines: 包括现成的函数，可以用来读写特殊格式的数据，并且只需要少量的编程。
Low level routines: 可以更加灵活的完成相对特殊的任务，需要较多的额外编程。
  
 
High level routines 包括现成的函数，可以用来读写特殊格式的数据，并且只需要少量的编程。
 
举个例子，如果你有一个包含数值和字母的文本文件（text file）想导入MATLAB，你可以调用一些low level routines自己写一个函数，或者是简单的用TEXTREAD函数。
 
使用high level routines的关键是：文件必须是相似的（homogeneous），换句话说，文件必须有一致的格式。下面的段落描述一些high level file I/O routines并给出一些例子帮助理解概念。
 
LOAD/SAVE
 
主要的high level file I/O routines 是LOAD 和 SAVE函数。LOAD
 可以读MAT-file data或者用空格间隔的格式相似的ASCII data. SAVE可以将MATLAB变量写入MAT-file格式或者空格间隔的ASCII data。大多数情况下，语法相当简单。下面的例子用到数值由空格间隔的ASCII file sample_file.txt ：
 
1 5 4 16 8
 
5 43 2 6 8
 
6 8 4 32 1
 
90 7 8 7 6
 
5 9 81 2 3
 
 
 
 
 
 
 
Example:
 用 LOAD and SAVE 读写数据
 
 
 

 CODE:
 % Load the file to the matrix, M :
 M = load('sample_file.txt') 
 % Add 5 to M :
 M = M +5 
 % Save M to a .mat file called 'sample_file_plus5.mat':
 save sample_file_plus5 M

 % Save M to an ASCII .txt file called 'sample_file_plus5.txt' :
 save sample_file_plus5.txt M -ascii 


  
 
 
 
UIGETFILE/UIPUTFILE
 
 
 
 
 
 
 
UIGETFILE/UIPUTFILE是基于图形用户界面（GUI）的。会弹出对话框，列出当前目录的文件和目录，提示你选择一个文件。UIGETFILE让你选择一个文件来写（类似Windows ‘另存为’选项？）。用UIGETFILE，可以选择已存在的文件改写，也可以输入新的文件名。两个函数的返回值是所选文件名和路径。
 
 
 
 
 
 
 
Example:
 用 UIGETFILE 从当前目录选择一个 M-file
 
 
 
 
 
 
 

 CODE:
 % This command lists all the M-files in the current directory and
 % returns the name and path of the selected file
 [fname,pname] = uigetfile('*.m','Sample Dialog Box') 
  
 
 
 
注意: UIGETFILE 一次只能选择一个文件。
 
 
 
 
 
 
 
UIIMPORT/IMPORTDATA
 
 
 
 
 
 
 
UIIMPORT是一个功能强大，易于使用的基于GUI的high level routine，用于读complex data files。文件也必须是homogeneous。
 
 
 
 
 
 
 
IMPORTDATA形成UIIMPORT的功能，不打开GUI。可以将IMPORTDATA用于函数或者脚本中，因为在函数或者脚本中基于GUI的文件导入机制并不理想。下面的例子用到包含几行文件头和文本、数值数据的文件'sample_file2.txt' ：
 
 
 
 
 
 
 
This is a file header.
 
 
 
 
 
 
 
This is file is an example.
 
 
 
 
 
 
 
col1 col2 col3 col4
 
 
 
 
 
 
 
A 1 4 612.000
 
 
 
 
 
 
 
B 1 4 613.000
 
 
 
 
 
 
 
C 1 4 614.000
 
 
 
 
 
 
 
D 1 4 615.000
 
 
 
 
 
 
 
Example: Using IMPORTDATA to read in a file with headers, text, and numeric data
 
 
 
 
 
 
 

 CODE:

 % This reads in the file 'sample_file2.txt' and creates a
 % structure D that contains both data and text data.
 % Note the IMPORTDATA command specifies a white space 
 % as the delimiter of the file, but IMPORTDATA can usually 
 % detect this on its own 

 D = importdata('sample_file2.txt','') % 原文有误？

 D = importdata('sample_file2.txt')

  
 
 
 
 
 
 
 
可以通过访问结构D的数据和文本域，来看结构D中的真实值，例如输入：
 
 
 
 
 
 
 
data = D.data
 
 
 
 
 
 
 
text = D.textdata
 
 
 
 
 
 
 
可以用UIIMPORT读同一个文件并得到同样的结构.
 
 
 
 
 
 
 
注意: 对于 ASCII data, 你必须检验导入向导正确的识别了列分隔符。
 
 
 
 
 
 
 
TEXTREAD/STRREAD
 
 
 
 
 
 
 
TEXTREAD 是一个强大的动态high level routine，设计用来读ASCII格式的文本和/或数值数据文件。STRREAD除是从字符串而不是文件读以外，类似于TEXTREAD。
 
 
 
 
 
 
 
两个函数可以用许多参数来改变其具体的工作方式，他们返回读入指定输出的数据。他们有效的提供给你一个
 “两全其美”的方法，因为他们可以用一个命令读入混合的ASCII和数值数据（high level routines的做法），并且你可以改变他们以匹配你特定的应用（如同low level routines做到的）。例子：
 
 
 
 
 
 
 

 CODE:

 Example 1: Using TEXTREAD to read in an entire file into a cell array
 % This command reads in the file fft.m into the cell array, file 
 file = textread('fft.m','%s','delimiter','\n','whitespace',''); 
 CODE:

 Example 2: Using STRREAD to read the words in a line
 % This command uses the cell array created in Example 1 to 
 % read in each word of line 28 in 'file' to a cell array, words
 words = strread(file{28},'%s','delimiter','')
 
 
 

 CODE:

 Example 3: Using TEXTREAD to read in text and numeric data from a file with headers

 % This command skips the 2 header lines at the top of the file
 % and reads in each column to the 4 specified outputs
 [c1 c2 c3 c4] = textread('sample_file2.txt','%s %s %s %s','headerlines',2)
 
 
 
CODE:

 Example 4: Using TEXTREAD to read in specific rows of text and numeric data from a file

 % This command reads in rows B and C of the file. The 'headerlines'
 % property is used to move down to the desired starting row and the 
 % read operation is performed 2 times 

 [c1 c2 c3 c4] = textread('sample_file2.txt',... 
 '%s %s %s %s',2,'headerlines',4) 



 CODE:

 Example 5: Using TEXTREAD to read in only the numeric data from a file containing text and numbers

 % This command reads in only the numeric data in the file. The
 % 'headerlines' property is used to move down to the first row 
 % of interest and the first column of text is ignored with the 
 % '*' operator 

 [c2 c3 c4] = textread('sample_file2.txt','%*s %d %d %f','headerlines',3) 

  
 
 
 
 
 
 
 
DLMREAD/DLMWRITE/CSVREAD
 
 
 
 
 
 
 
DLMREAD 和 DLMWRITE函数能够读写分隔的ASCII data，而不是用low level routines。他们比low level routines容易使用，Low level routines用几行代码实现的功能可以用DLMREAD/DLMWRITE简化成一行。
 
 
 
 
 
 
 
CSVREAD用来读分隔符是逗号的文件，是DLMREAD的特殊情况。当读空格和Tab分隔的电子数据表文件时，DLMREAD特别有用。以'sample_file.txt'为例：
 
 
 
 
 
 
 
 
 
 
 

 CODE:

 Example 1: Using DLMREAD to read in a file with headers, text, and numeric data

 % This reads in the file 'sample_file2.txt' and creates a matrix, D,
 % with the numeric data this command specifies a white space as the
 % delimiter of the file 

 D = dlmread('sample_file.txt','') 






 CODE:

 Example 2: Using DLMREAD to extract the first 3 columns of the last 3 rows

 % This reads in the first 3 columns of the last 3 rows of
 % the data file 'sample_file.txt'into the matrix, D_partial.
 % 读文件 'sample_file.txt' 前3列后3行，到矩阵D_partial.

 D_partial = dlmread('sample_file.txt','',[2 0 4 2]) 






 CODE:

 Example 3: Using DLMWRITE to write a comma delimited file

 % This creates a file called 'partialD.txt' that consists of 
 % the first 3 columns of the last 3 rows of data where each
 % element is separated by a comma 

 dlmwrite('partialD.txt',D_partial,',') 


  
 
 
 
注意: 保证DLMREAD and DLMWRITE指定范围的指标从0开始，而不是从1开始。
 
 
 
 
 
 
 
WK1READ/WK1WRITE
 
 
 
 
 
 
 
WK1READ 用来读Lotus123 电子数据表文件的数据；WK1WRITE用来写矩阵到Lotus123 电子数据表文件。
 
 
 
 
 
 
 
XLSREAD
 
 
 
 
 
 
 
XLSREAD用来读Excel的数值和文本数据。
 
 
 

 ---------------------------------------------------------------------------------------------------------

三. 具体例子分析：
 Matlab网站用两个例子非常详尽地介绍了各个命令的基本用法，实际中，面对手头上的数据，如何选用合适的命令呢？以下结合几个示例给出一些总结，大家举一反三就可以了：

1. 纯数据（列数相同）：
源文件：



 CODE:
 0 3866.162 2198.938 141.140
 1 3741.139 2208.475 141.252
 2 3866.200 2198.936 141.156
 3 3678.048 2199.191 141.230
 4 3685.453 2213.726 141.261
 5 3728.769 2212.433 141.277
 6 3738.785 2214.381 141.256
 7 3728.759 2214.261 141.228
 8 3748.886 2214.299 141.243
 9 3748.935 2212.417 141.253
 10 3733.612 2226.653 141.236
 11 3733.583 2229.248 141.223
 12 3729.229 2229.118 141.186




解答：对于这个txt文件，由于各行列数相同，故简单地使用load,importdata均可。


2.字段名（中、英文字段均可）+数据：
源文件：


 CODE:
 CH0 CH1 CH2 CH3
 0.000123 0.000325 0.000378 0.000598
 0.000986 0.000256 0.000245 0.000698


解答：由于是记录的形式，因此各行列数必相同（缺少部分列时请自行在文件中补上 Inf 或 NaN），故直接使用 importdata 便可。

3.注释（含有独立的数字串）+数据（列数相同）：
问题：这个文件有4列,但前6行是文字说明,4列数字是从第8行开始的.现在我想把这个文件的前2列和文字说明提出来组成一个新的dat文件

源文件：


 CODE:
 Group 2 12.02.2006 Limei
 Samples of datas: 50000

 CH0 CH1 CH2 CH3
 0.000123 0.000325 0.000378 0.000598
 0.000986 0.000256 0.000245 0.000698


目标文件：


 CODE:
 Group 2 12.02.2006 Limei
 Samples of datas: 50000

 CH0 CH1
 0.000123 0.000325
 0.000986 0.000256


解答：由于注释中含有独立的数字串，且注释部分没有明显的格式，这时候用importdata, load等高级命令直接读取会失败，用 textread, dlmwrite 等格式化命令也不太合适，因此只能使用低级命令进行读取。（当然了，可以跳过注释部分直接用高级命令读取数据，即：[a b c d] = textread(filename,'%f %f %f %f','headerlines',4); ）。一个简单的、非通用的包含注释的读取方法如下：
 -------------------------------------转 ---------------------------------------------------------------------------------------

 CODE:
 clc;clear;
 fid = fopen('exp.txt', 'r');
 fid_n=fopen('ex.dat','w');
 while ~feof(fid)
 tline=fgetl(fid);
 if ~isempty(tline)
 if double(tline(1))>=48 && double(tline(1))<=57 %数值开始
 a=strread(tline);
 a(3:4)=[];
 fprintf(fid_n,'%f %f\n',a);
 clear a;
 elseif double(tline(1))==67 %字母C开始
 [b1,b2,b3,b4]=strread(tline,'%s %s %s %s');
 b=[b1{1},' ',b2{1}];
 fprintf(fid_n,'%s\n',b);
 clear b b1 b2 b3 b4;
 else
 fprintf(fid_n,'%s\n',tline);
 end
 else
 fprintf(fid_n,'%s\n',tline);
 end
 end
 fclose(fid);
 fclose(fid_n);


 ---------------------------------------------------------------------------------

4. 注释（不含独立的数字串）+数据（列数相同）：
源文件：

 CODE:
 你好 abc
 欢迎来到 我们
 振动论坛
 vib.hit.edu.cn
 1 11 111 1111
 2 22 222 2222
 3 33 333 3333
 4 44 444 4444
 5 55 555 5555


解答：直接用 importdata 便可

注：有时候注释中含有独立的数字串也可以 importdata 成功，不过得到的结果有可能不正确，建议这时候使用第3种情形的读取方式。

5. 注释与数据混排：
 对此当然只能自己编程，举例：

源文件：

 CODE:
 1 11 111 1111
 你好
 2 22 222 2222
 欢迎来到
 3 33 333 3333
 振动论坛
 4 44 444 4444
 vib.hit.edu.cn
 5 55 555 5555


解答：
 --------------------------------------------转--------------------------------------
 CODE:

 function [data]=distilldata(infile)
 %功能说明：
 %将保存数据的原始文件中的数值数据读入到一个data变量中
 %使用说明：
 % infile——原始数据文件名;
 % data=数据变量

 tmpfile='tmp2.mat';

 fidin=fopen(infile,'r'); % 打开原始数据文件（.list）

 fidtmp=fopen(tmpfile,'w'); % 创建保存数据文件（不含说明文字）

 while ~feof(fidin) % 判断是否为文件末尾
 tline=fgetl(fidin); % 从文件读入一行文本（不含回车键）
 if ~isempty(tline) % 判断是否空行
 [m,n]=size(tline);
 flag=1;
 for i=1:n %判断一行中有没有字符（＋－.Ee和空格键除外）
 if ~(tline(i)==' '|tline(i)=='-'|tline(i)=='.'|tline(i)=='E'...
 |tline(i)=='e'|tline(i)=='+'...
 |(double(tline(i))>=48&&double(tline(i))<=57))
 flag=0;
 break;
 end
 end
 if flag==1 % 如果是数字行，把此行数据写入文件
 fprintf(fidtmp,'%s\n',tline);
 end
 end
 end
 fclose(fidin);
 fclose(fidtmp);
 data=textread(tmpfile);
 delete(tmpfile);

 ---------------------------------------------------------------------------------------------------------
 另外，如果要求不高，也可以使用 textread 函数跳过注释部分进行读取，不过前提是需要事先知道文件内容的结构（即哪行是数据、哪行是注释）

6.各列数据的分离：
源文件：


 CODE:
 0 + 47038.7 1.05 09:26:07 C
 2 + 46477.7 1.03 09:28:38 C 
 4 + 44865.7 1.04 09:28:48 C 
 6 + 41786.4 1.03 09:28:56 C 
 8 + 39896.0 0.97 09:29:03 C 
 10 + 37518.4 0.93 09:29:15 C 
 12 + 35858.5 0.92 09:29:30 C 
 14 + 46105.0 1.03 09:30:21 C 
 16 + 46168.6 6.89 09:30:30 C 
 18 + 48672.3 4.33 09:30:40 C 
 20 + 49565.7 0.49 09:30:48 C 
 22 + 49580.7 0.53 09:30:55 C 
 24 + 49602.3 0.84 09:31:03 C 
 26 + 49582.5 1.51 09:31:11 C 
 28 + 49577.0 1.39 09:31:19 C 
 30 + 49589.3 0.61 09:31:27 C 
 32 + 49578.3 1.06 09:31:29 C 
 34 + 49512.5 1.77 09:31:38 C 

解答：直接用 [a,b,c,d,e,f]=textread(yourfilename,'%d %c %f %f %s %c'); 便可


四. 注意事项：
 
 
 
1. 请在 matlab 中保持当前路径在该数据文件对应的目录下进行存取，否则，存取时请给出该数据文件的具体路径。
 
 
 
 
 
 
 
2. 存取时，请给出该数据文件的全称（包括后缀名，读取mat文件时可省略）
 
 
 
 
 
 
 
3. load data.txt和A=load(‘data.txt’)的区别请参阅精华贴：[原创]写给学习 matlab 的新手们
 
 
 
 
 
 
 
4. 请根据读写需要来打开文件，即根据你的需要来指定 fopen 的 permission 属性为读或写。如果只用 a 进行写入，就不能用 fread 读取。此时应该写完关闭文件，然后用 r 打开读取，或者直接用 a+ 进行同时读写操作。否则，会产生莫名其妙的问题！以下代码是一个错误的例子：
 
 
 
 
 
 
 
CODE:

 filename='e.dat';
 fid=fopen(filename,'a');
 if fid<0
 error('fopen error');
 end
 s=[1 2 3 4;5 6 7 8];
 fwrite(fid,s,'float32')
 [dd ll]=fread(fid,inf,'float32');％把t中的数据全部读出，即s矩阵。
 fclose(fid);
  
 
 
 
此时得到的dd, ll 是错误且无意义的！
 
 
 

五. 其他相关问题：

1. 连续读取多个文件的数据，并存放在一个矩阵中：
(1) 首先是如何读取文件名：
方法一：
 filename=dir(‘*.jpg’);
 那么第i个文件的文件名就可以表示为
 filename(i).name
 文件数量为：length(filename)

方法二：
 先在Windows的 MSDOS（命令行）中使用以下命令生成一个list.txt文件：
 
 
 
dir path\folder /on /b /s > path\list.txt
 
 
 
举例：dir d:\test /on /b /s > d:\list.txt
 
 
 
然后在 matlab 中使用：
 
 
 
filename = textread(sFileFullName,'%s');
 
 
 
把所有文件名读取到list细胞矩阵中，最后对filename{i}便可得到各文件名。
 
 
 

(2) 然后是读取文件名的数据并存储：
 假设每个文件对应的数据是m*n的，则：

 CODE:
 k = length(filename);
 Data = zeros(m,n,k);
 for ii = 1:k
 Data(:,:,ii) = yourreadstyle(filename{ii}); %yourreadstyle是对应的文件读取方式的函数
 end

2. 连续读取多个文件的数据，并存放在多个矩阵（以文件名命名）中：
 假设每个文件对应的数据是m*n的，则以上述第二种文件名读取方法为例：

 CODE:
 k = length(filename);
 for ii = 1:k
 D = yourreadstyle(filename{ii});
 eval([‘Data_’, num2str(ii), ‘ = D;’]);
 end



3. 文件名命名问题：
 文件名为 abc00001,abc00002,... abc00009,abc00010,... abc00099,abc00100,...abc00879. 准备把这些文件名给放到一个数组里面去。

解答：

 CODE:
 a=cell(879,1);
 for k=1:879
 a{k} = sprintf('%.5d',k);
 end


4. 上述各种文件格式、类型自动识别问题：可以利用正则表达式来处理，使之通用性较强。例如使用以下代码可以自动处理上面提到了例1到例5各种情形，不过由于存在自动判断，对某些例子（如例1）效率自然要低一点，而对于另外的例子（如例3、例5）效率估计要高一点（少用了一个循环）。

 CODE:
 function [data]=distilldata_eight(infile)
 %功能说明：
 %将保存数据的原始文件中的数值数据读入到一个data变量中（自动判断数据行）
 %使用说明：
 % infile——原始数据文件名;
 % data=数据变量
 tmpfile='tmp2.mat';
 fidin=fopen(infile,'r'); % 打开原始数据文件（.list）
 fidtmp=fopen(tmpfile,'w'); % 创建保存数据文件（不含说明文字）
 while ~feof(fidin) % 判断是否为文件末尾
 tline=fgetl(fidin); % 从文件读入一行文本（不含回车键）
 if ~isempty(tline) % 判断是否空行
 str = '[^0-9 | \. | \- | \s | e | E]'; %正则表达式为：该行中是否包含除 - . E e 数字 和 空白字符 外的其他字符
 start = regexp(tline,str, 'once');
 if isempty(start)
 fprintf(fidtmp,'%s\n',tline);
 end
 end
 end
 fclose(fidin);
 fclose(fidtmp);
 data=textread(tmpfile);
 delete(tmpfile)



5. 大量数据的读取问题：
 可以考虑使用循环分批读取（特别是在各数据是独立的时候），或者使用稀疏矩阵来实现（对此可以参阅本版精华贴： [原创]提高matlab运行速度和节省空间的一点心得（之三））。另外，也可参考《深入浅出MATLAB 7_X混合编程》一书第一章

6. 读取整个txt文件的内容（获得文件中的所有字符）：

 CODE:

 f = fopen('yourfilename.txt','rt'); % t 属性根据需要可省略
 x = fread(f,'*char');
 fclose(f);


7. 把维数不同的矩阵及其变量名保存到一个 txt 文件中，例如 a1 = 123; a2 = [1 2 3;4 5 6] ，希望得到的 txt 文件如下：


QUOTE:

a1：
 123
 a2：
 1 2 3
 4 5 6





 如果写入的时候简单一点，则可以采用以下方式，不过读取的时候比较麻烦：

 CODE:

 a1=123;
 a2=[1 2 3;4 5 6];
 fid = fopen('myfile.txt', 'wt');
 for i=1:2
 fprintf(fid, '%s: \n %s\n', ['a',int2str(i)], mat2str(eval(['a',int2str(i)])));
 end
 fclose(fid);


 相反，如果写入的时候复杂一点，则读取的时候会简单一点：

 CODE:

 a1=123;
 a2=[1 2 3;4 5 6];
 fid = fopen('myfile.txt', 'wt');
 for i=1:2
 fprintf(fid, '%s: \n', ['a',int2str(i)]); 
 b = eval(['a',int2str(i)]);
 fprintf(fid, [repmat('%d ', 1, size(b,2)), '\n'], b');
 end
 fclose(fid);
 
 
 
https://www.cnblogs.com/pengwangguoyh/articles/3223072.html

文件有两种，文本文件和二进制文件。读写文本文件比较简单，也在这里简单说一下；读写二进制文件用到了struct库，涉及一些大端小端、字节填充等概念，稍微有点复杂。
 
文件打开关闭
 
在读写文件之前，需要打开文件，Python不需要导入其他库，直接可以打开关闭文件
 
file = open('filename.ext', openmod)  #打开文件

file.close()  #关闭文件
 
操作模式可以分为两种，一种是文本文件模式，另一种为二进制文件模式
 
 
读写文本文件
 
文件写入就比较简单了
 
file.write('string')  
file.write('string\n') # 换行
file.write('%10s=%10.2f\n' % ('val', 12.3455)) # 格式化字符串
 
write函数只能输出字符串，不能像C语言那样定义输出格式。 如果像这么做，需要先对要输出的内容转换为字符串。可以像上例那样格式化字符串，格式化方法与C中的是一致的，适合学过C语言的同学。
 
Python也有一个输出多行的函数，同时输出多行
 
content = ['I have a dream.\n', 'One day, \n', 'former slaves and slave owners will join together,\n',
           'as brotherhood.\n']
file.writelines(content)
 
writelines()函数不会为你添加换行符，需要自己添加。
 
读入文件内容
 
file.read() # 读取文件所有内容
file.read(n) # 读取前n个字符
 
需要注意的是read(n)。如果文件中有中文，一个中文字表示一个字符，不管其中内部编码是几个字节。读取完之后，光标移动n个字符。
 
顺便讲一讲如何读取中文。如果要正确读取中文，以下条件要满足
 
要读的文本文件的编码与打开文件时设置的编码一致。
 
其实我们在打开文件时，有一个文件编码参数我们没有设置，用的默认的参数，这个参数可以设置。假如我们的文本文件a.txt用的utf-8进行的编码。就可以进行下面设置。
 
file = open('a.txt', 'r', encoding='utf-8')
 
如果两者没有设置成一致的，在读取时就会出错。 在Windows中, open方法打开的文件好像默认为GBK编码，如果你的文本文件用的utf-8格式，就会错误。
 
除了上面的读取函数之外，还有一个
 
line1 = file.readline()
str2 = file.readline(n) #读取本行的n个字符
 
注意line1中包含回车符，读取完line1后，读取位置移动到下一行
 读取完str2后，读取位置移动n个字符，可能还在本行。
 如果n >= 本行的字符数(包含换行符), 最终读取的内容就是本行的字符，读取位置移到下一行；
 如果n <本行的字符数(包含换行符), 最终读取的内容长度为n， 读取位置移动n个字符，读取位置还在本行。
 
感觉说的有点啰嗦，就这样吧。
 
读写二进制文件
 
二进制文件中都是一个一个的字节数据。因此读和写，都是针对字节数据的。
 
bytes_all = file.read()   #读取文件所有的字节数据
bytes_read = file.read(n)  #读取n个字节数据
file.write(bytes_read)     #将字节数据写到文件
 
下面就是讲如何把数据转换为字节数据，以及如何把字节数据解析成原始数据。
 这里用到了Python提供了一个struct库。
 
在使用之前先导入struct库
 
import struct
 
struct库有两个基本操作
 
struct.pack(fmt, v1, v2, ...)  #将原始数据v1, v2, ...根据fmt格式转换为字节串
val_arr = struct.unpack(fmt, bytes_arr)  #将字节数据byts_arr根据fmt格式转换为原始数据元组 val_arr
 
下面是一个简单的例子
 
b1 = struct.pack('>hif', 65, 123, 3.14)
print([hex(i) for i in b1])
 
输出
 
['0x0', '0x41', '0x0', '0x0', '0x0', '0x7b', '0x40', '0x48', '0xf5', '0xc3']
 
这里稍作解释，后面会有更详细的。
 这里的fmt为’>hif’ 表示数据为大端顺序，h表示一个short类型，也就是2个字节的整数，i表示一个int类型也就是4个字节表示的整数， f表示单精度浮点类型，也是4个字节。 因此这个fmt表示的10个字节的数据。
 
可以用下面计算fmt代表的字节数
 
struct.calcsize('>hif')
 
然后是把字节解析为原始数据
 
struct.unpack('>hif', b1)
 
输出
 
(65, 123, 3.140000104904175)
 
在fmt的定义中，有3样东西需要注意：字节顺序，数据由几个字节组成，以及字节填充（对齐）。
 字节顺序：
 是对于多字节的数据，比如一个int类型的数16909060（其十六进制表示为 0x01020304），转换为字节有两种转换方法
 大端表示，最高位在前， 0x01, 0x02, 0x03, 0x04
 小端表示，最低位在前， 0x04, 0x03, 0x02, 0x01
 
[hex(i) for i in struct.pack('>i', 16909060)]
Out[69]: ['0x1', '0x2', '0x3', '0x4']
[hex(i) for i in struct.pack('<i', 16909060)]
Out[70]: ['0x4', '0x3', '0x2', '0x1']
 
数据长度，这个大家应该都知道。下面是完整的数据长度列表
 
 字节填充（对齐），这是以前C语言中的一个概念。比如有一个100个长度的int类型的数组，为了能够找到第61个数据，我只需要把指针移动60个int长度就行了，因为这100个数都是4字节对齐的。
 在Python中，对齐稍微有一点区别。比如h表示的是short，是2字节的。如果启用了对齐设置，那么在任何short类型放置的位置，都需要2字节对齐。如果是i，也就是int类型的数据，就需要4字节对齐。如果是d，也就是double，就需要8字节对齐。放在最前面的数据不需要对齐，始终是从第0个字节开始。当然也可以不用对齐设置，那么数据就是连续排列的。
 
像刚刚的’>'就定义了这三样东西：大端字节顺序(big-endian)，标准的数据字节数，无字节填充（对齐）。 完成的参数见下表：
 
 默认是@，native表示配置方法跟本机环境有关。不同类型的CPU，操作系统，配置不一样。有些CPU可能是采用大端、有些事小端；有些操作系统下int表示4个字节，有些表示8个字节；有些要求对齐，有些不要求对齐。size设置为standard，表示数据类型的长度不随着本地环境而改变。
 
可以通过下面的方法，查看本地的字节顺序
 
import sys
print(sys.byteorder)
 
我的电脑处理器i7, 系统win10。 显示的little， 也就是小端模式
 
后面还有几个例子，来说明x，c, s类型。
 x表示填充字节。如果首字符设置的是不填充，那么一个x代表一个字节。pack中不需要有数据与之对应。
 
[hex(i) for i in struct.pack('<xxi',16909060)]
Out[76]: ['0x0', '0x0', '0x4', '0x3', '0x2', '0x1']
 
如果首字符设置的是填充，并且在x的位置本来就有填充，那么x就不起作用，除非x的个数超过了本来要填充的数目。
 
[hex(i) for i in struct.pack('xxi',16909060)]  #x不起作用，因为本身要填充3个字节
输出：
['0x2a', '0x0', '0x0', '0x0', '0x4', '0x3', '0x2', '0x1']

[hex(i) for i in struct.pack('cxxxxi',b'*', 16909060)]  #x起作用，x数超过了3个字节，int对齐到下下一个4字节了
输出：
['0x2a',
 '0x0',
 '0x0',
 '0x0',
 '0x0',
 '0x0',
 '0x0',
 '0x0',
 '0x4',
 '0x3',
 '0x2',
 '0x1']

 
c表示的是一个char，其实只能用字节数据，并且字节长度只能是1。 但是可以在c前面加数字，避免连续写几个c（也适用x)。
 
[hex(i) for i in struct.pack('<3ci', b'a', b'b', b'c',16909060)]
Out[75]: ['0x61', '0x62', '0x63', '0x4', '0x3', '0x2', '0x1']
 
s表示的是字符串，其实也是只能用字节数据，不过字节长度可以大于1。在s前面加数字，表示这个串的长度。如果后面字节数目不够，就会填充0；如果后面字节数过长，就会截取。
 
[hex(i) for i in struct.pack('<1si', b'abc',16909060)]
Out[90]: ['0x61', '0x4', '0x3', '0x2', '0x1']
[hex(i) for i in struct.pack('<10si', b'abc',16909060)]
Out[89]: 
['0x61',
 '0x62',
 '0x63',
 '0x0',
 '0x0',
 '0x0',
 '0x0',
 '0x0',
 '0x0',
 '0x0',
 '0x4',
 '0x3',
 '0x2',
 '0x1']
 
哎，写了这么长，累死了。

序言
 
随着websocket、webAudio，Ajax2等广泛应用，前端方面只要是处理大数据 或 想提供数据处理性能，那就少不了 ArrayBuffer 对象。同时在浏览器中处理二进制数据的需求在不断增加，有时需要字节数组、8位、16位、32位整型数组，有必要对JS中处理二进制的知识做一次梳理。
 
应用场景
 
操作用户选中的本地二进制文件，需要用二进制流的方式上传到服务端。
保存快照 HTML 文件。JS拿到的只是HTML源码长字符串，需要生成二进制流上传到服务端。（其中涉及到 base64 和 encodeURIComponent 等编码问题） 
  
前端通过 screen-capture-js 库取得当前页面的 documentText – 长长的字符串，需要转成二进制文件流的格式，通过websocket 分多次数据包传输给后台存储。
 
结合JS的ArrayBuffer和 Typed Array去获取及处理音频数据、XHR2上传或下载二进制内容等等
 
Blob 接口
 
Blob 对象表示一个不可变、原始数据的类文件对象。
创建 Blob 对象的语法：
 
// array 是一个由ArrayBuffer, ArrayBufferView, Blob, DOMString 等对象构成的 Array ，或者其他类似对象的混合体。DOMString 会被编码为 UTF-8
var aBlob = new Blob( array, {type: '', endings: 'transparent'} );

// 示例
var aBlob = new Blob(['<html><body>test!</body></html>'], {
	type: 'text/html'
});
 
属性：size、type
方法： 
  
Blob.slice()：创建子集
Blob.stream()：返回能读取 blob 的字节流（兼容性不好）
Blob.text()：返回一个promise且包含blob所有内容的UTF-8格式的字符串
Blob.arrayBuffer()：返回一个promise，且包含blob所有内容的二进制格式 ArrayBuffer
 
 
File 接口
 
File API 属于 HTML5 DOM 的内容。让用户能在 web 内容中选择本地文件并读取这些文件的内容。
File 接口基于Blob，继承了 blob 的功能并将其扩展使其支持用户系统上的文件。
语法：
 
// bits: 一个包含ArrayBuffer，ArrayBufferView，Blob，或者 DOMString 对象的数组 — 或者任何这些对象的组合。这是 UTF-8 编码的文件内容。
// name: 文件名或文件路径
// options: { type, lastModified } MIME 类型和最后修改时间
var myFile = new File(bits, name[, options]);

// 示例
var file = new File(['foo'], 'foo.txt', {
	type: 'text/plain',
})
 
可以处理 File 对象的 context：FileReader对象, URL.createObjectURL(), XMLHttpRequest.send(), createImageBitmap()。
file 对象的主要属性，都是只读： 
  
name：文件名，但不包含路径信息
size：文件大小
type：文件的 MIME 类型
webkitRelativePath：文件 path 或 URL
 
file 接口没定义新方法，一切接口都继承自 Blob
 
// HTML
<input type="file" id="fileInput">

// JS
const selectFile = document.getElementById('fileInput').files[0];
 
注意：File 对象不能简单地通过指定路径来访问本地文件，是处于安全的考虑，必须要通过用户自己手动选择的方式才可以访问到本地文件。如果要自动读取某个文件，只能通过异步请求读取服务器端的文件。
 
ArrayBuffer 对象
 
ES6 新增接口，ArrayBuffer 对象用来表示通用的、固定长度的原始二进制数据缓冲区。它是一个字节数组，通常在其他语言中称为“byte array”。
你不能直接操作 ArrayBuffer 的内容，而是要通过类型数组对象或 DataView 对象来操作。它们会将缓冲区中的数据表示为特定的格式，并通过这些格式来读写缓冲区的内容。比如八、十六、三十二进制格式。
 
结合 TypedArray 一起学习
 
读取、预览、显示 file 对象
 
视频文件
 
 
 
Streams API
 流将你希望通过网络接收的资源拆分成小块，然后按位处理它。这正是浏览器在接收用于显示web页面的资源时做的事情——视频缓冲区和更多的内容可以逐渐播放，有时候随着内容的加载，你可以看到图像逐渐地显示。
 
 
图片文件
PDF文件
等等
以下2种方法以预览图片文件为例
 
方法一：通过创建 FileReader 来读取文件信息。
 
示例：上传图片的预览
 
var img = document.createElement("img");
img.classList.add("obj");
img.file = file; // ？
preview.appendChild(img); // 假设"preview"就是用来显示内容的div

var reader = new FileReader();
reader.onload = (function(aImg) {
	return function(e) {
		// event.target.result 包含被转化为 type array 的 file
		aImg.src = e.target.result;
	};
})(img);
// readAsDataURL 方法用于将文件转换为二进制字符串
reader.readAsDataURL(file);
// 通过创建FileReader来处理异步的图片加载并把他赋给img元素。在创建一个新的 FileReader对象后，我们新建了它的onload 函数，然后调用readAsDataURL()函数开始后台读取文件。当整个图片文件的内容都被全部加载完后，它们被转换成了一个被传递到onload回调函数的data:URL。我们再执行常规操作将img元素的src属性设置为刚刚加载完毕的URL，使得图像可以显示在用户屏幕上的缩略图中。
 
方法二：使用 URL.createObjectURL 方法
 
对象URL可以用于image之外的其它东西！它可以用于显示嵌入的PDF文件或任何其它浏览器能显示的资源。
该静态方法接受 File 对象或者 Blob 对象为参数，会创建一个 DOMString，可直接用于 src URL。 
  
file input 选择的本地文件，要显示文件缩略图的话，可使用 window.URL.createObjectURL(file) 方法，返回的是一个类似这样的url：blob:http://localhost:8080/6111b0b0-13c0-4618-a356-05d0fa62de6a，可直接赋值给 img 或 video 等标签的 src 属性值实现预览。
注意：在不需要使用该对象以后要显式调用 URL.revokeObjectURL() 来释放它们。
 
 
var img = document.createElement("img");
img.src = window.URL.createObjectURL(files[i]);
img.height = 60;
// 当图片加载完成之后对象URL就不再需要了, 设置图片的load事件处理器来释放对象URL。
img.onload = function() {
	window.URL.revokeObjectURL(this.src);
}
li.appendChild(img);
var info = document.createElement("span");
info.innerHTML = files[i].name + ": " + files[i].size + " bytes";
li.appendChild(info);
 
 
预览 pdf 文件
 
让PDF嵌入式地显示在iframe中（而不是作为下载的文件弹出）
 
// HTML
<iframe id="viewer">

// JS
const obj_url = window.URL.createObjectURL(blob);
const iframe = document.getElementById('viewer');
iframe.setAttribute('src', obj_url);
window.URL.revokeObjectURL(obj_url);
 
file 文件上传
 
FormData
 
关于进度条的实现。 
  
HXR 异步请求中，progress event 对象中有个 event.total 属性可实时反映出已上传的部分大小。
 
 
var xhr = new XMLHttpRequest();
xhr.upload.addEventListener("progress", function(e) {
  	if(e.lengthComputable) {
	    var percentage = Math.round((e.loaded * 100) / e.total);
	}
}, false);
 
WebSocket 发送二进制数据
 
WebSocket可以通过ArrayBuffer，发送或接收二进制数据。
 
let socket = new WebSocket('ws://127.0.0.1:8081');
socket.binaryType = 'arraybuffer';

// Wait until socket is open
socket.addEventListener('open', function (event) {
  // Send binary data
  const typedArray = new Uint8Array(4);
  socket.send(typedArray.buffer);
});

// Receive binary data
socket.addEventListener('message', function (event) {
  const arrayBuffer = event.data;
  // ···
});
 
编码知识
 
ASCII 字符集
 
背景：因为计算机只能处理数字，如果要处理文本，就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特（bit）作为一个字节（byte）。一个字节能表示的最大的整数就是255（2^8-1=255），而ASCII编码，占用0 - 127用来表示大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码。
组成：26个字母的大小写、数字、特殊符号、美式英语中的控制字符。在英语中，用128个符号编码便可以表示所有。
32～126(共95个)是字符(32是空格），其中48～57为0到9十个阿拉伯数字，65～90为26个大写英文字母，97～122号为26个小写英文字母，其余为一些标点符号、运算符号等。
大小规则：09<AZ<a~z。
 
 
Unicode（支持多国语言）
 
Unicode码也是一种国际标准编码，采用二个字节编码，与ASCII码不兼容。在网络、Windows系统和很多大型软件中得到应用。
因为ASCII编码无法表示多国语言的编码，为了统一所有文字的编码，Unicode应运而生。Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。
Unicode通常用两个字节表示一个字符，原有的英文编码从单字节变成双字节，只需要把高字节全部填为0就可以。
Unicode 编码共有三种具体实现，分别为utf-8,utf-16,utf-32
它前128个字符就是ASCII码，之后是扩展码。
JS 中 ASCII 码和 unicode 码之间的转换 
  
ASCII 转 unicode：用 String 的 CharCodeAt() 方法，返回指定位置的字符的 unicode 编码。
unicode 转 ASCII：用 String 的 fromCharCode() 方法，可将 unicode 编码转为字符。
 
 
GB23129（中文编码规范）
 
中文编码标准，由中国国家标准总局1980年发布。
ASCII编码只覆盖英文，如果要表示中文（10万个汉字），因为一个字节能表示的最大的整数就是255，显然一个字节是不够的，至少需要两个字节，而且还不能和ASCII编码冲突，所以，中国制定了GB2312编码，用来把中文编进去。
由于欧洲国家使用的编码体系，可以表示最多256个符号，但不同的国家有不同的字母，亚洲国家的文字，使用的符号就更多了，汉字就多达10万左右。一个字节只能表示256种符号，肯定是不够的，就必须使用多个字节表达一个符号。比如，简体中文常见的编码方式是 GB2312，使用两个字节表示一个汉字，所以理论上最多可以表示 256 x 256 = 65536 个符号。
 
base64 编码
 
 
待研读
 
 
注意：btoa(‘中文’) btoa方法传入中文字符会报错：
 
  
< VM197:1 Uncaught DOMException: Failed to execute ‘btoa’ on ‘Window’:
 The string to be encoded contains characters outside of the Latin1 range.(…)
原因：btoa只能转换占一个字节宽度的字符，就是Latin1字符集(它是ASCII的超集)。而中文汉字是被编码成占两个或以上个字节的。所以btoa方法无法对中文进行操作，于是就报了上面看到的错误。
 
 
Binary strings
 
utf-16 编码
 
如 DOMString 就是一种 UTF-16 字符串
 
注意 encodeURL 和 encodeURLComponent 编码方法的使用
 
当单页应用里的不同路由之间想通过 URL params 的方式传递参数的话，要注意对中文等其他非英文语言做编码处理，也就是 encodeURL方法、或者 encodeURLComponent 方法。
对应的解码方法分别是：decodeURL 和 decodeURLComponent。
注意：当URL参数里包含特殊字符 - _ . ! ~ * ’ ( ) 的时候，要注意 encodeURLComponent 编码方法不会对这些字符作编码的，可能会在编码结果中以这些字符作分隔符时遇到坑。比如：
 
// FileA.js
const paramA = encodeURLComponent('xxxx.xxxxxxxx.filename.txt');
const str = `http://baidu.com?paramA=${paramA}`;

// FileB.js
// 假设已经定义好了 getParamByUrl 方法，可从 URL 获取参数的
const paramA = decodeURLComponent(getParamByUrl(url, 'paramA'));
// 此处得到的 fileSuffix 值为 xxxx.xxxxxxxx.filename.txt, 而不是期望的 filename.txt
const fileSuffix = paramA.slice('.');
 
参考
 
在Web前端还可以这样实现Base64
彻底弄懂 Unicode 编码
在web应用程序中使用文件
developer.mozilla.org
JS中Buffer数据详解
Base64的编码与解码 - Web API 接口参考 _ MDN
ArrayBuffer - ECMAScript 6入门
你不知道的 Blob

0 引言
 
最近老师让写一个程序，作为学习JAVA的练习。目的在于：将一个二进制文件中的数据读取出来，其中数据包括点的位置信息和压力值及状态。将这些数据画作图像的形式展示。
 
本小程序分为以下几部分：
 
（1）读取二进制文件；其中需要考虑二进制文件读出来的是十进制数，需要将二个字节合成一个short型，并转换为int型值。
 
（2）画图；根据读取到的点的信息，循环，如果状态是画，则将该点与上一点相连；
 
1 读取二进制文件
 
所有的输入流类都是抽象类InputStream或Reader的子类。本文主要使用其中的FilterInputStream子类中的DataInputStream和BufferedInputStream这两个子类。
 
1.1 DataInputStream
 
构造函数为：
 
DataInputStream(InputStream in)
Creates a DataInputStream that uses the specified underlying InputStream.
 
使用基础类InputStream构造DataInputStream
 
方法主要有，见下表
 
 
本文使用readFully(byte[] b)方法读取所有的字节信息。
 
代码示例如下：
 
DataInputStream dis = null;

dis = new DataInputStream(new FileInputStream ("./test.txt"));

byte []b = new byte [1024];

dis.read(b);
 
文件的所有信息都会存储在定义的byte数组中。
 
1.2 BufferedInputStream
 
构造函数如下：
 
BufferedInputStream(InputStream in)
Creates a BufferedInputStream and saves its argument, the input stream in, for later use.
BufferedInputStream(InputStream in, int size)
Creates a BufferedInputStream with the specified buffer size, and saves its argument, the input stream in, for later use.
 
方法主要有，见下表
 
 
主要使用read(byte [], off, len)方法读取文件信息。方法available()返回文件的字节数；
 
示例代码如下：
 
BUfferedInputStream bis = null;

bis = new BufferedInputStream(new fileInputStream("./test.txt"));

int len = bis.available();
byte []b = new byte[len];

bis.read(b, 0, len);
 
byte数组中将存放文件的所有信息。
 
1.3 处理数据
 
根据以上两种方法获取了数据，接下来将对数据转换成int型。
 
由于buff数组中存放的是一个字节一个字节的，故将两个字节组合即可。
 
代码如下：
 
int x = (buff[0] & 0xff) | (buff[1] & 0xff) << 8;
int y = (buff[2] & 0xff) | (buff[3] & 0xff) << 8;
 
以上是小端模式（低地址中存放的是字数据的低字节，高地址存放的是字数据的高字节）的转换，大端（与小端相反）的话直接调换一下就行。
 
2 画图
 
采用Graphics2D进行画图，使用BufferedImage创建画，并通过方法getGraphics()返回2D图像。
 
 
 // create a BufferedImage with the size of (width, height)
        BufferedImage bufferedImage = new BufferedImage(width, height,                 
        BufferedImage.TYPE_INT_RGB);
        // to draw strokes, we need a Graphics2D - correlated with BufferedImage
        Graphics2D graphics2D = (Graphics2D) bufferedImage.getGraphics();
        // set the background to be WHITE
        graphics2D.setBackground(Color.WHITE);
        graphics2D.clearRect(0, 0, width, height);
        // set width and color for lines
        graphics2D.setPaint(Color.BLACK);
        graphics2D.setStroke(new BasicStroke(3));
 
2.1 将所有点连接成线
 
判断该点的状态是否是画，及下一个点是否是画，然后再连线
 
int pos;
        boolean bDrawing = false;
        int xPrev=-1, yPrev=-1;
        for( pos = 4; pos + 7 <= nLength ; pos += 7)
        {
            byte status = buffer[pos];
            int x = ((buffer[pos+1]&0xff) | ((buffer[pos+2]&0xff) << 8)) / 10;
            int y = ((buffer[pos+3]&0xff) | ((buffer[pos+4]&0xff) << 8)) / 10;
            if( bDrawing ) {
                if(status == 0x11) {
                    graphics2D.drawLine(xPrev, yPrev, x, y);
                    xPrev = x;
                    yPrev = y;
                }
                else {
                    bDrawing = false;
                }
            }
            else {
                if(status == 0x11) {
                    bDrawing = true;
                    xPrev = x;
                    yPrev = y;
                }
                else {
                    // floating
                }
            }

        }
 
3 结果
 
 
4 总结
 
任重而道远，老师还是最牛逼的！