[XML] Opmaak

[Verwijderd]

Graag hoor ik jullie mening over onderstaande manieren van opmaak. Welke prefereren jullie? En zijn er nog bepaalde richtlijnen voor de opmaak van een XML-bestand (qua netheid bedoel ik dan)?

XML:

<eten>
    <pizzas>
       <pizza>
             <id>1</id>
             <topping>kaas</topping>
        </pizza>
        <pizza>
            <id>2</id>
            <topping>salami</topping>
        </pizza>
    </pizzas>
</eten>

XML:

<eten>
    <pizzas>
       <pizza id="1">
             <topping>kaas</topping>
        </pizza>
        <pizza id="2">
            <topping>salami</topping>
        </pizza>
    </pizzas>
</eten>

XML:

<eten>
   <pizza>
         <id>1</id>
         <topping>kaas</topping>
    </pizza>
    <pizza>
        <id>2</id>
        <topping>salami</topping>
    </pizza>
</eten>

XML:

<eten>
    <pizza id="1">
        <topping>kaas</topping>
    </pizza>
    <pizza id="2">
        <topping>salami</topping>
    </pizza>
</eten>

[T.T.]

Dat hangt af van hoe vaak je data verandert en hoe je het gebruikt.

http://www.w3schools.com/xml/xml_attributes.asp

There are no rules about when to use attributes, and when to use child elements. My experience is that attributes are handy in HTML, but in XML you should try to avoid them. Use child elements if the information feels like data.

Some of the problems with using attributes are:

* attributes cannot contain multiple values (child elements can)
* attributes are not easily expandable (for future changes)
* attributes cannot describe structures (child elements can)
* attributes are more difficult to manipulate by program code
* attribute values are not easy to test against a Document Type Definition (DTD) - which is used to define the legal elements of an XML document

If you use attributes as containers for data, you end up with documents that are difficult to read and maintain. Try to use elements to describe data. Use attributes only to provide information that is not relevant to the data.

Don't end up like this ( if you think this looks like XML, you have not understood the point):

code:

<note day="12" month="11" year="2002"
to="Tove" from="Jani" heading="Reminder" 
body="Don't forget me this weekend!">
</note>

Rules always have exceptions.

My rule about attributes has one exception:

Sometimes I assign ID references to elements. These ID references can be used to access XML elements in much the same way as the NAME or ID attributes in HTML. This example demonstrates this:
The ID in these examples is just a counter, or a unique identifier, to identify the different notes in the XML file, and not a part of the note data.

What I am trying to say here is that metadata (data about data) should be stored as attributes, and that data itself should be stored as elements.

[ Voor 5% gewijzigd door T.T. op 02-06-2005 14:36 ]

[Verwijderd]

T.T. schreef op donderdag 02 juni 2005 @ 14:35:
Dat hangt af van hoe vaak je data verandert en hoe je het gebruikt.

http://www.w3schools.com/xml/xml_attributes.asp

[...]


[...]

code:

<note day="12" month="11" year="2002"
to="Tove" from="Jani" heading="Reminder" 
body="Don't forget me this weekend!">
</note>

[...]

Ok. Thanks! Duidelijk. Maar w.b.t. het definieren van 'pizza' binnen 'pizza's' zou ik ook graag nog een mening horen. Ikzelf vind het definieren van 'pizza' binnen 'pizza's' mooier staan, dan om 'pizza' los binnen 'eten' te plaatsen.

[ Voor 32% gewijzigd door Verwijderd op 02-06-2005 14:41 ]

[OkkE]

Ik zou persoonlijk manier 1 of 2 gebruiken. Inderdaad zou ik binnen <eten> ook nog een <pizzas> maken, en daarbinnen alle <pizza> zetten. Zonder echt een goede redenatie zou ik dan kiezen voor de 2e optie, dus <pizza id="1"> ipv de ID los. Het is meer een gevoel dan een logische redenatie btw.

// Edit

Even over het stukje van W3Schools icm <pizza id="1">

* attributes cannot contain multiple values (child elements can)
- Het ID is over het algemeen lijkt me alleen een getal, dus dan zou het prima kunnen als attribute.

* attributes are not easily expandable (for future changes)
- Ook geen probleem, want lijkt me sterk dat je zoiets constants als een ID gaat veranderen.

* attributes cannot describe structures (child elements can)
- ID's zijn alleen om records uniek te kunnen benaderen.

* attributes are more difficult to manipulate by program code
- Lijkt me dat je ID's ook niet eens wil aanpassen.

* attribute values are not easy to test against a Document Type Definition (DTD) - which is used to define the legal elements of an XML document
- Is zoiets nuttig in het geval van ID's?

[ Voor 62% gewijzigd door OkkE op 02-06-2005 14:50 ]

[T.T.]

Verwijderd schreef op donderdag 02 juni 2005 @ 14:40:
Ok. Thanks! Duidelijk. Maar w.b.t. het definieren van 'pizza' binnen 'pizza's' zou ik ook graag nog een mening horen. Ikzelf vind het definieren van 'pizza' binnen 'pizza's' mooier staan, dan om 'pizza' los binnen 'eten' te plaatsen.

Je moet niet kijken wat mooier staat, maar wat voor nut het heeft. Mocht je bijvoorbeeld behoefte hebben aan diverse groepen pizza's of aan bijvoorbeeld aan een hierarchie van eten. Misschien wil je apart pasta's onderscheiden.

[whoami]

Ff een linkje dat je misschien wel leuk vind:
[rml][ Discussie] Stelling: XML attributen zuigen![/rml]

[TheNameless]

Ik zou ook manier 2 gebruiken, vooral omdat het id de pizza indentificeert en een topping is een onderdeel van pizza. Maar het is wat je zelf beter/makkelijker/mooier vind.

Btw. als je XML schema's zou gebruiken i.p.v. een DTD worden attributen wel getest of ze legaal zijn. Kortom het is net waar je het XML bestand voor gaat gebruiken

[riezebosch]

Ja, nu komt bij mij ook de vraag op (nav dit): hoe lees je het uit als je alles in elementen stopt?

Ikzelf had in de vorige versie van een programma alle eigenschappen in attributen gestopt, en alleen subelementen als element. Bij het uitlezen hoefde ik me dan niet druk te maken over de volgorde en het afwisselen van subelementen en data.

Is hier een standaard oplossing voor, als je wel alles in elemtenten stop? Dat je bijvoorbeeld in een while-loopje uitlijst en dan in een switch bepaald wat je met het huidige element doet? Lijkt mij vrij omslachtig werken, maar goed...

Zoals ik het deed:

code:

<set name="set1" enabled="true">
   <script name="script1" enabled="true">
      <item left="10" top="11" width="50" heigh="12" />
      <item left="85" top="11" width="50" heigh="12" />
    </script>
   <script name="script2" enabled="true">
      <item left="60" top="11" width="50" heigh="12" />
    </script>
</set>

Met dan dit als code om het uit te lezen:

C#:

public set openSet(XmlReader xmlReader)
{
   set s = new set();
   s.name = xmlReader.GetAttribute("name");
   s.enabled = bool.Parse(xmlReader.GetAttribute("enabled");

   xmlReader.Read();
   while (xmlReader.NodeType != XmlNodeType.EndElement)
   {
      openScript(xmlReader); // spreekt verder wel voor zich; ongeveer net zo'n functie
   }

   return s;
}

Zoals ik het wil doen:

code:

<set>
   <name>"set1"</name>
   <enabled>"true"</enabled>
   <script>
      <name>"script1"</name>
      <enabled>"true"</enabled>
      <item>
         <position>
            <left>"10"</left>
            <top>"11"</left>
            <width>"50"</width>
            <heigh>"12"</height>
         </position>
      </item>
      <item>
         <position>
            <left>"85"</left>
            <top>"11"</left>
            <width>"50"</width>
            <heigh>"12"</height>
         </position>
      </item>
    </script>
   <script>
      <name>"script2"</name>
      <enabled>"true"</enabled>
      <item>
         <position>
            <left>"60"</left>
            <top>"11"</left>
            <width>"50"</width>
            <heigh>"12"</height>
         </position>
      </item>
   </script>
</set>

Maar dan lijkt opnieuw inlezen me dus best moeilijk... Omdat je van een element direct z'n attributen op kan vragen. Maar als je van attributen subelementen maakt, moet je hierdoor heen itereren...

[ Voor 102% gewijzigd door riezebosch op 02-06-2005 21:52 ]

[djc]

riezebosch schreef op donderdag 02 juni 2005 @ 21:37:
Is hier een standaard oplossing voor, als je wel alles in elemtenten stop? Dat je bijvoorbeeld in een while-loopje uitlijst en dan in een switch bepaald wat je met het huidige element doet? Lijkt mij vrij omslachtig werken, maar goed...

Een woord: XPath.

[Glimi]

Manuzhai schreef op vrijdag 03 juni 2005 @ 07:57:
[...]
Een woord: XPath.

Ik weet niet hoe de implementatie van XPath in C# is, maar in Java vind ik de standaard die bij 1.5 zit zodanig traag, dat deze niet te gebruiken is voor een selectie van allerlei kleine subelelementen. Meestal grijp ik dan ook het hoofdelement met XPath en om daarna verder te gaan dmv DOM.

[Verwijderd]

Het grootste nadeel van attributen vind ik zelf dat je er geen speciale characters in kwijt kunt. De scheiding die ik zelf hanteer is enkel een richtlijn en uiteraard discutabel.

Ik zelf noem alles een attribuut als deze een beschrijving geeft van het element (in de regel zijn dit attributen die 1 keer voorkomen). De uitzondering is dus als je data moet vastleggen die bijvoorbeeld aanhalingstekens bevat.

De inhoud van een element moet zijn wat het element beschrijft.

Alles wat onder de verzamling van het element valt behoort in mijn ogen een element te worden.

Ik zou dus bijvoorbeeld de welbekende html anchor tag zo hebben geschreven:

code:

<anchor title="GoT">
   http://gathering.tweakers.net
</anchor>

Anchor beschrijft immers een link en niet een titel. Een titel zie ik dus als een attribuut van een anchor. Maarja, zoals gezegd, alles is discutabel.

[ Voor 3% gewijzigd door Verwijderd op 03-06-2005 10:54 ]