mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2025-08-31 02:20:22 +02:00
Simplify language codes in directories
This commit is contained in:
Boris Verkhovskiy
97
pl/bf.md
Normal file
97
pl/bf.md
Normal file
@@ -0,0 +1,97 @@
|
||||
---
|
||||
category: language
|
||||
language: BF
|
||||
filename: learnbf-pl.bf
|
||||
contributors:
|
||||
- ["Prajit Ramachandran", "http://prajitr.github.io/"]
|
||||
- ["Mathias Bynens", "http://mathiasbynens.be/"]
|
||||
translators:
|
||||
- ["Jakub Młokosiewicz", "https://github.com/hckr"]
|
||||
- ["Mateusz Burniak", "https://github.com/matbur"]
|
||||
lang: pl-pl
|
||||
|
||||
---
|
||||
|
||||
Brainfuck (pisane małymi literami, za wyjątkiem początku zdania) jest bardzo
|
||||
minimalistycznym, kompletnym w sensie Turinga, językiem programowania.
|
||||
Zawiera zaledwie 8 poleceń.
|
||||
|
||||
Możesz przetesotwać brainfucka w swojej przeglądarce, korzystając z narzędzia
|
||||
[brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
|
||||
|
||||
```bf
|
||||
Wszystkie znaki oprócz "><+-.,[]" (wyłączając znaki zapytania) są ignorowane.
|
||||
|
||||
Pamięć w brainfucku jest reprezentowana przez tablicę 30.000 komórek
|
||||
zainicjalizowanych zerami, ze wskaźnikiem pokazującym na aktualną komórkę.
|
||||
|
||||
Oto osiem poleceń brainfucka:
|
||||
+ : inkrementuje (zwiększa o jeden) wartość aktualnie wskazywanej komórki
|
||||
- : dekrementuje (zmniejsza o jeden) wartość aktualnie wskazywanej komórki
|
||||
> : przesuwa wskaźnik na następną komórkę (w prawo)
|
||||
< : przesuwa wskaźnik na poprzednią komórkę (w lewo)
|
||||
. : wyświetla wartość bieżącej komórki (w formie znaku ASCII, np. 65 = 'A')
|
||||
, : wczytuje (jeden) znak z wejścia do bieżącej komórki
|
||||
(konkretnie jego numer z tabeli ASCII)
|
||||
[ : jeśli wartość w bieżącej komórce jest równa zeru, przechodzi do
|
||||
odpowiadającego ]; w przeciwnym wypdaku przechodzi do następnej instrukcji
|
||||
] : Jeśli wartość w bieżącej komórce jest równa zeru, przechodzi do
|
||||
następnej instrukcji; w przeciwnym wypdaku przechodzi do odpowiadającego [
|
||||
|
||||
[ i ] oznaczają pętlę while. Oczywiście każda pętla rozpoczęta [
|
||||
musi być zakończona ].
|
||||
|
||||
Zobaczmy kilka prostych programów w brainfucku.
|
||||
|
||||
|
||||
++++++ [ > ++++++++++ < - ] > +++++ .
|
||||
|
||||
Ten program wypisuje literę 'A'. Najpierw zwiększa wartość komórki #1 do 6.
|
||||
Komórka #1 będzie wykorzystana w pętli. Następnie program wchodzi w pętlę ([)
|
||||
i przechodzi do komórki #2. Pętla wykonuje się sześć razy (komórka #1 jest
|
||||
dekrementowana sześć razy, nim osiągnie wartość zero, kiedy to program
|
||||
przechodzi do odpowiadającego ] i wykonuje kolejne instrukcje).
|
||||
|
||||
W tym momencie wskaźnik pokazuje na komórkę #1, mającą wartość 0, podczas gdy
|
||||
komórka #2 ma wartość 60. Przesuwamy wskaźnik na komórkę #2, inkrementujemy ją
|
||||
pięć razy, uzyskując wartość 65. Następnie wyświetlamy wartość komórki #2.
|
||||
65 to 'A' w tabeli ASCII, więc właśnie ten znak jest wypisany na konsolę.
|
||||
|
||||
|
||||
, [ > + < - ] > .
|
||||
|
||||
Ten program wczytuje znak z wejścia i umieszcza jego kod ASCII w komórce #1.
|
||||
Następnie zaczyna się pętla, w której znajdują się następujące instrukcje:
|
||||
przesunięcie wskaźnika na komórkę #2, inkrementacja wartości komóri #2,
|
||||
powrót do komórki #1 i dekrementacja wartości komórki #1. Instrukcje pętli
|
||||
wykonują się aż wartość komórki #1 osiągnie zero, a komórka #2 osiągnie
|
||||
poprednią wartość komórki #1. Ponieważ na końcu pętli wskaźnik pokazuje na
|
||||
komórkę #1, po pętli następuje instrukcja przejścia do komórki #2 i wysłanie
|
||||
jej wartości (w formie znaku ASCII) na wyjście.
|
||||
|
||||
Zauważ, że odstępy służą wyłącznie poprawie czytelności.
|
||||
Równie dobrze można powyższy program zapisać tak:
|
||||
|
||||
,[>+<-]>.
|
||||
|
||||
|
||||
Spróbuj odgadnąć, co robi poniższy program:
|
||||
|
||||
,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
|
||||
|
||||
Ten program pobiera z wejścia dwie liczby i je mnoży.
|
||||
|
||||
Po wczytaniu dwóch wejść (do komórek #1 i #2) następuje pętla zewnętrzna,
|
||||
warunkowana wartością komórki #1. Następnie program przechodzi do komórki #2
|
||||
i rozpoczyna pętlę wewnętrzną z warunkiem zakończenia w komórce #2,
|
||||
inkrementującą komórkę #3. Tu jednak pojawia się problem: w chwili zakończenia
|
||||
wewnętrznej pętli komórka #2 ma wartość zero. W takim razie wewętrzna pętla
|
||||
nie wywoła się następny raz. Aby rozwiązać ten problem, inkrementujemy także
|
||||
wartość komórki #4, a następnie kopiujemy jej wartość do komórki #2.
|
||||
Ostatecznie wynik działania znajduje się w komórce #3.
|
||||
```
|
||||
|
||||
I to właśnie jest brainfuck. Nie taki trudny, co? W ramach rozrywki możesz
|
||||
napisać własne programy w brainfucku. Możesz też napisać interpreter brainfucka
|
||||
w innym języku. Implementacja interpretera to dość proste zadanie. Jeśli
|
||||
jesteś masochistą, spróbuj napisać interpreter brainfucka w... brainfucku.
|
||||
448
pl/haskell.md
Normal file
448
pl/haskell.md
Normal file
@@ -0,0 +1,448 @@
|
||||
---
|
||||
category: language
|
||||
filename: haskell-pl.hs
|
||||
language: Haskell
|
||||
contributors:
|
||||
- ["Adit Bhargava", "http://adit.io"]
|
||||
translators:
|
||||
- ["Remigiusz Suwalski", "https://github.com/remigiusz-suwalski"]
|
||||
lang: pl-pl
|
||||
|
||||
---
|
||||
|
||||
Haskell został zaprojektowany jako praktyczny, czysto funkcyjny język
|
||||
programowania. Jest znany przede wszystkim ze względu na jego monady oraz system
|
||||
typów, ale ja lubię do niego wracać przez jego elegancję. Sprawił on, że
|
||||
programowanie jest prawdziwą przyjemnością.
|
||||
|
||||
```haskell
|
||||
-- Komentarze jednolinijkowe zaczynają się od dwóch myślników
|
||||
{- Komentarze wielolinijkowe należy
|
||||
zamykać w bloki klamrami.
|
||||
-}
|
||||
|
||||
----------------------------------------------------
|
||||
-- 1. Podstawowe typy danych oraz operatory
|
||||
----------------------------------------------------
|
||||
|
||||
-- Mamy liczby
|
||||
3 -- 3
|
||||
|
||||
-- Podstawowe działania działają tak, jak powinny
|
||||
1 + 1 -- 2
|
||||
8 - 1 -- 7
|
||||
10 * 2 -- 20
|
||||
35 / 5 -- 7.0
|
||||
|
||||
-- dzielenie domyślnie zwraca ,,dokładny'' wynik
|
||||
35 / 4 -- 8.75
|
||||
|
||||
-- dzielenie całkowitoliczbowe
|
||||
35 `div` 4 -- 8
|
||||
|
||||
-- wartości logiczne także są podstawowym typem danych:
|
||||
True
|
||||
False
|
||||
|
||||
-- operacje logiczne: negacja oraz porównania
|
||||
not True -- False
|
||||
not False -- True
|
||||
1 == 1 -- True
|
||||
1 /= 1 -- False
|
||||
1 < 10 -- True
|
||||
|
||||
-- W powyższych przykładach, `not` jest funkcją przyjmującą jeden argument.
|
||||
-- Haskell nie potrzebuje nawiasów, by wywołać funkcję: argumenty są po prostu
|
||||
-- wypisywane jeden za drugim. Ogólnie wygląda to tak:
|
||||
-- funkcja arg1 arg2 arg3...
|
||||
-- Sekcja poświęcona funkcjom zawiera informacje, jak stworzyć własne.
|
||||
|
||||
-- Łańcuchy znaków (stringi) i pojedyncze znaki:
|
||||
"To jest lancuch."
|
||||
'a' -- znak
|
||||
'Nie mozna laczyc apostrofow z lancuchami.' -- błąd!
|
||||
|
||||
-- Łańcuchy można sklejać
|
||||
"Hello " ++ "world!" -- "Hello world!"
|
||||
|
||||
-- Łańcuch jest listą własnych znaków
|
||||
['H', 'e', 'l', 'l', 'o'] -- "Hello"
|
||||
"To jest lancuch" !! 0 -- 'T'
|
||||
|
||||
----------------------------------------------------
|
||||
-- 2. Listy oraz krotki
|
||||
----------------------------------------------------
|
||||
|
||||
-- Wszystkie elementy listy muszą być tego samego typu.
|
||||
-- Poniższe dwie listy są identyczne:
|
||||
[1, 2, 3, 4, 5]
|
||||
[1..5]
|
||||
|
||||
-- Zakresy są uniwersalne.
|
||||
['A'..'F'] -- "ABCDEF"
|
||||
|
||||
-- Przy tworzeniu zakresów można określić krok.
|
||||
[0,2..10] -- [0, 2, 4, 6, 8, 10]
|
||||
[5..1] -- To nie zadziała, gdyż w Haskellu zakresy tworzone są domyślnie rosnąco
|
||||
[5,4..1] -- [5, 4, 3, 2, 1]
|
||||
|
||||
-- indeksowanie listy od zera
|
||||
[1..10] !! 3 -- 4
|
||||
|
||||
-- Można nawet tworzyć listy nieskończone!
|
||||
[1..] -- lista wszystkich liczb naturalnych
|
||||
|
||||
-- Nieskończone listy mają prawo działać, ponieważ Haskell cechuje się leniwym
|
||||
-- wartościowaniem. To oznacza, że obliczane są jedynie te elementy listy,
|
||||
-- których istotnie potrzebujemy. Możemy poprosić o tysiączny element i
|
||||
-- dostaniemy go:
|
||||
|
||||
[1..] !! 999 -- 1000
|
||||
|
||||
-- Haskell wyznaczył pierwsze tysiąc elementów listy, ale cała jej reszta
|
||||
-- jeszcze nie istnieje! Nie zostanie obliczona ich wartość, póki nie zajdzie
|
||||
-- taka potrzeba.
|
||||
|
||||
-- łączenie dwóch list
|
||||
[1..5] ++ [6..10]
|
||||
|
||||
-- dodawanie pojedynczego elementu na początek listy
|
||||
0:[1..5] -- [0, 1, 2, 3, 4, 5]
|
||||
|
||||
-- więcej operacji na listach
|
||||
head [1..5] -- 1
|
||||
tail [1..5] -- [2, 3, 4, 5]
|
||||
init [1..5] -- [1, 2, 3, 4]
|
||||
last [1..5] -- 5
|
||||
|
||||
-- list comprehensions
|
||||
[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
|
||||
|
||||
-- z dodatkowym warunkiem
|
||||
[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10]
|
||||
|
||||
-- każdy element krotki może być innego typu, jednak sama krotka musi być stałej
|
||||
-- długości. Przykładowo:
|
||||
("haskell", 1)
|
||||
|
||||
-- dostęp do elementów pary (krotki długości 2):
|
||||
fst ("haskell", 1) -- "haskell"
|
||||
snd ("haskell", 1) -- 1
|
||||
|
||||
----------------------------------------------------
|
||||
-- 3. Funkcje
|
||||
----------------------------------------------------
|
||||
-- Prosta funkcja przyjmująca dwa argumenty
|
||||
add a b = a + b
|
||||
|
||||
-- Pamiętaj, że podczas stosowania ghci, interpretera Haskella, wszelkie
|
||||
-- definicje muszą zostać poprzedzone słowem `let`, na przykład:
|
||||
-- let add a b = a + b
|
||||
|
||||
-- Używanie funkcji:
|
||||
add 1 2 -- 3
|
||||
|
||||
-- Nazwę funkcji można podać między dwoma argumentami, ale wtedy musi zostać
|
||||
-- otoczona grawisami:
|
||||
1 `add` 2 -- 3
|
||||
|
||||
-- Nazwa funkcji nie musi zawierać żadnych liter, przykładem czego jest
|
||||
-- operator dzielenia:
|
||||
(//) a b = a `div` b
|
||||
35 // 4 -- 8
|
||||
|
||||
-- Strażnicy: prosty sposób na rozbijanie funkcji na przypadki
|
||||
fib x
|
||||
| x < 2 = 1
|
||||
| otherwise = fib (x - 1) + fib (x - 2)
|
||||
|
||||
-- Dopasowanie wzorca jest podobne. Haskell sam automatycznie wybierze, która
|
||||
-- z poniższych definicji fib powinna zostać użyta:
|
||||
fib 1 = 1
|
||||
fib 2 = 2
|
||||
fib x = fib (x - 1) + fib (x - 2)
|
||||
|
||||
-- Dopasowanie z krotkami:
|
||||
foo (x, y) = (x + 1, y + 2)
|
||||
|
||||
-- Dopasowanie z listami. Tutaj `x` jest pierwszym elementem listy,
|
||||
-- natomiast `xs` to jej reszta (ogon). Poniższa funkcja nakłada funkcję
|
||||
-- na każdy z elementów listy:
|
||||
myMap func [] = []
|
||||
myMap func (x:xs) = func x:(myMap func xs)
|
||||
|
||||
-- Funkcje anonimowe tworzone są przy użyciu w-tył-ciachu, po którym następują
|
||||
-- wszystkie argumenty:
|
||||
myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
|
||||
|
||||
-- używanie zwijania z anonimowymi funkcjami: foldl1 zwija z lewej strony,
|
||||
-- przyjmując jako wartość początkową zbieracza pierwszy element listy.
|
||||
foldl1 (\acc x -> acc + x) [1..5] -- 15
|
||||
|
||||
----------------------------------------------------
|
||||
-- 4. Więcej funkcji
|
||||
----------------------------------------------------
|
||||
|
||||
-- częściowe nakładanie: jeśli funkcja nie otrzyma wszystkich swoich argumentów,
|
||||
-- zostaje cześciowo nałożona - zwraca funkcję, która przyjmuje pozostałe,
|
||||
-- brakujące argumenty.
|
||||
|
||||
add a b = a + b
|
||||
foo = add 10 -- foo jest teraz funkcją, która przyjmuje liczbę, zwiększa ją o 10
|
||||
foo 5 -- 15
|
||||
|
||||
-- Inny sposób na zapisanie tego samego:
|
||||
foo = (10+)
|
||||
foo 5 -- 15
|
||||
|
||||
-- składanie funkcji:
|
||||
-- operator `.` składa wiele funkcji w jedną.
|
||||
-- Dla przykładu, foo jest funkcją, która powiększa swój argument o 10, mnoży
|
||||
-- tak uzyskaną liczbę przez 4 i zwraca wynik:
|
||||
foo = (4*) . (10+)
|
||||
|
||||
-- 4*(10 + 5) = 60
|
||||
foo 5 -- 60
|
||||
|
||||
-- ustalanie kolejności
|
||||
-- Haskell posiada inny operator, `$`, który nakłada funkcję do podanego
|
||||
-- parametru. W przeciwieństwie do zwykłego lewostronnie łącznego nakładania
|
||||
-- funkcji, którego priorytet jest najwyższy (10), operator `$` posiada
|
||||
-- priorytet 0 i jest prawostronnie łączny. Tak niski priorytet oznacza, że
|
||||
-- wyrażenie po prawej traktowane jest jako parametr funkcji po lewej
|
||||
|
||||
-- wcześniej
|
||||
even (fib 7) -- fałsz
|
||||
|
||||
-- równoważnie
|
||||
even $ fib 7 -- fałsz
|
||||
|
||||
-- składanie funkcji
|
||||
even . fib $ 7 -- fałsz
|
||||
|
||||
|
||||
----------------------------------------------------
|
||||
-- 5. Sygnatury typów
|
||||
----------------------------------------------------
|
||||
|
||||
-- Haskell posiada wyjątkowo silny system typów, w którym każde poprawne
|
||||
-- wyrażenie ma swój typ.
|
||||
|
||||
-- Kilka podstawowych typów:
|
||||
5 :: Integer
|
||||
"hello" :: String
|
||||
True :: Bool
|
||||
|
||||
-- Funkcje też są określonego typu.
|
||||
-- `not` przyjmuje wartość logiczną i taką też zwraca:
|
||||
-- not :: Bool -> Bool
|
||||
|
||||
-- Przykład funkcji przyjmującej dwa argumenty
|
||||
-- add :: Integer -> Integer -> Integer
|
||||
|
||||
-- Dobrą praktyką podczas definiowania wartości jest napisanie nad nią
|
||||
-- także jej typu:
|
||||
double :: Integer -> Integer
|
||||
double x = x * 2
|
||||
|
||||
----------------------------------------------------
|
||||
-- 6. Wyrażenia warunkowe
|
||||
----------------------------------------------------
|
||||
|
||||
-- wyrażenie warunkowe
|
||||
haskell = if 1 == 1 then "wspaniale" else "paskudnie" -- haskell = "wspaniale"
|
||||
|
||||
-- wyrażenie warunkowe można rozbić na wiele linii,
|
||||
-- ale trzeba uważać na wcięcia w kodzie
|
||||
haskell = if 1 == 1
|
||||
then "wspaniale"
|
||||
else "paskudnie"
|
||||
|
||||
-- rozpatrywanie przypadków: oto jak można parsować argumenty z linii poleceń:
|
||||
case args of
|
||||
"help" -> printHelp
|
||||
"start" -> startProgram
|
||||
_ -> putStrLn "bad args"
|
||||
|
||||
-- Haskell zastępuje pętle (których nie ma) rekurencyjnymi wywołaniami funkcji.
|
||||
-- map aplikuje funkcję do każdego elementu listy:
|
||||
|
||||
map (*2) [1..5] -- [2, 4, 6, 8, 10]
|
||||
|
||||
-- możesz zdefiniować funkcję for przy użyciu map:
|
||||
for array func = map func array
|
||||
|
||||
-- a następnie użyć jej:
|
||||
for [0..5] $ \i -> show i
|
||||
|
||||
-- mogliśmy użyć krótszego zapisu bez zmiany działania funkcji for:
|
||||
for [0..5] show
|
||||
|
||||
-- Do redukcji listy służy polecenie foldl (foldr):
|
||||
-- foldl <fn> <initial value> <list>
|
||||
foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
|
||||
|
||||
-- Jest to równoważne z:
|
||||
(2 * (2 * (2 * 4 + 1) + 2) + 3)
|
||||
|
||||
-- foldl składa od od lewej strony, foldr od prawej
|
||||
foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
|
||||
|
||||
-- To zaś równoważne jest:
|
||||
(2 * 1 + (2 * 2 + (2 * 3 + 4)))
|
||||
|
||||
----------------------------------------------------
|
||||
-- 7. Typy danych
|
||||
----------------------------------------------------
|
||||
|
||||
-- Oto jak tworzy się nowe typy danych w Haskellu:
|
||||
|
||||
data Color = Red | Blue | Green
|
||||
|
||||
-- Teraz można używać ich we własnych funkcjach:
|
||||
|
||||
say :: Color -> String
|
||||
say Red = "You are Red!"
|
||||
say Blue = "You are Blue!"
|
||||
say Green = "You are Green!"
|
||||
|
||||
-- Twoje typy danych mogą posiadać nawet parametry:
|
||||
|
||||
data Maybe a = Nothing | Just a
|
||||
|
||||
-- Wszystkie poniższe są typu Maybe
|
||||
Just "hello" -- typu `Maybe String`
|
||||
Just 1 -- typu `Maybe Int`
|
||||
Nothing -- typu `Maybe a` for any `a`
|
||||
|
||||
----------------------------------------------------
|
||||
-- 8. Haskell IO
|
||||
----------------------------------------------------
|
||||
|
||||
-- Chociaż obsługa wejścia i wyjścia nie może zostać wyjaśniona przez poznaniem
|
||||
-- monad, spróbujemy zrobić to częściowo
|
||||
|
||||
-- Wykonanie programu napisanego w Haskellu wywołuje funkcję `main`
|
||||
-- Musi zwrócić wartość typu `IO a` dla pewnego `a`. Przykład:
|
||||
|
||||
main :: IO ()
|
||||
main = putStrLn $ "Hello, sky! " ++ (say Blue)
|
||||
-- putStrLn has type String -> IO ()
|
||||
|
||||
-- Najłatwiej obsłużyć wejście i wyjście, kiedy program zostanie
|
||||
-- zaimplementowany jako funkcja String -> String. Funkcja
|
||||
-- interact :: (String -> String) -> IO ()
|
||||
-- pobiera pewien tekst, wykonuje na nim operacje, po czym wypisuje wynik.
|
||||
|
||||
countLines :: String -> String
|
||||
countLines = show . length . lines
|
||||
|
||||
main' = interact countLines
|
||||
|
||||
-- Możesz myśleć o wartości typu `IO ()` jako reprezentującej ciąg czynności,
|
||||
-- które komputer ma wykonać, zupełnie niczym program komputerowy w imperatywnym
|
||||
-- języku programowania. Akcje można łączyć przy użyciu notacji `do`:
|
||||
|
||||
sayHello :: IO ()
|
||||
sayHello = do
|
||||
putStrLn "What is your name?"
|
||||
name <- getLine -- this gets a line and gives it the name "name"
|
||||
putStrLn $ "Hello, " ++ name
|
||||
|
||||
-- Ćwiczenie: napisz własną wersję `interact`,
|
||||
-- która czyta tylko jedną linię wejścia.
|
||||
|
||||
-- Kod w `sayHello` nigdy się nie wykona. Jedyną akcją, która zostanie
|
||||
-- uruchomiona, jest wartość `main`.
|
||||
-- Aby uruchomić `sayHello`, należy zastąpić poprzednią definicję `main` przez
|
||||
-- main = sayHello
|
||||
|
||||
-- Spróbujmy lepiej zrozumieć, jak działa funkcja `getLine`, której właśnie
|
||||
-- użyliśmy. Jej typem jest
|
||||
-- getLine :: IO String
|
||||
-- Możesz myśleć o wartości typu `IO a` jako reprezentującej program, który
|
||||
-- wygeneruje wartość typu `a`, poza wszystkim innym, co jeszcze zrobi.
|
||||
-- Możemy także tworzyć własne akcje typu `IO String`:
|
||||
|
||||
action :: IO String
|
||||
action = do
|
||||
putStrLn "This is a line. Duh"
|
||||
input1 <- getLine
|
||||
input2 <- getLine
|
||||
-- The type of the `do` statement is that of its last line.
|
||||
-- `return` is not a keyword, but merely a function
|
||||
return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
|
||||
|
||||
-- Możemy użyć tego tak jak używaliśmy `getLine`:
|
||||
|
||||
main'' = do
|
||||
putStrLn "I will echo two lines!"
|
||||
result <- action
|
||||
putStrLn result
|
||||
putStrLn "This was all, folks!"
|
||||
|
||||
-- Typ `IO` jest przykładem monady. Sposób w jakim Haskell używa monad do
|
||||
-- obsługi wejścia i wyjścia pozwala mu być czysto funkcyjnym językiem.
|
||||
-- Każda funkcja, która wchodzi w interakcje ze światem zewnętrznym, oznaczana
|
||||
-- jest jako `IO` w jej sygnaturze typu, co umożliwia odróżnianie funkcji
|
||||
-- czystych od zależnych od świata lub modyfikujących stan.
|
||||
|
||||
-- To naprawdę użyteczna własność, dzięki której jesteśmy w stanie uruchamiać
|
||||
-- czyste funkcje jednocześnie.
|
||||
|
||||
----------------------------------------------------
|
||||
-- 9. Interaktywne środowisko programowania
|
||||
----------------------------------------------------
|
||||
|
||||
-- Aby uruchomić repl (read-eval-print loop, interaktywne środowisko), należy
|
||||
-- wpisać `ghci`. Można już programować. Do definiowania nowych wartości służy
|
||||
-- słowo kluczowe `let`:
|
||||
|
||||
let foo = 5
|
||||
|
||||
-- Do sprawdzania typów dowolnej wartości (wyrażenia) wykorzystuje się `:t`:
|
||||
|
||||
> :t foo
|
||||
foo :: Integer
|
||||
|
||||
-- Działania takie jak `+`, `:` czy `$`, są funkcjami.
|
||||
-- Przed sprawdzeniem ich typu należy otoczyć je nawiasami:
|
||||
|
||||
> :t (:)
|
||||
(:) :: a -> [a] -> [a]
|
||||
|
||||
-- Dodatkowych informacji dostarcza `:i`:
|
||||
|
||||
> :i (+)
|
||||
class Num a where
|
||||
(+) :: a -> a -> a
|
||||
...
|
||||
-- Defined in ‘GHC.Num’
|
||||
infixl 6 +
|
||||
|
||||
-- Można nawet wykonywać akcje typu `IO ()`!
|
||||
|
||||
> sayHello
|
||||
What is your name?
|
||||
Friend!
|
||||
Hello, Friend!
|
||||
```
|
||||
|
||||
Pominęliśmy wiele aspektów Haskella, wliczając w to monady. To właśnie one
|
||||
sprawiają, że programowanie w Haskellu sprawia tyle frajdy. Na zakończenie
|
||||
pokażę Tobie implementację algorytmu quicksort w Haskellu:
|
||||
|
||||
```haskell
|
||||
qsort [] = []
|
||||
qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
|
||||
where lesser = filter (< p) xs
|
||||
greater = filter (>= p) xs
|
||||
```
|
||||
|
||||
Haskell może zostać zainstalowany na co najmniej dwa sposoby:
|
||||
- tradycyjnie [przy użyciu Cabala](http://www.haskell.org/platform/),
|
||||
- nowocześnie [z pomocą Stack](https://www.stackage.org/install).
|
||||
|
||||
Godnymi poleceniami wprowadzeniami są wspaniałe
|
||||
[Learn you a Haskell](http://learnyouahaskell.com/) albo
|
||||
[Real World Haskell](http://book.realworldhaskell.org/).
|
||||
1011
pl/java.md
Normal file
1011
pl/java.md
Normal file
File diff suppressed because it is too large
Load Diff
86
pl/json.md
Normal file
86
pl/json.md
Normal file
@@ -0,0 +1,86 @@
|
||||
---
|
||||
category: language
|
||||
language: JSON
|
||||
contributors:
|
||||
- ["Anna Harren", "https://github.com/iirelu"]
|
||||
- ["Marco Scannadinari", "https://github.com/marcoms"]
|
||||
- ["himanshu", "https://github.com/himanshu81494"]
|
||||
- ["Michael Neth", "https://github.com/infernocloud"]
|
||||
translators:
|
||||
- ["Michał Mitrosz", "https://github.com/Voltinus"]
|
||||
lang: pl-pl
|
||||
filename: learnjson-pl.json
|
||||
---
|
||||
|
||||
JSON to bardzo prosty format wymiany danych. Jak jest napisane na [json.org](http://json.org), jest łatwy do pisania i czytania dla ludzi i do parsowania i generowania dla maszyn.
|
||||
|
||||
Kod JSON musi zawierać któreś z poniższych:
|
||||
* Zbiór par nazwa/wartość (`{ }`). W różnych językach jest to obiekt, rekord, struktura, słownik, tablica mieszająca, lista z kluczami, lub tablica asocjacyjna.
|
||||
* Uporządkowana lista wartości (`[ ]`). W różnych językach jest to tablica, wektor, lista, lub sekwencja.
|
||||
tablica/lista/sekwencja (`[ ]`) lub słownik/obiekt/tablica asocjacyjna (`{ }`).
|
||||
|
||||
JSON w swojej czystej postaci nie ma komentarzy, ale większość parserów akceptuje komentarze w stylu C (`//`, `/* */`). Niektóre parsery pozwalają także na końcowy przecinek (np. przecinek po ostatnim elemencie w tablicy lub po ostatiej własności obiektu), ale powinien on być omijany dla lepszej kompatybilności.
|
||||
|
||||
Dla celów tego poradnika wszystko będzie 100% kodem JSON. Na szczęście, to samo mówi za siebie.
|
||||
|
||||
Wspierane typy danych:
|
||||
|
||||
* Łańcuchy znaków: `"witaj"`, `"\"Cytat.\""`, `"\u0abe"`, `"Nowa linia.\n"`
|
||||
* Liczby: `23`, `0.11`, `12e10`, `3.141e-10`, `1.23e+4`
|
||||
* Obiekty: `{ "klucz": "wartość" }`
|
||||
* Tablice: `["Wartości"]`
|
||||
* Inne: `true`, `false`, `null`
|
||||
|
||||
```json
|
||||
{
|
||||
"klucz": "wartość",
|
||||
|
||||
"klucze": "muszą być zawsze zamknięte w podwójnych cudzysłowach",
|
||||
"liczby": 0,
|
||||
"łańcuchy": "Hellø, wørld. Wszystkie znaki unicode są dozwolone, razem z \"sekwencjami escape\".",
|
||||
"wartości logiczne?": true,
|
||||
"nic": null,
|
||||
|
||||
"duża liczba": 1.2e+100,
|
||||
|
||||
"obiekty": {
|
||||
"komentarz": "Większość twojej struktury będzie zbudowana z obiektów.",
|
||||
|
||||
"tablica": [0, 1, 2, 3, "Tablice mogą mieć wewnątrz cokolwiek", 5],
|
||||
|
||||
"inny obiekt": {
|
||||
"komentarz": "Elementy mogą się w sobie zawierać, bardzo użyteczne"
|
||||
}
|
||||
},
|
||||
|
||||
"głupota": [
|
||||
{
|
||||
"źródła potasu": ["banany"]
|
||||
},
|
||||
[
|
||||
[1, 0, 0, 0],
|
||||
[0, 1, 0, 0],
|
||||
[0, 0, 1, "neo"],
|
||||
[0, 0, 0, 1]
|
||||
]
|
||||
],
|
||||
|
||||
"styl alternatywny": {
|
||||
"komentarz": "sprawdź to!"
|
||||
, "pozycja przecinka": "nie ma znaczenia, o ile jest przed następnym kluczem, jest poprawnie"
|
||||
, "następny komentarz": "jak ładnie"
|
||||
},
|
||||
|
||||
|
||||
|
||||
"znaki białe": "nie mają znaczenia",
|
||||
|
||||
|
||||
|
||||
"to było krótkie": "I gotowe. Wiesz już wszystko o formacie JSON."
|
||||
}
|
||||
```
|
||||
|
||||
## Dalsza lektura
|
||||
|
||||
* [JSON.org](http://json.org) Cały JSON pięknie wytłumaczony na podstawie grafik przypominających schematy blokowe.
|
||||
169
pl/perl.md
Normal file
169
pl/perl.md
Normal file
@@ -0,0 +1,169 @@
|
||||
---
|
||||
category: language
|
||||
language: Perl
|
||||
filename: learnperl-pl.pm
|
||||
contributors:
|
||||
- ["Korjavin Ivan", "http://github.com/korjavin"]
|
||||
- ["Dan Book", "http://github.com/Grinnz"]
|
||||
translators:
|
||||
- ["Michał Kupczyński", "http://github.com/ukoms"]
|
||||
lang: pl-pl
|
||||
|
||||
---
|
||||
|
||||
Perl jest wysoce użytecznym, bogatym w wiele opcji językiem programowania
|
||||
z ponad 25 latami nieustannego rozwoju.
|
||||
|
||||
Perl używany jest na ponad 100 różnych platformach (od przenośnych do w
|
||||
pełni stacjonarnych) i nadaje się zarówno do szybkiego prototypowania jak
|
||||
i projektów deweloperskich prowadzonych na szeroką skalę.
|
||||
|
||||
```perl
|
||||
# Pojedyncza linia komentarza zaczyna się od znaku hasha (płotka) "#".
|
||||
|
||||
#### Typy zmiennych w Perlu
|
||||
|
||||
# Zmienna zaczyna się od symbolu dolara "$".
|
||||
# Prawidłowa nazwa zmiennej zaczyna się od litery lub podkreślnika "_",
|
||||
# po których następuje dowolna ilość liter, cyfr i podkreślników.
|
||||
|
||||
### W Perlu występują trzy główne typy zmiennych: skalary, tablice i hasze.
|
||||
|
||||
## Skalary
|
||||
# Skalar przechowuje pojedynczą wartość:
|
||||
my $zwierze = "wielbłąd";
|
||||
my $odpowiedź = 42;
|
||||
|
||||
# Wartości skalarne mogą być ciągami znaków, liczbami całkowitymi lub
|
||||
# zmiennoprzecinkowymi, zaś Perl automatycznie dokonuje konwersji pomiędzy nimi,
|
||||
# w zależności od wykonywanego kodu/kontekstu.
|
||||
|
||||
## Tablice
|
||||
# Tablica przechowuje listę wartości:
|
||||
my @zwierzęta = ("wielbłąd", "alpaka", "sowa");
|
||||
my @liczby = (23, 42, 69);
|
||||
my @mieszanka = ("wielbłąd", 42, 1.23);
|
||||
|
||||
## Hasze
|
||||
# Hasz przechowuje zestawy par klucz-wartość:
|
||||
my %kolor_owocu = ('jabłko', 'czerwony', 'banan', 'żółty');
|
||||
|
||||
# Możesz używać białych znaków (spacje, tabulatory) i operatora strzałki "=>"
|
||||
# by czytelniej sformatować zapis hasza:
|
||||
my %kolor_owocu = (
|
||||
jabłko => 'czerwony',
|
||||
banan => 'żółty',
|
||||
);
|
||||
|
||||
# Skalary, tablice i hasze są bardziej wyczerpująco udokumentowane w dokumencie
|
||||
# [perldoc perldata](http://perldoc.perl.org/perldata.html).
|
||||
|
||||
# Bardziej złożone typy danych mogą być stworzone poprzez używanie referencji,
|
||||
# które pozwalają Ci zbudować listy i hasze wewnątrz list i haszy.
|
||||
|
||||
#### Warunki logiczne i pętle
|
||||
|
||||
# W Perlu występują typowe warunki i pętle.
|
||||
if ($var) {
|
||||
...
|
||||
} elsif ($var eq 'bar') {
|
||||
...
|
||||
} else {
|
||||
...
|
||||
}
|
||||
|
||||
unless (warunek) {
|
||||
...
|
||||
}
|
||||
# Powyższy zapis jest równoznaczny zapisowi "if (!warunek)"
|
||||
|
||||
# Perlowy skrócony zapis warunków:
|
||||
print "Siema!" if $rozochocony;
|
||||
print "Nie mamy bananów" unless $banany;
|
||||
|
||||
# Pętla while
|
||||
while (warunek) {
|
||||
...
|
||||
}
|
||||
|
||||
# Pętle for oraz foreach
|
||||
for ($i = 0; $i <= $max; $i++) {
|
||||
...
|
||||
}
|
||||
|
||||
foreach (@tablica) {
|
||||
print "Tym elementem jest $_\n";
|
||||
}
|
||||
|
||||
# lub
|
||||
|
||||
foreach my $iterator (@tablica) {
|
||||
print "Iterowanym elementem jest $iterator\n";
|
||||
}
|
||||
|
||||
#### Wyrażenia regularne
|
||||
|
||||
# Perlowe wyrażenia regularne są tematem tak rozległym, jak wymagającym.
|
||||
# Istnieje ogromna ilość dokumentacji w artykułach takich jak
|
||||
# [perlrequick](http://perldoc.perl.org/perlrequick.html),
|
||||
# [perlretut](http://perldoc.perl.org/perlretut.html) i inne.
|
||||
# W dużym skrócie, podstawy perlowych wyrażeń regularnych są następujące:
|
||||
|
||||
# Proste dopasowanie:
|
||||
if (/foo/) { ... } # prawda jeżeli $_ zawiera "foo"
|
||||
if ($a =~ /foo/) { ... } # prawda jeżeli $a zawiera "foo"
|
||||
|
||||
# Prosta zamiana:
|
||||
# Zamienia "foo" na "bar" w zmiennej $a
|
||||
$a =~ s/foo/bar/;
|
||||
# Zamienia WSZYSTKIE WYSTĄPIENIA "foo" na "bar" w zmiennej $a
|
||||
$a =~ s/foo/bar/g;
|
||||
|
||||
#### Pliki i I/O
|
||||
|
||||
# Możesz otworzyć plik do odczytu lub zapisu używając funkcji "open ()".
|
||||
open (my $odczyt, "<", "odczyt.txt") or die "Błąd otwierania input.txt: $!";
|
||||
open (my $zapis, ">", "zapis.txt") or die "Błąd otwierania output.txt: $!";
|
||||
open (my $dopisanie, ">>", "my.log") or die "Błąd otwierania my.log: $!";
|
||||
|
||||
# Pliki możesz odczytywać z otworzonego handlera używając operatora "<>"
|
||||
# (operator diamentowy). W kontekście skalarnym (przypisanie wyniku do skalara)
|
||||
# operator ten zczytuje pojedynczą linię pliku, w kontekście listowym
|
||||
# (przypisanie wyniku do tablicy) zczytuje całą zawartość pliku, przypisując
|
||||
# każdą linię jako kolejny element listy:
|
||||
my $linia = <$in>;
|
||||
my @linie = <$in>;
|
||||
|
||||
#### Perlowe funkcje (procedury)
|
||||
|
||||
# Pisanie funkcji (procedur) jest proste:
|
||||
sub logger {
|
||||
my $wiadomosc_do_loga = shift;
|
||||
open (my HANDLER, ">>", "my.log") or die "Błąd otwierania my.log: $!";
|
||||
print HANDLER $wiadomosc_do_loga;
|
||||
}
|
||||
|
||||
# Teraz można używać napisanej funkcji, tak jak każdej innej wbudowanej
|
||||
# funkcji perlowej:
|
||||
logger ("Mamy funkcję perlową");
|
||||
```
|
||||
|
||||
#### Używanie modułów perlowych
|
||||
|
||||
Moduły perlowe dostarczają szeroki wachlarz możliwości, byś nie musiał
|
||||
wynajdywać koła na nowo. Moduły te można pobrać z [CPAN](http://www.cpan.org).
|
||||
Sam Perl zawiera w swoich dystrybucjach kilka najpopularniejszych modułów
|
||||
z repozytorium [CPAN](http://www.cpan.org).
|
||||
|
||||
Najczęściej zadawane pytania [perlfaq](http://perldoc.perl.org/perlfaq.html)
|
||||
- zawierają pytania i odpowiedzi dotyczące wielu typowo realizowanych zadań.
|
||||
Często znajdziesz tam również sugestie dotyczące użycia najlepszego modułu
|
||||
z repozytorium CPAN do zrealizowania konkretnego zadania.
|
||||
|
||||
|
||||
#### Do doczytania
|
||||
|
||||
- [perl-tutorial](http://perl-tutorial.org/)
|
||||
- [Naucz się Perla na www.perl.com](http://www.perl.org/learn.html)
|
||||
- [perldoc](http://perldoc.perl.org/)
|
||||
- wbudowane w Perla: `perldoc perlintro`
|
||||
634
pl/pythonlegacy.md
Normal file
634
pl/pythonlegacy.md
Normal file
@@ -0,0 +1,634 @@
|
||||
---
|
||||
language: Python 2 (legacy)
|
||||
filename: learnpythonlegacy-pl.py
|
||||
contributors:
|
||||
- ["Louie Dinh", "http://ldinh.ca"]
|
||||
- ["Amin Bandali", "http://aminbandali.com"]
|
||||
- ["Andre Polykanine", "https://github.com/Oire"]
|
||||
translators:
|
||||
- ["Dominik Krzemiński", "https://github.com/dokato"]
|
||||
lang: pl-pl
|
||||
---
|
||||
|
||||
Python został opracowany przez Guido Van Rossuma na początku lat 90-tych.
|
||||
Obecnie jest jednym z najbardziej popularnych języków programowania.
|
||||
Zakochałem się w Pythonie dzięki porządkowi, jaki utrzymywany jest w kodzie.
|
||||
To po prostu wykonywalny pseudokod.
|
||||
|
||||
Uwaga: Ten artykuł odnosi się do wersji Pythona 2.7, ale powinien
|
||||
działać w wersjach 2.x. Dla wersji 3.x znajdziesz odpowiedni artykuł na stronie głównej.
|
||||
|
||||
```python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# Pojedyncze komentarze oznaczamy takim symbolem.
|
||||
|
||||
""" Wielolinijkowe napisy zapisywane są przy użyciu
|
||||
potrójnych cudzysłowów i często
|
||||
wykorzystywane są jako komentarze.
|
||||
"""
|
||||
|
||||
####################################################
|
||||
## 1. Podstawowe typy danych i operatory
|
||||
####################################################
|
||||
|
||||
# Liczby to liczby
|
||||
3 # => 3
|
||||
|
||||
# Matematyka jest intuicyjna
|
||||
1 + 1 # => 2
|
||||
8 - 1 # => 7
|
||||
10 * 2 # => 20
|
||||
35 / 5 # => 7
|
||||
|
||||
# Dzielenie może być kłopotliwe. Poniższe działanie to dzielenie
|
||||
# całkowitoliczbowe(int) i wynik jest automatycznie zaokrąglany.
|
||||
5 / 2 # => 2
|
||||
|
||||
# Aby to naprawić, musimy powiedzieć nieco o liczbach zmiennoprzecinkowych.
|
||||
2.0 # To liczba zmiennoprzecinkowa, tzw. float
|
||||
11.0 / 4.0 # => 2.75 ahhh...znacznie lepiej
|
||||
|
||||
# Wynik dzielenia całkowitoliczbowego jest obcinany dla liczb
|
||||
# dodatnich i ujemnych.
|
||||
5 // 3 # => 1
|
||||
5.0 // 3.0 # => 1.0 # działa też na floatach
|
||||
-5 // 3 # => -2
|
||||
-5.0 // 3.0 # => -2.0
|
||||
|
||||
# Operator modulo - wyznaczanie reszty z dzielenia
|
||||
7 % 3 # => 1
|
||||
|
||||
# Potęgowanie (x do potęgi y-tej)
|
||||
2**4 # => 16
|
||||
|
||||
# Wymuszanie pierwszeństwa w nawiasach
|
||||
(1 + 3) * 2 # => 8
|
||||
|
||||
# Operacje logiczne
|
||||
# Zauważ, że przy "and" i "or" trzeba zwracać uwagę na rozmiar liter
|
||||
True and False #=> False # Fałsz
|
||||
False or True #=> True # Prawda
|
||||
|
||||
# Zauważ, że operatorów logicznych można używać z intami
|
||||
0 and 2 #=> 0
|
||||
-5 or 0 #=> -5
|
||||
0 == False #=> True
|
||||
2 == True #=> False
|
||||
k1 == True #=> True
|
||||
|
||||
# aby zanegować, użyj "not"
|
||||
not True # => False
|
||||
not False # => True
|
||||
|
||||
# Równość ==
|
||||
1 == 1 # => True
|
||||
2 == 1 # => False
|
||||
|
||||
# Nierówność !=
|
||||
1 != 1 # => False
|
||||
2 != 1 # => True
|
||||
|
||||
# Więcej porównań
|
||||
1 < 10 # => True
|
||||
1 > 10 # => False
|
||||
2 <= 2 # => True
|
||||
2 >= 2 # => True
|
||||
|
||||
# Porównania można układać w łańcuch!
|
||||
1 < 2 < 3 # => True
|
||||
2 < 3 < 2 # => False
|
||||
|
||||
# Napisy (typ string) tworzone są przy użyciu cudzysłowów " lub '
|
||||
"Jestem napisem."
|
||||
'Ja też jestem napisem.'
|
||||
|
||||
# Napisy można dodawać!
|
||||
"Witaj " + "świecie!" # => "Witaj świecie!"
|
||||
|
||||
# ... a nawet mnożyć
|
||||
"Hej" * 3 # => "HejHejHej"
|
||||
|
||||
# Napis może być traktowany jako lista znaków
|
||||
"To napis"[0] # => 'T'
|
||||
|
||||
# % może być używane do formatowania napisów:
|
||||
"%s są %s" % ("napisy", "fajne")
|
||||
|
||||
# Jednak nowszym sposobem formatowania jest metoda "format".
|
||||
# Ta metoda jest obecnie polecana:
|
||||
"{0} są {1}".format("napisy", "fajne")
|
||||
# Jeśli nie chce ci się liczyć, użyj słów kluczowych.
|
||||
"{imie} chce zjeść {jadlo}".format(imie="Bob", jadlo="makaron")
|
||||
|
||||
# None jest obiektem
|
||||
None # => None
|
||||
|
||||
# Nie używaj "==" w celu porównania obiektów z None
|
||||
# Zamiast tego użyj "is"
|
||||
"etc" is None # => False
|
||||
None is None # => True
|
||||
|
||||
# Operator 'is' testuje identyczność obiektów. Nie jest to zbyt
|
||||
# pożyteczne, gdy działamy tylko na prostych wartościach,
|
||||
# ale przydaje się, gdy mamy do czynienia z obiektami.
|
||||
|
||||
# None, 0 i pusty napis "" są odpowiednikami logicznego False.
|
||||
# Wszystkie inne wartości są uznawane za prawdę (True)
|
||||
bool(0) # => False
|
||||
bool("") # => False
|
||||
|
||||
|
||||
####################################################
|
||||
## 2. Zmienne i zbiory danych
|
||||
####################################################
|
||||
|
||||
# Python ma instrukcję wypisującą "print" we wszystkich wersjach 2.x, ale
|
||||
# została ona usunięta z wersji 3.
|
||||
print "Jestem Python. Miło Cię poznać!"
|
||||
# Python ma też funkcję "print" dostępną w wersjach 2.7 i 3...
|
||||
# ale w 2.7 musisz dodać import (odkomentuj):
|
||||
# from __future__ import print_function
|
||||
print("Ja też jestem Python! ")
|
||||
|
||||
# Nie trzeba deklarować zmiennych przed przypisaniem.
|
||||
jakas_zmienna = 5 # Konwencja mówi: używaj małych liter i znaków podkreślenia _
|
||||
jakas_zmienna # => 5
|
||||
|
||||
# Próba dostępu do niezadeklarowanej zmiennej da błąd.
|
||||
# Przejdź do sekcji Obsługa wyjątków, aby dowiedzieć się więcej...
|
||||
inna_zmienna # Wyrzuca nazwę błędu
|
||||
|
||||
# "if" może być użyte jako wyrażenie
|
||||
"huraaa!" if 3 > 2 else 2 # => "huraaa!"
|
||||
|
||||
# Listy:
|
||||
li = []
|
||||
# Możesz zacząć od wypełnionej listy
|
||||
inna_li = [4, 5, 6]
|
||||
|
||||
# Dodaj na koniec, używając "append"
|
||||
li.append(1) # li to teraz [1]
|
||||
li.append(2) # li to teraz [1, 2]
|
||||
li.append(4) # li to teraz [1, 2, 4]
|
||||
li.append(3) # li to teraz [1, 2, 4, 3]
|
||||
# Usuwanie z konca da "pop"
|
||||
li.pop() # => 3 a li stanie się [1, 2, 4]
|
||||
# Dodajmy ponownie
|
||||
li.append(3) # li to znowu [1, 2, 4, 3].
|
||||
|
||||
# Dostęp do list jak do każdej tablicy
|
||||
li[0] # => 1
|
||||
# Aby nadpisać wcześniej wypełnione miejsca w liście, użyj znaku =
|
||||
li[0] = 42
|
||||
li[0] # => 42
|
||||
li[0] = 1 # Uwaga: ustawiamy starą wartość
|
||||
# Tak podglądamy ostatni element
|
||||
li[-1] # => 3
|
||||
|
||||
# Jeżeli wyjdziesz poza zakres...
|
||||
li[4] # ... zobaczysz IndexError
|
||||
|
||||
# Możesz też tworzyć wycinki.
|
||||
li[1:3] # => [2, 4]
|
||||
# Bez początku
|
||||
li[2:] # => [4, 3]
|
||||
# Omijamy koniec
|
||||
li[:3] # => [1, 2, 4]
|
||||
# Wybierz co drugi
|
||||
li[::2] # =>[1, 4]
|
||||
# Odwróć listę
|
||||
li[::-1] # => [3, 4, 2, 1]
|
||||
# Użyj kombinacji powyższych aby tworzyć bardziej skomplikowane wycinki
|
||||
# li[poczatek:koniec:krok]
|
||||
|
||||
# Usuń element używając "del"
|
||||
del li[2] # li to teraz [1, 2, 3]
|
||||
|
||||
# Listy można dodawać
|
||||
li + inna_li # => [1, 2, 3, 4, 5, 6]
|
||||
# Uwaga: wartości oryginalnych list li i inna_li się nie zmieniają.
|
||||
|
||||
# Do łączenia list użyj "extend()"
|
||||
li.extend(other_li) # li to teraz [1, 2, 3, 4, 5, 6]
|
||||
|
||||
# Sprawdź, czy element jest w liście używając "in"
|
||||
1 in li # => True
|
||||
|
||||
# "len()" pokazuje długość listy
|
||||
len(li) # => 6
|
||||
|
||||
|
||||
# Krotki (tuple) są jak listy, ale nie można ich modyfikować.
|
||||
tup = (1, 2, 3)
|
||||
tup[0] # => 1
|
||||
tup[0] = 3 # wyrzuci TypeError
|
||||
|
||||
# Ale wielu akcji dla list możesz używać przy krotkach
|
||||
len(tup) # => 3
|
||||
tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6)
|
||||
tup[:2] # => (1, 2)
|
||||
2 in tup # => True
|
||||
|
||||
# Można rozpakować krotki i listy do poszczególych zmiennych
|
||||
a, b, c = (1, 2, 3) # a to teraz 1, b jest 2, a c to 3
|
||||
# Jeżeli zapomnisz nawiasów, automatycznie tworzone są krotki
|
||||
d, e, f = 4, 5, 6
|
||||
# Popatrz jak prosto zamienić wartości
|
||||
e, d = d, e # d to teraz 5 a e to 4
|
||||
|
||||
|
||||
# Słowniki są również pożyteczne
|
||||
pusty_slownik = {}
|
||||
# Tu tworzymy wypełniony:
|
||||
pelen_slownik = {"raz": 1, "dwa": 2, "trzy": 3}
|
||||
|
||||
# Podglądany wartość
|
||||
pelen_slownik["one"] # => 1
|
||||
|
||||
# Wypisz wszystkie klucze, używając "keys()"
|
||||
pelen_slownik.keys() # => ["trzy", "dwa", "raz"]
|
||||
# Uwaga: słowniki nie zapamiętują kolejności kluczy.
|
||||
|
||||
# A teraz wszystkie wartości "values()"
|
||||
pelen_slownik.values() # => [3, 2, 1]
|
||||
# Uwaga: to samo dotyczy wartości.
|
||||
|
||||
# Sprawdzanie czy klucz występuje w słowniku za pomocą "in"
|
||||
"raz" in pelen_slownik # => True
|
||||
1 in pelen_slownik # => False
|
||||
|
||||
# Próba dobrania się do nieistniejącego klucza da KeyError
|
||||
pelen_slownik["cztery"] # KeyError
|
||||
|
||||
# Użyj metody "get()", aby uniknąć błędu KeyError
|
||||
pelen_slownik.get("raz") # => 1
|
||||
pelen_slownik.get("cztery") # => None
|
||||
# Metoda get zwraca domyślną wartość gdy brakuje klucza
|
||||
pelen_slownik.get("one", 4) # => 1
|
||||
pelen_slownik.get("cztery", 4) # => 4
|
||||
# zauważ, że pelen_slownik.get("cztery") wciąż zwraca => None
|
||||
# (get nie ustawia wartości słownika)
|
||||
|
||||
# przypisz wartość do klucza podobnie jak w listach
|
||||
pelen_slownik["cztery"] = 4 # teraz: pelen_slownik["cztery"] => 4
|
||||
|
||||
# "setdefault()" wstawia do słownika tylko jeśli nie było klucza
|
||||
pelen_slownik.setdefault("piec", 5) # pelen_slownik["piec"] daje 5
|
||||
pelen_slownik.setdefault("piec", 6) # pelen_slownik["piec"] to wciąż 5
|
||||
|
||||
|
||||
# Teraz zbiory (set) - działają jak zwykłe listy, ale bez potórzeń
|
||||
pusty_zbior = set()
|
||||
# Inicjalizujemy "set()" pewnymi wartościami
|
||||
jakis_zbior = set([1, 2, 2, 3, 4]) # jakis_zbior to teraz set([1, 2, 3, 4])
|
||||
|
||||
# kolejność nie jest zachowana, nawet gdy wydaje się posortowane
|
||||
inny_zbior = set([4, 3, 2, 2, 1]) # inny_zbior to set([1, 2, 3, 4])
|
||||
|
||||
# Od Pythona 2.7 nawiasy klamrowe {} mogą być użyte do deklarowania zbioru
|
||||
pelen_zbior = {1, 2, 2, 3, 4} # => {1, 2, 3, 4}
|
||||
|
||||
# Dodaj więcej elementów przez "add()"
|
||||
pelen_zbior.add(5) # pelen_zbior is now {1, 2, 3, 4, 5}
|
||||
|
||||
# Znajdź przecięcie (część wspólną) zbiorów, używając &
|
||||
inny_zbior = {3, 4, 5, 6}
|
||||
pelen_zbior & other_set # => {3, 4, 5}
|
||||
|
||||
# Suma zbiorów |
|
||||
pelen_zbior | other_set # => {1, 2, 3, 4, 5, 6}
|
||||
|
||||
# Różnicę zbiorów da znak -
|
||||
{1, 2, 3, 4} - {2, 3, 5} # => {1, 4}
|
||||
|
||||
# Sprawdzanie obecności w zbiorze: "in".
|
||||
2 in pelen_zbior # => True
|
||||
10 in pelen_zbior # => False
|
||||
|
||||
|
||||
####################################################
|
||||
## 3. Kontrola przepływu
|
||||
####################################################
|
||||
|
||||
# Tworzymy zmienną jakas_zm
|
||||
jakas_zm = 5
|
||||
|
||||
# Tutaj widzisz wyrażenie warunkowe "if". Wcięcia w Pythonie są ważne!
|
||||
# Poniższy kod wypisze "jakas_zm jest mniejsza niż 10"
|
||||
if jakas_zm > 10:
|
||||
print("jakas_zm jest wieksza niż 10")
|
||||
elif some_var < 10: # Opcjonalna klauzula elif
|
||||
print("jakas_zm jest mniejsza niż 10")
|
||||
else: # Również opcjonalna klauzula else
|
||||
print("jakas_zm jest równa 10")
|
||||
|
||||
|
||||
"""
|
||||
Pętla for iteruje po elementach listy, wypisując:
|
||||
pies to ssak
|
||||
kot to ssak
|
||||
mysz to ssak
|
||||
"""
|
||||
for zwierze in ["pies", "kot", "mysz"]:
|
||||
# Użyj metody format, aby umieścić wartość zmiennej w ciągu
|
||||
print("{0} to ssak".format(zwierze))
|
||||
|
||||
"""
|
||||
"range(liczba)" zwraca listę liczb
|
||||
z przedziału od zera do wskazanej liczby (bez niej):
|
||||
0
|
||||
1
|
||||
2
|
||||
3
|
||||
"""
|
||||
for i in range(4):
|
||||
print(i)
|
||||
|
||||
"""
|
||||
While to pętla, która jest wykonywana, dopóki spełniony jest warunek:
|
||||
0
|
||||
1
|
||||
2
|
||||
3
|
||||
"""
|
||||
x = 0
|
||||
while x < 4:
|
||||
print(x)
|
||||
x += 1 # Skrót od x = x + 1
|
||||
|
||||
# Wyjątki wyłapujemy, używając try i except
|
||||
|
||||
# Działa w Pythonie 2.6 i wyższych:
|
||||
try:
|
||||
# Użyj "raise" aby wyrzucić wyjątek
|
||||
raise IndexError("To błąd indeksu")
|
||||
except IndexError as e:
|
||||
pass # Pass to brak reakcji na błąd. Zwykle opisujesz tutaj, jak program ma się zachować w przypadku błędu.
|
||||
except (TypeError, NameError):
|
||||
pass # kilka wyjątków można przechwycić jednocześnie.
|
||||
else: # Opcjonalna część bloku try/except. Musi wystąpić na końcu
|
||||
print "Wszystko ok!" # Zadziała tylko, gdy program nie napotka wyjatku.
|
||||
|
||||
|
||||
####################################################
|
||||
## 4. Funkcje
|
||||
####################################################
|
||||
|
||||
# Użyj "def", aby stworzyć nową funkcję
|
||||
def dodaj(x, y):
|
||||
print("x to %s, a y to %s" % (x, y))
|
||||
return x + y # słowo kluczowe return zwraca wynik działania
|
||||
|
||||
# Tak wywołuje się funkcję z parametrami:
|
||||
dodaj(5, 6) # => wypisze "x to 5, a y to 6" i zwróci 11
|
||||
|
||||
# Innym sposobem jest wywołanie z parametrami nazwanymi.
|
||||
dodaj(y=6, x=5) # tutaj kolejność podania nie ma znaczenia.
|
||||
|
||||
|
||||
# Można też stworzyć funkcję, które przyjmują zmienną liczbę parametrów pozycyjnych,
|
||||
# które zostaną przekazana jako krotka, pisząc w definicji funkcji "*args"
|
||||
def varargs(*args):
|
||||
return args
|
||||
|
||||
varargs(1, 2, 3) # => (1, 2, 3)
|
||||
|
||||
|
||||
# Można też stworzyć funkcję, które przyjmują zmienną liczbę parametrów
|
||||
# nazwanych kwargs, które zostaną przekazane jako słownik, pisząc w definicji funkcji "**kwargs"
|
||||
def keyword_args(**kwargs):
|
||||
return kwargs
|
||||
|
||||
# Wywołajmy to i sprawdźmy co się dzieje
|
||||
keyword_args(wielka="stopa", loch="ness") # => {"wielka": "stopa", "loch": "ness"}
|
||||
|
||||
|
||||
# Możesz też przyjmować jednocześnie zmienną liczbę parametrów pozycyjnych i nazwanych
|
||||
def all_the_args(*args, **kwargs):
|
||||
print(args)
|
||||
print(kwargs)
|
||||
"""
|
||||
all_the_args(1, 2, a=3, b=4) wypisze:
|
||||
(1, 2)
|
||||
{"a": 3, "b": 4}
|
||||
"""
|
||||
|
||||
# Użyj * aby rozwinąć parametry z krotki args
|
||||
# i użyj ** aby rozwinąć parametry nazwane ze słownika kwargs.
|
||||
args = (1, 2, 3, 4)
|
||||
kwargs = {"a": 3, "b": 4}
|
||||
all_the_args(*args) # odpowiednik foo(1, 2, 3, 4)
|
||||
all_the_args(**kwargs) # odpowiednik foo(a=3, b=4)
|
||||
all_the_args(*args, **kwargs) # odpowiednik foo(1, 2, 3, 4, a=3, b=4)
|
||||
|
||||
# Możesz podać parametry args i kwargs do funkcji równocześnie
|
||||
# przez rozwinięcie odpowiednio * i **
|
||||
def pass_all_the_args(*args, **kwargs):
|
||||
all_the_args(*args, **kwargs)
|
||||
print varargs(*args)
|
||||
print keyword_args(**kwargs)
|
||||
|
||||
# Zasięg zmiennych
|
||||
x = 5
|
||||
|
||||
def setX(num):
|
||||
# Lokalna zmienna x nie jest tym samym co zmienna x
|
||||
x = num # => 43
|
||||
print x # => 43
|
||||
|
||||
def setGlobalX(num):
|
||||
global x
|
||||
print x # => 5
|
||||
x = num # globalna zmienna to teraz 6
|
||||
print x # => 6
|
||||
|
||||
setX(43)
|
||||
setGlobalX(6)
|
||||
|
||||
# Można tworzyć funkcje wewnętrzne i zwrócić je jako wynik
|
||||
def rob_dodawacz(x):
|
||||
def dodawacz(y):
|
||||
return x + y
|
||||
return dodawacz
|
||||
|
||||
dodaj_10 = rob_dodawacz(10)
|
||||
dodaj_10(3) # => 13
|
||||
|
||||
# Są również funkcje anonimowe "lambda"
|
||||
(lambda x: x > 2)(3) # => True
|
||||
|
||||
# Python ma też wbudowane funkcje wyższego rzędu (przyjmujące inną funkcje jako parametr)
|
||||
map(add_10, [1, 2, 3]) # => [11, 12, 13]
|
||||
filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
|
||||
|
||||
# Można używać wyrażeń listowych (list comprehensions) do mapowania i filtrowania
|
||||
[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
|
||||
[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7]
|
||||
|
||||
|
||||
####################################################
|
||||
## 5. Klasy
|
||||
####################################################
|
||||
|
||||
# Wszystkie klasy są podklasą object
|
||||
class Czlowiek(object):
|
||||
|
||||
# Atrybut klasy. Występuje we wszystkich instancjach klasy.
|
||||
gatunek = "H. sapiens"
|
||||
|
||||
# Podstawowa inicjalizacja - wywoływana podczas tworzenia instacji.
|
||||
# Zauważ, że podwójne podkreślenia przed i za nazwą oznaczają
|
||||
# specjalne obiekty lub atrybuty wykorzystywane wewnętrznie przez Pythona.
|
||||
# Nie używaj ich we własnych metodach.
|
||||
def __init__(self, nazwa):
|
||||
# przypisz parametr "nazwa" do atrybutu instancji
|
||||
self.nazwa = nazwa
|
||||
|
||||
# Metoda instancji. Wszystkie metody przyjmują "self" jako pierwszy argument
|
||||
def mow(self, wiadomosc):
|
||||
return "%s: %s" % (self.nazwa, wiadomosc)
|
||||
|
||||
# Metoda klasowa współdzielona przez instancje.
|
||||
# Przyjmuje wywołującą klasę jako pierwszy argument.
|
||||
@classmethod
|
||||
def daj_gatunek(cls):
|
||||
return cls.gatunek
|
||||
|
||||
# Metoda statyczna jest wywoływana bez argumentów klasy czy instancji.
|
||||
@staticmethod
|
||||
def grunt():
|
||||
return "*grunt*"
|
||||
|
||||
|
||||
# Instancja klasy
|
||||
i = Czlowiek(name="Ian")
|
||||
print(i.mow("cześć")) # wypisze "Ian: cześć"
|
||||
|
||||
j = Czlowiek("Joel")
|
||||
print(j.mow("cześć")) # wypisze "Joel: cześć"
|
||||
|
||||
# Wywołujemy naszą metodę klasową
|
||||
i.daj_gatunek() # => "H. sapiens"
|
||||
|
||||
# Zmieniamy wspólny parametr
|
||||
Czlowiek.gatunek = "H. neanderthalensis"
|
||||
i.daj_gatunek() # => "H. neanderthalensis"
|
||||
j.daj_gatunek() # => "H. neanderthalensis"
|
||||
|
||||
# Wywołanie metody statycznej
|
||||
Czlowiek.grunt() # => "*grunt*"
|
||||
|
||||
|
||||
####################################################
|
||||
## 6. Moduły
|
||||
####################################################
|
||||
|
||||
# Tak importuje się moduły:
|
||||
import math
|
||||
print(math.sqrt(16)) # => 4.0
|
||||
|
||||
# Można podać konkretne funkcje, np. ceil, floor z modułu math
|
||||
from math import ceil, floor
|
||||
print(ceil(3.7)) # => 4.0
|
||||
print(floor(3.7)) # => 3.0
|
||||
|
||||
# Można zaimportować wszystkie funkcje z danego modułu.
|
||||
# Uwaga: nie jest to polecane, bo później w kodzie trudno połapać się,
|
||||
# która funkcja pochodzi z którego modułu.
|
||||
from math import *
|
||||
|
||||
# Można skracać nazwy modułów.
|
||||
import math as m
|
||||
math.sqrt(16) == m.sqrt(16) # => True
|
||||
# sprawdźmy czy funkcje są równoważne
|
||||
from math import sqrt
|
||||
math.sqrt == m.sqrt == sqrt # => True
|
||||
|
||||
# Moduły Pythona to zwykłe skrypty napisane w tym języku. Możesz
|
||||
# pisać własne i importować je. Nazwa modułu to nazwa pliku.
|
||||
|
||||
# W ten sposób sprawdzisz jakie funkcje wchodzą w skład modułu.
|
||||
import math
|
||||
dir(math)
|
||||
|
||||
|
||||
####################################################
|
||||
## 7. Zaawansowane
|
||||
####################################################
|
||||
|
||||
# Generatory pomagają tworzyć tzw. "leniwy kod"
|
||||
def podwojne_liczby(iterowalne):
|
||||
for i in iterowalne:
|
||||
yield i + i
|
||||
|
||||
# Generatory tworzą wartości w locie.
|
||||
# Zamiast generować wartości raz i zapisywać je (np. w liście),
|
||||
# generator tworzy je na bieżąco, w wyniku iteracji. To oznacza,
|
||||
# że w poniższym przykładzie wartości większe niż 15 nie będą przetworzone
|
||||
# w funkcji "podwojne_liczby".
|
||||
# Zauważ, że xrange to generator, który wykonuje tę samą operację co range.
|
||||
# Stworzenie listy od 1 do 900000000 zajęłoby sporo czasu i pamięci,
|
||||
# a xrange tworzy obiekt generatora zamiast budować całą listę jak range.
|
||||
|
||||
# Aby odróżnić nazwę zmiennej od nazwy zarezerwowanej w Pythonie, używamy
|
||||
# zwykle na końcu znaku podkreślenia
|
||||
xrange_ = xrange(1, 900000000)
|
||||
|
||||
# poniższa pętla będzie podwajać liczby aż do 30
|
||||
for i in podwojne_liczby(xrange_):
|
||||
print(i)
|
||||
if i >= 30:
|
||||
break
|
||||
|
||||
|
||||
# Dekoratory
|
||||
# w tym przykładzie "beg" jest nakładką na "say"
|
||||
# Beg wywołuje say. Jeśli say_please jest prawdziwe, wtedy zwracana wartość
|
||||
# zostanie zmieniona
|
||||
|
||||
from functools import wraps
|
||||
|
||||
|
||||
def beg(target_function):
|
||||
@wraps(target_function)
|
||||
def wrapper(*args, **kwargs):
|
||||
msg, say_please = target_function(*args, **kwargs)
|
||||
if say_please:
|
||||
return "{} {}".format(msg, "Proszę! Jestem spłukany :(")
|
||||
return msg
|
||||
return wrapper
|
||||
|
||||
|
||||
@beg
|
||||
def say(say_please=False):
|
||||
msg = "Kupisz mi piwo?"
|
||||
return msg, say_please
|
||||
|
||||
|
||||
print(say()) # Kupisz mi piwo?
|
||||
print(say(say_please=True)) # Kupisz mi piwo? Proszę! Jestem spłukany :(
|
||||
```
|
||||
|
||||
## Gotowy na więcej?
|
||||
### Polskie
|
||||
|
||||
* [Zanurkuj w Pythonie](http://pl.wikibooks.org/wiki/Zanurkuj_w_Pythonie)
|
||||
* [LearnPythonPl](http://www.learnpython.org/pl/)
|
||||
|
||||
### Angielskie:
|
||||
#### Darmowe źródła online
|
||||
|
||||
* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
|
||||
* [Dive Into Python](http://www.diveintopython.net/)
|
||||
* [The Official Docs](http://docs.python.org/2.6/)
|
||||
* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
|
||||
* [Python Module of the Week](http://pymotw.com/2/)
|
||||
* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
|
||||
|
||||
#### Inne
|
||||
|
||||
* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
|
||||
* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
|
||||
* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
|
||||
|
||||
592
pl/ruby.md
Normal file
592
pl/ruby.md
Normal file
@@ -0,0 +1,592 @@
|
||||
---
|
||||
language: Ruby
|
||||
filename: learnruby-pl.rb
|
||||
contributors:
|
||||
- ["David Underwood", "http://theflyingdeveloper.com"]
|
||||
- ["Joel Walden", "http://joelwalden.net"]
|
||||
- ["Luke Holder", "http://twitter.com/lukeholder"]
|
||||
- ["Tristan Hume", "http://thume.ca/"]
|
||||
- ["Nick LaMuro", "https://github.com/NickLaMuro"]
|
||||
- ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
|
||||
- ["Ariel Krakowski", "http://www.learneroo.com"]
|
||||
- ["Dzianis Dashkevich", "https://github.com/dskecse"]
|
||||
- ["Levi Bostian", "https://github.com/levibostian"]
|
||||
- ["Rahil Momin", "https://github.com/iamrahil"]
|
||||
- ["Gabriel Halley", "https://github.com/ghalley"]
|
||||
- ["Persa Zula", "http://persazula.com"]
|
||||
translators:
|
||||
- ["Marcin Klocek", "https://github.com/mklocek"]
|
||||
lang: pl-pl
|
||||
---
|
||||
|
||||
```ruby
|
||||
# To jest komentarz
|
||||
|
||||
=begin
|
||||
To jest wielolinijkowy komentarz
|
||||
Nikt ich nie używa
|
||||
Ty też nie powinieneś
|
||||
=end
|
||||
|
||||
# Przede wszystkim: Wszystko jest obiektem.
|
||||
|
||||
# Liczby są obiektami
|
||||
|
||||
3.class #=> Fixnum
|
||||
|
||||
3.to_s #=> "3"
|
||||
|
||||
|
||||
# Trochę podstawowej arytmetyki
|
||||
1 + 1 #=> 2
|
||||
8 - 1 #=> 7
|
||||
10 * 2 #=> 20
|
||||
35 / 5 #=> 7
|
||||
2**5 #=> 32
|
||||
5 % 3 #=> 2
|
||||
5 ^ 6 #=> 3
|
||||
|
||||
# Arytmetyka jest zastąpeniem składni
|
||||
# metod wywoływanych na obiektach
|
||||
1.+(3) #=> 4
|
||||
10.* 5 #=> 50
|
||||
|
||||
# Wartości specjalne są obiektami
|
||||
nil # To na prawdę jest niczym
|
||||
true # prawda
|
||||
false # fałsz
|
||||
|
||||
nil.class #=> NilClass
|
||||
true.class #=> TrueClass
|
||||
false.class #=> FalseClass
|
||||
|
||||
# Równość
|
||||
1 == 1 #=> true
|
||||
2 == 1 #=> false
|
||||
|
||||
# Nierówność
|
||||
1 != 1 #=> false
|
||||
2 != 1 #=> true
|
||||
|
||||
# jedyną 'fałszywą' wartością poza false, jest nil
|
||||
|
||||
!nil #=> true
|
||||
!false #=> true
|
||||
!0 #=> false
|
||||
|
||||
# Więcej porównań
|
||||
1 < 10 #=> true
|
||||
1 > 10 #=> false
|
||||
2 <= 2 #=> true
|
||||
2 >= 2 #=> true
|
||||
|
||||
# Operatory logiczne
|
||||
true && false #=> false
|
||||
true || false #=> true
|
||||
!true #=> false
|
||||
|
||||
# Istnieją alternatywne wersje operatorów logicznych ze znacznie mniejszym
|
||||
# pierwszeństwem. Używane są by kontrolować wyrażenia w łańcuchach wyrażeń
|
||||
# aż jedno z nich wróci true lub false.
|
||||
|
||||
# `zrob_cos_innego` wywołaj tylko wtedy gdy `zrob_cos` zakończy się sukcesem.
|
||||
zrob_cos_innego() and zrob_cos()
|
||||
# `log_error` wywołaj tylko wtedy gdy `zrob_cos` nie zakończy się sukcesem.
|
||||
zrob_cos() or log_error()
|
||||
|
||||
|
||||
# Stringi są obiektami
|
||||
|
||||
'Jestem stringiem.'.class #=> String
|
||||
"Ja również jestem stringiem.".class #=> String
|
||||
|
||||
wypelnienie = 'użyć interpolacji stringa'
|
||||
"Potrafię #{wypelnienie} używając podwójnych cudzysłowów."
|
||||
#=> "Potrafię użyć interpolacji stringa używając podwójnych cudzysłowów."
|
||||
|
||||
# Staraj się zapisywać stringi za pomocą apostrof, zamiast cudzysłowów tam, gdzie to możliwe
|
||||
# Cudzysłowy wykonują dodatkowe wewnętrzne operacje
|
||||
|
||||
|
||||
# Łączenie stringów, ale nie liczb
|
||||
'hej ' + 'świecie' #=> "hej świecie"
|
||||
'hej ' + 3 #=> TypeError: can't convert Fixnum into String
|
||||
'hej ' + 3.to_s #=> "hej 3"
|
||||
|
||||
# Łączenie stringów i operatorów
|
||||
'hej ' * 3 #=> "hej hej hej "
|
||||
|
||||
# Dodawanie do stringa
|
||||
'hej' << ' świecie' #=> "hej świecie"
|
||||
|
||||
# wydrukowanie wartości wraz z nową linią na końcu
|
||||
puts "Drukuję!"
|
||||
#=> Drukuję!
|
||||
#=> nil
|
||||
|
||||
# wydrukowanie wartości bez nowej linii na końcu
|
||||
print "Drukuję!"
|
||||
#=> Drukuję! => nill
|
||||
|
||||
# Zmienne
|
||||
x = 25 #=> 25
|
||||
x #=> 25
|
||||
|
||||
# Zauważ, że przypisanie zwraca przypisywaną wartość
|
||||
# To znaczy, że możesz wykonać wielokrotne przypisanie:
|
||||
|
||||
x = y = 10 #=> 10
|
||||
x #=> 10
|
||||
y #=> 10
|
||||
|
||||
# Zwyczajowo, używaj notacji nazwa_zmiennej dla nazw zmiennych
|
||||
nazwa_zmiennej = true
|
||||
|
||||
# Używaj opisowych nazw zmiennych
|
||||
sciezka_do_projektu = '/dobra/nazwa/'
|
||||
sciezka = '/zla/nazwa/'
|
||||
|
||||
# Symbole (są obiektami)
|
||||
# Symbole są niezmiennymi, wielokrotnie używanymi stałymi reprezentowanymi wewnętrznie jako
|
||||
# liczby całkowite. Często używane są zamiast stringów w celu wydajniejszego przekazywania danych
|
||||
|
||||
:oczekujacy.class #=> Symbol
|
||||
|
||||
status = :oczekujacy
|
||||
|
||||
status == :oczekujacy #=> true
|
||||
|
||||
status == 'oczekujacy' #=> false
|
||||
|
||||
status == :zatwierdzony #=> false
|
||||
|
||||
# Tablice
|
||||
|
||||
# To jest tablica
|
||||
array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
|
||||
|
||||
# Tablice mogą zwierać różne typy danych
|
||||
|
||||
[1, 'hej', false] #=> [1, "hej", false]
|
||||
|
||||
# Tablice mogę być indeksowane
|
||||
# Od początku
|
||||
tablica[0] #=> 1
|
||||
tablica.first #=> 1
|
||||
tablica[12] #=> nil
|
||||
|
||||
# Podobnie jak przy arytmetyce, dostęp poprzez [zmienna]
|
||||
# jest tylko czytelniejszą składnią
|
||||
# dla wywoływania metody [] na obiekcie
|
||||
tablica.[] 0 #=> 1
|
||||
tablica.[] 12 #=> nil
|
||||
|
||||
# Od końca
|
||||
tablica[-1] #=> 5
|
||||
tablica.last #=> 5
|
||||
|
||||
# Z początkowym indeksem i długością
|
||||
tablica[2, 3] #=> [3, 4, 5]
|
||||
|
||||
# Odwrotność tablicy
|
||||
a=[1,2,3]
|
||||
a.reverse! #=> [3,2,1]
|
||||
|
||||
# Lub zakres
|
||||
array[1..3] #=> [2, 3, 4]
|
||||
|
||||
# Dodawanie do tablicy w taki sposób
|
||||
tablica << 6 #=> [1, 2, 3, 4, 5, 6]
|
||||
# Lub taki
|
||||
tablica.push(6) #=> [1, 2, 3, 4, 5, 6]
|
||||
|
||||
# Sprawdzanie, czy tablica zawiera element
|
||||
tablica.include?(1) #=> true
|
||||
|
||||
# Hasze są Ruby'owymi podstawowymi słownikami z parami klucz/wartość.
|
||||
# Hasze są zapisywane za pomocą nawiasów klamrowych
|
||||
hasz = { 'kolor' => 'zielony', 'numer' => 5 }
|
||||
|
||||
hasz.keys #=> ['kolor', 'numer']
|
||||
|
||||
# Można szybko sprawdzić zawartość hasza za pomocą kluczy:
|
||||
hasz['kolor'] #=> 'zielony'
|
||||
hasz['numer'] #=> 5
|
||||
|
||||
# Sprawdzenie wartośći dla nieistniejącego klucza zwraca nil:
|
||||
hasz['nic tutaj nie ma'] #=> nil
|
||||
|
||||
# Od wersji 1.9, Ruby posiada specjalną składnię, gdy używamy symboli jako kluczy:
|
||||
|
||||
nowy_hasz = { stan: 3, akcja: true }
|
||||
|
||||
nowy_hasz.keys #=> [:stan, :akcja]
|
||||
|
||||
# Sprawdzenie istnienia kluczy i wartości w haszu
|
||||
new_hash.has_key?(:defcon) #=> true
|
||||
new_hash.has_value?(3) #=> true
|
||||
|
||||
# Wskazówka: Zarówno tablice, jak i hasze, są policzalne
|
||||
# Współdzielą wiele metod takich jak each, map, count, i inne
|
||||
|
||||
# Instrukcje warunkowe
|
||||
|
||||
if true
|
||||
'wyrażenie if'
|
||||
elsif false
|
||||
'wyrażenie if, opcjonalne'
|
||||
else
|
||||
'wyrażenie else, również opcjonalne'
|
||||
end
|
||||
|
||||
for licznik in 1..5
|
||||
puts "powtórzenie #{licznik}"
|
||||
end
|
||||
#=> powtórzenie 1
|
||||
#=> powtórzenie 2
|
||||
#=> powtórzenie 3
|
||||
#=> powtórzenie 4
|
||||
#=> powtórzenie 5
|
||||
|
||||
# JEDNAKŻE, Nikt nie używa pętli for.
|
||||
# Zamiast tego, powinno się używać metody "each" i podawać jej blok.
|
||||
# Blok jest kawałkiem kodu, który możesz podać metodzie podobnej do "each".
|
||||
# Jest analogiczny do wyrażeń lambda, funkcji anonimowych lub zamknięć w innych
|
||||
# językach programowania.
|
||||
#
|
||||
# Metoda "each" danego zakresu, wykonuje blok dla każdego elementu w zakresie.
|
||||
# Do bloku zostaje przekazany licznik jako parametr.
|
||||
# Wykonanie metody "each" z przekazaniem bloku wygląda następująco:
|
||||
|
||||
(1..5).each do |licznik|
|
||||
puts "powtórzenie #{licznik}"
|
||||
end
|
||||
#=> powtórzenie 1
|
||||
#=> powtórzenie 2
|
||||
#=> powtórzenie 3
|
||||
#=> powtórzenie 4
|
||||
#=> powtórzenie 5
|
||||
|
||||
# Możesz również otoczyć blok nawiasami klamrowymi:
|
||||
(1..5).each { |licznik| puts "powtórzenie #{licznik}" }
|
||||
|
||||
# Zawartość struktur danych również może być powtarzana używając each.
|
||||
tablica.each do |element|
|
||||
puts "#{element} jest częścią tablicy"
|
||||
end
|
||||
hasz.each do |klucz, wartosc|
|
||||
puts "#{klucz} jest #{wartosc}"
|
||||
end
|
||||
|
||||
# Jeśli nadal potrzebujesz indeksum, możesz użyć "each_with_index" i zdefiniować
|
||||
# zmienną odpowiadającą indeksowi
|
||||
tablica.each_with_index do |element, indeks|
|
||||
puts "#{element} jest numerem #{indeks} w tablicy"
|
||||
end
|
||||
|
||||
licznik = 1
|
||||
while licznik <= 5 do
|
||||
puts "powtórzenie #{licznik}"
|
||||
licznik += 1
|
||||
end
|
||||
#=> powtórzenie 1
|
||||
#=> powtórzenie 2
|
||||
#=> powtórzenie 3
|
||||
#=> powtórzenie 4
|
||||
#=> powtórzenie 5
|
||||
|
||||
# W Ruby istnieje dużo pomocnych funkcji wykonujących pętle,
|
||||
# na przykład "map", "reduce", "inject" i wiele innych. Map,
|
||||
# w każdym wywołaniu, pobiera tablicę, na której wykonuję pętlę,
|
||||
# wykonuje kod zapisany za pomocą bloku i zwraca całkowicie nową tablicę.
|
||||
tablica = [1,2,3,4,5]
|
||||
podwojone = tablica.map do |element|
|
||||
element * 2
|
||||
end
|
||||
puts podwojona
|
||||
#=> [2,4,6,8,10]
|
||||
puts tablica
|
||||
#=> [1,2,3,4,5]
|
||||
|
||||
ocena = 2
|
||||
|
||||
case ocena
|
||||
when 1
|
||||
puts 'Dobra robota, masz wolne'
|
||||
when 2
|
||||
puts 'Następnym razem będziesz miał więcej szczęścia'
|
||||
when 3
|
||||
puts 'Możesz to zrobić lepiej'
|
||||
when 4
|
||||
puts 'Przebrnąłeś'
|
||||
when 5
|
||||
puts 'Oblałeś!'
|
||||
else
|
||||
puts 'Inny system oceniania?'
|
||||
end
|
||||
#=> "Następnym razem będziesz miał więcej szczęścia"
|
||||
|
||||
# case może również użwać zakresów
|
||||
ocena = 82
|
||||
case ocena
|
||||
when 90..100
|
||||
puts 'Hurra!'
|
||||
when 80...90
|
||||
puts 'Dobra robota'
|
||||
else
|
||||
puts 'Oblałeś!'
|
||||
end
|
||||
#=> "Dobra robota"
|
||||
|
||||
# obsługa błędów:
|
||||
begin
|
||||
# kod, który może wywołać wyjątek
|
||||
raise NoMemoryError, 'Zabrakło pamięci.'
|
||||
rescue NoMemoryError => zmienna_wyjatku
|
||||
puts 'Został wywołany NoMemoryError', zmienna_wyjatku
|
||||
rescue RuntimeError => inna_zmienna_wyjatku
|
||||
puts 'Teraz został wywołany RuntimeError'
|
||||
else
|
||||
puts 'To zostanie uruchomione, jeśli nie wystąpi żaden wyjątek'
|
||||
ensure
|
||||
puts 'Ten kod wykona się zawsze'
|
||||
end
|
||||
|
||||
# Funkcje
|
||||
|
||||
def podwojenie(x)
|
||||
x * 2
|
||||
end
|
||||
|
||||
# Funkcje (i wszystkie bloki) zawsze zwracają wartość ostatniego wyrażenia
|
||||
podwojenie(2) #=> 4
|
||||
|
||||
# Okrągłe nawiady są opcjonalne, gdy wynik jest jednoznaczny
|
||||
podwojenie 3 #=> 6
|
||||
|
||||
podwojenie podwojenie 3 #=> 12
|
||||
|
||||
def suma(x, y)
|
||||
x + y
|
||||
end
|
||||
|
||||
# Argumenty metod są oddzielone przecinkami
|
||||
suma 3, 4 #=> 7
|
||||
|
||||
suma suma(3, 4), 5 #=> 12
|
||||
|
||||
# yield
|
||||
# Wszystkie metody mają ukryty, opcjonalny parametr bloku,
|
||||
# który może być wykonany używając słowa kluczowego 'yield'
|
||||
|
||||
def otoczenie
|
||||
puts '{'
|
||||
yield
|
||||
puts '}'
|
||||
end
|
||||
|
||||
otoczenie { puts 'hej świecie' }
|
||||
|
||||
# {
|
||||
# hej świecie
|
||||
# }
|
||||
|
||||
|
||||
# Możesz przekazać blok do funkcji
|
||||
# "&" oznacza referencję to przekazanego bloku
|
||||
def goscie(&blok)
|
||||
blok.call 'jakis_argument'
|
||||
end
|
||||
|
||||
# Możesz przekazać listę argumentów, które będę przekonwertowane na tablicę
|
||||
# Do tego służy operator ("*")
|
||||
def goscie(*tablica)
|
||||
tablica.each { |gosc| puts gosc }
|
||||
end
|
||||
|
||||
# Definiowanie klas używając słowa kluczowego class
|
||||
class Czlowiek
|
||||
|
||||
# Zmienna klasowa. Jest współdzielona przez wszystkie instancje tej klasy.
|
||||
@@gatunek = 'H. sapiens'
|
||||
|
||||
# Podstawowe inicjalizowanie
|
||||
def initialize(imie, wiek = 0)
|
||||
# Przypisanie argumentu do zmiennej danej instancji o nazwie "imie"
|
||||
@imie = imie
|
||||
# Jeśli nie podano wieku, zostanie użyta domyślna wartość z listy argumentów.
|
||||
@wiek = wiek
|
||||
end
|
||||
|
||||
# Podstawowa metoda przypisująca wartość
|
||||
def imie=(imie)
|
||||
@imie = imie
|
||||
end
|
||||
|
||||
# Podstawowa metoda pobierająca wartość
|
||||
def imie
|
||||
@imie
|
||||
end
|
||||
|
||||
# Powyższa funkcjonalność może być zastąpiona używając metody attr_accessor w taki sposób
|
||||
attr_accessor :imie
|
||||
|
||||
# Metody przypisujące/pobierające mogą być stworzone indywidualnie
|
||||
attr_reader :imie
|
||||
attr_writer :imie
|
||||
|
||||
# Metody klasowe używają self aby odróżnić się od metody instancji.
|
||||
# To może być wywołane na klasie, nie na instancji.
|
||||
def self.powiedz(wiadomosc)
|
||||
puts wiadomosc
|
||||
end
|
||||
|
||||
def gatunek
|
||||
@@gatunek
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
# Tworzenie instancji klasy
|
||||
jim = Czlowiek.new('Jim Halpert')
|
||||
|
||||
dwight = Czlowiek.new('Dwight K. Schrute')
|
||||
|
||||
# Wywołajmy parę metod
|
||||
jim.gatunek #=> "H. sapiens"
|
||||
jim.imie #=> "Jim Halpert"
|
||||
jim.imie = "Jim Halpert II" #=> "Jim Halpert II"
|
||||
jim.imie #=> "Jim Halpert II"
|
||||
dwight.gatunek #=> "H. sapiens"
|
||||
dwight.imie #=> "Dwight K. Schrute"
|
||||
|
||||
# Wywołanie metody klasowej
|
||||
Czlowiek.powiedz('Cześć') #=> "Cześć"
|
||||
|
||||
# Zasięg zmiennej jest definiowany poprzez jej nazwę.
|
||||
# Zmienne, które zaczynają się na $ mają zasięg globalny
|
||||
$zmienna = "Jestem zmienną globalną"
|
||||
defined? $zmienna #=> "global-variable"
|
||||
|
||||
# Zmienne zczynające się na @ mają zasięg danej instancji
|
||||
@zmienna = "Jestem zmienną instancji"
|
||||
defined? @zmienna #=> "instance-variable"
|
||||
|
||||
# Zmienne, które zaczynają się na @@ mają zasięg danej klasy
|
||||
@@zmienna = "Jestem zmienną klasową"
|
||||
defined? @@zmienna #=> "class variable"
|
||||
|
||||
# Zmienne, które zaczynają się na dużą literę, są stałymi
|
||||
Zmienna = "Jestem stałą"
|
||||
defined? Zmienna #=> "constant"
|
||||
|
||||
# Klasa jest również obiektem w ruby. Może więc mieć zmienne instancji.
|
||||
# Zmienna klasowa może być współdzielona między klasą i jej potomstwem.
|
||||
|
||||
# podstawowa klasa
|
||||
class Czlowiek
|
||||
@@cokolwiek = 0
|
||||
|
||||
def self.cokolwiek
|
||||
@@cokolwiek
|
||||
end
|
||||
|
||||
def self.cokolwiek=(wartosc)
|
||||
@@cokolwiek = wartosc
|
||||
end
|
||||
end
|
||||
|
||||
# klasa pochodna
|
||||
class Pracownik < Czlowiek
|
||||
end
|
||||
|
||||
Czlowiek.cokolwiek # 0
|
||||
Pracownik.cokolwiek # 0
|
||||
|
||||
Czlowiek.cokolwiek = 2 # 2
|
||||
Pracownik.cokolwiek # 2
|
||||
|
||||
# Zmienna instancji danej klasy nie jest współdzielona przez jej potomstwo.
|
||||
|
||||
class Czlowiek
|
||||
@cos = 0
|
||||
|
||||
def self.cos
|
||||
@cos
|
||||
end
|
||||
|
||||
def self.cos=(wartosc)
|
||||
@cos = wartosc
|
||||
end
|
||||
end
|
||||
|
||||
class Doktor < Czlowiek
|
||||
end
|
||||
|
||||
Czlowiek.cos # 0
|
||||
Doktor.cos # nil
|
||||
|
||||
module PrzykladowyModul
|
||||
def cokolwiek
|
||||
'cokolwiek'
|
||||
end
|
||||
end
|
||||
|
||||
# Włączanie modułów łączy ich metody z metodami instancji klasy
|
||||
# Rozszerzanie modułów łączy ich metody z metodami klasy
|
||||
|
||||
class Osoba
|
||||
include PrzykladowyModul
|
||||
end
|
||||
|
||||
class Ksiazka
|
||||
extend PrzykladowyModul
|
||||
end
|
||||
|
||||
Osoba.cokolwiek # => NoMethodError: undefined method `cokolwiek' for Osoba:Class
|
||||
Osoba.new.cokolwiek # => 'cokolwiek'
|
||||
Ksiazka.cokolwiek # => 'cokolwiek'
|
||||
Ksiazka.new.cokolwiek # => NoMethodError: undefined method `cokolwiek'
|
||||
|
||||
# Gdy włączamy lub rozszerzamy muduły, wykonywane są tzw. wywołania zwrotne
|
||||
|
||||
module PrzykladowyModul
|
||||
def self.included(baza)
|
||||
baza.extend(MotodyKlasowe)
|
||||
baza.send(:include, MetodyInstancji)
|
||||
end
|
||||
|
||||
module MotodyKlasowe
|
||||
def cos
|
||||
'cos'
|
||||
end
|
||||
end
|
||||
|
||||
module MetodyInstancji
|
||||
def xyz
|
||||
'xyz'
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class Cokolwiek
|
||||
include PrzykladowyModul
|
||||
end
|
||||
|
||||
Cokolwiek.cos # => 'cos'
|
||||
Cokolwiek.xyz # => NoMethodError: undefined method `xyz'
|
||||
Cokolwiek.new.cos # => NoMethodError: undefined method `cos'
|
||||
Cokolwiek.new.xyz # => 'qux'
|
||||
```
|
||||
|
||||
## Dodatkowe źródła
|
||||
### Polskie
|
||||
|
||||
- [Dokumentacja](https://www.ruby-lang.org/pl/documentation/quickstart/)
|
||||
|
||||
### Angielskie
|
||||
|
||||
- [Official Documentation](http://www.ruby-doc.org/core-2.1.1/)
|
||||
- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
|
||||
- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online.
|
||||
- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
|
||||
236
pl/vim.md
Normal file
236
pl/vim.md
Normal file
@@ -0,0 +1,236 @@
|
||||
---
|
||||
category: tool
|
||||
tool: Vim
|
||||
contributors:
|
||||
- ["RadhikaG", "https://github.com/RadhikaG"]
|
||||
translators:
|
||||
- ["Adam Bobowski", "https://github.com/Bobowski"]
|
||||
lang: pl-pl
|
||||
filename: LearnVim-pl.txt
|
||||
---
|
||||
|
||||
|
||||
[Vim](http://www.vim.org)
|
||||
(Vi IMproved) jest klonem popularnego edytora vi dla systemów Unix.
|
||||
Zaprojektowany z myślą o prędkości edycji i zwiększeniu produktywności jest
|
||||
wszechobecny na systemach UNIXopodobnych. Posiada wiele skrótów klawiszowych
|
||||
do szybkiej nawigacji do wybranych miejsc w plikach oraz szybkiej edycji
|
||||
danych fragmentów.
|
||||
|
||||
## Podstawy nawigacji w Vim
|
||||
|
||||
```
|
||||
vim <nazwapliku> # Otwórz <nazwapliku> w vim
|
||||
:q # Zamknij vim
|
||||
:w # Zapisz aktualny plik
|
||||
:wq # Zapisz i wyjdź z vim
|
||||
:q! # Wyjdź bez zapisywania
|
||||
# ! *wymusza* wykonanie :q, dlatego nie wykonuje zapisu
|
||||
:x # Zapisz i wyjdź, krótszy odpowiednik :wq
|
||||
|
||||
u # Cofnij operację
|
||||
CTRL+R # Powtórz operację
|
||||
|
||||
h # Przesuń kursor w lewo
|
||||
j # Przesuń kursor w dół
|
||||
k # Przesuń kursor w górę
|
||||
l # Przesuń kursor w prawo
|
||||
|
||||
# Poruszanie w obrębie jednej lini
|
||||
|
||||
0 # Skocz do początku linii
|
||||
$ # Skocz do końca linii
|
||||
^ # Skocz do pierwszego niebiałego znaku
|
||||
|
||||
# Wyszukiwanie w tekście
|
||||
|
||||
/slowo # Zaznacza wszystkie wystąpienia słowa za kursorem
|
||||
?slowo # Zaznacza wszystkie wystąpienia słowa przed kursorem
|
||||
n # Przemieszcza kursor do następnego wystąpienia słowa
|
||||
N # Przemieszcza kursor do poprzedniego wystąpenia słowa
|
||||
|
||||
:%s/foo/bar/g # Zamień 'foo' na 'bar' w każdej linii tekstu
|
||||
:s/foo/bar/g # Zamień 'foo' na 'bar' w aktualnej linii
|
||||
|
||||
# Skoki do znaków
|
||||
|
||||
f<znak> # Skocz do przodu i zatrzymaj się na <znak>
|
||||
t<znak> # Skocz do przodu i zatrzymaj się przed <znak>
|
||||
|
||||
# Na przykład,
|
||||
f< # Skocz do przodu i zatrzymaj się na <
|
||||
t< # Skocz do przodu i zatrzymaj się przed <
|
||||
|
||||
# Moving by word
|
||||
|
||||
w # Przesuń kursor do przodu o jedno słowo
|
||||
b # Przesuń kursor do tyłu o jedno słowo
|
||||
e # Przesuń kursor do końca aktualnego słowa
|
||||
|
||||
# Inne znaki do przemieszczania się
|
||||
|
||||
gg # Skocz na początek pliku
|
||||
G # Skocz na koniec pliku
|
||||
:NUM # Skocz do linii o numerze NUM
|
||||
H # Skocz na górę ekranu
|
||||
M # Skocz na środek ekranu
|
||||
L # Skocz na dół ekranu
|
||||
```
|
||||
|
||||
## Tryby
|
||||
|
||||
Vim oparty jest na koncepcji **trybów**.
|
||||
|
||||
Command Mode - (Tryb komend) vim zaczyna w tym trybie, używany do nawigacji i wpisywania komend
|
||||
Insert Mode - (Tryb wprowadzania) używany do wprowadzania zmian w pliku
|
||||
Visual Mode - (Tryb wizualny) używany do zaznaczania tekstu i wykonywania komend na nim
|
||||
Ex Mode - (Tryb Ex)
|
||||
|
||||
```
|
||||
i # Przechodzi to trybu wprowadzania, przed pozycją kursora
|
||||
a # Przechodzi do trybu wprowadzania, za pozycją kursora
|
||||
v # Przechodzi do trybu wizualnego
|
||||
: # Przechodzi do trybu ex
|
||||
<esc> # Wychodzi z dowolnego aktywnego trybu do trybu komend
|
||||
|
||||
# Kopiowanie i wklejanie tekstu
|
||||
|
||||
y # Skopiuj zaznaczony tekst
|
||||
yy # Skopiuj aktualną linię
|
||||
d # Usuń zaznaczony tekst
|
||||
dd # Usuń aktualną linię
|
||||
p # Wklej skopiowany tekst za kursorem
|
||||
P # Wklej skopiowany tekst przed kursorem
|
||||
x # Usuń znak pod kursorem
|
||||
```
|
||||
|
||||
## 'Gramatyka' vim'a
|
||||
|
||||
Vim można traktować jako zbiór komend w formacie 'Akcja-Modyfikator-Obiekt', gdzie:
|
||||
|
||||
Akcja - jedna z dostępnych akcji
|
||||
Modyfikator - w jaki sposób wykonywana jest akcja
|
||||
Obiekt - obiekt na którym wykonywana jest akcja
|
||||
|
||||
Kilka ważnych przykładów Akcji, Modyfikatorów i Obiektów:
|
||||
|
||||
```
|
||||
# 'Akcje'
|
||||
|
||||
d # Usuń
|
||||
c # Zmień
|
||||
y # Skopiuj
|
||||
v # Zaznacz
|
||||
|
||||
# 'Modyfikatory'
|
||||
|
||||
i # W środku
|
||||
a # Dookoła
|
||||
NUM # Liczba
|
||||
f # Szuka czegoś i zatrzymuje się na tym
|
||||
t # Szuka czegoś i zatrzymuje się przed tym
|
||||
/ # Znajduje napis od kursora naprzód
|
||||
? # Znajduje napis przed kursorem
|
||||
|
||||
# 'Obiekty'
|
||||
|
||||
w # Słowo
|
||||
s # Zdanie
|
||||
p # Paragraf
|
||||
b # Blok
|
||||
|
||||
# Przykładowe 'zdania'
|
||||
|
||||
d2w # Usuń 2 słowa
|
||||
cis # Zmień w zdaniu
|
||||
yip # Skopiuj paragraf w którym jest kursor
|
||||
ct< # Zamień na <
|
||||
d$ # Usuń tekst do końca linii
|
||||
```
|
||||
|
||||
## Pewne skróty i triki
|
||||
|
||||
<!--TODO: Dodać więcej!-->
|
||||
```
|
||||
> # Zrób wcięcie zaznaczonego bloku
|
||||
< # Usuń wcięcie zaznaczonego bloku
|
||||
:earlier 15m # Przywróć dokument do stanu z przed 15 minut
|
||||
:later 15m # Odwróć efekt poprzedniej komendy
|
||||
ddp # Zamień kolejnością kolejne linie, dd potem p
|
||||
. # Powtórz poprzednią komendę
|
||||
```
|
||||
|
||||
## Makra
|
||||
|
||||
Makra są właściwie nagrywanymi akcjami. Gdy zaczynasz nagrywać makro, nagrywa ono
|
||||
**każdą** akcję i komendę jaką wykonasz do momentu przerwania nagrywania.
|
||||
Wywołanie makra wykonuje dokładnie te same operacje w tej samej kolejności.
|
||||
|
||||
```
|
||||
qa # Zacznij nagrywać makro 'a'
|
||||
q # Przerwij nagrywanie
|
||||
@a # Odtwórz makro 'a'
|
||||
```
|
||||
|
||||
### Konfiguracja ~/.vimrc
|
||||
|
||||
Plik .vimrc może być użyty do skonfigurowania Vim'a przy jego starcie
|
||||
|
||||
Poniżej zamieszczono przykładowy plik ~/.vimrc:
|
||||
|
||||
```vim
|
||||
" Przykładowy ~/.vimrc
|
||||
" 2016.10
|
||||
|
||||
" Wymagane aby korzystać z opcji iMproved
|
||||
set nocompatible
|
||||
|
||||
" Na podstawie typu pliku włącza inteligentne wcięcia i inne.
|
||||
filetype indent plugin on
|
||||
|
||||
" Włącz podkreślanie składni
|
||||
syntax on
|
||||
|
||||
" Lepsze uzupełnianie składni komend
|
||||
set wildmenu
|
||||
|
||||
" Wyszukiwanie będzie ignorować wielkość liter poza przypadkami gdy użyjemy wielkich liter
|
||||
set ignorecase
|
||||
set smartcase
|
||||
|
||||
" Po otwarciu pliku gdzie nie jest zdefiniowane zachowanie wcięć
|
||||
" zostanie zachowane wcięcie takie samo jak w aktualnej linii
|
||||
set autoindent
|
||||
|
||||
" Wyświetlaj numer lini
|
||||
set number
|
||||
|
||||
" Opcje wcięć, zmień w zależności od osobistych upodobań
|
||||
|
||||
" Szerokość TAB w spacjach
|
||||
set tabstop=4
|
||||
|
||||
" Liczba spacji w TAB podczas edycji
|
||||
set softtabstop=4
|
||||
|
||||
" Liczba spacji gdy wykonywane są operacje wcięcia (>> i <<)
|
||||
set shiftwidth=4
|
||||
|
||||
" Zamieniaj tabulatory na spacje
|
||||
set expandtab
|
||||
|
||||
" Aktywuj inteligentne tabulatory i spacje do wcięć i wyrównań
|
||||
set smarttab
|
||||
```
|
||||
|
||||
### Odniesienia [ENG]
|
||||
|
||||
[Vim | Home](http://www.vim.org/index.php)
|
||||
|
||||
`$ vimtutor`
|
||||
|
||||
[A vim Tutorial and Primer](https://danielmiessler.com/study/vim/)
|
||||
|
||||
[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about)
|
||||
|
||||
[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim)
|
||||
133
pl/xml.md
Normal file
133
pl/xml.md
Normal file
@@ -0,0 +1,133 @@
|
||||
---
|
||||
language: XML
|
||||
filename: learnxml-pl.xml
|
||||
contributors:
|
||||
- ["João Farias", "https://github.com/JoaoGFarias"]
|
||||
translators:
|
||||
- ["Tomasz Janiszewski", "https://github.com/janisz"]
|
||||
lang: pl-pl
|
||||
---
|
||||
|
||||
XML (_Extensible Markup Language_) to rozszerzalny język znaczników, stworzony
|
||||
do przechowywania i transportu danych.
|
||||
|
||||
W przeciwieństwie do HTML, XML nie specyfikuje w jaki sposób wyświetlić dane, a
|
||||
tylko je przechowuje.
|
||||
|
||||
* Składnia XML
|
||||
|
||||
```xml
|
||||
<!-- Komentarze w XML wyglądają jak ten -->
|
||||
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<ksiegarnia>
|
||||
<ksiazka kategoria="GOTOWANIE">
|
||||
<tytul lang="pl">Codzienny Włoski</tytul>
|
||||
<autor>Giada De Laurentiis</autor>
|
||||
<rok>2005</rok>
|
||||
<cena>30.00</cena>
|
||||
</ksiazka>
|
||||
<ksiazka kategoria="DZIECI">
|
||||
<tytul lang="pl">Harry Potter</tytul>
|
||||
<autor>J K. Rowling</autor>
|
||||
<rok>2005</rok>
|
||||
<cena>29.99</cena>
|
||||
</ksiazka>
|
||||
<ksiazka kategoria="WEB">
|
||||
<tytul lang="pl">Nauka XML</tytul>
|
||||
<autor>Erik T. Ray</autor>
|
||||
<rok>2003</rok>
|
||||
<cena>39.95</cena>
|
||||
</ksiazka>
|
||||
</ksiegarnia>
|
||||
|
||||
<!-- Powyżej jest typowy plik XML.
|
||||
Zaczyna się od deklaracji zawierającej metadane (opcjonalne).
|
||||
|
||||
XML używa drzewiastej struktury. Powyżej, głównym wierzchołkiem jest
|
||||
'ksiegarnia' , która zawiera trzy (3) węzły potomne, wszystkie 'ksiazki',
|
||||
które zawierają swoje węzły potomne, i tak dalej...
|
||||
|
||||
Węzły są tworzone używające otwierających/zamykających znaczników.
|
||||
Węzły potomne znajdują się pomiędzy otwierającym i zamykającym znacznikiem.
|
||||
-->
|
||||
|
||||
<!-- XML przechowuje dwa typy danych
|
||||
1 - Atrybuty -> metadane o węźle
|
||||
Zazwyczaj parser XML używa tych informacji do przechowywania danych we
|
||||
właściwy sposób. Atrybuty nadawane są poprzez wpisanie ich w otwierajacym
|
||||
znaczniku.
|
||||
2 - Elementy -> to są czyste dane.
|
||||
Dane, które parser otrzymuje z pliku XML.
|
||||
Elementy są deklarowane pomiędzy otwierajacym i zamykającym znacznikiem,
|
||||
bez nawiasów. -->
|
||||
|
||||
<!-- Poniższy element ma dwa atrybuty -->
|
||||
<plik type="gif" id="4293">komputer.gif</plik>
|
||||
```
|
||||
|
||||
* Dobrze sformatowany dokument i walidacja
|
||||
|
||||
Dokument XML jest dobrze sformatowany gdy jest syntaktycznie poprawny.
|
||||
Jednakże możliwe jest wstrzykiwanie większej liczby ograniczeń w dokumencie,
|
||||
używając definicji takich jak DTD i XML Schema.
|
||||
|
||||
Dokument XML, który jest zgodny ze swoją definicją jest poprawny.
|
||||
|
||||
|
||||
Korzystając z tych narzędzi możesz sprawdzić dane zawarte w dokumencie poza
|
||||
logiką aplikacji.
|
||||
|
||||
```xml
|
||||
<!-- Poniżej jest uproszczona wersja dokumentu księgarni,
|
||||
z dodatkową definicją DTD.-->
|
||||
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE notatka SYSTEM "Ksiegarnia.dtd">
|
||||
<ksiegarnia>
|
||||
<ksiazka kategoria="GOTOWANIE">
|
||||
<tytul >Everyday Italian</tytul>
|
||||
<cena>30.00</cena>
|
||||
</ksiazka>
|
||||
</ksiegarnia>
|
||||
|
||||
<!-- DTD może wyglądać następująco:-->
|
||||
|
||||
<!DOCTYPE notatka
|
||||
[
|
||||
<!ELEMENT ksiegarnia (ksiazka+)>
|
||||
<!ELEMENT ksiazka (tytul,cena)>
|
||||
<!ATTLIST ksiazka kategoria CDATA "Literatura">
|
||||
<!ELEMENT tytul (#PCDATA)>
|
||||
<!ELEMENT cena (#PCDATA)>
|
||||
]>
|
||||
|
||||
|
||||
<!-- DTD zaczyna się od deklaracji
|
||||
Zaczynając od góry, główny węzeł jest zadeklarowany jako wymagający jednego
|
||||
lub więcej węzłów potomnych typu 'ksiżka'.
|
||||
Każda 'ksiażka' powinna zawierać dokładnie jeden 'tytuł' i 'cene' oraz atrybut
|
||||
'kategoria' z 'literaturą' jako wartość domyślna.
|
||||
'tytuł' i 'cena' to pola typu parsowalnych zmiennyc znakowych, co oznacza że
|
||||
użyte znaczniki zostaną zinterpretowane < zamienione <. -->
|
||||
|
||||
<!-- DTD moze być deklarowane wewnątrz pliku XML. -->
|
||||
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
|
||||
<!DOCTYPE notatka
|
||||
[
|
||||
<!ELEMENT ksiegarnia (ksiazka+)>
|
||||
<!ELEMENT ksiazka (tytul,cena)>
|
||||
<!ATTLIST ksiazka kategoria CDATA "Literatura">
|
||||
<!ELEMENT tytul (#PCDATA)>
|
||||
<!ELEMENT cena (#PCDATA)>
|
||||
]>
|
||||
|
||||
<ksiegarnia>
|
||||
<ksiazka kategoria="GOTOWANIE">
|
||||
<tytul >Everyday Italian</tytul>
|
||||
<cena>30.00</cena>
|
||||
</ksiazka>
|
||||
</ksiegarnia>
|
||||
```
|
||||
Reference in New Issue
Block a user