Importa dati senza utilizzare l'archiviazione

L’importazione dei dati Excel è un processo complesso. Molti fattori contribuiscono alla complessità e, pertanto, è necessario tenerne conto durante il processo di esportazione. La possibilità di importare diversi formati e tipologie di dati nel file con una qualità professionale e precisa è una delle caratteristiche principali di Aspose.Cells Cloud.

Questo REST API indica import data in un file Excel.

RSET API


POST https://api.aspose.cloud/v3.0/cells/import

I parametri della richiesta sono:

Nome del parametro	Tipo	Percorso/Stringa di query/Corpo HTTP	Descrizione
file	file	formData	File da caricare
Opzione di importazione	Opzioni di importazione	HTTPBody	IntArray/DoubleArray/StringArray/TwoDimensionIntArray/TwoDimensionDoubleArray/TwoDimensionStringArray/BatchData/CSVData/Immagine

Parametri delle opzioni di importazione dei dati sono descritti inil collegamento di riferimento.

ILSpecifiche OpenAPI definisce un’interfaccia di programmazione accessibile al pubblico e consente di eseguire interazioni REST direttamente da un browser web.

È possibile utilizzare lo strumento da riga di comando cURL per accedere facilmente ai servizi web Aspose.Cells. L’esempio seguente mostra come effettuare chiamate al Cloud API con cURL.

Request

 
curl -v "http://api.aspose.cloud/v3.0/cells/import" \
-X POST \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
-H "Authorization: Bearer <jwt token>" \
-F 'xxxxx1=@xxxx1.xlsx' \
-F 'xxxxx2=@xxxx2.xlsx' \
-F 'ImportOption={\"Data\":[1,2,4],\"DestinationWorksheet\":\"Sheet1\",\"FirstRow\":1,\"FirstColumn\":2,\"IsVertical\":true,\"IsInsert\":true,\"importDataType\":\"IntArray\"}'

Response

{
    "Files":
    [
        { 
            "Filename":"xxxxx",
            "FileSize":274022,
            "FileContent":"-----Base64String--------"
        },
        { 
            "Filename":"xxxxx",
            "FileSize":274022,
            "FileContent":"-----Base64String--------"
        }
    ]
}

Famiglia Cloud SDK

Utilizzare un SDK è il modo migliore per accelerare lo sviluppo. Un SDK si occupa dei dettagli di basso livello e ti consente di concentrarti sulle attività del progetto. Dai un’occhiata aRepository GitHub per un elenco completo di Aspose.Cells Cloud SDK.

I seguenti esempi di codice mostrano come effettuare chiamate ai servizi Web Aspose.Cells utilizzando vari SDK:

	namespace Aspose.Cells.Cloud.SDK.Tests.Api.Example
	{
	using Microsoft.VisualStudio.TestTools.UnitTesting;
	using Aspose.Cells.Cloud.SDK.Request;
	using System.Collections.Generic;
	using Aspose.Cells.Cloud.SDK.Api;
	using System;
	using System.IO;

	[TestClass]
	public class CellsApiExample
	{
	string CellsCloudClientId ="....";//get from https://dashboard.aspose.cloud/#/applications
	string CellsCloudClientSecret="...";//get from https://dashboard.aspose.cloud/#/applications
	private readonly string remoteFolder = "TestData/In";
	string localName = "Book1.xlsx";
	string remoteName = "remote_book1.xlsx";
	string localPath = "D:/TestData/CellsCloud";
	[TestCategory("Cells")]
	[TestMethod]
	public void Example()
	{


	UploadFileRequest uploadFileRequest = new UploadFileRequest();
	FileInfo fileInfo = new FileInfo(localPath + "/" + localName);
	uploadFileRequest.path = remoteFolder + "/" + remoteName;
	uploadFileRequest.storageName = "";
	uploadFileRequest.UploadFiles = new Dictionary<string, Stream>() { { localName, File.OpenRead(localPath +"/"+ localName) } };
	cellsApi.UploadFile(uploadFileRequest);


	var importOptionData = new List<int?>()
	{
	1,
	2,
	3,
	4
	};
	var importOption = new ImportIntArrayOption()
	{
	DestinationWorksheet = "Sheet1",
	FirstColumn = 1,
	FirstRow = 3,
	ImportDataType = "IntArray",
	IsInsert = true,
	IsVertical = true,
	Data = importOptionData
	};
	var request = new PostImportDataRequest(
	name: remoteName,
	importOption: importOption,
	folder: remoteFolder,
	storageName: ""
	);
	cellsApi.PostImportData(request);







	}


	}
	}

view raw ExamplePostImportData.cs hosted with ❤ by GitHub

Java

	package com.aspose.cloud.cells.api;
	import com.aspose.cloud.cells.client.*;
	import com.aspose.cloud.cells.model.*;
	import com.aspose.cloud.cells.request.*;
	import java.io.IOException;
	import org.junit.Test;
	import java.util.ArrayList;
	import java.util.List;
	import java.io.File;
	import java.util.HashMap;

	public class Example {
	private CellsApi api;
	public Example(){
	try {
	api = new CellsApi(
	System.getenv("CellsCloudClientId"),
	System.getenv("CellsCloudClientSecret"),
	"v3.0",
	System.getenv("CellsCloudApiBaseUrl")
	);
	} catch (ApiException e) {
	e.printStackTrace();
	}
	}

	public void Run(){
	try{
	String remoteFolder = "TestData/In";

	String localName = "Book1.xlsx";
	String remoteName = "Book1.xlsx";

	UploadFileRequest uploadFileRequest = new UploadFileRequest();
	uploadFileRequest.setPath( remoteFolder + "/" + remoteName );
	uploadFileRequest.setStorageName( "");
	HashMap<String,File> files = new HashMap<String,File>();
	files.put( localName , new File(localName ));
	uploadFileRequest.setUploadFiles(files);
	api.uploadFile(uploadFileRequest);

	PostImportDataRequest request = new PostImportDataRequest();
	ImportIntArrayOption importOption = new ImportIntArrayOption();
	importOption.setDestinationWorksheet("Sheet1");


	importOption.setFirstColumn(1);


	importOption.setFirstRow(3);


	importOption.setImportDataType("IntArray");


	importOption.setIsInsert(true);


	importOption.setIsVertical(true);


	ArrayList<Integer> importOptionData = new ArrayList<Integer>();
	importOption.setData(importOptionData);

	request.setImportOption(importOption);

	request.setName(remoteName);

	request.setFolder(remoteFolder);

	request.setStorageName("");

	this.api.postImportData(request);

	} catch (ApiException e) {
	e.printStackTrace();
	}catch (IOException e) {
	e.printStackTrace();
	}
	}
	}

view raw Example_PostImportData.java hosted with ❤ by GitHub

PHP

	<?php
	require_once('vendor\autoload.php');
	use \Aspose\Cells\Cloud\Api\CellsApi;
	use \Aspose\Cells\Cloud\Request\PostImportDataRequest;

	$CellsCloudClientId = "...." ; # get from https://dashboard.aspose.cloud/#/applications
	$CellsCloudClientSecret = "...."; # get from https://dashboard.aspose.cloud/#/applications
	$cellsApi = new CellsApi($CellsCloudClientId , $CellsCloudClientSecret );

	$remoteFolder = "TestData/In";

	$localName = "Book1.xlsx";
	$remoteName = "Book1.xlsx";

	$importOptionData = array (
	1,
	2,
	3,
	4
	);
	$importOption = new \Aspose\Cells\Cloud\Model\ImportIntArrayOption();
	$importOption->setDestinationWorksheet("Sheet1" );
	$importOption->setFirstColumn(1 );
	$importOption->setFirstRow(3 );
	$importOption->setImportDataType("IntArray" );
	$importOption->setIsInsert('true' );
	$importOption->setIsVertical('true' );
	$importOption->setData($importOptionData );


	$request = new PostImportDataRequest();
	$request->setName( $remoteName);
	$request->setImportOption( $importOption);
	$request->setFolder( $remoteFolder);
	$request->setStorageName( "");
	$cellsApi->postImportData($request);

view raw Example_PostImportData.php hosted with ❤ by GitHub

Ruby

	require 'openssl'
	require 'bundler'
	require 'aspose_cells_cloud'


	CellsCloudClientId = "...." # get from https://dashboard.aspose.cloud/#/applications
	CellsCloudClientSecret = "...." # get from https://dashboard.aspose.cloud/#/applications
	@instance = AsposeCellsCloud::CellsApi.new(CellsCloudClientId, CellsCloudClientSecret)

	remote_folder = 'TestData/In'

	local_name = 'Book1.xlsx'
	remote_name = 'Book1.xlsx'


	mapFiles = { }
	mapFiles[local_name] = ::File.open(File.expand_path("TestData/"+local_name),"r")

	uploadrequest = AsposeCellsCloud::UploadFileRequest.new( { :UploadFiles=>mapFiles,:path=>remote_folder })
	@instance.upload_file(uploadrequest)
	importOptionData = [
	1,
	2,
	3,
	4
	];
	importOption = AsposeCellsCloud::ImportIntArrayOption.new(:DestinationWorksheet=>'Sheet1' ,:FirstColumn=>1 ,:FirstRow=>3 ,:ImportDataType=>'IntArray' ,:IsInsert=>true ,:IsVertical=>true ,:Data=>importOptionData );
	request = AsposeCellsCloud::PostImportDataRequest.new(:name=>remote_name,:importOption=>importOption,:folder=>remote_folder,:storageName=>'');
	@instance.post_import_data(request);

view raw Example_PostImportData.rb hosted with ❤ by GitHub

Node.js

	import { CellsApi,ImportIntArrayOption,PostImportDataRequest,UploadFileRequest } from "asposecellscloud";
	var fs = require('fs');
	var path = require('path');
	var process = require('process');
	const _ = require('asposecellscloud');

	const CellsCloudClientId ="....";//get from https://dashboard.aspose.cloud/#/applications
	const CellsCloudClientSecret="...";//get from https://dashboard.aspose.cloud/#/applications
	const cellsApi = new CellsApi(CellsCloudClientId, CellsCloudClientSecret);

	var remoteFolder = "TestData/In"
	var localPath = "TestData/CellsCloud/"
	var localName = "Book1.xlsx"
	var remoteName = "Book1.xlsx"


	describe('example', function(){
	it("should call successfully" , function(){
	var localNameRequest = new UploadFileRequest();
	localNameRequest.uploadFiles ={localName:fs.createReadStream(localPath + localName)};
	localNameRequest.path = remoteFolder + "/" + remoteName ;
	localNameRequest.storageName ="";
	cellsApi.uploadFile(localNameRequest );

	var importOptionData = new Array<number>();importOptionData.push(1);
	importOptionData.push(2);
	importOptionData.push(3);
	importOptionData.push(4);
	var importOption = new ImportIntArrayOption();
	importOption.destinationWorksheet = "Sheet1" ;
	importOption.firstColumn = 1 ;
	importOption.firstRow = 3 ;
	importOption.importDataType = "IntArray" ;
	importOption.isInsert = true ;
	importOption.isVertical = true ;
	importOption.data = importOptionData ;

	var request = new PostImportDataRequest();
	request.name = remoteName;
	request.importOption = importOption;
	request.folder = remoteFolder;
	request.storageName = "";
	return cellsApi.postImportData(request)
	});

view raw Example_PostImportData.ts hosted with ❤ by GitHub

Python

	import os
	import sys

	from asposecellscloud.apis.cells_api import CellsApi
	from asposecellscloud.models import *
	from asposecellscloud.requests import *

	CellsCloudClientId ='....' # get from https://dashboard.aspose.cloud/#/applications
	CellsCloudClientSecret='....' # get from https://dashboard.aspose.cloud/#/applications
	api = CellsApi(CellsCloudClientId,CellsCloudClientSecret)
	importOption = ImportIntArrayOption(destination_worksheet= 'Sheet1' ,first_column= 1 ,first_row= 3 ,import_data_type= 'IntArray' ,is_insert= True ,is_vertical= True ,data= [1,2,3,4] )
	request = PostImportDataRequest( 'Book1.xlsx',import_option= importOption,folder= 'PythonTest',storage_name= '')
	api.post_import_data(request)

view raw Example_PostImportData.py hosted with ❤ by GitHub

Perl

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $CellsCloudClientId = "...."; # get from https://dashboard.aspose.cloud/#/applications
	my $CellsCloudClientSecret = "...."; # get from https://dashboard.aspose.cloud/#/applications
	my $config = AsposeCellsCloud::Configuration->new( client_id => $CellsCloudClientId , client_secret => $CellsCloudClientSecret );

	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my @import_option_data = [];push (@import_option_data ,1 );
	push (@import_option_data ,2 );
	push (@import_option_data ,3 );
	push (@import_option_data ,4 );
	my $import_option = AsposeCellsCloud::Object::ImportIntArrayOption->new();
	$import_option->{destination_worksheet} = 'Sheet1' ;
	$import_option->{first_column} = 1 ;
	$import_option->{first_row} = 3 ;
	$import_option->{import_data_type} = 'IntArray' ;
	$import_option->{is_insert} = 'true' ;
	$import_option->{is_vertical} = 'true' ;
	$import_option->{data} = []; push ( @{$import_option->{data}}, 1 );
	push ( @{$import_option->{data}}, 2 );
	push ( @{$import_option->{data}}, 3 );
	push ( @{$import_option->{data}}, 4 ); ;

	my $request = AsposeCellsCloud::Request::PostImportDataRequest->new();
	$request->{name} = $remoteName;
	$request->{import_option} = $import_option;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_import_data(request=> $request);

view raw Example_PostImportData.pl hosted with ❤ by GitHub

	package main

	import (
	. "github.com/aspose-cells-cloud/aspose-cells-cloud-go/v25"
	)

	func main() {
	CellsCloudClientId := "...." // get from https://dashboard.aspose.cloud/#/applications
	CellsCloudClientSecret := "...." // get from https://dashboard.aspose.cloud/#/applications
	instance := NewCellsApiService(CellsCloudClientId, CellsCloudClientSecret)
	remoteFolder := "TestData/In"

	localName := "Book1.xlsx"
	remoteName := "Book1.xlsx"

	localNameRequest := new(UploadFileRequest)
	localNameRequest.UploadFiles = make(map[string]string)
	localNameRequest.UploadFiles[localName] = localName
	localNameRequest.Path = remoteFolder + "/" + remoteName
	localNameRequest.StorageName = ""
	instance.UploadFile(localNameRequest)

	var importOptionData = []int64{int64(1),
	int64(2),
	int64(3),
	int64(4)}
	var importOption = new(ImportIntArrayOption)
	importOption.DestinationWorksheet = "Sheet1"
	importOption.FirstColumn = int64(1)
	importOption.FirstRow = int64(3)
	importOption.ImportDataType = "IntArray"
	importOption.IsInsert = true
	importOption.IsVertical = true
	importOption.Data = importOptionData

	request := new(PostImportDataRequest)
	request.Name = remoteName
	request.ImportOption = importOption
	request.Folder = remoteFolder
	request.StorageName = ""
	_, httpResponse, err := instance.PostImportData(request)
	if err != nil {
	println(err.Error())
	} else if httpResponse.StatusCode < 200 \|\| httpResponse.StatusCode > 299 {
	println("Fail")
	}
	}

view raw Example_PostImportData.go hosted with ❤ by GitHub

Importa dati batch nel foglio di lavoro Excel