Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Teorainneacha an Mhóid JSON agus Bainistiú Earráidí

Ceacht 6 as 12 Nuashonraithe 29 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Ní Ciallaíonn “Bailí” go bhfuil sé “Ceart”
  2. Gan Ráthaíochtaí Scéime
  3. Bailíochtú Éigeantach ar an gCliant
  4. Trí Theip a Bhuailfidh Leat
  5. Atriail le hAiseolas
  6. An Comhartha le Cur Chuige a Athrú
  7. Príomhphointí

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_reason chun 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