Hur man skapar XML-fil Delphi. Internetreseguide - allt det roliga på nätet
Välkommen! Den här bloggen handlar om Internet och datorer, eller snarare tillägnad den.
Förmodligen är det omedelbart klart att inga nya artiklar har dykt upp på webbplatsen på många år. Ja, det är ödet för de flesta bloggar. Detta projekt var en gång ett ambitiöst företag och författaren hade, precis som många andra som skrev på den tiden, ambitiösa planer på att bli en av de bästa ryska bloggarna. Tja, om du tittar nu, av de bloggar som skapades samtidigt som mina, har de flesta redan försvunnit i evigheten. Och jag hade bara inte tillräckligt med tid att blogga. Så ja, det uppdateras inte längre. Även om vi med den här webbplatsen en gång vann tävlingen "Blog of Runet 2011".
Jag hade till och med en idé att ta bort allt detta, men sedan granskade jag det gamla materialet och insåg att det fortfarande kan vara användbart för läsarna. Ja, vissa artiklar är föråldrade (om jag har tillräckligt med styrka får de lämpliga anteckningar), men webbplatsen kan till exempel vara användbar för nybörjare - här kan du läsa om grundläggande koncept Internet, lär dig hur du konfigurerar Internet, Windows eller till och med bestämmer dig för att byta till Linux. Så titta på rubrikerna och välj den som passar dig.
Och ändå hoppas jag att det här är mer än bara en blogg, utan en riktig guide till Internet. Webbplatsen kan visas i katalogläget, där alla tillgängliga artiklar är strukturerade efter kategori. Och vem vet, kanske en dag kommer nya högkvalitativa artiklar att dyka upp här.
Sander
Picodi.ru är en rabattportal från International Coupons, en polsk expert inom sparande och billig shopping. Polacker anses vara en av de mest ekonomiska nationerna i världen, så det är inte förvånande att denna typ av projekt växte fram ur den polska startkoden kodyrabatowe.pl. Hur kan denna portal vara användbar för en vanlig Internetanvändare i Ryssland?
Moderna Android-telefoner är mer än telefoner. Du blir van vid att skriva installerade program, till din samtals- och sms-historik, fotosamling och mycket mer. Men tiden går och enheten som passar dig börjar sakta ner, glida eller helt enkelt förlora sitt presentabla utseende på grund av chips på fodralet eller repor på skärmen. Frågan uppstår att välja en ny telefon och byta android telefon... Och om vi nu kringgår frågan om val, så "flytta" till ny telefon är fortfarande ett allvarligt problem - du vill absolut inte starta all data från grunden. Det här är vad vi ska prata om idag.
De flesta av läsarna på den här bloggen har troligen aldrig stött på versionskontrollsystem och kommer inte att stöta på några inom en snar framtid. Det är synd. Denna extremt praktiska uppfinning används ofta av programmerare, men enligt min mening kan den vara mycket användbar för dem som aktivt arbetar med texter. Men förmodligen finns det nu inte ett enda versionskontrollsystem som skulle vara lätt att börja använda för "kontoret" ( Microsoft Office) arbete. Ändå tror jag att materialet som presenteras i artikeln kan vara intressant för alla läsare.
Om du har funderat på hur du kan titta på filmer i nätverket från din TV och gå online är den här artikeln något för dig. Nej, jag vet att vissa TV-apparater redan har Smart TV-funktionalitet, men jag har aldrig sett det fungera ordentligt. Tydligen visade därför Google-företaget nyligen en helt fantastisk enhet, som omedelbart blev en sensation. Vi pratar om Chromecast media streamer (Chromecast), en mer avancerad och prisvärd version av förra årets katastrofala Nexus Q.
Dongle Chromkast, som inte överstiger 2 tum, ansluts till porten HDMI-TV och låter dig titta på strömmande webbinnehåll. För att styra streamern kan du använda vilken enhet som helst (surfplatta, PC, smartphone) baserat på operativplattformen iOS, Windows, Android eller Mac OS.
Den här artikeln handlar om enhetssystemet minne android, problem som kan uppstå på grund av dess brist och sätt att lösa dem. Jag själv kom nyligen över det faktum att min Android-telefon började regelbundet ge ut meddelanden om otillräckligt minne när jag försökte installera en applikation. Vilket var väldigt konstigt för mig, med tanke på att enligt beskrivningen på marknaden borde det ha varit cirka 16 GB, och jag ökade också volymen med ett extra minneskort. Det var dock ett problem, och jag var tvungen att tippa mycket innan jag hittade rätt lösning, som inte krävde root-åtkomst eller full återhämtning telefonen tillbaka till fabrikstillståndet.
XML används alltmer för att lagra information och utbyta mellan applikationer och webbplatser. Många applikationer använder detta språk som basspråk för lagring av data, medan andra använder det för att exportera och importera XML-data. Så det är dags för utvecklare att börja tänka på hur XML-data kan användas i sina egna applikationer.
I den här artikeln tittar vi på XML-dokument Objektmodell (DOM) och dess implementering av Microsoft - Microsoft XML DOM.
XML DOM är en objektmodell som ger utvecklaren objekt för att ladda och bearbeta XML-filer. Objektmodell består av följande kärnobjekt: XMLDOMDocument, XMLDOMNodeList, XMLDOMNode, XMLDOMNamedNodeMap och XMLDOMParseError. Var och en av dessa objekt (förutom XMLDOMParseError) innehåller egenskaper och metoder som låter dig få information om objektet, manipulera objektets värden och struktur och navigera i strukturen i ett XML-dokument.
Låt oss titta på de viktigaste XML DOM-objekten och visa några exempel på deras användning i Borland Delphi.
Använda XML DOM i Borland Delphi
För att kunna använda Microsoft XML DOM i Delphi-applikationer måste du ansluta lämpligt typbibliotek till projektet. För att göra detta kör vi kommandot Project | Importera typbibliotek och i dialogrutan Importera typbibliotek väljer du Microsoft XML version 2.0 (version 2.0) -biblioteket, som vanligtvis finns i Windows \\ System \\ MSXML.DLL-filen
Efter att ha klickat på knappen Skapa enhet skapas gränssnittsmodulen MSXML_TLB som gör det möjligt för oss att använda XML DOM-objekt: DOMDocument, XMLDocument, XMLHTTPRequest och ett antal andra, implementerade i MSXML.DLL-biblioteket. Hänvisningen till MSXML_TLB-modulen måste finnas i listan Användningar.
XML DOM-enhet
Dokumentobjektmodellen representerar ett XML-dokument som en trädstruktur av grenar. XML DOM API: er tillåter applikationer att navigera i dokumentträdet och manipulera dess grenar. Varje gren kan ha en specifik typ (DOMNodeType), enligt vilken förälder- och undergrenarna bestäms. De flesta XML-dokument innehåller grenar av typelement, attribut och text. Attribut är en speciell typ av gren och är inte barngrenar. Attribut manipuleras med hjälp av speciella metoder som tillhandahålls av XML DOM-objekt.
Förutom att implementera W3C (World Wide Web Consortium) rekommenderade gränssnitt innehåller Microsoft XML DOM metoder som stöder XSL, XSL-mönster, namnområden och datatyper. Med SelectNodes-metoden kan du till exempel använda XSL-mönster-syntax för att hitta grenar i ett specifikt sammanhang, och metoden TransformNode stöder användning av XSL för att utföra transformationer.
Testa XML-dokument
Som ett exempel på ett XML-dokument, ta en CD-ROM-katalog med musik som har följande struktur:
Empire burlesk
Bob dylan
USA
Columbia
10.90
1985
Dölj ditt hjärta
Bonnie Tylor
Storbritannien
CBS Records
9.90
1988
...
Lossa mitt hjärta
Joe cocker
USA
EMI
8.20
1987
Vi är nu redo att börja titta på XML DOM-objektmodellen, från och med XMLDOMDocument-objektet.
XML-dokument - XMLDOMDocument-objekt
Att arbeta med ett XML-dokument börjar med att ladda det. För att göra detta använder vi Load-metoden, som bara har en parameter som anger URL för det laddade dokumentet. När du laddar filer från en lokal disk anges endast hela filnamnet (protokollet file: /// kan i detta fall utelämnas). Om XML-dokumentet är lagrat som en sträng använder du LoadXML-metoden för att ladda det dokumentet.
Egenskapen Async används för att styra hur dokumentet laddas (synkron eller asynkron). Som standard är den här egenskapen inställd på True, vilket indikerar att dokumentet laddas asynkront och kontrollen returneras till programmet innan dokumentet laddas helt. Annars laddas dokumentet synkront och sedan måste du kontrollera värdet på egenskapen ReadyState för att se om dokumentet har laddats eller inte. Du kan också skapa en händelsehanterare för OnReadyStateChange-händelsen som tar kontroll när värdet på egenskapen ReadyState ändras.
Följande visar hur man laddar ett XML-dokument med Load-metoden:
Använder ... MSXML_TLB ... procedur TForm1.Button1Click (Sender: TObject); var XMLDoc: IXMLDOMDocument; börja XMLDoc: \u003d CoDOMDocument.Create; XMLDoc.Async: \u003d Falskt; XMLDoc.Load (‘C: \\ DATA \\ DATA.xml’); // // Det är här koden // manipulerar XML-dokumentet och dess filialer // XMLDoc: \u003d Nil; slutet;
När dokumentet har laddats kan vi komma åt dess egenskaper. Således kommer egenskapen NodeName att innehålla #document-värdet, egenskapen NodeTypeString kommer att innehålla dokumentvärdet och URL-egenskapen kommer att innehålla värdet file: /// C: /DATA/DATA.xml.
Felhantering
Av särskilt intresse är egenskaperna som är associerade med dokumenthantering vid laddning. Till exempel returnerar egenskapen ParseError ett XMLDOMParseError-objekt som innehåller information om ett fel som uppstod när dokumentet bearbetades.
För att skriva en felhanterare kan du lägga till följande kod:
Var XMLError: IXMLDOMParseError; ... XMLDoc.Load (‘C: \\ DATA \\ DATA.xml’); XMLError: \u003d XMLDoc.ParseError; Om XMLError.ErrorCode<> 0 Sedan // // Här hanterar vi felet // Else Memo1.Lines.Add (XMLDoc.XML); ... XMLDoc: \u003d Noll;
För att se vilken information som returneras vid ett fel, ändra följande katalogpost:
Empire burlesk
Bob dylan
USA
Columbia
10.90
1985
ta bort stängningselementet
på andra raden:</p><p>
<CD>
<TITLE>Empire burlesk <ARTIST>Bob dylan</ARTIST> <COUNTRY>USA</COUNTRY> <COMPANY>Columbia</COMPANY> <PRICE>10.90</PRICE> <YEAR>1985</YEAR> </CD>
</p><p>Låt oss nu skriva kod som returnerar egenskapsvärdena för XMLDOMParseError-objektet:</p><p>XMLError: \u003d XMLDoc.ParseError; Om XMLError.ErrorCode<> 0 Sedan med XMLError börjar Memo1.Lines Lägg till (‘File:’ + URL); Lägg till (‘Kod:’ + IntToStr (ErrorCode)); Lägg till (‘Fel:’ + Orsak); Lägg till (‘Text:’ + SrcText); Lägg till (‘Line:’ + IntToStr (Line)); Lägg till (‘Position:’ + IntToStr (LinePos)); avsluta annat Memo1.Lines.Add (XMLDoc.XML); Slutet;</p><p>och kör vår ansökan. Som ett resultat får vi följande information om felet.</p>
<p>Som du kan se från exemplet ovan är informationen som returneras av XMLDOMParseError-objektet tillräckligt för att lokalisera felet och förstå orsaken till det.</p>
<p>Nu återställer vi stängningselementet <TITLE> i vårt dokument och fortsätt vår diskussion om XML DOM.</p>
<table border="0" width="100%"><tr><td width="50%">
</td>
<td width="50%">
</td>
</tr></table><h2> Åtkomst till dokumentträdet</h2>
<p>För att komma åt dokumentträdet kan du antingen hämta rotelementet och sedan itera över dess undergrenar eller hitta en specifik gren. I det första fallet får vi rotelementet genom egenskapen DocumentElement, som returnerar ett objekt av typen XMLDOMNode. Så här använder du egenskapen DocumentElement för att få innehållet i varje underordnat element:</p><p>Var-nod: IXMLDOMNode; Rot: IXMLDOMElement; I: Heltal; ... Rot: \u003d XMLDoc.DocumentElement; För I: \u003d 0 till Root.ChildNodes.Length-1 do Start Node: \u003d Root.ChildNodes.Item [I]; Memo1.Lines.Add (Node.Text); Slutet;</p><p>För vårt XML-dokument får vi följande text.</p>
<p>Om vi \u200b\u200bär intresserade av en specifik gren eller en gren under den första undergrenen kan vi använda antingen NodeFromID-metoden eller GetElementByTagName-metoden för XMLDOMDocument-objektet.</p>
<p>Metoden NodeFromID kräver en unik identifierare enligt definitionen i XML-schemat eller dokumenttypsdefinitionen (DTD) och returnerar en gren med den identifieraren.</p>
<p>GetElementByTagName-metoden kräver en sträng med ett specifikt element (tagg) och returnerar alla grenar med detta element. Så här använder du den här metoden för att hitta alla artister i vår CD-ROM-katalog:</p><p>Noder: IXMLDOMNodeList; Nod: IXMLDOMNode; ... Noder: \u003d XMLDoc.GetElementsByTagName (‘ARTIST’); För I: \u003d 0 till noder.Längd-1 gör Startnod: \u003d Noder.Item [I]; Memo1.Lines.Add (Node.Text); Slutet;</p><p>För vårt XML-dokument får vi följande text</p>
<p>Observera att SelectNodes-metoden för XMLDOMNode-objektet ger ett mer flexibelt sätt att komma åt dokumentgrenar. Men mer om det nedan.</p>
<table border="0" width="100%"><tr><td width="50%">
</td>
<td width="50%">
</td>
</tr></table><h2> Dokumentfilial - XMLDOMNode-objekt</h2>
<p>XMLDOMNode-objektet representerar en dokumentgren. Vi har redan stött på detta objekt när vi fick dokumentets rotelement:</p><p>Rot: \u003d XMLDoc.DocumentElement;</p><p>För att få information om en filial av ett XML-dokument kan du använda egenskaperna för XMLDOMNode-objektet (tabell 1).</p>
<p>För att komma åt data som lagras i en gren är det vanligt att använda antingen NodeValue-egenskapen (tillgänglig för attribut, textgrenar, kommentarer, bearbetningsinstruktioner och CDATA-sektioner) eller egenskapen Text som returnerar filialens textinnehåll eller egenskapen NodeTypedValue. Det senare kan emellertid endast användas för filialer med typföremål.</p>
<table border="0" width="100%"><tr><td width="50%">
</td>
<td width="50%">
</td>
</tr></table><h3> Navigera i dokumentträdet</h3>
<p>XMLDOMNode-objektet ger många sätt att navigera i dokumentträdet. Om du till exempel vill komma åt den överordnade grenen använder du egenskapen ParentNode (typ XMLDOMNode), åtkomst till undergrenarna genom ChildNodes-egenskaperna (XMLDOMNodeList-typ), FirstChild och LastChild (XMLDOMNode-typ), etc. Egenskapen OwnerDocument returnerar ett XMLDOMDocument-objekt som identifierar själva XML-dokumentet. Egenskaperna som listas ovan gör det enkelt att navigera i dokumentträdet.</p>
<p>Låt oss nu iterera över alla grenar av XML-dokumentet:</p><p>Rot: \u003d XMLDoc.DocumentElement; För I: \u003d 0 till Root.ChildNodes.Length-1 do Start Node: \u003d Root.ChildNodes.Item [I]; If Node.HasChildNodes Then GetChilds (Node, 0); Slutet;</p><p>Som nämnts ovan ger SelectNodes för XMLDOMNode-objektet ett mer flexibelt sätt att komma åt dokumentgrenar. Dessutom finns en SelectSingleNode-metod som bara returnerar dokumentets första gren. Båda dessa metoder gör att du kan definiera XSL-mallar för filialsökningar.</p>
<p>Låt oss titta på processen att använda SelectNodes-metoden för att hämta alla grenar som har en CD-gren och en PRICE-undergren:</p><p>Rot: \u003d XMLDoc.DocumentElement; Noder: \u003d Root.SelectNodes (‘CD / PRICE’);</p><p>Alla PRICE-undergrenar för CD-grenen kommer att placeras i Nodesamlingen. Vi kommer tillbaka för att diskutera XSL-mallar lite senare.</p>
<table border="0" width="100%"><tr><td width="50%">
</td>
<td width="50%">
</td>
</tr></table><h3> Manipulera barngrenar</h3>
<p>För att manipulera barngrenar kan vi använda metoderna för XMLDOMNode-objektet (tabell 2).</p>
<p>För att helt radera posten om den första disken måste du köra följande kod:</p><p>Var XMLDoc: IXMLDOMDocument; Rot: IXMLDOMNode; Nod: IXMLDOMNode; XMLDoc: \u003d CoDOMDocument.Create; XMLDoc.Async: \u003d Falskt; XMLDoc.Load (‘C: \\ DATA \\ DATA.xml’); // Hämta rotelementet Root: \u003d XMLDoc.DocumentElement; Nod: \u003d Rot; // Ta bort den första undergrenen Node.RemoveChild (Node.FirstChild);</p><p>Observera att i det här exemplet tar vi bort den första undergrenen. Hur man tar bort det första elementet i den första undergrenen visas nedan:</p><p>Var XMLDoc: IXMLDOMDocument; Rot: IXMLDOMNode; Nod: IXMLDOMNode; XMLDoc: \u003d CoDOMDocument.Create; XMLDoc.Async: \u003d Falskt; XMLDoc.Load (‘C: \\ DATA \\ DATA.xml’); // Hämta rotelementet Root: \u003d XMLDoc.DocumentElement; // och den första undergrenen Nod: \u003d Root.FirstChild; // Ta bort den första undergrenen Node.RemoveChild (Node.FirstChild);</p><p>I ovanstående exempel raderade vi inte den första grenen <CD>…</CD>och det första elementet i grenen är <TITLE>….
Låt oss nu lägga till en ny gren. Nedan är koden som visar hur man lägger till en ny musik-CD-ROM-post:
Var NewNode: IXMLDOMNode; Barn: IXMLDOMNode; ... // Skapa en ny gren - NewNode: \u003d XMLDoc.CreateNode (1, 'CD', ''); // Lägg till ett element Child: \u003d XMLDoc.CreateNode (1, 'TITLE', ''); // Lägg till ett element NewNode.AppendChild (Child); // Och ställ in värdet Child.Text: \u003d ‘Pink Floyd’; // Lägg till ett element <ARTIST> Child: \u003d XMLDoc.CreateNode (1, 'ARTIST', ''); // Lägg till ett element NewNode.AppendChild (Child); // Och ställ in värdet Child.Text: \u003d ‘Division Bell’; // Lägg till ett element <COUNTRY> Child: \u003d XMLDoc.CreateNode (1, 'COUNTRY', ''); // Lägg till ett element NewNode.AppendChild (Child); // Och ställ in dess värde Child.Text: \u003d ‘UK’; // Lägg till ett element <COMPANY> Barn: \u003d XMLDoc.CreateNode (1, 'FÖRETAG', ''); // Lägg till ett element NewNode.AppendChild (Child); // Och ställ in värdet Child.Text: \u003d ‘EMI Records Ltd.’; // Lägg till ett element <PRICE>Child: \u003d XMLDoc.CreateNode (1, 'PRICE', ''); // Lägg till ett element NewNode.AppendChild (Child); // Och ställ in värdet Child.Text: \u003d '11 .99 "; // Lägg till ett element <YEAR> Child: \u003d XMLDoc.CreateNode (1, 'YEAR', ''); // Lägg till ett element NewNode.AppendChild (Child); // Och ställ in dess värde Child.Text: \u003d ‘1994’; // Och lägg till en gren Root.AppendChild (NewNode); ...</p><p>Ovanstående kod visar följande steg för att lägga till en ny gren:</p>
<ul><li>Skapa en ny gren med metoden CreateNode: <ul><li>skapa ett element med hjälp av CreateNode-metoden;</li>
<li>lägga till ett element i en gren med AppendChild-metoden;</li>
<li>ställa in värdet för ett element genom textegenskapen;</li>
<li>... Upprepa för alla element.</li>
</ul></li>
<li>Lägga till en ny gren i dokumentet med AppendChild-metoden.</li>
</ul><p>Kom ihåg att metoden AppendChild lägger till en gren i trädets ände. För att lägga till en gren till en viss plats i trädet måste du använda metoden InsertBefore.</p>
<h2> Grenuppsättning - XMLDOMNodeList-objekt</h2>
<p>XMLNodeList-objektet innehåller en lista med grenar som kan byggas med metoderna SelectNodes eller GetElementsByTagName och även erhållas från ChildNodes-egenskapen.</p>
<p>Vi har redan diskuterat användningen av detta objekt i exemplet i avsnittet "Navigera i dokumentträdet". Här ger vi också några teoretiska kommentarer.</p>
<p>Antalet grenar i listan kan erhållas som värdet på egenskapen Length. Grenarna indexeras från 0 till längd-1, och varje enskild gren är tillgänglig via motsvarande indexerade objekt i artikelmatrisen.</p>
<p>Navigering genom listan med grenar kan också göras med NextNode-metoden, som returnerar nästa gren i listan, eller Noll om den aktuella grenen är den sista. För att återgå till toppen av listan, ring återställningsmetoden.</p>
<table border="0" width="100%"><tr><td width="50%">
</td>
<td width="50%">
</td>
</tr></table><h2> Skapa och spara dokument</h2>
<p>Så vi har sett hur du kan lägga till filialer och element i befintliga XML-dokument. Låt oss nu skapa ett XML-dokument i farten. Först och främst, kom ihåg att ett dokument kan laddas inte bara från en URL utan också från en vanlig sträng. Följande visar hur man skapar ett rotelement, som sedan kan användas för att dynamiskt bygga resten av elementen (som vi redan täckte i avsnittet "Manipulera barngrenar"):</p><p>Var XMLDoc: IXMLDOMDocument; Rot: IXMLDOMNode; Nod: IXMLDOMNode; S: WideString; ... S: \u003d ‘ <CATALOG></CATALOG>'; XMLDoc: \u003d CoDOMDocument.Create; XMLDoc.Async: \u003d Falskt; XMLDoc.LoadXML (S); Rot: \u003d XMLDoc.DocumentElement; Nod: \u003d XMLDoc.CreateNode (1, 'CD', ''); Root.AppendChild (Node); Memo1.Lines.Add (XMLDoc.XML); ... XMLDoc: \u003d Noll;</p><p>När du har skapat XML-dokumentet sparar du det i en fil med Spara-metoden. Till exempel:</p>
<p>XMLDoc.Save ('C: \\ DATA \\ NEWCD.XML');</p>
<p>Förutom att spara i en fil, kan du med Save-metoden spara ett XML-dokument i ett nytt XMLDOMDocument-objekt. I det här fallet behandlas dokumentet helt och följaktligen kontrolleras dess struktur och syntax. Så här sparar du ett dokument till ett annat objekt:</p><p>Procedur TForm1.Button2Click (Avsändare: TObject); var XMLDoc2: IXMLDOMDocument; börja XMLDoc2: \u003d CoDOMDocument.Create; XMLDoc.Save (XMLDoc2); Memo2.Lines.Add (XMLDoc2.XML); ... XMLDoc2: \u003d Noll; slutet;</p><p>Sammanfattningsvis låter Save-metoden dig också spara XML-dokumentet till andra COM-objekt som stöder gränssnitten IStream, IPersistStream eller IPersistStreamInit.</p>
<table border="0" width="100%"><tr><td width="50%">
</td>
<td width="50%">
</td>
</tr></table><h2> Använda XSL-mallar</h2>
<p>När vi diskuterade SelectNodes-metoden för XMLDOMNode-objektet nämnde vi att det ger ett mer flexibelt sätt att komma åt dokumentgrenar. Flexibiliteten är att du kan ange en XSL-mall som kriterier för att välja filialer. Sådana mallar ger en kraftfull mekanism för att hitta information i XML-dokument. För att till exempel få en lista över alla CD-ROM-titlar i vår katalog kan du köra följande fråga:</p><p>För att ta reda på vilka artistskivor som släpptes i USA, är begäran utformad enligt följande:</p><p>Noder: \u003d Root.SelectNodes (‘CD / ARTIST’);</p><p>Så här hittar du den första enheten i en katalog:</p><p>Noder: \u003d Root.SelectNodes (‘CD / TITLE’);</p><p>och sist:</p><p>Noder: \u003d Root.SelectNodes (‘CD / TITLE’);</p><p>För att hitta Bob Dylans skivor kan du köra följande fråga:</p><p>Noder: \u003d Root.SelectNodes (‘CD [$ any $ ARTIST \u003d” Bob Dylan ”] / TITLE’);</p><p>och för att få en lista över diskar som gjorts efter 1985 kör vi följande fråga:</p><p>Noder: \u003d Root.SelectNodes (‘CD / TITLE’);</p><p>En mer detaljerad diskussion om XSL-syntax kräver en separat publikation. För att intressera läsare och uppmuntra till vidare forskning kommer jag bara att ge ett litet exempel på möjlig användning av XSL. Låt oss säga att vi måste konvertera vår katalog till en vanlig HTML-tabell. Med traditionella metoder måste vi itera över alla grenar i trädet och för varje mottaget element bilda motsvarande taggar <TD>…</TD>.</p>
<p>Med hjälp av XSL skapar vi helt enkelt en mall (eller formatmall) som anger vad och hur man ska transformera. Sedan lägger vi den här mallen i vår katalog - och du är klar: vi har texten i en XSL-mall som förvandlar katalogen till en tabell (Listing 2).</p>
<p>Koden för att lägga en XSL-mall i vår katalog ser ut så här:</p><p>Procedur TForm1.Button2Click (Avsändare: TObject); var XSLDoc: IXMLDOMDocument; börja XSLDoc: \u003d CoDOMDocument.Create; XSLDoc.Load (‘C: \\ DATA \\ DATA.xsl’); Memo2.Text: \u003d XMLDoc.TransformNode (XSLDoc); XSLDoc: \u003d Noll; slutet;</p><p>Avslutande av vår diskussion om XSL bör det sägas att för närvarande används detta språk aktivt för transformation mellan olika XML-dokument, liksom för formatering av dokument.</p>
<table border="0" width="100%"><tr><td width="50%">
</td>
<td width="50%">
</td>
</tr></table><h2> Slutsats</h2>
<p>Av uppenbara skäl är det omöjligt att täcka alla Microsoft XML DOM-objekt och ge exempel på deras användning i en artikel. Här har vi precis berört de grundläggande problemen med att använda XML DOM i applikationer. Tabell 3 visar alla objekt implementerade i Microsoft XML DOM.</p>
<p>ComputerPress 12 "2000</p>
<p>Nyligen har mycket uppmärksamhet ägnats åt att bygga e-affärssystem, eller som de också kallas - B2B (business to business). Med tanke på rekommendationerna om konstruktion av utbytesströmningssystem från den samordnande organet för internetteknik - WWW Consortium: tonvikten ligger på XML-teknik och konstruktion av system för utbyte av XML-dokument.</p>
<p>Fördelen med att använda XML i e-handel är den höga effektiviteten hos B2B-system till låga kostnader för dess skapande på grund av en tydlig och visuell presentation av strukturerad information, möjligheten att använda moderna nätverksprotokoll och skapa affärssystem i realtid.</p>
<p>Oberoende av presentation av information i form av XML-dokument gör det möjligt för olika företag som är involverade i e-handel att producera programvara oberoende av varandra.</p>
<p>I alla system byggs utbytet som regel enligt samma schema med HTTP-förfrågningar. SSL används som informationssäkerhetsprotokoll (men detta är ett separat ämne).</p>
<p>Ett av de möjliga alternativen för bearbetning av XML-meddelanden är att bygga BIN / CGI (ISAPI) applikationer eller COM (server) komponenter som genererar eller bearbetar XML-dokument.</p>
<p>Å ena sidan fungerar applikationen som en klient, som utfärdar en HTTP-begäran i POST-läge, å andra sidan finns det en WEB-server på vilken sidan begäran behandlas och ett svar utfärdas. XML-dokument används i informationsutbytet.</p>
<p>Ett av de mest effektiva implementeringsalternativen är att använda en befintlig XML-parser som stöder DOM-modellen. En sådan parser är ett distributionspaket av Win'98 eller en integrerad del av IE 4.7 och högre (för Win'95) och representerar en COM-server som finns i msxml.dll-biblioteket.</p>
<p>Component Object Model (COM) - representerar inkapslad data och metoder i en enda enhet och ett sätt att komma åt dem via ett system av gränssnitt. Med Delphi-verktyg är det ganska enkelt att komma åt klasserna för ett COM-objekt (flera klasser kan inkluderas i en COM-server). Objekt nås genom att initiera en klassinstans via gränssnittssystemet. Beskrivningen av gränssnitt utförs av gränssnittsdefinitionsspråket (IDL), som kan utföras med hjälp av miljön automatiskt.</p>
<p>Delphi-verktyg används för att importera från en COM-server <i>msxml.dll</i>, filerna för beskrivningen av IDL-gränssnittet och filen för den binära beskrivningen av bibliotektyperna - TLB är byggda. Denna operation utförs via systemmenyn: <b>Projekt | Skriv biblioteksimport:</b>(bild 1). Därefter visas en dialogruta (Figur 2) där du måste välja ett COM-objekt (i vårt fall är objektet registrerat under namnet "Microsoft.XMLDom (Version 2.0)") och skapa en TLB-fil (knapp <b>Skapa enhet</b>). Genom att använda TLB-filen genererar ramverket en Pascal COM-serverbeskrivningsfil - MSXML_TLB.pas</p>
<p>MSXML_TLB.pas-filen beskriver alla gränssnitt, konstanter och coclasses på COM-servern.</p>
<p>För att komma åt objekt från ett COM-element behöver du i direktivet <b>ANVÄNDNINGAR</b>lägg till namnet på biblioteksbeskrivningsfilen (MSXML_TLB.pas). Nedan finns ett enkelt program som använder standard DOM-parser msxml.dll, som laddar ett XML-dokument och visar det i ett Memo1-textfältelement.</p> <b>användningsområden</b> Windows, Meddelanden, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, OleServer, MSXML_TLB, StdCtrls; <b>typ</b> TForm1 \u003d <b>klass</b>(TForm) Knapp1: TButton; Memo1: TMemo; <b>procedur</b> Button1Click (Sender: TObject); <b> slutet;</b>
<b>var</b> Form1: TForm1; <b>genomförande</b> ($ R * .DFM) <b>Procedur</b>TForm1.Button1Click (Sender: Tobject); <span> // förklaring av DOMDocument-objektets soclass;</span>
<b>var</b>coDoc: CoDOMDocument; <span> // klass överensstämmer med IDOMDocument-gränssnittet;</span>
<b>var</b>Dok: IXMLDOMDocument; <b>börja</b>
<span> // skapa en instans av DOMDocument-objektet;</span> Doc: \u003d coDoc.Create; <span> // anropa Load-metoden för en instans av DOMDocument-objektet;</span> Doc.load ("data.xml"); <span> // åtkomst till xml-egenskapen för DOMDocument-instansen;</span> Memo1.Text: \u003d Doc.xml; <b>slutet;</b>
<b>slutet.</b>
<h2>DOM-koncept - Dokumentobjektmodell</h2>
<p>Varje XML-dokument representeras som en uppsättning av flera objekt (klasser), med hjälp av vilket det är möjligt att komma åt enskilda element (objektfält). DOM - gränssnittet beskriver åtkomst till både enkla objekt av typen DOMString eller CharacterData och till delar eller enskilda element i ett XML-dokument: DOMFragmentElement, DOMNode, DOMElement.</p>
<p>Följande är de viktigaste egenskaperna och metoderna för XMLDOMDocument, XMLDOMNode, XMLDOMNodeList-objekt. Det bör noteras att metoderna och funktionerna för DOM-objekt som presenteras nedan (Document Object Model) används av Microsoft XML-parser msxml.dll och är något bredare än den modell som godkänts av W3C DOM Consortium.</p>
<p>En mer fullständig beskrivning av DOM-objektgränssnittet finns på</p>
<table cellspacing="0" cellpadding="4" width="500" border="1"><tbody><tr><td valign="top" colspan="2"> XMLDOMDocument-objekt</td>
</tr><tr><td valign="top" colspan="2">Representerar den översta nivån i objekthierarkin och innehåller metoder för att arbeta med ett dokument: ladda det, analysera det, skapa element, attribut, kommentarer etc. ...</td>
</tr><tr><td valign="top" colspan="2"><b>Egenskaper</b>
</td>
</tr><tr><td valign="top" width="39%"><b>Async</b>
</td>
<td valign="top" width="61%">Egenskap som identifierar det aktuella bearbetningsläget</td>
</tr><tr><td valign="top" width="39%" height="19"><b>ParseError</b>
</td>
<td valign="top" width="61%" height="19">Returnerar en referens till XMLDOMParseError-felhanteringsobjektet</td>
</tr><tr><td valign="top" width="39%"><b>Aktivera - inaktivera dokumentverifiering.</b>
</td>
<td>
</td>
</tr><tr><td valign="top" width="39%"><b>url</b>
</td>
<td valign="top" width="61%">Returnerar dokumentets URL</td>
</tr><tr><td valign="top" width="39%"><b>documentElement</b>
</td>
<td valign="top" width="61%">Innehåller en referens till dokumentets rotelement som ett XMLDOMElement-objekt.</td>
</tr><tr><td valign="top" colspan="2"><b>Metoder</b>
</td>
</tr><tr><td valign="top" width="39%"><b>belastning (url) <br>loadXML (xmlString)</b>
</td>
<td valign="top" width="61%">Läser in ett XML-dokument,</td>
</tr><tr><td valign="top" width="39%"><b>spara (objTarget)</b>
</td>
<td valign="top" width="61%">Sparar XML-dokument som fil</td>
</tr><tr><td valign="top" width="39%"><b>avbryta</b>
</td>
<td valign="top" width="61%">Avbrott i processen att ladda och bearbeta dokumentet.</td>
</tr><tr><td valign="top" width="39%"><b>createAttribute (namn)</b>
</td>
<td valign="top" width="61%">Skapar ett nytt attribut med det angivna namnet för det aktuella elementet.</td>
</tr><tr><td valign="top" width="39%"><b>createNode (Type, name, nameSpaceURI)</b>
</td>
<td valign="top" width="61%">Skapar en nod av angiven typ och namn</td>
</tr><tr><td valign="top" width="39%"><b>createElement (tagName)</b>
</td>
<td valign="top" width="61%">Skapar ett dokumentelement med det angivna namnet.</td>
</tr><tr><td valign="top" width="39%"><b>createTextNode (data)</b>
</td>
<td valign="top" width="61%">Skapar text i ett dokument</td>
</tr><tr><td valign="top" width="39%"><b>getElementsByTagName (tagnamn)</b>
</td>
<td valign="top" width="61%">Returnerar en hänvisning till samlingen av dokumentelement med det angivna namnet</td>
</tr><tr><td valign="top" width="39%"><b>nodeFromID (idString)</b>
</td>
<td valign="top" width="61%">Hitta ett objekt efter ID</td>
</tr></tbody></table><br><table cellspacing="0" cellpadding="4" width="500" border="1"><tbody><tr><td valign="top" colspan="2"> <b>XMLDOMNode-objekt</b>
</td>
</tr><tr><td valign="top" colspan="2">XMLDOMNode-objekt som implementerar DOM-basgränssnittet <b>Nod</b>, är avsedd för att manipulera en separat nod i dokumentträdet. Dess egenskaper och metoder gör att du kan få och ändra fullständig information om den aktuella noden - dess typ, namn, fullständiga namn, dess innehåll, lista över underordnade element etc.</td>
</tr><tr><td valign="top" colspan="2"><b>Egenskaper</b>
</td>
</tr><tr><td valign="top" width=" "><b>nodnamn, basnamn</b>
</td>
<td valign="top" width="65%">Returnerar namnet på den aktuella noden.</td>
</tr><tr><td valign="top" width="35%"><b>prefix</b>
</td>
<td valign="top" width="65%">Returnerar namnområdet prefix.</td>
</tr><tr><td valign="top" width="35%"><b>data typ</b>
</td>
<td valign="top" width="65%">Anger innehållstypen för den aktuella noden</td>
</tr><tr><td valign="top" width="35%"><b>nodeType, nodeTypeString</b>
</td>
<td valign="top" width="65%">Returnerar typen av aktuell nod:</td>
</tr><tr><td valign="top" width="35%"><b>attribut</b>
</td>
<td valign="top" width="65%">Hämtar en lista över attributen för den aktuella noden som en XMLDOMNamedNodeMap-samling.</td>
</tr><tr><td valign="top" width="35%"><b>text</b>
</td>
<td valign="top" width="65%">Returnerar innehållet i det aktuella underträdet som text</td>
</tr><tr><td valign="top" width="35%"><b>xml</b>
</td>
<td valign="top" width="65%">Returnerar en XML-representation av det aktuella underträdet.</td>
</tr><tr><td valign="top" width="35%"><b>nodeValue</b>
</td>
<td valign="top" width="65%">Returnerar innehållet i den aktuella noden.</td>
</tr><tr><td valign="top" width="35%"><b>childNodes</b>
</td>
<td valign="top" width="65%">Returnerar en lista med underordnade element som XMLDOMNodeList.</td>
</tr><tr><td valign="top" width="35%"><b>firstChild, lastChild</b>
</td>
<td valign="top" width="65%">Returnerar det första / sista barnet</td>
</tr><tr><td valign="top" width="35%"><b>previousSibling, nextSibling</b>
</td>
<td valign="top" width="65%">Returnerar föregående / nästa syskonelement.</td>
</tr><tr><td valign="top" width="35%"><b>parentNode</b>
</td>
<td valign="top" width="65%">Innehåller en länk till det överordnade elementet.</td>
</tr><tr><td valign="top" width="35%"><b>ägareDokument</b>
</td>
<td valign="top" width="65%">Returnerar en pekare till dokumentet som innehåller den aktuella noden.</td>
</tr><tr><td valign="top" colspan="2"><b>Metoder</b>
</td>
</tr><tr><td valign="top" width="35%"><b>appendChild (newChild)</b>
</td>
<td valign="top" width="65%">Lägger till ett nytt barn i den aktuella noden.</td>
</tr><tr><td valign="top" width="35%"><b>insertBefore (newChild, refChild)</b>
</td>
<td valign="top" width="65%">Infogar en undernod och placerar den i det aktuella underträdet "till vänster" om noden som anges av parametern refChild.</td>
</tr><tr><td valign="top" width="35%"><b>cloneNode (djup)</b>
</td>
<td valign="top" width="65%">Skapar en kopia av det aktuella objektet.</td>
</tr><tr><td valign="top" width="35%"><b>getAttribute</b><b>(namn) <br>
</b><b>getAttributeNode</b><b><span> (namn) <br>setAttribute (namn, värde) <br>setAttributeNode (XMLDOMAttribute)</span>
</b>
</td>
<td valign="top" width="65%">Tillgång till attribut (skapa, läsa, skriva) för objektet. Namn är namnet på attributet, värdet är dess värde. Returnerar ett XMLDOMAttribute-objekt.</td>
</tr><tr><td valign="top" width="35%"><b>replaceChild (newChild, oldChild) removeChild (oldChild)</b>
</td>
<td valign="top" width="65%">Ersätta det gamlaChild-objektet i den aktuella listan med underordnade objekt med newChild. Ta bort oldChild-objekt</td>
</tr><tr><td valign="top" width="35%"><b>selectNodes (patternString) selectSingleNode (patternString)</b>
</td>
<td valign="top" width="65%">Returnerar ett XMLDOMNodeList-objekt som valts av sökmönster eller första nod</td>
</tr><tr><td valign="top" width="35%"><b>transformNode (formatmall) <br>transformNodeToObject (formatmall, outputObject)</b>
</td>
<td valign="top" width="65%">Tilldelar ett formatark till den aktuella nodens underträd och returnerar en sträng som är resultatet av bearbetningen. Parametern är en referens till DOMDocument-objektet som innehåller XSL-uttalanden.</td>
</tr></tbody></table><br><h2>Använda XML i affärer.</h2>
<p>För en tydligare bild behövs en förklaring och varför allt detta behövs för att förstå hur det fungerar:</p>
<p>När du bygger ett B2B- eller företags-ERP-system, när du organiserar informationsutbytet av XML-dokument mellan företag eller filialer i pr-I, används ett effektivt bevisat system för informationsöverföring baserat på befintliga WEB-servrar via HTTP-protokoll.</p>
<p>Å ena sidan fungerar applikationen som en klient, som utfärdar en HTTP-begäran i POST-läge, å andra sidan finns det en WEB-server, på vilken sidan begäran behandlas och ett svar utfärdas. XML-dokument används som utbyte.</p>
<p>I ett enkelt företags ERP-system, ett redovisningsprogram (ACS Accounting), är det till exempel nödvändigt att bilda en begäran om en faktura och skicka den till en filial som har ett lager (ACS Warehouse). AWP Ett liknande problemmeddelande när man skapar ett B2B-system när företag A begär tillgång till produkter (gör en beställning för inköpet) från leverantör B.</p>
<p>Enterprise A och dess program fungerar som en klient. Lageret betjänas av leverantör B, som har ett lagerkomplex med en databas på en SQL-server. Utbytet genomförs via företagets WEB-server hos leverantören V.</p>
<p>Nedan följer följande typiska utbytesalgoritm:</p>
<br>Figur 3. <ol><li><b>Företag A</b>initierar <b>process A</b>(produktorder), som fungerar som en WEB-klient.</li><li><b>Process A</b>genererar ett XML-dokument (till exempel en fakturaförfrågan) och överför det som en POST http-förfrågan till WEB-servern hos leverantör B. Som URI används resursidentifieraren för behandlingsapplikationen. URI kan vara densamma för alla typer av dokument, eller individuellt för varje typ. Allt beror på strukturen på B2B (WEB) -servern.</li><li>WEB-server analyserar begäran och genererar en server <b>Process B</b>genom att skicka kroppen till XML-dokumentet som en parameter. <br>Process B lanseras av en WEB-server och behandlas antingen som en ASP-sida, CGI (ISAPI) - applikation eller JAVA-server (serverapplikation)</li><li><b>Process B</b>- genererar en begäran till SQL-databasservern.</li><li>SQL-servern utför de nödvändiga operationerna i databasen, genererar ett svar och returnerar det <b>Process B</b>.</li><li>Enligt svaret från SQL-servern <b>Process B</b> bildar ett XML-dokument (svar) och returnerar det som ett svar på en http-begäran till klientapplikationen.</li><li>Beroende på situationen på klientsidan bildas antingen en ny http-begäran eller så avslutas sessionen.</li>
</ol><h2>Några ord om organisationen av dokumentflöde.</h2>
<p>Den allmänna regeln för att utveckla ett system för utbyte av XML-dokument är:</p><ul><li><b>i början</b>- Utveckling av ett flödesschema över elektroniska dokument och deras struktur.</li><li><b>för det andra</b>- utveckling av tabeller över processfunktioner (delprocesser), dvs. vilken funktion med avseende på vilket XML-dokument varje process ska implementeras.</li>
</ul><p>Varje XML-dokument, som ett HTML-dokument, måste bestå av ett meddelandehuvud (information bifogat av taggar) och ett meddelandetext (för en begäran är denna information inramad med taggar för att svara på en begäran). För att XML-dokumentet ska vara välformat är det nödvändigt att till exempel rama in dess två komponentdelar "Rubrik" och "Begär" med taggar. Typen av ett typiskt dokument presenteras nedan:</p>
<p>Rubriken (Figur 4), till skillnad från ett HTML-dokument, måste innehålla olika typer av tjänsteinformation, inklusive information om typen av det överförda dokumentet och processen för dess bearbetning. Dokumentets kropp kommer in i informationsbehandling, d.v.s. innehåll inramat av taggar. Det bör noteras att rubrikernas struktur bör vara densamma för alla typer av dokument.</p>
<p>För processen som startas av servern är det att föredra (men inte nödvändigt) att bygga bearbetningsalgoritmen enligt följande:</p>
<img src='https://i0.wp.com/codenet.ru/np-includes/upload/2005/01/05/128666.jpg' height="500" width="408" loading=lazy><br>Figur 6. <h2>Några grundläggande punkter när du skapar klientsidan</h2>
<p>Som redan förklarats används dess representation i form av en DOM-modell när du skapar ett XML-dokument. Nedan följer ett exempel på en Delphi-textdel i ett meddelandeprogram som skapar rubrikhuvud.</p> <b>procedur</b>TThread1.HeaderCreate (Avsändare: Tobject); <b>var</b>
<span> // klassdeklaration, behövs för att skapa</span> coDoc: CoDomDocument; <span> // XMLDomDocument-objekt</span> Dok: DomDocument; r: IXMLDOMElement; Nod: IXMLDOMElement; // DOMText txt: IXMLDOMText; // DOMAttribute attr: IXMLDOMAttribute; <b>börja</b>
<span> // skapa DOM-dokument</span> Doc: \u003d coDoc.Create; Doc.Set_async (falskt); <span> // initial initiering av DOM-dokumentet</span> Doc.LoadXML (" <Header/>");
<span> // skapa DOMElement (tagg<<b>Avsändare</b>>)
</span> Nod: \u003d Doc.createElement ("Avsändare"); <span> // skapa en textnod " <b>Typhoon LLC</b>"
</span> txt: \u003d Doc.createTextNode ("Typhoon LLC"); <span> // tilldelning till nod<<b>Avsändare</b>\u003e värde</span>
<span> // textnod " <b>Typhoon LLC</b>"
</span> Node.appendChild (txt); <span> // lägg till element<<b>Avsändare</b>\u003e till dokumentroten som barn</span> r.appendChild (Node); <span> <<b>Från</b>>
</span> Nod: \u003d Doc.createElement ("Från"); txt: \u003d Doc.createTextNode ("http://tayfun.ru/xml/default.asp"); Node.appendChild (txt); r.appendChild (Node); <span> // liknande operationer för taggen<<b>Till</b>>
</span> Nod: \u003d Doc.createElement ("Till"); txt: \u003d Doc.createTextNode ("http://irbis.ru"); Node.appendChild (txt); r.appendChild (Node); <span> // skapa DOMElement ()</span> Nod: \u003d Doc.createElement ("TypeDocument"); <span> // skapa XMLDOMAttribute-nod</span> Att: \u003d Doc.createAttribute ("Id", "Order"); <span> // <TypeDocument Id="Order"/>
</span> Node.appendChild (Att); r.appendChild (Node); <b>slutet;</b>
<p>Det bör noteras att deklarationen av variabeln coDoc: CoDomDocument och Doc: DomDocument, liksom dess skapande med metoden Create (Doc: \u003d coDoc.Create;), görs en gång. Variabeldeklarationen finns i avsnittet som beskriver globala variabler och inte i det lokala förfarandet, eftersom det visades för tydlighet i detta exempel (det vill säga en global variabel av DomDocument-typen per programmodul).</p>
<p>Resultatet av arbetet med ovanstående program blir den skapade rubriken, applicerad på vårt exempel xml-dokument: visas i figur 5.</p>
<img src='https://i0.wp.com/codenet.ru/np-includes/upload/2005/01/05/128662.gif' height="116" width="298" loading=lazy><br>Figur 5. <p><img src='https://i0.wp.com/codenet.ru/np-includes/upload/2005/01/05/128664.gif' height="179" width="385" loading=lazy><br>Figur 6.</p><p>Den största fördelen med att överföra information i form av XML-dokument är att det är möjligt att skapa ett meddelande med hjälp av oberoende tabellstrukturer i DBMS på både mottagande och sändande sida. Anta med vårt exempel att det krävs att överföra information om fakturorna för Enterprise A, från DBMS med strukturen som visas i figur 6</p>
<p>För att generera ett xml-dokument som innehåller en faktura byggs en SQL-fråga (fråga A) inledningsvis med information om själva fakturan:</p>
<b>VÄLJ</b> * FRÅN Invoice_General <b>VAR</b> InvoiceNum \u003d: num <b>VÄLJ</b>Varor, kvalitet, pris, HZ_cod <b>FRÅN</b>Varor <b>VAR</b> InvoiceNum \u003d: num <span> //: num - en parameter som anger fakturanumret.</span>
<p>Nedan följer en del av programmet som genererar xml-dokumentets kropp:</p> <b>procedur</b> TThread1.DataBodyCreate (Avsändare: Tobject); <b>var</b>
<span> // deklaration av klassen och XMLDomDocument-objektet</span> // coDoc: CoDomDocument; <span> // måste vara global för hela modulen.</span> // Dok: DomDocument; <span> // deklarera DOMElement-objekt</span> r: IXMLDOMElement; // DOMElement; Nod, Node2: IXMLDOMElement; Node3, Node4: IXMLDOMElement; // DOMText txt: IXMLDOMText; str: Sträng; <span> // Fakturanummer: <b>heltal;</b> - global variabel - // har värdet 987654 // queryA, queryB: <b>Sträng;</b> - global variabel, // har ett värde som motsvarar frågan // fråga A - fråga A med allmän information om fakturan // fråga B - fråga B information om de varor som beskrivs i // faktura (se text)</span>
<b>börja</b> Fråga. Stäng; <span> // se texten "begär A"</span> Query.Text: \u003d queryA; <span> // kör begäran</span> Query.ExecSQL; Fråga. Öppna; <span> // få adressen till rotelementet</span> r: \u003d Doc.Get_documentElement; Node2: \u003d Doc.createElement ("Request"); <span> // skapa DOMElement (tagg)</span> Nod: \u003d Doc.createElement ("Faktura"); <span> // lägg till ett element i roten</span> r.appendChild (Node2); <span> // lägg till ett objekt i</span> Nod2. appendChild (Node); <span> // skapa DOMElement (tagg)</span> Node3: \u003d Doc.createElement ("Depurture"); <span> // lägg till ett objekt i</span> Nod. appendChild (Node3); <span> // tillgång till "Depurture" -fältet i begäran</span> str: \u003d Query.FieldByName ("Depurture"). AsString; <span> // skapa textnod \u003d fältvärde</span><span> // tilldela noden ett värde</span>
<span> // textnod, variabel str</span> Node.appendChild (txt); <span> // liknande operationer för taggen <Destination>, <DataSend>,
// <DataDepurture>, <Currency>
// <DestinationCompany> (fält DB "Mottagare")</span> Nod: \u003d Doc.createElement ("Destination"); <span> // namnet på databasfältet kanske inte är detsamma som namnet</span> str: \u003d Query.FieldByName ("Mottagare") .AsString; <span> // tagg, detta är fördelen med att använda</span> txt: \u003d Doc.createTextNode (str); <span> // DOM i gränssnittet framför ett DBMS som stöder XML-gränssnitt, // som ORACLE 8i eller MS SQL 2000</span> Node.appendChild (txt); ... <span> // generera en begäran om en specifikation för varor</span>
<span> // stäng begäran om åtkomst</span> Fråga. Stäng; <span> // se i texten "begäran B", info. Om varor</span> Query.Text: \u003d frågaВ; <span> // tilldelning av parametervärden</span> Query.Params.AsInteger: \u003d InvoiceNumber; <span> // kör begäran</span> Fråga2.ExecSQL; <span> // öppen åtkomst till begäran om data</span> Fråga.Öppen; <span> // skapa DOMElement (tagg)</span> Node3: \u003d Doc.createElement ("Imems"); <span> // lägg till ett objekt i</span> Nod. appendChild (Node3); <span> // slinga igenom alla frågelinjer</span>
<b>medan</b> <b>inte</b> Eof.Query <b>do</b> börja Node4: \u003d Doc.createElement ("Imem"); <span> // lägg till ett objekt i</span> Node3.appendChild (Node4); <span> // generera data för taggen</span> str: \u003d Query.FieldByName ("Pris"). AsString; txt: \u003d Doc.createTextNode (str); Node.appendChild (txt); ... <span>// liknande operationer för taggar <HZ_Cod>, <Quality>, <GoodName>
</span>
<b>slutet;</b>
<b>slutet;</b>
<p>Som ett resultat av denna procedur genereras följande text i ett XML-dokument:</p>
<table width="100%"><tbody><tr><td align="middle"><br><img src='https://i2.wp.com/codenet.ru/np-includes/upload/2005/01/05/128661.gif' width="100%" loading=lazy></td>
</tr></tbody></table><p>Använd objektet Öppna för att göra en begäran <b>IXMLHttpRequest</b>:</p> <b>procedur</b> Öppna (const bstrMethod, - method type \u003d "POST" bstrUrl, - varAsync server url, - asynchronous / synchronous communication mode \u003d true bstrUser, - bstrPassword authentication username) - password <h2>Skapa serversidan av dokumenthantering</h2>
<p>Som nämnts tidigare kan hantering av en HTTP-begäran hanteras av antingen CGI-applikationer eller Java-servlets. Det är också möjligt att skriva ASP-sidor. Men i det här fallet är dataöverföring endast möjlig med "GET" -metoden genom frågesträngen. Att hantera en HTTP-begäran för ASP-sidor är dock effektivare än en CGI-applikation. Men enligt min mening spelar det ingen roll hur man bearbetar det, men det är viktigare att bestämma hur man bygger ett bearbetningsprogram och inte på vilket sätt.</p>
<p>Om vi \u200b\u200bfrån föregående kapitel undersökte alternativen för att skapa ett XML-dokument, så är serverapplikationens uppgift tvärtom - analysera XML-dokument. Nedan följer en del av programmet som analyserar ett xml-dokument:</p> <b>procedur</b>Tthread1.DataParser (Avsändare: Tobject); <b>var</b>
<span>// deklarera DOMElement-objekt</span> r, FNode: IXMLDOMElement; Str, Filnamn: Sträng; parm: Sträng; <span>// soclassdeklaration och</span> CoDocXML, CoDocXSL, CoDocResult: CoDomDocument; <span>// XMLDomDocument-objekt</span> XMLDoc, XSLDoc, ResultDoc: DomDocument; <span>// HttpStr: Sträng; - en global variabel som innehåller HTTP-begäran sträng</span>
<b>Börja</b> XMLDoc: \u003d coDocXML.Create; XMLDoc.LoadXML (HttpStr); <span> // få adressen till rotelementet</span> r: \u003d Doc.Get_documentElement; <span> // få värdet av elementet</span> FNode: \u003d r.SelectSingleNode ("// TypeDocument"); <span> // få värdet på attributet id \u003d "Order"</span> Filnamn: \u003d FNode.GetAttibute ("id"); <span> // och bildar filnamnet Order.xsl</span> Filnamn: \u003d Filnamn + ". Xsl"; <span> // skapa XSLDoc-dokument</span> XSLDoc: \u003d coDocXSL.Create; XSLDoc.LoadXML (filnamn); <span> // skapa XMLDoc-dokument</span> ResultDoc: \u003d coDocResult.Create; <span> // ställa in synkron bearbetningsläge</span> ResultDoc.Set_async (false); <span> // ställa in analys</span> ResultDoc.validateOnParse: \u003d true; <span> // analysera XMLDoc med hjälp av XSL-mall</span> XMLDoc.transformNodeToObject (XSLDoc, ResultDoc); <span> // Str-variabeln tilldelas ett textvärde</span>
<span> // av det resulterande dokumentet.</span> Str: \u003d ResultDoc.text; <span> // hitta element</span> FNode: \u003d r.SelectSingleNode ("// InvoiceNumber"); <span> // och få elementvärdet</span> parm: \u003d FNode.text; <span> // stäng begäran om åtkomst</span> Fråga. Stäng; Query.Text: \u003d Str; <span> // tilldelning av parametervärde</span> Query.Params.AsString: \u003d parm; <span> // kör begäran</span> Query.ExecSQL; <b>slutet;</b>
<p>Hela höjdpunkten i tolkningen ligger i användningen av en XSL-mall, som genereras individuellt för varje typ av dokument. Resultatet av analysering är en SQL-frågesträng. Därefter kommer körningen av den genererade SQL-frågesträngen att göra nödvändiga dataändringar i DBMS.</p>
<p>Fördelen med att analysera genom en mall är också att du får någon form av dataflexibilitet och att du får algoritmens fullständiga oberoende från programkoden. Nedan visas texten i XSL-mallen som används för att behandla ett BESTÄLLNINGsdokument:</p><p>
<!-- файл Order.xsl -->
<xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl">
<xsl:template match="/">
<xsl:for-each select="//header"> INSÄTT i TABREG (FRÅN, TILL, TYPEDOC, kropp) VÄRDEN (" <xsl:value-of select="from" />",
"<xsl:value-of select="to" />",
"<xsl:value-of select="TypeDocument/@id" />")
</xsl:for-each>
<xsl:for-each select="//item"> INSERT in GOODS (invoiceNumber, name, price, quality) VALUES (": num", " <xsl:value-of select="name" />",
"<xsl:value-of select="price" />",
"<xsl:value-of select="quality" />
")
</xsl:for-each>
</xsl:template>
</xsl:stylesheet>
</p><p>Förklara exemplet ovan bör det noteras att användningen av ett par taggar är formell till sin natur, eftersom efter analysering måste det resulterande XML-dokumentet formellt innehålla minst en nod. ResultDoc.text-metoden tilldelar textvärdet för ResultDoc som erhållits under analysering av XML-dokumentet. I det här fallet är värdet allt som är inramat av ett par taggar och, dvs. SQL-frågan vi genererade.</p>
<p>En annan funktion för att skriva programmet bör noteras möjligheten att använda SQL-parametern <b>: num.</b> Att använda parametern förenklar texten i xsl-mallen. Definitionen av värdet på motsvarande element i XML-dokumentets noder bestäms initialt av valet med namnet på motsvarande nod, till exempel:</p><h2>XSL i korthet</h2>
<p>XSL är en akronym härledd från eXtensible Stylesheet Language, ett formatformatspråk (XML-data). Som du kan se i rubriken används eXtensible Stylesheet Language (XSL) för att formatera XML-data. Per definition består W3C XSL av två delar:</p>
<ul><li>XSLT - XSL-transformation. Språket som används för att transformera eller formatera (transformera) XML-dokument. Således, med hjälp av XSLT, kan vi få olika nedskärningar av en uppsättning data och former för datapresentation.</li><li>Formateringselement. Dessa element inkluderar alla typografiska element i data efter att ha bearbetat dem med XSL. Används endast för att generera HTML-sidor.</li>
</ul><p>Med hjälp av XSLT kan vi välja de data vi behöver från en XML-fil och ordna dem i ett formulär för presentation för användaren. I vårt fall har vi till exempel transformerat XML-data i form av en SQL-fråga. Den klassiska användningen av XSL är vanligtvis att formatera data i form av HTML-sidor eller, mer sällan, i form av RTF-filer.</p>
<p>XSL-filen beskriver en mall, enligt vilken omvandlingen av XML-data kommer att utföras. Återgå till xsl-mallar kan följande element (direktiv) särskiljas i XSLT:</p>
<table cellspacing="0" cellpadding="4" width="500" border="1"><tbody><tr><td valign="top" width="31%"> <b>XSL-direktiv</b>
</td><th align="middle" width="69%"> <b>beskrivning</b>
</th>
</tr><tr><td>xsl: tillämpa-mallar</td>
<td>Ett direktiv som anger användningen av matchande mallar för attributet select \u003d "mallnamn"</td>
</tr><tr><td>xsl: attribut</td>
<td>skapar ett attributträd och lägger till det i utgångselementet, parameternamn \u003d "attributnamn", namespace är ett namnområde-URI (namespace-prefix)</td>
</tr><tr><td>xsl: samtalsmall</td>
<td>ringer en mall, attributnamn \u003d "URI till mall"</td>
</tr><tr><td>xsl: välj <br>xsl: när <br>xsl: annars</td>
<td>markering efter villkor xsl: när expr \u003d "utvärdering av uttryck i skript", <br>språk \u003d "språknamn" <br>test \u003d "utvärderat uttryck"</td>
</tr><tr><td>xsl: kommentar</td>
<td>genererar en kommentar i utdatadokumentet</td>
</tr><tr><td>xsl: kopiera <br>xsl: kopia av</td>
<td>kopierar den aktuella noden till utgångskällan eller infogar ett dokumentfragment i noden där select attribute \u003d "källnodnamn"</td>
</tr><tr><td>xsl: element</td>
<td>skapar ett utdataelement med namn, attributnamn \u003d "elementnamn", namnområde \u003d "uri-namnområdesreferens"</td>
</tr><tr><td>xsl: för varje</td>
<td>tillämpar mallen igen på alla noder i nodlistan, attributet select specificerar listan med noder</td>
</tr><tr><td>xsl: om</td>
<td>villkorskontroll, ställt in av testattributet som ett uttryck</td>
</tr><tr><td>xsl: inkludera</td>
<td>inkluderar extern mall, attribut href \u003d "URI-referens"</td>
</tr><tr><td>xsl: utdata</td>
<td>anger utdata, metodattributet kan vara "xml", "html" eller "text"</td>
</tr><tr><td>xsl: param</td>
<td>anger parametrarnas värde, attributnamn \u003d "parameternamn", välj \u003d "värde"</td>
</tr><tr><td>xsl: bearbetningsinstruktion</td>
<td>skapar en bearbetningsinstruktion, attributnamn \u003d "processinstruktionsnamn"</td>
</tr><tr><td>xsl: sortera</td>
<td>sorterar uppsättning noder, attribut select \u003d "nodnamn", datatyp \u003d datatyp ("text" | "nummer" | Qname), ordning \u003d sorteringsriktning ("stigande" | "fallande")</td>
</tr><tr><td>xsl: formatmall</td>
<td>definierar ett xsl-malldokument, är rotelementet för XSLT</td>
</tr><tr><td>xsl: mall</td>
<td>definierar xsl-mall, attributnamn \u003d "URI-prefix till mallnamnet", match \u003d "en indikation på den nod som mallen tillämpas på"</td>
</tr><tr><td>xsl: text</td>
<td>genererar text till utgångsströmmen, attribut disable-output-escaping \u003d "ja" eller "nej", indikerar möjligheten att generera ESC-tecken</td>
</tr><tr><td>xsl: värde-av</td>
<td>infogar värdet för den valda noden som text, attribut select \u003d "pekare till nod" från vilken värdet tas</td>
</tr><tr><td>xsl: variabel</td>
<td>anger värdet på variabla gränser, attributnamn \u003d "variabelnamn", välj \u003d "beräkning av variabelvärde"</td>
</tr><tr><td>xsl: med-param</td>
<td>tillämpar en parameter på mallen, attributnamn \u003d "parameternamn", välj \u003d uttryck för att utvärdera det aktuella sammanhanget, standardvärde "."</td>
</tr></tbody></table><h2>Slutsats</h2>
<p>Slutligen bör det noteras att använda standard XML-parser <i>msxml.dll</i>är inte det enda verktyget för att analysera och skapa XML-dokument. Till exempel, för att skapa XML-dokument effektivt använda komponenterna <b>TPageProduser</b>och <b>TableProduser</b>... Men den här artikeln betonar bara bredden och användbarheten av DOM-modellen i praktiken.</p>
<p>Författaren kommer att vara mycket tacksam för feedback om ämnets relevans, allmänna innehåll, presentationsstil, liksom alla andra kommentarer som hjälper till att ytterligare förbättra kvaliteten på att skriva en samling artiklar och släppa en bok som täcker ämnet av den praktiska sidan av att använda XML-dokument i e-handel. Mer detaljerad information om den praktiska sidan av att använda elektroniska dokument finns på författarens webbplats www.eDocs.al.ru Även på författarens webbplats är det planerat att placera källtexter och exempel.</p>
<p>För många Delphi-programmerare är spara inställningar associerade med användning <i>INI</i> filer i sina program. Användningen av denna metod i mer eller mindre allvarliga projekt bör undvikas, eftersom den begränsar flexibiliteten, vilket förhindrar ytterligare expansion av programmet. Det bör sägas att detta tillvägagångssätt är ganska populärt på grund av dess användarvänlighet och förekomsten av inbyggda verktyg i utvecklingsmiljön. <br><br> Det idealiska alternativet för lagring av programinställningar är dock strukturerat <i>XML</i> filer. Deras fördel är att antalet parametrar kanske inte är fasta. För att förstå detta bättre, överväg ett specifikt exempel.</p><p>I USearch-programmet, när du klickar på en post, visas en snabbmeny som visar en lista med objekt. Dessa objekt är kommandon som i sin tur laddas från inställningsfilen. Om inställningarna sparades i <i>INI</i> filen kan spara och ladda ett visst antal kommandon, till exempel 10 eller 50. Så snart ett större värde krävs måste du skriva om koden och kompilera den därefter.</p><p><img src='https://i0.wp.com/zoo-mania.ru/wp-content/uploads/2011/08/settings.ini_.jpg' height="145" width="247" loading=lazy><br> Tillämpa ett tillvägagångssätt med <i>XML</i> filer kommer vi att kunna ladda alla sektionsparametrar dynamiskt. Dessutom kommer konfigurationsfilen att vara elegantare utan redundant parameternummerering. Men standardverktygen för att arbeta med <i>XML</i> Delphi har många nackdelar, så jag rekommenderar att du använder standardbiblioteket <b>MSXML</b>... Vanligtvis ingår det som standard i Windows-operativsystemen.</p><p><img src='https://i2.wp.com/zoo-mania.ru/wp-content/uploads/2011/08/settings.xml_.jpg' align="center" width="100%" loading=lazy><br> Att ansluta <b>MSXML</b>måste vi skapa en gränssnittsfil med en lista över alla funktioner genom att importera den från COM-servern. Många detaljerade artiklar har skrivits om hur man importerar gränssnittet, men jag föreslår att du laddar ner filen <b>MSXML2_TLB.PAS</b> redo att använda. När filen har laddats ner placerar du den bredvid ditt projekt eller släpper den i lib-mappen i Delphi-miljön. Således kommer alla skapade program att kunna använda modulen <b>MSXML</b>, du behöver bara lägga till MSXML2_TLB-raden till användningen.</p><p>För tydlighetens skull överväga följande exempel på hur du använder detta bibliotek:</p><p>Procedur LoadData; var XMLDoc: DOMDocument; Rot: IXMLDOMElement; börja XMLDoc: \u003d CoDOMDocument.Create; XMLDoc.Load ("settins.xml"); Rot: \u003d XMLDoc.DocumentElement; ShowMessage (Root.SelectSingleNode ("storlek / bredd"). Text); Rot: \u003d noll; XMLDoc: \u003d noll; slutet;</p><p>Först skapas en instans av DOMDocument-klassen, varefter innehållet i filen settings.xml laddas in i minnet. Eftersom enligt standarden någon <i>XML</i> filen måste innehålla root-taggen (i det här fallet <i>config</i>), då måste vi hämta det med funktionen <i>DocumentElement</i>... Sedan visas innehållet mellan taggarna <width></width> , som i sin tur är mellan taggar <size></size> ... Således kommer vår metod från filen settings.xml att visa texten i MessageBox <i>"100px"</i>.</p><p>
<?xml version="1.0" encoding="utf-8"?>
<config>
<size>
<height>500px</height>
<width>100 pixlar</width>
</size>
</config>
</p><p>Här tillämpas SelectSingleNode-metoden, som tar en sträng som parameter</p>
<p>BESTÄLL EN LÖSNING TILL DELPHI <br> Delphi är det näst viktigaste programmeringsspråket som studenterna ofta introduceras till i inlärningsprocessen. Detta är början på att lära sig om objektorienterad programmering. Som student kom jag fram till att det inte finns någon enklare metod att lära sig ett språk än att skriva en miniräknare i det. Även om du implementerar en rudimentär funktion för att lägga till två siffror kommer det att kasta ljus på mycket.</p>
<p>CodeGaear, Delphi 7, Lazarus är olika kompilatorer, program som överför koden du har skrivit till maskinen och konverterat den till en och en. Dessa är alla program för att skapa program, inte separata programmeringsspråk. Dessa kompilatorer använder programmeringsspråket Object Pascal, som är grunden för Delphi-språket, som liknar vanlig Pascal i syntax men skiljer sig funktionellt väsentligt. <br></p>
<h2>Vad är syntaxen för ett programmeringsspråk?</h2>
<p>Detta är formatet för att skriva olika operatörer. Till exempel har en Pascal for loop följande format: för n: \u003d 1 till k do, och så vidare.</p><p>I programmeringsspråket C ++ skrivs samma slinga lite annorlunda: för (n \u003d 1; n Vi skriver en räknare</p><p>Detta ger dig en förståelse för hur objekt interagerar med programkoden, vilka "variabler" är, hur matematiska funktioner fungerar. All programmering kommer ändå att vara en beräkning. Ett spel är också ett program som ständigt beräknar något, fungerar med siffror och numeriska funktioner. Programmering är oskiljaktig från matematik.</p>
<p>Låt oss använda utvecklingsmiljön Lazarus för att skriva. Dess funktionalitet är inte lika rik som till exempel CodeGear, men den är fritt tillgänglig och är avsedd för träning.</p><p>När vi öppnar utvecklingsmiljön ser vi formuläret och verktygslådan. Här är formuläret.</p>
<p><img src='https://i0.wp.com/reshatel.org/wp-content/uploads/2018/09/Bez-imeni-24.jpg' width="100%" loading=lazy></p><p>Här är verktygslådan.</p><p>Det första vi ska göra är att lägga till de tre elementen vi behöver för att implementera funktionen för att lägga till två nummer. Vi behöver: "Tedit" i mängden av tre stycken och "TButton". På bilden nedan visas de på panelen med pilar. Vi klickar på dem en gång och sedan en gång på formuläret och de visas på den.</p><p>Dessa är textfält för inmatning och en vanlig knapp. Du stöter på dessa element med nästan alla Windows-program. Ta en titt.</p><p><img src='https://i0.wp.com/reshatel.org/wp-content/uploads/2018/09/Bez-imeni-27.jpg' width="100%" loading=lazy><br></p>
<p>Låt oss nu rensa dessa etiketter. Klicka på fliken "Visa". Och klicka på objektet "Objektinspektör. Ett fönster som detta visas.</p><p><img src='https://i0.wp.com/reshatel.org/wp-content/uploads/2018/09/Bez-imeni-28.jpg' width="100%" loading=lazy></p><p>Vi klickar en gång på vårt "Button" -element i formuläret och ändrar "Caption" -värdet i inspektörsfönstret till något annat. Till exempel ordet "Ok". Vi trycker på Enter. Vi ser på formuläret hur elementet har ändrat namn.</p><p>Låt oss göra detsamma med Edit, bara byt inte namn på dem utan gör dem utan något innehåll. Markera dem en efter en och rensa textvärdet i inspektören. Glöm inte att trycka på Enter.</p><p><img src='https://i0.wp.com/reshatel.org/wp-content/uploads/2018/09/Bez-imeni-29.jpg' width="100%" loading=lazy></p><p>Som ett resultat ser vårt formulär ut så här.</p><p><img src='https://i0.wp.com/reshatel.org/wp-content/uploads/2018/09/Bez-imeni-30.jpg' width="100%" loading=lazy><br></p>
<p>För att vår miniräknare ska fungera måste du skriva den nödvändiga programkoden för proceduren för vår knapp. Klicka två gånger på knappelementet och öppna källredigeraren.</p><p><img src='https://i1.wp.com/reshatel.org/wp-content/uploads/2018/09/Bez-imeni-31.jpg' width="100%" loading=lazy></p><p>Ser? Procedurknapp 1Klicka. Detta är proceduren som är ansvarig för vad som händer när vi klickar på knappen en gång. Och följande bör hända: programmet måste visa summan av siffrorna som anges i de två första fälten i den tredje redigeringen. Vi skriver koden.</p><p><img src='https://i2.wp.com/reshatel.org/wp-content/uploads/2018/09/Bez-imeni-32.jpg' width="100%" loading=lazy></p><p>Vi måste skriva så enkla 5 rader kod. Kommentarer och förklaringar kan ses på bilden ovan. Därefter trycker vi på den här knappen.</p>
<p>Vårt projekt kommer att sammanställas. Den kommer att sammanställas i ett program. Ange siffrorna i de två första fälten, klicka på knappen och få summan.</p><p><img src='https://i0.wp.com/reshatel.org/wp-content/uploads/2018/09/Bez-imeni-34-2.jpg' width="100%" loading=lazy></p>
<h2>Slutsats</h2>
<p>Du kan klicka på "File" -knappen, sedan "Save All", välja en mapp som du vill spara och du kommer att ha ett fullfjädrat program som kan startas från skrivbordet. Försök nu att räkna ut själv vad du behöver skriva om i den här koden så att programmet delar upp två nummer och inte lägger till. Tips: du måste ändra datatypen. Videon nedan visar ett liknande exempel, men i Delphi 7-miljön, inte Lazarus.</p><p><span class="6qR5tjJKK3g"></span></p>
<script>document.write("<img style='display:none;' src='//counter.yadro.ru/hit;artfast_after?t44.1;r"+
escape(document.referrer)+((typeof(screen)=="undefined")?"":
";s"+screen.width+"*"+screen.height+"*"+(screen.colorDepth?
screen.colorDepth:screen.pixelDepth))+";u"+escape(document.URL)+";h"+escape(document.title.substring(0,150))+
";"+Math.random()+
"border='0' width='1' height='1' loading=lazy>");</script>
</div>
</div>
</div>
</div>
<aside class="col-lg-4 col-md-12 col-md-offset-4 col-lg-offset-0" id="right">
<div>
</div>
<br/>
<div>
</div>
<br/>
<div>
</div>
<br/>
<div>
</div>
<br/>
</aside>
</div>
</div>
</div>
<div class="popup" id="share">
<div class="perfect-scroll" style="text-align: center">
<div style="margin-bottom: 20px">
<strong> Nedladdningen börjar nu ...</strong>
<br> Glöm inte att dela material <br>på sociala nätverk med din <br> kollegor</div>
<div>
<div class="ya-share2" data-services="vkontakte,facebook,odnoklassniki,moimir,gplus" data-counter=""></div>
</div>
</div>
<div class="close-pop pull-right">
<svg width="10px" height="10px" viewBox="0 0 10 10">
<path fillrule="evenodd"
d="M 6.41 5C 6.41 5 9.24 7.83 9.24 7.83 9.63 8.22 9.63 8.85 9.24 9.24 8.85 9.63 8.22 9.63 7.83 9.24 7.83 9.24 5 6.41 5 6.41 5 6.41 2.17 9.24 2.17 9.24 1.78 9.63 1.15 9.63 0.76 9.24 0.37 8.85 0.37 8.22 0.76 7.83 0.76 7.83 3.59 5 3.59 5 3.59 5 0.76 2.17 0.76 2.17 0.37 1.78 0.37 1.15 0.76 0.76 1.15 0.37 1.78 0.37 2.17 0.76 2.17 0.76 5 3.58 5 3.58 5 3.58 7.83 0.76 7.83 0.76 8.22 0.37 8.85 0.37 9.24 0.76 9.63 1.15 9.63 1.78 9.24 2.17 9.24 2.17 6.41 5 6.41 5Z"></path>
</svg>
</div>
</div>
<section id="views">
<div class="container">
</div>
</section>
<script type="text/javascript">
$(document).ready(
function () {
$('.kursiv').readmore({
speed: 75,
maxHeight: 84,
heightMargin: 16,
moreLink: '<a href="#"><span>Показать полностью</span>',
lessLink: '<a href="#"><span>Скрыть</span></a>',
} );
} );
</script>
<style>
div.kursiv {
margin-bottom: 0;
}
#razrabotka {
margin-top: 30px;
}
.readmore-js-toggle {
font-style: italic;
color: #999;
display: inline;
margin-right: 10px;
font-size: 14px;
cursor: pointer;
border-bottom: 1px dotted #e6e6e6;
}
</style></section>
<footer>
<div class="container">
<div class="row">
<div class="col-xs-16 col-sm-4 col-md-3">
<p>© 2021, mkr-novo2.ru, Internet. Utbildning. Program. Firmware. Installation och konfiguration. Navigatorer</p>
<div class="social">
<a target="_blank" href="">
<svg width="32px" height="19px" viewBox="0 0 32 19">
<path fillRule="evenodd"
d="M 15.36 18.01C 15.36 18.01 17.24 18.01 17.24 18.01 17.24 18.01 17.81 17.94 18.1 17.64 18.36 17.37 18.35 16.85 18.35 16.85 18.35 16.85 18.32 14.41 19.49 14.05 20.64 13.7 22.12 16.4 23.69 17.45 24.87 18.23 25.77 18.06 25.77 18.06 25.77 18.06 29.97 18.01 29.97 18.01 29.97 18.01 32.16 17.87 31.12 16.21 31.03 16.07 30.51 14.97 28 12.72 25.37 10.35 25.72 10.74 28.89 6.65 30.82 4.16 31.59 2.65 31.35 2 31.12 1.38 29.7 1.54 29.7 1.54 29.7 1.54 24.98 1.57 24.98 1.57 24.98 1.57 24.63 1.52 24.37 1.67 24.12 1.82 23.95 2.16 23.95 2.16 23.95 2.16 23.21 4.09 22.21 5.72 20.11 9.18 19.27 9.36 18.92 9.15 18.12 8.65 18.32 7.14 18.32 6.07 18.32 2.72 18.85 1.32 17.3 0.96 16.79 0.84 16.41 0.76 15.1 0.75 13.41 0.73 11.99 0.76 11.18 1.14 10.64 1.39 10.23 1.96 10.48 1.99 10.79 2.03 11.5 2.18 11.88 2.67 12.36 3.31 12.34 4.74 12.34 4.74 12.34 4.74 12.62 8.68 11.69 9.17 11.06 9.5 10.18 8.82 8.31 5.68 7.35 4.08 6.62 2.3 6.62 2.3 6.62 2.3 6.48 1.97 6.23 1.8 5.93 1.58 5.51 1.51 5.51 1.51 5.51 1.51 1.02 1.54 1.02 1.54 1.02 1.54 0.35 1.56 0.1 1.84-0.12 2.09 0.08 2.62 0.08 2.62 0.08 2.62 3.6 10.57 7.57 14.57 11.22 18.25 15.36 18.01 15.36 18.01 15.36 18.01 15.36 18.01 15.36 18.01Z"/>
</svg>
</a>
<a target="_blank" href="">
<svg viewBox="0 0 25 25" width="25px" height="25px">
<path class="st0" d="M12.5,12.7c3.2,0,5.8-2.6,5.8-5.8c0-3.2-2.6-5.8-5.8-5.8C9.3,1,6.7,3.6,6.7,6.8C6.7,10,9.3,12.7,12.5,12.7z
M12.5,3.9c1.6,0,2.9,1.3,2.9,2.9c0,1.6-1.3,2.9-2.9,2.9c-1.6,0-2.9-1.3-2.9-2.9C9.6,5.2,10.9,3.9,12.5,3.9z M19.2,13.4
c-0.3-0.7-1.2-1.2-2.5-0.3c-1.6,1.3-4.3,1.3-4.3,1.3s-2.6,0-4.3-1.3c-1.2-1-2.1-0.4-2.5,0.3c-0.6,1.2,0.1,1.7,1.5,2.7
c1.3,0.8,3,1.1,4.1,1.2l-0.9,0.9c-1.3,1.3-2.6,2.6-3.4,3.4c-0.5,0.5-0.5,1.4,0,1.9l0.2,0.2c0.5,0.5,1.4,0.5,1.9,0l3.4-3.4
c1.3,1.3,2.6,2.6,3.4,3.4c0.5,0.5,1.4,0.5,1.9,0l0.2-0.2c0.5-0.5,0.5-1.4,0-1.9l-3.4-3.4l-0.9-0.9c1.1-0.1,2.8-0.4,4.1-1.2
C19.2,15.1,19.8,14.5,19.2,13.4z"/>
</svg>
</a>
<a target="_blank" href="https://facebook.com/">
<svg width="26px" height="25px" viewBox="0 0 26 25">
<path fillRule="evenodd"
d="M 24.33-0C 24.33-0 1.96-0 1.96-0 1.19-0 0.57 0.62 0.57 1.38 0.57 1.38 0.57 23.62 0.57 23.62 0.57 24.38 1.19 25 1.96 25 1.96 25 14 25 14 25 14 25 14 15.32 14 15.32 14 15.32 10.72 15.32 10.72 15.32 10.72 15.32 10.72 11.54 10.72 11.54 10.72 11.54 14 11.54 14 11.54 14 11.54 14 8.76 14 8.76 14 5.53 15.98 3.77 18.88 3.77 20.27 3.77 21.46 3.88 21.81 3.92 21.81 3.92 21.81 7.3 21.81 7.3 21.81 7.3 19.8 7.3 19.8 7.3 18.22 7.3 17.92 8.04 17.92 9.13 17.92 9.13 17.92 11.54 17.92 11.54 17.92 11.54 21.68 11.54 21.68 11.54 21.68 11.54 21.19 15.32 21.19 15.32 21.19 15.32 17.92 15.32 17.92 15.32 17.92 15.32 17.92 25 17.92 25 17.92 25 24.33 25 24.33 25 25.09 25 25.71 24.38 25.71 23.62 25.71 23.62 25.71 1.38 25.71 1.38 25.71 0.62 25.09-0 24.33-0Z"/>
</svg>
</a>
<a target="_blank" href="https://youtube.com/">
<svg width="26px" height="19px" viewBox="0 0 26 19">
<path fillRule="evenodd"
d="M 25.75 14.46C 25.75 14.46 25.5 16.18 24.75 16.93 23.79 17.92 22.72 17.93 22.23 17.99 18.71 18.24 13.43 18.25 13.43 18.25 13.43 18.25 6.89 18.19 4.88 18 4.32 17.89 3.06 17.92 2.11 16.93 1.35 16.18 1.11 14.46 1.11 14.46 1.11 14.46 0.86 12.45 0.86 10.44 0.86 10.44 0.86 8.55 0.86 8.55 0.86 6.54 1.11 4.52 1.11 4.52 1.11 4.52 1.35 2.81 2.11 2.05 3.06 1.06 4.14 1.06 4.63 1 8.15 0.75 13.42 0.75 13.42 0.75 13.42 0.75 13.43 0.75 13.43 0.75 13.43 0.75 18.71 0.75 22.23 1 22.72 1.06 23.79 1.06 24.75 2.05 25.5 2.81 25.75 4.52 25.75 4.52 25.75 4.52 26 6.54 26 8.55 26 8.55 26 10.44 26 10.44 26 12.45 25.75 14.46 25.75 14.46ZM 10.83 5.73C 10.83 5.73 10.83 12.72 10.83 12.72 10.83 12.72 17.62 9.24 17.62 9.24 17.62 9.24 10.83 5.73 10.83 5.73Z"/>
</svg>
</a>
</div>
</div>
<div class="col-lg-2 col-sm-4 col-xs-16 links">
<h4>mkr-novo2.ru</h4>
<a href="https://mkr-novo2.ru/sv/category/internet/">Internet</a>
<a href="https://mkr-novo2.ru/sv/category/multimedia/">Multimedia</a>
<a href="https://mkr-novo2.ru/sv/category/navigation/">Navigatorer</a>
<a href="https://mkr-novo2.ru/sv/category/education/">Utbildning</a>
<a href="https://mkr-novo2.ru/sv/category/at/">FÖRBI</a>
<a href="https://mkr-novo2.ru/sv/category/problems/">Problem</a>
</div>
<div class="col-lg-2 col-sm-3 col-xs-16 links">
<h4>om projektet</h4>
<a href="">Respons</a>
<a href="">Om webbplatsen</a>
</div>
<div class="col-lg-5 col-sm-1 col-xs-16 links"></div>
<div class="col-lg-4 col-sm-5 col-xs-16 links">
</div>
</div>
<div class="row v-center">
<div class="col-md-8 col-xs-16">
<a data-fancybox data-type="iframe" data-src="">Kontakter</a>
</div>
<div class="col-md-8 col-xs-16">
<div class="share pull-right">
<script type="text/javascript" src="//yastatic.net/es5-shims/0.0.2/es5-shims.min.js" charset="utf-8"></script>
<script type="text/javascript" src="//yastatic.net/share2/share.js" charset="utf-8"></script>
<div class="ya-share2" data-services="vkontakte,facebook,odnoklassniki,moimir,gplus" data-counter=""></div>
</div>
</div>
</div>
</div>
</footer>
<a href="https://mkr-novo2.ru/sv/#bot" id="to-top">
<svg width="50px" height="50px" viewBox="0 0 50 50">
<circle cx="25.00" cy="25.00" r="25.00" fill="rgb(0,0,0)" opacity="0.37"/>
<path fillRule="evenodd"
d="M 33.94 24.46C 33.94 24.46 25.89 16.3 25.89 16.3 25.32 15.73 24.41 15.73 23.84 16.3 23.84 16.3 15.79 24.46 15.79 24.46 14.88 25.38 15.52 26.97 16.81 26.97 16.81 26.97 20.43 26.97 20.43 26.97 21.23 26.97 21.88 27.62 21.88 28.43 21.88 28.43 21.88 32.51 21.88 32.51 21.88 33.71 22.83 34.68 24.01 34.68 24.01 34.68 25.72 34.68 25.72 34.68 26.9 34.68 27.86 33.71 27.86 32.51 27.86 32.51 27.86 28.43 27.86 28.43 27.86 27.62 28.5 26.97 29.31 26.97 29.31 26.97 32.92 26.97 32.92 26.97 34.21 26.97 34.85 25.38 33.94 24.46Z"
fill="rgb(241,241,241)"/>
</svg>
</a>
<div class="overlay"></div>
<div class="popup" id="password">
<div class="perfect-scroll">
<h2>Återställning av lösenord <div class="close-pop pull-right">
<svg width="10px" height="10px" viewBox="0 0 10 10">
<path fillRule="evenodd"
d="M 6.41 5C 6.41 5 9.24 7.83 9.24 7.83 9.63 8.22 9.63 8.85 9.24 9.24 8.85 9.63 8.22 9.63 7.83 9.24 7.83 9.24 5 6.41 5 6.41 5 6.41 2.17 9.24 2.17 9.24 1.78 9.63 1.15 9.63 0.76 9.24 0.37 8.85 0.37 8.22 0.76 7.83 0.76 7.83 3.59 5 3.59 5 3.59 5 0.76 2.17 0.76 2.17 0.37 1.78 0.37 1.15 0.76 0.76 1.15 0.37 1.78 0.37 2.17 0.76 2.17 0.76 5 3.58 5 3.58 5 3.58 7.83 0.76 7.83 0.76 8.22 0.37 8.85 0.37 9.24 0.76 9.63 1.15 9.63 1.78 9.24 2.17 9.24 2.17 6.41 5 6.41 5Z"/>
</svg>
</div>
</h2>
<div class="recover-success">
<form action="/recovery/request" data-method="post" method="post" class="recover_form">
<p>Ange din e-postadress för att återställa ditt lösenord!</p>
<div class="input-wrp">
<input name="email" type="text" placeholder="Skriv in din e-postadress">
</div>
<input type="submit" data-disable-with="Отправить..." class="btn green" value="Skicka meddelande">
</form>
</div>
<div class="auth-form_error" style="padding-top: 10px"></div>
</div>
</div>
<script>
$('.user.one').click(function (e, ob) {
$('.user').removeClass('active-user');
$('.user.one').addClass('active-user');
$('#user_type').val('1');
e.stopPropagation();
} );
$('.user.two').click(function (e, ob) {
$('.user').removeClass('active-user');
$('.user.two').addClass('active-user');
$('#user_type').val('2');
e.stopPropagation();
} );
$('.user.three').click(function (e, ob) {
$('.user').removeClass('active-user');
$('.user.three').addClass('active-user');
$('#user_type').val('3');
e.stopPropagation();
} );
function clearErrors() {
$('.auth-form_error').each(function () {
$(this).html('');
} );
}
$('body').on('click', '.open-login-form', function (e) {
$('#register, .overlay').removeClass('visible-pop');
$('#login, .overlay').addClass('visible-pop');
e.preventDefault();
} );
$('body').on('click', '.open-pass-form', function (e) {
$('#register, .overlay').removeClass('visible-pop');
$('#password, .overlay').addClass('visible-pop');
e.preventDefault();
} );
$('.login_form')
.on('ajax:beforeSend', function (event, xhr, settings) {
clearErrors();
} )
.on('ajax:complete', function (event, xhr, status) {
} )
.on('ajax:success', function (event, data, status, xhr) {
if (data.status == 0) {
$('.auth-form_error').html(data.text + '<br>');
} else {
$('.open-register').html(data.text);
var delay = 1000;
window.location.href = url = window.location.href + "?login=ok";
location.replace(url);
setTimeout('window.location.reload(true);', delay);
}
} ).on('ajax:error', function (event, xhr, status, error) {
} );
$('.recover_form')
.on('ajax:beforeSend', function (event, xhr, settings) {
clearErrors();
} )
.on('ajax:complete', function (event, xhr, status) {
} )
.on('ajax:success', function (event, data, status, xhr) {
console.log(data);
if (data.status == 0) {
$('.auth-form_error').html(data.text + '<br>');
} else {
$('.recover-success').html('<div class="success" >' + data.text + '</div>');
}
} ).on('ajax:error', function (event, xhr, status, error) {
} );
$('.registration_form')
.on('ajax:beforeSend', function (event, xhr, settings) {
var emailError = $('#emailError');
var passwordError = $('#passwordError');
var passwordVerify = $('#passwordVerifyError');
var userTypeError = $('#userTypeError');
var emailExist = $('#emailExist');
emailError.html('');
passwordError.html('');
passwordVerify.html('');
userTypeError.html('');
emailExist.hide();
} )
.on('ajax:complete', function (event, xhr, status) {
} ).on('ajax:success', function (event, data, status, xhr) {
// insert the failure message inside the "#account_settings" element
//console.log(data);
if (data.status == 0) {
//$('.reg-info').html('<div class="error">' + data.text + '</div>');
if (data.text.email) {
var emailError = $('#emailError');
var emailExist = $('#emailExist');
console.log(data.text.email);
if (data.text.email == 'Найдена совпадающая со значением запись') {
console.log('alert');
emailExist.show();
} else {
emailError.html('<i class="icon-error"></i><div class="error_note_wrapper">' +
'<div class="error_note">' +
'<span class="error_note_text">' + data.text.email + '</span></div></div>');
}
}
if (data.text.password) {
var passwordError = $('#passwordError');
console.log(data.text.password);
passwordError.html('<i class="icon-error"></i><div class="error_note_wrapper">' +
'<div class="error_note">' +
'<span class="error_note_text">' + data.text.password + '</span></div></div>');
}
if (data.text.passwordVerify) {
var passwordVerify = $('#passwordVerifyError');
console.log(data.text.passwordVerify);
passwordVerify.html('<i class="icon-error"></i><div class="error_note_wrapper">' +
'<div class="error_note">' +
'<span class="error_note_text">' + data.text.passwordVerify + '</span></div></div>');
}
if (data.text.captcha) {
var captcha = $('#captchaError');
console.log(data.text.captcha);
captcha.html('<i class="icon-error"></i><div class="error_note_wrapper">' +
'<div class="error_note">' +
'<span class="error_note_text">' + data.text.captcha + '</span></div></div>');
}
if (data.text.userType) {
var user_type = $('#userTypeError');
console.log(data.text.userType);
user_type.html('<i class="icon-error"></i><div class="error_note_wrapper">' +
'<div class="error_note">' +
'<span class="error_note_text">' + data.text.userType + '</span></div></div>');
}
} else {
$('.reg-success').html(data.text);
var delay = 2000;
window.location.href = url = window.location.href + "?reg=ok";
location.replace(url);
setTimeout('window.location.reload(true);', delay);
}
} ).on('ajax:error', function (event, xhr, status, error) {
} );
</script>
<div class="popup" id="premium-pop">
</div>
<link rel="stylesheet" href="/videouroki/res/lightslider/lightslider.min.css">
<link rel="stylesheet" href="/videouroki/res/perfectScrollbar/perfect-scrollbar.css">
<link rel="stylesheet" href="/videouroki/assets/font-awesome/css/font-awesome.min.css">
<link rel="stylesheet" href="/assets/vendor/fancybox/jquery.fancybox.min.css">
<script src="/videouroki/res/perfectScrollbar/perfect-scrollbar.jquery.min.js"></script>
<script src="/js/rails.js"></script>
<script src="/videouroki/res/lightslider/lightslider.min.js"></script>
<script src="/videouroki/res/jquery.validate.min.js"></script>
<script src="/videouroki/res/autosize-master/autosize.min.js"></script>
<script src="/videouroki/js/tabs.js"></script>
<script src="/videouroki/js/select.js"></script>
<script src="/videouroki/js/global.js?2109"></script>
<script src="/videouroki/js/views.js"></script>
<script src="/videouroki/plugin/notify/notify.min.js"></script>
<script src="/videouroki/plugin/notify/notify-metro.js"></script>
<script src="/videouroki/js/lazyload.min.js"></script>
<script src="/assets/vendor/fancybox/jquery.fancybox.min.js"></script>
<script type="text/javascript">
$(document).ready(
function () {
// new LazyLoad();
} )
</script>
<!--[if gte IE 9]><script type="text/javascript" src="/videouroki/assets/ckeditor-mini/ckeditor.js"></script><![endif]-->
<script type="text/javascript" src="/videouroki/js/readmore.js"></script></body>
</html>
inmatning