Gibt es gute Bibliotheken zum Parsen von JSON in Classic ASP? [geschlossen]

Ich konnte zig Bibliotheken zum Generieren von JSON in Classic ASP (VBScript) finden, aber ich habe KEINE zum Parsen gefunden .

Ich möchte etwas, mit dem ich eine JSON-Zeichenfolge übergeben und ein VBScript-Objekt (Array, Scripting.Dictionary usw.) zurückerhalten kann.

Kann jemand eine Bibliothek zum Parsen von JSON in Classic ASP empfehlen?

Beachten Sie, dass Classic ASP sowohl JScript als auch VBScript enthält. Interessanterweise können Sie JSON mit JScript analysieren und die resultierenden Objekte direkt in VBScript verwenden.

Daher ist es möglich, das kanonische https://github.com/douglascrockford/JSON-js/blob/master/json2.js in serverseitigem Code ohne Änderungen zu verwenden.

Wenn Ihr JSON Arrays enthält, bleiben diese natürlich JScript-Arrays, wenn die Analyse abgeschlossen ist. Sie können über VBScript mit der Punktnotation auf den Inhalt des JScript-Arrays zugreifen.

<%@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
%>

Ich bin mir nicht sicher. Haben Sie das ASP Extreme Framework überprüft, das JSON unterstützt?

Ich konnte die extreme Entwicklung oder Chris Nielsons Vorschlag, zu arbeiten, nicht verstehen. Aber das Folgende hat bei mir funktioniert:

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

Laden Sie Folgendes als "json2.min.asp" herunter

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

Fügen Sie die folgende Zeile oben in Ihre ASP-Datei ein:

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

Sie können dann JSON in ASP verwenden.

   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

Hinweis: Um eine Reihe von Elementen zu analysieren, müssen Sie folgende Schritte ausführen:

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

Ich habe kürzlich eine VbsJson- Klasse implementiert , die eine " Decode " -Methode zum Parsen von JSON in VBScript und eine " Encode " -Methode zum Generieren von JSON aus VBScript enthält. Der Code ist etwas lang, deshalb füge ich ihn hier nicht ein.

Ich habe diese Antwort geschrieben, als ich nach einer leichten reinen VBScript-Lösung suchte.

Durch Zusammenstellen eines rudimentären JSON-XML-Konverters können wir die JSON-Zeichenfolge durchlaufen und in ein Microsoft.XMLDOM-Dokument umwandeln.

Von dort aus verwenden wir die XML-API von Microsoft, einschließlich XPath-Abfragen, um alle gewünschten Werte zu ermitteln.

Dies behandelt einfaches JSON, aber ich habe diese Antwort nie für etwas Anspruchsvolleres gedacht.

Für eine robustere Lösung ist der beste JSON-Interpreter eine richtige Javascript-Engine. Daher empfehle ich die akzeptierte Antwort auf diese Frage, dh Gibt es gute Bibliotheken zum Parsen von JSON in Classic ASP?

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

Das obige Skript transformiert den folgenden JSON:

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

in:

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

Wir können jetzt XPath verwenden, um Folgendes zu extrahieren tokenServicesUrl:

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

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

AX ist eine großartige Bibliothek, aber ziemlich umfangreich, wenn Sie nur JSON-Verarbeitungsfunktionen benötigen.

Ich habe jedoch die Datei base.asp und die Klassendatei json.asp aus dem AX-Projekt abgerufen und sie erfolgreich verwendet, um die JSON-Analyse in meinem Projekt zu implementieren.

Für die JSON-Generierung war Aspjson einfacher zu integrieren. Es hat auch leistungsfähigere json-bezogene Funktionen. Die Axtdokumentation fehlte ein wenig und es war mehr Arbeit, sie in das Projekt zu integrieren. Sie kann jedoch das JSON VB-Objekt problemlos wieder in eine Zeichenfolge serialisieren.

Die Lösungen hier sind sehr gut, aber manchmal übertrieben. Wenn der JSON einfach ist und immer dieselbe Struktur aufweist, die Sie selbst analysieren können, ist er schnell und einfach.

 '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