---
title: filesysteminfile
slug: develop/es/filesysteminfile
docTags: 
createdAt: 2025-03-11T07:07:19.526Z
---

El *filesysteminfile* le permite crear y actualizar sistemas de archivos para usarlos como dispositivos de almacenamiento. 

**IDL de filesysteminfile**

```text
interface FileSystemInFile {
    constructor(String path);
    Promise<String> getFilename();
    Promise<long long> getSize();
    Promise<void> format(String fileSystem);
    Promise<void> mount();
    Promise<void> unmount();
};                                                                                                                  
```

## Creación de objetos

Para crear un objeto *filesysteminfile*, cargue el módulo *@brightsign/filesysteminfile* usando el método require() de Node.js®:

```javascript
var FileSystemInFile = require('@brightsign/filesysteminfile');
var fsif = new FileSystemInFile("/storage/sd/usbstore.img"); // Node's native 'fs' can create an .img file                                                                                 
```

## filesysteminfile

Use esta interfaz para configurar un *filesysteminfile*.

### getFilename()

```javascript
Promise<String> getFilename()                                                                                                   
```

Obtiene el nombre del archivo que se utilizó para crear *FileSystemInFile.*

### getSize()

```javascript
Promise<long long> getSize()                                                                                           
```

Recupera el tamaño (en bytes) del archivo del sistema de archivos utilizado para crear la clase *FileSystemInFile*.

### format()

```javascript
Promise<void> format(String fileSystem)                                                                                            
```

Crea el sistema de archivos especificado en un archivo que ya existe. Los tipos de sistemas de archivos compatibles son "fat" y "exfat".

### mount()

```javascript
Promise<String> mount()                                                                                                 
```

Monta el sistema de archivos. No es necesario formatear el sistema de archivos si ya existe y está formateado.

La cadena devuelta es *filepath* y el valor devuelto es la ruta donde se ha montado el sistema de archivos. No puede montarse más de una vez.

### unmount()

```javascript
Promise<void> unmount()                                                                                                 
```

Desmonta el sistema de archivos.

## Ejemplo

El siguiente ejemplo crea un sistema de archivos, lo formatea, lo monta y lo desmonta usando el paquete npm *fs*, 

```javascript
const fs = require('fs');
const FileSystemInFile = require('@brightsign/filesysteminfile');

var fsif;
var fd;

open()
.then(function(fileDescriptor) {
	fd = fileDescriptor;
	return write(fd);
})
.then(function(bytes) {
	console.log(`${bytes} written to new file`);
	return close(fd);
})
.then(function() {
	// Create FileSystemInFile using the backing file
	fsif = new FileSystemInFile('/storage/sd/usbstore');

	return format();
})
.then(function() {
	return mount();
})
.then(function() {
	/* This is where you can actually do stuff with the mounted filesystem. */

	// Unmount the mounted file after 10 seconds
	setTimeout(function() {
		return unmount();
	}, 10000);
})
.catch(function(error) {
	console.log(JSON.stringify(error));
});


// Create a writable file for the file system
function open() {
	return new Promise(function(resolve, reject) {
		fs.open('/storage/sd/usbstore', 'w', function(error, fd) {
			if (error) reject(error);
			resolve(fd);
		});	
	});
};

// Write a buffer allocating 1GB of disk space for the file
function write(fd) {
	return new Promise(function(resolve, reject) {
		fs.write(fd, Buffer.alloc(1), 0, 1, (1024*1024*1024) - 1, function(error, bytesWritten) {
			if (error) reject(error);
			resolve(bytesWritten);
		});
	});
};

// Close the created file
function close(fd) {
	return new Promise(function(resolve, reject) {
		fs.close(fd, function(error) {
			if (error) reject(error);
			resolve();
		});
	});
};

// Format the file system
function format() {
	return new Promise(function(resolve, reject) {
		fsif.format("exfat")
		.then(function() {
		  console.log('Filesystem formatted');
		  resolve();
		})
		.catch(function(error) {
		  reject(error);
		});		
	});
};


// Mount the filesystem internally
function mount() {
	return new Promise(function(resolve, reject) {
		fsif.mount()
		.then(function(mount_point) {
		  console.log('Filesystem mounted' + mount_point);
		  resolve();
		})
		.catch(function(error) {
		  reject(error);
		});
	});
};

// Unmount filesystem from internal mount point. Only can unmount a mounted file
function unmount() {
	return new Promise(function(resolve, reject) {
		fsif.unmount()
		.then(function() {
		  console.log('Filesystem unmounted');
		  resolve();
		})
		.catch(function(error) {
		  reject(error);
		});
	});
};                                                                                    
```

También puede consultar nuestro [ejemplo de github](https://github.com/brightsign/usb-filesystem) público que utiliza un dispositivo BrightSign como sistema de archivos a través de USB.