Teorainneacha an Mhóid JSON agus Bainistiú Earráidí
Ar an leathanach seo
Ní Ciallaíonn “Bailí” go bhfuil sé “Ceart”
Ráthaíonn an Mód JSON go bhfuil an JSON bailí ó thaobh na comhréire de, ach ní ráthaíonn sé go bhfuil sé ceart ó thaobh na brí de. D’fhéadfadh an t-idirdhealú seo a bheith mín le linn forbartha, ach éiríonn sé ríthábhachtach i dtimpeallachtaí táirgeachta. Cruthaíonn JSON a pharsáiltear gan earráidí ach ina bhfuil eochracha gan choinne an cineál fabhtanna a thógann laethanta le sárú, toisc nach dtarlaíonn aon eisceacht nuair a tharlaíonn an fhadhb i ndáiríre.
Gan Ráthaíochtaí Scéime
Níl a fhios ag an sásra faoi do scéim: ní fhaca sé riamh an struchtúr a bhfuil súil ag do chód leis. D’fhéadfadh an tsamhail réimse a theastaíonn uait a fhágáil ar lár, ceann nach ndearna tú iarratas air a chur leis, eochair a athainmniú—firstName in ionad first_name—nó cineál a athrú trí "42" a thabhairt ar ais mar shreang nuair a bhí súil agat leis an uimhir 42. Níl aon cheann de seo ina JSON neamhbhailí.
# You expect this:
# {"name": "Alice", "age": 30, "city": "Paris"}
# But you might receive:
# {"nom": "Alice", "âge": "trente ans", "ville": "Paris", "pays": "France"}
Tá an JSON bailí, ach ní hionann an struchtúr agus an méid a bhfuil súil ag do chód leis. Seo an difríocht bhunúsach idir é seo agus Aschuir Struchtúrtha Saincheaptha.
Bailíochtú Éigeantach ar an gCliant
Ós rud é nach bhfuil ráthaíocht ar an scéim, titfidh an bailíochtú ortsa. Déanann an patrún íosta trí rud in ord: déanann sé iarracht parsáil a dhéanamh, fíoraíonn sé gur oibiacht é an fréamh (ní liosta ná scálach), agus ansin seiceálann sé eochracha riachtanacha. Ardaíonn gach teip ValueError le teachtaireacht is féidir leat a úsáid i do logaí.
import json
from typing import Optional
def parse_and_validate(raw_content: str, required_keys: list[str]) -> dict:
"""Parse JSON and verify required keys."""
try:
data = json.loads(raw_content)
except json.JSONDecodeError as e:
raise ValueError(f"Invalid JSON: {e}")
if not isinstance(data, dict):
raise ValueError(f"Expected JSON object, received {type(data).__name__}")
missing = [k for k in required_keys if k not in data]
if missing:
raise ValueError(f"Missing keys: {missing}")
return data
# Usage
try:
result = parse_and_validate(
response.choices[0].message.content,
required_keys=["name", "category", "priority"]
)
process_ticket(result)
except ValueError as e:
log_error(f"Invalid output: {e}")
fallback_processing(raw_content)
Téann an leagan TypeScript céim níos faide trí fhíorú, seachas láithreacht na n-eochracha, go mbaineann an catagóir a tugadh ar ais leis an liosta ceadaithe. Seo an seiceáil is minice a bhíonn ar iarraidh, agus an ceann a chuireann cosc ar thicéad a aicmítear mar "urgent_billing" ó bheith ag sleamhnú go ciúin trí do chóras ródaireachta.
interface TicketClassification {
category: string;
priority: string;
sentiment: string;
summary: string;
}
function validateTicket(raw: string): TicketClassification {
const data = JSON.parse(raw);
const requiredKeys = ["category", "priority", "sentiment", "summary"];
const missing = requiredKeys.filter((k) => !(k in data));
if (missing.length > 0) {
throw new Error(`Missing keys: ${missing.join(", ")}`);
}
const validCategories = ["billing", "account", "technical", "feature_request", "other"];
if (!validCategories.includes(data.category)) {
throw new Error(`Invalid category: ${data.category}`);
}
return data as TicketClassification;
}
Trí Theip a Bhuailfidh Leat
Is é an chéad cheann ná JSON gearrtha. Má shroicheann an freagra an teorainn max_tokens, gearrtar é sa lár agus éiríonn sé neamhbhailí—ní thagann an lúibín dúnta riamh. Is féidir leat an comhartha a aithint fiú sula ndéanann tú parsáil: tá finish_reason cothrom le "length" in ionad "stop".
response = client.chat.complete(
model="mistral-small-latest",
messages=messages,
response_format={"type": "json_object"},
max_tokens=50 # Too small for complete JSON
)
# response.choices[0].finish_reason will be "length" instead of "stop"
if response.choices[0].finish_reason == "length":
print("Warning: Truncated response, increase max_tokens")
Seiceáil finish_reason i gcónaí: má tá sé cothrom le "length", tá an freagra neamhiomlán, beag beann ar an méid a deir an chuid eile den ábhar.
Baineann an dara teip le cineálacha. D’fhéadfadh aois teacht mar shreang, nó praghas mar shlánuimhir nuair a bhí súil agat le snámhphointe. In ionad muinín a bheith agat as an aschur, cuimsigh an rochtain i bhfeidhmiú cúnta a dhéanann iarracht tiontú agus a úsáideann luach réamhshocraithe má theipeann air.
def safe_get_int(data: dict, key: str, default: int = 0) -> int:
"""Extract an integer, with conversion if needed."""
value = data.get(key)
if value is None:
return default
if isinstance(value, int):
return value
if isinstance(value, float):
return int(value)
if isinstance(value, str):
try:
return int(value)
except ValueError:
return default
return default
# Usage
age = safe_get_int(data, "age", default=0)
Is é an tríú ceann ná athainmniú eochracha. Le leid i bhFraincis, d’fhéadfadh an tsamhail phone a athrú go telephone go héasca, nó name go nom. Glacann mapáil comhchiallach leis na hathruithe seo gan a bheith ort an glao a athdhéanamh.
def normalize_keys(data: dict, key_mapping: dict) -> dict:
"""Normalize keys using a synonym mapping."""
normalized = {}
for standard_key, aliases in key_mapping.items():
for alias in aliases:
if alias in data:
normalized[standard_key] = data[alias]
break
return normalized
# Synonym mapping
mapping = {
"name": ["name", "nom", "full_name", "fullName"],
"email": ["email", "mail", "e-mail", "emailAddress"],
"phone": ["phone", "telephone", "tel", "phoneNumber"],
}
normalized = normalize_keys(raw_data, mapping)
Atriail le hAiseolas
Nuair a theipeann ar an mbailíochtú d’ainneoin do dhícheall, ní hé an freagra is fearr an glao céanna a athdhéanamh: is é an rud is fearr ná a chur in iúl don tsamhail cad a chuaigh mícheart. Trína fhreagra féin a bheathú ar ais isteach sa chomhrá in éineacht leis an teachtaireacht earráide, tugann tú an comhthéacs is gá di féin a cheartú, de ghnáth faoin dara hiarracht.
import json
def call_with_retry(client, messages, max_retries=3):
"""Call with retry and error feedback."""
for attempt in range(max_retries):
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
response_format={"type": "json_object"},
temperature=0
)
raw = response.choices[0].message.content
try:
data = json.loads(raw)
validate_schema(data) # Your validation function
return data
except (json.JSONDecodeError, ValueError) as e:
if attempt < max_retries - 1:
# Add error feedback to context
messages.append({"role": "assistant", "content": raw})
messages.append({
"role": "user",
"content": f"Your response is invalid: {e}. Correct it and return valid JSON."
})
else:
raise RuntimeError(f"Failed after {max_retries} attempts: {e}")
An Comhartha le Cur Chuige a Athrú
Má fhaigheann tú thú féin ag scríobh cód bailíochtaithe fairsing, is comhartha láidir é sin go bhfuil sé in am aistriú chuig Aschuir Struchtúrtha Saincheaptha. Deimhníonn trí thairseach tipiciúla é seo: thar chúig réimse le bailíochtú, bíonn an fheidhm rialaithe níos faide ná an glao féin; nuair a éiríonn cineálacha casta le liostanna neadaithe nó áireamhaithe, éiríonn bailíochtú láimhe doscartha ó na fabhtanna a thugann sé isteach; agus d’aon phíblíne táirgeachta chriticiúil, is sábháilte go mór srianta a tharmligean chuig an scéim ná iad a athchruthú de láimh.
Príomhphointí
- Ráthaíonn an Mód JSON go bhfuil JSON bailí ann, ní scéim bhailí
- Déan bailíochtú ar an aschur ar an gcliant i gcónaí: seiceáil eochracha riachtanacha, cineálacha cearta, agus luachanna laistigh de theorainneacha
- Seiceáil
finish_reasonchun freagraí gearrtha a bhrath - Cuir meicníocht atriail le haiseolas earráide i bhfeidhm
- Má éiríonn an bailíochtú casta, aistrigh chuig Aschuir Struchtúrtha Saincheaptha