Trouvez‑le, corrigez‑le, validez‑le : Guide complet de l’API de recherche, remplacement et liens brisés d’Aspose.Cells Cloud (.NET / Python / Java / cURL)

“Lequel de nos 400 classeurs budgétaires indique encore Old Vendor Ltd ?” “Remplacez chaque espace réservé {{COMPANY}} dans ce modèle.” “Est‑ce que l’un de nos rapports pointe encore vers ce domaine que nous avons retiré l’an dernier ?” — trois questions très différentes, une réponse commune : un appel REST qui lit et réécrit des feuilles de calcul dans le cloud, sans qu’Excel ne soit installé nulle part.

Les problèmes de contenu de feuille de calcul apparaissent dans presque toutes les bases de code riches en données :

• Audit de contenu — trouver chaque cellule, forme ou hyperlien qui mentionne un nom de produit obsolète, une ancienne adresse de bureau ou une entité juridique périmée ;
• Rendu de modèle — remplir les jetons {{PLACEHOLDER}} à travers les feuilles avant d’envoyer un classeur à un client ;
• Dégradation des liens — vérifier que les URL intégrées dans un classeur résolvent toujours, avant qu’une tâche de conformité ou d’archivage ne la valide ;
• Correction en masse — corriger une faute de frappe ou une valeur de colonne mal orthographiée à travers des dizaines de feuilles, ou limitée à une seule région d’une feuille.

Les options traditionnelles — une bibliothèque de scripts s’exécutant sur votre propre machine, une macro Excel ou un composant COM sur un serveur Windows — signifient toutes que vous êtes celui qui héberge et fait évoluer la logique des feuilles de calcul. Aspose.Cells Cloud le transforme en REST simple : envoyez un fichier (ou simplement un nom de fichier), obtenez des correspondances — ou un fichier corrigé — en retour.

Cet article parcourt les API exposées par le contrôleur principal SearchController du microservice Aspose.Cells Cloud (source : src/Aspose.Cells.Cloud.MicroService/Controllers/SearchController.cs), avec des exemples exécutables en cURL et C# (.NET), ainsi que des notes pour les utilisateurs Python et Java.

1. Que peut faire le SearchController ?

SearchController couvre trois familles de capacités, chacune disponible à plusieurs périmètres :

Et chaque famille est exposée à quatre portées, ce qui rend la liste des points de terminaison longue :

Plus deux points de terminaison bonus qui extraient chaque élément de texte d’un classeur — voir §4 :

Note d’implémentation : les routes sont préfixées par v{version:apiVersion}/cells et ce contrôleur est [ApiVersion("4.0")], ainsi les appels en direct ressemblent à https://api.aspose.cloud/v4.0/cells/.... Tout dans ce contrôleur est un PUT — même les recherches en lecture seule — car une recherche est modélisée comme une opération soumise à une ressource, et non comme un GET cacheable.

Les deux modes d’opération, et pourquoi ils sont importants

Le contrôleur décore chaque action, et le décorateur vous indique exactement d’où provient le fichier :

• [OnlineOperation] — sans état. Vous téléversez le classeur dans le corps de la requête (multipart), le serveur le traite en mémoire, et rien n’est persistant dans le stockage cloud. Idéal pour « dites‑moi simplement ce qu’il y a dans ce fichier » et pour le templating ponctuel.
• [CloudFileOperation] — basé sur le stockage. Le serveur récupère {name} depuis le stockage cloud (éventuellement sous folder=), effectue le travail, et — pour les opérations de remplacement — écrit le résultat directement en retour. Rien ne transite vers votre machine.

Cette unique distinction, ainsi que les segments de route {worksheet} / {cellArea}, constituent le modèle mental complet. Le reste de cet article ne contient que les détails.

2. Les modèles de réponse que vous analyserez réellement

Les deux familles de recherche renvoient une forme petite, plate, facile à lier. Search renvoie SearchResponse:

{
  "Code": 200,
  "Status": "OK",
  "TextItems": [
    {
      "Filename": "Book1.xlsx",
      "Worksheet": "Q3 Forecast",
      "Position": "Cell:B7",
      "Content": "Old Vendor Ltd"
    },
    {
      "Filename": "Book1.xlsx",
      "Worksheet": "Q3 Forecast",
      "Position": "Shape:TextBox 3",
      "Content": "Prepared by Old Vendor Ltd"
    }
  ]
}

La recherche de liens brisés renvoie BrokenLinksResponse:

{
  "Code": 200,
  "Status": "OK",
  "BrokenLinks": [
    {
      "Filename": "Book1.xlsx",
      "Worksheet": "Links",
      "Position": "Hyperlink:Sheet1!B4",
      "LinkAddress": "https://retired-domain.example.com/report"
    }
  ]
}

Deux choses méritent d’être soulignées immédiatement :

1. Position est un emplacement balisé, pas seulement une adresse de cellule. Il est préfixé par Cell:, Hyperlink: ou Shape:, ce qui permet à une liste plate unique de vous indiquer quel type d’élément a été trouvé. Cette balise fait la différence entre « corriger la cellule B7 » et « corriger la zone de texte située au-dessus de B7 ».
2. Les deux modèles sont auto-descriptifs pour le reporting — Filename et Worksheet sont renvoyés pour chaque élément, de sorte qu’une analyse de nombreux classeurs puisse être concaténée en une seule table d’audit sans post-traitement.

3. Deux choses dont vous avez besoin avant de commencer

1. Enregistrez un compte gratuit sur le Aspose Cloud Dashboard et créez une application pour obtenir un Client ID et un Client Secret (les SDK échangent ces informations contre un JWT automatiquement — pas besoin de créer vous‑même les en‑têtes d’authentification).
2. Installez le SDK pour le langage de votre choix:

<!-- .NET -->
<PackageReference Include="Aspose.Cells-Cloud" Version="25.x" />

# Python
pip install asposecellscloud

<!-- Java (Maven) — note: NOT on Maven Central, so the Aspose repo below is required -->
<repositories>
    <repository>
        <id>AsposeJavaAPI</id>
        <name>Aspose Java API</name>
        <url>https://repository.aspose.cloud/repo/</url>
    </repository>
</repositories>

<dependency>
    <groupId>com.aspose</groupId>
    <artifactId>aspose-cells-cloud</artifactId>
    <version>26.8</version>
</dependency>

Pas de SDK requis ? Tout est du REST pur, donc cURL fonctionne tout aussi bien (voir ci‑dessous). La famille recherche/remplacement/liens cassés est également accessible via des modèles de requête SDK typés — SearchSpreadsheetContentRequest, ReplaceContentInRemoteRangeRequest, et leurs amis — ce qui est ce que les extraits C# ci‑dessous utilisent.

4. Scénario A : Rechercher un fichier local en ligne (aucune persistance)

Ceci est PUT /v4.0/cells/search/content — téléchargez le classeur, récupérez les correspondances. Pas de stockage cloud, pas de nettoyage, aucune copie laissée derrière.

① cURL

# 1) First, get a token
curl -X POST "https://api.aspose.cloud/connect/token" \
  -d "grant_type=client_credentials" \
  -d "client_id=YOUR_CLIENT_ID" \
  -d "client_secret=YOUR_CLIENT_SECRET"

# 2) Find "Old Vendor Ltd" anywhere in a local workbook
curl -X PUT "https://api.aspose.cloud/v4.0/cells/search/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText=Old Vendor Ltd" \
  --data-urlencode "ignoringCase=true" \
  -F "file=@Book1.xlsx"

Restreignez-le à une feuille, ou à une région d’une feuille, avec deux paramètres de requête supplémentaires :

# Only "Q3 Forecast", only the range A1:F40
curl -X PUT "https://api.aspose.cloud/v4.0/cells/search/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText=Old Vendor Ltd" \
  --data-urlencode "worksheet=Q3 Forecast" \
  --data-urlencode "cellArea=A1:F40" \
  -F "file=@Book1.xlsx"

② C# / .NET

using Aspose.Cells.Cloud.SDK.Api;
using Aspose.Cells.Cloud.SDK.Request;

var cellsApi = new CellsApi("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");

// Local file, whole workbook
var request = new SearchSpreadsheetContentRequest(
    spreadsheet:  "C:/audit/Book1.xlsx",   // local file path
    searchText:   "Old Vendor Ltd",
    ignoringCase: true);

SearchResponse response = cellsApi.SearchSpreadsheetContent(request);

foreach (var item in response.TextItems)
{
    Console.WriteLine($"{item.Worksheet} | {item.Position} | {item.Content}");
}

// Same call, scoped to one sheet and one range
var scoped = new SearchSpreadsheetContentRequest(
    spreadsheet:  "C:/audit/Book1.xlsx",
    searchText:   "Old Vendor Ltd",
    ignoringCase: true,
    sheetname:    "Q3 Forecast",
    cellarea:     "A1:F40");

Les modèles de requête exposent également password (ouvrir un classeur protégé) et regoin (paramètre de région/locale) — les mêmes paramètres optionnels que vous verrez sur les variantes cloud‑storage sous le nom storageName. Notez que le SDK .NET conserve l’orthographe regoin ; le SDK Python appelle les mêmes deux paramètres password et region.

③ Python / Java

Le SDK Python encapsule la même famille de points de terminaison, les champs du modèle de requête étant mappés aux champs C# un à un, mais en snake_case :

from asposecellscloud.apis.cells_api import CellsApi
from asposecellscloud.requests import (
    SearchSpreadsheetContentRequest,
    SearchContentInRemoteRangeRequest,
)

instance = CellsApi("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET")

# Local upload — returned items carry Worksheet / Position / Content
local = instance.search_spreadsheet_content(
    SearchSpreadsheetContentRequest(
        "Book1.xlsx", "Old Vendor Ltd",
        ignoring_case=True, worksheet="Q3 Forecast", cell_area="A1:F40"))

# Range-scoped search of a file already in cloud storage
remote = instance.search_content_in_remote_range(
    SearchContentInRemoteRangeRequest(
        "Book1.xlsx", "Q3 Forecast", "A1:F40", "Old Vendor Ltd",
        ignoring_case=True, folder="Reports"))

for item in remote.text_items:
    print(item.worksheet, item.position, item.content)

Le SDK Java suit la même forme avec des objets Request construits via des setters :

import com.aspose.cloud.cells.api.CellsApi;
import com.aspose.cloud.cells.model.SearchResponse;
import com.aspose.cloud.cells.request.SearchContentInRemoteRangeRequest;

public class SearchDemo {
    public static void main(String[] args) throws Exception {
        CellsApi api = new CellsApi("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");

SearchContentInRemoteRangeRequest req = new SearchContentInRemoteRangeRequest();
        req.setName("Book1.xlsx");
        req.setWorksheet("Q3 Forecast");
        req.setCellArea("A1:F40");
        req.setSearchText("Old Vendor Ltd");
        req.setIgnoringCase(true);
        req.setFolder("Reports");

SearchResponse response = api.searchContentInRemoteRange(req);
        response.getTextItems().forEach(i ->
            System.out.println(i.getWorksheet() + " | " + i.getPosition() + " | " + i.getContent()));
    }
}

Si vous utilisez le REST brut, le cURL ci‑dessus constitue le contrat complet — le champ multipart doit simplement contenir le nom de fichier, car le service déduit le nom du classeur (et donc son format) à partir de celui‑ci.

5. Scénario B : Rechercher un fichier déjà présent dans le stockage cloud

Lorsque le classeur se trouve déjà dans Aspose Cloud Storage, ignorez complètement le téléchargement — le service le lit là où il se trouve :

# Whole workbook
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/search/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText=Old Vendor Ltd" \
  --data-urlencode "ignoringCase=true" \
  --data-urlencode "folder=Reports"

# Just one worksheet
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/worksheets/Q3%20Forecast/search/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText=Old Vendor Ltd"

# Just one range of one worksheet
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/worksheets/Q3%20Forecast/ranges/A1:F40/search/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText=Old Vendor Ltd"

// Whole workbook in storage
var response = cellsApi.SearchContentInRemoteSpreadsheet(
    new SearchContentInRemoteSpreadsheetRequest(
        name:         "Book1.xlsx",
        searchText:   "Old Vendor Ltd",
        ignoringCase: true,
        folder:       "Reports"));

// One worksheet
var sheetHits = cellsApi.SearchContentInRemoteWorksheet(
    new SearchContentInRemoteWorksheetRequest(
        name:       "Book1.xlsx",
        sheetname:  "Q3 Forecast",
        searchText: "Old Vendor Ltd",
        folder:     "Reports"));

// One range
var rangeHits = cellsApi.SearchContentInRemoteRange(
    new SearchContentInRemoteRangeRequest(
        name:        "Book1.xlsx",
        sheetname:   "Q3 Forecast",
        cellArea:    "A1:F40",
        searchText:  "Old Vendor Ltd",
        ignoringCase: true,
        folder:      "Reports"));

Pourquoi trois points de terminaison au lieu d’un ? Parce que la route transporte le périmètre. Le point de terminaison whole‑workbook accepte un nom et une requête ; le point de terminaison worksheet accepte un segment de feuille de calcul ; le point de terminaison range accepte un segment de feuille de calcul et un segment de plage. C’est une forme REST propre et mise en cache — et cela signifie que les paramètres « réduire ma recherche » (worksheet, cellArea) existent uniquement sur le point de terminaison local‑file, ce qui vaut la peine d’être rappelé lorsque vous migrez un appel d’un périmètre à un autre.

6. Scénario C : Obtenir tous les éléments de texte d’un classeur

Parfois, vous n’avez pas de terme de recherche — vous voulez l’inventaire. Les points de terminaison all-textitems renvoient chaque élément texte du classeur, de sorte que vous pouvez comparer deux révisions, créer un glossaire de traduction ou alimenter un indexeur :

# Cloud file — every text item
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/search/content/all-textitems" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "folder=Reports"

# Local upload — every text item
curl -X PUT "https://api.aspose.cloud/v4.0/cells/search/content/all-textitems" \
  -H "Authorization: Bearer $TOKEN" \
  -F "file=@Book1.xlsx"

La réponse est la même enveloppe SearchResponse, avec Content remplie pour chaque chaîne de cellule, légende de lien hypertexte et texte de forme dans le fichier. C’est la primitive “grep the whole workbook”.

7. Scénario D : Remplacer — et les deux résultats très différents

Replace est l’endroit où l’API se divise en deux, et la division est délibérée :

① Remplacer dans un classeur local, renvoyer le résultat sous forme de flux

curl -X PUT "https://api.aspose.cloud/v4.0/cells/replace/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText={{COMPANY}}" \
  --data-urlencode "replaceText=Northwind Traders" \
  -F "file=@template.xlsx" \
  -o template-rendered.xlsx

using Aspose.Cells.Cloud.SDK.Request;

var request = new ReplaceSpreadsheetContentRequest(
    spreadsheet: "C:/templates/template.xlsx",
    searchText:  "{{COMPANY}}",
    replaceText: "Northwind Traders");

// Option A: get the corrected workbook as a Stream
using Stream corrected = cellsApi.ReplaceSpreadsheetContent(request);
using var outFile = File.Create("C:/templates/template-rendered.xlsx");
corrected.CopyTo(outFile);

// Option B: let the SDK write it for you (.NET overload with an output path)
// cellsApi.ReplaceSpreadsheetContent(request, "C:/templates/template-rendered.xlsx");

Deux paramètres de portée sont également disponibles ici — sheetname et cellarea — afin que vous puissiez rendre les espaces réservés dans une feuille sans toucher au reste du modèle.

② Remplacer dans un classeur cloud, le conserver en place

# Whole workbook, saved back to storage
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/replace/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText=Old Vendor Ltd" \
  --data-urlencode "replaceText=Northwind Traders" \
  --data-urlencode "folder=Reports"

# One worksheet
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/worksheets/Q3%20Forecast/replace/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText=Old Vendor Ltd" \
  --data-urlencode "replaceText=Northwind Traders" \
  --data-urlencode "folder=Reports"

# One range
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/worksheets/Q3%20Forecast/ranges/A1:F40/replace/content" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "searchText=Old Vendor Ltd" \
  --data-urlencode "replaceText=Northwind Traders" \
  --data-urlencode "folder=Reports"

// Whole workbook — result saved back into cloud storage
cellsApi.ReplaceContentInRemoteSpreadsheet(
    new ReplaceContentInRemoteSpreadsheetRequest(
        name:        "Book1.xlsx",
        searchText:  "Old Vendor Ltd",
        replaceText: "Northwind Traders",
        folder:      "Reports"));

// Range-scoped
cellsApi.ReplaceContentInRemoteRange(
    new ReplaceContentInRemoteRangeRequest(
        name:        "Book1.xlsx",
        searchText:  "Old Vendor Ltd",
        replaceText: "Northwind Traders",
        worksheet:   "Q3 Forecast",
        cellarea:    "A1:F40",
        folder:      "Reports"));

Le remplacement sur place est destructeur par conception. Les variantes cloud écrasent {name} — aucune copie de sauvegarde n’est créée. Pour les flux de travail fortement axés sur l’audit, conservez une copie révisée (par ex. téléchargez d’abord Book1-2026-09-11.xlsx, puis remplacez) ou utilisez la variante de téléchargement local et stockez vous‑même le flux retourné.

8. Scénario E : Trouver les liens brisés avant que quelqu’un d’autre ne le fasse

La vérification des liens est la fonctionnalité cachée ici — c’est le genre de chose fastidieuse à écrire soi‑même et embarrassante à ignorer. Toutes les quatre portées sont disponibles ; la variante de fichier local est le contrôle de cohérence le plus rapide :

# Local workbook, whole file
curl -X PUT "https://api.aspose.cloud/v4.0/cells/search/broken-links" \
  -H "Authorization: Bearer $TOKEN" \
  -F "file=@Book1.xlsx"

# Cloud workbook, whole file
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/search/broken-links" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "folder=Reports"

# Cloud workbook, one worksheet
curl -X PUT "https://api.aspose.cloud/v4.0/cells/Book1.xlsx/worksheets/Links/search/broken-links" \
  -H "Authorization: Bearer $TOKEN" \
  --data-urlencode "folder=Reports"

var broken = cellsApi.SearchSpreadsheetBrokenLinks(
    new SearchSpreadsheetBrokenLinksRequest(
        spreadsheet: "C:/audit/Book1.xlsx"));

foreach (var link in broken.BrokenLinks)
{
    Console.WriteLine($"{link.Worksheet} {link.Position} -> {link.LinkAddress}");
}

Le résultat est une liste que vous pouvez exploiter directement : chaque entrée indique la feuille, la position et le LinkAddress incriminé.

9. Que se fait réellement scanner ? (les détails d’implémentation qui changent vos attentes)

C’est la partie qui sépare une intégration fonctionnelle d’une intégration surprenante. En lisant WorkbookExtension.cs, une recherche parcourt trois types d’éléments distincts dans chaque feuille de calcul :

Et voici les comportements qu’il vaut la peine de connaître avant de les concevoir autour :

Seules les cellules de type chaîne sont recherchées. Le balayage filtre sur CellValueType.IsString. Une cellule contenant un nombre, une date ou un booléen est ignorée — ainsi, une recherche de 2025 ne correspondra pas à une cellule formatée en date dont la valeur sérielle est 2025. Les cellules dont les formules évaluent du texte sont correspondantes, car leur type de valeur est chaîne.

La sensibilité à la casse est la seule option de correspondance. ignoringCase bascule entre InvariantCultureIgnoreCase et InvariantCulture comparaison — rien de plus. Il n’existe aucun mode mot entier, regex ou « correspondance de toute la valeur de la cellule », malgré ce que les documents API générés pourraient laisser penser. Si vous avez besoin de ces sémantiques, récupérez l’inventaire all-textitems et filtrez‑le de votre côté.

Le remplacement est simple, sensible à la casse, une substitution littérale. Le drapeau ignoringCase de Search n’a aucun équivalent dans Replace — le chemin de remplacement n’a aucun paramètre d’insensibilité à la casse. Et les deux chemins de code diffèrent en interne : un remplacement de feuille entière délègue à la méthode Worksheet.Replace(...) du moteur, tandis qu’un remplacement limité à une plage parcourt la plage et réécrit chaque cellule de texte avec cell.StringValue.Replace(...). Conséquence pratique : le remplacement limité à une plage ne touche que les cellules de texte, et il est littéral, pas basé sur des motifs.

Les correspondances d’hyperlien renvoient l’adresse, pas la légende. Lorsque qu’une recherche correspond au texte d’affichage d’un hyperlien, le Content renvoyé reste hyperlink.Address. Si vous générez un rapport “trouvé ici”, attendez-vous à l’URL — la légende n’est pas renvoyée.

La vérification des liens cassés ne porte que sur http:// et https://. Les liens mailto: , les chemins de fichiers locaux et les ancres internes #Sheet1!A1 sont complètement ignorés — ils ne sont jamais testés, donc ils n’apparaîtront jamais dans les résultats. Elle analyse également les hyperliens attachés aux formes ainsi qu’aux cellules, qui est exactement l’endroit où les liens morts aiment se cacher. Notez qu’un Position de lien cassé est construit à partir du hyperlink.Area brut (et non du plus convivial Area.ToRangName() utilisé par les points de terminaison de recherche), donc ne supposez pas que les deux familles affichent les positions de la même manière — analysez la paire Worksheet + LinkAddress si vous avez besoin d’une clé stable.

“Broken” signifie “inaccessible”, pas “code d’état incorrect”. Le contrôle envoie une requête HTTP HEAD pour chaque lien et considère toute réponse — y compris 404 ou 500 — comme accessible ; il ne marque un lien comme cassé que lorsque la requête lance (échec DNS, connexion refusée, erreur TLS, délai d’attente). Ainsi, traitez la sortie comme “les liens qui n’ont pas pu être contactés”. Si ce dont vous avez réellement besoin est “les liens qui ne renvoient pas 2xx”, vous devrez revérifier vous‑même les valeurs LinkAddress retournées.

cellArea est accepté mais n’est pas appliqué sur les points de terminaison broken-link. L’implémentation BrokenLinks filtre uniquement par le nom de la feuille de calcul ; l’argument de zone de cellules est passé mais jamais utilisé. En pratique, cela signifie que .../ranges/A1:F40/search/broken-links se comporte actuellement de la même manière que /worksheet/search/broken-links pour la même feuille — les liens sont validés sur l’ensemble de la feuille. Adaptez la portée de vos rapports en conséquence (ou filtrez la liste renvoyée par position) plutôt que de supposer que la plage restreint la vérification.

Aucun de ceux‑ci n’est un obstacle — c’est la différence entre une fonctionnalité qui “fonctionne dans la démo” et une qui se comporte de façon prévisible en production.

10. Gestion des erreurs et notes opérationnelles

Le contrat que le contrôleur documente

En interne, chaque action encapsule son travail dans un utilitaire (WorkbookElementOperation, UpdateWorkbookElementOperation, UpdateWorkbookElementOperationAndSave) qui intercepte les échecs et les relance sous forme de CellsApiException préfixé du nom de l’opération — par exemple SearchContentInRemoteRange Error Message: .... Ce nom d’opération est la chaîne que vous verrez dans vos journaux :

Paramètres optionnels exposés par les SDK

Au-delà des paramètres documentés, les modèles de requête cloud-storage comportent tous les mêmes trois paramètres optionnels :

• password — ouvrir un classeur protégé par mot de passe (les recherches ne nécessitent pas d’accès en écriture, donc les fichiers protégés en lecture fonctionnent correctement) ;
• storageName — cibler un stockage cloud personnalisé/attaché au lieu de celui par défaut (Python : storage_name) ;
• regoin — le paramètre de région/locale utilisé lors de l’interprétation du classeur (Python l’appelle region).

Authentification

Tous les SDK s’authentifient automatiquement avec OAuth 2.0 client_credentials et un JWT ; lors de l’utilisation de cURL brut, appelez /connect/token une première fois (voir §4, ①).

11. Pourquoi Aspose.Cells Cloud pour la recherche et le remplacement ?

• ✅ Aucune dépendance locale — pas d’Office/Excel, pas de COM, pas d’hôte de script. Appelable depuis n’importe quel langage, n’importe quelle plateforme (Linux, conteneurs, serverless) ;
• ✅ Plus profond que la recherche de texte — les cellules, formes et hyperliens sont tous des cibles de correspondance de premier ordre, ce qui correspond exactement à l’endroit où les vraies feuilles de calcul conservent leur contenu ;
• ✅ Opérations à portée — classeur / feuille de calcul / plage, ainsi vous pouvez corriger une région d’une feuille sans réécrire un fichier de 50 Mo ;
• ✅ Natif cloud ou sans état — les fichiers déjà stockés ne le quittent jamais ; les opérations de téléchargement local ne persistent rien du tout ;
• ✅ Réécriture haute fidélité — les remplacements sont appliqués via le moteur Aspose.Cells et re‑sérialisés, de sorte que formules, styles, graphiques et mise en forme survivent au aller‑retour ;
• ✅ Une même forme à travers les SDK — les interfaces cURL, .NET, Python et Java sont mappées 1:1, ainsi le modèle que vous copiez d’un langage fonctionne dans les autres.

Commencez dès maintenant : inscrivez‑vous sur le Aspose Cloud Dashboard, créez une Application, insérez vos informations d’identification dans n’importe quel extrait ci‑dessus, et pointez‑le vers l’un de vos classeurs — vous disposerez d’un audit de contenu fonctionnel en quelques minutes.

Vous avez trouvé cela utile ? Ajoutez une étoile, un signet ou partagez‑le — et dites‑nous dans les commentaires à quoi vous utilisez la recherche et le remplacement dans le classeur.