Documentation – Convertir documentos PDF usando JavaScript

Javascript-Cpp: Convertir PDF a documentos de Word en JavaScript

Fri, 04 Aug 2023 00:00:00 +0000

La operación de conversión depende del número de páginas en el documento y puede ser muy lenta. Por lo tanto, recomendamos encarecidamente usar Web Workers.

Este código demuestra una manera de descargar tareas de conversión de archivos PDF que consumen muchos recursos a un trabajador web para evitar bloquear el hilo principal de la interfaz de usuario. También ofrece una forma fácil de usar para descargar el archivo convertido.

Para editar el contenido de un archivo PDF en Microsoft Word u otros procesadores de texto que soportan los formatos DOC y DOCX. Los archivos PDF son editables, pero los archivos DOC y DOCX son más flexibles y personalizables.

Intenta convertir PDF a DOC en línea

Aspose.PDF para JavaScript te presenta la aplicación gratuita en línea “PDF to DOC”, donde puedes intentar investigar la funcionalidad y la calidad con la que trabaja.

Convertir PDF a DOC


  /*Crear Web Worker*/
  const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
  AsposePDFWebWorker.onerror = evt => console.log(`Error desde Web Worker: ${evt.message}`);
  AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
    (evt.data == 'ready') ? '¡cargado!' :
      (evt.data.json.errorCode == 0) ? `Resultado:\n${DownloadFile(evt.data.json.fileNameResult, "application/msword", evt.data.params[0])}` : `Error: ${evt.data.json.errorText}`;

  /*Manejador de eventos*/
  const ffileToDoc = e => {
    const file_reader = new FileReader();
    file_reader.onload = event => {
      /*Convertir un archivo PDF a Doc y guardar como "ResultPDFtoDoc.doc" - Pedir a Web Worker*/
      AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfToDoc', "params": [event.target.result, e.target.files[0].name, "ResultPDFtoDoc.doc"] }, [event.target.result]);
    };
    file_reader.readAsArrayBuffer(e.target.files[0]);
  };

  /*Crear un enlace para descargar el archivo resultante*/
  const DownloadFile = (filename, mime, content) => {
      mime = mime || "application/octet-stream";
      var link = document.createElement("a"); 
      link.href = URL.createObjectURL(new Blob([content], {type: mime}));
      link.download = filename;
      link.innerHTML = "Haga clic aquí para descargar el archivo " + filename;
      document.body.appendChild(link); 
      document.body.appendChild(document.createElement("br"));
      return filename;
    }

El siguiente fragmento de código JavaScript muestra un ejemplo simple de conversión de páginas PDF a archivos DOC:

Seleccione un archivo PDF para convertir.
Cree un ‘FileReader’.
Se ejecuta la función AsposePdfToDoc.
Se establece el nombre del archivo resultante, en este ejemplo “ResultPDFtoDoc.doc”.
A continuación, si el ‘json.errorCode’ es 0, entonces su archivo resultante recibe el nombre que especificó anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, hay un error en su archivo, entonces la información sobre dicho error se contendrá en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y le permite descargar el archivo resultante al sistema operativo del usuario.


  var ffileToDoc = function (e) {
    const file_reader = new FileReader();
    file_reader.onload = (event) => {
      /*Convertir un archivo PDF a Doc y guardar el "ResultPDFtoDoc.doc"*/
      const json = AsposePdfToDoc(event.target.result, e.target.files[0].name, "ResultPDFtoDoc.doc");
      if (json.errorCode == 0) document.getElementById('output').textContent = json.fileNameResult;
      else document.getElementById('output').textContent = json.errorText;
      /*Crear un enlace para descargar el archivo resultante*/
      DownloadFile(json.fileNameResult, "application/msword");
    }
    file_reader.readAsArrayBuffer(e.target.files[0]);
  }

Intente convertir PDF a DOCX en línea

Aspose.PDF para JavaScript te presenta la aplicación en línea gratuita “PDF a Word”, donde puedes probar e investigar la funcionalidad y calidad con la que trabaja.

Convertir PDF a DOCX

La API Aspose.PDF para JavaScript te permite leer y convertir documentos PDF a DOCX. DOCX es un formato bien conocido para documentos de Microsoft Word cuya estructura cambió de binario simple a una combinación de archivos XML y binarios. Los archivos Docx pueden abrirse con Word 2007 y versiones posteriores, pero no con las versiones anteriores de MS Word que soportan extensiones de archivo DOC.


  /*Crear un Web Worker*/
    const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
    AsposePDFWebWorker.onerror = evt => console.log(`Error del Web Worker: ${evt.message}`);
    AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
      (evt.data == 'ready') ? '¡cargado!' :
        (evt.data.json.errorCode == 0) ? `Resultado:\n${DownloadFile(evt.data.json.fileNameResult, "application/vnd.openxmlformats-officedocument.wordprocessingml.document", evt.data.params[0])}` : `Error: ${evt.data.json.errorText}`;

    /*Manejador de eventos*/
    const ffileToDocX = e => {
      const file_reader = new FileReader();
      file_reader.onload = event => {
        /*convertir un archivo PDF a DocX y guardar como "ResultPDFtoDocX.docx" - Preguntar al Web Worker*/
        AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfToDocX', "params": [event.target.result, e.target.files[0].name, "ResultPDFtoDocX.docx"] }, [event.target.result]);
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };
  /// [Fragmento de código]

    /*crear un enlace para descargar el archivo resultado*/
    const DownloadFile = (filename, mime, content) => {
        mime = mime || "application/octet-stream";
        var link = document.createElement("a"); 
        link.href = URL.createObjectURL(new Blob([content], {type: mime}));
        link.download = filename;
        link.innerHTML = "Haz clic aquí para descargar el archivo " + filename;
        document.body.appendChild(link); 
        document.body.appendChild(document.createElement("br"));
        return filename;
      }

El siguiente fragmento de código JavaScript muestra un ejemplo simple de cómo convertir páginas PDF en archivos DOCX:

Seleccionar un archivo PDF para convertir.
Crear un ‘FileReader’.
Se ejecuta la función AsposePdfToDocX.
Se establece el nombre del archivo resultante, en este ejemplo “ResultPDFtoDocX.docx”.
A continuación, si el ‘json.errorCode’ es 0, entonces su archivo de resultado recibe el nombre que especificó anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, hay un error en su archivo, entonces la información sobre dicho error estará contenida en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y le permite descargar el archivo resultante al sistema operativo del usuario.


  var ffileToDocX = function (e) {
    const file_reader = new FileReader();
    file_reader.onload = (event) => {
      /*convertir un archivo PDF a DocX y guardar el "ResultPDFtoDocX.docx"*/
      const json = AsposePdfToDocX(event.target.result, e.target.files[0].name, "ResultPDFtoDocX.docx");
      if (json.errorCode == 0) document.getElementById('output').textContent = json.fileNameResult;
      else document.getElementById('output').textContent = json.errorText;
      /*crear un enlace para descargar el archivo de resultado*/
      DownloadFile(json.fileNameResult, "application/vnd.openxmlformats-officedocument.wordprocessingml.document");
    }
    file_reader.readAsArrayBuffer(e.target.files[0]);
  }

Javascript-Cpp: Convertir PDF a Excel en JavaScript

Wed, 01 Nov 2023 00:00:00 +0000

Crear hojas de cálculo desde PDF usando JavaScript

Aspose.PDF para JavaScript soporta la función de convertir archivos PDF a formatos Excel y CSV.

Intenta convertir PDF a Excel en línea

Aspose.PDF para JavaScript te presenta una aplicación gratuita en línea “PDF a XLSX”, donde puedes probar la funcionalidad y calidad con la que trabaja.

La operación de conversión depende del número de páginas en el documento y puede ser muy lenta. Por lo tanto, recomendamos encarecidamente usar Web Workers.

Este código demuestra una manera de delegar tareas de conversión de archivos PDF que consumen muchos recursos a un trabajador web para evitar bloquear el hilo principal de la interfaz de usuario. También ofrece una forma fácil de usar para descargar el archivo convertido.

Convertir PDF a XLSX


  /*Crear Web Worker*/
    const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
    AsposePDFWebWorker.onerror = evt => console.log(`Error del Web Worker: ${evt.message}`);
    AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
      (evt.data == 'ready') ? '¡cargado!' :
        (evt.data.json.errorCode == 0) ? `Resultado:\n${DownloadFile(evt.data.json.fileNameResult, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", evt.data.params[0])}` : `Error: ${evt.data.json.errorText}`;

    /*Manejador de eventos*/
    const ffileToXlsX = e => {
      const file_reader = new FileReader();
      file_reader.onload = event => {
        /*convertir un archivo PDF a XlsX y guardar como "ResultPDFtoXlsX.xlsx" - Preguntar al Web Worker*/
        AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfToXlsX', "params": [event.target.result, e.target.files[0].name, "ResultPDFtoXlsX.xlsx"] }, [event.target.result]);
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };
  /// [Fragmento de código]

    /*crear un enlace para descargar el archivo de resultado*/
    const DownloadFile = (filename, mime, content) => {
        mime = mime || "application/octet-stream";
        var link = document.createElement("a"); 
        link.href = URL.createObjectURL(new Blob([content], {type: mime}));
        link.download = filename;
        link.innerHTML = "Haz clic aquí para descargar el archivo " + filename;
        document.body.appendChild(link); 
        document.body.appendChild(document.createElement("br"));
        return filename;
      }

El siguiente fragmento de código JavaScript muestra un ejemplo simple de convertir páginas PDF en archivos XlsX:

Seleccione un archivo PDF para convertir.
Cree un ‘FileReader’.
Se ejecuta la función AsposePdfToXlsX.
Se establece el nombre del archivo resultante, en este ejemplo “ResultPDFtoXlsX.xlsx”.
A continuación, si el ‘json.errorCode’ es 0, entonces su archivo resultado recibe el nombre que especificó anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, hay un error en su archivo, entonces la información sobre tal error se contendrá en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y le permite descargar el archivo resultante al sistema operativo del usuario.


  var ffileToXlsX = function (e) {
    const file_reader = new FileReader();
    file_reader.onload = (event) => {
      /*convertir un archivo PDF a XlsX y guardar el "ResultPDFtoXlsX.xlsx"*/
      const json = AsposePdfToXlsX(event.target.result, e.target.files[0].name, "ResultPDFtoXlsX.xlsx");
      if (json.errorCode == 0) document.getElementById('output').textContent = json.fileNameResult;
      else document.getElementById('output').textContent = json.errorText;
      /*crear un enlace para descargar el archivo resultante*/
      DownloadFile(json.fileNameResult, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
    }
    file_reader.readAsArrayBuffer(e.target.files[0]);
  }

Convertir PDF a CSV


    /*Crear Web Worker*/
    const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
    AsposePDFWebWorker.onerror = evt => console.log(`Error del Web Worker: ${evt.message}`);
    AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
      (evt.data == 'ready') ? '¡cargado!' :
        (evt.data.json.errorCode == 0) ? 
          `Número de archivos(tablas): ${evt.data.json.filesCount.toString()}\n${evt.data.params.forEach(
            (element, index) => DownloadFile(evt.data.json.filesNameResult[index], "text/csv", element) ) ?? ""}` : 
          `Error: ${evt.data.json.errorText}`;

    /*Manejador de eventos*/
    const ffileToCSV = e => {
      const file_reader = new FileReader();
      file_reader.onload = event => {
        /*Convertir un archivo PDF a CSV (extraer tablas) con la plantilla "ResultPdfTablesToCSV{0:D2}.csv" ({0}, {0:D2}, {0:D3}, ... formato de número de página), TAB como delimitador y guardar - Preguntar al Web Worker*/
        AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfTablesToCSV', "params": [event.target.result, e.target.files[0].name, "ResultPdfTablesToCSV{0:D2}.csv", "\t"] }, [event.target.result]);
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };

    /*Crear un enlace para descargar el archivo resultante*/
    const DownloadFile = (filename, mime, content) => {
        mime = mime || "application/octet-stream";
        var link = document.createElement("a"); 
        link.href = URL.createObjectURL(new Blob([content], {type: mime}));
        link.download = filename;
        link.innerHTML = "Haz clic aquí para descargar el archivo " + filename;
        document.body.appendChild(link); 
        document.body.appendChild(document.createElement("br"));
        return filename;
      }

El siguiente fragmento de código JavaScript muestra un ejemplo simple de convertir PDF en CSV:

Seleccione un archivo PDF para convertir.
Cree un ‘FileReader’.
Se ejecuta la función AsposePdfTablesToCSV.
Se establece el nombre del archivo resultante, en este ejemplo “ResultPdfTablesToCSV{0:D2}.csv”.
A continuación, si el ‘json.errorCode’ es 0, entonces su archivo de resultado recibe el nombre que especificó anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, habrá un error en su archivo, entonces la información sobre dicho error estará contenida en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y le permite descargar el archivo resultante al sistema operativo del usuario.


  var ffileToCSV = function (e) {
      const file_reader = new FileReader();
      file_reader.onload = (event) => {
        /*Convierta un archivo PDF a CSV (extraiga tablas) con la plantilla "ResultPdfTablesToCSV{0:D2}.csv" ({0}, {0:D2}, {0:D3}, ... formato número de página), TAB como delimitador*/
        const json = AsposePdfTablesToCSV(event.target.result, e.target.files[0].name, "ResultPdfTablesToCSV{0:D2}.csv", "\t");
        if (json.errorCode == 0) {
          document.getElementById('output').textContent = "Conteo de archivos(tablas): " + json.filesCount.toString();
          /*Crear enlaces a los archivos de resultado*/
          for (let fileIndex = 0; fileIndex < json.filesCount; fileIndex++) DownloadFile(json.filesNameResult[fileIndex], "text/csv");
        }
        else document.getElementById('output').textContent = json.errorText;
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };

Javascript-Cpp: Convertir PDF a PPTX en JavaScript

Wed, 01 Nov 2023 00:00:00 +0000

La operación de conversión depende del número de páginas en el documento y puede ser muy lenta. Por lo tanto, recomendamos encarecidamente usar Web Workers.

Este código demuestra una forma de descargar tareas de conversión de archivos PDF que consumen muchos recursos a un trabajador web para evitar bloquear el subproceso principal de la interfaz de usuario. También ofrece una forma fácil de usar para descargar el archivo convertido.

Intente convertir PDF a PowerPoint en línea

Aspose.PDF para JavaScript le presenta la aplicación gratuita en línea “PDF a PPTX”, donde puede intentar investigar la funcionalidad y calidad con la que trabaja.

Convertir PDF a PPTX


  /*Crear Web Worker*/
  const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
  AsposePDFWebWorker.onerror = evt => console.log(`Error desde Web Worker: ${evt.message}`);
  AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
    (evt.data == 'ready') ? '¡cargado!' :
      (evt.data.json.errorCode == 0) ? `Resultado:\n${DownloadFile(evt.data.json.fileNameResult, "application/vnd.openxmlformats-officedocument.presentationml.presentation", evt.data.params[0])}` : `Error: ${evt.data.json.errorText}`;

  /*Manejador de eventos*/
  const ffileToPptX = e => {
    const file_reader = new FileReader();
    file_reader.onload = event => {
      /*Convertir un archivo PDF a PptX y guardar como "ResultPDFtoPptX.pptx" - Solicitar a Web Worker*/
      AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfToPptX', "params": [event.target.result, e.target.files[0].name, "ResultPDFtoPptX.pptx"] }, [event.target.result]);
    };
    file_reader.readAsArrayBuffer(e.target.files[0]);
  };

  /*Crear un enlace para descargar el archivo resultante*/
  const DownloadFile = (filename, mime, content) => {
      mime = mime || "application/octet-stream";
      var link = document.createElement("a"); 
      link.href = URL.createObjectURL(new Blob([content], {type: mime}));
      link.download = filename;
      link.innerHTML = "Haga clic aquí para descargar el archivo " + filename;
      document.body.appendChild(link); 
      document.body.appendChild(document.createElement("br"));
      return filename;
    }

El siguiente fragmento de código JavaScript muestra un ejemplo simple de conversión de archivos PDF a PPTX:

Seleccione un archivo PDF para convertir.
Cree un ‘FileReader’.
Se ejecuta la función AsposePdfToPptX.
Se establece el nombre del archivo resultante, en este ejemplo “ResultPDFtoPptX.pptx”.
A continuación, si el ‘json.errorCode’ es 0, entonces su archivo de resultado recibe el nombre que especificó anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, hay un error en su archivo, entonces la información sobre dicho error estará contenida en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y le permite descargar el archivo resultante al sistema operativo del usuario.


  var ffileToPptX = function (e) {
    const file_reader = new FileReader();
    file_reader.onload = (event) => {
      /*Convertir un archivo PDF a PptX y guardar como "ResultPDFtoPptX.pptx"*/
      const json = AsposePdfToPptX(event.target.result, e.target.files[0].name, "ResultPDFtoPptX.pptx");
      if (json.errorCode == 0) document.getElementById('output').textContent = json.fileNameResult;
      else document.getElementById('output').textContent = json.errorText;
      /*Crear un enlace para descargar el archivo resultante*/
      DownloadFile(json.fileNameResult, "application/vnd.openxmlformats-officedocument.presentationml.presentation");
    }
    file_reader.readAsArrayBuffer(e.target.files[0]);
  }

Javascript-Cpp: Convertir PDF a Formatos de Imagen en JavaScript

Wed, 01 Nov 2023 00:00:00 +0000

Convertir PDF a Imagen en JavaScript

En este artículo, te mostraremos las opciones para convertir PDF a formatos de imagen.

Los documentos previamente escaneados a menudo se guardan en formato de archivo PDF. Sin embargo, ¿necesitas editarlo en un editor gráfico o enviarlo en formato de imagen? Tenemos una herramienta universal para ti para convertir PDF a imágenes usando La tarea más común es cuando necesitas guardar un documento PDF completo o algunas páginas específicas de un documento como un conjunto de imágenes. Aspose para JavaScript vía C++ te permite convertir PDF a formatos JPG y PNG para simplificar los pasos requeridos para obtener tus imágenes de un archivo PDF específico.

Aspose.PDF para JavaScript vía C++ soporta varias conversiones de PDF a formatos de imagen. Por favor, consulte la sección Formatos de archivo compatibles con Aspose.PDF.

La operación de conversión depende del número de páginas en el documento y puede ser muy laboriosa. Por lo tanto, recomendamos encarecidamente usar Web Workers.

Este código demuestra una forma de descargar tareas intensivas en recursos de conversión de archivos PDF a un trabajador web para evitar bloquear el hilo principal de la interfaz de usuario. También ofrece una forma fácil de usar para descargar el archivo convertido.

Intenta convertir PDF a JPEG en línea

Aspose.PDF para JavaScript te presenta una aplicación gratuita en línea “PDF to JPEG”, donde puedes intentar investigar la funcionalidad y la calidad con la que trabaja.

Convertir PDF a JPEG


  /*Crear Web Worker*/
    const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
    AsposePDFWebWorker.onerror = evt => console.log(`Error desde el Web Worker: ${evt.message}`);
    AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
      (evt.data == 'ready') ? '¡cargado!' :
        (evt.data.json.errorCode == 0) ? 
          `Cantidad de archivos(páginas): ${evt.data.json.filesCount.toString()}\n${evt.data.params.forEach(
            (element, index) => DownloadFile(evt.data.json.filesNameResult[index], "image/jpeg", element) ) ?? ""}` : 
          `Error: ${evt.data.json.errorText}`;

    /*Manejador de eventos*/
    const ffileToJpg = e => {
      const file_reader = new FileReader();
      file_reader.onload = event => {
        const password = 'owner';
        /*convertir un archivo PDF a archivos jpg con la plantilla "ResultPdfToJpg{0:D2}.jpg" ({0}, {0:D2}, {0:D3}, ... formato de número de página), resolución 150 DPI y guardar - Preguntar al Web Worker*/
        AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfPagesToJpg', "params": [event.target.result, e.target.files[0].name, "ResultPdfToJpg{0:D2}.jpg", 150] }, [event.target.result]);
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };
  /// [Fragmento de código]

    /*crear un enlace para descargar el archivo resultante*/
    const DownloadFile = (filename, mime, content) => {
        mime = mime || "application/octet-stream";
        var link = document.createElement("a"); 
        link.href = URL.createObjectURL(new Blob([content], {type: mime}));
        link.download = filename;
        link.innerHTML = "Haz clic aquí para descargar el archivo " + filename;
        document.body.appendChild(link); 
        document.body.appendChild(document.createElement("br"));
        return filename;
      }

El siguiente fragmento de código JavaScript muestra un ejemplo simple de conversión de páginas de PDF a archivos Jpeg:

Seleccione un archivo PDF para convertir.
Cree un ‘FileReader’.
Se ejecuta la función AsposePdfPagesToJpg.
Se establece el nombre del archivo resultante, en este ejemplo “ResultPdfToJpg{0:D2}.jpg”.
A continuación, si el ‘json.errorCode’ es 0, entonces su archivo de resultado recibe el nombre que especificó anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, hay un error en su archivo, entonces la información sobre dicho error estará contenida en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y le permite descargar el archivo resultante al sistema operativo del usuario.


  var ffileToJpg = function (e) {
    const file_reader = new FileReader();
    file_reader.onload = (event) => {
      /*convierte un archivo PDF a archivos jpg con la plantilla "ResultPdfToJpg{0:D2}.jpg" ({0}, {0:D2}, {0:D3}, ... formato de número de página), resolución 150 DPI y guarda*/
      const json = AsposePdfPagesToJpg(event.target.result, e.target.files[0].name, "ResultPdfToJpg{0:D2}.jpg", 150);
      if (json.errorCode == 0) {
        document.getElementById('output').textContent = "Conteo de archivos(páginas): " + json.filesCount.toString();
        /*crear enlaces a los archivos resultantes*/
        for (let fileIndex = 0; fileIndex < json.filesCount; fileIndex++) DownloadFile(json.filesNameResult[fileIndex], "image/jpeg");
      }
      else document.getElementById('output').textContent = json.errorText;
    };
    file_reader.readAsArrayBuffer(e.target.files[0]);
  };

Intenta convertir PDF a TIFF en línea

Aspose.PDF para JavaScript te presenta una aplicación gratuita en línea “PDF a TIFF”, donde puedes probar para investigar la funcionalidad y calidad con la que trabaja.

Convertir PDF a TIFF


  /*Crear Web Worker*/
    const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
    AsposePDFWebWorker.onerror = evt => console.log(`Error desde Web Worker: ${evt.message}`);
    AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
      (evt.data == 'ready') ? '¡cargado!' :
        (evt.data.json.errorCode == 0) ? 
          `Cantidad de archivos(páginas): ${evt.data.json.filesCount.toString()}\n${evt.data.params.forEach(
            (element, index) => DownloadFile(evt.data.json.filesNameResult[index], "image/tiff", element) ) ?? ""}` : 
          `Error: ${evt.data.json.errorText}`;

    /*Manejador de eventos*/
    const ffileToTiff = e => {
      const file_reader = new FileReader();
      file_reader.onload = event => {
        /*Convertir un archivo PDF a TIFF con la plantilla "ResultPdfToTiff{0:D2}.tiff" ({0}, {0:D2}, {0:D3}, ... formato de número de página), resolución de 150 DPI y guardar - Pedir a Web Worker*/
        AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfPagesToTiff', "params": [event.target.result, e.target.files[0].name, "ResultPdfToTiff{0:D2}.tiff", 150] }, [event.target.result]);
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };

    /*Crear un enlace para descargar el archivo resultante*/
    const DownloadFile = (filename, mime, content) => {
        mime = mime || "application/octet-stream";
        var link = document.createElement("a"); 
        link.href = URL.createObjectURL(new Blob([content], {type: mime}));
        link.download = filename;
        link.innerHTML = "Haz clic aquí para descargar el archivo " + filename;
        document.body.appendChild(link); 
        document.body.appendChild(document.createElement("br"));
        return filename;
      }

El siguiente fragmento de código JavaScript muestra un ejemplo simple de conversión de páginas PDF a archivos Tiff:

Seleccione un archivo PDF para convertir.
Cree un ‘FileReader’.
Se ejecuta la función AsposePdfPagesToTiff.
Se establece el nombre del archivo resultante, en este ejemplo “ResultPdfToTiff{0:D2}.tiff”.
A continuación, si el ‘json.errorCode’ es 0, entonces su DownloadFile recibe el nombre que especificó anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, hay un error en su archivo, entonces la información sobre dicho error se encontrará en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y le permite descargar el archivo resultante al sistema operativo del usuario.


    var ffileToTiff = function (e) {
      const file_reader = new FileReader();
      file_reader.onload = (event) => {
        /*Convierte un archivo PDF a TIFF con la plantilla "ResultPdfToTiff{0:D2}.tiff" ({0}, {0:D2}, {0:D3}, ... formato de número de página), resolución 150 DPI y guardar*/
        const json = AsposePdfPagesToTiff(event.target.result, e.target.files[0].name, "ResultPdfToTiff{0:D2}.tiff", 150);
        if (json.errorCode == 0) {
          document.getElementById('output').textContent = "Cantidad de archivos(páginas): " + json.filesCount.toString();
          /*Crear enlaces a los archivos resultantes*/
          for (let fileIndex = 0; fileIndex < json.filesCount; fileIndex++) DownloadFile(json.filesNameResult[fileIndex], "image/tiff");
        }
        else document.getElementById('output').textContent = json.errorText;
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };

Intenta convertir PDF a PNG en línea

Como ejemplo de cómo funcionan nuestras aplicaciones gratuitas, por favor verifica la siguiente característica.

Aspose.PDF para JavaScript te presenta una aplicación gratuita en línea “PDF a PNG”, donde puedes intentar investigar la funcionalidad y la calidad con la que trabaja.

Convertir PDF a PNG


  /*Crear Web Worker*/
    const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
    AsposePDFWebWorker.onerror = evt => console.log(`Error desde Web Worker: ${evt.message}`);
    AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
      (evt.data == 'ready') ? '¡cargado!' :
        (evt.data.json.errorCode == 0) ? 
          `Cantidad de archivos(páginas): ${evt.data.json.filesCount.toString()}\n${evt.data.params.forEach(
            (element, index) => DownloadFile(evt.data.json.filesNameResult[index], "image/png", element) ) ?? ""}` : 
          `Error: ${evt.data.json.errorText}`;

    /*Manejador de eventos*/
    const ffileToPng = e => {
      const file_reader = new FileReader();
      file_reader.onload = event => {
        const password = 'owner';
        /*convierte un archivo PDF a archivos png con la plantilla "ResultPdfToPng{0:D2}.png" ({0}, {0:D2}, {0:D3}, ... formato de número de página), resolución 150 DPI y guarda - Pregunta al Web Worker*/
        AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfPagesToPng', "params": [event.target.result, e.target.files[0].name, "ResultPdfToPng{0:D2}.png", 150] }, [event.target.result]);
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };
  /// [Fragmento de código]

    /*crear un enlace para descargar el archivo resultante*/
    const DownloadFile = (filename, mime, content) => {
        mime = mime || "application/octet-stream";
        var link = document.createElement("a"); 
        link.href = URL.createObjectURL(new Blob([content], {type: mime}));
        link.download = filename;
        link.innerHTML = "Haz clic aquí para descargar el archivo " + filename;
        document.body.appendChild(link); 
        document.body.appendChild(document.createElement("br"));
        return filename;
      }

El siguiente fragmento de código JavaScript muestra un ejemplo simple de conversión de páginas PDF en archivos PNG:

Seleccione un archivo PDF para convertir.
Cree un ‘FileReader’.
Se ejecuta la función AsposePdfPagesToPng.
Se establece el nombre del archivo resultante, en este ejemplo “ResultPdfToPng{0:D2}.png”.
A continuación, si el ‘json.errorCode’ es 0, entonces su DownloadFile recibe el nombre que especificó anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, hay un error en su archivo, la información sobre dicho error se contendrá en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y le permite descargar el archivo resultante al sistema operativo del usuario.


  var ffileToPng = function (e) {
    const file_reader = new FileReader();
    file_reader.onload = (event) => {
      /*convertir un archivo PDF a archivos png con la plantilla "ResultPdfToPng{0:D2}.png" ({0}, {0:D2}, {0:D3}, ... formato de número de página), resolución 150 DPI y guardar*/
      const json = AsposePdfPagesToPng(event.target.result, e.target.files[0].name, "ResultPdfToPng{0:D2}.png", 150);
      if (json.errorCode == 0) {
        document.getElementById('output').textContent = "Cantidad de archivos(páginas): " + json.filesCount.toString();
        /*crear enlaces a los archivos resultantes*/
        for (let fileIndex = 0; fileIndex < json.filesCount; fileIndex++) DownloadFile(json.filesNameResult[fileIndex], "image/png");
      }
      else document.getElementById('output').textContent = json.errorText;
    };
    file_reader.readAsArrayBuffer(e.target.files[0]);
  };

Intenta convertir PDF a SVG en línea

Aspose.PDF para JavaScript te presenta una aplicación gratuita en línea “PDF a SVG”, donde puedes investigar la funcionalidad y la calidad con la que trabaja.

Gráficos Vectoriales Escalables (SVG) es una familia de especificaciones de un formato de archivo basado en XML para gráficos vectoriales bidimensionales, tanto estáticos como dinámicos (interactivos o animados). La especificación SVG es un estándar abierto que ha estado en desarrollo por el Consorcio World Wide Web (W3C) desde 1999.

Convertir PDF a SVG


  /*Crear Worker Web*/
    const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
    AsposePDFWebWorker.onerror = evt => console.log(`Error desde el Worker Web: ${evt.message}`);
    AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
      (evt.data == 'ready') ? '¡cargado!' :
        (evt.data.json.errorCode == 0) ? 
          `Número de archivos(páginas): ${evt.data.json.filesCount.toString()}\n${evt.data.params.forEach(
            (element, index) => DownloadFile(evt.data.json.filesNameResult[index], "image/svg", element) ) ?? ""}` : 
          `Error: ${evt.data.json.errorText}`;

    /*Manejador de eventos*/
    const ffileToSvg = e => {
      const file_reader = new FileReader();
      file_reader.onload = event => {
        /*Convertir un archivo PDF a SVG - Solicitar al Worker Web*/
        AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfPagesToSvg', "params": [event.target.result, e.target.files[0].name, "ResultPdfToSvg.svg"] }, [event.target.result]);
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };

    /*Crear un enlace para descargar el archivo de resultado*/
    const DownloadFile = (filename, mime, content) => {
        mime = mime || "application/octet-stream";
        var link = document.createElement("a"); 
        link.href = URL.createObjectURL(new Blob([content], {type: mime}));
        link.download = filename;
        link.innerHTML = "Haz clic aquí para descargar el archivo " + filename;
        document.body.appendChild(link); 
        document.body.appendChild(document.createElement("br"));
        return filename;
      }

El siguiente fragmento de código JavaScript muestra un ejemplo simple de convertir páginas PDF en archivos SVG:

Seleccione un archivo PDF para convertir.
Cree un ‘FileReader’.
Se ejecuta la función AsposePdfPagesToSvg.
Se establece el nombre del archivo resultante, en este ejemplo “ResultPdfToSvg.svg”.
A continuación, si el ‘json.errorCode’ es 0, entonces su DownloadFile recibe el nombre que especificó anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, hay un error en su archivo, entonces la información sobre tal error se encontrará en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y le permite descargar el archivo resultante al sistema operativo del usuario.


    var ffileToSvg = function (e) {
      const file_reader = new FileReader();
      file_reader.onload = (event) => {
        /*Convertir un archivo PDF a SVG*/
        const json = AsposePdfPagesToSvg(event.target.result, e.target.files[0].name, "ResultPdfToSvg.svg");
        if (json.errorCode == 0) {
          document.getElementById('output').textContent = "Cantidad de archivos(páginas): " + json.filesCount.toString();
          /*Hacer enlaces a los archivos resultantes*/
          for (let fileIndex = 0; fileIndex < json.filesCount; fileIndex++) DownloadFile(json.filesNameResult[fileIndex], "image/svg");
        }
        else document.getElementById('output').textContent = json.errorText;
      }
      file_reader.readAsArrayBuffer(e.target.files[0]);
    }

Convertir PDF a SVG comprimido


  /*Crear Web Worker*/
    const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
    AsposePDFWebWorker.onerror = evt => console.log(`Error del Web Worker: ${evt.message}`);
    AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
      (evt.data == 'ready') ? '¡cargado!' :
        (evt.data.json.errorCode == 0) ? `Resultado:\n${DownloadFile(evt.data.json.fileNameResult, "application/zip", evt.data.params[0])}` : `Error: ${evt.data.json.errorText}`;

    /*Manejador de eventos*/
    const ffileToSvgZip = e => {
      const file_reader = new FileReader();
      file_reader.onload = event => {
        /*Convertir un archivo PDF a SVG(zip) y guardar como "ResultPdfToSvgZip.zip" - Pedir al Web Worker*/
        AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfPagesToSvgZip', "params": [event.target.result, e.target.files[0].name, "ResultPdfToSvgZip.zip"] }, [event.target.result]);
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };

    /*Crear un enlace para descargar el archivo resultante*/
    const DownloadFile = (filename, mime, content) => {
        mime = mime || "application/octet-stream";
        var link = document.createElement("a"); 
        link.href = URL.createObjectURL(new Blob([content], {type: mime}));
        link.download = filename;
        link.innerHTML = "Haz clic aquí para descargar el archivo " + filename;
        document.body.appendChild(link); 
        document.body.appendChild(document.createElement("br"));
        return filename;
      }

El siguiente fragmento de código JavaScript muestra un ejemplo simple de conversión de páginas PDF en archivos SVG(zip):

Selecciona un archivo PDF para convertir.
Crea un ‘FileReader’.
Se ejecuta la función AsposePdfPagesToSvgZip.
Se establece el nombre del archivo resultante, en este ejemplo “ResultPdfToSvgZip.zip”.
A continuación, si el ‘json.errorCode’ es 0, entonces tu DownloadFile recibe el nombre que especificaste anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, hay un error en tu archivo, entonces la información sobre dicho error estará contenida en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y te permite descargar el archivo resultante al sistema operativo del usuario.


    var ffileToSvgZip = function (e) {
      const file_reader = new FileReader();
      file_reader.onload = (event) => {
        /*Convierte un archivo PDF a SVG(zip) y guarda el "ResultPdfToSvgZip.zip"*/
        const json = AsposePdfPagesToSvgZip(event.target.result, e.target.files[0].name, "ResultPdfToSvgZip.zip");
        if (json.errorCode == 0) document.getElementById('output').textContent = json.fileNameResult;
        else document.getElementById('output').textContent = json.errorText;
        /*Crea un enlace para descargar el archivo resultante*/
        DownloadFile(json.fileNameResult, "application/zip");
      }
      file_reader.readAsArrayBuffer(e.target.files[0]);
    }

Convertir PDF a DICOM


  /*Crear Web Worker*/
  const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
  AsposePDFWebWorker.onerror = evt => console.log(`Error del Web Worker: ${evt.message}`);
  AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
    (evt.data == 'ready') ? '¡cargado!' :
      (evt.data.json.errorCode == 0) ?
        `Número de archivos(páginas): ${evt.data.json.filesCount.toString()}\n${evt.data.params.forEach(
          (element, index) => DownloadFile(evt.data.json.filesNameResult[index], "application/dicom", element) ) ?? ""}` :
        `Error: ${evt.data.json.errorText}`;

  /*Manejador de eventos*/
  const ffileToDICOM = e => {
    const file_reader = new FileReader();
    file_reader.onload = event => {
      /*Convertir un archivo PDF a DICOM con la plantilla "ResultPdfToDICOM{0:D2}.dcm" ({0}, {0:D2}, {0:D3}, ... formato número de página), resolución 150 DPI y guardar - Preguntar al Web Worker*/
      AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfPagesToDICOM', "params": [event.target.result, e.target.files[0].name, "ResultPdfToDICOM{0:D2}.dcm", 150] }, [event.target.result]);
    };
    file_reader.readAsArrayBuffer(e.target.files[0]);
  };

  /*Crear un enlace para descargar el archivo resultante*/
  const DownloadFile = (filename, mime, content) => {
      mime = mime || "application/octet-stream";
      var link = document.createElement("a"); 
      link.href = URL.createObjectURL(new Blob([content], {type: mime}));
      link.download = filename;
      link.innerHTML = "Haga clic aquí para descargar el archivo " + filename;
      document.body.appendChild(link); 
      document.body.appendChild(document.createElement("br"));
      return filename;
    }

El siguiente fragmento de código JavaScript muestra un ejemplo simple de conversión de páginas PDF a archivos DICOM:

Seleccione un archivo PDF para convertir.
Cree un ‘FileReader’.
Se ejecuta la función AsposePdfPagesToDICOM.
Se establece el nombre del archivo resultante, en este ejemplo “ResultPdfToDICOM{0:D2}.dcm”.
A continuación, si el ‘json.errorCode’ es 0, entonces su archivo resultante recibe el nombre que especificó anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, hay un error en su archivo, entonces la información sobre dicho error se contendrá en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y le permite descargar el archivo resultante al sistema operativo del usuario.


  var ffileToDICOM = function (e) {
    const file_reader = new FileReader();
    file_reader.onload = (event) => {
      /*Convertir un archivo PDF a DICOM con la plantilla "ResultPdfToDICOM{0:D2}.dcm" ({0}, {0:D2}, {0:D3}, ... formato de número de página), resolución 150 DPI y guardar*/
      const json = AsposePdfPagesToDICOM(event.target.result, e.target.files[0].name, "ResultPdfToDICOM{0:D2}.dcm", 150);
      if (json.errorCode == 0) {
        document.getElementById('output').textContent = "Conteo de archivos(páginas): " + json.filesCount.toString();
        /*Crear enlaces a los archivos resultantes*/
        for (let fileIndex = 0; fileIndex < json.filesCount; fileIndex++) DownloadFile(json.filesNameResult[fileIndex], "application/dicom");
      }
      else document.getElementById('output').textContent = json.errorText;
    };
    file_reader.readAsArrayBuffer(e.target.files[0]);
  };

Convertir PDF a BMP


    const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
    AsposePDFWebWorker.onerror = evt => console.log(`Error del trabajador web: ${evt.message}`);
    AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
      (evt.data == 'ready') ? '¡cargado!' :
        (evt.data.json.errorCode == 0) ? 
          `Conteo de archivos(páginas): ${evt.data.json.filesCount.toString()}\n${evt.data.params.forEach(
            (element, index) => DownloadFile(evt.data.json.filesNameResult[index], "image/bmp", element) ) ?? ""}` : 
          `Error: ${evt.data.json.errorText}`;

    /*Manejador de eventos*/
    const ffileToBmp = e => {
      const file_reader = new FileReader();
      file_reader.onload = event => {
        /*Convertir un archivo PDF a BMP con plantilla "ResultPdfToBmp{0:D2}.bmp" ({0}, {0:D2}, {0:D3}, ... formato número de página), resolución 150 DPI y guardar - Preguntar al trabajador web*/
        AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfPagesToBmp', "params": [event.target.result, e.target.files[0].name, "ResultPdfToBmp{0:D2}.bmp", 150] }, [event.target.result]);
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };

    /*Crear un enlace para descargar el archivo resultante*/
    const DownloadFile = (filename, mime, content) => {
        mime = mime || "application/octet-stream";
        var link = document.createElement("a"); 
        link.href = URL.createObjectURL(new Blob([content], {type: mime}));
        link.download = filename;
        link.innerHTML = "Haga clic aquí para descargar el archivo " + filename;
        document.body.appendChild(link); 
        document.body.appendChild(document.createElement("br"));
        return filename;
      }

El siguiente fragmento de código JavaScript muestra un ejemplo sencillo de convertir páginas PDF en archivos BMP:

Seleccione un archivo PDF para convertir.
Cree un ‘FileReader’.
Se ejecuta la función AsposePdfPagesToBmp.
Se establece el nombre del archivo resultante, en este ejemplo “ResultPdfToBmp{0:D2}.bmp”.
Luego, si el ‘json.errorCode’ es 0, entonces su DownloadFile recibe el nombre que especificó anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, hay un error en su archivo, entonces la información sobre dicho error se encontrará en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y le permite descargar el archivo resultante al sistema operativo del usuario.


    var ffileToBmp = function (e) {
      const file_reader = new FileReader();
      file_reader.onload = (event) => {
        /*Convertir un archivo PDF a BMP con la plantilla "ResultPdfToBmp{0:D2}.bmp" ({0}, {0:D2}, {0:D3}, ... formato de número de página), resolución 150 DPI y guardar*/
        const json = AsposePdfPagesToBmp(event.target.result, e.target.files[0].name, "ResultPdfToBmp{0:D2}.bmp", 150);
        if (json.errorCode == 0) {
          document.getElementById('output').textContent = "Recuento de archivos(páginas): " + json.filesCount.toString();
          /*Hacer enlaces a los archivos resultantes*/
          for (let fileIndex = 0; fileIndex < json.filesCount; fileIndex++) DownloadFile(json.filesNameResult[fileIndex], "image/bmp");
        }
        else document.getElementById('output').textContent = json.errorText;
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };

Javascript-Cpp: Convertir PDF a EPUB, TeX, Texto, XPS en JavaScript

Wed, 01 Nov 2023 00:00:00 +0000

La operación de conversión depende del número de páginas en el documento y puede llevar mucho tiempo. Por lo tanto, recomendamos encarecidamente usar Web Workers.

Este código demuestra una forma de descargar tareas de conversión de archivos PDF que consumen muchos recursos a un trabajador web para evitar bloquear el hilo principal de la interfaz de usuario. También ofrece una forma amigable para el usuario de descargar el archivo convertido.

Intenta convertir PDF a EPUB en línea

Aspose.PDF para JavaScript te presenta la aplicación gratuita en línea “PDF a EPUB”, donde puedes intentar investigar la funcionalidad y la calidad con la que funciona.

Convertir PDF a EPUB

EPUB es un estándar de libro electrónico libre y abierto del Foro Internacional de Publicación Digital (IDPF). Los archivos tienen la extensión .epub. EPUB está diseñado para contenido refluible, lo que significa que un lector EPUB puede optimizar el texto para un dispositivo de visualización particular. EPUB también soporta contenido de diseño fijo. El formato está destinado como un formato único que los editores y las casas de conversión pueden usar internamente, así como para distribución y venta. Reemplaza el estándar Open eBook.


    /*Crear Web Worker*/
    const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
    AsposePDFWebWorker.onerror = evt => console.log(`Error desde Web Worker: ${evt.message}`);
    AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
      (evt.data == 'ready') ? '¡cargado!' :
        (evt.data.json.errorCode == 0) ? `Resultado:\n${DownloadFile(evt.data.json.fileNameResult, "application/epub+zip", evt.data.params[0])}` : `Error: ${evt.data.json.errorText}`;

    /*Manejador de eventos*/
    const ffileToEPUB = e => {
      const file_reader = new FileReader();
      file_reader.onload = event => {
        /*Convertir un archivo PDF a ePub y guardar como "ResultPDFtoEPUB.epub" - Preguntar al Web Worker*/
        AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfToEPUB', "params": [event.target.result, e.target.files[0].name, "ResultPDFtoEPUB.epub"] }, [event.target.result]);
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };

    /*Crear un enlace para descargar el archivo resultante*/
    const DownloadFile = (filename, mime, content) => {
        mime = mime || "application/octet-stream";
        var link = document.createElement("a"); 
        link.href = URL.createObjectURL(new Blob([content], {type: mime}));
        link.download = filename;
        link.innerHTML = "Haz clic aquí para descargar el archivo " + filename;
        document.body.appendChild(link); 
        document.body.appendChild(document.createElement("br"));
        return filename;
      }

El siguiente fragmento de código JavaScript muestra un ejemplo simple de conversión de páginas PDF en archivos EPUB:

Selecciona un archivo PDF para convertir.
Crea un ‘FileReader’.
Se ejecuta la función AsposePdfToEPUB.
Se establece el nombre del archivo resultante, en este ejemplo “ResultPDFtoEPUB.epub”.
A continuación, si el ‘json.errorCode’ es 0, entonces tu archivo de resultado recibe el nombre que especificaste anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, hay un error en tu archivo, entonces la información sobre dicho error estará contenida en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y te permite descargar el archivo resultante al sistema operativo del usuario.


    var ffileToEPUB = function (e) {
      const file_reader = new FileReader();
      file_reader.onload = (event) => {
        /*Convierte un archivo PDF a EPUB y guarda el "ResultPDFtoEPUB.epub"*/
        const json = AsposePdfToEPUB(event.target.result, e.target.files[0].name, "ResultPDFtoEPUB.epub");
        if (json.errorCode == 0) document.getElementById('output').textContent = json.fileNameResult;
        else document.getElementById('output').textContent = json.errorText;
        /*Crea un enlace para descargar el archivo de resultado*/
        DownloadFile(json.fileNameResult, "application/epub+zip");
      }
      file_reader.readAsArrayBuffer(e.target.files[0]);
    }

Intenta convertir PDF a LaTeX/TeX en línea

Aspose.PDF para JavaScript te presenta la aplicación gratuita en línea “PDF a LaTeX”, donde puedes intentar investigar la funcionalidad y calidad con la que trabaja.

Convertir PDF a TeX

Aspose.PDF para JavaScript admite la conversión de PDF a TeX. El formato de archivo LaTeX es un formato de archivo de texto con un marcado especial y se utiliza en el sistema de preparación de documentos basado en TeX para la composición tipográfica de alta calidad.


  /*Crear un Trabajador Web*/
    const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
    AsposePDFWebWorker.onerror = evt => console.log(`Error del Trabajador Web: ${evt.message}`);
    AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
      (evt.data == 'ready') ? '¡cargado!' :
        (evt.data.json.errorCode == 0) ? `Resultado:\n${DownloadFile(evt.data.json.fileNameResult, "application/x-tex", evt.data.params[0])}` : `Error: ${evt.data.json.errorText}`;

    /*Manejador de eventos*/
    const ffileToTeX = e => {
      const file_reader = new FileReader();
      file_reader.onload = event => {
        /*Convertir un archivo PDF a TeX y guardar como "ResultPDFtoTeX.tex" - Preguntar al Trabajador Web*/
        AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfToTeX', "params": [event.target.result, e.target.files[0].name, "ResultPDFtoTeX.tex"] }, [event.target.result]);
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };

    /*Crear un enlace para descargar el archivo de resultado*/
    const DownloadFile = (filename, mime, content) => {
        mime = mime || "application/octet-stream";
        var link = document.createElement("a"); 
        link.href = URL.createObjectURL(new Blob([content], {type: mime}));
        link.download = filename;
        link.innerHTML = "Haz clic aquí para descargar el archivo " + filename;
        document.body.appendChild(link); 
        document.body.appendChild(document.createElement("br"));
        return filename;
      }

El siguiente fragmento de código JavaScript muestra un ejemplo simple de conversión de páginas PDF a archivos TEX:

Seleccione un archivo PDF para convertir.
Cree un ‘FileReader’.
Se ejecuta la función AsposePdfToTeX.
Se establece el nombre del archivo resultante, en este ejemplo “ResultPDFtoTeX.tex”.
Luego, si el ‘json.errorCode’ es 0, entonces su archivo de resultado recibe el nombre que especificó anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, habrá un error en su archivo, entonces la información sobre dicho error se contendrá en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y le permite descargar el archivo resultante al sistema operativo del usuario.


    var ffileToTeX = function (e) {
      const file_reader = new FileReader();
      file_reader.onload = (event) => {
        /*Convertir un archivo PDF a TeX y guardar el "ResultPDFtoTeX.tex"*/
        const json = AsposePdfToTeX(event.target.result, e.target.files[0].name, "ResultPDFtoTeX.tex");
        if (json.errorCode == 0) document.getElementById('output').textContent = json.fileNameResult;
        else document.getElementById('output').textContent = json.errorText;
        /*Hacer un enlace para descargar el archivo de resultado*/
        DownloadFile(json.fileNameResult, "application/x-tex");
      }
      file_reader.readAsArrayBuffer(e.target.files[0]);
    }

Intenta convertir PDF a Texto en línea

Aspose.PDF para JavaScript te presenta una aplicación gratuita en línea “PDF a Texto”, donde puedes intentar investigar la funcionalidad y la calidad con la que trabaja.

Convertir PDF a TXT


    /*Crear Web Worker*/
    const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
    AsposePDFWebWorker.onerror = evt => console.log(`Error del Web Worker: ${evt.message}`);
    AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
      (evt.data == 'ready') ? '¡cargado!' :
        (evt.data.json.errorCode == 0) ? `Resultado:\n${DownloadFile(evt.data.json.fileNameResult, "text/plain", evt.data.params[0])}` : `Error: ${evt.data.json.errorText}`;

    /*Manejador de eventos*/
    const ffileToTxt = e => {
      const file_reader = new FileReader();
      file_reader.onload = event => {
        /*Convertir un archivo PDF a Txt y guardar como "ResultPDFtoTxt.txt" - Pedir al Web Worker*/
        AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfToTxt', "params": [event.target.result, e.target.files[0].name, "ResultPDFtoTxt.txt"] }, [event.target.result]);
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };

    /*Hacer un enlace para descargar el archivo de resultado*/
    const DownloadFile = (filename, mime, content) => {
        mime = mime || "application/octet-stream";
        var link = document.createElement("a"); 
        link.href = URL.createObjectURL(new Blob([content], {type: mime}));
        link.download = filename;
        link.innerHTML = "Haz clic aquí para descargar el archivo " + filename;
        document.body.appendChild(link); 
        document.body.appendChild(document.createElement("br"));
        return filename;
      }

El siguiente fragmento de código JavaScript muestra un ejemplo simple de cómo convertir páginas PDF en archivos TXT:

Seleccione un archivo PDF para convertir.
Cree un ‘FileReader’.
Se ejecuta la función AsposePdfToTxt.
Se establece el nombre del archivo resultante, en este ejemplo “ResultPDFtoTxt.txt”.
A continuación, si el ‘json.errorCode’ es 0, entonces su archivo de resultado recibe el nombre que especificó anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, hay un error en su archivo, entonces la información sobre dicho error se contendrá en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y le permite descargar el archivo resultante al sistema operativo del usuario.


    var ffileToTxt = function (e) {
      const file_reader = new FileReader();
      file_reader.onload = (event) => {
        /*Convertir un archivo PDF a Txt y guardar el "ResultPDFtoTxt.txt"*/
        const json = AsposePdfToTxt(event.target.result, e.target.files[0].name, "ResultPDFtoTxt.txt");
        if (json.errorCode == 0) document.getElementById('output').textContent = json.fileNameResult;
        else document.getElementById('output').textContent = json.errorText;
        /*Crear un enlace para descargar el archivo resultante*/
        DownloadFile(json.fileNameResult, "text/plain");
      }
      file_reader.readAsArrayBuffer(e.target.files[0]);
    }

Intenta convertir PDF a XPS en línea

Aspose.PDF para JavaScript te presenta la aplicación gratuita en línea “PDF a XPS”, donde puedes intentar investigar la funcionalidad y calidad con la que trabaja.

Convertir PDF a XPS

El tipo de archivo XPS está principalmente asociado con la Especificación de Papel XML de Microsoft Corporation. La Especificación de Papel XML (XPS), anteriormente con nombre en código Metro e incorporando el concepto de marketing Next Generation Print Path (NGPP), es la iniciativa de Microsoft para integrar la creación y visualización de documentos en el sistema operativo Windows.

Aspose.PDF para JavaScript ofrece la posibilidad de convertir archivos PDF al formato XPS. Vamos a intentar usar el fragmento de código presentado para convertir archivos PDF a formato XPS con JavaScript.


    /*Crear Web Worker*/
    const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
    AsposePDFWebWorker.onerror = evt => console.log(`Error desde el Web Worker: ${evt.message}`);
    AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
      (evt.data == 'ready') ? '¡cargado!' :
        (evt.data.json.errorCode == 0) ? `Resultado:\n${DownloadFile(evt.data.json.fileNameResult, "application/vnd.ms-xpsdocument", evt.data.params[0])}` : `Error: ${evt.data.json.errorText}`;

    /*Manejador de eventos*/
    const ffileToXps = e => {
      const file_reader = new FileReader();
      file_reader.onload = event => {
        /*Convertir un archivo PDF a Xps y guardar el "ResultPDFtoXps.xps" - Pedir al Web Worker*/
        AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfToXps', "params": [event.target.result, e.target.files[0].name, "ResultPDFtoXps.xps"] }, [event.target.result]);
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };

    /*Crear un enlace para descargar el archivo de resultado*/
    const DownloadFile = (filename, mime, content) => {
        mime = mime || "application/octet-stream";
        var link = document.createElement("a"); 
        link.href = URL.createObjectURL(new Blob([content], {type: mime}));
        link.download = filename;
        link.innerHTML = "Haz clic aquí para descargar el archivo " + filename;
        document.body.appendChild(link); 
        document.body.appendChild(document.createElement("br"));
        return filename;
      }

El siguiente fragmento de código JavaScript muestra un ejemplo simple de cómo convertir páginas PDF en archivos XPS:

Seleccione un archivo PDF para convertir.
Cree un ‘FileReader’.
Se ejecuta la función AsposePdfToXps.
Se establece el nombre del archivo resultante, en este ejemplo “ResultPDFtoXps.xps”.
A continuación, si el ‘json.errorCode’ es 0, entonces su archivo de resultado recibe el nombre que especificó anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, habrá un error en su archivo, entonces la información sobre dicho error se contendrá en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y le permite descargar el archivo resultante al sistema operativo del usuario.


    var ffileToXps = function (e) {
      const file_reader = new FileReader();
      file_reader.onload = (event) => {
        /*Convertir un archivo PDF a Xps y guardar el "ResultPDFtoXps.xps"*/
        const json = AsposePdfToXps(event.target.result, e.target.files[0].name, "ResultPDFtoXps.xps");
        if (json.errorCode == 0) document.getElementById('output').textContent = json.fileNameResult;
        else document.getElementById('output').textContent = json.errorText;
        /*Crear un enlace para descargar el archivo de resultado*/
        DownloadFile(json.fileNameResult, "application/vnd.ms-xpsdocument");
      }
      file_reader.readAsArrayBuffer(e.target.files[0]);
    }

Convertir PDF a PDF en Escala de Grises

Convierte PDF a blanco y negro con Aspose.PDF para JavaScript a través del kit de herramientas web C++. ¿Por qué debería convertir PDF a Escala de Grises? Si el archivo PDF contiene muchas imágenes a color y el tamaño del archivo es importante en lugar del color, la conversión ahorra espacio. Si imprimes un archivo PDF en blanco y negro, convertirlo te permitirá comprobar visualmente cómo se ve el resultado final.


  /*Crear Web Worker*/
    const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
    AsposePDFWebWorker.onerror = evt => console.log(`Error desde Web Worker: ${evt.message}`);
    AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
      (evt.data == 'ready') ? '¡cargado!' :
        (evt.data.json.errorCode == 0) ? `Resultado:\n${DownloadFile(evt.data.json.fileNameResult, "application/pdf", evt.data.params[0])}` : `Error: ${evt.data.json.errorText}`;

    /*Manejador de eventos*/
    const ffileConvertToGrayscale = e => {
      const file_reader = new FileReader();
      file_reader.onload = event => {
        /*convertir un archivo PDF a escala de grises y guardar el "ResultConvertToGrayscale.pdf" - Pedir al Web Worker*/
        AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfConvertToGrayscale', "params": [event.target.result, e.target.files[0].name, "ResultConvertToGrayscale.pdf"] }, [event.target.result]);
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };
  /// [Fragmento de código]

    /*crear un enlace para descargar el archivo resultado*/
    const DownloadFile = (filename, mime, content) => {
        mime = mime || "application/octet-stream";
        var link = document.createElement("a"); 
        link.href = URL.createObjectURL(new Blob([content], {type: mime}));
        link.download = filename;
        link.innerHTML = "Haga clic aquí para descargar el archivo " + filename;
        document.body.appendChild(link); 
        document.body.appendChild(document.createElement("br"));
        return filename;
      }

El siguiente fragmento de código JavaScript muestra un ejemplo simple de conversión de páginas PDF a PDF en escala de grises:

Seleccione un archivo PDF para convertir.
Cree un ‘FileReader’.
Se ejecuta la función AsposePdfConvertToGrayscale.
Se establece el nombre del archivo resultante, en este ejemplo “ResultConvertToGrayscale.pdf”.
A continuación, si el ‘json.errorCode’ es 0, entonces su DownloadFile se le da el nombre que especificó anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, hay un error en su archivo, entonces la información sobre dicho error se contendrá en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y le permite descargar el archivo resultante al sistema operativo del usuario.


  var ffileConvertToGrayscale = function (e) {
    const file_reader = new FileReader();
    file_reader.onload = (event) => {
      /*convierte un archivo PDF a escala de grises y guarda el "ResultConvertToGrayscale.pdf"*/
      const json = AsposePdfConvertToGrayscale(event.target.result, e.target.files[0].name, "ResultConvertToGrayscale.pdf");
      if (json.errorCode == 0) document.getElementById('output').textContent = json.fileNameResult;
      else document.getElementById('output').textContent = json.errorText;
      /*crear un enlace para descargar el archivo resultado*/
      DownloadFile(json.fileNameResult, "application/pdf");
    };
    file_reader.readAsArrayBuffer(e.target.files[0]);
  };

Javascript-Cpp: Convertir PDF a formatos PDF/A

Wed, 01 Nov 2023 00:00:00 +0000

Aspose.PDF para JavaScript te permite convertir un archivo PDF a un archivo PDF compatible con PDF/A.

La operación de conversión depende del número de páginas en el documento y puede consumir mucho tiempo. Por lo tanto, recomendamos encarecidamente usar Web Workers.

Este código demuestra una manera de descargar tareas de conversión de archivos PDF que consumen muchos recursos a un web worker para evitar bloquear el hilo principal de la interfaz de usuario. También ofrece una forma amigable para el usuario de descargar el archivo convertido.

Intenta convertir PDF a PDF/A en línea

Aspose.PDF para JavaScript te presenta una aplicación en línea gratuita “PDF a PDF/A-1A”, donde puedes intentar investigar la funcionalidad y calidad con la que trabaja.

Convertir PDF a formato PDF/A


  /*Crear Web Worker*/
    const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
    AsposePDFWebWorker.onerror = evt => console.log(`Error del Web Worker: ${evt.message}`);
    AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
      (evt.data == 'ready') ? '¡cargado!' :
        (evt.data.json.errorCode == 0) ? `Resultado:\n${DownloadFile(evt.data.json.fileNameResult, "application/pdf", evt.data.params[0])}\n${DownloadFile(evt.data.json.fileNameLogResult, "application/xml", evt.data.params[1])}` : `Error: ${evt.data.json.errorText}`;

    /*Manejador de eventos*/
    const ffilePdfConvertToPDFA = e => {
      const file_reader = new FileReader();
      file_reader.onload = event => {
        const pdfFormat = 'Module.PdfFormat.PDF_A_1A';
        /*convertir un archivo PDF a PDF/A(1A) y guardar el "ResultConvertToPDFA.pdf"*/
        /*durante el proceso de conversión, también se realiza la validación, "ResultConvertToPDFA.xml"- Preguntar al Web Worker*/
        AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfConvertToPDFA', "params": [event.target.result, e.target.files[0].name, pdfFormat, "ResultConvertToPDFA.pdf", "ResultConvertToPDFA.xml"] }, [event.target.result]);
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };
  /// [Fragmento de código]

    /*crear un enlace para descargar el archivo de resultado*/
    const DownloadFile = (filename, mime, content) => {
        mime = mime || "application/octet-stream";
        var link = document.createElement("a"); 
        link.href = URL.createObjectURL(new Blob([content], {type: mime}));
        link.download = filename;
        link.innerHTML = "Haga clic aquí para descargar el archivo " + filename;
        document.body.appendChild(link); 
        document.body.appendChild(document.createElement("br"));
        return filename;
      }

El siguiente fragmento de código JavaScript muestra un ejemplo simple de conversión de archivos PDF a PDF/A:

Seleccione un archivo PDF para convertir.
Cree un ‘FileReader’.
Se ejecuta la función AsposePdfConvertToPDFA.
Se establece el nombre del archivo resultante, en este ejemplo “ResultConvertToPDFA.pdf”. Durante el proceso de conversión, también se realiza la validación, “ResultConvertToPDFA.xml”.
A continuación, si el ‘json.errorCode’ es 0, entonces su DownloadFile recibe el nombre que especificó anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, hay un error en su archivo, entonces la información sobre dicho error se encontrará en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y le permite descargar el archivo resultante, y un enlace para descargar el archivo de Log (xml) al sistema operativo del usuario.


  var ffilePdfConvertToPDFA = function (e) {
    const file_reader = new FileReader();
    file_reader.onload = (event) => {
      /*convertir un archivo PDF a PDF/A(1A) y guardar "ResultConvertToPDFA.pdf"*/
      /*durante el proceso de conversión, también se realiza la validación, "ResultConvertToPDFA.xml"*/
      const json = AsposePdfConvertToPDFA(event.target.result, e.target.files[0].name, Module.PdfFormat.PDF_A_1A, "ResultConvertToPDFA.pdf", "ResultConvertToPDFA.xml");
      if (json.errorCode == 0)
      {
        document.getElementById('output').textContent = json.fileNameResult + "\nArchivo de Log (formato xml): " + json.fileNameLogResult;
        /*crear un enlace para descargar el archivo resultante*/
        DownloadFile(json.fileNameResult, "application/pdf");
      }
      else document.getElementById('output').textContent = json.errorText + "\nArchivo de Log (formato xml): " + json.fileNameLogResult;
      /*crear un enlace para descargar el Log (xml)*/
      DownloadFile(json.fileNameLogResult, "application/xml");
    };
    file_reader.readAsArrayBuffer(e.target.files[0]);
  };

Javascript-Cpp: Convertir PDF/A a formato PDF

Wed, 01 Nov 2023 00:00:00 +0000

Convertir PDF/A a formato PDF


  /*Crear Web Worker*/
    const AsposePDFWebWorker = new Worker("AsposePDFforJS.js");
    AsposePDFWebWorker.onerror = evt => console.log(`Error desde Web Worker: ${evt.message}`);
    AsposePDFWebWorker.onmessage = evt => document.getElementById('output').textContent = 
      (evt.data == 'ready') ? '¡cargado!' :
        (evt.data.json.errorCode == 0) ? `Resultado:\n${DownloadFile(evt.data.json.fileNameResult, "application/pdf", evt.data.params[0])}` : `Error: ${evt.data.json.errorText}`;

    /*Manejador de eventos*/
    const ffilePdfAConvertToPDF = e => {
      const file_reader = new FileReader();
      file_reader.onload = event => {
        /*convertir un archivo PDF/A a PDF y guardar como "ResultConvertToPDF.pdf" - Solicitar al Web Worker*/
        AsposePDFWebWorker.postMessage({ "operation": 'AsposePdfAConvertToPDF', "params": [event.target.result, e.target.files[0].name, "ResultConvertToPDF.pdf"] }, [event.target.result]);
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };
  /// [Fragmento de código]

    /*crear un enlace para descargar el archivo resultante*/
    const DownloadFile = (filename, mime, content) => {
        mime = mime || "application/octet-stream";
        var link = document.createElement("a"); 
        link.href = URL.createObjectURL(new Blob([content], {type: mime}));
        link.download = filename;
        link.innerHTML = "Haz clic aquí para descargar el archivo " + filename;
        document.body.appendChild(link); 
        document.body.appendChild(document.createElement("br"));
        return filename;
      }

El siguiente fragmento de código en JavaScript muestra un ejemplo simple de conversión de PDF/A a PDF:

Selecciona un archivo PDF para convertir.
Crea un ‘FileReader’.
Se ejecuta la función AsposePdfAConvertToPDF.
Se establece el nombre del archivo resultante, en este ejemplo “ResultConvertToPDFA.pdf”.
A continuación, si ‘json.errorCode’ es 0, entonces tu DownloadFile se le da el nombre que especificaste anteriormente. Si el parámetro ‘json.errorCode’ no es igual a 0 y, en consecuencia, habrá un error en tu archivo, entonces la información sobre dicho error estará contenida en el archivo ‘json.errorText’.
Como resultado, la función DownloadFile genera un enlace y te permite descargar el archivo resultante al sistema operativo del usuario.


    var ffilePdfAConvertToPDF = function (e) {
      const file_reader = new FileReader();
      file_reader.onload = (event) => {
        /*convierte un archivo PDF/A a PDF y guarda el "ResultConvertToPDF.pdf"*/
        const json = AsposePdfAConvertToPDF(event.target.result, e.target.files[0].name, "ResultConvertToPDF.pdf");
        if (json.errorCode == 0) document.getElementById('output').textContent = json.fileNameResult;
        else document.getElementById('output').textContent = json.errorText;
        /*crear un enlace para descargar el archivo resultante*/
        DownloadFile(json.fileNameResult, "application/pdf");
      };
      file_reader.readAsArrayBuffer(e.target.files[0]);
    };