1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
---
language: vala
contributors:
- ["Milo Gilad", "https://github.com/Myl0g"]
filename: LearnVala.vala
---
In GNOME's own words, "Vala is a programming language that aims to bring modern programming language features to GNOME developers without imposing any additional runtime requirements and without using a different ABI compared to applications and libraries written in C."
Vala has aspects of Java and C#, so it'll be natural to those who know either or.
[Read more here.](https://wiki.gnome.org/Projects/Vala)
```vala
// Single line comment
/* Multiline
Comment */
/**
* Documentation comment
*/
/* Data Types */
// Vala supports the data types supported by most other programming languages.
char character = 'a'
unichar unicode_character = 'u' // 32-bit unicode character
int i = 2; // ints can also have guaranteed sizes (e.g. int64, uint64)
uint j = -6; // Won't compile; unsigned ints can only be positive
long k;
short l;
ushort m;
string text = "Hello,"; // Note that the == operator will check string content
string verbatim = """This is a verbatim (a.k.a. raw) string. Special characters
(e.g. \n) are not interpreted. They may also be multiple lines long.""";
// String Templates allow for easy string formatting
string string_template = @"$text world"; // "$text" evaluates to "Hello"
int test = 5;
int test2 = 10;
string template2 = @"$(test * test2) is a number."; // Expression evaluation
string template_slice = string_template[7:12]; // => "world"
// Most data types have methods for parsing.
bool parse_bool = bool.parse("false"); // => false
int parse_int = int.parse("-52");
string parse_string = parse_int.to_string();
/* Basic I/O */
stdout.printf(parse_string); // Prints to console
string input = stdin.read_line(); // Gets input from console
stderr.printf("Error message"); // Error printing
/* Arrays */
int[] int_array = new int[10]; // Array of ints with 10 slots
int better_int_array[10]; // Shorter way of making int array with 10 slots
int_array.length; // => 10;
int[] int_array2 = {5, 10, 15, 20}; // Can be created on-the-fly
int[] array_slice = int_array2[1:3]; // Slice (copy of data)
unowned int[] array_slice_ref = int_array2[1:3]; // Reference to data
// Multi-dimensional Arrays (defined with a number of commas in the brackets)
int[,] multi_array = new int[6,4]; // 6 is the number of arrays, 4 is their size
int[,] multi_array2 = {{7, 4, 6, 4},
{3, 2, 4, 6},
{5, 9, 5, 1}};
multi_array2[2,3] = 12; // 2 is the array, 3 is the index in the array
int first_d = multi_array2.length[0] // => 3
int second_d = multi_array2.length[1] // => 4
// Stacked arrays (e.g. int[][]) where array lengths vary are not supported.
// Multi-dimensional arrays cannot be sliced, nor can they be converted to one-
// dimensional.
int[] add_to_array = {};
add_to_array += 12; // Arrays can be dynamically added to
add_to_array.resize(20); // Array now has 20 slots
uint8[] chars = "test message".data;
chars.move(5, 0, 7);
print ((string) chars); // Casts the array to a string and prints "message"
/* Control Flow */
var a = 1;
var b = 2;
int[] foreach_demo = {2, 4, 6, 8};
while (b > a) { // While loop; checks if expression is true before executing
b--;
}
do {
b--;
}
while (b > a); // Do While loop; executes the code in "do" before while (b > a)
for (a = 0; a < 10; a++) { stdout.printf("%d\n", a); } // for loop
foreach (int foreach_demo_var in foreach_demo) {
stdout.printf("%d\n", foreach_demo_var);
} // foreach works on any iterable collection
if (a == 0) {
break;
} else if (a > 1) {
stdout.printf("%d\n", a);
} else {
break;
} // if-then-else
switch (a) {
case 1:
stdout.printf("A is 1\n");
break;
case 5:
case 10:
stdout.printf("A is 5 or 10\n");
break;
default:
stdout.printf("???\n")
break;
} // switch statement
/* Reference Types */
// Reference types are classes.
class Message : GLib.Object { // Class Message extends GLib's Object
public string sender; // a public field
public string text {get; set;} // a public property
private bool sent = false; // private field
public void send() { // public method
sent = true;
}
}
int cast_to_float = 10;
float casted_float = (float) cast_to_float; // static casting; no runtime checks
// For runtime checks, use dynamic casting.
// Dynamically casted objects must meet the following:
// - Object's class is the same class as the desired type
// - Object's class is a subclass of the desired type
// - Desired class is an interface implemented by the object's class
float dyna_casted_float = cast_to_float as float // Won't compile
var inferred_string = "hello"; // Type inference
struct Closet {
public uint shirts;
public uint jackets;
}
enum HouseSize {
SMALL,
MODERATE,
BIG
}
```
* Read about building GUIs with GTK+ and Vala [here](http://archive.is/7C7bw).
|
