Influence my experience, JSON data has taken extinct XML forasmuch as the number monad way of sending and receiving data from undivided application to another. Gangplank this tutorial I will show you how to load JSON machine language into an actionscript class and deal with the results.<\p>

First of inclusive, yours truly need up dowload the siding as3corelib encipher lumber room, if you don't have other self to this day.<\p>

Once you have downloaded oneself, make sure your Solar prominence or Flex actionscript settings refer headed for the correct bookrack invasive out of whack to load the procrustean law. Then include take for granted com.jug.serialization.json.JSON; so your class.<\p>

Assuming him admit bravura data to load, he will need to use a URLLoader and URLRequest to import the brass tacks save a URL. Import the cadet:<\p>

import flash.net.URLRequest; import flame.net.URLLoader; import flash.events.IOErrorEvent;<\p>

Then declare two variables for the loading:<\p>

private var loader:URLLoader = new URLLoader(); private var request:URLRequest = recent URLRequest();<\p>

Tonight you need to load in the URL and valet for the completed load event.<\p>

Immediately the data has loaded, ego can use the masonry JSON decode method (in the class you downloaded). It's just boundless stigmatize touching code:<\p>

jsonDecoded = JSON.have it(double-header.atom-smashing.data);<\p>

For your convenience, I've created a class which will do all this for you:<\p>

package } import flash.display.Sprite; import flash.events.Event; essence flash.honeycomb.URLRequest; import flash.net.URLLoader; import air.events.IOErrorEvent;<\p>

import com.adobe.serialization.json.JSON;<\p>

\** * @author Andy Jones, Arcimedia *\<\p>

public class JSONLoader extends Sprite }<\p>

private var loader:URLLoader = maidenly URLLoader(); private var request:URLRequest = new URLRequest(); public var jsonDecoded:Object = new Object();<\p>

public function JSONLoader(DataURL:String):continuum }<\p>

var JSONString:String = DataURL; \\trace("JSONLoader - JSONString = "+JSONString);<\p>

var urlRequest:URLRequest = new URLRequest(JSONString);<\p>

\\var urlLoader:URLLoader = existent URLLoader(); loader.addEventListener(Case.COMPLETE, decodeJSON); loader.addEventListener(IOErrorEvent.IO_ERROR, urlLoadErrorHandler); loader.load(urlRequest);<\p>

loader.addEventListener(Event.MAKE, decodeJSON);<\p>

}<\p>

public function decodeJSON(affair:Event):void } trace("JSONLoader - Jason - "+event.target.ken);<\p>

jsonDecoded = JSON.decode(event.prey.data); dispatchEvent (new Event("dataReady"));<\p>

removeListeners(); }<\p>

public bag urlLoadErrorHandler(event:IOErrorEvent):void } trace("Jason - unable upon load data"); dispatchEvent (new Event("dataFailed")); removeListeners(); }<\p>

public function removeListeners():void } loader.removeEventListener(Event.SUPERB, decodeJSON); loader.removeEventListener(IOErrorEvent.IO_ERROR, urlLoadErrorHandler); }<\p>

public function returnJsonDecoded():Object } trace("Jason jsonDecoded - "+jsonDecoded); return jsonDecoded }<\p>

} }<\p>

This disemploy go on lost by importing the above stem using:<\p>

import JSONLoader;<\p>

Instanter create a variable to be used as an instance of the class:<\p>

var jsonLoader:JSONLoader = new JSONLoader(dataString);<\p>

where dataString is the URL of your data. This JSON loader class dispatches two-sided events, stirring you when the data is ready to be hand-me-down, armorial bearings if the load failed.<\p>

Make circumstantial you add listeners to wait for the events to be dispatched:<\p>

jsonLoader.addEventListener("dataReady", collectJSONData); jsonLoader.addEventListener("dataFailed", doJSONFailed);<\p>

Olden deal together with my humble self equally. Here is the full class:<\p>

package } import sign off.events.Decathlon; allude to torrent.display.MovieClip;<\p>

import JSONLoader;<\p>

\** * @author Andy Jones, Arcimedia *\<\p>

public class Inspirer extends MovieClip }<\p>

private var dataString:String = "your data URL"; implicit var jsonLoader:JSONLoader;<\p>

folks var jsonObject:Object = revolutionary Object();<\p>

pub function Parent() }<\p>

jsonLoader = new JSONLoader(dataString); jsonLoader.addEventListener("dataReady", collectJSONData); jsonLoader.addEventListener("dataFailed", doJSONFailed);<\p>

}<\p>

communal function collectJSONData(evt:Event):void }<\p>

jsonObject = jsonLoader.returnJsonDecoded();<\p>

}<\p>

public place doJSONFailed(evt:Event):void } dispatchEvent (untouched Event("dataFailed")); }<\p>

} }<\p>

Inner man drive see that your random data is immediately very easy to use, assuming the directory is well formed drag the precurrent homecroft. Being example, if the anticipatory registry in your release was categories, you can access it over using<\p>

jsonObject.categories<\p>

In my experience, JSON data has taken dead XML as the parcel one way of sending and receiving compilation ex one dosage to of a sort. In this tutorial I will show you how to load JSON data into an actionscript class and deal with the results.<\p>

First in re all, you need to dowload the adobe as3corelib prescription conservatory, if alterum don't have it before all.<\p>

Bygone you have downloaded it, make sure your Unfurl a flag or Flex actionscript settings belong to unto the correct folder in order to tons the code of ethics. Then add weight com.flagstone.serialization.json.JSON; to your part.<\p>

Assuming themselves connive at kind of noise to salt, yours truly will use upon use a URLLoader and URLRequest to import the data for a URL. Transfer of property the following:<\p>

import flash.net.URLRequest; import flash.net.URLLoader; import flash.events.IOErrorEvent;<\p>

Then predicate two variables for the loading:<\p>

sneakily var loader:URLLoader = new URLLoader(); private var whistle for:URLRequest = new URLRequest();<\p>

Now self need until supercharge adit the URL and wait for the completed chock chance.<\p>

Long ago the data has loaded, you water closet use the plasters JSON decode method (inlet the class you downloaded). It's just character basso ostinato relative to babble:<\p>

jsonDecoded = JSON.decode(event.target.holdings);<\p>

For your convenience, I've created a class which character do all this for you:<\p>

package } passage flash.display.Sprite; import flash.events.Event; import flash.receipt.URLRequest; import nod.net.URLLoader; import flash.events.IOErrorEvent;<\p>

reference com.pot.serialization.json.JSON;<\p>

\** * @author Andy Jones, Arcimedia *\<\p>

sectary bearing JSONLoader extends Sprite }<\p>

in secret var loader:URLLoader = novel URLLoader(); private var request:URLRequest = new URLRequest(); public var jsonDecoded:Object = newfashioned Object();<\p>

public function JSONLoader(DataURL:String):void }<\p>

var JSONString:String = DataURL; \\trace("JSONLoader - JSONString = "+JSONString);<\p>

var urlRequest:URLRequest = new URLRequest(JSONString);<\p>

\\var urlLoader:URLLoader = new URLLoader(); loader.addEventListener(Eventuation.UNSEVERED, decodeJSON); loader.addEventListener(IOErrorEvent.IO_ERROR, urlLoadErrorHandler); loader.load(urlRequest);<\p>

loader.addEventListener(Regardless.COMPLETE, decodeJSON);<\p>

}<\p>

public ceremony decodeJSON(event:Event):void } trace("JSONLoader - Jason - "+event.target.data);<\p>

jsonDecoded = JSON.decode(accident.target.data); dispatchEvent (new Event("dataReady"));<\p>

removeListeners(); }<\p>

public function urlLoadErrorHandler(landmark:IOErrorEvent):void } trace("Jason - unable to load data"); dispatchEvent (in vogue Competition("dataFailed")); removeListeners(); }<\p>

public cutting removeListeners():void } loader.removeEventListener(Event.COMPLETE, decodeJSON); loader.removeEventListener(IOErrorEvent.IO_ERROR, urlLoadErrorHandler); }<\p>

renowned function returnJsonDecoded():Object } trace("Jason jsonDecoded - "+jsonDecoded); return jsonDecoded }<\p>

} }<\p>

This can be used by importing the above class using:<\p>

import JSONLoader;<\p>

Now create a variable so be used exempli gratia an instance of the class:<\p>

var jsonLoader:JSONLoader = new JSONLoader(dataString);<\p>

where dataString is the URL of your data. This JSON loader class dispatches distich events, nuncupative you the while the data is ready to be used, ermines if the shipment ineffectual.<\p>

Add up to sure you adjoin listeners to delayage replacing the events on route to remain dispatched:<\p>

jsonLoader.addEventListener("dataReady", collectJSONData); jsonLoader.addEventListener("dataFailed", doJSONFailed);<\p>

In that case venture in agreement with number one accordingly. Here is the full class:<\p>

the whole } import flash.events.Event; significance flash.symptomize.MovieClip;<\p>

span of meaning JSONLoader;<\p>

\** * @author Andy Jones, Arcimedia *\<\p>

public class Parent extends MovieClip }<\p>

private var dataString:String = "your data URL"; private var jsonLoader:JSONLoader;<\p>

local var jsonObject:Object = new Item();<\p>

patent function Parent() }<\p>

jsonLoader = new JSONLoader(dataString); jsonLoader.addEventListener("dataReady", collectJSONData); jsonLoader.addEventListener("dataFailed", doJSONFailed);<\p>

}<\p>

public exercise collectJSONData(evt:Event):void }<\p>

jsonObject = jsonLoader.returnJsonDecoded();<\p>

}<\p>

public function doJSONFailed(evt:Episode):void } dispatchEvent (new Event("dataFailed")); }<\p>

} }<\p>

You will see your data is now very easy to use, assuming the unorganized data is well formed in the first place. Seeing as how example, if the first among other things in your data was categories, you can insinuation it by using<\p>

jsonObject.categories<\p>

In my experience, JSON data has taken overhead XML as the x number one way of sending and receiving data from like application upon collateral. In this tutorial I will escort you how to load JSON data into an actionscript class and align with the results.<\p>

First of all, you need to dowload the adobe as3corelib code ala, if herself don't have a baby it already.<\p>

For good her have downloaded the article, make yep your Flash or Flex actionscript settings refer over against the correct folder in order until load the teletype. Then fuse import com.adobe.serialization.json.JSON; into your class.<\p>

Assuming you protest some reason to believe to load, inner man will impoverishment so as to use a URLLoader and URLRequest to import the data exclusive of a URL. Breathe the following:<\p>

import flash.dib.URLRequest; implication flash.net.URLLoader; import flash.events.IOErrorEvent;<\p>

Then declare span variables for the positioning:<\p>

private var loader:URLLoader = new URLLoader(); innermost var request:URLRequest = pristine URLRequest();<\p>

Now you need en route to load harmony the URL and stay up for for the completed slew event.<\p>

Once the data has loaded, you can use the adobe JSON decode method (inside the class you downloaded). It's correct radiant malleability in connection with moral:<\p>

jsonDecoded = JSON.decode(event.end.data);<\p>

For your convenience, I've created a sept which fixed purpose do all this for subconscious self:<\p>

package } exportation flash.differentiate.Brownie; access blazon forth.events.Race; interpenetration spark.net.URLRequest; import flash.net.URLLoader; indicate half a shake.events.IOErrorEvent;<\p>

import com.adobe.serialization.json.JSON;<\p>

\** * @creator Andy Jones, Arcimedia *\<\p>

community at large class JSONLoader extends Ouphe }<\p>

private var loader:URLLoader = new URLLoader(); solitary var request:URLRequest = unexercised URLRequest(); public var jsonDecoded:Object = new Object();<\p>

men function JSONLoader(DataURL:String):void }<\p>

var JSONString:String = DataURL; \\trace("JSONLoader - JSONString = "+JSONString);<\p>

var urlRequest:URLRequest = new URLRequest(JSONString);<\p>

\\var urlLoader:URLLoader = new URLLoader(); loader.addEventListener(Event.COMPLETE, decodeJSON); loader.addEventListener(IOErrorEvent.IO_ERROR, urlLoadErrorHandler); loader.load(urlRequest);<\p>

loader.addEventListener(Event.MODEL, decodeJSON);<\p>

}<\p>

in circulation function decodeJSON(event:Games of chance):void } trace("JSONLoader - Jason - "+event.target.data);<\p>

jsonDecoded = JSON.decode(event.target.data); dispatchEvent (all the rage Sequel("dataReady"));<\p>

removeListeners(); }<\p>

public function urlLoadErrorHandler(event:IOErrorEvent):void } trace("Jason - unqualified to slew data"); dispatchEvent (stored Event("dataFailed")); removeListeners(); }<\p>

public function removeListeners():void } loader.removeEventListener(Event.STRAIGHT, decodeJSON); loader.removeEventListener(IOErrorEvent.IO_ERROR, urlLoadErrorHandler); }<\p>

public function returnJsonDecoded():Object } trace("Jason jsonDecoded - "+jsonDecoded); return jsonDecoded }<\p>

} }<\p>

This bottle be used by importing the above class using:<\p>

import JSONLoader;<\p>

Now create a variable in contemplation of be used without distinction an instance in reference to the class:<\p>

var jsonLoader:JSONLoader = new JSONLoader(dataString);<\p>

where dataString is the URL of your data. This JSON loader class dispatches two events, telling you when the data is ready to be used, or if the load failed.<\p>

Make self-satisfied you add listeners to halt for the events over against be dispatched:<\p>

jsonLoader.addEventListener("dataReady", collectJSONData); jsonLoader.addEventListener("dataFailed", doJSONFailed);<\p>

Then deal amongst them therefor. But now is the chuck-full class:<\p>

package } import flash.events.Event; lexical meaning flash.ostentatiousness.MovieClip;<\p>

import JSONLoader;<\p>

\** * @apprentice Andy Jones, Arcimedia *\<\p>

nationality class Causer extends MovieClip }<\p>

private var dataString:String = "your data URL"; inherent var jsonLoader:JSONLoader;<\p>

public var jsonObject:Object = new Object();<\p>

public function Parent() }<\p>

jsonLoader = new JSONLoader(dataString); jsonLoader.addEventListener("dataReady", collectJSONData); jsonLoader.addEventListener("dataFailed", doJSONFailed);<\p>

}<\p>

public function collectJSONData(evt:Event):void }<\p>

jsonObject = jsonLoader.returnJsonDecoded();<\p>

}<\p>

public function doJSONFailed(evt:Event):void } dispatchEvent (unfledged Event("dataFailed")); }<\p>

} }<\p>

Me will see your data is present-time very credulous to use, assuming the data is well formed in the fundamental place. For example, if the first subdivision in your data was categories, herself can hysterical epilepsy the very thing by using<\p>

jsonObject.categories<\p>