A Boo programozási nyelv

Típusok, típuskonstrukciók

Típusszerkezet

Elemi típusok

Számok

3 fajta lebegő pontos szám típus található meg a Boo nyelvben a single, a double és a decimal. A különbség ezek között a méretükben van. A single ez egyszeres, a double pedig dupla pontosságú lebegő pontos szám, a legtöbb helyzetben a double megfelelő és ajánlott választás.

Ezek a 2-es számrendszeren alapulnak, ami gondot okozhat, mikor a mi 10-es alapú számrendszerünkkel dolgozunk. Ezért készítették el a decimal-t. Ez 10-es számrendszer alapú szám, fixpontos, így nem veszítjük el a kerekítésnél lemaradó részeket.

Alapesetben a double tökéletes, azonban magas pontosságot igénylő számításokkor a decimal-t használjuk inkább.

Az egész számoknak módosító kulcsszavak:


A legtöbbször int-et használunk kódoláskor, és ez is az alapértelmezett.

Karakterek és sztringek

$ booish >>> s = "apple" 'apple' >>> print s apple >>> s += " banana" 'apple banana' >>> print s apple banana >>> c = char('C') C >>> print c C

A legtöbbet a sztringet használják. A sztring deklarálására 3 lehetőség van:
Három féle módon tudunk stringeket deklaráni. Használhatunk szimpla és tripla idézőjelet, azaz "peldaszoveg" vagy """peldaszoveg""", valamint lehet így is: 'peldaszoveg'.

A különbség köztük az, hogy a háromszoros idézőjel között többsoros string is szerepelhet (míg a másik kettőnél nem), továbbá a "szoveg" és a 'szoveg' tartalmazhat escape szekvenciákat is. A háromszoros idézőjel minden, a stringliterálban szereplő karaktert a string részeként kezel.

Escape szekvenciák:

Fontos, hogy a stringek "immutable"-k, azaz sohasem változtatható meg az értékük / nem írható felül egy string. A "változtatáshoz" minden esetben új stringre van szükség.

Sztring interpoláció

A sztring interpoláció segítségével értékeket helyettesíthetünk be, valid boo kifejezéseket sztringekbe, a ${} segítségével. Ezek sztringgé értékelődnek ki és behelyettesítődnek.

$ booish >>> name = "Santa Claus" Santa Claus >>> print "Hello, ${name}!" Hello, Santa Claus! >>> print "2 + 2 = ${2 + 2}" 2 + 2 = 4

Boolean

Definíció: Boolean = Igaz vagy Hamis érték binárisan ábrázolva.
A két lehetséges értéke a true és a false.

Az object típus

Object: A központi koncepciója az objektum-orientált programozás paradigmájának.
A Boo-ban minden object. Habár a számok és a karakterek érték típusok, a Boo-ban ezek is objectek.

$ booish >>> o as object >>> o = 'string' 'string' >>> print o string >>> o = 42 42 >>> print o 42

A példában a probléma az object-el, hogy implicit módon nem tudjuk megmondani, hogy string vagy int.

Nézzük ugyanezt a oéldát, de most ne object-ként vegyük fel az o változót:
$ booish >>> o = 'string' 'string' >>> print o string >>> o = 42

ERROR: Cannot convert 'System.Int32' to 'System.String'.

A statikus kódolás eredménye biztonságos és megbízható kód lesz.

A típus deklarációja

Egy típus deklarációja a következőképpen történik: < változó > as < típus > .
pl.: i as int

A legtöbb esetben a Boo egyszerűsíti a dolgunkat, mert ki tudja következtetni az egyszerű típusok esetén mit is szerettünk volna:
"i = 25" és az "i as int = 25" teljesen megegyezik egymással, így válazthatjuk a rövidebbet.

Az érték típusok listája

Boo type .NET Framework type Signed? Size in bytes Possible Values
sbyte System.Sbyte Yes 1 -128 to 127
short System.Int16 Yes 2 -32768 - 32767
int System.Int32 Yes 4 -2147483648 - 2147483647
long System.Int64 Yes 8 -9223372036854775808 - 9223372036854775807
byte System.Byte No 1 0 - 255
ushort System.Uint16 No 2 0 - 65535
uint System.UInt32 No 4 0 - 4294967295
ulong System.Uint64 No 8 0 - 18446744073709551615
single System.Single Yes 4 Approximately ±1.5 x 10-45 - ±3.4 x 1038 with 7 significant figures
double System.Double Yes 8 Approximately ±5.0 x 10-324 - ±1.7 x 10308 with 15 or 16 significant figures
decimal System.Decimal Yes 12 Approximately ±1.0 x 10-28 - ±7.9 x 1028 with 28 or 29 significant figures
char System.Char N/A 2 Any UTF-16 character
bool System.Boolean N/A 1 true or false

Típuskonstrukciók

Lista típusok

Egy láncolt lista, amely változó mennyiségű object típusú elemet tárol.
A listák mutable tulajdonságúak, tehát megváltoztathatóak.
Listát 2 módon definiálhatunk:



Példa:
print((0, 'alpha', 4.5, char('d'))) print array('abcdefghij') l = array(range(5)) print l l[2] = 5 print l l[3] = 'banana'

[0, alpha, 4.5, d]
[a, b, c, d, e, f, g, h, i, j]
[0, 1, 2, 3, 4]
[0, 1, 5, 3, 4]
[0, 1, 5, 'banana', 4]
[0, 1, 5, 'banana', 4, 100.1]
[0, 5, 'banana', 4, 100.1]
0
5
'banana'
4
100.1v


A listák,tömbök és sztringek esetén is lehetőségünk van szeletelésre(slicing). Formája: var[start:end], mindkét érték lehet pozitív, negatív, nulla, hiányzó. Ha csak egy bizonyos elemet szeretnénk, akkor var[position] adja a megfelelő elemet.

print([0, 'alpha', 4.5, char('d')]) print List('abcdefghij') l = List(range(5)) print l l[2] = 5 print l l[3] = 'banana' print l l.Add(100.1) print l l.Remove(1) print l for item in l: print item


[0, alpha, 4.5, d]
[a, b, c, d, e, f, g, h, i, j]
[0, 1, 2, 3, 4]
[0, 1, 5, 3, 4]
[0, 1, 5, 'banana', 4]
[0, 1, 5, 'banana', 4, 100.1]
[0, 5, 'banana', 4, 100.1]
0
5
'banana'
4
100.1

Tömb típusok

A tömbök egyszerű object típusok, melyeknek fix a mérete és csak azonos elemekből állhat.
A tömbök a listákhoz képest nem változtathatják a méretüket, azaz immutable tulajdonságúak. Szeletelhetőek(slicing), de nem adható hozzá újabb, a méretbe már be nem férő elem.
3 módon deklarálhatunk egy tömböt:

print((0, 'alpha', 4.5, char('d'))) print array('abcdefghij') l = array(range(5)) print l l[2] = 5 print l l[3] = 'banana'


(0, alpha, 4.5, d)
(a, b, c, d, e, f, g, h, i, j)
(0, 1, 2, 3, 4)
(0, 1, 5, 3, 4)
ERROR: Cannot convert 'System.String' to 'System.Int32'.


A tömbök a listákkal ellentétben nem szükségszerűen object-eket tárolnak. Bármilyen típusból állhatnak, például az "array(range(5))" esetében int-ekből álló tömböt hoz létre.

Hash típusok

Definíció: Hash = Olyan lista, amely nem csak az egyik dimenzióban nőhet, hanem nagyon sok irányban.
Más nyelvekben a hash típust dictionary-nak hívják. Nagyon hasonló a listákhoz, azonban itt a kulcsok nemcsak integerek lehetnek, hanem object típusúak. 2 módon lehet hash típust definiálni.

hash = {'a': 1, 'b': 2, 'monkey': 3, 42: 'the answer'} print hash['a'] print hash[42] print '---' for item in hash: print item.Key, '=>', item.Value # the same hash can be created from a list like this : ll = [ ('a',1), ('b',2), ('monkey',3), (42, "the answer") ] hash = Hash(ll)


1
the answer
---
a => 1
b => 2
monkey => 3
42 => the answer

Konverziók

Listából tömb konverzió

Ha egy int-ekből űlló listát szeretnénk tömbbé konvertálni, akkor explicit módon meg kell mondanunk, hogy a listánk inte-eket tartalmaz.

Példa:

hash = {'a': 1, 'b': 2, 'monkey': 3, 42: 'the answer'} list = [] for i in range(5): list.Add(i) print list a = array(int, list) for a_s in a: print a_s a[2] += 5 print a list[2] += 5 print list[2]


1 [0]
[0, 1]
[0, 1, 2]
[0, 1, 2, 3]
[0, 1, 2, 3, 4]
(0, 1, 2, 3, 4)
(0, 1, 7, 3, 4)
ERROR: Operator '+' cannot be used with a left-hand side of type 'System.Object' and a right-hand side of type 'System.Int32'

Típuskonverziók / kasztolás

Egy adott típusú elem más típusúvá konvertálása, a megszorításokat figyelembe véve.
Ha valami olyasmit próbálunk konvertálni, ami nem lehetséges, akkor a Boo hibát fog jelezni. Két féle módon tudunk kasztolni:



Példa:
hash = {'a': 1, 'b': 2, 'monkey': 3, 42: 'the answer'} list = List(range(5)) print list for item in list: print ((item cast int) * 5) print '---' for item as int in list: print item * item


1 [0, 1, 2, 3, 4]
0
5
10
15
20
---
0
1
4
9
16


Megj.: Nem ajánlott a túlzott típus-konverzió használata. Ha azt vesszük észre, hogy sokszor szükségünk van rá, gondoljuk újra a problémát és a kódunkat.

Operátorok

Name Syntax example Comments
Multiplication a * b
Division a / b
Remainder a % b Gyakran hívják mod vagy modulus-nak
Addition a + b
Subtraction a - b
Exponent a ** b Ne keverjük össze a Bitwise Xor ^- ral
Bitshift Right a >> b
Bitshift Left a << b
Bitwise And a & b
Bitwise Or a | b
Bitwise Xor a ^ b

Ezek a matematikai operátorok, melyek többféle szintaxissal is használhatjuk: a < operator > = b, pl.: a += b.

Name Syntax Example Comments
Less Than a < b
Greater Than a > b
Less Than or Equal To a <= b
Greater Than or Equal To a >= b
Equality a == b
Inequality a != b
Logical And a and b Akkor használható, ha a és b is logikai érték.
Logical Or a or b Akkor használható, ha a és b is logikai érték.
Logical Not not a Akkor használható, ha a és b is logikai érték.
Name Syntax Example Comments
Typecast cast(string, a)
Typecast a as string
Type Equality/Compatibility a isa string
Type Retrieval typeof(string)
Type Retrieval a.GetType()
Name Syntax Example Comments
Member A.B
Function Call f(x)
Post Increment i++
Post Decrement i--
Constructor Call o = MyClass()
Name Syntax Example Comments
Negative Value -5
Pre Increment ++i
Pre Decrement --i
Grouping (a + b)

Különbség a Pre és Post increment/decrement között: Pre növelésnél először meg történik a növelés, aztán a visszatérés, míg Post esetében először visszatér, majd csak utána növeli.