#include <stdio.h>
#include <iostream>
#include <string>
#include <string.h>
#include <bitset>
#include <regex>
#include <sstream>
int main() {
// napisy w stylu C
// czyli tak naprawdę tablice bajtów (znaków)
const char* x = "abcdefg";
// wypisanie długości napisu
printf("%d\n", strlen(x));
// wypisanie pod-napisu od 2 do końca
puts(x+2);
// wyszukiwanie
// pod-napisu "cd" w x od pozycji 1
const char* cd = strstr(x+1, "cd");
printf("%d\n", cd-x);
// 3 znakowy pod-napis napisu x
// rozpoczynający się od cd
char buf[16];
strncpy(buf, cd, 3);
buf[3]=0; // NULL end
puts(buf);
// porównywanie
if (strcmp(x, "a") == 0)
puts("x == \"a\"");
if (strncmp(x, "a", 1) == 0)
puts("pierwsze 1 znaków x to \"a\"");
// napisy w stylu C++
std::string xx(x);
std::string y = "aa bb cc bb dd bb ee";
// wypisanie długości napisu
std::cout << xx.size() << "\n";
// .size() to to samo co .length()
// uzyskanie napisy w stylu C
puts(xx.c_str());
// wypisanie pod-napisu od 2 do końca
std::cout << xx.substr(2) << "\n";
std::cout << xx.substr(2, std::string::npos) << "\n";
// i od 0 (początku)do 3
std::cout << xx.substr(0, 3) << "\n";
// wyszukiwanie pod-napisu "bb" w y od pozycji 5
std::cout << y.find("bb", 5) << "\n";
// porównywanie
if (xx == "a")
std::cout << "x == \"a\"\n";
if (xx.compare(0, 1, "a") == 0)
puts("pierwsze 1 znaków x to \"a\"");
if ( std::regex_match(xx, std::regex(".*[dz].*")) )
puts("x zawiera d lub z");
// regex_match dopasowuje całość napisu do wyrażenia regularnego
// dopasowanie częściowe wraz z opcjonalnym uzyskaniem
// pasującej części umożliwia: std::regex_search()
// modyfikowanie std::string
xx = "Ala ma psa";
// wstawianie - insert(pozycja, co)
xx.insert(6, " kota i");
std::cout << xx << std::endl;
// zastępowanie - replace(pozycja, ile, czym);
xx.replace(4, 2, "miała samochód", 0, 6);
// mogłoby też być xx.replace(4, 2, "miała"); i parę innych wariantów ...
std::cout << xx << std::endl;
// usuwanie - erase(pozycja, ile);
xx.erase(9, 1); // 9 zamiast 8 bo UTF-8 i ł ma dwa znaki
std::cout << xx << std::endl;
// zastępowanie z użyciem wyrażeń regularnych
std::cout << std::regex_replace (y, std::regex("[bc]+"), "XX") << "\n";
// zastępowanie z użyciem podstawienia
// $2 zostanie zastąpione wartością drugie pod-wyrażenia,
// czyli fragmentu ujętego w nawiasach
std::cout << std::regex_replace (
y, std::regex("([bc]+) ([bc]+)"), "X-$2-X"
) << "\n";
// konwersja liczb na napis w systemach:
// dwójkowym, ósemkowym, dziesiętnym i szesnastkowym
std::cout << std::bitset<8>(7) << " ";
std::cout << std::oct << 0xf << " ";
std::cout << std::dec << 010 << " ";
std::cout << std::hex << 0b11 << "\n";
// liczby podawane do wypisywania są w odpowiednio systemach:
// dziesiętnym, szesnastkowym, ósemkowym i dwójkowym
// wskazane jest to przez brak prefixu i prefixy "0x" "0" "0b"
// alternatywnie w stylu printf, ale bez dwójkowego
printf("0o%o %d 0x%x\n", 0xf, 010, 0b11);
// wypisywanie znaków unicodu
puts("\u21c4 = ⇄");
// strumienie napisowe
std::ostringstream zzz;
zzz << xx << " cpp\n";
zzz << 34.6 << " " << std::oct << 0xf << " ";
// konwersja do std::string
xx = zzz.str();
std::cout << xx << "\n";
}
import re
x = "abcdefg"
y = "aa bb cc bb dd bb ee"
z = "qw=rt"
# wypisanie długości napisu
print(len(x))
# wypisanie pod-napisu od 2 do końca
# i od 0 (początku)do 3
print (x[2:], x[0:3])
# wypisanie ostatniego i 3 ostatnich znaków
print (x[-1], x[-3:])
# wypisanie co 3ciego znaku z napisu oraz napisu od tyłu
print (y[::3], x[::-1])
# wyszukiwanie
# pod-napisu "bb" w y od pozycji 5
print (y.find("bb", 5))
# porównywanie
if x == "a":
print("x == \"a\"")
if re.search("[dz]", x):
print(x, "zawiera d lub z")
# sprawdzanie czy jest pod-napisem
if "ab" in x:
print ("ab jest pod-napisem:", x)
# sprawdzanie czy jest pod-napisem
if "ba" in x:
print ("ba jest pod-napisem:", x)
# zastępowanie
print (re.sub('[bc]+', "XX", y, 2))
print (re.sub('[bc]+', "XX", y))
# zastępowanie z użyciem podstawienia
# \\2 zostanie zastąpione wartością drugie pod-wyrażenia,
# czyli fragmentu ujętego w nawiasach
print (re.sub('([bc]+) ([bc]+)', "X-\\2-X", y))
# mamy też wpływ na zachłanność wyrażeń regularnych:
print (re.sub('bb (.*) bb', "X \\1 X", y))
# "bb (.*) bb" dopasowało najdłuższy możliwy fragment, czyli: cc bb dd
print (re.sub('.*bb (.*) bb.*', "\\1", y))
# "bb (.*) bb" dopasowało jedynie "dd", bo najdłuższy możliwy
# fragment został dopasowany przez poprzedzające ".*"
print (re.sub('.*?bb (.*) bb.*', "\\1", y))
# "bb (.*) bb" mogło i dopasowało najdłuższy możliwy fragment,
# gdyż było poprzedzone niezachłanną odmianą dopasowania
# dowolnego napisu, czyli: .*?
# Po każdym z operatorów powtórzeń (. ? + {n,m}) możemy dodać
# pytajnik (.? ?? +? {n,m}?) aby wskazać że ma on dopasowywać
# najmniejszy możliwy fragment, czyli ma działać nie zachłannie.
# nie da się modyfikować napisu z użyciem odwołań x[numer] np.
# x[2]="X"
# nie zadziała
# można (gdy dużo tego typu modyfikacji) przepisać do listy:
l=list(x)
# alternatywnie można manualnie:
# l=[]
# for c in x:
# l.append(c)
# albo tak:
# l=[c for c in x]
l[1]="X"
l[3]="qqq"
del l[5]
print("".join(l))
# albo tak (gdy mniej modyfikacji)
print(x[:2] + "XXX" + x[3:])
# można także modyfikować po kolei i dodawać do nowego napisu
s = ""
for c in x:
if c == "a":
s += "AA"
else:
s += c
print(s)
# przy pomocy metody split() napis możemy podzielić
# na listę napisów przy pomocy dowolnego separatora
print(y.split(" "))
print(y.split(" cc "))
# konwersja liczb na napis w systemach:
# dwójkowym, ósemkowym, dziesiętnym i szesnastkowym
print( bin(7), oct(0xf), str(0o10), hex(0b11) )
# liczby podawane do wypisywania są w odpowiednio systemach:
# dziesiętnym, szesnastkowym, ósemkowym i dwójkowym
# wskazane jest to przez brak prefixu i prefixy "0x" "0o" "0b"
# alternatywnie w stylu printf, ale bez dwójkowego
s = "0o%o %d 0x%x" % (0xf, 0o10, 0b11)
print(s)
# wypisywanie znaków z użyciem ich numeru w unikodzie
# - funkcja chr() zwraca napis złożony ze znaku o podanym numerze
# w ramach napisów można też użyć \uNNNN gdzie NNNN jest numerem znaku
# lub po prostu umieścić dany znak w pliku kodowanym UTF8
print(chr(0x21c4) + " == \u21c4 == ⇄")
# funkcja ord() umożliwia konwersję napis złożonego
# z pojedynczego znaku na numer unicodowy
print(hex(ord("⇄")), hex(ord("\u21c4")), hex(ord(chr(0x21c4))) )
# Python używa Unicode dla obsługi napisów, jednak przed
# przekazaniem napisu do świata zewnętrznego konieczne
# może być zastosowanie konwersji do określonej postaci
# bytowej (zastosowanie odpowiedniego kodowania)
# służy do tego metoda encode() np.
a = "aąbcć ... ⇄"
inUTF7 = a.encode('utf7')
inUTF8 = a.encode() # lub a.encode('utf8')
print("'" + a + "' w UTF7 to: " + str(inUTF7))
print(" i jest typu: " + str(type(inUTF7)))
# obiekty typu 'bytes' mogą zostać zdekodowane do napisu
print("zdekodowany UTF7: " + inUTF7.decode('utf7'))
# lub zostać poddane dalszej konwersji np. kodowaniu base64:
import codecs
b64 = codecs.encode(inUTF8, 'base64')
print("napis w UTF8 po zakodowaniu base64 to: " + str(b64))
<?php
$x = "abcdefg";
$y = "aa bb cc bb dd bb ee";
$z = "qw=rt";
# wypisanie długości napisu
echo strlen($x) . "\n";
# wypisanie pod-napisu od 2 do końca
echo substr($x, 2);
# i od 0 (początku) 3 kolejne znaki
echo substr($x, 0, 3) . "\n";
# wyszukiwanie
# pod-napisu "bb" w $y od pozycji 5
echo strpos($y, "bb", 5) . "\n";
# porównywanie
if ($x == "a")
echo "$x == a\n";
if (substr_compare($x, "de", 3, 2)) {
echo "2 znakowy pod-napis od";
echo "pozycji 3 w $x to \"de\"\n";
}
if (preg_match("/[dz]/", $x)) {
echo "$x zawiera d lub z\n";
}
# zastępowanie
echo str_replace("bb", "BB", $y) . "\n";
echo preg_replace('/[bc]+/', "XX", $y, 2) . "\n";
echo preg_replace('/[bc]+/', "XX", $y) . "\n";
# zastępowanie z użyciem podstawienia
# $2 zostanie zastąpione wartością pierwszego pod-wyrażenia,
# czyli fragmentu ujętego w nawiasach
echo preg_replace('/^([^=]*)=.*$/', '$1', $z);
echo " = ";
echo preg_replace('/^[^=]*=(.*)$/', '$1', $z);
echo "\n";
# wypisywanie w różnych systemach liczbowych
printf("0b%b 0o%o %d 0x%x\n", 7, 0xf, 010, 0b11);
?>
# ${zmienna:-"napis"} zwróci napis gdy
# zmienna nie jest zdefiniowana lub jest pusta
# ${zmienna:="napis"} zwróci napis
# oraz wykona podstawienie zmienna="napis" gdy
# zmienna nie jest zdefiniowana lub jest pusta
# ${zmienna:+"napis"} zwróci napis gdy
# zmienna jest zdefiniowana i nie pusta
a=""; b=""; c=""
echo ${a:-"aa"} ${b:="bb"} ${c:+"cc"}
echo $a $b $c
a="x"; b="y"; c="z"
echo ${a:-"aa"} ${b:="bb"} ${c:+"cc"}
echo $a $b $c
# ${#str} zwróci długość napisu w zmiennej str
# ${str:n} zwróci pod-napis $str od n do końca
# ${str:n:m} zwróci pod-napis $str od n o długości m
x=abcdefg
echo ${#x} ${x:2} ${x:0:3} ${x:0:$((${#x}-2))}
# ${str#"ab"} zwróci $str z obciętym "ab" z początku
# ${str%"fg"} zwróci $str z obciętym "fg" z końca
echo ${x#"abc"} ${x%"efg"}
echo ${x#"ac"} ${x%"eg"}
# w napisach do obcięcia możliwe jest stosowanie shellowych
# znaków uogólniających, czyli *, ?, [abc], itd
# operator # i % dopasowują minimalny napis do usunięcia
# operatory ## i %% dopasowują maksymalny napis do usunięcia
x=abcd.e.fg
echo ${x#*.} ${x##*.} ${x%.*} ${x%%.*}
# ${str/"n1"/"n2"} zwróci $str z zastąpionym
# pierwszym wystąpieniem n1 przez n2
# ${str//"n1"/"n2"} zwróci $str z zastąpionymi
# wszystkimi wystąpieniami n1 przez n2
y="aa bb cc bb dd bb ee"
echo ${y/"bb"/"XX"}
echo ${y//"bb"/"XX"}
# polecenie expr match $x 'wr1\(wr2\)wr3'
# zwróci część $x pasującą do wyrażenia regularnego wr2
# wyrażenia regularne wr1 i wr2 pozwalają na
# określanie części napisu do odrzucenia
# alternatywną składnią jest expr $x : 'wr1\(wr2\)wr3'
z="ab=cd"
expr match $z '^\([^=]*\)='
expr $z : '^[^=]*=\(.*\)$'
# możliwe jest też sprawdzanie dopasowań wyrażeń
# regularnych poprzez (uwaga na brak cytowania):
[[ "$z" =~ ^([^=]*)= ]] && echo "OK"
# wypisywanie w różnych systemach liczbowych
printf "0o%o %d 0x%x\n" 0xf 010 3
# do bardziej zaawansowanych operacji
# mogą być przydatne także polecenia:
# grep diff sed awk
# join comm paste
# należy też pamiętać o różnicy w działaniu echo "$a" i
# echo $a w przypadku gdy zmienna a zawiera znaki nowej linii:
# - w pierwszym wypadku będą traktowane jako znaki nowej linii
# - w drugim jako spacje
# obsługa napisów w bash'u przy pomocy standardowych komend POSIXa
# jako że większość operacji bashowych wiąże się z
# uruchamianiem zewnętrznych programów to także
# przetwarzanie napisów może być realizowane w ten sposób
a="aąbcć 123"
# obliczanie długości napisu w znakach, w bajtach i ilości słów w napisie
echo -n $a | wc -m
echo -n $a | wc -c
echo -n $a | wc -w
# obliczanie ilości linii (dokładniej ilości znaków nowej linii)
wc -l < /etc/passwd
# wypisanie 5 pola (rozdzielanego :) z pliku /etc/passwd z eliminacją
# pustych linii oraz linii złożonych tylko ze spacji i przecinków
cut -f5 -d: /etc/passwd | grep -v '^[ ,]*$'
# komenda cut wybiera wskazane pola, opcja -d określa separator
# alternatywne podejście z użyciem AWK
awk -F: '$5 !~ "^[ ,]*$" {print $5}' /etc/passwd
# awk daje duże możliwości przy przetwarzaniu tego typu tekstowych baz
# danych ... możemy np. wypisywać wypisywać pierwsze pole w oparciu
# o warunki nałożone na inne:
awk -F: '$5 !~ "^[ ,]*$" && $3 >= 1000 {print $1}' /etc/passwd
# jak widać w powyższych przykładach do poszczególnych pól odwołujemy
# się poprzez $n, gdzie n jest numerem pola, $0 oznacza cały rekord
# program dla każdego rekordu przetwarza kolejne instrukcje postaci
# "warunek { komendy }", instrukcji takich może być wiele w programie
# (przetwarzane są kolejno) komenda "next" kończy przetwarzanie danego rekordu
# separator pola ustawiamy opcją -F (lub zmienną FS) domyślnym separatorem
# pola jest dowolny ciąg spacji i tabulatorów (w odróżnieniu od cut
# separator może być wieloznakowym napisem lub wyrażeniem regularnym)
# domyślnym separatorem rekordu jest znak nowej linii
# (można go zmienić zmienną RS)
# awk jest prostym językiem programowania obsługującym podstawowe pętle
# i instrukcje warunkowe oraz funkcje wyszukujące i modyfikujące napisy
echo "aba aab bab baa bba bba" | awk '{
for (i=1; i<=NF; ++i) { # dla każdego pola w rekordzie
if(i%2==0) # jeżeli jego numer jest parzysty
gsub("b+", "B", $i); # zastąp wszystkie ciągi b pojedynczym B
ii = index($i, "B") # wyszukaj pozycję pod-napisu B
if (ii) # jeżeli znalazł to wypisz pozycję i pod-napis
printf("# %d %s\n", ii, substr($i, ii)) # od tej pozycji do końca
}
print $0
}'
# AWK obsługuje także tablice asocjacyjne pozwala to np. policzyć
# powtórzenia słów
echo "aa bb aa ee dd aa dd" | awk '
BEGIN {RS="[ \t\n]+"; FS=""}
{slowa[$0]++}
{printf("rekord: %d done\n", NR)}
END {for (s in slowa) printf("%s: %s\n", s, slowa[s])}
'
# podobny efekt możemy uzyskać stosując "uniq -c" (który wypisuje unikalne
# wiersze wraz z ich ilością) na odpowiednio przygotowanym napisie
# (spacje zastąpione nową linią, a linie posortowane)
echo "aa bb aa ee dd aa dd" | tr ' ' '\n' | sort | uniq -c
# jednak rozwiązanie awk można łatwo zmodyfikować aby wypisywało pierwsze
# wystąpienie linii bez sortowania pliku
# inną bardzo przydatną komendą jest sed pozwala ona m.in na zastępowanie
# wyszukiwanego na podstawie wyrażenia regularnego tekstu innym
echo "aa bb cc bb dd bb ee" | sed -e 's#\([bc]\+\) \([bc]\+\)#X-\2-X#g'
# sedowe polecenie s przyjmuje 3 argumenty (oddzielane mogą być dowolnym
# znakiem który wystąpi za s), pierwszy to wyszukiwane wyrażenie, drugi
# tekst którym ma zostać zastąpione, a trzeci gdy jest g to powoduje
# zastępowanie wszystkich wystąpień a nie tylko pierwszego
# należy zwrócić uwagę na różnicę w składni wyrażenia regularnego polegającą
# na poprzedzaniu (, ) i + odwrotnym ukośnikiem aby MIAŁY znaczenie specjalne
# sed z opcją -i i wskazaniem pliku modyfikuje zawartości tego pliku
# pozwala to na łatwe stworzenie funkcji rekurencyjnego zastępowania:
rreplace() {
if [ $# -ne 2 ]; then
echo USAGE: $1 str1 str2
return
fi
grep -R "$1" . | cut -f 1 -d: | uniq | while read f; do
[ -L $f ] || sed -e "s#$1#$2#g" -i $f;
done;
}
var x = "abcdefg";
var y = "aa bb cc bb dd bb ee";
var z = "qw=rt";
// podstawianie wartości zmiennych w napisie
console.log(`x=${x} y=${y} z=${z}\n`)
function echo(a) {
// łączenie napisów (lub napisu i czegoś
// co można skonwertować na napis)
// z użyciem operatora +
console.log(a + "\n");
}
// wypisanie długości napisu
echo(x.length);
// wypisanie pod-napisu od 2 do końca
echo(x.substr(2));
// i od 0 (początku) 3 kolejne znaki
echo(x.substr(0, 3));
// wyszukiwanie
// pod-napisu "bb" w $y od pozycji 5
echo(y.indexOf("bb", 5));
// porównywanie
if (x == "abcdefg")
echo("x == abcdefg");
if (x.search(/[dz]/) > 0) {
echo("x zawiera d lub z");
}
// zastępowanie
echo(y.replace("bb", "BB"));
echo(y.replace(/[bc]+/g, "XX"));
// zastępowanie z użyciem podstawienia
// $2 zostanie zastąpione wartością
// pierwszego pod-wyrażenia,
// czyli fragmentu ujętego w nawiasach
console.log(
z.replace(/^([^=]*)=.*$/, '$1') +
" = " +
z.replace(/^[^=]*=(.*)$/, '$1') +
"\n"
);
var a = 7, b = 0xf, c = 010, d = 0b11;
echo("0b" + a.toString(2))
echo("0o" + b.toString(8))
echo(c.toString())
echo("0x" + d.toString(16))
