એક સરળ કાર્ય જે ઘણા એપ્લિકેશન્સનો બેકબોન છે તે XML ફાઇલોને પાર્સ કરવાની ક્ષમતા છે. અને, સદભાગ્યે, Xcode ઉદ્દેશ C- માં એક XML ફાઇલ પાર્સ પ્રમાણમાં સરળ બનાવે છે
XML ફાઇલમાં તમારી એપ્લિકેશન વિશેની મૂળભૂત માહિતી વેબસાઇટ માટે આરએસએસ ફીડ પર હોઈ શકે છે . તેઓ તમારી એપ્લિકેશનની અંતર્ગત દૂરસ્થ માહિતીને અપડેટ કરવાની એક સરસ રીત પણ હોઈ શકે છે, આમ એપલને એક નવી બાઈનરી સબમિટ કરવાની જરૂરિયાતને ટાળીને ફક્ત સૂચિમાં એક નવી આઇટમ ઉમેરી શકે છે
તેથી અમે Xcode માં XML ફાઇલોને કેવી રીતે કાર્ય કરી શકીએ? આ પ્રક્રિયામાં XML પાર્સર પ્રક્રિયા શરૂ કરવા, ફાઇલની પ્રક્રિયાને ખવડાવવા, વ્યક્તિગત તત્વની શરૂઆત કરવા, તત્વની અંદર અક્ષરો (મૂલ્ય), ઉપયોગ કરવા માટેના ચલોને પ્રારંભ કરવા માટેનાં પગલાંઓ છે, વ્યક્તિગત ઘટકનો અંત અને પદચ્છેદન પ્રક્રિયા અંત.
આ ઉદાહરણમાં, અમે ઇન્ટરનેટ પરથી ફાઇલને વિશિષ્ટ વેબ સરનામું ( URL ) પાસ કરીને પદચ્છેદન કરીશું.
આપણે હેડર ફાઈલની રચના સાથે શરૂઆત કરીશું. આ અમારી ફાઇલનું વિશ્લેષણ કરવા માટેની લઘુત્તમ આવશ્યકતાઓ સાથે વિગતવાર દૃશ્ય કંટ્રોલર માટે ખૂબ જ મૂળભૂત હેડર ફાઇલનું એક ઉદાહરણ છે:
@ ઈન્ટરફેસ રુટવીવ કન્ટ્રોલર: UITableViewController {
વિગતવારવિજયંત્રણકર્તા * વિગતવારવિજયંત્રણકાર;
NSXMLParser * rssParser;
NSMutableArray * લેખો;
NSMutableDictionary * વસ્તુ;
NSString * વર્તમાન એલિમેન્ટ;
NSMutableString * ElementValue;
BOOL ભૂલ પાર્સીંગ;
}
@પ્રોપેર્ટી (નોનઆટોમિક, જાળવી) IBOutlet DetailViewController * વિગતવાર ViewController;
- (રદબાતલ) parseXMLFileAtURL: (NSString *) URL;
ParseXMLFileAtURL કાર્ય અમારા માટે પ્રક્રિયા શરૂ કરશે. જ્યારે તે સમાપ્ત થાય, ત્યારે NSMutableArray "લેખો" અમારા ડેટાને પકડી કરશે. એરે XML ફાઇલમાં ફિલ્ડ નામોથી સંબંધિત કીઓ સાથે પરિવર્તનક્ષમ શબ્દકોશો ધરાવે છે.
હવે અમે જરૂરી વેરિયેબલ્સ સેટ કર્યા છે, અમે .m ફાઈલમાં પ્રક્રિયાના મીટિંગ પર ખસેડીશું:
- (રદબાતલ) પાર્સર ડીડેસ્ટાર્ટ દસ્તાવેજ: (NSXMLParser *) પાર્સર {
એનએસલૉગ (@ "ફાઇલ મળી અને પર્સિંગ શરૂ થયું");
}
આ કાર્ય પ્રક્રિયાની શરૂઆતમાં ચાલે છે. આ કાર્યમાં કોઈ પણ વસ્તુ મૂકવાની કોઈ જરુર નથી, પરંતુ જો તમે કાર્ય કરવા માંગો છો જ્યારે ફાઇલને પદચ્છેદન શરૂ થાય છે, તો તે એ છે જ્યાં તમે તમારો કોડ મુકશો.
- (રદબાતલ) parseXMLFileAtURL: (NSString *) URL
{
NSString * agentString = @ "મોઝિલા / 5.0 (મેકિન્ટોશ; U; ઇન્ટેલ મેક ઓએસ એક્સ 10_5_6; en-us) એપલ વેબકિટ / 525.27.1 (કે.એમ.ટી.એમ.ટી., ગીકો જેવી) વર્ઝન / 3.2.1 સફારી / 525.27.1";
NSMutableURLRequest * વિનંતિ = [NSMutableURL વિનંતી વિનંતી સાથેઅથવા URL:
[NSURL URLWithString: URL]];
[વિનંતી કરો કિંમત: એજન્ટ સ્ટ્રિંગ ફોર એચટીટીપી હેડરફિલ્ડ: @ "યુઝર એજન્ટ"];
xmlFile = [NSURLConnection મોકલવા સિંક્રોનસઅરજ: વિનંતિ પરત કરવાની રીસપેન્સઃ શૂન્ય ભૂલ: નાઇલ];
લેખો [[NSMutableArray alloc] init];
ભૂલ પાર્સિંગ = ના;
rssParser = [[NSXMLParser alloc] initWithData: xmlFile];
[આરએસએસપીર્સ સેટ ડીઇલીએટ: સ્વ];
// તમે વિશ્લેષણ કરી રહ્યા છો તે XML ફાઇલના પ્રકારને આધારે તેમાંના કેટલાકને ચાલુ કરવાની જરૂર પડી શકે છે
[આરએસએસપીર્સર સેટહોલ્ડપ્રોસેસનમસ્પેસેસ: ના];
[આરએસએસપર્સર સેટશેલ્ડ રીપોર્ટનમસ્પેસપ્રિફેક્સ: ના];
[આરએસએસપર્સર સેટશેલ્ડ રીસ્લવેઇએનએન્ટેનિક ઍંટીટીસ: ના];
[આરએસએસપર્સર પાર્સ];
}
આ ફંક્શન એન્જિનને ચોક્કસ વેબ સરનામાં (URL) પર ફાઇલ ડાઉનલોડ કરવાની સૂચના આપે છે અને તેને પાર્સ કરવા માટેની પ્રક્રિયા શરૂ કરે છે.
અમે દૂરસ્થ સર્વરને કહીએ છીએ કે અમે મેક પર સફારી ચલાવીએ છીએ, જો કે તે કિસ્સામાં સર્વર iPhone / iPad ને મોબાઇલ સંસ્કરણ પર રીડાયરેક્ટ કરવાનો પ્રયાસ કરે છે.
અંતના વિકલ્પો ચોક્કસ XML ફાઇલો માટે વિશિષ્ટ છે મોટાભાગની આરએસએસ ફાઇલો અને જિનેરિક XML ફાઇલોને તેમને ચાલુ કરવાની જરૂર નહીં હોય.
- (રદબાતલ) પાર્સર: (NSXMLParser *) પાર્સર પર્સ એરેરક્રાઈડ: (NSError *) parseError {
NSString * errorString = [NSString stringWithFormat: @ "ભૂલ કોડ% i", [parseError કોડ]];
એનએસલોગ (@ "ભૂલ પદચ્છેદન XML:% @", ભૂલ સ્ટ્રિંગ);
ભૂલપત્રો = હા;
}
આ એક સરળ ભૂલ-ચકાસણી રાઉટીંગ છે જે બાઈનરી મૂલ્યને સેટ કરશે જો તેને કોઈ ભૂલ મળે. તમે શું કરી રહ્યા છો તેના આધારે તમારે અહીં વધુ ચોક્કસતાની જરૂર હોઈ શકે છે. જો તમને ભૂલના કિસ્સામાં પ્રોસેસ કર્યા પછી કેટલાક કોડ ચલાવવાની જરૂર હોય, તો તે સમયે ભૂલ પર્સિંગ બાઈનરી વેરીએબલને કહી શકાય.
- (રદબાતલ) પાર્સર: (NSXMLParser *) પાર્સર didStartElement: (NSString *) elementName namespaceURI: (NSString *) નેમસ્પેસયુઅર qualifiedName: (NSString *) qName એટ્રિબ્યુટ્સ: (NSDictionary *) attributeDict {
currentElement = [elementName કોપી];
એલિમેન્ટવલે = [[NSMutableString alloc] init];
જો ([ઘટક એવુ છે કે એક્લટૉસ્ટ્રિંગ: @ "આઈટમ"]) {
આઇટમ = [[NSMutableDictionary alloc] init];
}
}
XML પાર્સરનાં માંસમાં ત્રણ કાર્યોનો સમાવેશ થાય છે, જે વ્યક્તિગત તત્વની શરૂઆતમાં ચાલે છે, જે તત્વના વિશ્લેષણના મધ્યમાં ચાલે છે અને તત્વના અંતે ચાલે છે તે એક છે.
આ ઉદાહરણ માટે, અમે આરએસએસ ફાઇલોની જેમ જ ફાઇલને વિશ્લેષિત કરીશું જે XML ફાઇલમાં "આઇટમ્સ" ના શીર્ષક હેઠળ ઘટકોમાં વિભાજન કરે છે. પ્રોસેસિંગની શરૂઆતમાં, અમે તત્વ નામ "આઇટમ" માટે તપાસ કરી રહ્યાં છીએ અને જ્યારે નવા જૂથને શોધવામાં આવે ત્યારે અમારી આઇટમ શબ્દકોશની ફાળવણી કરવામાં આવે છે. નહિંતર, અમે વેલ્યુ માટે અમારા વેરીએબલ પ્રારંભ કરીશું.
- (રદબાતલ) પાર્સર: (NSXMLParser *) પાર્સર મળ્યુંછક્ષક: (NSString *) શબ્દમાળા {
[એલિમેન્ટવલે એપેન્ડ સ્ટ્રિંગ: સ્ટ્રિંગ];
}
આ સરળ ભાગ છે. જ્યારે આપણે અક્ષરો શોધીએ છીએ, ત્યારે આપણે તેમને ફક્ત "વેલ્યુએબલ વેલ્યુ" માં ઉમેરીએ છીએ.
- (રદબાતલ) પાર્સર: (એનએસએક્સએમએલપર્સર *) પાર્સર ઇડએલિમેન્ટ: (NSString *) elementName નામસ્થળઅરઆઇ: (NSString *) નામસ્થળ કુશળ નામને: (NSString *) qName {
જો ([ઘટક એવુ છે કે એક્લટૉસ્ટ્રિંગ: @ "આઈટમ"]) {
[લેખો addObject: [આઇટમ નકલ]];
} બીજું {
[વસ્તુ સેટ ઑબ્જેક્ટ: એલિમેન્ટવલે ફોર કી: elementName];
}
}
જ્યારે અમે એક તત્વની પ્રક્રિયા પૂર્ણ કરી લીધી હોય, ત્યારે અમને બે બાબતોમાંથી એક કરવાની જરૂર છે: (1) જો અંતિમ ઘટક એ "આઇટમ" છે, તો અમે અમારું જૂથ સમાપ્ત કર્યું છે, તેથી અમે અમારા શબ્દોની "એરે" ".
અથવા (2) જો તત્વ "આઇટમ" નથી, તો અમે અમારા શબ્દકોશમાં કી સેટ સાથે સેટ કરીશું જે તત્વના નામથી મેળ ખાય છે. (આનો અર્થ એ છે કે XML ફાઇલમાં દરેક ક્ષેત્રમાં આપણે એક વ્યક્તિગત વેરિઅરની જરૂર નથી.અમે તેને વધુ ગતિશીલ પ્રક્રિયા કરી શકીએ છીએ.)
- (રદબાતલ) પાર્સર ડીડેડ ડોક્યુમેન્ટ: (NSXMLParser *) પાર્સર {
જો (errorParsing == ના)
{
એનએસલૉગ (@ "XML પ્રક્રિયા થઈ!");
} બીજું {
NSLog (@ "XML પ્રોસેસિંગ દરમિયાન ભૂલ આવી છે");
}
}
આ અમારી પદચ્છેદનની નિયમિતતા માટે જરૂરી અંતિમ કાર્ય છે. તે ફક્ત દસ્તાવેજ સમાપ્ત કરે છે તમે કોઈ પણ કોડ મૂકીશું જે તમે પ્રક્રિયાને અહીં પૂર્ણ કરવા માગો છો અથવા ભૂલની બાબતમાં તમે જે કંઈ પણ કરવા માગો છો.
ઉપકરણ પર ફાઇલમાં ડેટા અને / અથવા XML ફાઇલને બચાવવા માટે ઘણી એપ્લિકેશન્સ અહીં કરવા માંગી શકે છે. આ રીતે, જો કોઈ વપરાશકર્તા આગામી વખતે જ્યારે તેઓ એપ્લિકેશન લોડ કરે છે ત્યારે ઇન્ટરનેટથી કનેક્ટ ન હોય, તો પણ તેઓ આ માહિતી મેળવી શકે છે.
અલબત્ત, અમે સૌથી મહત્વપૂર્ણ ભાગને ભૂલી શકતા નથી: ફાઇલને પાર્સ કરવા માટે તમારી એપ્લિકેશનને કહેવાની (અને તેને શોધવા માટે વેબ સરનામું આપવું!).
પ્રક્રિયા શરૂ કરવા માટે, તમારે ફક્ત આ વાક્ય કોડને યોગ્ય સ્થાન પર ઉમેરવાની જરૂર છે જ્યાં તમે XML પ્રોસેસિંગ કરવા માંગો છો:
[સ્વયં parseXMLFileAtURL: @ "http://www.webaddress.com/file.xml"];