Δευτέρα 4 Ιανουαρίου 2016

Ο πίνακας κατακερματισμού 2.0 στα ελληνικά!

Το πρόγραμμα από εδώ το μετέτρεψα με ελληνικές εντολές (η Μ2000 έχει δυο σετ εντολών), αλλά άφησα τις μεταβλητές και τις λεζάντες στα ελληνικά
Δείτε ότι τα αντικείμενα διατηρούν επίσης τα ονόματα των συναρτήσεων και των τμημάτων στα αγγλικά. Θα μπορούσαμε να χρησιμοποιήσουμε διπλά ονόματα, χωρίς διπλούς πλήρεις ορισμούς:

Ομάδα Α {
      Συνάρτηση {
            \\ Μια φορά ο κώδικας
            Διάβασε Α, Β
            Βάλε Α*Β
      }
      Συνάρτηση L {
            Κάλεσε .LΛ() ' καλούμε τη συνάρτηση ως τμήμα
            =Αριθμός
      }
      Συνάρτηση Λ {
            Κάλεσε .LΛ()
            =Αριθμός
      }
      Τμήμα ΑΛΦΑ {
            .ALFA
      }
      Τμήμα ALFA {
            \\ μια φορά ο κώδικας
            Διάβασε Α, Ν
            Τύπωσε Α*Ν
      }
}


Τύπωσε Α.Λ(10,20) \\ 200
Τύπωσε Α.L(10,20) \\ 200
Α.ALFA 10,4 \\ 40
Α.ΑΛΦΑ 10,4 \\ 40




Μπορούμε να πετύχουμε το παραπάνω επειδή στη Μ2000 οι παράμετροι μπαίνουν σε έναν σωρό τιμών. Όταν καλέσουμε τη συνάρτηση Λ τότε δημιουργείται ένας νέος σωρός και εκεί θα μπει στη κορυφή η τιμή 10 και αμέσως μετά η 20 (βάσει του παραδείγματος).  Η Λ όμως συνάρτηση καλεί την .LΛ() (η τελεία στην αρχή δηλώνει ότι είναι της ομάδας), σαν να ήταν τμήμα, σε ότι έχει να κάνει με το σωρό τιμών. Τα τμήματα μοιράζονται τον ίδιο σωρό αν βρίσκονται στην ίδια γραμμή συγγένειας.
Έτσι η Λ() και η LΛ() μέσω της ΚΑΛΕΣΕ μπήκαν σε ίδια γραμμή συγγένειας! Έτσι στη LΛ() βλέπουμε το σωρό της Λ() και κάνουμε αυτό που θέλουμε και βάζουμε πάλι στο σωρό την απάντηση με το ΒΑΛΕ. Δεν επιστρέφουμε τιμή με το = γιατί μη μηδενική τιμή είναι λάθος! (αυτό γίνεται για την Κάλεσε μόνο). Η δεύτερη εντολή της Λ() είναι το =Αριθμός. Η μεταβλητή Αριθμός  δίνει την κορυφή του σωρού τιμών αν είναι αριθμός, και τον βγάζει από εκεί, αλλιώς δίνει λάθος. Άρα δίνουμε τον αριθμό που έβαλε η LΛ(). Ο σωρός της Λ() στην επιστροφή θα πεταχτεί...και αν υπάρχουν τιμές θα διαγραφούν και αυτές. Αν θέλαμε να πάρουμε π.χ. έναν πίνακα τότε θα είχαμε μια Διάβασε Π() και μια =Π()  (δηλαδή θέλουμε αναγνωριστικό για σηκώσουμε το πίνακα). Όπως είναι η Αριθμός για τις αριθμητικές τιμές είναι και η Γράμμα$ για τα αλφαριθμητικά. Θα τις δείτε και στο πρόγραμμα παρακάτω!
Ο Σωρός Τιμών είναι μια ειδική λίστα, LIFO (Last In First Out) κατά κύριο λόγο αλλά μπορεί να χρησιμοποιηθεί ως FIFO (First In First Out), πάντα όμως παίρνουμε από την κορυφή. Με την Βάλε βάζουμε στη κορυφή (και η προηγούμενη πάει από κάτω), και με την Σειρά βάζουμε στο τέλος (άρα κάνουμε το FIFO). Κάθε φορά που καλούμε συνάρτηση ή τμήμα στο σωρό (νέο για τη συνάρτηση) μπαίνουν οι παράμετροι με συγχώνευση λίστας, ώστε η πρώτη αριστερά παράμετρος να είναι στη κορυφή ...και μετά τη τελευταία παράμετρο ακολουθεί ότι άλλο υπήρχε στο σωρό (αν είναι κλήση τμήματος, αλλιώς δεν έχει τίποτα).
Μπορούμε να βλέπουμε τι έχουμε στη κορυφή. Με την Ταύτιση( ) δίνουμε ένα αλφαριθμητικό όπου το πρώτο αριστερά γράμμα αντιστοιχεί στο τύπο της κορυφής. Με αυτό το τρόπο μπορούμε να ξέρουμε τι έχουμε στο σωρό πριν το "σηκώσουμε" με μια διάβασε. Το Α το ελληνικό σημαίνει αριθμός και το Γ σημαίνει γράμματα (Αλφαριθμητικό). Στην αγγλική έκδοση του προγράμματος έχω χρησιμοποιήσει τα N (Number) και S (String). Αυτός είναι ένας γρήγορος τρόπος. Υπάρχουν και άλλοι που θα δούμε σε άλλες αναρτήσεις!
Στο σωρό τιμών μπορούμε να βάζουμε αναφορές σε μεταβλητές, πίνακες, συναρτήσεις. Οι αναφορές είναι αλφαριθμητικά και την χρήση τους την κάνει η Διάβασε με το & πριν το όνομα (πρέπει να βάζουμε το ίδιο & και στην κλήση. Η εντολή ΚΑΝΕ φτιάχνει μια συνάρτηση απλά μας βολεύει εδώ γιατί μπαίνει σε μια γραμμή (δεν μπαίνει όμως σε ορισμό ομάδας-κλάσης)

Τμήμα ΑΑ {
      Διάβασε &Α()
      Τύπωσε Α(10)
}
Συνάρτηση Κ {
      =Αριθμός**2
}
Κάνε Χ(κ)=κ**3
ΑΑ &Κ()
ΑΑ &Χ()


Μπορούμε να αλλάζουμε κώδικα σε μια συνάρτηση ή ένα τμήμα μιας ομάδας. Αυτό συμβαίνει εδώ με το να δημιουργήσουμε μια ομάδα (εδώ ΚΚ) και να την συγχωνεύσουμε στο Αυτό, το αντικείμενο της κλάσης. Επειδή το όνομα είναι ίδιο...θα αντικατασταθεί ο ορισμός, διαφορετικά θα βάζαμε κάτι επιπλέον.
Κλάση α {
      Συνάρτηση Β {
      }
      Τμήμα α {
      Αν Αριθμός=1 τότε {
            Ομάδα ΚΚ {Συνάρτηση Β {=1000+Αριθμός}}
      } Αλλιώς {
            Ομάδα ΚΚ {Συνάρτηση Β {=2000+Αριθμός}}
      }
      Αυτό=ΚΚ
      }
}
αα=α(2)
Τύπωσε αα.β(10)
αα.α 1 \\ αλλάζει συνάρτηση
Τύπωσε αα.β(10)



Με τα παραπάνω είδαμε μερικές από τις δυνατότητες της Μ2000, που σίγουρα δεν τις βρίσκει κανείς σε μια απλή Basic. Πόσο μάλλον να βρει τρόπο να φτιάξει δυναμική δομή όπως αυτός εδώ ο πίνακας κατακερματισμού. Δείτε πως δεν έχουμε χρησιμοποιήσει δείκτες! Ούτε μπλεκόμαστε με αναφορές (δεν έχουμε πέρασμα με αναφορά εδώ). Έχουμε μια δυναμική δομή επειδή χρησιμοποιούμε αντικείμενα μέσα σε αντικείμενο. Όλη την δουλειά την κάνει ο διερμηνευτής της Μ2000!
Με την χρήση του Εγγράφου, του ειδικού τύπου μεταβλητής, έχουμε ταξινομημένα τα κλειδιά. Εδώ μπορούμε να κάνουμε μια δυαδική αναζήτηση αν θέλουμε να βρούμε το επόμενο στοιχείο, αλλά ουσιαστικά δεν μας ενδιαφέρει η σειρά. Μπορεί κανείς να κάνει με την FindIt συνεχόμενες αναζητήσεις, Δηλαδή αν το κλειδί περιλαμβάνει ένα επίθετο τότε μπορούμε να βρούμε όλες τις εγγραφές με αυτό το επίθετο. Να γιατί έχει και μια δεύτερη παράμετρο..και γιατί ακόμα μπορούμε να την καλέσουμε χωρίς παράμετρο (θα δώσουμε στην αρχή και μετά θα καλούμε μέχρι να μην βρει άλλο στοιχείο που να ταιριάζει με αυτό που ψάχνουμε). Ενώ λοιπόν η σειριακή αναζήτηση είναι αργή, με αυτόν τον τρόπο, ξεκινώντας από το τέλος της προηγούμενης αναζήτησης, έχουμε πολλαπλή αναζήτηση σε μια κατεύθυνση.
Διορθώθηκε και εδώ η FastExistItem()



Διάστιχο 0 : Window 12,0 : Διάστιχο 30 : Φόρμα 84 : Πένα 14 : Οθόνη 1 : Περιθώριο { Οθόνη 1 }
Ανανέωση 100
Αναφορά 2,"Hash Table ver2.0"
Διαμέσου MyClass
Alfabeta=Hashtable(6)
Alfabeta.ItemNew "Zorro The Great", "data123456"
Alfabeta.ItemNew "Black Smith", "data1334245", "Alexander III", "data345678"
Alfabeta.ItemNew "Singer Sofia", "data1313113" , "Panatha Maria", "data234234"
Τύπωσε "Search Alfabeta key ";
Αναλυτής
      Τύπωσε Alfabeta.Item$("Black Smith")
Τύπωσε Φόρτος
Τύπωσε Alfabeta.Item$("Panatha Maria")
Τύπωσε "Search Alfabeta key ";
Αναλυτής
      Τύπωσε Alfabeta.Item$("Alexander III")
Τύπωσε Φόρτος
\Διαμέσου CheckThis()
Διαμέσου DisplayItem(0)
ok=Alfabeta.RemoveItem("Black Smith")
ok=Alfabeta.RemoveItem("Alexander III")
Διαμέσου CheckThis()
Διαμέσου DisplayItem(0)
Alfabeta.Item "Panatha Maria", "Hello There"
Διαμέσου DisplayItem(0)
Τύπωσε Alfabeta.FastExistItem("Panatha Maria")
Τύπωσε Alfabeta.ExistItem("Panatha Maria")
Τέλος
Ρουτίνα CheckThis()
      Τοπικές i
      Αναφορά Alfabeta.sort1$
      Για i=0 Έως Alfabeta.items-1 {
      Για alfabeta.data(i) {
          Τύπωσε i, .emp, .items,
          Αν Δεν .emp Τότε { Τύπωσε .i$(0,0) } Αλλιώς Τύπωσε
      }
      }
Τέλος Ρουτίνας
Ρουτίνα DisplayItem(x)
      Τοπικές i,j, k$
      i=Alfabeta.Iterator()
      Τύπωσε @(x),"Items:"; i.itemmax
      Για Alfabeta {
            Ενώ i.NextItem() {
                  Aa$=i.key$()
                  k$=.Item$(Aa$)
                  j=.Hash(Aa$)
                  Τύπωσε @(x),i.item,") "+ Aa$, k$, j
            }
      }
Τέλος Ρουτίνας


MyClass:
Κλάση HashTable {
      item_no, items
      lasts$, spos
      newkey=Αληθές
      Έγγραφο sort1$=""
      nl$={
      }
      Πίνακας data()
      Κλάση Item {
            Πίνακας i$(1)
            items=0, LastId, Emp=Αληθές
            Τμήμα AddItem {
                  Πίνακας .i$(.items+1, 2)
                  Διάβασε .i$(.items,0), .i$(.items,1)
                  .items++
                  .Emp<=Ψευδές
            }
            Συνάρτηση FindIt {
                  Διάβασε anykey$
                  Αν .Emp Τότε Έξοδος
                  = Ψευδές
                  Για .Lastid<=.items-1 Έως 0 {
                        Αν .i$(.Lastid,0)=anykey$ Τότε =Αληθές : Έξοδος
                  }
            }
            Συνάρτηση Value$ {
                  Αν .Emp Τότε Λάθος 10030
                  =.i$(.Lastid,1)
            }
            Τμήμα Delone {
                  Αν .lastid<=.items-2 Τότε {
                    Στοκ .i$(.lastid+1,0) Για (.items-.lastid-1)*2, .i$(.lastid,0)
                  }
                  .items--
                  Αν .items=0 Τότε {
                        .emp<=Αληθές
                        Πίνακας .i$()
                  } Αλλιώς Πίνακας .i$(.items, 2)
            }
      }
      Τμήμα HashTable {
            Διάβασε .items
            A=.Item()
            Καθαρό .sort1$
            Πίνακας .data(.items)=A
      }
      Συνάρτηση F {
            Διάβασε A, b
            b+=A*1024+A
            Βάλε Δυαδικό.Από(b,0X83F3Cf)
      }
      Συνάρτηση Hash {
            Διάβασε Alfabeta$
            Βάλε 0
            Για i=1 Έως len(Alfabeta$)
                  Κάλεσε .F(χαρκωδ(μεσ$(Alfabeta$,i)))
            Επόμενο i
            =Δυαδικό.Η(Αριθμός, 0XAFFA0000+i*.items) υπόλοιπο .items
      }
      Τμήμα Item {
            .newkey<=Ψευδές
            .ItemNew
            .newkey<=Αληθές
      }
      Τμήμα ItemNew {
            Ενώ Ταύτιση("ΓΓ") {
            Διάβασε name$, data$
            name$=Κεφ$(name$)
            i=.Hash(name$)
                  Για Αυτό, this.data(i) {
                        Αν ..Findit(name$) Τότε {
                              Αν .newkey Τότε Λάθος 10010
                              ..i$(..lastid,1)=data$
                        } Αλλιώς {
                        ..AddItem name$, data$
                        .sort1$<=name$+.nl$ : Ταξινόμηση .sort1$,1, Εγγράφου.παρ(.sort1$)-1
                        }
                  }
            }
      }
      Συνάρτηση Item$ {
            Διάβασε name$
            name$=Κεφ$(name$)
            Για .data(.Hash(name$)) {
                  Αν Δεν .Findit(name$) Τότε Λάθος 10020
                  =.value$()
            }
      }
      Συνάρτηση FastExistItem {
            Πάνω
            =.data(.Hash(Κεφ$(Γράμμα$))).Findit(Κεφ$(Γράμμα$))
      }
      Συνάρτηση ExistItem {
            Αν Ταύτιση("Γ") Τότε {
                  Διάβασε .lasts$
                  .lasts$ <= Κεφ$(.lasts$)
                  .spos<=1
            }
            Find .sort1$, .lasts$, .spos
            Διάβασε .spos
            Αν .spos=0 Αλλιώς {
                  Διάβασε .item_no, c
                  Αν Ταύτιση("Α") Τότε { Διάβασε ok } Αλλιώς ok=Ψευδές
                  Αν ok Τότε {
                  .spos++ : =Αληθές
                   } Αλλιώς {
                  Αν c=1 Τότε .spos++ : =Αληθές
                  }
            }
      }
      Συνάρτηση ItemKey$ {
            Διάβασε No
            =Παράγραφος$(.sort1$,No)
      }
      Συνάρτηση ValidItems {
            =Εγγράφου.παρ(.sort1$)-1
      }
      Συνάρτηση Iterator {
            Ομάδα aa {
                  item, itemmax
                  ref$
                  Συνάρτηση nextitem {
                        .item++
                        =.item<=.itemmax
                  }
                  Συνάρτηση key$ {
                        Αν .item=0 Τότε Λάθος 101010
                       = Συνάρτηση$(.ref$.ItemKey$(), .item)
                  }
            }
            aa.itemmax=.ValidItems()
            aa.ref$=&Αυτό
            =aa
      }
      Συνάρτηση RemoveItem {
            Διάβασε Alfabeta$
            Alfabeta$=Κεφ$(Alfabeta$)
            Αν .ExistItem(Alfabeta$) Τότε {
                  oldvalue$=Παράγραφος$( .sort1$, .item_no, -1) ' διαγράφουμε γραμμή
                  Για .data(.Hash(Alfabeta$)) {
                        Αν Δεν .Findit(Alfabeta$) Τότε Έξοδος
                        .delone
                        =Αληθές
                   }
             }
       }
}


Επιστροφή

Το ίδιο πρόγραμμα με αλλαγές που ισχύουν στην τελευταία έκδοση (10). Τρέχει και το προηγούμενο. Απλά βγήκαν μερικά μπλοκ, και μπήκαν εντολές όπως Τέλος Ενώ, Τέλος Αν, Επόμενο.

Όταν φτιάχτηκε το παράδειγμα είχα έως εκείνη τη στιγμή μαύρα μεσάνυχτα για τη χρήση πινάκων κατακερματισμού. Ήταν κάτι που δεν το έβλεπες στο σχολείο ή σε περιοδικά, και ο Διερμηνευτής δεν χρησιμοποιούσε τέτοια αναζήτηση, αλλά σειριακή. Όσο περισσότερα ονόματα χειροτέρευε η αναζήτηση. Απλά γίνονταν από το τέλος στα  πιο πρόσφατα ονόματα μεταβλητών και συναρτήσεων/τμημάτων και αυτό είχε μια επιτυχία. Τώρα λοιπόν όχι μόνο κάνει χρήση αλλά και η συνάρτηση κατακερματισμού είναι αυτή του συστήματος των Windows, βελτιστοποιημένη να εκτελείται πολύ γρήγορα. Πέρα από τη συνάρτηση χρειάζονται δυο δομές, ο πίνακας κατακερματισμού και ο πίνακας καταχωρήσεων. Σε άλλες περιπτώσεις αυτοί ο πίνακας καταχωρήσεων είναι κάποιο δένδροπχ τύπος B-Tree, αλλά εδώ είναι πίνακας UDT (user define type), με πεδία, ένα από αυτά είναι η τιμή  (για το κλειδί) και ένα άλλο ο πρώτος αριθμός  Hash. Οπότε αν αλλάξει μέγεθος ο πίνακας κατακερματισμού, ξαναφτιάχνεται με χρήση των αριθμών Hash απλά αλλάζει το υπόλοιπο βάσει του νέου μήκους. Και αυτό είναι πιολύ γρήγορο. Ορισμένα στοιχεία απο τον πίνακα UDT μπορεί να είναι εκτός πίνακα κατακερματιμσού, επειδή είναι σε λίστα "συγκρούσεων", που δομείται μέσα στον πίνακα UDT με ένα πεδίο  επόμενο_στοιχείο. Σε αυτήν την μικρή λίστα πάντα πρώτο είναι το τελευταίο που μπήκε στο πίνακα UDT με ίδιο HASH. Σε αυτό σύστημα πινάκων, η αναζήτηση βάσει HASH γίνεται σε O(1), αλλά και στη διαγραφή και στην προσθήκη έχουμε Ο(1). Απλά στη διαγραφή έχουμε μετάθεση του τελευταίου στη θέση του διαγραφόμενου. Οπότε δεν κρατάμε τη σειρά. Εδώ έχουμε δέκα φορές πιο γρήγορο κώδικα, αφού η δομή Κατάσταση, είναι πλέον αντικείμενο της Μ2000!

Κατάσταση Alfabeta= "Zorro The Great":= "data123456", "Black Smith":= "data1334245", "Alexander III":= "data345678", "Singer Sofia":= "data1313113" , "Panatha Maria":="data234234"
Τύπωσε "Search Alfabeta key ";
Αναλυτής
Τύπωσε Alfabeta$("Black Smith")
Τύπωσε Φόρτος
Τύπωσε Alfabeta$("Panatha Maria")
Τύπωσε "Search Alfabeta key ";
Αναλυτής
Τύπωσε Alfabeta$("Alexander III")
Τύπωσε Φόρτος
Μ=Κάθε(Alfabeta)
Ενώ Μ
Τύπωσε Μορφή$("{0::-3}. {1:30}{2:30}",1+Μ^, Εκφρ$(Alfabeta!), Εκφρ$(Alfabeta))
Τέλος Ενώ
Αφαίρεση Alfabeta, "Black Smith", "Alexander III"
Επιστροφή Alfabeta,"Panatha Maria":= "Hello There"
Μ=Κάθε(Alfabeta)
Ενώ Μ
Τύπωσε Μορφή$("{0::-3}. {1:30}{2:30}",1+Μ^, Εκφρ$(Alfabeta!), Εκφρ$(Alfabeta))
Τέλος Ενώ


Αν Υπάρχει(Alfabeta, "Panatha Maria") Τότε Τύπωσε Εκφρ$(Alfabeta!), Εκφρ$(Alfabeta) ' κλειδί και τιμή


Υπάρχουν δυο ειδών καταστάσεις ειδών, αυτή που περιγράφτηκε και η κατάσταση ουρά. Η τελευταία έχει το πλεονέκτημα να χειρίζεται όμοια κλειδιά, επίσηςδεν χαλάει ποτέ τη σειρά που μπήκαν τα στοιχεία. Το μειονέκτημα είναι ότι δεν μπορούμε να διαγράψουμε από οπουδήποτε, παρά μόνο από το τέλος όσα θέλουμε. Μπορούμε όμως να απαριθμούμε τα όμοια κλειδιά, με τη σειρά που μπήκαν. Η αναζήτηση πάντα δείχνει το τλευταίο που μπήκε (ακόμα και στα όμοια).

Τα κλειδιά στις καταστάσεις μπορεί να είναι αριθμοί ή αλφαριθμητικά. Τα στοιχεία μπορεί:

1. Να μην υπάρχουν οπότε το κλειδί είναι και το επιστρεφόμενο στοιχείο (μέχρι να αλλάξουμε τιμή).

2. Οτιδήποτε,  από αριθμητική τιμή, αλφαριθμητικό, πίνακας, άλλη κατάσταση, σωρός τιμών.

Οι καταστάσεις,  πίνακες και σωροί τιμών είναι τα τρια βασικά στοιχεία καταχώρησης δεδομένων μαζικά.

Ο σωρός τιμών έχει στοιχεία διάσπαρτα, που σημαίνει ότι εύκολα παρεμβάλουμε ή αφαιρούμε στοιχεία, αλλά δεν έχει "κλειδί" ανά στοιχείο. Μας ενδιαφέρει το επόμενο μέχρι να τελειώσει.

Ο πίνακας έχει στοιχεία σε διάταξη, σε ένα σώμα. Μας ενδιαφέρει το ν-οστό προηγούμενο ή επόμενο, καθώς και τη πολλπαλή χρήση τους, οπότε βολεύει η διάταξη. Υπάρχει τρόπος παρεμβολής  αλλά όχι τόσο γρήγορος όπως στο σωρό τιμών. Στον HASH 2.0 χρησιμοποιώ την Στοκ που κάνει τις μετακινήσεις στοιχείων (τα αλαφαριθμητικά δεν αντιγράφονται, μεταφέρεται ο δείκτης τους, οπότε γλιτώνουμε μετακινήσεις μεγάλων δεδομένων, όπως είναι τα αλφαριθμητικά).

Η Κατάσταση έχει στοιχεία βάσει ονόματος (πεζά καφαλαία μετράνε), αν έχουμε τον υποτύπο Ουρά τότε έχει νόημα η σειρά σε όμοια κλειδιά. Δεν υπάρχει παρεμβολή.

Πέρα από αυτά η Μ2000 έχει ενσωματωμένα αντικείμενα για χειρισμό Json και XML αρχείων, στη μνήμη. (όμως αυτά δεν καταχωρούν αντικείμενα με δείκτες (πραγματικά αντικείμενα) όπως οι τρεις καταχωρητές παραπάνω. Καταχωρούν αυτά που σχεδιάστηκαν να καταχωρούν και αποδίδουν τελικά ένα αλφαριθμητικό με όλη τη δομή μέσα σαν κείμενο.

Τα αντικείμενα json τα έχω φτιάξει με δομή όπως η Κατάσταση,  οπότε έχουν αλφαριθμητικά για κλειδιά (άρα είναι Json αντικείμενο), και για τον Json Πίνακα έχω βάλει ένα πίνακα . Εδώ η αναζήτηση γίνεται με χρήση μονοπατιών. Ακόμα και να μην υπάρχει υπάρχει το μονοπάτι, θα πάρουμε τιμή (υπάρχει και η κενή τιμή). Ή αν δώσουμε ένα μονοπάτι που δεν υπάρχει για να καταχωρηθεί τιμή, τοτε θα δημιουργηθεί με όσα ανιτκέιμενα χρειάζεται (json πίνακας  [ ], json αντικείμενο { })

Τα xml αντικείμενα είναι δένδρα με κόμβους σε διάταξη. Ένας κόμβος (node) μπορεί να είναι ένα άλλο xml αντικείμενο, η μια τιμή σε μορφή κειμένου. Κάθε κόμβος μπορεί να έχει ξεχωριστή λίστα χαρακτηριστικών (άνευ διάταξης). Οπότε ο χειρισμός γίνεται ως εξής. Βρίσκουμε ποια xml διάταξη θα σαρώσουμε, και βάσει ποιών χαρακτηρισιτκών θα επιλέξουμε το κάθε κόμβο (node). Εδώ μπορεί κάποιος να αλλάξει τη διάταξη των κόμβων. Δεν υπάρχει έννοια "κλειδιών" αλλά ετικετών (TAG).  Η διάταξη είναι σειρά όμοιων ετικετών. Η υλοποίηση στη Μ2000 γίνεται εσωτερικά με σωρό τιμών, όπου η τιμή είναι το XmlNode. Αυτό το XmlNode έχει μια κατάσταση με χαρακτηριστικά (attributes), που μπορεί να είναι μηδενική (Null), δηλαδή να μην έχει χαρακτηριστικά, αλλά μπορεί να αυξομειωθεί ναάλογα πώς θέλουμε. Επίσης έχει την τιμή που μπορεί να είναι τίποτα, ή κείμενο, ή ένα xml αντικείμενο. Οπότε υπάρχει περίπτωση να ετοιμάσουμε ένα xml αντικείμενο να το φορτώσουμε σε ένα νέο κόμβο (χωρίς σύνδεση)  και να τον προσθέσουμε ή να τον παρεμβάλουμε σε μια διάταξη υπάρχουσα σε ένα xml αντικείμενο. Εντελώς διαφορετικός τρόπος χειρισμού σε σχέση με το json.

Η HTML μιας σελίδας στο ιντερνετ είναι ένα XML αντικείμενο. H javascript φτιάχτηκε για το χειρισμό του στον Browser (στον Firefox αρχικά). Το Json αρχείο είναι επακριβώς συντακτικό της javascript ως κείμενο. Όπως ορίζει πίνακες και αντικείμενα η javascript.  Σήμερα οι επικοινωνίες μεταξύ πελάτη (client) και εξυπηρετητή (server) γίνονται με αυτά τα δυο πρότυπα (XML και Json). Έτσι στη Μ2000 σταδιακά οδηγούμε τον εκπαιδευόμενο στη χρήση αυτών. Θα μάθεi πρώτα τα βασικά πάνω στα οποία στηρίζονται τα XML και JSON.

Έτσι θα κατανοήσει ο εκπαιδευόμενος γιατί το ODF (Open document format) είναι στη βάση του XML τύπου και όχι JSON. Επίσης υπάρχει ένα αντικείμενο ZipWork για να ανοίγουμε να αρχείο συμπιεσμένο που περιέχει xml αρχεία (όπως το ODF,  αλλά και τα αρχεία των Word, Excel).

Εδώ το HASH2 ανανενωμένο:

 
Διάστιχο 0 : Window 12,0 : Διάστιχο 30 : Φόρμα 84 : Πένα 14 : Οθόνη 1 : Περιθώριο { Οθόνη 1 }
Ανανέωση 100
Αναφορά 2,"Hash Table ver2.0"
Διαμέσου MyClass
Alfabeta=Hashtable(6)
Alfabeta.ItemNew "Zorro The Great", "data123456"
Alfabeta.ItemNew "Black Smith", "data1334245", "Alexander III", "data345678"
Alfabeta.ItemNew "Singer Sofia", "data1313113" , "Panatha Maria", "data234234"
Τύπωσε "Search Alfabeta key ";
Αναλυτής
      Τύπωσε Alfabeta.Item$("Black Smith")
Τύπωσε Φόρτος
Τύπωσε Alfabeta.Item$("Panatha Maria")
Τύπωσε "Search Alfabeta key ";
Αναλυτής
      Τύπωσε Alfabeta.Item$("Alexander III")
Τύπωσε Φόρτος
\Διαμέσου CheckThis()
Διαμέσου DisplayItem(0)
ok=Alfabeta.RemoveItem("Black Smith")
ok=Alfabeta.RemoveItem("Alexander III")
Διαμέσου CheckThis()
Διαμέσου DisplayItem(0)
Alfabeta.Item "Panatha Maria", "Hello There"
Διαμέσου DisplayItem(0)
Τύπωσε Alfabeta.FastExistItem("Panatha Maria")
Τύπωσε Alfabeta.ExistItem("Panatha Maria")
Τέλος
Ρουτίνα CheckThis()
      Τοπικές i
      Αναφορά Alfabeta.sort1$
      Για i=0 Έως Alfabeta.items-1
      Για alfabeta.data(i) {
          Τύπωσε i, .emp, .items,
          Αν Δεν .emp Τότε Τύπωσε .i$(0,0) Αλλιώς Τύπωσε
      }
      Επόμενο
Τέλος Ρουτίνας
Ρουτίνα DisplayItem(x)
      Τοπικές i,j, k$
      i=Alfabeta.Iterator()
      Τύπωσε @(x),"Items:"; i.itemmax
      Για Alfabeta {
            Ενώ i.NextItem()
                  Aa$=i.key$()
                  k$=.Item$(Aa$)
                  j=.Hash(Aa$)
                  Τύπωσε @(x),i.item,") "+ Aa$, k$, j
            Τέλος Ενώ
      }
Τέλος Ρουτίνας


MyClass:
Κλάση HashTable {
      item_no, items
      lasts$, spos
      newkey=Αληθές
      Έγγραφο sort1$=""
      nl$={
      }
      Πίνακας data()
      Κλάση Item {
            Πίνακας i$(1)
            items=0, LastId, Emp=Αληθές
            Τμήμα AddItem {
                  Πίνακας .i$(.items+1, 2)
                  Διάβασε .i$(.items,0), .i$(.items,1)
                  .items++
                  .Emp<=Ψευδές
            }
            Συνάρτηση FindIt {
                  Διάβασε anykey$
                  Αν .Emp Τότε Έξοδος
                  = Ψευδές
                  Για .Lastid<=.items-1 Έως 0
                        Αν .i$(.Lastid,0)=anykey$ Τότε =Αληθές : Έξοδος
                  Επόμενο
            }
            Συνάρτηση Value$ {
                  Αν .Emp Τότε Λάθος 10030
                  =.i$(.Lastid,1)
            }
            Τμήμα Delone {
                  Αν .lastid<=.items-2 Τότε
                    Στοκ .i$(.lastid+1,0) Για (.items-.lastid-1)*2, .i$(.lastid,0)
                  Τέλος Αν
                  .items--
                  Αν .items=0 Τότε .emp<=Αληθές:Πίνακας .i$() Αλλιώς Πίνακας .i$(.items, 2)
            }
      }
      Τμήμα HashTable {
            Διάβασε .items
            A=.Item()
            Καθαρό .sort1$
            Πίνακας .data(.items)=A
      }
      Συνάρτηση F {
            Διάβασε A, b
            b+=A*1024+A
            Βάλε Δυαδικό.Από(b,0X83F3Cf)
      }
      Συνάρτηση Hash {
            Διάβασε Alfabeta$
            Βάλε 0
            Για i=1 Έως len(Alfabeta$)
                  Κάλεσε .F(χαρκωδ(μεσ$(Alfabeta$,i)))
            Επόμενο i
            =Δυαδικό.Η(Αριθμός, 0XAFFA0000+i*.items) υπόλοιπο .items
      }
      Τμήμα Item {
            .newkey<=Ψευδές
            .ItemNew
            .newkey<=Αληθές
      }
      Τμήμα ItemNew {
            Ενώ Ταύτιση("ΓΓ") {
            Διάβασε name$, data$
            name$=Κεφ$(name$)
            i=.Hash(name$)
                  Για Αυτό, this.data(i) {
                        Αν ..Findit(name$) Τότε
                              Αν .newkey Τότε Λάθος 10010
                              ..i$(..lastid,1)=data$
                        Αλλιώς
                              ..AddItem name$, data$
                              .sort1$<=name$+.nl$ : Ταξινόμηση .sort1$,1, Εγγράφου.παρ(.sort1$)-1
                        Τέλος Αν
                  }
            }
      }
      Συνάρτηση Item$ {
            Διάβασε name$
            name$=Κεφ$(name$)
            Για .data(.Hash(name$)) {
                  Αν Δεν .Findit(name$) Τότε Λάθος 10020
                  =.value$()
            }
      }
      Συνάρτηση FastExistItem {
            Πάνω
            =.data(.Hash(Κεφ$(Γράμμα$))).Findit(Κεφ$(Γράμμα$))
      }
      Συνάρτηση ExistItem {
            Αν Ταύτιση("Γ") Τότε
                  Διάβασε .lasts$
                  .lasts$ <= Κεφ$(.lasts$)
                  .spos<=1
            Τέλος Αν
            Find .sort1$, .lasts$, .spos
            Διάβασε .spos
            Αν .spos=0 Αλλιώς
                  Διάβασε .item_no, c
                  Αν Ταύτιση("Α") Τότε Διάβασε ok Αλλιώς ok=Ψευδές
                  Αν ok Τότε .spos++ : =Αληθές Αλλιώς Αν c=1 Τότε .spos++ : =Αληθές
            Τέλος Αν
      }
      Συνάρτηση ItemKey$ {
            Διάβασε No
            =Παράγραφος$(.sort1$,No)
      }
      Συνάρτηση ValidItems {
            =Εγγράφου.παρ(.sort1$)-1
      }
      Συνάρτηση Iterator {
            Ομάδα aa {
                  item, itemmax
                  ref$
                  Συνάρτηση nextitem {
                        .item++
                        =.item<=.itemmax
                  }
                  Συνάρτηση key$ {
                        Αν .item=0 Τότε Λάθος 101010
                       = Συνάρτηση$(.ref$.ItemKey$(), .item)
                  }
            }
            aa.itemmax=.ValidItems()
            aa.ref$=&Αυτό
            =aa
      }
      Συνάρτηση RemoveItem {
            Διάβασε Alfabeta$
            Alfabeta$=Κεφ$(Alfabeta$)
            Αν .ExistItem(Alfabeta$) Τότε
                  oldvalue$=Παράγραφος$( .sort1$, .item_no, -1) ' διαγράφουμε γραμμή
                  Για .data(.Hash(Alfabeta$)) {
                        Αν Δεν .Findit(Alfabeta$) Τότε Έξοδος
                        .delone
                        =Αληθές
                   }
             Τέλος Αν
       }
}


Επιστροφή

Δεν υπάρχουν σχόλια:

Δημοσίευση σχολίου

You can feel free to write any suggestion, or idea on the subject.