Napisy są to ciągi liczb, w których kolejne liczby (pojedynczo lub grupami) interpretowane są jako kolejne znaki (litery).
W przypadku kodowań o ustalonej długości znaku (np. UTF-32, ASCI) każda n-bitowa liczba odpowiada jednemu znakowi napisu (przy czym i tak mogą się one graficznie nakładać, ale każdy jest integralną całością).
W przypadku kodowań o zmiennej długości znaku długość znaku kodowana jest w ramach tego znaku (np. w UTF-8 długość wynosi od 1 do 4 bajtów, informacja o długości zakodowana jest w pierwszym bajcie, a dodatkowe bajty mają ustawione najstarsze bity na 10 co jednoznacznie identyfikuje je jako uzupełniające).
Mogą one być przechowywane jako tablica lub lista tablic (ułatwia to operowanie dużymi zmiennymi napisowymi - unikanie relokacji i przepisywania dużej ilości danych).
Możliwe jest kilka sposobów przechowywania napisu w tablicy różniących się metodą uzyskiwania informacji o końcu napisu - może to być osobna zmienna przechowująca długość napisu (lub adres jego końca) albo znacznik końca przechowywany w samym napisie (w tej roli stosowane jest 0 w tzw. NULL-end stringach z języka C).
W przetwarzaniu napisów bardzo często stosowane są wyrażenia regularne służące do dopasowywania napisów do wzorca który opisują, wyszukiwaniu/zastępowaniu tego wzorca. Do typowej, podstawowej składni wyrażeń regularnych zalicza się m.in. następujące operatory:
/* w C++ można korzystać także z napisów w stylu C
* jednak C++ oferuje własny typ obudowujący w sposób obiektowy
* tablicę znaków znaną z języka C
* oraz kilka innych udogodnień (jak np. strumienie)
*/
#include <stdio.h>
#include <iostream>
#include <string>
#include <bitset>
#include <regex>
#include <sstream>
int main() {
// 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
# napisem w Pythonie jest ciąg znaków ujęty w cudzysłowa lub apostrofy
# (nie ma różnicy którego zapisu użyjemy).
x = "abcdefg"
y = "aa bb cc bb dd bb ee"
z = "qw=rt"
# Potrójne cudzysłowa / apostrofy pozwalają na definiowanie napisów wieloliniowych
# (a także zawierających pojedyncze cudzysłowa / apostrofy w tekście).
q = '''abc
def'''
'''rozpoczynający się z początkiem linii nieprzypisany do zmiennej napis
jest ignorowany i może być użyty jako komentarz, typowo komentarz dokumentacyjny'''
# 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\"")
# sprawdzanie czy zawiera pod-napis (z listy)
for podnapis in ["ab", "bc"]:
if podnapis in x:
print (podnapis, "jest pod-napisem:", x)
#
# Wyrażenia regularne
#
# sprawdzanie czy pasuje do wyrażenia regularnego
if re.search("[dz]", x):
print(x, "zawiera d lub z")
# zastępowanie (dowolny niepusty ciąg złożony z liter b oraz c na XX)
print (re.sub('[bc]+', "XX", y))
# czwarty (opcjonalny) argument określa ile razy ma być wykonane zastępowanie
print (re.sub('[bc]+', "XX", y, 2))
# 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.
#
# Modyfikowanie napisów
#
# w Pythonie 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 liczba - napis
#
# 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)
#
# Konwersja znak - numer znaku i kodowania znaków
#
# uzyskiwanie 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))
XML
Extensible Markup Language (XML) jest tekstowym formatem wymiany danych. W odróżnieniu od formatu klasycznego formatu utożsamiającego linię z rekordem złożonym z pól oddzielanych wskazanym separatorem może on w łatwy sposób opisywać bardziej złożoną (drzewiastą a nie tabelkową) postać danych.
Dokument XML składa się z zagnieżdżonych w sobie znaczników, każdy z nich może posiadać atrybuty oraz wartość, którą jest tekst zawierający lub nie kolejne znaczniki. Kolejność występowania elementów w dokumencie jest znacząca.
Każdy znacznik otwierający posiada odpowiadający mu znacznik zamykający (np. <b>aa</b>), znaczniki bez wartości mogą być samo-zamykające (np. <g />).
Dokumenty HTML mogą być zgodne z wymogami formalnymi XML tym samym stanowiąc dokumenty XML.
// wymaga pobrania biblioteki nagłówkowej rapidxml (http://rapidxml.sourceforge.net/)
#include "rapidxml.hpp"
namespace rapidxml { namespace internal {
// fix bug in rapidxml https://sourceforge.net/p/rapidxml/bugs/16/
template<class V, class C> V print_children(V, const xml_node<C>*, int, int);
template<class V, class C> V print_element_node(V, const xml_node<C>*, int, int);
template<class V, class C> V print_data_node(V, const xml_node<C>*, int, int);
template<class V, class C> V print_cdata_node(V, const xml_node<C>*, int, int);
template<class V, class C> V print_declaration_node(V, const xml_node<C>*, int, int);
template<class V, class C> V print_comment_node(V, const xml_node<C>*, int, int);
template<class V, class C> V print_doctype_node(V, const xml_node<C>*, int, int);
template<class V, class C> V print_pi_node(V, const xml_node<C>*, int, int);
}}
#include "rapidxml_print.hpp"
#include <iostream>
#include <string.h>
int main() {
char xmlString[1024];
strncpy(xmlString,
"<a>"
"<b>A<h>qwe ... rty</h></b>"
"ABCD...HIJ..."
"<c x=\"q\" w=\"p p\">EE F</c>"
"<g y=\"zz\" />"
"<c x=\"pp\">123 <d rr=\"oo\">456</d> 78 90.</c>"
"</a>",
1024
);
// utworzenie obiektu drzewa XMLowego w oparciu o napis
rapidxml::xml_document<> xmlDoc;
xmlDoc.parse<0>(xmlString);
// pobranie głównego węzła
rapidxml::xml_node<>* xmlRoot = xmlDoc.first_node();
std::cout << "nazwa głównego elementu to: " << xmlRoot->name() << "\n";
std::cout << "jego zawartość tekstowa to: " << xmlRoot->value() << "\n";
std::cout << "jego wartość to: {{{{" << *xmlRoot << "}}}}\n";
std::cout << "jego potomkowie to: \n";
rapidxml::xml_node<>* xmlNode = xmlRoot->first_node();
while(xmlNode) {
std::cout << " " << xmlNode->name() << " : ";
rapidxml::print( std::cout, *xmlNode, rapidxml::print_no_indenting );
// rapidxml::print() może zapisywać także do napisu
std::cout << "\n";
xmlNode = xmlNode->next_sibling();
}
std::cout << "pierwszy węzeł c ma atrybuty:\n";
xmlNode = xmlRoot->first_node("c");
if(xmlNode) {
rapidxml::xml_attribute<>* xmlAtrib = xmlNode->first_attribute();
while(xmlAtrib) {
std::cout << xmlAtrib->name() << " = " << xmlAtrib->value() << "\n";
xmlAtrib = xmlAtrib->next_attribute();
}
}
// modyfikacje dokumentu:
// zmiana nazwy i zawartości elementu
xmlNode = xmlRoot->first_node("g");
if (xmlNode) {
xmlNode->name("noweGG");
xmlNode->value("!@#$");
}
// zmiana nazwy i wartości atrybutu
xmlNode = xmlRoot->first_node("c");
if(xmlNode) {
rapidxml::xml_attribute<>* xmlAtrib = xmlNode->first_attribute();
while(xmlAtrib) {
if (xmlAtrib->name() == std::string("w")) {
xmlAtrib->name("uu");
xmlAtrib->value("1 2 3");
break;
}
xmlAtrib = xmlAtrib->next_attribute();
}
}
// usuwanie wszystkich potomków ostatniego <c>
xmlNode = xmlRoot->last_node("c");
xmlNode->remove_all_nodes();
xmlNode->value("");
// usuwanie wszystkich atrybutów ...
xmlNode->remove_all_attributes();
// są też funkcje usuwające wskazanego potomka lub atrybut:
// remove_node() i remove_attribute()
// dodawanie atrybutów
xmlNode->append_attribute(
xmlDoc.allocate_attribute("abc", "098")
);
xmlNode->append_attribute(
xmlDoc.allocate_attribute("qwe", "...")
);
// powyższa metoda dodaje na koniec, można także dodawać na początek:
// prepend_attribute() lub na wskazaną pozycję insert_attribute()
// dodawanie potomków
rapidxml::xml_node<>* xmlNode2;
xmlNode2 = xmlDoc.allocate_node(rapidxml::node_data, NULL);
xmlNode2->value("ert");
xmlNode->append_node(xmlNode2);
xmlNode2 = xmlDoc.allocate_node(rapidxml::node_element, "kk");
xmlNode2->value("uio");
xmlNode->append_node(xmlNode2);
xmlNode2 = xmlDoc.allocate_node(rapidxml::node_data, NULL);
xmlNode2->value("bnm");
xmlNode->append_node(xmlNode2);
// podobnie jak atrybuty nody też możemy dodawać na początku
// prepend_node() lub na dowolnej pozycji insert_node()
// wypisanie zmienionego dokumentu
std::cout << xmlDoc;
}
import xml.etree.ElementTree as xml
# Python oferuje także inne niz ElementTree moduły do obsługi XML
# także wspierające DOM
d = """<a>
<b>A<h>qwe ... rty</h></b>
ABCD... &' HIJ...
<c x="q" w="p p">EE FĄ</c>
<g y="zz" />
<c x="pp">123 <d rr="oo">456</d> 78 90.</c>
</a>"""
rootNode = xml.fromstring(d)
# pobieranie informacji z dokumentu
print("nazwa głównego elementu to:", rootNode.tag)
print("jego zawartość tekstowa to:", rootNode.text)
print("jego pełna zawartość tekstowa to:", "".join(rootNode.itertext()))
print("jego wartość to: {{{{", xml.tostring(rootNode, encoding="unicode") ,"}}}}")
print("jego potomkowie to:")
for c in rootNode:
print(" ", c.tag, ":", xml.tostring(c, encoding="unicode"))
print("pierwszy węzeł c ma atrybuty:")
try:
ci = rootNode.iter("c")
print(next(ci).attrib)
except StopIteration:
print(" [brak takiego węzła]")
# modyfikacje dokumentu
# zmiana nazwy i zawartości elementu
try:
ci = rootNode.iter("g")
cc = next(ci);
cc.tag = "noweGG"
cc.text = "!@#$"
except StopIteration: pass
# zmiana nazwy i wartości atrybutu
try:
ci = rootNode.iter("c")
cc = next(ci);
del cc.attrib["w"]
cc.attrib["uu"] = "1 2 3"
except StopIteration: pass
try:
cc = next(ci);
# usuwanie wszystkich potomków drugiego <c>
cc.clear()
# jest też remove() które usuwa wskazany element
# usuwanie wszystkich atrybutów ...
cc.attrib.clear()
se = xml.SubElement(cc, "kk", attrib={"aa":str(45)})
se.text = "uio"
se = xml.SubElement(cc, None)
se.text = "bnm"
# możliwe jest też wstawienie w podanym miejscu
se = xml.Element(None)
se.text = "ert"
cc.insert(0, se)
except StopIteration: pass
print(xml.tostring(rootNode, encoding="unicode"))
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="pl">
<head>
<meta http-equiv="ContentType" content="application/xhtml+xml; charset=utf-8" />
</head><body>
<div id="xyz">
<p>
<b id="abc">Lorem <i>ipsum</i></b> dolor sit amet, <i>consectetur</i> adipiscing elit.
<ul class="typA typX">
<li>Sed congue, eros quis ultricies ornare,</li>
<li>massa sem auctor arcu, et semper ex arcu id augue.</li>
<li>Fusce pretium <i><b>turpis</b></i> massa, maximus <i>dapibus</i> sit amet.</li>
<li>Nulla fermentum molestie finibus.</li>
</ul>Etiam accumsan <i>tempus</i> ante at congue.</p>
<p data-abc="123" data-zz="0" class="az" id="q23y">
Sed feugiat vestibulum sapien eget iaculis.<br />
Integer quis magna nec lacus tempor sagittis.
</p>
</div>
<script type="text/javascript">//<![CDATA[
function fff() {
console.log("wszystkie elementy <i> w dokumencie:");
var a = document.getElementsByTagName("i");
for (var j = 0; j < a.length; j++) {
console.log(a[j].innerHTML + "\n");
}
// modyfikacja zawartości elementu o id="abc"
var b = document.querySelector("#abc");
b.innerHTML = "ABC <u>ABC</u> ABC";
// potomkowie rodzica wskazanego elementu
var child = b.parentNode.firstElementChild
while (child) {
console.log("potomek jest węzłem: " + child.nodeName + "\n");
if (child.nodeName == "ul") {
// jeżeli jest to lista <ul>
// która posiada (wśród klass podanych w atrybucie class) klasę "typA"
// to ją usuń i dodaj klasę "typB"
if (child.classList.contains('typA')) {
child.classList.remove('typA');
child.classList.add('typB');
}
}
child = child.nextElementSibling;
}
var c = document.querySelector("#xyz");
// drugi potomek typu <p> elementu określonego w zmiennej c
var d = c.querySelector("p:nth-of-type(2)");
console.log("ma atrybuty:")
for (var i = 0; i < d.attributes.length; ++i) {
console.log(" " + d.attributes[i].name + " = " + d.attributes[i].value + "\n");
}
// można też pytać o konkretny atrybut
console.log("abc => " + d.getAttribute("data-abc"));
// oraz ustawić (zarówno dodać nowy jak i zmienić istniejący)
d.setAttribute("data-def", "tyui");
}
addEventListener('DOMContentLoaded', fff, false);
//]]></script>
</body></html>
char,short,int,long,long longunsigned char,unsigned short,unsigned int,unsigned long,unsigned long longint, choć ten najczęściej ma 32 bitystdint.h):int8_t,int16_t,int32_t,int64_tuint8_t,uint16_t,uint32_t,uint64_tfloat,doubleprintfz biblioteki standardowej języka C (z nagłówkastdio.h).%) pod które będą podstawiane wartości kolejnych zmiennych%określa sposób wypisywania, np.:%d- liczba całkowita typuintwypisana dziesiętnie%x- liczba całkowita bez znaku wypisana szesnastkowo%f- liczba zmiennoprzecinkowa%s- napis%3d- całkowita rezerwująca 3 miejsca (dopełnianie spacjami od przodu)%03d- całkowita rezerwująca 3 miejsca (dopełnianie zerami wiodącymi)%.2d- zmiennoprzecinkowa z dwoma miejscami po kropce%6.2d- zmiennoprzecinkowa z dwoma miejscami po kropce, rezerwująca 6 miejsc (wliczając kropkę i miejsca po kropce)