One place for hosting & domains

      buscar

      Como usar a Fetch API do JavaScript para buscar dados


      Introdução

      Houve um tempo em que o XMLHttpRequest era usado para fazer solicitações de API. Ele não incluía promessas e não gerava um código JavaScript organizado. Ao usar o jQuery, usava-se a sintaxe mais organizada com o jQuery.ajax().

      Agora, o JavaScript tem sua própria maneira integrada de fazer solicitações de API. Isso é feito pela Fetch API, um novo padrão para fazer solicitações de servidor com promessas, que inclui também muitas outras funcionalidades.

      Neste tutorial, você criará solicitações GET e POST usando a Fetch API.

      Pré-requisitos

      Para concluir este tutorial, você precisará do seguinte:

      Para usar a Fetch API, chame o método fetch, que aceita a URL da API como um parâmetro:

      fetch(url)
      

      Após o método fetch(), inclua o método de promessa then():

      .then(function() {
      
      })
      

      O método fetch() retorna uma promessa. Se a promessa retornada for resolve, a função dentro do método then() é executada. Essa função contém o código para lidar com os dados recebidos da API.

      Abaixo do método then(), inclua o método catch():

      .catch(function() {
      
      });
      

      A API chamada usando fetch() pode estar inoperante ou outros erros podem ocorrer. Se isso acontecer, a promessa reject será retornada. O método catch é usado para lidar com reject. O código dentro de catch() será executado se um erro ocorrer ao chamar a API escolhida.

      Resumindo, usar a Fetch API será parecido com isto:

      fetch(url)
      .then(function() {
      
      })
      .catch(function() {
      
      });
      

      Com uma compreensão da sintaxe para usar a Fetch API, agora siga em frente para usar fetch() em uma API real.

      Passo 2 — Usando Fetch para buscar dados de uma API

      As amostras de código a seguir baseiam-se na Random User API. Usando a API, você irá buscar dez usuários e os exibirá na página usando o JavaScript puro.

      A ideia é obter todos os dados da Random User API e exibí-los em itens de lista dentro da lista de autores. Comece criando um arquivo HTML e adicionando um cabeçalho e uma lista não ordenada com o id de authors:

      <h1>Authors</h1>
      <ul id="authors"></ul>
      

      Agora, adicione identificadores script no final do seu arquivo HTML e use um seletor DOM para pegar o ul. Utilize getElementById com authors como o argumento. Lembre-se, authors é o id para o ul criado anteriormente:

      <script>
      
          const ul = document.getElementById('authors');
      
      </script>
      

      Crie uma variável constante chamada url que armazenará o URL da API que irá retornar dez usuários aleatórios:

      const url="https://randomuser.me/api/?results=10";
      

      Com ul e url instalados, é hora de criar as funções que serão usadas para criar os itens de lista. Crie uma função chamada createNode que recebe um parâmetro chamado element:

      function createNode(element) {
      
      }
      

      Mais tarde, quando o createNode for chamado, será necessário passar o nome de um elemento HTML real a ser criado.

      Dentro da função, adicione uma instrução return que retorna o element usando document.createElement():

      function createNode(element) {
          return document.createElement(element);
      }
      

      Também será necessário criar uma função chamada append que recebe dois parâmetros: parent e el:

      function append(parent, el) {
      
      }
      

      Essa função irá acrescentar el ao parent usando o document.createElement:

      function append(parent, el) {
          return parent.appendChild(el);
      }
      

      Tanto o createNode quanto o append estão prontos para o uso. Agora, com a Fetch API, chame a Random User API usando fetch() com url como o argumento:

      fetch(url)
      
      fetch(url)
        .then(function(data) {
      
          })
        })
        .catch(function(error) {
      
        });
      

      No código acima, você está chamando a Fetch API e passando o URL para a Random User API. Então, uma resposta é recebida. No entanto, a resposta recebida não é JSON, mas um objeto com uma série de métodos que podem ser usados dependendo do que você quer fazer com as informações. Para converter o objeto retornado em JSON, use o método json().

      Adicione o método then(), que irá conter uma função com um parâmetro chamado resp:

      fetch(url)
      .then((resp) => )
      

      O parâmetro resp recebe o valor do objeto retornado de fetch(url). Use o método json() para converter resp em dados JSON:

      fetch(url)
      .then((resp) => resp.json())
      

      Os dados JSON ainda precisam ser processados. Adicione outra instrução then() com uma função que tem um argumento chamado data:

      .then(function(data) {
      
          })
      })
      

      Dentro dessa função, crie uma variável chamada authors que seja definida igual à data.results:

      .then(function(data) {
          let authors = data.results;
      

      Para cada autor em authors, será criado um item de lista que exibe uma figura o nome deles. O método map() é ótimo para isso:

      let authors = data.results;
      return authors.map(function(author) {
      
      })
      

      Dentro de sua função map, crie uma variável chamada li que será definida igual a createNode com li (o elemento HTML) como o argumento:

      return authors.map(function(author) {
          let li = createNode('li');
      })
      

      Repita isso para criar um elemento span e um elemento img:

      let li = createNode('li');
      let img = createNode('img');
      let span = createNode('span');
      

      A API oferece um nome para o author e uma imagem que acompanha o nome. Defina img.src para a imagem do autor:

      let img = createNode('img');
      let span = createNode('span');
      
      img.src = author.picture.medium;
      

      O elemento span deve conter o primeiro e último nome de author. A propriedade innerHTML e a interpolação de strings permitirão fazer isso:

      img.src = author.picture.medium;
      span.innerHTML = `${author.name.first} ${author.name.last}`;
      

      Com a imagem e o elemento de lista criados juntamente com o elemento span, use a função append criada anteriormente para exibir esses elementos na página:

      append(li, img);
      append(li, span);
      append(ul, li);
      

      Com ambas as funções then() concluídas, adicione agora a função catch(). Essa função irá registrar o erro em potencial no console:

      .catch(function(error) {
        console.log(error);
      });
      

      Este é o código completo da solicitação que você criou:

      function createNode(element) {
          return document.createElement(element);
      }
      
      function append(parent, el) {
        return parent.appendChild(el);
      }
      
      const ul = document.getElementById('authors');
      const url="https://randomuser.me/api/?results=10";
      
      fetch(url)
      .then((resp) => resp.json())
      .then(function(data) {
        let authors = data.results;
        return authors.map(function(author) {
          let li = createNode('li');
          let img = createNode('img');
          let span = createNode('span');
          img.src = author.picture.medium;
          span.innerHTML = `${author.name.first} ${author.name.last}`;
          append(li, img);
          append(li, span);
          append(ul, li);
        })
      })
      .catch(function(error) {
        console.log(error);
      });
      

      Você acabou de realizar uma solicitação GET com sucesso usando a Random User API e a Fetch API. No próximo passo, irá aprender como realizar solicitações POST.

      Passo 3 — Lidando com solicitações POST

      A Fetch usa por padrão solicitações GET, mas é possível usar qualquer outro tipo de solicitação, alterar os cabeçalhos e enviar os dados. Para fazer isso, é necessário definir seu objeto e passá-lo como o segundo argumento da função fetch.

      Antes de criar uma solicitação POST, crie os dados que gostaria de enviar à API. Este será um objeto chamado data com a chave name e o valor Sammy (ou seu nome):

      const url="https://randomuser.me/api";
      
      let data = {
        name: 'Sammy'
      }
      

      Certifique-se de incluir uma variável constante que contém o link da Random User API.

      Como esta é uma solicitação POST, será necessário declarar isso explicitamente. Crie um objeto chamado fetchData:

      let fetchData = {
      
      }
      

      Esse objeto precisa incluir três chaves: method, body e headers. A chave method deve conter o valor 'POST'. body deve ser definido igual ao objeto data que acabou de ser criado. headers deve conter o valor de new Headers():

      let fetchData = {
        method: 'POST',
        body: data,
        headers: new Headers()
      }
      

      A interface Headers, que é uma propriedade da Fetch API, permite realizar várias ações em cabeçalhos de solicitação HTTP e de resposta. Se quiser aprender mais sobre isso, este artigo chamado Como definir rotas e métodos de solicitação HTTP no Express pode oferecer-lhe mais informações.

      Com esse código no lugar, a solicitação POST pode ser feita usando a Fetch API. Você incluirá url e fetchData como argumentos para sua solicitação POST fetch:

      fetch(url, fetchData)
      

      A função then() irá incluir o código que lida com a resposta recebida do servidor da Random User API:

      fetch(url, fetchData)
      .then(function() {
          // Handle response you get from the server
      });
      

      Para criar um objeto e usar a função fetch(), há também outra opção. Ao invés de criar um objeto como o fetchData, é possível usar o construtor de solicitações para criar seu objeto de solicitação. Para fazer isso, crie uma variável chamada request:

      const url="https://randomuser.me/api";
      
      let data = {
        name: 'Sara'
      }
      
      var request =
      

      A variável request deve ser definida igual a new Request. O constructo new Request recebe dois argumentos: a url da API (url) e um objeto. O objeto também deve incluir as chaves method, body e headers assim como o fetchData:

      var request = new Request(url, {
          method: 'POST',
          body: data,
          headers: new Headers()
      });
      

      Agora, request pode ser usado como o argumento único para o fetch(), uma vez que ele também inclui a url da API:

      fetch(request)
      .then(function() {
          // Handle response we get from the API
      })
      

      No conjunto, seu código ficará semelhante a este:

      const url="https://randomuser.me/api";
      
      let data = {
        name: 'Sara'
      }
      
      var request = new Request(url, {
          method: 'POST',
          body: data,
          headers: new Headers()
      });
      
      fetch(request)
      .then(function() {
          // Handle response we get from the API
      })
      

      Agora, você conhece dois métodos para criar e executar solicitações POST com a Fetch API.

      Conclusão

      Embora a Fetch API ainda não seja suportada por todos os navegadores, é uma ótima alternativa ao XMLHttpRequest. Se quiser aprender como chamar APIs da Web usando o React, confira este artigo sobre este tópico.



      Source link

      Cómo usar Find y Locate para buscar archivos en Linux


      Introducción

      Un problema al que los usuarios se enfrentan cuando utilizan por primera vez una máquina Linux es cómo encontrar los archivos que buscan.

      En esta guía, se explicará cómo utilizar el comando llamado find de manera adecuada. Eso lo ayudará a buscar archivos en su VPS utilizando diversos filtros y parámetros. También abordaremos brevemente el comando locate, que se puede utilizar para buscar archivos de distinta manera.

      Cómo buscar por nombre

      La forma más evidente de buscar archivos es por nombre.

      Para encontrar un archivo por nombre, escriba lo siguiente:

      Distingue entre mayúsculas y minúsculas, lo que significa que una búsqueda de file será diferente a File.

      Para encontrar un archivo por nombre, pero ignorar mayúsculas o minúsculas en la consulta, escriba lo siguiente:

      Si desea encontrar todos los archivos que no se ajustan a un patrón específico, puede invertir la búsqueda con -not o !. Si utiliza !, debe quitar el carácter de forma que bash no intente interpretarlo antes que find pueda actuar:

      • find -not -name "query_to_avoid"

      o

      • find ! -name "query_to_avoid"

      Cómo buscar por tipo

      Puede especificar el tipo de archivos que desea encontrar con el parámetro -type. Funciona de la siguiente manera:

      • find -type type_descriptor query

      A continuación, encontrará algunos de los descriptores más frecuentes que puede utilizar para especificar el tipo de archivo:

      Por ejemplo, si quisiéramos encontrar todos los dispositivos de caracteres en nuestro sistema, podríamos ejecutar el siguiente comando:

      Output

      /dev/parport0 /dev/snd/seq /dev/snd/timer /dev/autofs /dev/cpu/microcode /dev/vcsa7 /dev/vcs7 /dev/vcsa6 /dev/vcs6 /dev/vcsa5 /dev/vcs5 /dev/vcsa4 . . .

      Podemos buscar todos los archivos que terminan en .conf como se muestra a continuación:

      • find / -type f -name "*.conf"

      Output

      /var/lib/ucf/cache/:etc:rsyslog.d:50-default.conf /usr/share/base-files/nsswitch.conf /usr/share/initramfs-tools/event-driven/upstart-jobs/mountall.conf /usr/share/rsyslog/50-default.conf /usr/share/adduser/adduser.conf /usr/share/davfs2/davfs2.conf /usr/share/debconf/debconf.conf /usr/share/doc/apt-utils/examples/apt-ftparchive.conf . . .

      Cómo filtrar por fecha y tamaño

      Find le proporciona diversas maneras de filtrar resultados por tamaño y fecha.

      Tamaño

      Puede filtrar por tamaño utilizando el parámetro -size.

      Añadimos un sufijo al final de nuestro valor con el que se especifica cómo se cuenta. Estas son algunas opciones populares:

      • c: bytes

      • k: kilobytes

      • M: megabytes

      • G: gigabytes

      • b: bloques de 512 bytes

      Para encontrar todos los archivos que son exactamente de 50 bytes, escriba lo siguiente:

      Para encontrar todos los archivos de menos de 50 bytes, podemos utilizar la siguiente forma:

      Para encontrar todos los archivos de más de 700 megabytes, podemos utilizar el siguiente comando:

      Fecha

      Linux almacena datos de fecha de las fechas de acceso, fechas de modificación y fechas de cambio.

      • Fechas de acceso: La última vez que se leyó o se escribió un archivo.

      • Fecha de modificación: La última vez que el contenido del archivo se modificó.

      • Fecha de cambio: La última vez que se modificaron los metadatos inode del archivo.

      Podemos utilizarlos con los parámetros -atime, -mtime y -ctime. Con estos, se pueden usar los signos de más y menos para especificar mayor o menor que, como hicimos con el tamaño.

      Con el valor de este parámetro, se especifica cuántos días atrás le gustaría buscar.

      Para encontrar archivos que tengan una fecha de modificación de un día atrás, escriba lo siguiente:

      Si queremos archivos a los que se haya accedido hace menos de un día, podemos escribir lo siguiente:

      Para obtener archivos cuya metainformación se haya modificado hace más de 3 días, escriba lo siguiente:

      También existen algunos parámetros complementarios que podemos usar para especificar minutos en vez de días:

      Con esto, se mostrarán los archivos que se modificaron en el último minuto en el sistema.

      Find también puede hacer comparaciones con un archivo de referencia y mostrar los que son más recientes:

      Cómo buscar por propietario y permisos

      También puede buscar archivos por su propietario o propietario del grupo.

      Para hacerlo, utilice los parámetros -user y -group respectivamente. Busque un archivo que sea propiedad del usuario “syslog” ingresando lo siguiente:

      De igual manera, podemos especificar archivos que son propiedad del grupo “shadow” escribiendo lo siguiente:

      También podemos buscar archivos con permisos específicos.

      Si queremos que coincida un conjunto exacto de permisos, utilizamos esta forma:

      Eso relacionará los archivos con los permisos especificados.

      Si queremos especificar algún elemento con al menos esos permisos, puede utilizar esta forma:

      Eso relacionará cualquier archivo que tenga permisos adicionales. En este caso, se relacionaría un archivo con permisos de “744”.

      Cómo filtrar por profundidad

      Para esta sección, crearemos una estructura de directorio en un directorio temporal. Contendrá tres niveles de directorios, con diez directorios en el primer nivel. Cada directorio (incluido el directorio temporal) contendrá diez archivos y diez subdirectorios.

      Cree esta estructura ejecutando los siguientes comandos:

      • cd
      • mkdir -p ~/test/level1dir{1..10}/level2dir{1..10}/level3dir{1..10}
      • touch ~/test/{file{1..10},level1dir{1..10}/{file{1..10},level2dir{1..10}/{file{1..10},level3dir{1..10}/file{1..10}}}}
      • cd ~/test

      No dude en consultar las estructuras de directorios con ls y cd para entender cómo se organizan los elementos. Cuando termine, regrese al directorio de prueba:

      Trabajaremos en cómo obtener archivos específicos con esta estructura. Para comparar, primero probaremos un ejemplo con una búsqueda de nombre normal:

      Output

      ./level1dir7/level2dir8/level3dir9/file1 ./level1dir7/level2dir8/level3dir3/file1 ./level1dir7/level2dir8/level3dir4/file1 ./level1dir7/level2dir8/level3dir1/file1 ./level1dir7/level2dir8/level3dir8/file1 ./level1dir7/level2dir8/level3dir7/file1 ./level1dir7/level2dir8/level3dir2/file1 ./level1dir7/level2dir8/level3dir6/file1 ./level1dir7/level2dir8/level3dir5/file1 ./level1dir7/level2dir8/file1 . . .

      Aparecen muchos resultados. Si canalizamos el resultado en un contador, observamos que hay 1111 resultados en total:

      Output

      1111

      Probablemente, sean demasiados resultados para que le resulte útil en la mayoría de los casos. Intentemos reducirlo.

      Puede especificar la profundidad máxima de la búsqueda en el directorio de búsqueda de nivel superior:

      • find -maxdepth num -name query

      Para encontrar “file1” solo en los directorios de “level1” y superiores, puede especificar una profundidad máxima de 2 (1 para el directorio de nivel superior y 1 para los directorios de level1):

      • find -maxdepth 2 -name file1

      Output

      ./level1dir7/file1 ./level1dir1/file1 ./level1dir3/file1 ./level1dir8/file1 ./level1dir6/file1 ./file1 ./level1dir2/file1 ./level1dir9/file1 ./level1dir4/file1 ./level1dir5/file1 ./level1dir10/file1

      Esa lista es mucho más manejable.

      También se puede especificar un directorio mínimo si sabe que todos los archivos existen a partir de cierto punto en el directorio actual:

      • find -mindepth num -name query

      Podemos utilizarlo para encontrar solo los archivos al final de las ramas de los directorios:

      • find -mindepth 4 -name file

      Output

      ./level1dir7/level2dir8/level3dir9/file1 ./level1dir7/level2dir8/level3dir3/file1 ./level1dir7/level2dir8/level3dir4/file1 ./level1dir7/level2dir8/level3dir1/file1 ./level1dir7/level2dir8/level3dir8/file1 ./level1dir7/level2dir8/level3dir7/file1 ./level1dir7/level2dir8/level3dir2/file1 . . .

      Una vez más, debido a nuestra estructura de directorio con ramificaciones, obtendremos un gran número de resultados (1000).

      Puede combinar los parámetros de profundidad min y max para centrarse en un rango más pequeño:

      • find -mindepth 2 -maxdepth 3 -name file

      Output

      ./level1dir7/level2dir8/file1 ./level1dir7/level2dir5/file1 ./level1dir7/level2dir7/file1 ./level1dir7/level2dir2/file1 ./level1dir7/level2dir10/file1 ./level1dir7/level2dir6/file1 ./level1dir7/level2dir3/file1 ./level1dir7/level2dir4/file1 ./level1dir7/file1 . . .

      Cómo ejecutar y combinar comandos find

      Puede ejecutar un comando auxiliar arbitrario en todo lo que se encuentre con find mediante el uso del parámetro -exec. Eso se invoca de la siguiente manera:

      • find find_parameters -exec command_and_params {} ;

      El {} se utiliza como un marcador de posición para los archivos que se encuentren con find. El ; se utiliza para que find sepa dónde termina el comando.

      Por ejemplo, podríamos encontrar los archivos en la sección anterior que tenían 644 permisos y modificarlos para que tengan 664 permisos:

      • cd ~/test
      • find . -type f -perm 644 -exec chmod 664 {} ;

      Luego, podríamos cambiar los permisos del directorio de esta manera:

      • find . -type d -perm 755 -exec chmod 700 {} ;

      Si desea encadenar diferentes resultados, puede usar los comandos -and o -or. Si se omite, se asume el comando -and.

      • find . -name file1 -or -name file9

      Cómo encontrar archivos utilizando Locate

      Una alternativa a utilizar find es el comando locate. A menudo, este comando es más rápido y puede realizar una búsqueda en todo el sistema de archivos con facilidad.

      Puede instalar el comando en Debian o Ubuntu con apt:

      En CentOS, utilice dnf en su lugar:

      La razón por la que locate es más rápido que find es porque utiliza una base de datos de los archivos en el sistema de archivos.

      Normalmente, la base de datos se actualiza una vez al día con una secuencia de comandos de Cron, pero puede actualizarla de forma manual escribiendo lo siguiente:

      Ejecute ese comando ahora. Recuerde que la base de datos siempre debe estar actualizada si desea encontrar archivos recientemente adquiridos o creados.

      Para encontrar archivos con locate, simplemente utilice la siguiente sintaxis:

      Puede filtrar el resultado de alguna manera.

      Por ejemplo, para solo obtener archivos que contengan la consulta en sí, en vez de obtener cada archivo que contenga la consulta en los directorios en que se encuentre, puede utilizar el -b solamente para buscar el “nombre de base”:

      Para que con locate solo se obtengan resultados que todavía existen en el sistema de archivos (que no se eliminaron entre la última invocación de updatedb y la invocación actual de locate), utilice el indicador -e:

      Para ver estadísticas sobre la información que se catalogó con locate, utilice la opción -S:

      Output

      Database /var/lib/mlocate/mlocate.db: 3,315 directories 37,228 files 1,504,439 bytes in file names 594,851 bytes used to store database

      Conclusión

      Find y locate son buenas maneras de encontrar archivos en su sistema. Le corresponde decidir cuál de estas herramientas es la adecuada para cada situación.

      Find y locate son comandos potentes que se pueden reforzar combinándolos con otras utilidades mediante canalizaciones. Experimente con filtros utilizando comandos como wc, sort y grep.



      Source link