First, the function realizes the core: FileSystemObject object
In fact, to implement the file operation function in JavaScript, the main thing is to rely on the FileSystemObject object.
Ii. FileSystemObject Programming Trilogy
Programming with a FileSystemObject object is simple, typically through the following steps: Creating FileSystemObject objects, applying related methods, and accessing object-related properties.
(i) Creating FileSystemObject objects
The code to create the FileSystemObject object takes only 1 lines:
The code is as follows |
Copy Code |
var fso = new ActiveXObject ("Scripting.FileSystemObject");
|
After the above code executes, the FSO becomes a FileSystemObject object instance.
(ii) Application of relevant methodologies
After you create an object instance, you can use the associated methods of the object. For example, use the CreateTextFile method to create a text file:
The code is as follows |
Copy Code |
var fso = new ActiveXObject ("Scripting.FileSystemObject"); var f1 = fso.createtextfile ("C://myjstest.txt", true);
|
(iii) Access to object-related properties
To access the related properties of an object, you first establish a handle to the object, which is done by the Get series method: Getdrive is responsible for obtaining the drive information, GetFolder is responsible for obtaining the folder information, GetFile is responsible for obtaining the file information. For example, after pointing to the following code, F1 becomes a handle to the file C:/test.txt:
The code is as follows |
Copy Code |
var fso = new ActiveXObject ("Scripting.FileSystemObject"); var f1 = fso. GetFile ("C://myjstest.txt"); Then, use F1 to access the associated properties of the object. Like what: var fso = new ActiveXObject ("Scripting.FileSystemObject"); var f1 = fso. GetFile ("C://myjstest.txt"); Alert ("File Last modified:" + F1.) DateLastModified);
|
After the last sentence is executed, the last modified Date attribute value for C:/myjstest.txt is displayed.
But one thing. Note: For objects created using the Create method, you do not have to use the Get method to obtain the object handle, and then the handle name created directly by using the Create method can be:
code is as follows |
copy code |
var fso = new ActiveXObject ("Scripting.FileSystemObject"); var f1 = fso.createtextfile ("C://myjstest.txt", true); Alert ("File Last modified:" + F1.) DateLastModified); |
Three, Operation drives (drives)
It is easy to use the FileSystemObject object to programmatically manipulate drives (drives) and folders (Folders), which is like interacting with files in a Windows file browser, such as copying, Move the folder to get the properties of the folder. The
(a) Drives object Properties
Drive object collects the contents of physical or logical drive resources in the system, and it has the following properties:
L totalsize: Drive size in bytes (byte).
L availablespace or freespace: drive free space calculated in bytes (byte).
L DriveLetter: drive letter.
L DriveType: Drive type, value: Removable (removable media), fixed (fixed media), Network (network Resource), CD-ROM, or RAM disk.
L SerialNumber: Serial code for the drive.
L FileSystem: The file system type of the drive on which the value is fat, FAT32, and NTFS.
L IsReady: The drive is available.
L ShareName: share name.
L VolumeName: the volume label name.
L Path and RootFolder: The path to the drive or the name of the root directory.
(ii) Drive object manipulation routines
The routines below display information such as the volume label, Total capacity, and free space of drive C:
The code is as follows |
Copy Code |
var fso, DRV, s = ""; FSO = new ActiveXObject ("Scripting.FileSystemObject"); DRV = FSO. Getdrive (FSO. GetDriveName ("c://")); S + + "Drive C:" + "-"; S + + DRV. VolumeName + "n"; S + + "total space:" + DRV. totalsize/1024; s + = "Kb" + "n"; s + + "free space:" + DRV. freespace/1024; s + = "Kb" + "n"; alert (s); |
Iv. Operation folder (Folders)
Actions that involve folders include creating, moving, deleting, and getting related properties.
Folder object Action routines:
The following routines practice getting the parent folder name, creating a folder, deleting a folder, and determining whether it is a root directory, and so on:
code is as follows |
copy code |
var FSO, FLDR, S = ""; //Create FileSystemObject object instance FSO = new ActiveXObject ("Scripting.FileSystemObject"); //Get Drive object Fldr = FSO . GetFolder ("c://"); //Show parent directory name Alert ("Parent folder name is:" + Fldr + "n"); Displays the drive name Alert ("contained on drive" + Fldr). Drive + "n"); //To determine if the root directory if (Fldr. IsRootFolder) Alert ("This is the root folder."); Else Alert ("This folder isn ' t a root folder."); Alert ("/n/n"); //Create a new folder FSO. CreateFolder ("C://bogus"); Alert ("Created folder C://bogus" + "n"); //Displays the folder base name, not including the pathname alert ("Basename =" + FSO). Getbasename ("C://bogus") + "n"); //Delete the created folder FSO. DeleteFolder ("C://bogus"); Alert ("Deleted folder C://bogus" + "n"); |
V. Operating documents (FILES)
Operations on files are more complex than the drives (Drive) and folders (folder) described above, and are essentially grouped into the following two categories: creation, copying, movement, deletion, and creation, addition, deletion, and reading of file content. The details are detailed below.
(i) Create a file
There are 3 ways to create an empty text file, which is sometimes called a text stream.
The first is the use of the CreateTextFile method. The code is as follows:
The code is as follows |
Copy Code |
var fso, F1; FSO = new ActiveXObject ("Scripting.FileSystemObject"); F1 = fso. CreateTextFile ("C://testfile.txt", true);
|
The second is to use the OpenTextFile method and add the ForWriting property, the ForWriting value is 2. The code is as follows:
The code is as follows |
Copy Code |
var fso, TS; var forwriting= 2; FSO = new ActiveXObject ("Scripting.FileSystemObject"); TS = fso. OpenTextFile ("C://test.txt", ForWriting, True);
|
The third is to use the OpenAsTextStream method, also set the ForWriting property. The code is as follows:
code is as follows |
copy code |
var FSO, F1, TS; var forwriting = 2; FSO = new ActiveXObject ("Scripting.FileSystemObject"); FSO. CreateTextFile ("C://test1.txt"); F1 = fso. GetFile ("C://test1.txt"); ts = f1. OpenAsTextStream (ForWriting, true); |
(ii) Adding data to a file
when a file is created, you typically add data to a file by following the steps of "Open file-> fill data-> close file." The
Open file can use the OpenTextFile method of the FileSystemObject object, or use the OpenAsTextStream method of the file object.
Fill in data to use the Write, WriteLine, or WriteBlankLines method of the TextStream object. The difference between these 3 is that the Write method does not add a new line break at the end of the write data, the WriteLine method adds a new newline character at the end, and WriteBlankLines adds one or more blank rows. The Close method of the TextStream object can be used by
closing a file.
(iii) Create a file and add a data routine
The following code creates a file, adds data, and closes the file in a combination of several steps:
The code is as follows |
Copy Code |
var fso, TF; FSO = new ActiveXObject ("Scripting.FileSystemObject"); Create a new file tf = FSO. CreateTextFile ("C://testfile.txt", true); Fill in the data and add line breaks Tf. WriteLine ("Testing 1, 2, 3."); Add 3 Blank Lines Tf. WriteBlankLines (3); Fill in a line without line breaks Tf. Write ("This is a test."); Close File Tf. Close (); |
(iv) Read the contents of the file
Reading data from a text file uses the read, ReadLine, or ReadAll method of the TextStream object. The Read method is used to read a specified number of characters in a file; the ReadLine method reads an entire line, but does not include a newline character; the ReadAll method reads the entire contents of the text file. The read content is stored in a string variable for display, parsing. When reading a file's contents using the Read or ReadLine method, skip or SkipLine method is used if you want to skip some parts.
The following code shows opening the file, filling in the data, and then reading the data:
code is as follows |
copy code |
var FSO, F1, TS, S var ForReading = 1; FSO = new ActiveXObject ("Scripting.FileSystemObject"); //Create file F1 = fso. CreateTextFile ("C://testfile.txt", true); //Fill in one row of data F1. WriteLine ("Hello World"); F1. WriteBlankLines (1); //Close file F1. Close (); //Open file ts = fso. OpenTextFile ("C://testfile.txt", ForReading); //Read a file line to the string s = ts. ReadLine (); //Display string Information Alert ("File contents =" + S + ""); Closes the file Ts. Close (); |
(v) moving, copying, and deleting files
for all of the above three files, JavaScript has two corresponding methods: File.move or filesystemobject.movefile for moving files; File.Copy or Filesystemobject.copyfile is used to copy files, File.delete or filesystemobject.deletefile to delete files.
The following code demonstrates creating a text file in the root directory of drive C, filling in some content, then moving the file to the/tmp directory, creating a copy of the file under the directory/temp, and finally deleting the files for both directories:
The code is as follows |
Copy Code |
Var fso, F1, F2, s; FSO = new ActiveXObject ("Scripting.FileSystemObject"); F1 = fso. CreateTextFile ("C://testfile.txt", true); Write a line F1. Write ("This is a test."); Close File F1. Close (); Get the file handle in the c:/root directory F2 = fso. GetFile ("C://testfile.txt"); Move files to/tmp directory F2. Move ("C://tmp//testfile.txt"); Copy files to the/temp directory F2. Copy ("C://temp//testfile.txt"); Get file Handle F2 = fso. GetFile ("C://tmp//testfile.txt"); F3 = FSO. GetFile ("C://temp//testfile.txt"); deleting files F2. Delete (); F3. Delete (); |