{"id":51144,"date":"2022-07-12T04:20:37","date_gmt":"2022-07-12T07:20:37","guid":{"rendered":"https:\/\/kinsta.com\/pt\/?p=51144&post_type=knowledgebase&preview_id=51144"},"modified":"2025-10-01T17:03:54","modified_gmt":"2025-10-01T20:03:54","slug":"nodejs-fs","status":"publish","type":"post","link":"https:\/\/kinsta.com\/pt\/blog\/nodejs-fs\/","title":{"rendered":"Entendendo o M\u00f3dulo do Sistema de Arquivos Node.js (FS)"},"content":{"rendered":"

O JavaScript tem sido uma das linguagens de script mais populares, mas por um longo per\u00edodo, n\u00e3o foi uma grande escolha para o desenvolvimento de aplicativos backend do lado do servidor. Ent\u00e3o veio o Node.js, usado para criar aplicativos leves, orientados a eventos, constru\u00eddos usando a linguagem de programa\u00e7\u00e3o JavaScript.<\/p>\n

Node.js \u00e9 um JavaScript de c\u00f3digo aberto runtime<\/a> que est\u00e1 dispon\u00edvel para download e instala\u00e7\u00e3o gratuita em qualquer um dos principais sistemas operacionais (Windows, Mac, Linux). Ele tem se tornado cada vez mais popular entre os criadores de aplicativos<\/a> nos \u00faltimos anos, e tem fornecido novas oportunidades de emprego<\/a> para desenvolvedores de JavaScript que buscam uma especialidade.<\/p>\n\n

Neste artigo, vamos aprender sobre como gerenciar o sistema de arquivos usando o Node.js. \u00c9 f\u00e1cil usar as APIs do Node.js para interagir com o sistema de arquivos e realizar muitas opera\u00e7\u00f5es complexas, e saber como manobrar atrav\u00e9s delas ir\u00e1 aumentar sua produtividade.<\/p>\n

Vamos come\u00e7ar!<\/p>\n

<\/div><\/kinsta-auto-toc>\n

Pr\u00e9-requisitos para entender o sistema de arquivos Node.js<\/h2>\n

O principal pr\u00e9-requisito \u00e9 a instala\u00e7\u00e3o do Node.js no seu sistema operacional. O Node.js n\u00e3o requer nenhum hardware complexo para executar, facilitando o download e a instala\u00e7\u00e3o do Node.js<\/a> em seu computador.<\/p>\n

Ajudaria se voc\u00ea tamb\u00e9m tivesse um conhecimento b\u00e1sico de JavaScript<\/a> para trabalhar em m\u00f3dulos Node.js como sistemas de arquivos (tamb\u00e9m conhecidos como “FS” ou “fs”). Um entendimento de alto n\u00edvel das fun\u00e7\u00f5es JavaScript, fun\u00e7\u00f5es de retorno de chamada (callback) e promessas o ajudar\u00e1 a compreender esse assunto ainda<\/a> mais r\u00e1pido.<\/p>\n

M\u00f3dulo de sistema de arquivos do Node.js<\/h2>\n

Trabalhar com arquivos e diret\u00f3rios \u00e9 uma das necessidades b\u00e1sicas de um aplicativo fullstack. Seus usu\u00e1rios podem querer enviar imagens, curr\u00edculos ou outros arquivos para um servidor. Ao mesmo tempo, seu aplicativo pode precisar ler arquivos de configura\u00e7\u00e3o, mover arquivos, ou mesmo mudar suas permiss\u00f5es programaticamente.<\/p>\n

O m\u00f3dulo de sistema de arquivos Node.js tem tudo isso. Ele fornece v\u00e1rias APIs para interagir com os sistemas de arquivos de forma transparente. A maioria das APIs s\u00e3o customiz\u00e1veis com op\u00e7\u00f5es e flags. Voc\u00ea tamb\u00e9m pode us\u00e1-las para realizar opera\u00e7\u00f5es de arquivo tanto s\u00edncronas quanto ass\u00edncronas.<\/p>\n

Antes de abordarmos detalhadamente o m\u00f3dulo de sistema de arquivos, vamos dar uma olhada no que o m\u00f3dulo Node.js \u00e9.<\/p>\n

M\u00f3dulos do Node.js<\/h3>\n

Os m\u00f3dulos Node.js s\u00e3o um conjunto de funcionalidades dispon\u00edveis como APIs para um programa de consumo a ser utilizado. Por exemplo, voc\u00ea tem o m\u00f3dulo fs<\/code> para interagir com o sistema de arquivos. Da mesma forma, um m\u00f3dulo http<\/code> utiliza suas fun\u00e7\u00f5es para criar um servidor e muitas outras opera\u00e7\u00f5es. O Node.js oferece muitos m\u00f3dulos para abstrair muitas funcionalidades de baixo n\u00edvel para voc\u00ea.<\/p>\n

Voc\u00ea pode fazer seus pr\u00f3prios m\u00f3dulos tamb\u00e9m. Com Node.js vers\u00e3o 14 e seguintes, voc\u00ea pode criar e usar os m\u00f3dulos Node.js de duas maneiras: M\u00f3dulos CommonJS (CJS) e ESM (MJS). Todos os exemplos que veremos neste artigo est\u00e3o no estilo CJS.<\/p>\n

Trabalhando com arquivos no Node.js<\/h2>\n

Trabalhar com arquivos envolve v\u00e1rias opera\u00e7\u00f5es com arquivos e diret\u00f3rios (pastas). Agora vamos aprender sobre cada uma dessas opera\u00e7\u00f5es com exemplos de c\u00f3digo-fonte. Abra seu editor de c\u00f3digo-fonte<\/a> favorito e teste conforme a explica\u00e7\u00e3o.<\/p>\n

Primeiro, importe o m\u00f3dulo fs<\/code> para o seu arquivo-fonte para come\u00e7ar a trabalhar com os m\u00e9todos do sistema de arquivos. No estilo CJS, usamos o m\u00e9todo require<\/code> para importar um m\u00e9todo a partir de um m\u00f3dulo. Ent\u00e3o, para importar e usar os m\u00e9todos do m\u00f3dulo fs, voc\u00ea faria isso:<\/p>\n

const { writeFile } = require('fs\/promises');<\/code><\/pre>\n
Al\u00e9m disso, note que estamos importando o m\u00e9todo writeFile<\/code> a partir do pacote fs\/promises<\/code>. Queremos usar os m\u00e9todos com promessas porque s\u00e3o mais recentes e f\u00e1ceis de usar com as palavras-chave async\/await e exigem menos c\u00f3digo. Outras alternativas s\u00e3o os m\u00e9todos s\u00edncronos e as fun\u00e7\u00f5es de callback que veremos mais adiante.<\/p>\n
Como criar e escrever em um arquivo<\/h3>\n
Voc\u00ea pode criar e escrever em um arquivo de tr\u00eas maneiras:<\/p>\n
    \n
  1. Usando o m\u00e9todo writeFile<\/code><\/li>\n
  2. Usando o m\u00e9todo appendFile<\/code><\/li>\n
  3. Usando o m\u00e9todo openFile<\/code><\/li>\n<\/ol>\n
    Estes m\u00e9todos aceitam um caminho de arquivo e os dados como conte\u00fado para escrever no arquivo. Se o arquivo existe, eles substituem o conte\u00fado do arquivo. Caso contr\u00e1rio, eles criam um novo arquivo com o conte\u00fado.<\/p>\n
    1. Usando o m\u00e9todo writeFile<\/h4>\n
    O trecho de c\u00f3digo abaixo mostra o uso do m\u00e9todo writeFile<\/code>. Comece criando um arquivo chamado createFile.js<\/strong> usando o snippet abaixo:<\/p>\n
    const { writeFile } = require('fs\/promises');\nasync function writeToFile(fileName, data) {\n  try {\n    await writeFile(fileName, data);\n    console.log(`Wrote data to ${fileName}`);\n  } catch (error) {\n    console.error(`Got an error trying to write the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Note que estamos usando a palavra-chave await<\/code> para chamar o m\u00e9todo, uma vez que ele retorna uma promessa JavaScript. Uma promessa de sucesso ir\u00e1 criar\/escrever no arquivo. Temos um bloco de tentativas para lidar com erros caso a promessa seja rejeitada.<\/p>\n
    Agora podemos chamar a fun\u00e7\u00e3o writeToFile<\/code>:<\/p>\n
    writeToFile('friends.txt', 'Bob');<\/code><\/pre>\n
    Em seguida, abra um prompt de comando ou terminal e execute o programa acima usando o seguinte comando:<\/p>\n
    node createFile.js<\/code><\/pre>\n
    Ele ir\u00e1 criar um novo arquivo chamado friends.txt<\/strong> com uma linha que simplesmente diz:<\/p>\n
    Bob<\/code><\/pre>\n
    2. Usando o m\u00e9todo appendFile<\/h4>\n
    Como o nome indica, o principal uso deste m\u00e9todo \u00e9 anexar e editar um arquivo. Entretanto, voc\u00ea tamb\u00e9m pode usar o mesmo m\u00e9todo para criar um arquivo.<\/p>\n
    Observe a fun\u00e7\u00e3o abaixo. Usamos o m\u00e9todo appendFile<\/code> com a flag w<\/code> para escrever um arquivo. A flag padr\u00e3o para anexar a um arquivo \u00e9 a<\/code>:<\/p>\n
    const { appendFile} = require('fs\/promises');\n\nasync function appendToFile(fileName, data) {\n  try {\n    await appendFile(fileName, data, { flag: 'w' });\n    console.log(`Appended data to ${fileName}`);\n  } catch (error) {\n    console.error(`Got an error trying to append the file: {error.message}`);\n  }\n}<\/code><\/pre>\n
    Agora, voc\u00ea pode chamar a fun\u00e7\u00e3o acima desta forma:<\/p>\n
    appendToFile('activities.txt', 'Skiing');<\/code><\/pre>\n
    Em seguida, voc\u00ea pode executar o c\u00f3digo no ambiente Node.js usando o comando node, como vimos anteriormente. Isso criar\u00e1 um arquivo chamado activities.txt<\/strong> com o conte\u00fado Skiing<\/code> nele.<\/p>\n
    3. Usando o m\u00e9todo open<\/h4>\n
    O \u00faltimo m\u00e9todo que vamos aprender para criar e escrever em um arquivo \u00e9 o m\u00e9todo open<\/code>. Voc\u00ea pode abrir um arquivo usando a flag w<\/code> (para “write”):<\/p>\n
    const { open} = require('fs\/promises');\n\nasync function openFile(fileName, data) {\n  try {\n    const file = await open(fileName, 'w');\n    await file.write(data);\n    console.log(`Opened file ${fileName}`);\n  } catch (error) {\n    console.error(`Got an error trying to open the file: {error.message}`);\n  }\n}<\/code><\/pre>\n
    Agora chame a fun\u00e7\u00e3o openFile<\/code> com:<\/p>\n
    openFile('tasks.txt', 'Do homework');<\/code><\/pre>\n
    Quando voc\u00ea executar o script usando o comando node, voc\u00ea ter\u00e1 um arquivo chamado tasks.txt<\/strong> criado com o conte\u00fado inicial:<\/p>\n
    Do homework<\/code><\/pre>\n
    Como ler um arquivo<\/h3>\n
    Agora que sabemos como criar e escrever em um arquivo, vamos aprender a ler o conte\u00fado do arquivo. Vamos usar o m\u00e9todo readFile<\/code> do m\u00f3dulo de sistema de arquivos para fazer isso.<\/p>\n
    Crie um arquivo chamado readThisFile.js<\/strong> com o seguinte c\u00f3digo:<\/p>\n
    \/\/ readThisFile.js\nconst { readFile } = require('fs\/promises');\nasync function readThisFile(filePath) {\n  try {\n    const data = await readFile(filePath);\n    console.log(data.toString());\n  } catch (error) {\n    console.error(`Got an error trying to read the file: {error.message}`);\n }\n}<\/code><\/pre>\n
    Agora vamos ler todos os tr\u00eas arquivos que criamos invocando a fun\u00e7\u00e3o readThisFile<\/code>:<\/p>\n
    readThisFile('activities.txt');\nreadThisFile('friends.txt');\nreadThisFile('tasks.txt');<\/code><\/pre>\n
    Finalmente, execute o script usando o seguinte comando de Node:<\/p>\n
    node readThisFile.js<\/code><\/pre>\n
    Voc\u00ea deve ver a seguinte sa\u00edda no console:<\/p>\n
    Skiing\nDo homework\nBob<\/code><\/pre>\n
    Um ponto a ser observado aqui: O m\u00e9todo readFile<\/code> l\u00ea o arquivo de forma ass\u00edncrona. Isso significa que a ordem que voc\u00ea l\u00ea o arquivo e a ordem que voc\u00ea obt\u00e9m uma resposta para imprimir no console pode n\u00e3o ser a mesma. Voc\u00ea tem que usar a vers\u00e3o s\u00edncrona do m\u00e9todo readFile<\/code> para obt\u00ea-lo em ordem. Veremos isso aqui em pouco tempo.<\/p>\n
    Como renomear um arquivo<\/h3>\n
    Para renomear um arquivo, use o m\u00e9todo de renomea\u00e7\u00e3o do m\u00f3dulo fs. Vamos criar um arquivo chamado renamee-me.txt<\/strong>. Vamos renomear este arquivo programaticamente.<\/p>\n
    Crie um arquivo chamado renomeFile.js<\/strong> com o seguinte c\u00f3digo:<\/p>\n
    const { rename } = require('fs\/promises');\n\nasync function renameFile(from, to) {\n  try {\n    await rename(from, to);\n    console.log(`Renamed ${from} to ${to}`);\n  } catch (error) {\n    console.error(`Got an error trying to rename the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Como voc\u00ea deve ter notado, o m\u00e9todo de renomea\u00e7\u00e3o leva dois argumentos. Um \u00e9 o arquivo com o nome da fonte, e o outro \u00e9 o nome do alvo.<\/p>\n
    Agora vamos chamar a fun\u00e7\u00e3o acima para renomear o arquivo:<\/p>\n
    const oldName = \"rename-me.txt\";\nconst newName = \"renamed.txt\";\nrenameFile(oldName, newName);<\/code><\/pre>\n
    Como antes, execute o arquivo de script usando o comando de Node para renomear o arquivo:<\/p>\n
    node renameFile.js<\/code><\/pre>\n
    Como mover um arquivo<\/h3>\n
    Mover um arquivo de um diret\u00f3rio para outro \u00e9 similar a renomear seu caminho. Ent\u00e3o, podemos usar o pr\u00f3prio m\u00e9todo rename<\/code> para mover arquivos.<\/p>\n
    Vamos criar duas pastas, from<\/strong>\u00a0e to<\/strong>. Ent\u00e3o vamos criar um arquivo chamado move-me.txt <\/strong>dentro da pasta from<\/strong>\u00a0e to<\/strong>.<\/p>\n
    A seguir, escreveremos o c\u00f3digo para mover o arquivo move-me.txt.<\/strong> Crie um arquivo chamado moveFile.js<\/strong> com o seguinte snippet:<\/p>\n
    const { rename } = require('fs\/promises');\nconst { join } = require('path');\nasync function moveFile(from, to) {\n  try {\n    await rename(from, to);\n    console.log(`Moved ${from} to ${to}`);\n  } catch (error) {\n    console.error(`Got an error trying to move the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Como voc\u00ea pode ver, estamos usando o m\u00e9todo rename<\/code> exatamente como antes. Mas por que precisamos importar o m\u00e9todo join<\/code> do m\u00f3dulo path<\/code> (sim, o caminho \u00e9 outro m\u00f3dulo crucial do Node.js)?<\/p>\n
    O m\u00e9todo join<\/code> \u00e9 usado para unir v\u00e1rios segmentos de caminho especificados para formar um caminho. O usaremos para formar o caminho dos nomes dos arquivos de origem e destino:<\/p>\n
    const fromPath = join(__dirname, \"from\", \"move-me.txt\");\nconst destPath = join(__dirname, \"to\", \"move-me.txt\");\nmoveFile(fromPath, destPath);<\/code><\/pre>\n
    E \u00e9 isso a\u00ed! Se voc\u00ea executar o script moveFile.js<\/strong>, voc\u00ea ver\u00e1 o arquivo move-me.txt<\/strong> movido para a pasta move-me.txt<\/strong>.<\/p>\n
    Como copiar um arquivo<\/h3>\n
    Usamos o m\u00e9todo copyFile<\/code> do m\u00f3dulo fs<\/code> para copiar um arquivo da fonte para o destino.<\/p>\n
    Observe o snippet de c\u00f3digo abaixo:<\/p>\n
    const { copyFile } = require('fs\/promises');\nconst { join } = require('path');\nasync function copyAFile(from, to) {\n  try {\n    await copyFile(from, to);\n    console.log(`Copied ${from} to ${to}`);\n  } catch (err) {\n    console.error(`Got an error trying to copy the file: ${err.message}`);\n  }\n}<\/code><\/pre>\n
    Agora voc\u00ea pode chamar a fun\u00e7\u00e3o acima com:<\/p>\n
    copyAFile('friends.txt', 'friends-copy.txt');<\/code><\/pre>\n
    Ele ir\u00e1 copiar o conte\u00fado do friends.txt<\/strong> para o arquivo friends-copy.txt<\/strong>.<\/p>\n
    Agora, isso \u00e9 \u00f3timo, mas como voc\u00ea copia m\u00faltiplos arquivos?<\/p>\n
    Voc\u00ea pode usar a API Promise.all<\/code> para executar m\u00faltiplas promessas em paralelo:<\/p>\n
    async function copyAll(fromDir, toDir, filePaths) {\n  return Promise.all(filePaths.map(filePath => {\n   return copyAFile(join(fromDir, filePath), join(toDir, filePath));\n  }));\n}<\/code><\/pre>\n
    Agora voc\u00ea pode fornecer todos os caminhos de arquivos para copiar de um diret\u00f3rio para outro:<\/p>\n
    copyFiles('from', 'to', ['copyA.txt', 'copyB.txt']);<\/code><\/pre>\n
    Voc\u00ea tamb\u00e9m pode usar esta abordagem para realizar outras opera\u00e7\u00f5es como mover, escrever e ler arquivos em paralelo.<\/p>\n
    Como excluir um arquivo<\/h3>\n
    Usamos o m\u00e9todo unlink<\/code> para excluir um arquivo:<\/p>\n
    const { unlink } = require('fs\/promises');\nasync function deleteFile(filePath) {\n  try {\n    await unlink(filePath);\n    console.log(`Deleted ${filePath}`);\n  } catch (error) {\n    console.error(`Got an error trying to delete the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Lembre-se, voc\u00ea precisar\u00e1 fornecer o caminho para o arquivo para excluir:<\/p>\n
    deleteFile('delete-me.txt');<\/code><\/pre>\n
    Note que se o caminho for um link simb\u00f3lico para outro arquivo, o m\u00e9todo de destravamento cancelar\u00e1 o link simb\u00f3lico, mas o arquivo original ser\u00e1 intocado. Falaremos mais sobre links simb\u00f3licos mais tarde.<\/p>\n
    Como mudar as permiss\u00f5es e a propriedade do arquivo<\/h3>\n
    Voc\u00ea pode, em algum momento, querer mudar programaticamente as permiss\u00f5es dos arquivos. Isso pode ser muito \u00fatil para tornar um arquivo somente leitura ou totalmente acess\u00edvel.<\/p>\n
    Usaremos o m\u00e9todo chmod<\/code> para mudar a permiss\u00e3o de um arquivo:<\/p>\n
    const { chmod } = require('fs\/promises');\nasync function changePermission(filePath, permission) {\n  try {\n    await chmod(filePath, permission);\n    console.log(`Changed permission to ${permission} for ${filePath}`);\n  } catch (error) {\n    console.error(`Got an error trying to change permission: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Podemos passar o caminho do arquivo e o bitmask de permiss\u00e3o para alterar as permiss\u00f5es.<\/p>\n
    Aqui est\u00e1 a chamada de fun\u00e7\u00e3o para alterar a permiss\u00e3o de um arquivo para somente leitura:<\/p>\n
    changePermission('permission.txt', 0o400);<\/code><\/pre>\n
    Semelhante \u00e0 permiss\u00e3o, voc\u00ea tamb\u00e9m pode mudar a propriedade de um arquivo programaticamente. Usamos o m\u00e9todo chown<\/code> para fazer isso:<\/p>\n
    const { chown } = require('fs\/promises');\n\nasync function changeOwnership(filePath, userId, groupId) {\n  try {\n    await chown(filePath, userId, groupId);\n    console.log(`Changed ownership to ${userId}:${groupId} for ${filePath}`);\n  } catch (error) {\n    console.error(`Got an error trying to change ownership: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Ent\u00e3o chamamos a fun\u00e7\u00e3o com o caminho do arquivo, ID do usu\u00e1rio e ID do grupo:<\/p>\n
    changeOwnership('ownership.txt', 1000, 1010);<\/code><\/pre>\n
    Como criar um symlink<\/h3>\n
    O link simb\u00f3lico (tamb\u00e9m conhecido como symlink)<\/a> \u00e9 um conceito de sistema de arquivos para criar um link para um arquivo ou pasta. Criamos links simb\u00f3licos para criar shortcodes para um arquivo\/pasta de destino no sistema de arquivos. O m\u00f3dulo Node.js filesystem<\/code> fornece o m\u00e9todo symlink<\/code> para criar um link simb\u00f3lico.<\/p>\n
    Para criar o link simb\u00f3lico, precisamos passar o caminho do arquivo alvo, o caminho do arquivo real e digitar:<\/p>\n
    const { symlink } = require('fs\/promises');\nconst { join } = require('path');\nasync function createSymlink(target, path, type) {\n  try {\n    await symlink(target, path, type);\n    console.log(`Created symlink to ${target} at ${path}`);\n  } catch (error) {\n    console.error(`Got an error trying to create the symlink: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Podemos chamar a fun\u00e7\u00e3o:<\/p>\n
    createSymlink('join(__dirname, from, symMe.txt)', 'symToFile', 'file');<\/code><\/pre>\n
    Aqui criamos um link simb\u00f3lico chamado symToFile<\/code>.<\/p>\n
    Como observar as altera\u00e7\u00f5es de um arquivo<\/h3>\n
    Voc\u00ea sabia que voc\u00ea pode observar as altera\u00e7\u00f5es acontecendo em um arquivo? \u00c9 uma \u00f3tima maneira de monitorar altera\u00e7\u00f5es e eventos, especialmente quando voc\u00ea n\u00e3o est\u00e1 esperando por eles. Voc\u00ea pode captur\u00e1-las e audit\u00e1-las para revis\u00e3o posterior.<\/p>\n
    O m\u00e9todo watch<\/code> \u00e9 a melhor maneira de assistir \u00e0s altera\u00e7\u00f5es de arquivo. H\u00e1 um m\u00e9todo alternativo chamado watchFile<\/code>, mas n\u00e3o \u00e9 t\u00e3o performante quanto o m\u00e9todo watch<\/code>.<\/p>\n
    At\u00e9 agora, usamos o m\u00e9todo de m\u00f3dulo de sistema de arquivos com palavras-chave async\/await. Veremos os usos da fun\u00e7\u00e3o callback com este exemplo.<\/p>\n
    O m\u00e9todo watch<\/code> aceita o caminho do arquivo e uma fun\u00e7\u00e3o de chamada de retorno como argumentos. Sempre que uma atividade ocorre no arquivo, a fun\u00e7\u00e3o callback<\/code> \u00e9 chamada.<\/p>\n
    Podemos aproveitar o par\u00e2metro event<\/code> para obter mais informa\u00e7\u00f5es sobre as atividades:<\/p>\n
    const fs = require('fs');\nfunction watchAFile(file) {\n  fs.watch(file, (event, filename) => {\n    console.log(`${filename} file Changed`);\n  });\n}<\/code><\/pre>\n
    Chame a fun\u00e7\u00e3o passando um nome de arquivo para watch<\/code>:<\/p>\n
    watchAFile('friends.txt');<\/code><\/pre>\n
    Agora estamos capturando automaticamente qualquer atividade no arquivo friends.txt.<\/strong><\/p>\n
    Trabalhando com diret\u00f3rios (pastas) no Node.js<\/h2>\n
    Vamos aprender como realizar opera\u00e7\u00f5es em diret\u00f3rios ou pastas. Muitas das opera\u00e7\u00f5es como renomear, mover e copiar s\u00e3o similares ao que vimos para os arquivos. Entretanto, m\u00e9todos e opera\u00e7\u00f5es espec\u00edficas s\u00e3o utiliz\u00e1veis apenas em diret\u00f3rios.<\/p>\n
    Como criar um diret\u00f3rio<\/h3>\n
    Usamos o m\u00e9todo mkdir<\/code> para criar um diret\u00f3rio. Voc\u00ea precisa passar o nome do diret\u00f3rio como um argumento:<\/p>\n
    const { mkdir } = require('fs\/promises');\nasync function createDirectory(path) {\n  try {\n    await mkdir(path);\n    console.log(`Created directory ${path}`);\n  } catch (error) {\n    console.error(`Got an error trying to create the directory: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Agora podemos invocar a fun\u00e7\u00e3o createDirectory<\/code> com um caminho de diret\u00f3rio:<\/p>\n
    createDirectory('new-directory');<\/code><\/pre>\n
    Isso ir\u00e1 criar um diret\u00f3rio chamado new-directory<\/strong>.<\/p>\n
    Como criar um diret\u00f3rio tempor\u00e1rio<\/h3>\n
    Os diret\u00f3rios tempor\u00e1rios n\u00e3o s\u00e3o diret\u00f3rios regulares. Eles t\u00eam um significado especial para o sistema operacional. Voc\u00ea pode criar um diret\u00f3rio tempor\u00e1rio usando o m\u00e9todo mkdtemp()<\/code>.<\/p>\n
    Vamos criar uma pasta tempor\u00e1ria no diret\u00f3rio tempor\u00e1rio do seu sistema operacional. Obtemos as informa\u00e7\u00f5es para a localiza\u00e7\u00e3o do diret\u00f3rio tempor\u00e1rio atrav\u00e9s do m\u00e9todo tmpdir()<\/code> do m\u00f3dulo os<\/code>:<\/p>\n
    const { mkdtemp } = require('fs\/promises');\nconst { join } = require('path');\nconst { tmpdir } = require('os');\nasync function createTemporaryDirectory(fileName) {\n  try {\n    const tempDirectory = await mkdtemp(join(tmpdir(), fileName));\n    console.log(`Created temporary directory ${tempDirectory}`);\n  } catch (error) {\n    console.error(`Got an error trying to create the temporary directory: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Agora, vamos chamar a fun\u00e7\u00e3o com o nome do diret\u00f3rio para cri\u00e1-la:<\/p>\n
    createTemporaryDirectory('node-temp-file-');<\/code><\/pre>\n
    Note que Node.js adicionar\u00e1 seis caracteres aleat\u00f3rios no final do nome da pasta tempor\u00e1ria criada para mant\u00ea-la \u00fanica.<\/p>\n
    Como excluir um diret\u00f3rio<\/h3>\n
    Voc\u00ea precisa usar o m\u00e9todo rmdir()<\/code> para remover\/eliminar um diret\u00f3rio:<\/p>\n
    const { rmdir } = require('fs\/promises');\nasync function deleteDirectory(path) {\n  try {\n    await rmdir(path);\n    console.log(`Deleted directory ${path}`);\n  } catch (error) {\n    console.error(`Got an error trying to delete the directory: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Em seguida, chame a fun\u00e7\u00e3o acima, passando o caminho da pasta que voc\u00ea deseja remover:<\/p>\n
    deleteDirectory('new-directory-renamed');<\/code><\/pre>\n
    APIs s\u00edncronas vs ass\u00edncronas<\/h2>\n
    At\u00e9 agora, vimos muitos exemplos de m\u00e9todos de sistema de arquivos, e todos eles s\u00e3o com usos ass\u00edncronos. No entanto, voc\u00ea pode precisar lidar com algumas opera\u00e7\u00f5es de forma s\u00edncrona.<\/p>\n
    Um exemplo de opera\u00e7\u00e3o s\u00edncrona \u00e9 a leitura de v\u00e1rios arquivos um ap\u00f3s o outro. O m\u00f3dulo fs<\/code> tem um m\u00e9todo chamado readFileSync()<\/code> para fazer isso:<\/p>\n
    const { readFileSync } = require('fs');\nfunction readFileSynchronously(path) {\n  try {\n    const data = readFileSync(path);\n    console.log(data.toString());\n  } catch (error) {\n    console.error(error);\n  }\n}<\/code><\/pre>\n
    Note que o m\u00e9todo readFileSync()<\/code> n\u00e3o \u00e9 necess\u00e1rio a partir do pacote “fs\/promises”. Isso \u00e9 porque o m\u00e9todo n\u00e3o \u00e9 ass\u00edncrono. Portanto, voc\u00ea pode chamar a fun\u00e7\u00e3o acima com:<\/p>\n
    readFileSynchronously('activities.txt');\nreadFileSynchronously('friends.txt');\nreadFileSynchronously('tasks.txt');<\/code><\/pre>\n
    Neste caso, todos os arquivos acima ser\u00e3o lidos na ordem em que as fun\u00e7\u00f5es foram chamadas.<\/p>\n
    O m\u00f3dulo de sistema de arquivos Node.js oferece um m\u00e9todo s\u00edncrono para outras opera\u00e7\u00f5es como a opera\u00e7\u00e3o lida. Use com sabedoria e somente na base do que for necess\u00e1rio. Os m\u00e9todos ass\u00edncronos s\u00e3o muito mais \u00fateis para a execu\u00e7\u00e3o paralela.<\/p>\n
    Lidando com erros<\/h2>\n
    Como qualquer programador sabe, \u00e9 preciso esperar erros e estar preparado para lidar com eles<\/a> ao realizar opera\u00e7\u00f5es em arquivos ou diret\u00f3rios. E se o arquivo n\u00e3o for encontrado, ou se voc\u00ea n\u00e3o tiver permiss\u00e3o para escrever nele? Existem (e provavelmente haver\u00e1) muitos casos em que voc\u00ea pode encontrar um erro.<\/p>\n
    Sempre deve-se envolver as chamadas de m\u00e9todo com um bloco try-catch. Dessa forma, se ocorrer um erro, o controle ser\u00e1 transferido para o bloco catch, onde voc\u00ea pode revisar e lidar com o erro. Como voc\u00ea pode ter notado em todos os exemplos acima, utilizamos o bloco try-catch para lidar com os erros que encontramos.<\/p>\n\n
    Resumo<\/h2>\n
    Vamos rever os pontos-chave que abordamos neste tutorial:<\/p>\n