Vademecum informatyki praktycznej

#include <stdio.h>

int main() {
	double a = 12.7, b = 3, c, d, e;
	int x = 5, y = 6, z;
	
	// dodawanie, mnożenie, odejmowanie zapisuje się
	// i działają one tak jak w normalnej matematyce:
	e = (a + b) * 4 - y;
	
	// dzielenie zależy od typów argumentów
	d = a / b; // będzie dzieleniem zmiennoprzecinkowym bo a i b są typu float
	c = x / y; // będzie dzieleniem całkowitym bo z i y są zmiennymi typu int
	b = (int)a / (int)b; // będzie dzieleniem całkowitym
	a = (double)x / (double)y; // będzie dzieleniem zmiennoprzecinkowym
	
	// reszta z dzielenia (tylko dla argumentów całkowitych)
	z = x % y;
	
	// wypisanie wyników
	printf("%d %f %f %f %f %f\n", z, e, d, c, b, a);
	
	// operacje logiczne:
	// ((a większe równe od 0) AND (b mniejsze od 2)) OR (z równe 5)
	z = (a>=0 && b<2) || z == 5;
	// negacja logiczna z
	x = !z;
	
	printf("%d %d\n", z, x);
	
	// operacje binarne:
	// bitowy OR 0x0f z 0x11 i przesunięcie wyniku o 1 w lewo
	x = (0x0f | 0x11) << 1;
	// bitowy XOR 0x0f z 0x11
	y = (0x0f ^ 0x11);
	// negacja bitowa wyniku bitowego AND 0xfff i 0x0f0
	z = ~(0xfff & 0x0f0);
	
	printf("%x %x %x\n", x, y, z);
	
	// uwaga: powyższy program może nie wykonywać obliczeń w czasie działania
	// ze względu na optymalizację i fakt iż wyniki wszystkich operacji
	// są znane w momencie kompilacji programu
}

a = 12.7
b = 3
x = 5
y = 6

# dodawanie, mnożenie, odejmowanie zapisuje się
# i działają one tak jak w normalnej matematyce:
e = (a + b) * 4 - y

# dzielenie zmiennoprzecinkowe
c = x / y

#dzielenie całkowite
b = a // b

# reszta z dzielenia
z = x % y;

# wypisanie wyników
print(e, c, b, z)

# operacje logiczne:
# ((a większe równe od 0) AND (b mniejsze od 2)) OR (z równe 5)
z = (a>=0 and b<2) or z == 5;
# negacja logiczna z
x = not z;

print(z, x);

# operacje binarne:
# bitowy OR 0x0f z 0x11 i przesunięcie wyniku o 1 w lewo
x = (0x0f | 0x11) << 1;
# bitowy XOR 0x0f z 0x11
y = (0x0f ^ 0x11);
# negacja bitowa wyniku bitowego AND 0xfff i 0x0f0
z = ~(0xfff & 0x0f0);

print(hex(x), hex(y), hex(z & 0xffff));
# wypisując z musimy określić jego bitowość

# wieloargumentowa operacja przypisania
# może być użyta do zamiany wartości pomiędzy dwoma zmiennymi
# bez jawnego używania zmiennej tymczasowej
print(a, b)
a, b = b, a
print(a, b)
# oczywiście można w jej ramach używać więcej niż dwóch zmiennych

a=12; b=3; x=5; y=6

# aby wykonać działania arytmetyczne należy
# umieścić je wewnątrz $(( i ))

# dodawanie, mnożenie, odejmowanie zapisuje się
# i działają one tak jak w normalnej matematyce:
e=$(( ($a + $b) * 4 - $y ))

# dzielenie całkowite
c=$((  $x / $y ))

# wypisanie wyników
# (zwróć uwagę na wynik wypisania niezainicjalizowanej zmiennej z)
echo $e $c $z


# operacje logiczne obsługiwane są komendą test
# lub operatorem [ ] wynik zwracany jest jako kod powrotu
# należy zwrócić uwagę na escapowanie odwrotnym ukośnikiem
# nawiasów i na to że spacje mają znaczenie

# ((a większe równe od zera) AND (b mniejsze od dwóch)) OR (z równe 5)
[ \( $a -ge 0 -a $b -lt 2 \) -o $z -eq 5 ]; z=$?

# negację realizuje !, ale wynikiem negacją dowolnej liczby jest FALSE
# więc nie da się zanegować z jak w pozostałych przykładach

echo $z
# bash stosuje logikę odwróconą 0 == TRUE, coś nie zerowego to FALSE

# bash nie obsługuje liczb zmiennoprzecinkowych ani operacji bitowych
# nieobsługiwane operacje można wykonać za pomocą innego programu np:
a=`echo 'print(3/2)' | python3`
b=$(echo '3/2' | bc -l)
echo $a $b

# ujęcie polecenia w znaki ` powoduje podstawienie w tym miejscu
# standardowego wyjścia tego polecenia (w tym wypadku zapisania go
# do zmiennej), alternatywną składnią jest $( polecenie )
# pokazany na przykładzie zmiennej b

var a = 12.7, b = 3, c = 13, d, e;

// dodawanie, mnożenie, odejmowanie zapisuje się
// i działają one tak jak w normalnej matematyce:
e = (a + b) * 4 - c;

// dzielenie zawsze jest zmiennoprzecinkowe
d = a / b;
c = b / c;

// wypisanie wyników
console.log(
	"e=" + e + "\n" +
	"d=" + d + "\n" +
	"c=" + c + "\n"
);

// operacje logiczne:
// ((a większe równe od 0) AND (b mniejsze od 2)) OR (c równe 5)
var z = (a>=0 && b<2) || c == 5;
// negacja logiczna z
a = !z;

console.log(
	"z=" + z + "\n" +
	"a=" + a + "\n"
);

	// operacje binarne:
	// bitowy OR 0x0f z 0x11 i przesunięcie wyniku o 1 w lewo
	a = (0x0f | 0x11) << 1;
	// bitowy XOR 0x0f z 0x11
	b = (0x0f ^ 0x11);
	// negacja bitowa wyniku bitowego AND 0xfff i 0x0f0
	c = ~(0xfff & 0x0f0);
	
console.log(
	"a=0x" + a.toString(16) + "\n" +
	"b=0x" + b.toString(16) + "\n" +
	"c=0x" + (c & 0xffff).toString(16) + "\n"
);

#include <stdio.h>

int main() {
	int i, j, k;
	
	// instrukcja waunkowa if - else
	if (i<j) {
		puts("i<j");
	} else if (j<k) {
		puts("i>=j AND j<k");
	} else {
		puts("i>=j AND j>=k");
	}
	
	// podstawowe operatory logiczne
	if (i<j || j<k)
		puts("i<j OR j<k");
	// innymi operatorami logicznymi są && (AND), ! (NOT)
	
	// pętla for
	for (i=2; i<=9; ++i) {
		if (i==3) {
			// pominięcie tego kroku pętli
			continue;
		}
		if (i==7) {
			// wyjście z pętli
			break;
		}
		printf(" a: %d\n", i);
	}
	
	// pętla while
	while (i>0) {
		printf(" b: %d\n", --i);
	}
	
	// pętla do - while
	do {
		printf(" c: %d\n", ++i);
	} while (i<2);
	
	// instrukcja wyboru switch
	switch(i) {
		case 1:
			puts("i==1");
			break;
		default:
			puts("i!=1");
			break;
	}
	
	goto ETYKIETA;
	puts("to się nigdy nie wykona");
	puts("bo wcześniej robimy bezwarunkowe goto");
	
	ETYKIETA:
	puts("a to się wykona");
}

i, k, j = 0, 0, 0 # wielokrotne przypisanie
# najpierw oblicza wartości wyrażeń po prawej,
# potem przypisuje. Pozwala na a, b = b, a
# celem zamiany wartości zmiennych

# instrukcja waunkowa if - else
if i<j :
	print("i<j")
elif j<k :
	print("i>=j AND j<k")
else:
	print("i>=j AND j>=k")

# podstawowe operatory logiczne
if i<j or j<k:
	print("i<j OR j<k")
# innymi operatorami logicznymi są `and` oraz `not`


# pętla for
for i in range(2, 9):
	if i==3:
		# pominięcie tego kroku pętli
		continue;
	if i==7:
		# wyjście z pętli
		break;
	print(" a:", i)
else:
	# nie wejdzie tutaj bo pętla kończy
	# się z użyciem break
	print("else w pętli")

# pętla while
while i>0 :
	i = i - 1;
	print(" b:", i)
else:
	# wejdzie tu gdy warunek i>0
	# nie będzie spełniony
	# zarówno przy pierwszym
	# jak i kolejnych sprawdzeniach
	print("else w pętli")

# pętla for
for (( i=0 ; $i<=20 ; i++ )) ; do
	echo $i;
done

# w bardziej "shellowym" stylu:
for i in `seq 0 20`; do
	echo $i;
done

# pętla for po liście rozdzielanej spacjami
# wypisanie nazw wszystkich plików z /tmp
for nazwa in /tmp/* ; do
	echo $nazwa;
done

# pętla while z read (po liniach pliku)
cat /etc/fstab | while read slowo reszta; do
	echo $reszta;
done
# powyższa pętla wypisze po kolei wszystkie
# wiersze pliku przekazanego przez stdin
# (cat nazwa_pliku |) z pominięciem
# pierwszego słowa (które wczytywane było do
# zmiennej slowo)
# domyślnym separatorem pól dla komendy read 
# jest dowolny ciąg białych znaków (spacji i
# tabulatorów) można go zmienić przy pomocy
# zmiennej IFS:
IFS=:
while read a b c d; do
	echo $c
done < /etc/passwd
unset IFS

# Należy mieć na uwadze, że w konstrukcjach typu
# while read, pętla while uruchamiana może być w
# procesie potomnym obecnej powłoki.
# Efektem tego jest iż w niektórych przypadkach
# wykonywane modyfikacje zmiennych wewnątrz
# takiej pętli nie będą widoczne poza nią.


# instruikcja if - else
if [ "$xx" = "kot" -o "$xx" = "pies" ]; then
	echo  "kot lub pies";
elif [ "$xx" = "ryba" ];  then
	echo  "ryba"
else
	echo  "coś innego"
fi

# spacje wokół i wewnątrz nawiasów kwadratowych
# przy warunku są istotne składniowo, zawartość
# nawiasów kwadratowych to tak naprawdę
# argumenty dla komendy test, zatem wywołanie:
#  if [ "$xx" = "ryba" ];  then
# jest równoważne:
#  if test "$xx" = "ryba";  then
# a więcej na temat warunków można znaleźć w:
#  man test

# jako warunek może wystąpić dowolne polecenie
# wtedy sprawdzany jest jego kod powrotu
# 0 oznacza prawdę / zakończenie sukcesem
# wartość nie zerowa fałsz / błąd
if grep '^root:' /etc/passwd > /dev/null; then
	echo /etc/passwd zawiera użytkownika root;
fi

# istnieje możliwość skróconego zapisu warunków
# z użyciem łączenia instrukcji przy pomocy:
#  && wykonaj instrukcję występująca po prawej
#     gdy poprzednia zwróciła zero (true)
#  || (wykonaj instrukcję występująca po prawej
#     gdy poprzednia zwróciła nie zero -- false
[ "$xx" = "ryba" ] && echo '$xx = to ryba'
grep '^root:' /etc/passwd > /dev/null && \
  echo /etc/passwd zawiera użytkownika root;

# instrukcja case
# (w odróżnieniu od switch z C obsługuje napisy)
case $xx in
	kot | pies)
		echo  "kot lub pies"
		;;
	ryba)
		echo  "ryba"
		;;
	*)
		echo  "cos innego"
		;;
esac

<?php

$i=$j=$k=0;

// instrukcja waunkowa if - else
if ($i<$j) {
	echo("i<j\n");
} else if ($j<$k) {
	echo("i>=j AND j<k\n");
} else {
	echo("i>=j AND j>=k\n");
}

// pętla for
for ($i=2; $i<7; ++$i) {
	if ($i==$j) {
		// pominięcie tego kroku pętli
		continue;
	}
	printf(" a: %d\n", $i);
}

// pętla while
while ($i>0) {
	if ($i==$k) {
		// wyjście z pętli
		break;
	}
	printf(" b: %d\n", --$i);
}

// pętla do - while
do {
	printf(" c: %d\n", ++$i);
} while ($i<2);

// instrukcja wyboru switch
switch($i) {
	case 1:
		echo("i==1\n");
		break;
	default:
		echo("i!=1\n");
		break;
}

?>

var i, j, k;

// instrukcja waunkowa if - else
if (i<j) {
	console.log("i<j\n");
} else if (j<k) {
	console.log("i>=j AND j<k\n");
} else {
	console.log("i>=j AND j>=k\n");
}

// podstawowe operatory logiczne
if (i<j || j<k)
	console.log("i<j OR j<k\n");
// innymi operatorami logicznymi są && (AND), ! (NOT)

// pętla for
for (i=2; i<=9; ++i) {
	if (i==3) {
		// pominięcie tego kroku pętli
		continue;
	}
	if (i==7) {
		// wyjście z pętli
		break;
	}
	console.log(" a: ", + i + "\n");
}

// pętla while
while (i>0) {
	console.log(" b: " + --i + "\n");
}

// pętla do - while
do {
	console.log(" c: " + ++i + "\n");
} while (i<2);

// instrukcja wyboru switch
switch(i) {
	case 1:
		console.log("i==1\n");
		break;
	default:
		console.log("i!=1\n");
		break;
}

#include <stdio.h>

#include <stdarg.h>
// potrzebne dla obsługi dowolnej ilości argumentów

// funkcja bezargumentowa niezwracająca wartości
void f1() {
	puts("ABC");
}

// funkcja dwuargumentowa zwracająca wartość
int f2(int a, int b) {
	return a*2.5 + b;
}

// funkcja z jednym argumentem obowiązkowym
// i jednym opcjonalnym
float f3(int a, int b=1) {
	puts("F3");
	return a*2.5 + b;
}

// funkcja z dwoma argumentami wymaganymi
// i dowolną ilością argumentów opcjonalnych
float f4(int a, int b, ...) {
	float ret;
	
	va_list vl;
	va_start(vl, b);
	
	// w tym miejscu potrzebujemy znać ilość
	// oraz typy argumentów
	for (int i=0; i<a; i++) {
		ret += b * va_arg(vl,double);
	}
	va_end(vl);

	return ret;
}

int main() {
	f1();
	
	int a = f2(3, 6);
	// zwracaną wartość można wykorzystać
	// (jak wyżej) lub zignorować:
	f3(0);
	
	float b = f4(2, 1, 2.8, 3.5);
	
	printf("%d %f\n", a , b);
}

# funkcja bezargumentowa, zwracająca wartość
def f1():
	print("AA")
	return 5

a = f1()
print(a)

# funkcja przyjmująca jeden obowiązkowy
# argument oraz dwa opcjonalne
def f2(a, b=2, c=0):
	print(a**b+c)

f2(3)
f2(3, 3)
# można pominąć dowolne z argumentów z wartością
# domyślną odwołując się do pozostałych nazwami
f2(2, c=1)
# można podawać argumenty w dowolnej kolejności
# odwołując się do nich nazwami
f2(b=3, a=2)


# nieokreślona ilość argumentów pozycyjnych
def f(*a):
	for aa in a:
		print(aa)

f(1, "y", 6)
# ale nie: f(1, "y", u="p")

# nieokreślona ilość argumentów nazwanych
def f(**a):
	for aa in a:
		print(aa, "=", a[aa])

f(a="y", u="p")
# ale nie: f(1, u="p")

# nieokreślona ilość argumentów pozycyjnych i nazwanych
def f(*a1, **a2):
	print(a1)
	print(a2)

f(1, "y", 6)
f(a="y", u="p")
f(1, "y", u="p")

# można też wymusić ileś argumentów jawnych
def f(x, *a1, y="8", **a2):
	print(x, y)
	print(a1)
	print(a2)

f(1, "y", 6)
f(1, "y", u="p")
f(1, "z", y="y", u="p")
# ale nie: f(a="y", u="p")

# w bashu każda funkcja może przyjmować
# dowolną ilość parametrów pozycyjnych
# (w identyczny sposób obsługiwane są
#  argumenty linii poleceń dla całego skryptu)
f1() {
	echo "wywołano z $# parametrami"
	echo "parametry to: $@"
	
	[ $# -lt 2 ] && return;
	
	# można odwoływać się do pojedynczych parametrów
	echo "drugi: $2"
	echo "pierwszy: $1"
	
	# albo kolejnych w pętli
	for a in "$@"; do  echo $a;  done
	
	# lub z użyciem polecenia shift
	for i in `seq 1 $#`; do
		echo $1
		shift # powoduje zapomnienie $1
		      # i przenumerowanie pozostałych
		      # argumentów pozycyjnych o 1
		      # wpływa na wartości $@ $# itp
	done
	
	# funkcja może zwracać tylko wartość numeryczną
	# tzw kod powrotu
	return 83
}

# wywołanie - tak jak komendy, czyli bez nawiasów,
# a argumenty rozdzielane białym znakiem (spacją)
f1 aaa 3 t 56

# kod powrotu ostatnio wywołanej komendy lub funkcji
# uzyskuje się poprzez $?:
echo $?


# często funkcje (tak jak wiele komend) wynik swojego
# działania zwracają poprzez standardowe wyjście

f2() { echo "Uwolnić mrożone truskawki$1"; }

# pozyskać go można poprzez `` lub $()
# zapis z użyciem $() może być zagnieżdżony

a=`f2 '!!!'`
echo $a

b=$(f2 '!')
echo $b

# w jednolinijkowym zapisie definicji funkcji (jak
# miało to miejsce dla f2) spacje po { i przed } są
# obowiązkowe, podobnie jak średniki po instukcjach

<?php

# funkcja bezargumentowa, zwracająca wartość
function f1() {
	print("AA\n");
	return 5;
}

$a = f1();
print($a);
print("\n");

# funkcja przyjmująca jeden obowiązkowy
# argument oraz dwa opcjonalne
function f2($a, $b=2, $c=0) {
	print($a**$b+$c);
	print("\n");
}

f2(3);
f2(3, 3);


# nieokreślona ilość argumentów pozycyjnych
function f3() {
	$num = func_num_args();
	print("ilość argumentów:\n");
	print( $num );
	print("\n");
	for($i=0; $i<$num; ++$i) {
		print("argument $i: ");
		print(func_get_arg($i));
		print("\n");
	}
}

f3();
f3("a", 1, "c", 5);

# jeden wymagany, jeden opcjonalny
# i nieokreślona ilość dodatkowych
function f4($a, $b="16") {
	# tablica z wszystkimi argumentami
	# jest alternatywną metodą dostępu
	# do wszystkich argumentów w stosunku
	# co do pokazanej w f3()
	$args = func_get_args();
	print_r($args);
}

f4("a", 1, "c", 5);

?>

function f1() {
	console.log("ABC\n");
}

// funkcja dwuargumentowa zwracająca wartość
function f2(a, b) {
	return a*2.5 + b;
}

// funkcja z jednym argumentem obowiązkowym
// i jednym opcjonalnym
function f3(a, b=1) {
	console.log("F3\n");
	return a*2.5 + b;
}

// funkcja z dowolną ilością argumentów
function f4() {
	var ret = 0;
	
	for(var i=0; i<arguments.length; i++) {
		ret += arguments[i];
	}
	
	return ret;
}

f1();
// zwracaną wartość można wykorzystać:
var a = f2(3, 6);
// lub zignorować:
f3(0);
var b = f4(2, 1, 2.8, 3.5);

console.log("a=" + a +" b=" + b + "\n");