fs: drop duplicate API in promises mode · nodejs/node@2ffb9d6

.catch(() => console.log('The file could not be copied'));

```

### fsPromises.fchmod(filehandle, mode)

<!-- YAML

added: v10.0.0

-->

* `filehandle` {FileHandle}

* `mode` {integer}

* Returns: {Promise}

Asynchronous fchmod(2). The `Promise` is resolved with no arguments upon

success.

### fsPromises.fchown(filehandle, uid, gid)

<!-- YAML

added: v10.0.0

-->

* `filehandle` {FileHandle}

* `uid` {integer}

* `gid` {integer}

* Returns: {Promise}

Changes the ownership of the file represented by `filehandle` then resolves

the `Promise` with no arguments upon success.

### fsPromises.fdatasync(filehandle)

<!-- YAML

added: v10.0.0

-->

* `filehandle` {FileHandle}

* Returns: {Promise}

Asynchronous fdatasync(2). The `Promise` is resolved with no arguments upon

success.

### fsPromises.fstat(filehandle)

<!-- YAML

added: v10.0.0

-->

* `filehandle` {FileHandle}

* Returns: {Promise}

Retrieves the [`fs.Stats`][] for the given `filehandle`.

### fsPromises.fsync(filehandle)

<!-- YAML

added: v10.0.0

-->

* `filehandle` {FileHandle}

* Returns: {Promise}

Asynchronous fsync(2). The `Promise` is resolved with no arguments upon

success.

### fsPromises.ftruncate(filehandle[, len])

<!-- YAML

added: v10.0.0

-->

* `filehandle` {FileHandle}

* `len` {integer} **Default:** `0`

* Returns: {Promise}

Truncates the file represented by `filehandle` then resolves the `Promise`

with no arguments upon success.

If the file referred to by the `FileHandle` was larger than `len` bytes, only

the first `len` bytes will be retained in the file.

For example, the following program retains only the first four bytes of the

file:

```js

console.log(fs.readFileSync('temp.txt', 'utf8'));

// Prints: Node.js

async function doTruncate() {

const fd = await fsPromises.open('temp.txt', 'r+');

await fsPromises.ftruncate(fd, 4);

console.log(fs.readFileSync('temp.txt', 'utf8')); // Prints: Node

}

doTruncate().catch(console.error);

```

If the file previously was shorter than `len` bytes, it is extended, and the

extended part is filled with null bytes (`'\0'`). For example,

```js

console.log(fs.readFileSync('temp.txt', 'utf8'));

// Prints: Node.js

async function doTruncate() {

const fd = await fsPromises.open('temp.txt', 'r+');

await fsPromises.ftruncate(fd, 10);

console.log(fs.readFileSync('temp.txt', 'utf8')); // Prints Node.js\0\0\0

}

doTruncate().catch(console.error);

```

The last three bytes are null bytes (`'\0'`), to compensate the over-truncation.

### fsPromises.futimes(filehandle, atime, mtime)

<!-- YAML

added: v10.0.0

-->

* `filehandle` {FileHandle}

* `atime` {number|string|Date}

* `mtime` {number|string|Date}

* Returns: {Promise}

Change the file system timestamps of the object referenced by the supplied

`FileHandle` then resolves the `Promise` with no arguments upon success.

This function does not work on AIX versions before 7.1, it will resolve the

`Promise` with an error using code `UV_ENOSYS`.

### fsPromises.lchmod(path, mode)

<!-- YAML

deprecated: v10.0.0

a colon, Node.js will open a file system stream, as described by

[this MSDN page][MSDN-Using-Streams].

### fsPromises.read(filehandle, buffer, offset, length, position)

<!-- YAML

added: v10.0.0

-->

* `filehandle` {FileHandle}

* `buffer` {Buffer|Uint8Array}

* `offset` {integer}

* `length` {integer}

* `position` {integer}

* Returns: {Promise}

Read data from the file specified by `filehandle`.

`buffer` is the buffer that the data will be written to.

`offset` is the offset in the buffer to start writing at.

`length` is an integer specifying the number of bytes to read.

`position` is an argument specifying where to begin reading from in the file.

If `position` is `null`, data will be read from the current file position,

and the file position will be updated.

If `position` is an integer, the file position will remain unchanged.

Following successful read, the `Promise` is resolved with an object with a

`bytesRead` property specifying the number of bytes read, and a `buffer`

property that is a reference to the passed in `buffer` argument.

### fsPromises.readdir(path[, options])

<!-- YAML

added: v10.0.0

- If the value can not be converted to a number, or is `NaN`, `Infinity` or

`-Infinity`, an `Error` will be thrown.

### fsPromises.write(filehandle, buffer[, offset[, length[, position]]])

<!-- YAML

added: v10.0.0

-->

* `filehandle` {FileHandle}

* `buffer` {Buffer|Uint8Array}

* `offset` {integer}

* `length` {integer}

* `position` {integer}

* Returns: {Promise}

Write `buffer` to the file specified by `filehandle`.

The `Promise` is resolved with an object containing a `bytesWritten` property

identifying the number of bytes written, and a `buffer` property containing

a reference to the `buffer` written.

`offset` determines the part of the buffer to be written, and `length` is

an integer specifying the number of bytes to write.

`position` refers to the offset from the beginning of the file where this data

should be written. If `typeof position !== 'number'`, the data will be written

at the current position. See pwrite(2).

It is unsafe to use `fsPromises.write()` multiple times on the same file

without waiting for the `Promise` to be resolved (or rejected). For this

scenario, `fs.createWriteStream` is strongly recommended.

On Linux, positional writes do not work when the file is opened in append mode.

The kernel ignores the position argument and always appends the data to

the end of the file.

### fsPromises.writeFile(file, data[, options])

<!-- YAML

added: v10.0.0