Lista dziesięciu najpopularniejszych języków backendowych:
Deklaracja zmiennych za pomocą słów kluczowych var, let, lub const.
var x = 10; // zmienna typu number
let message = 'Hello'; // zmienna typu string
const PI = 3.14; // stałaJavaScript jest językiem z dynamicznym typowaniem.
var number = 10; // number
var text = 'Hello'; // string
var isTrue = true; // boolean
var person = { name: 'John', age: 30 }; // object
var numbers = [1, 2, 3, 4, 5]; // arrayWykorzystujemy instrukcje warunkowe do wykonywania różnych działań w zależności od spełnienia warunku.
var x = 10;
if (x > 5) {
console.log('x jest większe od 5');
} else {
console.log('x jest mniejsze lub równe 5');
}Pętle służą do iteracji przez kolekcje lub wykonywania kodu wielokrotnie.
for (var i = 0; i < 5; i++) {
console.log('Liczba: ' + i);
}
var numbers = [1, 2, 3, 4, 5];
numbers.forEach(function(number) {
console.log(number);
});Funkcje pozwalają na zorganizowanie kodu w celu wielokrotnego wykorzystania.
function greet(name) {
console.log('Hello, ' + name);
}
greet('John');JavaScript umożliwia tworzenie obiektów i klas.
// Obiekt
var person = {
name: 'John',
age: 30,
greet: function() {
console.log('Hello, my name is ' + this.name);
}
};
person.greet();
// Klasa
class Car {
constructor(brand) {
this.brand = brand;
}
present() {
return 'I have a ' + this.brand;
}
}
let myCar = new Car('Ford');
console.log(myCar.present());Obsługa wyjątków pozwala na kontrolowanie nieprzewidzianych sytuacji.
try {
// Kod, który może spowodować błąd
throw 'Oops!';
} catch (error) {
// Obsługa błędu
console.error('Wystąpił błąd: ' + error);
}To podstawowa składnia JavaScript w środowisku Node.js. JavaScript jest językiem wszechstronnym, który może być używany zarówno po stronie klienta (przeglądarka internetowa) jak i po stronie serwera (Node.js).
Oto kilka przykładów operatorów w języku JavaScript, które można wykorzystać w środowisku Node.js:
+ (dodawanie)- (odejmowanie)* (mnożenie)/ (dzielenie)% (modulo - reszta z dzielenia)var x = 10;
var y = 5;
console.log(x + y); // 15
console.log(x - y); // 5
console.log(x * y); // 50
console.log(x / y); // 2
console.log(x % y); // 0= (przypisanie)+= (dodawanie i przypisanie)-= (odejmowanie i przypisanie)*= (mnożenie i przypisanie)/= (dzielenie i przypisanie)%= (modulo i przypisanie)var x = 10;
x += 5; // równoważne z x = x + 5
console.log(x); // 15== (równy)!= (nierówny)=== (identyczny)!== (nieidentyczny)> (większy niż)< (mniejszy niż)>= (większy lub równy)<= (mniejszy lub równy)var x = 10;
var y = 5;
console.log(x === y); // false
console.log(x !== y); // true&& (i logiczne)|| (lub logiczne)! (negacja logiczna)var x = 10;
var y = 5;
console.log(x > 5 && y < 10); // true
console.log(x > 5 || y > 10); // true
console.log(!(x > 5)); // false++ (inkrementacja)-- (dekrementacja)var x = 5;
x++; // równoważne z x = x + 1
console.log(x); // 6To tylko kilka przykładów operatorów w języku JavaScript, których można używać w środowisku Node.js. JavaScript oferuje również wiele innych operatorów, które umożliwiają różne operacje na danych.
x = 10 # Przypisanie wartości do zmiennej x
name = "John" # Przypisanie tekstu do zmiennej name
is_true = True # Przypisanie wartości logicznej do zmiennej is_true# Typy proste
number = 10 # Liczba całkowita
floating_number = 3.14 # Liczba zmiennoprzecinkowa
text = "Hello" # Tekst
is_true = True # Wartość logiczna prawda/fałsz
none_value = None # Brak wartości
# Typy złożone
my_list = [1, 2, 3, 4, 5] # Lista
my_tuple = (1, 2, 3) # Krotka
my_dict = {'key': 'value'} # Słownikx = 10
if x > 5:
print("x jest większe od 5")
else:
print("x nie jest większe od 5")# Pętla for
for i in range(5):
print(i)
# Pętla while
i = 0
while i < 5:
print(i)
i += 1def greet(name):
print("Hello, " + name)
greet("John")class Car:
def __init__(self, brand):
self.brand = brand
def present(self):
return "I have a " + self.brand
my_car = Car("Ford")
print(my_car.present())try:
# Kod, który może spowodować błąd
x = 1 / 0
except ZeroDivisionError:
# Obsługa błędu
print("Nie można dzielić przez zero!")To podstawowa składnia języka Python. Python jest językiem programowania o czytelnej i przejrzystej składni, co czyni go popularnym wyborem dla wielu programistów.
Oto kilka przykładów operatorów w języku Python:
+ (dodawanie)- (odejmowanie)* (mnożenie)/ (dzielenie)% (modulo - reszta z dzielenia)** (potęgowanie)// (dzielenie całkowite)x = 10
y = 5
print(x + y) # 15
print(x - y) # 5
print(x * y) # 50
print(x / y) # 2.0
print(x % y) # 0
print(x ** y) # 100000
print(x // y) # 2= (przypisanie)+= (dodawanie i przypisanie)-= (odejmowanie i przypisanie)*= (mnożenie i przypisanie)/= (dzielenie i przypisanie)%=, **=, //= (analogicznie jak w arytmetycznych)x = 10
x += 5 # równoważne z x = x + 5
print(x) # 15== (równy)!= (nierówny)> (większy niż)< (mniejszy niż)>= (większy lub równy)<= (mniejszy lub równy)x = 10
y = 5
print(x == y) # False
print(x != y) # True
print(x > y) # True
print(x < y) # Falseand (i logiczne)or (lub logiczne)not (negacja logiczna)x = 10
y = 5
print(x > 5 and y < 10) # True
print(x > 5 or y > 10) # True
print(not(x > 5)) # Falsein (należy do)not in (nie należy do)my_list = [1, 2, 3, 4, 5]
print(3 in my_list) # True
print(6 not in my_list) # Trueis (jest tożsamy z)is not (nie jest tożsamy z)x = [1, 2, 3]
y = [1, 2, 3]
z = x
print(x is z) # True
print(x is y) # False
print(x is not y) # TrueTo są podstawowe operatory w języku Python. Python oferuje wiele innych operatorów, które umożliwiają różne operacje na danych.
public class MyClass {
// Ciało klasy
}public void myMethod() {
// Ciało metody
}int x = 10; // Deklaracja zmiennej typu int i przypisanie wartości
String name = "John"; // Deklaracja zmiennej typu String
boolean isTrue = true; // Deklaracja zmiennej typu boolean// Typy proste
int number = 10; // Liczba całkowita
double floatingNumber = 3.14; // Liczba zmiennoprzecinkowa
char letter = 'A'; // Znak
boolean isTrue = true; // Wartość logiczna prawda/fałsz
// Typy złożone
int[] numbers = {1, 2, 3, 4, 5}; // Tablica
String text = "Hello"; // Łańcuch znakówint x = 10;
if (x > 5) {
// Kod wykonywany jeśli warunek jest spełniony
} else {
// Kod wykonywany jeśli warunek nie jest spełniony
}// Pętla for
for (int i = 0; i < 5; i++) {
// Kod wykonywany w każdej iteracji
}
// Pętla while
int i = 0;
while (i < 5) {
// Kod wykonywany dopóki warunek jest spełniony
i++;
}// Deklaracja klasy
public class MyClass {
// Deklaracja zmiennej instancyjnej
private int myVar;
// Konstruktor
public MyClass(int var) {
this.myVar = var;
}
// Metoda
public void myMethod() {
// Kod metody
}
}try {
// Kod, który może zgłosić wyjątek
} catch (Exception e) {
// Obsługa wyjątku
}To są podstawowe elementy składni języka Java. Java jest językiem programowania obiektowego, który charakteryzuje się silnym typowaniem, statycznym wiązaniem i deklaratywnością.
Oto kilka przykładów operatorów w języku Java:
+ (dodawanie)- (odejmowanie)* (mnożenie)/ (dzielenie)% (modulo - reszta z dzielenia)int x = 10;
int y = 5;
System.out.println(x + y); // 15
System.out.println(x - y); // 5
System.out.println(x * y); // 50
System.out.println(x / y); // 2
System.out.println(x % y); // 0= (przypisanie)+= (dodawanie i przypisanie)-= (odejmowanie i przypisanie)*= (mnożenie i przypisanie)/= (dzielenie i przypisanie)%= (modulo i przypisanie)int x = 10;
x += 5; // równoważne z x = x + 5
System.out.println(x); // 15== (równy)!= (nierówny)> (większy niż)< (mniejszy niż)>= (większy lub równy)<= (mniejszy lub równy)int x = 10;
int y = 5;
System.out.println(x == y); // false
System.out.println(x != y); // true
System.out.println(x > y); // true
System.out.println(x < y); // false&& (i logiczne)|| (lub logiczne)! (negacja logiczna)int x = 10;
int y = 5;
System.out.println(x > 5 && y < 10); // true
System.out.println(x > 5 || y > 10); // true
System.out.println(!(x > 5)); // false++ (inkrementacja)-- (dekrementacja)int x = 5;
x++; // równoważne z x = x + 1
System.out.println(x); // 6To są podstawowe operatory w języku Java. Java oferuje również inne operatory, takie jak operatory przesunięcia bitowego, operatory przynależności i operatory trójargumentowe, które umożliwiają bardziej złożone operacje na danych.
Przykłady operacji związanych z tymi operatorami w języku Java:
<< (przesunięcie w lewo)>> (przesunięcie w prawo, z zachowaniem znaku)>>> (przesunięcie w prawo, bez zachowania znaku)int x = 8; // binarnie: 0000 1000
System.out.println(x << 1); // wynik: 16 (binarnie: 0001 0000)
System.out.println(x >> 1); // wynik: 4 (binarnie: 0000 0100)
System.out.println(x >>> 1); // wynik: 4 (binarnie: 0000 0100)instanceof (sprawdza czy obiekt jest instancją konkretnej klasy)class MyClass {}
MyClass obj = new MyClass();
System.out.println(obj instanceof MyClass); // true? : (jeśli warunek jest spełniony, wykonaj pierwszy wyrażenie, w przeciwnym razie wykonaj drugie wyrażenie)int x = 10;
String result = (x > 5) ? "Większe od 5" : "Mniejsze lub równe 5";
System.out.println(result); // wynik: "Większe od 5"Te operatory umożliwiają bardziej zaawansowane operacje w języku Java, takie jak manipulacja bitami, sprawdzanie typów obiektów oraz wybór wartości na podstawie warunku.
PHP kod zazwyczaj jest zawarty wewnątrz tagów <?php i ?>.
<?php
// Kod PHP
?>Do wyświetlania zawartości na stronie używamy funkcji echo lub print.
<?php
echo "Hello, world!";
print("Hello, world!");
?>Komentarze mogą być jedno lub wieloliniowe.
<?php
// To jest komentarz jednoliniowy
/*
To jest komentarz
wieloliniowy
*/
?>Zmienne w PHP rozpoczynają się od znaku $.
<?php
$name = "John";
$age = 30;
?>PHP jest językiem z dynamicznym typowaniem.
<?php
$number = 10; // liczba całkowita
$text = "Hello"; // łańcuch znaków
$isTrue = true; // wartość logiczna prawda/fałsz
$nothing = null; // brak wartości
?>Instrukcje warunkowe w PHP to if, else, elseif.
<?php
$x = 10;
if ($x > 5) {
echo "x jest większe od 5";
} elseif ($x == 5) {
echo "x jest równe 5";
} else {
echo "x jest mniejsze od 5";
}
?>W PHP używamy pętli for, while, do-while, foreach.
<?php
for ($i = 0; $i < 5; $i++) {
echo $i;
}
$i = 0;
while ($i < 5) {
echo $i;
$i++;
}
?>Definiowanie i wywoływanie funkcji w PHP.
<?php
function greet($name) {
echo "Hello, $name!";
}
greet("John");
?>Tablice w PHP mogą być indeksowane numerycznie lub za pomocą kluczy.
<?php
$numbers = array(1, 2, 3, 4, 5);
$person = array("name" => "John", "age" => 30);
?>Obsługa błędów za pomocą try, catch, throw.
<?php
try {
// kod, który może wygenerować błąd
} catch (Exception $e) {
// obsługa błędu
}
?>To jest podstawowa składnia języka PHP. PHP oferuje wiele więcej funkcji i konstrukcji językowych, które umożliwiają rozwinięte aplikacje internetowe.
5. Przykładów operatorów w języku PHP:
+ (dodawanie)- (odejmowanie)* (mnożenie)/ (dzielenie)% (modulo - reszta z dzielenia)$x = 10;
$y = 5;
echo $x + $y; // 15
echo $x - $y; // 5
echo $x * $y; // 50
echo $x / $y; // 2
echo $x % $y; // 0= (przypisanie)+= (dodawanie i przypisanie)-= (odejmowanie i przypisanie)*= (mnożenie i przypisanie)/= (dzielenie i przypisanie). (łączenie łańcuchów)$x = 10;
$x += 5; // równoważne z $x = $x + 5
echo $x; // 15
$text = "Hello, ";
$text .= "world!";
echo $text; // Hello, world!== (równy)!= (nierówny)=== (identyczny - sprawdza wartość i typ)!== (nieidentyczny)> (większy niż)< (mniejszy niż)>= (większy lub równy)<= (mniejszy lub równy)$x = 10;
$y = 5;
echo $x == $y; // false
echo $x != $y; // true
echo $x === $y; // false
echo $x > $y; // true&&, and (i logiczne)||, or (lub logiczne)!, not (negacja logiczna)xor (wykluczające lub logiczne)$x = 10;
$y = 5;
echo ($x > 5 && $y < 10); // true
echo ($x > 5 || $y > 10); // true
echo !($x > 5); // false++ (inkrementacja)-- (dekrementacja)$x = 5;
$x++; // równoważne z $x = $x + 1
echo $x; // 6To są podstawowe operatory w języku PHP. PHP oferuje również inne operatory, takie jak operatory konwersji typów, operatory tablicowe i operatory bitowe, które umożliwiają bardziej złożone operacje na danych.
Oto przykłady operacji związanych z tymi operatorami w języku PHP:
(int) - konwersja na liczbę całkowitą(float) - konwersja na liczbę zmiennoprzecinkową(string) - konwersja na łańcuch znaków(bool) - konwersja na wartość logiczną(array) - konwersja na tablicę(object) - konwersja na obiekt$number = "10";
$floatNumber = (float)$number; // konwersja na float: 10.0
$booleanValue = "true";
$boolValue = (bool)$booleanValue; // konwersja na bool: true+ - łączenie tablic== - sprawdzanie równości tablic (porównuje zawartość tablic, ale nie uwzględnia kolejności)=== - sprawdzanie identyczności tablic (porównuje zawartość oraz kolejność)$array1 = array(1, 2, 3);
$array2 = array(4, 5, 6);
$mergedArray = $array1 + $array2; // łączenie tablic
$array3 = array(1, 2, 3);
$array4 = array(3, 2, 1);
echo ($array3 == $array4) ? "Równe" : "Nierówne"; // Sprawdzanie równości: Równe
echo ($array3 === $array4) ? "Identyczne" : "Nieidentyczne"; // Sprawdzanie identyczności: Nieidentyczne& (AND bitowy)| (OR bitowy)^ (XOR bitowy)~ (NOT bitowy)<< (przesunięcie bitowe w lewo)>> (przesunięcie bitowe w prawo)$x = 5; // binarnie: 101
$y = 3; // binarnie: 011
echo $x & $y; // AND bitowy: 001 (1)
echo $x | $y; // OR bitowy: 111 (7)
echo $x ^ $y; // XOR bitowy: 110 (6)
echo ~$x; // NOT bitowy: 11111111111111111111111111111010 (-6)
echo $x << 1; // Przesunięcie bitowe w lewo o 1: 1010 (10)
echo $x >> 1; // Przesunięcie bitowe w prawo o 1: 10 (2)Operatory te pozwalają na wykonanie różnych operacji na bitach w zmiennych liczbowych.
Do wyświetlania zawartości na ekranie używamy metody puts.
puts "Hello, world!"Komentarze jednoliniowe zaczynają się od znaku #.
# To jest komentarz jednoliniowyZmienne w Ruby zaczynają się od znaku $, @ lub litery lub znaku podkreślenia.
name = "John"
age = 30Ruby jest językiem z dynamicznym typowaniem.
number = 10 # liczba całkowita
floating_number = 3.14 # liczba zmiennoprzecinkowa
text = "Hello" # łańcuch znaków
is_true = true # wartość logiczna prawda/fałszInstrukcje warunkowe w Ruby to if, elsif, else.
x = 10
if x > 5
puts "x jest większe od 5"
elsif x == 5
puts "x jest równe 5"
else
puts "x jest mniejsze od 5"
endW Ruby używamy pętli for, while, until.
for i in 0..4
puts i
end
i = 0
while i < 5
puts i
i += 1
endDefiniowanie i wywoływanie funkcji w Ruby.
def greet(name)
puts "Hello, #{name}!"
end
greet("John")Tablice w Ruby są dynamiczne i mogą zawierać elementy różnych typów.
numbers = [1, 2, 3, 4, 5]Obsługa wyjątków za pomocą begin, rescue, end.
begin
# kod, który może wygenerować wyjątek
rescue => exception
# obsługa wyjątku
endTo są podstawy składni języka Ruby. Ruby jest językiem programowania, który charakteryzuje się elegancką składnią i prostotą.
Oto kilka przykładów operatorów w języku Ruby:
+ (dodawanie)- (odejmowanie)* (mnożenie)/ (dzielenie)% (modulo - reszta z dzielenia)** (potęgowanie)x = 10
y = 5
puts x + y # 15
puts x - y # 5
puts x * y # 50
puts x / y # 2
puts x % y # 0
puts x ** y # 100000= (przypisanie)+= (dodawanie i przypisanie)-= (odejmowanie i przypisanie)*= (mnożenie i przypisanie)/= (dzielenie i przypisanie)%= (modulo i przypisanie)**= (potęgowanie i przypisanie)x = 10
x += 5 # równoważne z x = x + 5
puts x # 15== (równy)!= (nierówny)> (większy niż)< (mniejszy niż)>= (większy lub równy)<= (mniejszy lub równy)<=> (porównanie kombinowane)x = 10
y = 5
puts x == y # false
puts x != y # true
puts x > y # true
puts x <=> y # 1 (jeśli x > y), 0 (jeśli x == y), -1 (jeśli x < y)&& (i logiczne)|| (lub logiczne)! (negacja logiczna)x = 10
y = 5
puts (x > 5 && y < 10) # true
puts (x > 5 || y > 10) # true
puts !(x > 5) # false+ (konkatenacja łańcuchów)<< (dodawanie elementów do tablicy)text1 = "Hello"
text2 = "World"
puts text1 + " " + text2 # Hello World
array = [1, 2, 3]
array << 4
puts array.inspect # [1, 2, 3, 4]To są podstawowe operatory w języku Ruby. Ruby oferuje również inne operatory, takie jak operatory konwersji typów, operatory tablicowe i operatory bitowe, które umożliwiają bardziej złożone operacje na danych.
public class MyClass
{
// Ciało klasy
}public void MyMethod()
{
// Ciało metody
}int x = 10; // Deklaracja zmiennej typu int i przypisanie wartości
string name = "John"; // Deklaracja zmiennej typu string
bool isTrue = true; // Deklaracja zmiennej typu bool// Typy proste
int number = 10; // Liczba całkowita
double floatingNumber = 3.14; // Liczba zmiennoprzecinkowa
char letter = 'A'; // Znak
bool isTrue = true; // Wartość logiczna prawda/fałsz
// Typy złożone
int[] numbers = {1, 2, 3, 4, 5}; // Tablica
string text = "Hello"; // Łańcuch znakówint x = 10;
if (x > 5)
{
// Kod wykonywany jeśli warunek jest spełniony
}
else
{
// Kod wykonywany jeśli warunek nie jest spełniony
}// Pętla for
for (int i = 0; i < 5; i++)
{
// Kod wykonywany w każdej iteracji
}
// Pętla while
int i = 0;
while (i < 5)
{
// Kod wykonywany dopóki warunek jest spełniony
i++;
}// Deklaracja klasy
public class Car
{
// Deklaracja zmiennej instancyjnej
private string brand;
// Konstruktor
public Car(string brand)
{
this.brand = brand;
}
// Metoda
public string Present()
{
return "I have a " + this.brand;
}
}
// Utworzenie obiektu klasy Car
Car myCar = new Car("Ford");
Console.WriteLine(myCar.Present());try
{
// Kod, który może zgłosić wyjątek
}
catch (Exception ex)
{
// Obsługa wyjątku
}To są podstawowe elementy składni języka C#. C# jest językiem programowania stworzonym przez Microsoft, który charakteryzuje się silnym typowaniem, statycznym wiązaniem i bogatym zestawem funkcji.
Oto kilka przykładów operatorów w języku C#:
+ (dodawanie)- (odejmowanie)* (mnożenie)/ (dzielenie)% (modulo - reszta z dzielenia)++ (inkrementacja)-- (dekrementacja)int x = 10;
int y = 5;
Console.WriteLine(x + y); // 15
Console.WriteLine(x - y); // 5
Console.WriteLine(x * y); // 50
Console.WriteLine(x / y); // 2
Console.WriteLine(x % y); // 0
x++; // inkrementacja
y--; // dekrementacja
Console.WriteLine(x); // 11
Console.WriteLine(y); // 4= (przypisanie)+= (dodawanie i przypisanie)-= (odejmowanie i przypisanie)*= (mnożenie i przypisanie)/= (dzielenie i przypisanie)%= (modulo i przypisanie)int x = 10;
x += 5; // równoważne z x = x + 5
Console.WriteLine(x); // 15== (równy)!= (nierówny)> (większy niż)< (mniejszy niż)>= (większy lub równy)<= (mniejszy lub równy)int x = 10;
int y = 5;
Console.WriteLine(x == y); // False
Console.WriteLine(x != y); // True
Console.WriteLine(x > y); // True&& (i logiczne)|| (lub logiczne)! (negacja logiczna)int x = 10;
int y = 5;
Console.WriteLine(x > 5 && y < 10); // True
Console.WriteLine(x > 5 || y > 10); // True
Console.WriteLine(!(x > 5)); // Falseis (sprawdza, czy obiekt jest instancją określonej klasy)as (rzutowanie typów)object obj = "Hello";
if (obj is string)
{
string str = obj as string;
Console.WriteLine(str.ToUpper()); // HELLO
}To są podstawowe operatory w języku C#. C# oferuje również inne operatory, takie jak operatory bitowe, operatory logiczne, operatory warunkowe itp., które umożliwiają bardziej złożone operacje na danych.
func functionName(parameter1 type, parameter2 type) returnType {
// Ciało funkcji
}var variableName typevariableName = valuevariableName := valueif condition {
// Kod wykonywany jeśli warunek jest spełniony
} else {
// Kod wykonywany jeśli warunek nie jest spełniony
}// Pętla for
for i := 0; i < 5; i++ {
// Kod wykonywany w każdej iteracji
}
// Pętla while
for condition {
// Kod wykonywany dopóki warunek jest spełniony
}type structName struct {
fieldName1 type
fieldName2 type
}func (s structName) methodName() returnType {
// Ciało metody
}var arrayName [size]typesliceName := make([]type, length)mapName := make(map[keyType]valueType)Go nie posiada konstrukcji typowych dla obsługi wyjątków. Błędy zazwyczaj są zwracane jako wartość z funkcji, a ich obsługa jest oparta na mechanizmie zwracania wartości błędu.
To są podstawowe elementy składni języka Go. Go jest językiem programowania stworzonym przez Google, charakteryzującym się prostą, ale potężną składnią, koncentrującą się na efektywności oraz wydajności.
Oto kilka przykładów operatorów w języku Go:
+ (dodawanie)- (odejmowanie)* (mnożenie)/ (dzielenie)% (modulo - reszta z dzielenia)++ (inkrementacja)-- (dekrementacja)x := 10
y := 5
fmt.Println(x + y) // 15
fmt.Println(x - y) // 5
fmt.Println(x * y) // 50
fmt.Println(x / y) // 2
fmt.Println(x % y) // 0
x++ // inkrementacja
y-- // dekrementacja
fmt.Println(x) // 11
fmt.Println(y) // 4= (przypisanie)+= (dodawanie i przypisanie)-= (odejmowanie i przypisanie)*= (mnożenie i przypisanie)/= (dzielenie i przypisanie)%= (modulo i przypisanie)x := 10
x += 5 // równoważne z x = x + 5
fmt.Println(x) // 15== (równy)!= (nierówny)> (większy niż)< (mniejszy niż)>= (większy lub równy)<= (mniejszy lub równy)x := 10
y := 5
fmt.Println(x == y) // false
fmt.Println(x != y) // true
fmt.Println(x > y) // true&& (i logiczne)|| (lub logiczne)! (negacja logiczna)x := 10
y := 5
fmt.Println(x > 5 && y < 10) // true
fmt.Println(x > 5 || y > 10) // true
fmt.Println(!(x > 5)) // false& (adres zmiennej)* (dereferencja wskaźnika)x := 10
ptr := &x // adres zmiennej x
fmt.Println(*ptr) // dereferencja wskaźnika, wyświetli wartość zmiennej x (10)To są podstawowe operatory w języku Go. Go oferuje również inne operatory, takie jak operatory bitowe, operatory adresowania, operatory kanałów itp., które umożliwiają bardziej złożone operacje na danych.
def functionName(parameter1: Type, parameter2: Type): ReturnType = {
// Ciało funkcji
}var variableName: Type = valueif (condition) {
// Kod wykonywany jeśli warunek jest spełniony
} else {
// Kod wykonywany jeśli warunek nie jest spełniony
}// Pętla for
for (i <- 0 until 5) {
// Kod wykonywany w każdej iteracji
}
// Pętla while
var i = 0
while (i < 5) {
// Kod wykonywany dopóki warunek jest spełniony
i += 1
}class ClassName(parameters: Type) {
// Ciało klasy
}def methodName(parameters: Type): ReturnType = {
// Ciało metody
}val arrayName: Array[Type] = Array(value1, value2, ...)val listName: List[Type] = List(value1, value2, ...)val mapName: Map[KeyType, ValueType] = Map(key1 -> value1, key2 -> value2, ...)Scala używa bloków try-catch-finally do obsługi wyjątków, podobnie jak w języku Java.
try {
// Kod, który może zgłosić wyjątek
} catch {
case ex: Exception => // Obsługa wyjątku
} finally {
// Kod, który zawsze zostanie wykonany, niezależnie od tego, czy wystąpił wyjątek czy nie
}To są podstawowe elementy składni języka Scala. Scala to język programowania wieloparadygmatowy, który łączy w sobie cechy funkcyjne i obiektowe. Jest wysoce ekspresywny i elastyczny, dzięki czemu nadaje się zarówno do pisania krótkich skryptów, jak i dużych, skalowalnych systemów.
fun functionName(parameter1: Type, parameter2: Type): ReturnType {
// Ciało funkcji
}var variableName: Type = value // Zmienna z możliwością zmiany wartości
val constantName: Type = value // Stała (niemutowalna zmienna)if (condition) {
// Kod wykonywany jeśli warunek jest spełniony
} else {
// Kod wykonywany jeśli warunek nie jest spełniony
}// Pętla for
for (i in 0 until 5) {
// Kod wykonywany w każdej iteracji
}
// Pętla while
var i = 0
while (i < 5) {
// Kod wykonywany dopóki warunek jest spełniony
i++
}class ClassName(parameters: Type) {
// Ciało klasy
}fun methodName(parameters: Type): ReturnType {
// Ciało metody
}val arrayName = arrayOf(value1, value2, ...)val listName = listOf(value1, value2, ...)val mapName = mapOf(key1 to value1, key2 to value2, ...)try {
// Kod, który może zgłosić wyjątek
} catch (e: Exception) {
// Obsługa wyjątku
} finally {
// Kod, który zawsze zostanie wykonany, niezależnie od tego, czy wystąpił wyjątek czy nie
}To są podstawowe elementy składni języka Kotlin. Kotlin to język programowania stworzony przez JetBrains, który działa na maszynie wirtualnej Javy (JVM), ale również jest kompatybilny z platformą Android. Kotlin cechuje się czystą i zwięzłą składnią oraz obsługą wielu paradygmatów programowania, takich jak obiektowy, funkcyjny i imperatywny.
fn function_name(parameter1: Type, parameter2: Type) -> ReturnType {
// Ciało funkcji
}let variable_name: Type = value;if condition {
// Kod wykonywany jeśli warunek jest spełniony
} else {
// Kod wykonywany jeśli warunek nie jest spełniony
}// Pętla for
for i in 0..5 {
// Kod wykonywany w każdej iteracji
}
// Pętla while
let mut i = 0;
while i < 5 {
// Kod wykonywany dopóki warunek jest spełniony
i += 1;
}struct StructName {
field1: Type1,
field2: Type2,
// ...
}impl StructName {
fn method_name(&self, parameter: Type) -> ReturnType {
// Ciało metody
}
}let array_name: [Type; size] = [value1, value2, ...];let mut vector_name = Vec::new();
vector_name.push(value1);
vector_name.push(value2);
// ...Rust preferuje obsługę błędów za pomocą wyników zamiast mechanizmu wyjątków, używając np. typu Result.
fn function_that_might_fail() -> Result<(), ErrorType> {
// Kod, który może zakończyć się błędem
// Jeśli błąd wystąpi, zwróć Err(ErrorType)
// W przeciwnym razie, zwróć Ok(())
}To są podstawowe elementy składni języka Rust. Rust to język programowania stworzony przez Mozillę, który kładzie duży nacisk na bezpieczeństwo i wydajność, poprzez system typów, wypożyczanie (borrowing) i system zarządzania pamięcią bez użycia garbage collectora. Jest to język przeznaczony głównie do programowania systemów, gdzie bezpieczeństwo, wydajność i równoległość są kluczowymi aspektami.