ForHosting KIT · Strumenti per sviluppatori

Estragga i parametri di percorso OpenAPI in ordine

I modelli di percorso OpenAPI racchiudono i segmenti variabili tra parentesi graffe, ma generatori di documentazione, costruttori di richieste, dati di prova e generatori di codice spesso richiedono quei nomi in un elenco ordinato.

● BetaGratis · nel tuo browser

Esegui gratis nel browser Vedi l'API

Usalo da WebAPIEmailTelegramApp presto

Questa capacità esamina un modello da sinistra a destra, restituisce ogni parametro nella posizione originale e rifiuta parentesi graffe di apertura o chiusura spaiate. È deterministica, non usa la rete e produce sempre lo stesso risultato per lo stesso input; risulta quindi adatta a script di compilazione, passaggi di convalida, editor e flussi API automatizzati.

Trasformi un modello di percorso in un elenco ordinato

Un’operazione OpenAPI può utilizzare un percorso come <code>/users/{id}/posts/{postId}</code>, mentre gli strumenti collegati possono richiedere i nomi <code>id</code> e <code>postId</code> come valori separati. L’estrattore legge il modello dal primo all’ultimo carattere e restituisce i parametri nello stesso ordine. L’ordine è importante perché un costruttore di richieste, un server simulato, un esempio di documentazione o un generatore di test può associare i valori alle posizioni che occupano nell’URL. L’analisi non ordina, non elimina duplicati, non rinomina e non normalizza il testo acquisito. Se un nome compare due volte, appare due volte anche nel risultato, che rispecchia fedelmente il modello fornito. I segmenti statici vengono ignorati, quindi barre, versioni, punteggiatura e testo comune esterno alle parentesi non aggiungono rumore. Un modello privo di segmenti delimitati da parentesi graffe è valido e restituisce un elenco vuoto. Questo comportamento mirato rende il risultato prevedibile e facile da inserire in un processo OpenAPI più ampio senza trasformazioni nascoste.

Individui parentesi non valide prima delle fasi successive

Una parentesi mancante può compromettere silenziosamente il lavoro successivo. Per esempio, un generatore potrebbe interpretare il resto del percorso come un unico parametro, oppure un visualizzatore di documentazione potrebbe mostrare un modello che non potrà mai corrispondere a una richiesta. L’estrattore rifiuta quindi una parentesi di chiusura senza precedente apertura, un’apertura che non viene mai chiusa e una seconda apertura incontrata prima della chiusura del parametro corrente. L’errore indica la posizione della parentesi, rendendo più rapido diagnosticare modelli errati nei registri di compilazione o negli strumenti interattivi. La convalida avviene durante la stessa scansione lineare usata per l’estrazione, quindi non esiste uno stato di analisi separato che possa divergere dall’elenco restituito. I modelli bilanciati procedono normalmente, compresi quelli con nomi ripetuti o senza parametri. La capacità si concentra esclusivamente sulla struttura delle parentesi graffe; non convalida un intero documento OpenAPI, non verifica l’esistenza degli oggetti parametro dichiarati e non decide se un nome rispetta le convenzioni del Suo team. Tali controlli più ampi spettano alla convalida dello schema o della specifica.

Utilizzi il risultato in generatori, test e strumenti API

L’elenco restituito è pensato come un valore intermedio piccolo e componibile. Un generatore di codice può confrontarlo con i parametri di percorso dichiarati dall’operazione, uno strumento di test può creare un campo dati per ogni nome e un’interfaccia per richieste può mostrare i controlli nell’ordine del percorso. Anche un analizzatore può eseguire prima l’estrazione e fermarsi subito se la struttura delle parentesi è errata, evitando messaggi secondari poco chiari. Poiché l’algoritmo usa soltanto una scansione deterministica dei caratteri, non effettua chiamate di rete, non conserva l’input, non impiega valori casuali e non dipende dall’ora corrente. Può quindi essere ripetuto in sicurezza nell’integrazione continua e memorizzato nella cache in base all’input. Invii il modello nel campo <code>text</code> e legga l’elenco ordinato in <code>parameters</code>. L’esecuzione tramite API costa $0.002 per richiesta, mentre la versione per browser può funzionare localmente. Questa capacità estrae i nomi da un solo modello; non risolve variabili del server, non sostituisce valori, non codifica segmenti URL e non analizza un file OpenAPI YAML o JSON completo.

Casi d'uso

Controllare le dichiarazioni delle operazioni

Confronti i nomi estratti con i parametri di percorso dichiarati in OpenAPI e segnali dichiarazioni mancanti o superflue.

Creare moduli per le richieste

Generi controlli di input nello stesso ordine in cui le variabili compaiono nel modello di percorso.

Generare test API

Converta le variabili di percorso in campi dati ordinati prima di inserire valori di prova nelle richieste.

Domande frequenti

Che cosa restituisce questa capacità?

Restituisce un elenco parameters con ogni nome delimitato da parentesi graffe, da sinistra a destra.

Che cosa accade se una parentesi è spaiata?

La richiesta fallisce con un errore di input non valido che specifica se la parentesi spaiata apre o chiude e ne indica l’indice.

I nomi dei parametri ripetuti vengono rimossi?

No. I nomi ripetuti restano nel risultato perché l’output rappresenta ogni occorrenza nell’ordine del modello.

Convalida un documento OpenAPI completo?

No. Esamina un modello di percorso e le sue parentesi; non analizza YAML, JSON, operazioni o dichiarazioni di parametri.

Quanto costa una richiesta API?

Ogni richiesta API costa $0.002. La versione per browser può funzionare senza inviare il modello a un server.

Per sviluppatori — accesso via API

Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.

Endpoint

POSThttps://api.kit.forhosting.com/dev/openapi-path-params-extract

Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.

Chiamala dal tuo stack

curl -X POST https://api.kit.forhosting.com/dev/openapi-path-params-extract \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"/users/{id}/posts/{postId}"}'

const res = await fetch("https://api.kit.forhosting.com/dev/openapi-path-params-extract", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "text": "/users/{id}/posts/{postId}"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/openapi-path-params-extract",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "text": "/users/{id}/posts/{postId}"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/openapi-path-params-extract", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"text":"/users/{id}/posts/{postId}"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"text":"/users/{id}/posts/{postId}"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/openapi-path-params-extract", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Esempio di richiesta

{
  "text": "/users/{id}/posts/{postId}"
}

Esempio di risposta

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.openapi_path_params_extract",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.

Prezzi

per richiesta$0.002

Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.

Errori

HTTP	Codice	Significato
`401`	`unauthorized`	Chiave API mancante o non valida: controlla l'header Authorization.
`402`	`insufficient_balance`	Credito esaurito: ricarica per continuare a eseguire attività.
`404`	`unknown_type`	Tipo di attività sconosciuto: controlla il campo type della richiesta.
`429`	`rate_limited`	Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo.

Leggi la documentazione completa del KIT →