Перейти к содержимому

LeshaInc

Пользователи
 Профиль  Активность

  • Публикации

    777

  • Зарегистрирован

  • Посещение

  • Победитель дней

    68

Записи блога, опубликованные пользователем LeshaInc

  1. LeshaInc
    Rust

    Не так давно появился язык программирования Rust. В этой записи я расскажу вам, чем так примечателен Rust (раст) и почему всем стоит на него переходить.
    На главной странице раста написано, что он – системный язык программирования, который работает быстро, предотвращает вылеты и гарантирует безопасность.


    Не стоит прямо сейчас закрывать страницу из-за непонятных слов. Сейчас во всем разберемся.


    Rust – системный ЯП

    Это значит что на нем можно писать программы любой сложности и их можно будет запустить везде, от тостера до компьютера Васи Пупкина, без необходимости скачивать интерпретаторы/виртуальные машины (как в случае с Java и Lua ).  
    Например, Си – системный, а Java – нет. :P
    Попробуйте написать на Java ядро ОС. У вас ничего не выйдет, так как что бы запустить Java нужна виртуальная машина (да-да, то самое "скачать жаву" это и есть "скачать виртуальную машину Java =) )
    Совсем другое дело обстоит с Си.
     
    Например, следующий код можно запустить абсолютно на любом компьютере.
    int main() { int a = 1; a++; return 0;}
    Эквивалентный код на расте тоже будет работать везде. Вот он:
    fn main() { let mut a = 1; a += 1;}

    Эта фича позволит нам писать на расте программы любой сложности, от hello-world'ов, до операционных систем.
    Пойдем дальше.

    Rust – быстрый ЯП


    Раст – быстрый ЯП, и с этим не поспоришь. Он компилируется в машинный код что позволяет ему так быстро работать. Работает не хуже Си.

    Rust – безопасный ЯП  

    Безопасность раста проявляется во всем. От I/O до потоков, от указателей до типов данных. В этом можно убедиться самому.

    Например следующий код на Си int main(){ int x = 10; int *px = &x; px = 0; *px = 3;}
    Вполне скомпилируется, но работать не будет. Программа с подобным кодом упадет. Дебаг таких программ всегда сложен.

    Аналогичный код на расте:
    fn main() { let ref mut p = 10; p = 0; *p = 3;}
    Компилироваться он не будет, следовательно программист заметит (скорее всего) ошибку и исправит ее. Убедитесь сами.

    Это не единственный пример такого поведения компилятора раста. Он всегда сообщит вам о небезопасности кода, чего не скажешь о других компиляторах.


    Из фич этого языка я бы выделил:
    "Бесплатные" абстракции. Когда в Java абстракции достигаются путем уменьшения качества выходного кода, в расте все бесплатно, как и в C++. Гарантированная безопасность. Когда в других языках гарантия безопасности обеспечивается программистом, в расте компилятор сам позаботится о безопасности кода. Он делает это всегда, но мы вполне можем попросить его не проверять код. Для этого используются unsafe блоки кода (поговорим еще о них). Многопоточность без гонок (англ. data-race). Все кто писал многопоточный код на языках вроде C++ или Java знают как не просто достигнуть безопасности таких потоков. В расте же такой код делается очень просто, сам убеждался не раз. Трэйты. Разработчики раста решили отказаться от стандартной концепции классов и интерфейсов.
    Но на расте вполне можно писать в объектном стиле (поговорим еще об этом). Все решать вам.
     

    Фич куда больше, это только малая часть.

    О самой работе с растом будет написано в следующей серии. =)
     
    Да Здравствует Rust!
  2. LeshaInc
    Итак когда я захотел писать нормальные gui'шные программы я не знал как рисовать в ОС. Я искал мануалы но 'тупил'. Мне приходилось перелопачивать много информации чтобы понять как рисовать. Вскоре конечно я понял, но потратил много времени. Статья посвещается всем тем, кто так как и я не когда-то не может понять gpu api.
    Итак для начала нужно подключить нашего 'монстра' gpu api. Для этого надо ввести такие строчки вначале кода:
    local component = require("component") -- Подключаем API компонентовlocal gpu = component.gpu -- Подключаем GPU APi.
    После этого у нас загрузится наш 'монстр'. Итак программа наша программа ничего не делает. Хорошее начало. Теперь нарисуем первый пиксель! Для этого надо установить фон, таким какой нам цвет нужен, затем заполнить один пиксель пустым символом " ". Код будет выглядеть так:
    gpu.setBackground(ВАШ ЦВЕТ В 16 битном ФОРМАТЕ) --Например 0x00ff00gpu.set(X,Y,' ') -- X и Y это позиция вашего пикселя. Учтите что на компьютерах исчисление начинается не с середины, а с верхнего левого угла.
    Для удобства напишем функцию:
    function drawPixel(x,y,color) -- Начало функцииgpu.setBackground(color) -- Установка цвета gpu.set(x,y," ") -- Создание пикселяend -- Конец функции
    Теперь чтобы нарисовать один пиксель нужно будет просто ввести drawPixel(x,y,color). Учтите что нельзя писать там просто букву (x или y) если у вас нет переменной с таким названием. Если переменной нет, то пишите число. Также вы можете указать какой нибудь текст там где у нас ' '. Тем самым вы получите текст на цветном фоне. .
     

    Я думаю на сегодня все. Пока
  3. LeshaInc
    Итак, это снова я, сегодня я расскажу как делать более сложные вещи с Lua в OC, а именно:
    Очистка экрана; Коробочки; Кнопки.

    Ну что-же, приступим


    Вспомним-ка мы подключение API GPU. --Старый вариантlocal component = require("component")local gpu = component.gpu--Новый вариантlocal gpu = require("component").gpu
    Как вы видите теперь можно проще подключать API GPU.


    Очистка экрана. local w,h = gpu.getResolution() -- Узнаем разрешение монитораgpu.fill(1,1,w,h," ") --[[Тут мы заполняем пустым символом поле, начиная от верхнего левого угла экрана и заканчивающегося правым нижним углом. Проще говоря весь экран заполняем пустотой. Перед этой строкой можно указать и цвет фона/символов. Так можно добиться ромашек цветного фона.]]--
    Напишем для удобства функцию.
    function clear(color_bg, color_fg) local w,h = gpu.getResolution() -- Узнаем разрешение монитора local oldbg = gpu.getBackground() -- Для того, чтобы потом вернуть старый local oldfg = gpu.getForeground() -- цвет фона и символов. gpu.setBackground(color_bg) -- Устанавливаем цвет фона. gpu.setForeground(color_fg) -- Устанавливаем цвет символов. gpu.fill(1,1,w,h, " ") -- Заполняем экран пустотой. gpu.setBackground(oldbg) -- Восстанавливаем старый цвет фона. gpu.setForeground(oldfg) -- Восстанавливаем старый цвет символов.end
    Выглядит сложно, но на самом деле это просто. =)

    Коробочка
    function box(x,y,w,h,bg,fg,symb) -- Оставить symb " " и получится чистая коробка local oldbg = gpu.getBackground() local oldfg = gpu.getForeground() gpu.setBackground(color_bg) gpu.setForeground(color_fg) gpu.fill(x,y,w,h, symb) -- Рисуем боксик gpu.setBackground(oldbg) gpu.setForeground(oldfg) end
    Все просто и легко. =)

    Кнопка
    (будет сложно)
    local unicode = require("unicode") -- Нам потребуется юникод...-- Рисуем кнопку.function drawButton(x,y,bg,fg,text) local oldbg = gpu.getBackground() local oldfg = gpu.getForeground() gpu.setBackground(color_bg) gpu.setForeground(color_fg) gpu.set(x,y,text) -- Кнопка - текст с фоном. =) gpu.setBackground(oldbg) gpu.setForeground(oldfg) enddrawButton(2,2,0xff0000, 0x00ff00, "PressMeToWin")-- Обрабатывать клик будем по японский, можно использовать event.listen, но я для простоты использую event.pullwhile true do local name, add, xP, yP, b = event.pull("touch") if name ~= nil then if xP >= 2 and yP = 2 and xP <= 2 + unicode.len("PressMeToWin") then -- Тут сложно--Если нажали то... Например напишем "Ok" gpu.set(1,20, "Ok!") os.sleep(2) -- Спатки 2 секунды gpu.fill(1,20,10,10, " ") -- Очистить то, что написали end endend
    Как-то так. =)
    Пруф. =)
  4. LeshaInc
    Веб сервер на Lua.
    Часть 1: Установка
     
    Здравствуйте. Вы читаете запись из цикла "Веб сервер на Lua". В конце данного цикла у нас получится вполне работоспособный веб сайт, причем быстрый, да еще и на Lua. Я все действия буду производить в такой среде как "c9", сайт будет доступен под адресом: http://lua-includeralex.c9.io/ Все файлы, вы можете посмотреть тут: http://ide.c9.io/includeralex/lua Что, ж поехали.
     
    В этой части мы установим необходимый софт на наш сервер, увидим некий "Hello World!".
     
    Вступление
     

    Lua — мощный и быстрый скриптовый язык, который очень легко встраивается в C.
     

    OpenResty — это сборка Nginx с множеством сторонних модулей, в том числе для неблокирующего доступа к популярным БД. Последние версии используют LuaJIT для исполнения Lua. Разработчик Yichun Zhang (США, место работы: CloudFlare, основной разработчик lua-nginx-module).
     

    Lapis — это веб-фрейморк для написания веб-приложений на Lua и MoonScript, который живёт внутри OpenResty.
     
    Установка
     
    Со вступлением разобрались, теперь разберемся с установкой всего этого дела на наш сервер. Итак, что нам нужно: Lapis, OpenResty, Nginx, LuaRocks.
    Для начала:
    Установите perl 5.6.1+, libreadline, libpcre и libssl и убедитесь, что доступна команда ldconfig (её родительская папка может отсутствовать в PATH).
     
    Объяснять установку nginx не буду, это легко узнать на официальном сайте, поэтому сразу перейдем к установке OpenResty. Внимание, все объяснения по установке приведены для Линукса, объяснение для Виндовса и Мака возможно, будет в других частях цикла. Итак, установка OpenResty:
    $ wget http://openresty.org/download/ngx_openresty-1.7.4.1.tar.gz$ tar xzvf ngx_openresty-1.7.4.1.tar.gz$ cd ngx_openresty-1.7.4.1/$ ./configure$ make# make install
    После ввода этих команд (последовательно, конечно) у вас будет установлен OpenResty.
    Перейдем к LuaRocks. LuaRocks - это пакетный менеджер для Луа. Информацию о нем можно найти на https://luarocks.org/ В LuaRocks есть много вкусного, там тебе и OpenGL, и SSL, и moonscript, но сейчас не об этом. Установим LuaRocks, следуя инструкциям по установке на сайте. Если же у вас Ubuntu, как, впрочем, и у меня, вы можете установить LuaRocks напрямую из репы:
    # apt-get install luarocks
    Следующим шагом будет установка самого Lapis. Для этого воспользуемся LuaRocks, который мы только что скачали.
    # luarocks install lapis
    С установкой софта покончено. Перейдем к настройке всего этого.
     

    Настройка
    Для начала создадим "скелет" нашего сайта. Lapis сам сделает это за нас.
    $ lapis new --luawrote nginx.confwrote mime.typeswrote app.lua
    Ключ lua нужен, тк мы делаем сайт именно на lua, а не на moonscript.
     

    Следующим шагом для нас будет запуск сервера.
    $ lapis server
    Lapis автоматический запустит сервер и создаст структуру папок. На этом наш сайт готов, убеждаемся в этом.
     

    Проверка
    Заходим по адресу, на который настроен nginx, и узреваем сиё чудо:

     
    Это означает, что lapis настроен правильно, и мы можем приступать к работе, но об этом - в следующей части цикла (самому надо разобраться)
     
    Что-ж, на этом все.
    Enjoy!
  5. LeshaInc
    Rust

    Сегодня познакомимся с функциями и указателями, а также по мелочи: зоны видимости.
     
    Функции
    Функции в расте похожи на функции в Си, Jawa, луа. Для создания функции используется ключевое слово fn.
    fn add(a: i32, b: usize) -> usize { a + b}
    После ключевого слова fn идет имя функции, далее в скобках указываются аргументы через запятую, и опционально, стрелочка -> и возвращаемый тип.
    Указывая аргументы нужно указывать тип аргумента после символа :.
     
    Функции в которых не указано возвращаемое значение, возвращают ()
     
    Ключевое слово return возвращает значение из функции.
    fn answer() -> i32 { return 42;}
    return не всегда обязателен, позже разберемся где он нужен, а где не нужен.
     
    Указатели
    Указатели в расте гораздо безопаснее чем указатели в Си. Создать указатель на неизменяемые данные можно при помощи &.
    let a = 10;let pa = &a;
    Получить значение из указателя можно при помощи символа *.
    let a = 10;let pa = &a;println!("a = {}; *pa = {}; a + a = {}; *pa + *pa = {}", a, *pa, a + a, *pa + *pa);// \--> a = 10; *pa = 10; a + a = 20; *pa + *pa = 20
    Но в некоторых случаях писать * не обязательно.
    let a = 10;let pa = &a;println!("a = {}; pa = {}; a + a = {}; pa + pa = {}", a, pa, a + a, pa + pa);// \--> a = 10; pa = 10; a + a = 20; pa + pa = 20
    Раст сам все поймет, за что ему спасибо.
    Иногда мы хотим создать изменяемую ссылку. Для этого используется &mut.
    let mut a = 10;let pa = &mut a;*pa += 1; // здесь * обязателен println!("{}", pa); //--> 11
    Если мы хотим изменить значение на которое указывает наш указатель, * обязателен. Без него раст не может понять, мы хотим присвоить новый указатель, или значение.
    В расте используется концепция "либо один писатель, либо много читателей". В примере выше, переменную a прочитать мы уже не сможем, и писать в нее тоже не сможем, так как она передана указателю pa. pa – писатель.
     
    Бывают случаи когда мы хотим присвоить указателю новое значение, то есть сделать так, что бы указатель указывал на другие данные. Это тоже предусмотрено.
    let mut a = 10;let mut b = 20;let mut pa = &mut a; println!("{}", pa); // --> 10 pa = &mut b; println!("{}", pa); // --> 20 println!("{}", a); // --> 10// ^ ошибка, a уже имеет писателя, читателя не создать. println!("{}", &a); // --> 10// ^- ошибка, a уже имеет писателя, читателя не создать. println!("{}", &mut a); // --> 10// ^----- ошибка, a уже имеет писателя, еще одного не создать.
    Как видите, все правила про "либо один писатель, либо много читателей" работают даже если на a уже не указывает ничего.
     
    Зоны видимости
    Зоны видимости в расте ничем не отличаются от тех же в Луа.
    fn main() { let a = 10; { let b = 20; println!("{}", a); // --> 10 println!("{}", b); // --> 10 } println!("{}", a); // --> 10 println!("{}", b); // --> 10 // ^ ошибка, b нет.}
    Хочу отметить только, что в расте все переменные удаляются когда уйдут из зоны видимости. Исключением являются только значения которые возвращаются в функциях.
     

    Хозяйке на заметку:
    { и ) это аналог do и end в Луа.  
    На сегодня все. Извините что запоздал с 3 частью, так уж вышло. В следующий раз познакомимся с перечеслениями (enum) и структурами (struct). =)
  6. LeshaInc

    Пишу движок

    Автор: LeshaInc,

    Давно я тут ничего не писал. Надо реанимироваться.
    В общем, пишу я значит движок для LÖVE, ибо глаза режет код новичков в самом Lua и в LÖVE. Пишут всякий бред, все не удобно и не красиво.
     
    Чё за движок
     
    Значит, движок модульный, весь код пишем в модулях. Модули - просто хрени в которых хранится код. Уже сложилась такая структура и возможности модуля: клик. Если коротко - создается папка с модулем, создается там же файл init.lua. Собственно он и будет запускаться.
     
    Значит, структура всех этих свистелок и перделок выглядит следующим образом:


    Хочу обратить внимание на две папки: trash и res. В папке трэша хранится весь мусор (который надо удалить, но вдруг я откажусь от удаления того кода? че тогда? все пропало тогда! естественно на релизе не будет этой папки), в папке рес хранятся все ресурсы, к примеру картинки, музон, шрифты.
     
    Вот что еще стоит отметить, в папке classes храним все классы, которые могут понадобится в нескольких модулях. Например тот же класс для векторов, который нужен много где.
     
    Насчет производительности, значит, жрем мы очень мало. памяти всего ~30 мб (учитывая специфику love2d, который сам по себе жрет) ФПС пока выдает 35, посмотрим еще как будет на релизе(тьфу тьфу тьфу).
     
    Просьба
     
    Если есть возможность, пожалуйста, скиньте идейку для платформера, какого нибудь. В разумных пределах, естественно, не так чтобы "хачу платформир с графикой краисис три". В комменты это все к записи. Ииии, значит, потом я выберу норм идею и реализую на движке. Ну и не забуду вкрутить куда нибудь исходники движка, на гитхаб к примеру.
     
    Ну и все наверное, надо еще кучу всего пилировать.
  7. LeshaInc
    Привет! В этом уроке я вас научу псевдо-объектно-ориентированным программированием в Lua. Почему псевдо? А потому-что настоящего ООП в Lua нет, т к классов нет. Приступим!
    Для начала напишем класс!
    local class = { -- Создали таблицу x, y}class.__index = class -- Указали индексfunction class:addObject()-- Функция нового объекта local a = {} setmetatable(a,self) -- Наследуем методы return a -- Вовращаем таблицу endfunction class:setPos(x,y) -- Установим значения self.x=x self.y=yendpixel = class:addObject()pixel:setPos(1,1)
    Теперь вы можете создавать классы.
    Enjoy!
  8. LeshaInc
    Веб сервер на Lua.
    Часть 2: Структура
     
    Здравствуйте. Вы читаете запись из цикла "Веб сервер на Lua". В конце данного цикла у нас получится вполне работоспособный веб сайт, причем быстрый, да еще и на Lua. Я все действия буду производить в такой среде как "c9", сайт будет доступен под адресом: http://lua-includeralex.c9.io/ Все файлы, вы можете посмотреть тут: http://ide.c9.io/includeralex/lua Что, ж поехали.
     
    В этой части мы создадим структуру нашего сайта, а также узнаем о некоторых фишках Lapis.
     
    Структура
    Начнем, пожалуй с со структуры нашего веб-приложения.
    .├── app.lua // Входная точка приложения├── client_body_temp // папка с tmp файлами├── fastcgi_temp // папка с tmp файлами├── logs // папка с логами nginx'а│ ├── access.log // думаю, все знакомы с логами nginx│ ├── error.log│ └── nginx.pid├── mime.types // файл с mime типами├── nginx.conf // конфигурационный файл nginx├── nginx.conf.compiled├── proxy_temp // папка с tmp файлами├── public // папка с публичными файлами│ ├── script.js│ └── style.css├── scgi_temp // папка с tmp файлами├── uwsgi_temp // папка с tmp файлами└── views // папка с нашими вьюшками ├── index.etlua └── layout.etlua // шаблон для всех страниц
    В файле app.lua находится весь код нашего приложения.
    В файле nginx.conf находятся настройки NGINX
    В папке public находятся все публичные файлы, например:
    Файл: public/style.cssURL к файлу: хост.домен/style.css
    В папке views находятся наши "вьюшки", они используются при рендере наших страниц, в этой папке должны находится только те файлы, расширение которых == .etlua. О etlua мы поговорим чуть позже.
     

    Код
    Как вообще будет работать наше приложение? Да, очень просто.
    Всю логику мы будем описывать в файле app.lua.
     
    Посмотрим на код простейшего приложения на Lapis:
    local lapis = require("lapis")local app = lapis.Application()app:get("/", function(self) return "Контент страницы"end)return app
    Сначала мы подключаем сам lapis, далее мы создаем приложение lapis, используя метод Application. Потом создаем роутер на путь "/" который возвращает нам контент страницы. В конце концов мы возвращаем наше приложение.
    Все довольно просто. Используя полученные знания мы можем написать другой код:
    local lapis = require("lapis")local app = lapis.Application()function init() -- функция инициализации app:enable("etlua") app.layout = require "views.layout"endfunction getFile(path) return io.open(path,"r"):read("*all")endfunction index(self) -- функция получения index self.page_title = "To-Do App" return {render = "index"}end-- роутеры страницapp:get("/", index)-- 404 ошибкаapp.handle_404 = function(self) page = io.open("public"..self.req.parsed_url.path,"r") if page then return {layout = false, page:read("*all")} else return "Not found!" endendinit()return app
    Тут мы можем узреть вещи, неизвестные нам. А именно:
    app.handle_404 render = "index" app:enable("etlua") app.layout = require "views.layout"

    app.handle_404 - функция которая вызывается при ошибке "404", мы ее переопределяем на свою функцию. Наша функция - выполняет очень дельные вещи.
    app.handle_404 вызывается если роутер для страницы не найден. В нашем случае мы проверяем, есть ли файл по пути public..<url_не_найденного_роутера>, если он есть - мы выводим его контент, параметр layout = false делает так, чтоб мы возвращали не контент сайта, а полный код сайта. Если такого файла нет - мы пишем сообщение об ошибке "404 не найдено".
    render = "index" - рендерит файл (с расширением .etlua), который находится в папке views, о которой мы уже говорили.
    app:enable("etlua") - включает шаблонизатор EtLua, если мы это не напишем - то потеряем огромный функционал Lapis.
    app.layout = require "views.layout" - устанавливает стандартный шаблон для сайта, по пути /views/layout.etlua
     

    Итак, разобрались с кодом, перейдем к шаблонизатору.
     
    Шаблонизатор: EtLua
    Шаблонизатор EtLua очень похож на PHP. Рассмотрим пример кода:
    -- views/layout.etlua<!doctype html><html lang="en"><head> <meta charset="UTF-8"> <title><%= page_title or "Page from Lua" %></title> <%= page_headers or "" %></head><body> <% content_for("inner") %></body></html>
    То что находится в <% %> - луа код. Мы можем выполнять lua прямо тут.
    То что находится в <%= %> - возвращает то что нам отдал луа код - в html. Например:
    <title><%= "Page from Lua" %></title>Эквивалентно:<title>Page from Lua</title>
    На этом все.
    Enjoy!
  9. LeshaInc
    Rust

    Сегодня продолжим знакомство с языком программирования Rust. Научимся говорить как истинные джентльмены.
     
     
     

    Хозяйке на заметку:
    Комментарии в расте похожи на комментарии в большинства языках. От // до конца строки – комментарий: // Комментарий От /* до */ – комментарий: /* Большущий комментарий =) */

     

    Учимся говорить
    В расте для вывода текста на консоль используется println! и соответственно print!
    fn main() { println!("Hello, world!"); // --> Hello, world! print!("Hello, "); // -\ print!("world!\n"); // --> Hello, world! // ^- это нужно что бы весь следующий // текст в консоли был на новой строке}
    Выводом такой программы будут две строки "Hello, world!". Отличия println! от print! заключаются в том, что print! не ставит в конце строки перенос на новую строку. Это очень удобно, когда мы хотим вывести две надписи в одну строку.
     

    Раст поддерживает форматирование текста. Но оно не такое как в Lua и Си.
    println!("Rust forever! {}", 42); // -> Rust forever! 42print!("Rust forever! {}\n", 42); // -> Rust forever! 42
    println! и print! автоматически форматируют текст. Первый аргумент в таком случае – строка, которую будем форматировать, остальные аргументы – данные которые мы будем подставлять в {...}
     

    Мы также можем самостоятельно позиционировать аргументы.
    println!("{0}: Привет, я {0}. {1}: Привет! А я {1}! Приятно познакомиться.", "Маша", "Боб");// |--> Маша: Привет, я Маша. Боб: Привет! А я Боб! Приятно познакомиться.
    Фактически, {} {} {}... означает {0} {1} {2}....
     

    Также можем давать имя аргументам.
    println!("{subject} {verb} {object}!", subject="Петя", verb="съел", object="печеньку"); // --> Петя съел печеньку!
    Специальное форматирование может быть указано после :.
    println!("{0} + {0} = {1:b}, и никак иначе!", 1, 1 + 1); // --> 1 + 1 = 10, и никак иначе!// ^ это означает *напиши число в двоичном формате (нулями и единицами)// подробнее о возможных можно узнать в документации.
    Можно выровнять строку по правому краю.
    println!("{0:>06}", 42); // --> 00042println!("{0:>01$}", 42, 7) // --> 000042println!("{0:>0width$}", 42, width=7) // --> 0000042println!("{str:>width$}", str="Петя", width=10) // --> Петя// Замените > на < и выравнивание будет по левому краю.
    На этом с форматированием все. В следующей части поговорим о переменных и типах данных. =)
  10. LeshaInc
    Rust

    Сегодня как я и говорил познакомимся с переменными и типами данных. Ну и еще по мелочи: операторы и литералы =)
     

    Учимся считать (переменные)
    Для создания переменной в расте используется ключевое слово let.
    let a = 10; // тип i32
    Таким образом будет создана переменная a с типом i32 (подробнее о типах позже). Тип выведен автоматически.
    Например, если вместо числа 10 мы напишем строку, то тип будет выведен строковый.
    let a = "hello!"; // тип &str. да-да, вы угадали // будем говорить о нем позже =)
    Мы можем также сами указать тип через символ двоеточия :
    let a: char = "hello"; // ошибка, "hello" это не charlet b: u8 = 99; // ок, b теперь типа u8.
    Как видите компилятор проверяет типы.
     

    Теперь попробуем изменить нашу переменную.
    let a = 10;a = 20; // ошибкаa += 1; // ошибка
    ... И у нас ничего не выходит! Дело в том что по умолчанию переменные непеременные (но они не константы!) . Если мы хотим что бы наши переменные изменялись нужно использовать ключевое слово mut.
    let mut a = 10;// ^-- что бы наша переменная могла изменятьсяa = 20; // окa += 1; // ок// a = 21

    Хозяйке на заметку:
    Константы в расте встраиваются прямо в исходный код программы, как если бы мы создали константу используя язык ассемблера. Переменные же (даже если они вовсе не меняются) создаются во время работы программы по умолчанию на стеке (об этом поговорим еще когда нибудь).  

    Типы данных
    Раст предоставляет большой выбор примитивных типов:
    Целые: i8, i16, i32, i64, isize (размер указателя, на 32 битных машинах 32, на 64 битных - 64). Натуральные: u8, u16, u32, u64, usize (размер указателя). Рациональные: f32, f64. char Юникод символ, каждый 4 байта. bool Буля, true или false. () Юнит. (Используется как "ничего"). Массивы вроде [T; N]. Пример: [1, 2, 3, 4] тип: [i32; 4]. Кортежи вроде (A, B, ...). Пример: (true, false, 3) тип: (bool, bool, i32).

    Литералы
    Существуют литералы: целые числа 123, дробные числа 123.123, символы 'У', строки "RUST FOREVER!", були true, и юнит ().
     

    Целые числа могут быть также представлены двоичными, шестнадцатеричными и восьмеричными используя соответственно следующие префиксы: 0b, 0x, 0o. Например: 0b101 будет равно 5.
     
    В числа можно вставлять любое количество нижних подчеркиваний, дабы улучшить читаемость. 1_000_000 = 1000000, 0.000_000_1 = 0.0000001.
     
    Операторы
    В расте операторы похожи на операторы в Си-подобных языках.
    + плюс. - минус. * умножить. / разделить. % остаток от деления. ! логическое НЕ[/il] - унарный минус. ^ исключающее ИЛИ. | побитовое ИЛИ. & побитовое И. && логическое И. || логическое ИЛИ. << побитовый сдвиг влево. >> побитовый сдвиг вправо.

    А также соединенные с присваиванием операции, например a >>= 3 равносильно a = a >> 3.
     

    На этом все. В следующей части познакомимся с функциями и указателями. =)
  11. LeshaInc
    Веб сервер на Lua.
    Часть 3: Класс «App»
     
    Здравствуйте. Вы читаете запись из цикла "Веб сервер на Lua". В конце данного цикла у нас получится вполне работоспособный веб сайт, причем быстрый, да еще и на Lua. Я все действия буду производить в такой среде как "c9", сайт будет доступен под адресом: http://lua-includeralex.c9.io/ Все файлы, вы можете посмотреть тут: http://ide.c9.io/includeralex/lua Что, ж поехали.
     
    В этой части мы создадим более углубленно рассмотрим функционал Lapus, а именно: изучим класс App, а также узнаем о консоли Lapis.
     
    Консоль
    Начнем, пожалуй, с консоли Lapis. Эта консоль - некий дебагер, в него мы вставляем код - а он нам возвраащет результат. Интерпретатор Lua, так сказать, только с доступом ко всем библиотекам lapis.
     
    Первым делом такую консоль необходимо установить. Для начала скачаем необходимый пакет, используя уже знакомую нам утилиту LuaRocks:
    $ luarocks install --server=http://rocks.moonscript.org lapis-console
    После установки данной библиотеки мы готовы приступать к самому главному - добавлению роутера, который бы отвечал за эту консоль. В начало нашего кода, там где у нас подключаются все библиотеки, мы добавим такой код:
    local console = require("lapis.console")
    Структура данного require такова: имя_фрэймворка.имя_аддона. В нашем случае это lapis.console.
    Теперь необходимо добавить роутер, для этого используем уже знакомую структуру:
    app:get("/console", console.make())
    console.make - это та самая функция, которая конструирует консоль пот заданным роутером.
     

    Теперь запустим сервер, и убедимся что все работает:

    На этом разговор об консоли закончен. Приступим к самому вкусненькому - к класссу app.
     
    Класс App
    Класс app - это самый главный класс в нашем приложении. Без него наше приложение не сможет выполнять хоть какие-то полезные действия, кроме выжирания памяти, и ресурсов процессора.
     
    Для создания объекта этого класса нам необходимо выполнить следующий код:
    local app = lapis.Application()
    Перейдем к методам App.
     

    app:enable(module: string) - функция включения модуля lapis. Из модулей известны нам пока только etlua, но потом мы обязательно узнаем больше.
    app:match([router_name: string],url: string, onrequest: function) - функция создания нового роутера, с парсингом url, в параметр url передается паттерн, в параметр router_name передается имя роутера, об нем чуть позже, в параметр onrequest передается функция, которая и будет выполняться при каждом заходе на url (принимает аргумент self).
    app:before_filter(before: function) - устанавливает функцию-обработчик, которая вызывается при каждом запросе к сайту, функция принимает один аргумет self)
    app:get(url: string, onrequest: function - то же что и app:match, только умеет работать только с GET запросами, не поддерживает router-name, и не умеет парсить url.
    app:post(url: string, onrequest: function - то же что и app:match, только умеет работать только с POST запросами, не поддерживает router-name, и не умеет парсить url.
     
    Что-ж, на этом все.
    Enjoy!
×
×
  • Создать...