mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 09:41:36 +00:00
Compare commits
4 Commits
8757c648e5
...
9817a7193f
Author | SHA1 | Date | |
---|---|---|---|
|
9817a7193f | ||
|
00e817db85 | ||
|
1e27cd2fd1 | ||
|
4ed1d5a1dc |
@ -14,7 +14,7 @@ Turingovsky kompletní (ekvivalentní) programovací jazyk a má pouze 8 příka
|
||||
|
||||
Můžete si ho vyzkoušet přímo v prohlížeči s [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
|
||||
|
||||
```
|
||||
```bf
|
||||
Jakýkoliv znak mimo "><+-.,[]" (bez uvozovek) je ignorován.
|
||||
|
||||
Brainfuck je reprezentován jako pole, které má 30.000 buněk s počátkem v nule
|
||||
|
@ -16,7 +16,7 @@ mit lediglich 8 Befehlen.
|
||||
Mit dem [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/) kann
|
||||
Brainfuck im Browser ausprobiert werden.
|
||||
|
||||
```
|
||||
```bf
|
||||
Alle Zeichen außer "><+-.,[]" (ohne die Klammern) werden ignoriert.
|
||||
|
||||
Brainfuck besteht aus einem Array mit unendlich vielen Elementen, die alle mit Null initialisiert
|
||||
|
@ -15,7 +15,7 @@ lenguaje de programación extremadamente pequeño, Turing completo con sólo 8 c
|
||||
Puedes probar brainfuck en tu navegador con [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
|
||||
|
||||
|
||||
```
|
||||
```bf
|
||||
Cualquier caracter que no sea "><+-.,[]" (sin incluir las comillas)
|
||||
será ignorado.
|
||||
|
||||
|
@ -33,7 +33,7 @@ lang: fa-ir
|
||||
|
||||
<p dir='rtl'>در اینجا یک برنامه ی ساره برین فاک را مشاهده میکنید.</p>
|
||||
|
||||
```
|
||||
```bf
|
||||
++++++ [ > ++++++++++ < - ] > +++++ .
|
||||
```
|
||||
|
||||
@ -44,7 +44,7 @@ lang: fa-ir
|
||||
<p dir='rtl'>-- و در انتهای حلقه به خانه ی اول برگشته تا حلقه کنترل شود</p>
|
||||
<p dir='rtl'>بعد از اتمام حلقه به خانه ی دوم میرود و پنج بار به این خانه اضافه کرده و سپس آنرا چاپ میکند.</p>
|
||||
|
||||
```
|
||||
```bf
|
||||
, [ > + < - ] > .
|
||||
```
|
||||
|
||||
@ -55,13 +55,13 @@ lang: fa-ir
|
||||
<p dir='rtl'>توجه داشته باشید که ردر بالا فواصل بین دستور ها فقط برای خوانایی بیشتر گذاشته شده اند.</p>
|
||||
<p dir='rtl'>در واقع برنامه بالا به شکل زیر صحیح می باشد.</p>
|
||||
|
||||
```
|
||||
```bf
|
||||
,[>+<-]>.
|
||||
```
|
||||
|
||||
<p dir='rtl'>حال سعی کنید ببینید که برنامه ی زیر چه کاری انجام می دهد؟</p>
|
||||
|
||||
```
|
||||
```bf
|
||||
,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
|
||||
```
|
||||
|
||||
|
@ -12,7 +12,7 @@ lang: fr-fr
|
||||
Brainfuck (sans majuscule à part au début d’une phrase) est un langage
|
||||
Turing-complet extrêmement simple avec seulement 8 commandes.
|
||||
|
||||
```
|
||||
```bf
|
||||
Tout caractère en dehors de "><+-.,[]" (en dehors des guillemets) est ignoré.
|
||||
|
||||
Brainfuck est représenté par un tableau de 30 000 cellules initialisées à 0 et
|
||||
|
@ -1,4 +1,4 @@
|
||||
---
|
||||
--
|
||||
language: BF
|
||||
filename: learnbf-it.bf
|
||||
contributors:
|
||||
@ -17,7 +17,7 @@ estremamente minimale, composto da solo 8 comandi.
|
||||
Puoi provarlo nel tuo browser utilizzando
|
||||
[brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
|
||||
|
||||
```
|
||||
```bf
|
||||
Qualsiasi carattere diverso da "><+-.,[]" (escludendo gli apici)
|
||||
viene ignorato.
|
||||
Branfuck è caratterizzato da un array di 30,000 celle inizializzate a zero
|
||||
|
@ -13,7 +13,7 @@ lang: ko-kr
|
||||
Brainfuck(문장을 시작하는 단어가 아닌이상 첫글자는 대문자를 사용하지 않습니다)은
|
||||
여덟가지 명령어만으로 튜링-완전한 최소주의 프로그래밍 언어입니다.
|
||||
|
||||
```
|
||||
```bf
|
||||
"><+-.,[]" 이외의 문자들은 무시됩니다. (쌍따옴표는 제외)
|
||||
|
||||
브레인퍽은 30,000 칸 짜리의 0으로 초기화된 배열과,
|
||||
|
@ -13,7 +13,7 @@ Brainfuck (schrijf je niet met een hoofdletter behalve aan het begin van een
|
||||
zin) is een extreem
|
||||
minimalistische Turing-complete programmeertaal met maar acht commando's.
|
||||
|
||||
```
|
||||
```bf
|
||||
Elk karakter behalve "><+-.,[]" (en de quotes) wordt genegeerd.
|
||||
|
||||
Brainfuck wordt gerepresenteerd door een array met 30.000 cellen die initieel
|
||||
|
@ -19,7 +19,7 @@ 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
|
||||
|
427
pl-pl/lua-pl.html.markdown
Normal file
427
pl-pl/lua-pl.html.markdown
Normal file
@ -0,0 +1,427 @@
|
||||
---
|
||||
language: Lua
|
||||
contributors:
|
||||
- ["Tyler Neylon", "http://tylerneylon.com/"]
|
||||
translators:
|
||||
- ["Aimless", "https://github.com/aimlesx"]
|
||||
filename: learnlua-pl.lua
|
||||
lang: pl-pl
|
||||
---
|
||||
|
||||
```lua
|
||||
-- Dwa myślniki rozpoczynają jednolinijkowy komentarz.
|
||||
|
||||
--[[
|
||||
Dodanie dwóch znaków [ oraz ] tworzy
|
||||
komentarz wieloliniowy.
|
||||
--]]
|
||||
|
||||
----------------------------------------------------
|
||||
-- 1. Zmienne i sterowanie przepływem.
|
||||
----------------------------------------------------
|
||||
|
||||
liczba = 42 -- Liczby mogą być całkowite lub zmiennoprzecinkowe.
|
||||
|
||||
s = 'walternate' -- Niezmienne ciągi znaków jak w Pythonie.
|
||||
t = "podwójne cudzysłowy też są w porządku"
|
||||
u = [[ Podwójne nawiasy
|
||||
otwierają i zamykają
|
||||
wieloliniowe ciągi znaków.]]
|
||||
t = nil -- Usuwa zmienną t; Lua posiada garbage collector.
|
||||
|
||||
-- Bloki są oznaczane słowami kluczowymi, takimi jak do/end:
|
||||
while liczba < 50 do
|
||||
liczba = liczba + 1 -- Brak operatorów ++ lub +=.
|
||||
end
|
||||
|
||||
-- Instrukcje warunkowe if:
|
||||
if liczba > 40 then
|
||||
print('powyżej 40')
|
||||
elseif s ~= 'walternate' then -- ~= oznacza "nie równe".
|
||||
-- Porównanie równości to == jak w Pythonie; działa dla stringów.
|
||||
io.write('nie powyżej 40\n') -- Domyślnie wypisuje na stdout.
|
||||
else
|
||||
-- Zmienne są domyślnie globalne.
|
||||
zmiennaGlobalna = 5 -- Popularny jest camel case.
|
||||
|
||||
-- Tak deklaruje się zmienne lokalne:
|
||||
local linia = io.read() -- Odczytuje kolejną linię wejścia standardowego.
|
||||
|
||||
-- Łączenie ciągów znaków za pomocą operatora .. :
|
||||
print('Nadchodzi zima, ' .. linia)
|
||||
end
|
||||
|
||||
-- Niezdefiniowane zmienne zwracają nil.
|
||||
-- Nie jest to błędem:
|
||||
foo = nieznanaZmienna -- Teraz foo = nil.
|
||||
|
||||
wartoscLogiczna = false
|
||||
|
||||
-- Tylko nil i false są fałszywe; 0 i '' są prawdziwe!
|
||||
if not wartoscLogiczna then print('było fałszywe') end
|
||||
|
||||
-- 'or' i 'and' podlegają ewaluacji short-circuit.
|
||||
-- Działają podobnie do operatora a?b:c z C/js:
|
||||
wynik = wartoscLogiczna and 'tak' or 'nie' --> 'nie'
|
||||
|
||||
suma = 0
|
||||
for i = 1, 100 do -- Zakres obejmuje oba końce.
|
||||
suma = suma + i
|
||||
end
|
||||
|
||||
-- Aby zliczać w dół użyj zakresu "100, 1, -1":
|
||||
suma = 0
|
||||
for j = 100, 1, -1 do suma = suma + j end
|
||||
|
||||
-- Ogólnie zakres to początek, koniec[, krok].
|
||||
|
||||
-- Inna konstrukcja pętli:
|
||||
repeat
|
||||
print('droga przyszłości')
|
||||
liczba = liczba - 1
|
||||
until liczba == 0
|
||||
|
||||
|
||||
----------------------------------------------------
|
||||
-- 2. Funkcje.
|
||||
----------------------------------------------------
|
||||
|
||||
function fib(n)
|
||||
if n < 2 then return 1 end
|
||||
return fib(n - 2) + fib(n - 1)
|
||||
end
|
||||
|
||||
-- Funkcje anonimowe i domknięcia (Closures w JS) są okej:
|
||||
function sumator(x)
|
||||
-- Zwracana funkcja jest tworzona, gdy sumator jest
|
||||
-- wywoływany, i zapamiętuje wartość x:
|
||||
return function (y) return x + y end
|
||||
end
|
||||
a1 = sumator(9)
|
||||
a2 = sumator(36)
|
||||
print(a1(16)) --> 25
|
||||
print(a2(64)) --> 100
|
||||
|
||||
-- Zwracanie, wywołania funkcji i przypisania działają
|
||||
-- z listami o potencjalnie różnych długościach.
|
||||
-- Zmienne które nie dostaną wartości dostają wartość nil;
|
||||
-- nadmiarowe wartości są odrzucane.
|
||||
|
||||
x, y, z = 1, 2, 3, 4
|
||||
-- Teraz x = 1, y = 2, z = 3, a 4 jest odrzucone.
|
||||
|
||||
function bar(a, b, c)
|
||||
print(a, b, c)
|
||||
return 4, 8, 15, 16, 23, 42
|
||||
end
|
||||
|
||||
x, y = bar('zaphod') --> wypisuje "zaphod nil nil"
|
||||
-- Teraz x = 4, y = 8, wartości 15...42 są odrzucone.
|
||||
|
||||
-- Funkcje są obiektami pierwszej klasy, mogą być lokalne/globalne.
|
||||
-- Obie linie poniżej mają identyczny efekt:
|
||||
function f(x) return x * x end
|
||||
f = function (x) return x * x end
|
||||
|
||||
-- Te również:
|
||||
local function g(x) return math.sin(x) end
|
||||
local g; g = function (x) return math.sin(x) end
|
||||
-- deklaracja 'local g' sprawia, że odwołania do g są poprawne.
|
||||
|
||||
-- Tak swoją drogą, to funkcje trygonometryczne działają w radianach.
|
||||
|
||||
-- Wywołania z jednym parametrem stringowym nie wymagają nawiasów:
|
||||
print 'cześć' -- Działa poprawnie.
|
||||
|
||||
|
||||
----------------------------------------------------
|
||||
-- 3. Tabele.
|
||||
----------------------------------------------------
|
||||
|
||||
-- Tabele = jedyna złożona struktura danych w Lua;
|
||||
-- są to tablice asocjacyjne.
|
||||
-- Podobne do tablic w PHP lub obiektów w JS, są to
|
||||
-- słowniki (hashmap), które można używać także
|
||||
-- jako listy.
|
||||
|
||||
-- Używanie tabel jako słowników / map:
|
||||
|
||||
-- Literały słowników domyślnie mają klucze typu string:
|
||||
t = {klucz1 = 'wartość1', klucz2 = false}
|
||||
|
||||
-- Klucze typu string mogą używać notacji kropkowej (jak w JS):
|
||||
print(t.key1) -- Wypisuje 'wartość1'.
|
||||
t.nowyKlucz = {} -- Dodaje nową parę klucz/wartość.
|
||||
t.klucz2 = nil -- Usuwa klucz2 z tabeli.
|
||||
|
||||
-- Notacja literału dla dowolnego klucza (nie będącego nil):
|
||||
u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'}
|
||||
print(u[6.28]) -- wypisuje "tau"
|
||||
|
||||
-- Dopasowanie klucza działa według wartości dla liczb
|
||||
-- i ciągów, ale według tożsamości dla tabel.
|
||||
a = u['@!#'] -- Teraz a = 'qbert'.
|
||||
b = u[{}] -- Można by oczekiwać 1729, ale wynik to nil:
|
||||
-- b = nil, ponieważ wyszukiwanie nie powiodło się.
|
||||
-- Dzieje się tak, ponieważ klucz, którego użyliśmy, nie jest
|
||||
-- tym samym obiektem, który był użyty do przechowania
|
||||
-- oryginalnej wartości. Dlatego ciągi i liczby są bardziej
|
||||
-- przenośnymi kluczami.
|
||||
|
||||
-- Funkcje z jednym parametrem będącym tabelą nie wymagają nawiasów:
|
||||
function h(x) print(x.klucz1) end
|
||||
h{klucz1 = 'Sonmi~451'} -- Wypisuje 'Sonmi~451'.
|
||||
|
||||
for key, val in pairs(u) do -- Iteracja przez tabelę.
|
||||
print(key, val)
|
||||
end
|
||||
|
||||
-- _G to specjalna tabela zawierająca wszystkie zmienne globalne.
|
||||
print(_G['_G'] == _G) -- Wypisuje 'true'.
|
||||
|
||||
-- Używanie tabel jako list / tablic:
|
||||
|
||||
-- Literały list ustawiają domyślnie klucze jako liczby całkowite:
|
||||
v = {'wartość1', 'wartość2', 1.21, 'gigawaty'}
|
||||
for i = 1, #v do -- #v to rozmiar listy v.
|
||||
print(v[i]) -- Indeksy zaczynają się od 1 !! SZALONE!
|
||||
end
|
||||
-- "Lista" nie jest prawdziwym typem. v to po prostu tabela
|
||||
-- z kolejnymi kluczami liczbowymi, traktowana jako lista.
|
||||
|
||||
----------------------------------------------------
|
||||
-- 3.1 Metatabele i metametody.
|
||||
----------------------------------------------------
|
||||
|
||||
-- Tabela może mieć metatabelę, która nadaje tabeli
|
||||
-- funkcjonalność podobną do przeciążania operatorów.
|
||||
-- Później zobaczymy, jak metatabele wspierają zachowanie
|
||||
-- przypominające prototypy z JS.
|
||||
|
||||
f1 = {a = 1, b = 2} -- Reprezentuje ułamek a/b.
|
||||
f2 = {a = 2, b = 3}
|
||||
|
||||
-- To by się nie powiodło:
|
||||
-- s = f1 + f2
|
||||
|
||||
metaulamek = {}
|
||||
function metaulamek.__add(f1, f2)
|
||||
sum = {}
|
||||
sum.b = f1.b * f2.b
|
||||
sum.a = f1.a * f2.b + f2.a * f1.b
|
||||
return sum
|
||||
end
|
||||
|
||||
setmetatable(f1, metaulamek)
|
||||
setmetatable(f2, metaulamek)
|
||||
|
||||
s = f1 + f2 -- Wywołuje __add(f1, f2) na metatabeli f1
|
||||
|
||||
-- f1, f2 nie mają klucza dla swojej metatabeli, w przeciwieństwie
|
||||
-- do prototypów w JS, więc trzeba ją uzyskać za pomocą
|
||||
-- getmetatable(f1). Metatabela to normalna tabela
|
||||
-- z kluczami, które Lua rozpoznaje, np. __add.
|
||||
|
||||
-- Ale następna linia zawiedzie, ponieważ s nie ma metatabeli:
|
||||
-- t = s + s
|
||||
-- Wzorce przypominające klasy przedstawione poniżej
|
||||
-- byłyby w stanie to naprawić.
|
||||
|
||||
-- __index w metatabeli przeciąża odwołania przez kropkę:
|
||||
domyslnieUlubione = {zwierze = 'gru', jedzenie = 'pączki'}
|
||||
mojeUlubione = {jedzenie = 'pizza'}
|
||||
setmetatable(mojeUlubione, {__index = domyslnieUlubione})
|
||||
zjedzonyPrzez = mojeUlubione.zwierze -- działa! dzięki metatabelo
|
||||
|
||||
-- Bezpośrednie wyszukiwania w tabeli, które zawiodą, zostaną
|
||||
-- powtórzone przy użyciu wartości __index w metatabeli, co
|
||||
-- może się rekurencyjnie powtarzać.
|
||||
|
||||
-- Wartość __index może być także funkcją function(tabela, klucz)
|
||||
-- dla bardziej zaawansowanych wyszukiwań.
|
||||
|
||||
-- Wartości __index, __add, itd. nazywane są metametodami.
|
||||
-- Pełna lista. Tutaj a to tabela z metametodą.
|
||||
|
||||
-- __add(a, b) dla a + b
|
||||
-- __sub(a, b) dla a - b
|
||||
-- __mul(a, b) dla a * b
|
||||
-- __div(a, b) dla a / b
|
||||
-- __mod(a, b) dla a % b
|
||||
-- __pow(a, b) dla a ^ b
|
||||
-- __unm(a) dla -a
|
||||
-- __concat(a, b) dla a .. b
|
||||
-- __len(a) dla #a
|
||||
-- __eq(a, b) dla a == b
|
||||
-- __lt(a, b) dla a < b
|
||||
-- __le(a, b) dla a <= b
|
||||
-- __index(a, b) <fn or a table> dla a.b
|
||||
-- __newindex(a, b, c) dla a.b = c
|
||||
-- __call(a, ...) dla a(...)
|
||||
|
||||
----------------------------------------------------
|
||||
-- 3.2 Tabele przypominające klasy i dziedziczenie.
|
||||
----------------------------------------------------
|
||||
|
||||
-- Klasy nie są wbudowane; istnieją różne sposoby
|
||||
-- na ich tworzenie przy użyciu tabel i metatabel.
|
||||
|
||||
-- Wyjaśnienie dla tego przykładu znajduje się poniżej.
|
||||
|
||||
Pies = {} -- 1.
|
||||
|
||||
function Pies:new() -- 2.
|
||||
nowyObiekt = {odglos = 'hau'} -- 3.
|
||||
self.__index = self -- 4.
|
||||
return setmetatable(nowyObiekt, self) -- 5.
|
||||
end
|
||||
|
||||
function Pies:wydajOdglos() -- 6.
|
||||
print('Ja mówię ' .. self.odglos)
|
||||
end
|
||||
|
||||
panPies = Pies:new() -- 7.
|
||||
panPies:wydajOdglos() -- 'Ja mówię hau' -- 8.
|
||||
|
||||
-- 1. Pies działa jak klasa; w rzeczywistości to tabela.
|
||||
-- 2. function tablename:fn(...) to to samo, co
|
||||
-- function tablename.fn(self, ...)
|
||||
-- Dwukropek dodaje pierwszy argument o nazwie self.
|
||||
-- Przeczytaj 7 i 8 poniżej, aby zrozumieć, jak self
|
||||
-- dostaje swoją wartość.
|
||||
-- 3. nowyObiekt będzie instancją klasy Pies.
|
||||
-- 4. self = klasa, która jest instancjonowana. Często
|
||||
-- self = Pies, ale dziedziczenie może to zmienić.
|
||||
-- nowyObiekt dostaje funkcje self, kiedy ustawiamy
|
||||
-- metatabelę nowyObiekt i __index self na self.
|
||||
-- 5. Przypomnienie: setmetatable zwraca swój pierwszy argument.
|
||||
-- 6. Dwukropek działa jak w punkcie 2, ale tym razem
|
||||
-- oczekujemy, że self będzie instancją a nie klasą.
|
||||
-- 7. To samo, co Pies.new(Pies), więc self = Pies w new().
|
||||
-- 8. To samo, co panPies.wydajOdglos(panPies); self = panPies.
|
||||
|
||||
----------------------------------------------------
|
||||
|
||||
-- Przykład dziedziczenia:
|
||||
|
||||
GlosnyPies = Dog:new() -- 1.
|
||||
|
||||
function GlosnyPies:wydajOdglos()
|
||||
s = self.odglos .. ' ' -- 2.
|
||||
print(s .. s .. s)
|
||||
end
|
||||
|
||||
seymour = GlosnyPies:new() -- 3.
|
||||
seymour:wydajOdglos() -- 'hau hau hau' -- 4.
|
||||
|
||||
-- 1. GlosnyPies dziedziczy metody i zmienne od Pies.
|
||||
-- 2. self ma klucz 'odglos' z new(), zobacz punkt 3.
|
||||
-- 3. To samo, co GlosnyPies.new(GlosnyPies), przekształcone w
|
||||
-- Pies.new(GlosnyPies), ponieważ GlosnyPies nie ma klucza 'new',
|
||||
-- ale ma __index = Pies w swojej metatabeli.
|
||||
-- Wynik: metatabela seymoura to GlosnyPies, a
|
||||
-- GlosnyPies.__index = GlosnyPies. Więc seymour.klucz1 będzie
|
||||
-- = seymour.klucz1, GlosnyPies.klucz1, Pies.klucz1, w zależności od tego,
|
||||
-- która tabela pierwsza ma dany klucz.
|
||||
-- 4. Klucz 'wydajOdglos' jest znaleziony w GlosnyPies; to to samo,
|
||||
-- co GlosnyPies.wydajOdglos(seymour).
|
||||
|
||||
-- Jeśli potrzeba, new() w podklasie wygląda jak w bazowej:
|
||||
function GlosnyPies:new()
|
||||
nowyObiekt = {}
|
||||
-- konfiguracja nowyObiekt
|
||||
self.__index = self
|
||||
return setmetatable(nowyObiekt, self)
|
||||
end
|
||||
|
||||
----------------------------------------------------
|
||||
-- 4. Moduły.
|
||||
----------------------------------------------------
|
||||
|
||||
|
||||
--[[ Komentuję tę sekcję, aby reszta
|
||||
-- tego skryptu pozostała możliwa do uruchomienia.
|
||||
```
|
||||
|
||||
```lua
|
||||
-- Załóżmy, że plik mod.lua wygląda tak:
|
||||
local M = {}
|
||||
|
||||
local function przedstawSie()
|
||||
print('Hrunkner')
|
||||
end
|
||||
|
||||
function M.przywitajSie()
|
||||
print('Cześć ')
|
||||
przedstawSie()
|
||||
end
|
||||
|
||||
return M
|
||||
|
||||
-- Inny plik może użyć funkcjonalności z mod.lua:
|
||||
local mod = require('mod') -- Uruchamia plik mod.lua.
|
||||
|
||||
-- require to standardowy sposób na importowanie modułów.
|
||||
-- require działa jak: (jeśli nie jest w pamięci podręcznej; zob. poniżej)
|
||||
local mod = (function ()
|
||||
<zawartość mod.lua>
|
||||
end)()
|
||||
-- To tak, jakby mod.lua był ciałem funkcji, więc
|
||||
-- lokalne zmienne w mod.lua są niewidoczne na zewnątrz.
|
||||
|
||||
-- To działa, ponieważ mod tutaj = M w mod.lua:
|
||||
mod.przywitajSie() -- Wypisuje: Cześć Hrunkner
|
||||
|
||||
-- To jest błędne; sayMyName istnieje tylko w mod.lua:
|
||||
mod.przedstawSie() -- błąd
|
||||
|
||||
-- Zwracane wartości z require są pamiętane, więc plik
|
||||
-- jest uruchamiany maksymalnie raz, nawet jeśli jest
|
||||
-- wielokrotnie wywoływany przez require.
|
||||
|
||||
-- Załóżmy, że mod2.lua zawiera "print('Witam!')".
|
||||
local a = require('mod2') -- Wypisuje Witam!
|
||||
local b = require('mod2') -- Nie wypisuje nic; a=b.
|
||||
|
||||
-- dofile działa jak require, ale bez pamiętania wartości zwracanej:
|
||||
dofile('mod2.lua') --> Witam!
|
||||
dofile('mod2.lua') --> Witam! (uruchamia ponownie)
|
||||
|
||||
-- loadfile ładuje plik Lua, ale jeszcze go nie uruchamia.
|
||||
f = loadfile('mod2.lua') -- Wywołaj f(), aby go uruchomić.
|
||||
|
||||
-- load to odpowiednik loadfile dla stringów.
|
||||
-- (loadstring jest przestarzałe, używaj load)
|
||||
g = load('print(343)') -- Zwraca funkcję.
|
||||
g() -- Wypisuje 343; nic nie zostało wypisane wcześniej.
|
||||
--]]
|
||||
```
|
||||
|
||||
## Społeczność
|
||||
|
||||
Jeśli potrzebujesz wsparcia, dołącz do oficjalnej [listy mailingowej Lua](https://www.lua.org/lua-l.html), [kanału IRC](http://lua-users.org/wiki/IrcChannel) lub [forum](https://luaforum.com).
|
||||
|
||||
## Źródła
|
||||
|
||||
Chciałem nauczyć się Lua, aby tworzyć gry
|
||||
przy użyciu [silnika gier LÖVE](http://love2d.org/). To był mój cel.
|
||||
|
||||
Zacząłem od [„Lua for programmers” autorstwa BlackBulletIV](https://ebens.me/posts/lua-for-programmers-part-1/).
|
||||
Następnie przeczytałem oficjalną książkę [„Programming in Lua”](http://www.lua.org/pil/contents.html).
|
||||
Tak wyglądała moja droga.
|
||||
|
||||
Może być pomocne zapoznanie się z [krótką dokumentacją Lua](http://lua-users.org/wiki/LuaShortReference) na lua-users.org.
|
||||
|
||||
Główne tematy, które nie zostały omówione, to standardowe biblioteki:
|
||||
|
||||
* [`string` (łańcuchy znaków)](http://lua-users.org/wiki/StringLibraryTutorial)
|
||||
* [`table` (tabele)](http://lua-users.org/wiki/TableLibraryTutorial)
|
||||
* [`math` (funkcje matematyczne)](http://lua-users.org/wiki/MathLibraryTutorial)
|
||||
* [`io` (wejście/wyjście)](http://lua-users.org/wiki/IoLibraryTutorial)
|
||||
* [`os` (funkcje systemowe)](http://lua-users.org/wiki/OsLibraryTutorial)
|
||||
|
||||
Przy okazji, cały plik jest poprawnym skryptem Lua; zapisz go
|
||||
jako `learn.lua` i uruchom poleceniem "`lua learn.lua`"!
|
||||
|
||||
Ten tekst został pierwotnie napisany dla strony tylerneylon.com, a także
|
||||
jest dostępny jako [GitHub gist](https://gist.github.com/tylerneylon/5853042). Baw się dobrze z Lua!
|
@ -12,7 +12,7 @@ lang: pt-pt
|
||||
Brainfuck (não capitalizado excepto no início de uma frase) é uma linguagem de
|
||||
programação Turing-completa extremamente simples com apenas 8 comandos.
|
||||
|
||||
```
|
||||
```bf
|
||||
Qualquer caractere excepto "><+-.,[]" (não contar com as aspas) é ignorado.
|
||||
|
||||
Brainfuck é representado por um vector com 30 000 células inicializadas a zero
|
||||
|
@ -14,7 +14,7 @@ Brainfuck (пишется маленькими буквами, кроме нач
|
||||
|
||||
Вы можете испытать brainfuck в вашем браузере с помощью [brainfuck-визуализатора](http://fatiherikli.github.io/brainfuck-visualizer/).
|
||||
|
||||
```
|
||||
```bf
|
||||
Любой символ, кроме "><+-.,[]", игнорируется, за исключением кавычек.
|
||||
|
||||
Brainfuck представлен массивом из 30000 ячеек, инициализированных нулями,
|
||||
|
@ -14,7 +14,7 @@ minimalistiskt Turing-komplett programmeringsspråk med endast 8 kommandon.
|
||||
|
||||
Du kan testa brainfuck i din webbläsare via [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
|
||||
|
||||
```
|
||||
```bf
|
||||
Alla karaktärer förutom "><+-.,[]" (inte inkluderat citattecken) ignoreras.
|
||||
|
||||
Brainfuck är representerat av ett fält med 30 000 celler initialiserade till
|
||||
|
@ -12,7 +12,7 @@ Brainfuck (normalde brainfuck olarak bütün harfleri küçük olarak yazılır.
|
||||
son derece minimal bir programlama dilidir. (Sadece 8 komut) ve tamamen
|
||||
Turing'dir.
|
||||
|
||||
```
|
||||
```bf
|
||||
"><+-.,[]" (tırnak işaretleri hariç) karakterleri dışındaki her karakter
|
||||
gözardı edilir.
|
||||
|
||||
|
@ -3,7 +3,7 @@ language: F#
|
||||
contributors:
|
||||
- ["Scott Wlaschin", "http://fsharpforfunandprofit.com/"]
|
||||
translators:
|
||||
- ["Mustafa Zengin", "http://zengin.github.com/"]
|
||||
- ["Mustafa Zengin", "http://zengin.github.io/"]
|
||||
filename: learnfsharp-tr.fs
|
||||
lang: tr-tr
|
||||
---
|
||||
|
@ -3,7 +3,7 @@ language: TypeScript
|
||||
contributors:
|
||||
- ["Philippe Vlérick", "https://github.com/pvlerick"]
|
||||
translators:
|
||||
- ["Mustafa Zengin", "http://zengin.github.com"]
|
||||
- ["Mustafa Zengin", "http://zengin.github.io"]
|
||||
filename: learntypescript-tr.ts
|
||||
lang: tr-tr
|
||||
---
|
||||
|
@ -12,7 +12,7 @@ lang: zh-cn
|
||||
|
||||
Brainfuck 是一个极小的只有8个指令的图灵完全的编程语言。
|
||||
|
||||
```
|
||||
```bf
|
||||
除"><+-.,[]"之外的的任何字符都会被忽略 (不包含双引号)。
|
||||
|
||||
Brainfuck 包含一个有30,000个单元为0的数组,和
|
||||
|
Loading…
Reference in New Issue
Block a user