¿Alguna buena biblioteca para analizar JSON en ASP clásico? [cerrado]

He podido encontrar un trillón de bibliotecas para generar JSON en ASP clásico (VBScript) pero no he encontrado NINGUNA para analizar .

Quiero algo que pueda pasar una cadena JSON y recuperar un objeto VBScript de algún tipo (Array, Scripting.Dictionary, etc.)

¿Alguien puede recomendar una biblioteca para analizar JSON en ASP clásico?

Tenga en cuenta que Classic ASP incluye tanto JScript como VBScript. Curiosamente, puede analizar JSON usando JScript y usar los objetos resultantes directamente en VBScript.

Por lo tanto, es posible utilizar el https://github.com/douglascrockford/JSON-js/blob/master/json2.js canónico en el código del lado del servidor sin modificaciones.

Por supuesto, si su JSON incluye matrices, estas seguirán siendo matrices JScript cuando se complete el análisis. Puede acceder al contenido de la matriz JScript desde VBScript utilizando notación de puntos.

<%@Language="VBScript" %>
<%
Option Explicit
%>

<script language="JScript" runat="server" src='path/to/json2.js'></script>

<%

Dim myJSON
myJSON = Request.Form("myJSON") // "[ 1, 2, 3 ]"
Set myJSON = JSON.parse(myJSON) // [1,2,3]
Response.Write(myJSON)          // 1,2,3
Response.Write(myJSON.[0])      // 1
Response.Write(myJSON.[1])      // 2
Response.Write(myJSON.[2])      // 3
%>

No estoy seguro de eso. ¿Ha comprobado el marco extremo ASP que tiene soporte JSON?

No pude conseguir que la evolución extrema o la sugerencia de Chris Nielson funcionaran. Pero, lo siguiente funcionó para mí:

http://tforster.wik.is/ASP_Classic_Practices_For_The_21st_Century/JSON4ASP

Descargue lo siguiente como "json2.min.asp"

http://tforster.wik.is/@api/deki/files/2/=json2.min.asp

Agregue la siguiente línea en la parte superior de su archivo ASP:

<script language="javascript" runat="server" src="json2.min.asp"></script>

Luego puede usar JSON en ASP.

   Dim car: Set car = JSON.parse("{""brand"":""subaru"",""model"":""outback sport"",""year"":2003," & _
                                 """colour"":""green"",""accessories"":[" & _
                                 "{""foglamps"":true},{""abs"":true},{""heatedSeats"":true}]}")

   Response.Write("brand: " & car.brand & "<br/>")                               
   Response.Write("model: " & car.model & "<br/>")                               
   Response.Write("colour: " & car.colour & "<br/>")                               
   Response.Write("has foglamps: " & CStr(car.accessories.get(0).foglamps) & "<br/>")                               

   car.accessories.get(0).foglamps = false
   Response.Write("has foglamps: " & CStr(car.accessories.get(0).foglamps) & "<br/>")                               
   Response.Write("new Json: " & JSON.stringify(car) & "<br/>")

   Set car = Nothing

Nota: Para analizar una variedad de elementos, debe hacer lo siguiente:

   for each iTmp in testing
       if (TypeName(iTmp))<>"JScriptTypeInfo" then 
           Response.Write("Item: " &  iTmp & "<br/>")
       end if
   next

Recientemente implementé una clase VbsJson , que tiene un método " Decode " para analizar JSON a VBScript y un método " Encode " para generar JSON a partir de VBScript. El código es algo largo, así que no lo pego aquí.

Escribí esta respuesta cuando estaba buscando una solución única de VBScript pura y liviana.

Al armar un convertidor rudimentario de JSON a XML, podemos recorrer la cadena JSON y convertirla en un documento Microsoft.XMLDOM.

A partir de ahí, usamos la API XML de Microsoft, incluidas las consultas XPath, para extraer los valores que deseamos.

Esto maneja JSON simple, pero nunca pretendí esta respuesta para algo más sofisticado.

Para una solución más robusta, el mejor intérprete de JSON es un motor Javascript adecuado. Por lo tanto, recomiendo encarecidamente la respuesta aceptada a esta pregunta, es decir, ¿ alguna buena biblioteca para analizar JSON en ASP clásico?

Function JSONtoXML(jsonText)
  Dim idx, max, ch, mode, xmldom, xmlelem, xmlchild, name, value

  Set xmldom = CreateObject("Microsoft.XMLDOM")
  xmldom.loadXML "<xml/>"
  Set xmlelem = xmldom.documentElement

  max = Len(jsonText)
  mode = 0
  name = ""
  value = ""
  While idx < max
    idx = idx + 1
    ch = Mid(jsonText, idx, 1)
    Select Case mode
    Case 0 ' Wait for Tag Root
      Select Case ch
      Case "{"
        mode = 1
      End Select
    Case 1 ' Wait for Attribute/Tag Name
      Select Case ch
      Case """"
        name = ""
        mode = 2
      Case "{"
        Set xmlchild = xmldom.createElement("tag")
        xmlelem.appendChild xmlchild
        xmlelem.appendchild xmldom.createTextNode(vbCrLf)
        xmlelem.insertBefore xmldom.createTextNode(vbCrLf), xmlchild
        Set xmlelem = xmlchild
      Case "["
        Set xmlchild = xmldom.createElement("tag")
        xmlelem.appendChild xmlchild
        xmlelem.appendchild xmldom.createTextNode(vbCrLf)
        xmlelem.insertBefore xmldom.createTextNode(vbCrLf), xmlchild
        Set xmlelem = xmlchild
      Case "}"
        Set xmlelem = xmlelem.parentNode
      Case "]"
        Set xmlelem = xmlelem.parentNode
      End Select
    Case 2 ' Get Attribute/Tag Name
      Select Case ch
      Case """"
        mode = 3
      Case Else
        name = name + ch
      End Select
    Case 3 ' Wait for colon
      Select Case ch
      Case ":"
        mode = 4
      End Select
    Case 4 ' Wait for Attribute value or Tag contents
      Select Case ch
      Case "["
        Set xmlchild = xmldom.createElement(name)
        xmlelem.appendChild xmlchild
        xmlelem.appendchild xmldom.createTextNode(vbCrLf)
        xmlelem.insertBefore xmldom.createTextNode(vbCrLf), xmlchild
        Set xmlelem = xmlchild
        name = ""
        mode = 1
      Case "{"
        Set xmlchild = xmldom.createElement(name)
        xmlelem.appendChild xmlchild
        xmlelem.appendchild xmldom.createTextNode(vbCrLf)
        xmlelem.insertBefore xmldom.createTextNode(vbCrLf), xmlchild
        Set xmlelem = xmlchild
        name = ""
        mode = 1
      Case """"
        value = ""
        mode = 5
      Case " "
      Case Chr(9)
      Case Chr(10)
      Case Chr(13)
      Case Else
        value = ch
        mode = 7
      End Select
    Case 5
      Select Case ch
      Case """"
        xmlelem.setAttribute name, value
        mode = 1
      Case "\"
        mode = 6
      Case Else
        value = value + ch
      End Select
    Case 6
      value = value + ch
      mode = 5
    Case 7
      If Instr("}], " & Chr(9) & vbCr & vbLf, ch) = 0 Then
        value = value + ch
      Else
        xmlelem.setAttribute name, value
        mode = 1
        Select Case ch
        Case "}"
          Set xmlelem = xmlelem.parentNode
        Case "]"
          Set xmlelem = xmlelem.parentNode
        End Select
      End If
    End Select
  Wend

  Set JSONtoXML = xmlDom
End Function

El script anterior, transforma el siguiente JSON:

{
  "owningSystemUrl": "http://www.arcgis.com",
  "authInfo": {
    "tokenServicesUrl": "https://www.arcgis.com/sharing/rest/generateToken",
    "isTokenBasedSecurity": true
  }
}

dentro:

<xml owningSystemUrl="http://www.arcgis.com">
    <authInfo
        tokenServicesUrl="https://www.arcgis.com/sharing/rest/generateToken"
        isTokenBasedSecurity="true" >
    </authInfo>
</xml>

Ahora podemos usar XPath para extraer tokenServicesUrl, por ejemplo:

dom.SelectSingleNode("xml/authInfo").getAttribute("tokenServicesUrl")
' Returns: "https://www.arcgis.com/sharing/rest/generateToken"

http://github.com/nagaozen/asp-xtreme-evolution/

AX es una gran biblioteca, pero es bastante pesada si solo necesita la funcionalidad de procesamiento JSON.

Sin embargo, tomé el archivo base.asp y el archivo de clase json.asp del proyecto AX y los usé con éxito para implementar el análisis JSON en mi proyecto.

Para la generación JSON, encontré que aspjson era más simple de integrar. También tiene funciones relacionadas con json más potentes. La documentación del hacha es un poco escasa y fue más trabajo integrarla en el proyecto, sin embargo, hace un buen trabajo al serializar su objeto JSON VB de nuevo en una cadena.

las soluciones aquí son muy buenas pero a veces exageradas. Si el JSON es simple y siempre tiene la misma estructura, puede analizarlo usted mismo, es rápido y simple.

 'read data from client
 records = Request.Form("records")
 'convert the JSON string to an array
 Set oRegExpre = new RegExp
 oRegExpre.Global = true
 oRegExpre.Pattern = "[\[\]\{\}""]+"
 records = replace(records, "},{","||")
 records = oRegExpre.Replace(records, "" )
 aRecords = split(records,"||")
 'iterate the array and do some cleanup
 for each rec in aRecords
   aRecord = split(rec,",")
   id          = split(aRecord(1),":")(1)
   field       = split(aRecord(0),":")(0)
   updateValue = split(aRecord(0),":")(1)
   updateValue = replace(updateValue,chr(10),"\n")
   updateValue = replace(updateValue,chr(13),"\r")
   updateValue = replace(updateValue,"'","''")
  'etc
next