Si queres probar el código que vamos dejando, pueden hacerlo acá : https://play.ballerina.io/
Veamos un poco de código en Ballerina y empecemos con un hola mundo:
import ballerina/io;
public function main() {
io:println("Hello, World!");
}
import ballerina/io;
public function main() {
worker w1 {
io:println("Hello, World! #m");
} worker w2 {
io:println("Hello, World! #n");
} worker w3 {
io:println("Hello, World! #k");
}
}
import ballerina/http;
import ballerina/log;
service hello on new http:Listener(9090) {
resource function sayHello(http:Caller caller, http:Request req) {
var result = caller->respond("Hello, World!");
if (result is error) {
log:printError("Error sending response", result);
}
}
}
y ahora de cliente :
import ballerina/http;
import ballerina/io;
public function main() {
http:Client clientEP = new ("http://www.mocky.io");
var resp = clientEP->get("/v2/5ae082123200006b00510c3d/");
if (resp is http:Response) {
var payload = resp.getTextPayload();
if (payload is string) {
io:println(payload);
} else {
io:println(payload.detail());
}
} else {
io:println(resp.detail());
}
}
Puff... lo que se puede hacer con un "hola mundo". Primera conclusión, claramente se ve que Ballerina esta ampliamente influenciado por Node y javascript.
Veamos un objeto :
import ballerina/io;
type Person object {
public string name = "";
public int age = 0;
public Person? parent = ();
private string email = "default@abc.com";
string address = "No 20, Palm grove";
};
public function main() {
Person p1 = new;
io:println(p1.age);
Person p2 = new();
io:println(p2.age);
Person p3 = new Person();
io:println(p3.age);
}
Se ve que las clases se declaran con type y se pueden hacer cosas más complejas :
import ballerina/io;
type Person object {
public int age;
public string firstName;
public string lastName;
function __init(int age, string firstName, string lastName) {
self.age = age;
self.firstName = firstName;
self.lastName = lastName;
}
function getFullName() returns string {
return self.firstName + " " + self.lastName;
}
};
public function main() {
Person p1 = new(5, "John", "Doe");
io:println(p1.getFullName());
}
Ahora podemos ver la influencia de Go. Porque tiene la misma forma de manejar errores, los retorna y sigue la filosofía de que el error es un resultado más :
import ballerina/io;
const ACCOUNT_NOT_FOUND = "AccountNotFound";
const INVALID_ACCOUNT_ID = "InvalidAccountID";
function getAccountBalance(int accountID) returns int|error {
if (accountID < 0) {
return error(INVALID_ACCOUNT_ID, accountID = accountID);
} else if (accountID > 100) {
return error(ACCOUNT_NOT_FOUND, accountID = accountID);
}
return 600;
}
public function main() {
error simpleError = error("SimpleErrorType", message = "Simple error occurred");
io:println("Error: ", simpleError.reason(),
", Message: ", simpleError.detail()?.message);
int|error result = getAccountBalance(-1);
if (result is int) {
io:println("Account Balance: ", result);
} else {
io:println("Error: ", result.reason(),
", Account ID: ", result.detail()["accountID"]);
}
}
Y por último un ejemplo de interacción con Java :
import ballerinax/java;
import ballerina/io;
function newArrayDeque() returns handle = @java:Constructor {
class: "java.util.ArrayDeque"
} external;
function newArrayDequeWithInitialCapacity(int numElements) returns handle = @java:Constructor {
class: "java.util.ArrayDeque",
paramTypes: ["int"]
} external;
public function main() {
var arrayDeque = newArrayDeque();
io:println(arrayDeque);
var arrayDequeWithCapacity = newArrayDequeWithInitialCapacity(10);
io:println(arrayDequeWithCapacity);
}
No mucho que explicar, de esta manera podemos llamar clases java.
Conclusión, me gusto!
Toma buenas cosas de diferentes lenguajes y lo mezcla de forma equilibrada. Lo único que le critico es el ";" que no lo veo necesario. Por lo dicho, vamos a tener que estudiar un nuevo lenguaje :P
Dejo link: https://ballerina.io/v1-1/learn/by-example/
