1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
|
# fs
fs module is made to provide helpers to manipulate the filesystem.
## Usage
All the following modules are exposed in `mod.ts`
### emptyDir
Ensures that a directory is empty. Deletes directory contents if the directory
is not empty. If the directory does not exist, it is created. The directory
itself is not deleted.
```ts
import { emptyDir, emptyDirSync } from "https://deno.land/std/fs/mod.ts";
emptyDir("./foo"); // returns a promise
emptyDirSync("./foo"); // void
```
### ensureDir
Ensures that the directory exists. If the directory structure does not exist, it
is created. Like mkdir -p.
```ts
import { ensureDir, ensureDirSync } from "https://deno.land/std/fs/mod.ts";
ensureDir("./bar"); // returns a promise
ensureDirSync("./ensureDirSync"); // void
```
### ensureFile
Ensures that the file exists. If the file that is requested to be created is in
directories that do not exist, these directories are created. If the file
already exists, it is **NOT MODIFIED**.
```ts
import { ensureFile, ensureFileSync } from "https://deno.land/std/fs/mod.ts";
ensureFile("./folder/targetFile.dat"); // returns promise
ensureFileSync("./folder/targetFile.dat"); // void
```
### ensureSymlink
Ensures that the link exists. If the directory structure does not exist, it is
created.
```ts
import {
ensureSymlink,
ensureSymlinkSync
} from "https://deno.land/std/fs/mod.ts";
ensureSymlink(
"./folder/targetFile.dat",
"./folder/targetFile.link.dat",
"file"
); // returns promise
ensureSymlinkSync(
"./folder/targetFile.dat",
"./folder/targetFile.link.dat",
"file"
); // void
```
### eol
Detects and format the passed string for the targeted End Of Line character.
```ts
import { format, detect, EOL } from "https://deno.land/std/fs/mod.ts";
const CRLFinput = "deno\r\nis not\r\nnode";
const Mixedinput = "deno\nis not\r\nnode";
const LFinput = "deno\nis not\nnode";
const NoNLinput = "deno is not node";
detect(LFinput); // output EOL.LF
detect(CRLFinput); // output EOL.CRLF
detect(Mixedinput); // output EOL.CRLF
detect(NoNLinput); // output null
format(CRLFinput, EOL.LF); // output "deno\nis not\nnode"
...
```
### exists
Test whether or not the given path exists by checking with the file system
```ts
import { exists, existsSync } from "https://deno.land/std/fs/mod.ts";
exists("./foo"); // returns a Promise<boolean>
existsSync("./foo"); // returns boolean
```
### globToRegExp
Generate a regex based on glob pattern and options This was meant to be using
the the `fs.walk` function but can be used anywhere else.
```ts
import { globToRegExp } from "https://deno.land/std/fs/mod.ts";
globToRegExp("foo/**/*.json", {
flags: "g",
extended: true,
globstar: true
}); // returns the regex to find all .json files in the folder foo
```
### move
Moves a file or directory. Overwrites it if option provided
```ts
import { move, moveSync } from "https://deno.land/std/fs/mod.ts";
move("./foo", "./bar"); // returns a promise
moveSync("./foo", "./bar"); // void
moveSync("./foo", "./existingFolder", { overwrite: true });
// Will overwrite existingFolder
```
### copy
copy a file or directory. Overwrites it if option provided
```ts
import { copy, copySync } from "https://deno.land/std/fs/mod.ts";
copy("./foo", "./bar"); // returns a promise
copySync("./foo", "./bar"); // void
copySync("./foo", "./existingFolder", { overwrite: true });
// Will overwrite existingFolder
```
### readJson
Reads a JSON file and then parses it into an object
```ts
import { readJson, readJsonSync } from "https://deno.land/std/fs/mod.ts";
const f = await readJson("./foo.json");
const foo = readJsonSync("./foo.json");
```
### walk
Iterate all files in a directory recursively.
```ts
import { walk, walkSync } from "https://deno.land/std/fs/mod.ts";
for (const fileInfo of walkSync(".")) {
console.log(fileInfo.filename);
}
// Async
async function printFilesNames() {
for await (const fileInfo of walk()) {
console.log(fileInfo.filename);
}
}
printFilesNames().then(() => console.log("Done!"));
```
### writeJson
Writes an object to a JSON file.
**WriteJsonOptions**
- replacer : An array of strings and numbers that acts as a approved list for
selecting the object properties that will be stringified.
- space : Adds indentation, white space, and line break characters to the
return-value JSON text to make it easier to read.
```ts
import { writeJson, writeJsonSync } from "https://deno.land/std/fs/mod.ts";
writeJson("./target.dat", { foo: "bar" }, { spaces: 2 }); // returns a promise
writeJsonSync("./target.dat", { foo: "bar" }, { replacer: ["foo"] }); // void
```
### readFileStr
Read file and output it as a string.
**ReadOptions**
- encoding : The encoding to read file. lowercased.
```ts
import { readFileStr, readFileStrSync } from "https://deno.land/std/fs/mod.ts";
readFileStr("./target.dat", { encoding: "utf8" }); // returns a promise
readFileStrSync("./target.dat", { encoding: "utf8" }); // void
```
### writeFileStr
Write the string to file.
```ts
import {
writeFileStr,
writeFileStrSync
} from "https://deno.land/std/fs/mod.ts";
writeFileStr("./target.dat", "file content"); // returns a promise
writeFileStrSync("./target.dat", "file content"); // void
```
|
