├── .github
├── dependabot.yml
└── workflows
│ ├── deploy.yml
│ └── test.yml
├── .gitignore
├── .rspec
├── Dockerfile
├── Gemfile
├── Gemfile.lock
├── LICENSE
├── README.md
├── Rakefile
├── app
├── dependencies.rb
├── editor.rb
├── helper.rb
├── lesson.rb
├── ruby_engine.rb
├── ruby_engine
│ ├── cruby_wasi.rb
│ ├── opal.rb
│ └── opal_webworker.rb
└── try_ruby.rb
├── bin
├── middleman
└── rake
├── collector.rb
├── compose.yaml
├── config.rb
├── config.ru
├── opal-config.rb
├── shakespeare.json
├── source
├── about.html.markdown
├── articles
│ ├── 2015-01-01-try-ruby-version-4.html.markdown
│ ├── 2015-01-02-testing.html.markdown
│ ├── 2015-01-03-app-development.html.markdown
│ ├── 2015-01-04-web-development.html.markdown
│ ├── 2015-01-05-what-i-left-out.html.markdown
│ ├── 2015-01-06-what-to-do-next.html.markdown
│ └── index.html.erb
├── favicon.ico
├── images
│ └── foxes.svg
├── index.html.markdown
├── javascripts
│ ├── application.js.rb
│ └── vendor
│ │ └── codemirror-compressed-4.8.js
├── layouts
│ ├── _navbar.html.erb
│ └── layout.html.erb
├── playground.html.markdown
└── stylesheets
│ ├── application.css.scss
│ └── vendor
│ ├── bootstrap-theme.css
│ ├── codemirror-solarized.css
│ ├── codemirror.css
│ └── pygment_solarized_light.css
├── spec
├── playground_spec.rb
├── spec_helper.rb
├── tryruby_helpers.rb
└── tutorial_spec.rb
└── translations
├── README.md
├── convert-ruby-guide-en.rb
├── de
├── README.md
├── try_ruby_10.md
├── try_ruby_100.md
├── try_ruby_110.md
├── try_ruby_120.md
├── try_ruby_130.md
├── try_ruby_140.md
├── try_ruby_150.md
├── try_ruby_160.md
├── try_ruby_170.md
├── try_ruby_180.md
├── try_ruby_190.md
├── try_ruby_20.md
├── try_ruby_200.md
├── try_ruby_210.md
├── try_ruby_220.md
├── try_ruby_230.md
├── try_ruby_240.md
├── try_ruby_250.md
├── try_ruby_260.md
├── try_ruby_270.md
├── try_ruby_280.md
├── try_ruby_290.md
├── try_ruby_30.md
├── try_ruby_300.md
├── try_ruby_310.md
├── try_ruby_320.md
├── try_ruby_330.md
├── try_ruby_340.md
├── try_ruby_350.md
├── try_ruby_360.md
├── try_ruby_370.md
├── try_ruby_380.md
├── try_ruby_390.md
├── try_ruby_40.md
├── try_ruby_400.md
├── try_ruby_410.md
├── try_ruby_420.md
├── try_ruby_430.md
├── try_ruby_440.md
├── try_ruby_450.md
├── try_ruby_460.md
├── try_ruby_470.md
├── try_ruby_480.md
├── try_ruby_490.md
├── try_ruby_50.md
├── try_ruby_500.md
├── try_ruby_510.md
├── try_ruby_520.md
├── try_ruby_530.md
├── try_ruby_540.md
├── try_ruby_550.md
├── try_ruby_560.md
├── try_ruby_60.md
├── try_ruby_70.md
├── try_ruby_80.md
└── try_ruby_90.md
├── en
├── README.md
├── try_ruby_10.md
├── try_ruby_100.md
├── try_ruby_110.md
├── try_ruby_120.md
├── try_ruby_130.md
├── try_ruby_140.md
├── try_ruby_150.md
├── try_ruby_160.md
├── try_ruby_170.md
├── try_ruby_180.md
├── try_ruby_190.md
├── try_ruby_20.md
├── try_ruby_200.md
├── try_ruby_210.md
├── try_ruby_220.md
├── try_ruby_230.md
├── try_ruby_240.md
├── try_ruby_250.md
├── try_ruby_260.md
├── try_ruby_270.md
├── try_ruby_280.md
├── try_ruby_290.md
├── try_ruby_30.md
├── try_ruby_300.md
├── try_ruby_310.md
├── try_ruby_320.md
├── try_ruby_330.md
├── try_ruby_340.md
├── try_ruby_350.md
├── try_ruby_360.md
├── try_ruby_370.md
├── try_ruby_380.md
├── try_ruby_390.md
├── try_ruby_40.md
├── try_ruby_400.md
├── try_ruby_410.md
├── try_ruby_420.md
├── try_ruby_430.md
├── try_ruby_440.md
├── try_ruby_450.md
├── try_ruby_460.md
├── try_ruby_470.md
├── try_ruby_480.md
├── try_ruby_490.md
├── try_ruby_50.md
├── try_ruby_500.md
├── try_ruby_510.md
├── try_ruby_520.md
├── try_ruby_530.md
├── try_ruby_540.md
├── try_ruby_550.md
├── try_ruby_560.md
├── try_ruby_60.md
├── try_ruby_70.md
├── try_ruby_80.md
└── try_ruby_90.md
├── es
├── README.md
├── try_ruby_10.md
├── try_ruby_100.md
├── try_ruby_110.md
├── try_ruby_120.md
├── try_ruby_130.md
├── try_ruby_140.md
├── try_ruby_150.md
├── try_ruby_160.md
├── try_ruby_170.md
├── try_ruby_180.md
├── try_ruby_190.md
├── try_ruby_20.md
├── try_ruby_200.md
├── try_ruby_210.md
├── try_ruby_220.md
├── try_ruby_230.md
├── try_ruby_240.md
├── try_ruby_250.md
├── try_ruby_260.md
├── try_ruby_270.md
├── try_ruby_280.md
├── try_ruby_290.md
├── try_ruby_30.md
├── try_ruby_300.md
├── try_ruby_310.md
├── try_ruby_320.md
├── try_ruby_330.md
├── try_ruby_340.md
├── try_ruby_350.md
├── try_ruby_360.md
├── try_ruby_370.md
├── try_ruby_380.md
├── try_ruby_390.md
├── try_ruby_40.md
├── try_ruby_400.md
├── try_ruby_410.md
├── try_ruby_420.md
├── try_ruby_430.md
├── try_ruby_440.md
├── try_ruby_450.md
├── try_ruby_460.md
├── try_ruby_470.md
├── try_ruby_480.md
├── try_ruby_490.md
├── try_ruby_50.md
├── try_ruby_500.md
├── try_ruby_510.md
├── try_ruby_520.md
├── try_ruby_530.md
├── try_ruby_540.md
├── try_ruby_550.md
├── try_ruby_560.md
├── try_ruby_60.md
├── try_ruby_70.md
├── try_ruby_80.md
└── try_ruby_90.md
├── fr
├── README.md
├── try_ruby_10.md
├── try_ruby_100.md
├── try_ruby_110.md
├── try_ruby_120.md
├── try_ruby_130.md
├── try_ruby_140.md
├── try_ruby_150.md
├── try_ruby_160.md
├── try_ruby_170.md
├── try_ruby_180.md
├── try_ruby_190.md
├── try_ruby_20.md
├── try_ruby_200.md
├── try_ruby_210.md
├── try_ruby_220.md
├── try_ruby_230.md
├── try_ruby_240.md
├── try_ruby_250.md
├── try_ruby_260.md
├── try_ruby_270.md
├── try_ruby_280.md
├── try_ruby_290.md
├── try_ruby_30.md
├── try_ruby_300.md
├── try_ruby_310.md
├── try_ruby_320.md
├── try_ruby_330.md
├── try_ruby_340.md
├── try_ruby_350.md
├── try_ruby_360.md
├── try_ruby_370.md
├── try_ruby_380.md
├── try_ruby_390.md
├── try_ruby_40.md
├── try_ruby_400.md
├── try_ruby_410.md
├── try_ruby_420.md
├── try_ruby_430.md
├── try_ruby_440.md
├── try_ruby_450.md
├── try_ruby_460.md
├── try_ruby_470.md
├── try_ruby_480.md
├── try_ruby_490.md
├── try_ruby_50.md
├── try_ruby_500.md
├── try_ruby_510.md
├── try_ruby_520.md
├── try_ruby_530.md
├── try_ruby_540.md
├── try_ruby_550.md
├── try_ruby_560.md
├── try_ruby_60.md
├── try_ruby_70.md
├── try_ruby_80.md
└── try_ruby_90.md
├── ja
├── README.md
├── try_ruby_10.md
├── try_ruby_100.md
├── try_ruby_110.md
├── try_ruby_120.md
├── try_ruby_130.md
├── try_ruby_140.md
├── try_ruby_150.md
├── try_ruby_160.md
├── try_ruby_170.md
├── try_ruby_180.md
├── try_ruby_190.md
├── try_ruby_20.md
├── try_ruby_200.md
├── try_ruby_210.md
├── try_ruby_220.md
├── try_ruby_230.md
├── try_ruby_240.md
├── try_ruby_250.md
├── try_ruby_260.md
├── try_ruby_270.md
├── try_ruby_280.md
├── try_ruby_290.md
├── try_ruby_30.md
├── try_ruby_300.md
├── try_ruby_310.md
├── try_ruby_320.md
├── try_ruby_330.md
├── try_ruby_340.md
├── try_ruby_350.md
├── try_ruby_360.md
├── try_ruby_370.md
├── try_ruby_380.md
├── try_ruby_390.md
├── try_ruby_40.md
├── try_ruby_400.md
├── try_ruby_410.md
├── try_ruby_420.md
├── try_ruby_430.md
├── try_ruby_440.md
├── try_ruby_450.md
├── try_ruby_460.md
├── try_ruby_470.md
├── try_ruby_480.md
├── try_ruby_490.md
├── try_ruby_50.md
├── try_ruby_500.md
├── try_ruby_510.md
├── try_ruby_520.md
├── try_ruby_530.md
├── try_ruby_540.md
├── try_ruby_550.md
├── try_ruby_560.md
├── try_ruby_60.md
├── try_ruby_70.md
├── try_ruby_80.md
└── try_ruby_90.md
├── mk
├── README.md
├── try_ruby_10.md
├── try_ruby_100.md
├── try_ruby_110.md
├── try_ruby_120.md
├── try_ruby_130.md
├── try_ruby_140.md
├── try_ruby_150.md
├── try_ruby_160.md
├── try_ruby_170.md
├── try_ruby_180.md
├── try_ruby_190.md
├── try_ruby_20.md
├── try_ruby_200.md
├── try_ruby_210.md
├── try_ruby_220.md
├── try_ruby_230.md
├── try_ruby_240.md
├── try_ruby_250.md
├── try_ruby_260.md
├── try_ruby_270.md
├── try_ruby_280.md
├── try_ruby_290.md
├── try_ruby_30.md
├── try_ruby_300.md
├── try_ruby_310.md
├── try_ruby_320.md
├── try_ruby_330.md
├── try_ruby_340.md
├── try_ruby_350.md
├── try_ruby_360.md
├── try_ruby_370.md
├── try_ruby_380.md
├── try_ruby_390.md
├── try_ruby_40.md
├── try_ruby_400.md
├── try_ruby_410.md
├── try_ruby_420.md
├── try_ruby_430.md
├── try_ruby_440.md
├── try_ruby_450.md
├── try_ruby_460.md
├── try_ruby_470.md
├── try_ruby_480.md
├── try_ruby_490.md
├── try_ruby_50.md
├── try_ruby_500.md
├── try_ruby_510.md
├── try_ruby_520.md
├── try_ruby_530.md
├── try_ruby_540.md
├── try_ruby_550.md
├── try_ruby_560.md
├── try_ruby_60.md
├── try_ruby_70.md
├── try_ruby_80.md
└── try_ruby_90.md
├── nl
├── README.md
├── try_ruby_10.md
├── try_ruby_100.md
├── try_ruby_110.md
├── try_ruby_120.md
├── try_ruby_130.md
├── try_ruby_140.md
├── try_ruby_150.md
├── try_ruby_160.md
├── try_ruby_170.md
├── try_ruby_180.md
├── try_ruby_190.md
├── try_ruby_20.md
├── try_ruby_200.md
├── try_ruby_210.md
├── try_ruby_220.md
├── try_ruby_230.md
├── try_ruby_240.md
├── try_ruby_250.md
├── try_ruby_260.md
├── try_ruby_270.md
├── try_ruby_280.md
├── try_ruby_290.md
├── try_ruby_30.md
├── try_ruby_300.md
├── try_ruby_310.md
├── try_ruby_320.md
├── try_ruby_330.md
├── try_ruby_340.md
├── try_ruby_350.md
├── try_ruby_360.md
├── try_ruby_370.md
├── try_ruby_380.md
├── try_ruby_390.md
├── try_ruby_40.md
├── try_ruby_400.md
├── try_ruby_410.md
├── try_ruby_420.md
├── try_ruby_430.md
├── try_ruby_440.md
├── try_ruby_450.md
├── try_ruby_460.md
├── try_ruby_470.md
├── try_ruby_480.md
├── try_ruby_490.md
├── try_ruby_50.md
├── try_ruby_500.md
├── try_ruby_510.md
├── try_ruby_520.md
├── try_ruby_530.md
├── try_ruby_540.md
├── try_ruby_550.md
├── try_ruby_560.md
├── try_ruby_60.md
├── try_ruby_70.md
├── try_ruby_80.md
└── try_ruby_90.md
├── pt-br
├── README.md
├── try_ruby_10.md
├── try_ruby_100.md
├── try_ruby_110.md
├── try_ruby_120.md
├── try_ruby_130.md
├── try_ruby_140.md
├── try_ruby_150.md
├── try_ruby_160.md
├── try_ruby_170.md
├── try_ruby_180.md
├── try_ruby_190.md
├── try_ruby_20.md
├── try_ruby_200.md
├── try_ruby_210.md
├── try_ruby_220.md
├── try_ruby_230.md
├── try_ruby_240.md
├── try_ruby_250.md
├── try_ruby_260.md
├── try_ruby_270.md
├── try_ruby_280.md
├── try_ruby_290.md
├── try_ruby_30.md
├── try_ruby_300.md
├── try_ruby_310.md
├── try_ruby_320.md
├── try_ruby_330.md
├── try_ruby_340.md
├── try_ruby_350.md
├── try_ruby_360.md
├── try_ruby_370.md
├── try_ruby_380.md
├── try_ruby_390.md
├── try_ruby_40.md
├── try_ruby_400.md
├── try_ruby_410.md
├── try_ruby_420.md
├── try_ruby_430.md
├── try_ruby_440.md
├── try_ruby_450.md
├── try_ruby_460.md
├── try_ruby_470.md
├── try_ruby_480.md
├── try_ruby_490.md
├── try_ruby_50.md
├── try_ruby_500.md
├── try_ruby_510.md
├── try_ruby_520.md
├── try_ruby_530.md
├── try_ruby_540.md
├── try_ruby_550.md
├── try_ruby_560.md
├── try_ruby_60.md
├── try_ruby_70.md
├── try_ruby_80.md
└── try_ruby_90.md
├── renumber_translations.rb
├── ru
├── README.md
├── try_ruby_10.md
├── try_ruby_100.md
├── try_ruby_110.md
├── try_ruby_120.md
├── try_ruby_130.md
├── try_ruby_140.md
├── try_ruby_150.md
├── try_ruby_160.md
├── try_ruby_170.md
├── try_ruby_180.md
├── try_ruby_190.md
├── try_ruby_20.md
├── try_ruby_200.md
├── try_ruby_210.md
├── try_ruby_220.md
├── try_ruby_230.md
├── try_ruby_240.md
├── try_ruby_250.md
├── try_ruby_260.md
├── try_ruby_270.md
├── try_ruby_280.md
├── try_ruby_290.md
├── try_ruby_30.md
├── try_ruby_300.md
├── try_ruby_310.md
├── try_ruby_320.md
├── try_ruby_330.md
├── try_ruby_340.md
├── try_ruby_350.md
├── try_ruby_360.md
├── try_ruby_370.md
├── try_ruby_380.md
├── try_ruby_390.md
├── try_ruby_40.md
├── try_ruby_400.md
├── try_ruby_410.md
├── try_ruby_420.md
├── try_ruby_430.md
├── try_ruby_440.md
├── try_ruby_450.md
├── try_ruby_460.md
├── try_ruby_470.md
├── try_ruby_480.md
├── try_ruby_490.md
├── try_ruby_50.md
├── try_ruby_500.md
├── try_ruby_510.md
├── try_ruby_520.md
├── try_ruby_530.md
├── try_ruby_540.md
├── try_ruby_550.md
├── try_ruby_560.md
├── try_ruby_60.md
├── try_ruby_70.md
├── try_ruby_80.md
└── try_ruby_90.md
├── ruby-guide-en.html_
├── ruby-guide-es.html_
├── tr
├── README.md
├── try_ruby_10.md
├── try_ruby_100.md
├── try_ruby_110.md
├── try_ruby_120.md
├── try_ruby_130.md
├── try_ruby_140.md
├── try_ruby_150.md
├── try_ruby_160.md
├── try_ruby_170.md
├── try_ruby_180.md
├── try_ruby_190.md
├── try_ruby_20.md
├── try_ruby_200.md
├── try_ruby_210.md
├── try_ruby_220.md
├── try_ruby_230.md
├── try_ruby_240.md
├── try_ruby_250.md
├── try_ruby_260.md
├── try_ruby_270.md
├── try_ruby_280.md
├── try_ruby_290.md
├── try_ruby_30.md
├── try_ruby_300.md
├── try_ruby_310.md
├── try_ruby_320.md
├── try_ruby_330.md
├── try_ruby_340.md
├── try_ruby_350.md
├── try_ruby_360.md
├── try_ruby_370.md
├── try_ruby_380.md
├── try_ruby_390.md
├── try_ruby_40.md
├── try_ruby_400.md
├── try_ruby_410.md
├── try_ruby_420.md
├── try_ruby_430.md
├── try_ruby_440.md
├── try_ruby_450.md
├── try_ruby_460.md
├── try_ruby_470.md
├── try_ruby_480.md
├── try_ruby_490.md
├── try_ruby_50.md
├── try_ruby_500.md
├── try_ruby_510.md
├── try_ruby_520.md
├── try_ruby_530.md
├── try_ruby_540.md
├── try_ruby_550.md
├── try_ruby_560.md
├── try_ruby_60.md
├── try_ruby_70.md
├── try_ruby_80.md
└── try_ruby_90.md
├── ua
├── README.md
├── try_ruby_10.md
├── try_ruby_100.md
├── try_ruby_110.md
├── try_ruby_120.md
├── try_ruby_130.md
├── try_ruby_140.md
├── try_ruby_150.md
├── try_ruby_160.md
├── try_ruby_170.md
├── try_ruby_180.md
├── try_ruby_190.md
├── try_ruby_20.md
├── try_ruby_200.md
├── try_ruby_210.md
├── try_ruby_220.md
├── try_ruby_230.md
├── try_ruby_240.md
├── try_ruby_250.md
├── try_ruby_260.md
├── try_ruby_270.md
├── try_ruby_280.md
├── try_ruby_290.md
├── try_ruby_30.md
├── try_ruby_300.md
├── try_ruby_310.md
├── try_ruby_320.md
├── try_ruby_330.md
├── try_ruby_340.md
├── try_ruby_350.md
├── try_ruby_360.md
├── try_ruby_370.md
├── try_ruby_380.md
├── try_ruby_390.md
├── try_ruby_40.md
├── try_ruby_400.md
├── try_ruby_410.md
├── try_ruby_420.md
├── try_ruby_430.md
├── try_ruby_440.md
├── try_ruby_450.md
├── try_ruby_460.md
├── try_ruby_470.md
├── try_ruby_480.md
├── try_ruby_490.md
├── try_ruby_50.md
├── try_ruby_500.md
├── try_ruby_510.md
├── try_ruby_520.md
├── try_ruby_530.md
├── try_ruby_540.md
├── try_ruby_550.md
├── try_ruby_560.md
├── try_ruby_60.md
├── try_ruby_70.md
├── try_ruby_80.md
└── try_ruby_90.md
└── zh
├── README.md
├── try_ruby_10.md
├── try_ruby_100.md
├── try_ruby_110.md
├── try_ruby_120.md
├── try_ruby_130.md
├── try_ruby_140.md
├── try_ruby_150.md
├── try_ruby_160.md
├── try_ruby_170.md
├── try_ruby_180.md
├── try_ruby_190.md
├── try_ruby_20.md
├── try_ruby_200.md
├── try_ruby_210.md
├── try_ruby_220.md
├── try_ruby_230.md
├── try_ruby_240.md
├── try_ruby_250.md
├── try_ruby_260.md
├── try_ruby_270.md
├── try_ruby_280.md
├── try_ruby_290.md
├── try_ruby_30.md
├── try_ruby_300.md
├── try_ruby_310.md
├── try_ruby_320.md
├── try_ruby_330.md
├── try_ruby_340.md
├── try_ruby_350.md
├── try_ruby_360.md
├── try_ruby_370.md
├── try_ruby_380.md
├── try_ruby_390.md
├── try_ruby_40.md
├── try_ruby_400.md
├── try_ruby_410.md
├── try_ruby_420.md
├── try_ruby_430.md
├── try_ruby_440.md
├── try_ruby_450.md
├── try_ruby_460.md
├── try_ruby_470.md
├── try_ruby_480.md
├── try_ruby_490.md
├── try_ruby_50.md
├── try_ruby_500.md
├── try_ruby_510.md
├── try_ruby_520.md
├── try_ruby_530.md
├── try_ruby_540.md
├── try_ruby_550.md
├── try_ruby_560.md
├── try_ruby_60.md
├── try_ruby_70.md
├── try_ruby_80.md
└── try_ruby_90.md
/.github/dependabot.yml:
--------------------------------------------------------------------------------
1 | version: 2
2 | updates:
3 | - package-ecosystem: 'github-actions'
4 | directory: '/'
5 | schedule:
6 | interval: 'weekly'
7 |
--------------------------------------------------------------------------------
/.github/workflows/test.yml:
--------------------------------------------------------------------------------
1 | name: Run RSpec
2 |
3 | on:
4 | push:
5 | branches:
6 | - master
7 | pull_request: {}
8 |
9 | jobs:
10 | test:
11 | runs-on: ubuntu-latest
12 | steps:
13 | - name: Checkout
14 | uses: actions/checkout@v4
15 | - name: Setup Ruby
16 | uses: ruby/setup-ruby@v1
17 | with:
18 | ruby-version: "3.4"
19 | bundler-cache: true
20 | - name: Run RSpec
21 | run: bundle exec rake
22 | env:
23 | SIMPLIFIED_RUN: "1"
24 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | build/*
2 | _site/*
3 | .bundle
4 | .idea
5 | .ruby-version
6 | .sass-cache
7 | tmp
8 | app/application.js
9 | source/try_ruby*.json
10 |
--------------------------------------------------------------------------------
/.rspec:
--------------------------------------------------------------------------------
1 | --require spec_helper
2 |
--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
1 | ## Building image ##
2 | FROM ruby:3.0.3-slim-bullseye AS builder
3 | # install build dependencies
4 | RUN apt update && apt install make gcc g++ libffi-dev nodejs git -y
5 | COPY ./Gemfile /app/Gemfile
6 | COPY ./Gemfile.lock /app/Gemfile.lock
7 | WORKDIR /app
8 | RUN bundle install
9 | EXPOSE 4567
10 | CMD ["bin/middleman", "serve"]
11 |
--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
1 | source "https://rubygems.org"
2 |
3 | gem "opal", "~> 1.7"
4 | gem "opal-browser"
5 | gem "middleman"
6 | gem "middleman-livereload"
7 | gem "middleman-syntax"
8 | gem "middleman-blog"
9 | gem "middleman-gh-pages"
10 | gem "redcarpet"
11 | gem "sass"
12 | gem "webrick"
13 | gem "terser"
14 |
15 | group :test do
16 | gem "rspec"
17 | gem "capybara"
18 | gem "cuprite"
19 | gem "puma"
20 | end
21 |
--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
1 | require 'bundler'
2 | Bundler.require
3 |
4 | require "middleman-gh-pages"
5 |
6 | # Ensure builds are skipped when publishing to the gh-pages branch
7 | ENV["COMMIT_MESSAGE_SUFFIX"] = "[skip ci]"
8 | # Ignore errors about dirty builds (not recommended)
9 | ENV["ALLOW_DIRTY"] = "true"
10 |
11 | # RSpec tests
12 | require "rspec/core/rake_task"
13 | RSpec::Core::RakeTask.new(:spec)
14 | task :default => :spec
15 |
--------------------------------------------------------------------------------
/app/dependencies.rb:
--------------------------------------------------------------------------------
1 | require 'opal'
2 | require 'native'
3 | require 'promise/v2'
4 | require 'browser/setup/mini'
5 | require 'browser/cookies'
6 | require 'browser/http'
7 | require 'browser/location'
8 | require 'browser/history'
9 | require 'browser/navigator'
--------------------------------------------------------------------------------
/app/editor.rb:
--------------------------------------------------------------------------------
1 | # Wrapper for CodeMirror objects
2 | class Editor
3 | def initialize(dom_id, options)
4 | @native = `CodeMirror(document.getElementById(dom_id), #{options.to_n})`
5 | end
6 |
7 | def value=(str)
8 | `#@native.setValue(str)`
9 | end
10 |
11 | def value
12 | `#@native.getValue()`
13 | end
14 |
15 | def focus
16 | `#@native.focus()`
17 | end
18 |
19 | def mark_ok(line_from, line_to)
20 | `#@native.markText({line: line_from, ch: 0}, {line: line_to, ch: 99}, {className: "tryruby-output-green"})`
21 | end
22 |
23 | def mark_error(line_from, line_to)
24 | `#@native.markText({line: line_from, ch: 0}, {line: line_to, ch: 99}, {className: "tryruby-output-red"})`
25 | end
26 |
27 | def on(event, &block)
28 | `#@native.on(#{event}, #{block})`
29 | end
30 | end
31 |
--------------------------------------------------------------------------------
/app/helper.rb:
--------------------------------------------------------------------------------
1 | require 'dependencies'
2 |
3 | class Helper
4 | @@navigator = $window&.navigator
5 |
6 | def self.ios?
7 | @@navigator&.user_agent&.match?(/\b(iPad|iPhone|iPod)\b/) || false
8 | end
9 |
10 | def self.macos?
11 | @@navigator&.user_agent&.match?(/\bMac\b/) || false
12 | end
13 | end
14 |
--------------------------------------------------------------------------------
/app/ruby_engine/opal.rb:
--------------------------------------------------------------------------------
1 | require 'opal/full'
2 | require 'opal-parser'
3 |
4 | class RubyEngine
5 | class Opal < RubyEngine
6 | def name
7 | "Opal #{::Opal::VERSION}"
8 | end
9 |
10 | def engine_id
11 | "opal"
12 | end
13 |
14 | def run(source)
15 | # Compile
16 | js_code = ::Opal.compile(source)
17 |
18 | # Bind puts and print methods.
19 | $stdout.write_proc = $stderr.write_proc = ->(str) do
20 | writer.print_to_output str, ""
21 | end
22 |
23 | # Run
24 | retval = nil
25 | error = nil
26 |
27 | retval = `eval(js_code)`
28 | yield(retval ? retval.to_s : '')
29 | $stdout.write_proc = $stderr.write_proc = nil
30 | end
31 | end
32 | end
33 |
--------------------------------------------------------------------------------
/compose.yaml:
--------------------------------------------------------------------------------
1 | services:
2 | web:
3 | build: .
4 | image: tryruby:latest
5 | ports:
6 | - "9099:4567"
7 | volumes:
8 | - .:/app
9 |
--------------------------------------------------------------------------------
/config.ru:
--------------------------------------------------------------------------------
1 | require 'bundler'
2 | Bundler.require
3 |
4 | require 'middleman/rack'
5 |
6 | run Middleman.server
7 |
--------------------------------------------------------------------------------
/opal-config.rb:
--------------------------------------------------------------------------------
1 | require 'tilt/opal'
2 |
3 | Opal.append_path "#{__dir__}/app"
4 |
5 | class OpalBuilder < Opal::Builder
6 | def to_s
7 | super + "\n" + source_map.to_data_uri_comment
8 | end
9 | end
10 |
--------------------------------------------------------------------------------
/source/articles/index.html.erb:
--------------------------------------------------------------------------------
1 | ---
2 | title: "TryRuby Articles"
3 | ---
4 |
5 |
6 |
7 | <% blog.articles.each do |article| %>
8 |
<%= link_to article.title, article.url %>
9 |
<%= article.data.the_summary %>
10 | <% end %>
11 |
12 |
Klicke auf Next und beginne, zu lernen.
22 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_100.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Stop, du bist völlig irre!
4 | answer: ^\d{1,}$
5 | ok: Nur Strings können umgedreht werden
6 | error:
7 | ---
8 |
9 | Man kann die Nummer vierzig nicht umdrehen. Ich denke, du kannst deinen Monitor
10 | an den Spiegel halten, aber eine Nummer umzudrehen macht einfach keinen Sinn.
11 |
12 | Ruby hat eine Fehlermeldung geworfen. Ruby sagt dir, es gibt keine Methode
13 | 'reverse' für Nummern.
14 |
15 | Vielleicht, wenn du die Nummer zuerst in einen String umwandelst:
16 |
17 | 40.to_s.reverse
18 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_110.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Äpfel sind etwas anderes als Orangen
4 | answer: \[\]
5 | ok: Super, das ist eine leere Liste
6 | error:
7 | ---
8 |
9 | Und Nummern sind etwas anderes als Strings.
10 |
11 | Während du in Ruby Methoden auf jedes Objekt anwenden kannst, funktionieren
12 | einige Methoden nur auf bestimmte Arten von Objekten.
13 | Du kannst aber immer zwischen verschiedenen Typen konvertieren, indem du die
14 | "to"-Methoden von Ruby verwendest.
15 |
16 | - __to_s__ konvertiert Sachen in __S__trings
17 | - __to_i__ konvertiert Sachen in __I__nteger (Nummern)
18 | - __to_a__ konvertiert Sachen in __A__rrays
19 |
20 | __Was sind Arrays?!__
21 |
22 | Das sind Listen. Tippe ein Paar von Klammern ein:
23 |
24 | []
25 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_120.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: In einer Schlange stehen
4 | answer: ^\[([-\.\d]+)(\s*,\s*[-\d\.]+){3,}\]$
5 | ok: Ausgezeichnet
6 | error: Versuche, eine vierte Nummer in die Liste einzufügen
7 | ---
8 |
9 | Listen (Arrays) speichern Dinge __in einer Reihenfolge__.
10 |
11 | Wie beim Schlange stehen für Popcorn. Du stehst hinter jemandem und würdest
12 | nicht im Traum daran denken, ihn zur Seite zu schieben, oder? Und den Typ, der
13 | hinter dir steht, behältst du genau im Auge, richtig?
14 |
15 | Hier ist eine Liste für dich. Lottozahlen:
16 |
17 | [12, 47, 35]
18 |
19 | Versuche, eine Nummer zu dieser Liste hinzuzufügen: Gib ein Komma nach 35 ein,
20 | gefolgt von einer Nummer. Das Leerzeichen ist optional.
21 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_130.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Einer hebt die Hand
4 | answer: ^47$
5 | ok: Okay
6 | error:
7 | ---
8 |
9 | Eine Liste von Lottozahlen. Welche ist die höchste?
10 |
11 | Versuch es:
12 |
13 | [12, 47, 35].max
14 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_140.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Eine Liste wegstecken
4 | answer: ^\[(\d+)(,\s*\d+){2,}\]$
5 | ok: Gespeichert!
6 | error:
7 | ---
8 |
9 | Gut, gut. Aber es ist lästig, diese Liste jedes Mal neu eingeben zu müssen,
10 | wenn man sie braucht, nicht wahr?
11 |
12 | Speichern wir unsere Nummern in einem Ticket wie folgt:
13 |
14 | ticket = [12, 47, 35]
15 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_150.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Jetzt Ticket eintippen
4 | answer: \[(\d+(, )?){2,}\]
5 | load: ticket = [12, 47, 35]
6 | ok: Wiederhergestellt!
7 | error:
8 | ---
9 |
10 | Jetzt tippe:
11 |
12 | ticket
13 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_190.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Leider hasst du Toast-Poesie
4 | answer: (Toast){0}
5 | load: prev
6 | ok: Ausgezeichnet
7 | error: Riecht für mich immer noch nach Toast
8 | ---
9 |
10 | Es ist schon in Ordnung. Du musst es nicht mögen. Mach was draus, wenn du
11 | willst. Anstelle von Toast, nimm eine Melone oder so. Probier mal das hier, um
12 | das neue Gedicht zu sehen:
13 |
14 | poem.gsub("Toast", "Melonenstück")
15 |
16 | Die Methode __gsub__ ist die Abkürzung für global substitute. Sie ersetzt alle
17 | Vorkommen von "Toast" durch " Melonenstück".
18 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_20.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Den Editor benutzen
4 | answer: ^\d{1,}$
5 | ok: Gut! Du hast ein bisschen gerechnet. Siehst du, wie die Antwort herauskommt?
6 | error: Tippe 2 + 6 in den Editor
7 | ---
8 |
9 | Gib im Editor deinen Ruby-Code ein, klicke auf den Button __Run__ und siehe,
10 | wie er läuft!
11 |
12 | Versuche zum Beispiel, etwas Mathe zu tippen. Wie:
13 |
14 | 2 + 6
15 |
16 | Die Ausgabe deines Programms sollte im Ausgabefenster zu sehen sein.
17 | Es sollte auch eine Zeile geben, die dir sagt, wie gut du die Aufgabe gelöst
18 | hast.
19 |
20 | > Alternativ kannst du auch auf den Button __Copy__ klicken, um den
21 | Beispielcode in den Editor zu kopieren.
22 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_200.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Fertig, Zielen
4 | answer: negolfeg dnaH red sua rim tsi tsaoT nieM
5 | load: prev
6 | ok: Okay, ja. Das ganze Gedicht ist also umgedreht worden.
7 | error:
8 | ---
9 |
10 | Hier eine Frage: Was passiert, wenn wir dieses ganze Gedicht umkehren?
11 |
12 | poem.reverse
13 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_210.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Too Much Reversal
4 | answer: ^\["Noch mehr wollte (.+)
5 | load: prev
6 | ok: Ja, fast so, wie wir es wollen
7 | error:
8 | ---
9 |
10 | Das ganze Gedicht wurde also Buchstabe für Buchstabe umgedreht. Dabei wollte
11 | ich eigentlich nur die Zeilen umkehren.
12 | Verschiebe die letzte Zeile nach oben an den Anfang und die erste Zeile nach
13 | unten an das Ende.
14 |
15 | Rückwärts, aber nicht __so__ rückwärts.
16 |
17 | So geht's:
18 |
19 | poem.lines.reverse
20 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_270.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Hashes als Paare
4 | answer: ^\[".*"\]
5 | load: prev
6 | ok: Du hast die Schlüssel gefunden
7 | error:
8 | ---
9 |
10 | Vergiss nicht, dass Hashes nicht für die Reihenfolge der Dinge sorgen. Das ist
11 | nicht ihre Aufgabe. Sie verbinden nur zwei Dinge miteinander: einen __key
12 | (Schlüssel)__ und einen __value (Wert)__.
13 |
14 | In deinen Rezensionen ist der Titel des Buches der Schlüssel und die Bewertung
15 | ist der Wert.
16 |
17 | Wenn du nur die Titel aller Bücher sehen willst, die du bewertet hast:
18 |
19 | books.keys
20 |
21 | Du kannst es auch mit .values anstelle von .keys ausprobieren.
--------------------------------------------------------------------------------
/translations/de/try_ruby_290.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Ein Strichliste
4 | answer: \w+
5 | ok: Yodelay!
6 | error:
7 | ---
8 |
9 | Eines der tollen neuen Dinge, die wir gerade benutzt haben, ist ein __Block__.
10 | Wir werden sie in dieser und in der nächsten Lektion genauer betrachten. Aber
11 | im Grunde ist ein Block ein Stück Ruby-Code, das von geschweiften Klammern
12 | umgeben ist.
13 |
14 | Probieren wir einen anderen Block aus:
15 |
16 | 5.times { print "Odelay! " }
17 |
18 | Blöcke sind immer mit Methoden verbunden. Wie die Methode __times__, die den
19 | Block nimmt und den Code immer wieder ausführt. (In unserem Beispiel: fünfmal.)
--------------------------------------------------------------------------------
/translations/de/try_ruby_30.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Nummern und Mathematik
4 | answer: ^[0-9\.,-]{1,}$
5 | ok: Gut
6 | error:
7 | ---
8 |
9 | Ruby erkennt Nummern und mathematische Symbole. Du kannst auch andere
10 | mathematische Symbole ausprobieren:
11 |
12 | 4 * 10
13 | 5 - 12
14 | 30 / 4
--------------------------------------------------------------------------------
/translations/de/try_ruby_310.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Wir kommen zur Zusammenfassung #4
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Diese letzte Lektion war ein bisschen länger. Du hast sicher bis zu drei Minuten damit verbracht, etwas zu lernen über:
11 |
12 | ### Hashes
13 | Das kleine Wörterbuch mit den geschweiften Seiten: __{}__
14 |
15 | ### Symbole
16 | Kleine, effiziente Codewörter mit einem Doppelpunkt, wie: __:splendid__
17 |
18 | ### Blöcke
19 | Codestücke, die an viele der Methoden von Ruby angehängt werden können. Hier ist der Code, den du verwendet hast, um eine Übersicht über die Bewerungen zu erstellen:
20 | __books.values.each { |rate| ratings[rate] += 1 }__
21 |
22 | ### Als nächstes
23 | In der nächsten Lektion werden wir uns ein wenig näher mit Methoden beschäftigen.
24 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_350.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Die reife Frucht Ihrer eigenen Schöpfung
4 | answer: ^Tamed a shrew
5 | ok: Das wird es ihnen zeigen
6 | error:
7 | load: def tame(number_of_shrews);number_of_shrews.times{puts "Tamed a shrew"};end;
8 | ---
9 |
10 | Eine neue Methode ist geboren. Wir sollten sie jetzt anwenden:
11 |
12 | tame 5
13 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_370.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Hallo, wer ist da? Und Zusammenfassung #5 schwenkt seinen Hut!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Gut gemacht, gut gemacht, gut gemacht, gut gemacht!
11 |
12 | Ehrlich, ehrlich, ehrlich, ehrlich, eeeeeeehrlich!
13 |
14 | Hier sind die letzten Minuten deines Lebens im Rückblick:
15 |
16 | ### Methoden
17 | Methoden können mit __def__ definiert werden und haben einen Namen. Methoden
18 | machen dein Programm kürzer und einfacher zu lesen.
19 |
20 | ### Parameter
21 | Methoden können Parameter haben.
22 |
23 | ### Rückgabewerte
24 | Methoden geben (fast) immer einen Wert zurück.
25 |
26 | ## Und nun
27 | "To (be) or not to (be)" ist für dich keine Frage mehr. Bist du bereit für
28 | etwas mehr Shakespeare?
29 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_470.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Der Stoff, aus dem Apps gemacht sind
4 | answer:
5 | ok:
6 | error:
7 | ---
8 |
9 | Du hast eine neue BlurbTM-Klasse eröffnet. Woraus ist dein
10 | Blogeintrag gemacht?
11 | Der Inhalt, sicher. Auch eine Zeit, zu der der BlurbTM
12 | veröffentlicht wurde. Und eine Stimmung.
13 |
14 | Okay, du hast also die erste Zeile der Klasse, hier ist der Rest:
15 |
16 | class Blurb
17 | attr_accessor :content, :time, :mood
18 | end
19 |
20 | Klassennamen beginnen immer mit einem Großbuchstaben.
21 |
22 | (Immer noch keine Ausgabe)
23 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_490.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Ein Objekt, dieses hübsche kleine Paket
4 | answer: Blurb:
5 | ok: Blurb updated
6 | error:
7 | load: prev;blurb1=Blurb.new;blurb1.content="Today Mount Hood Was Stolen!"
8 | ---
9 |
10 | Lost geht's, stell die BlurbTM Zeit und Stimmung ein:
11 |
12 | blurb1.time = Time.now
13 | blurb1.mood = :sick
14 |
15 | puts blurb1
16 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_50.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Sag deinen Namen
4 | answer: [a-zA-Z]{1,1}
5 | ok: Perfekt, du hast einen String aus den Buchstaben deines Namens gebildet
6 | error:
7 | ---
8 |
9 | Sicher, Computer sind praktisch und schnell für Mathe. Aber machen wir weiter.
10 | Willst du deinen Namen rückwärts sehen?
11 |
12 | Gib als Erstes deinen Vornamen in Anführungszeichen ein, etwa so:
13 |
14 | "Jimmy"
15 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_60.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Sag deinen Namen rückwärts
4 | answer: \w+
5 | ok: tuG
6 | error:
7 | ---
8 |
9 | Ein String ist ein Set von Zeichen, die der Computer verarbeiten kann. Stell
10 | dir vor, die Buchstaben sind auf einer Wäscheleine und die Anführungszeichen
11 | sind Wäscheklammern, die die Enden halten. Die Anführungszeichen markieren den
12 | Anfang und das Ende.
13 |
14 | Um deinen Namen umzukehren, tippe:
15 |
16 | "Jimmy".reverse
17 |
18 | ("Vergiss nicht den Punkt!")
19 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_70.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Die Buchstaben zählen
4 | answer: ^\d+$
5 | ok: Jup. Länge ist auch eine "Methode".
6 | error:
7 | ---
8 |
9 | Du hast die Reverse-__Methode__ auf deinen Namen angewendet! Indem du deinen
10 | Namen in Anführungszeichen gesetzt hast, hast du einen String erstellt. Dann
11 | hast du die Reverse-Methode aufgerufen, die bei Strings funktioniert, um alle
12 | Buchstaben rückwärts umzukehren.
13 |
14 | Nun wollen wir mal sehen, wie viele Buchstaben dein Name hat:
15 |
16 | "Jimmy".length
17 |
--------------------------------------------------------------------------------
/translations/de/try_ruby_80.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: DE
3 | title: Auf Repeat
4 | answer: (\w+)
5 | ok: Schön, dich kennenzulernen.Schön, dich kennenzulernen.Schön, dich kennenzulernen.
6 | error:
7 | ---
8 |
9 | Jetzt fragst du dich wahrscheinlich, wozu das alles gut sein soll.
10 |
11 | Nun, ich bin sicher, du warst schon einmal auf einer Website, die geschrien hat:
12 | __Hey, dein Passwort ist zu kurz!__
13 |
14 | Siehst du, manche Programme verwenden diesen einfachen __.length__-Code.
15 |
16 | Pass auf. Multiplizieren wir deinen Namen mit 5.
17 |
18 | "Jimmy" * 5
19 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_10.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Got 30 minutes? Give Ruby a shot right now!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Ruby is a programming language from Japan which is revolutionizing
11 | software development.
12 |
13 | The beauty of Ruby is found in its balance between simplicity and power.
14 |
15 | You can type some Ruby code in the editor and use these buttons to navigate:
16 |
17 | - __Run__ → Executes the code in the editor
18 | - __Copy__ → Copies the example code to the editor
19 | - __Next__ → Allows you to go to the next lesson
20 | - __Back__ → Allows you to return to the previous lesson
21 |
22 | Click on Next to start learning.
23 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_100.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Stop, You're Barking Mad!
4 | answer: ^\d{1,}$
5 | ok: Only strings can be reversed
6 | error:
7 | ---
8 |
9 | You can't reverse the number forty. I guess you can hold your monitor up to the mirror, but reversing a number just doesn't make sense.
10 |
11 | Ruby has tossed an error message. Ruby is telling you there is no method reverse for numbers.
12 |
13 | Maybe if you turn the number into a string first:
14 |
15 | 40.to_s.reverse
16 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_110.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Apples are Different From Oranges
4 | answer: \[\]
5 | ok: Great, that's an empty list
6 | error:
7 | ---
8 |
9 | And numbers are different from strings.
10 |
11 | While you can use methods on any object in Ruby, some methods only work on certain types of things.
12 | But you can always convert between different types using Ruby's "to" methods.
13 |
14 | - __to_s__ converts things to __s__trings
15 | - __to_i__ converts things to __i__ntegers (numbers)
16 | - __to_a__ converts things to __a__rrays
17 |
18 | __What are arrays?!__
19 |
20 | They are lists. Type in a pair of brackets:
21 |
22 | []
23 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_120.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Standing in Line
4 | answer: ^\[([-\.\d]+)(\s*,\s*[-\d\.]+){3,}\]$
5 | ok: Excellent
6 | error: Try adding a fourth number to the list
7 | ---
8 |
9 | Lists (arrays) store things __in some order__.
10 |
11 | Like standing in line for popcorn. You are behind someone and you wouldn't dream of pushing them aside,
12 | right? And the guy behind you, you've got a close eye on him, right?
13 |
14 | Here's a list for you. Lottery numbers:
15 |
16 | [12, 47, 35]
17 |
18 | Try adding a number to this list: type a comma after 35 followed by a number. The space is optional.
19 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_130.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: One Raises Its Hand
4 | answer: ^47$
5 | ok: Okay
6 | error:
7 | ---
8 |
9 | A list of lottery numbers. Which one is the highest?
10 |
11 | Try:
12 |
13 | [12, 47, 35].max
14 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_140.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Tucking a List Away
4 | answer: ^\[(\d+)(,\s*\d+){2,}\]$
5 | ok: Saved!
6 | error:
7 | ---
8 |
9 | Good, good. But it's annoying to have to retype that list every time you need it, isn't it?
10 |
11 | Let's save our numbers inside a ticket like so:
12 |
13 | ticket = [12, 47, 35]
14 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_150.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Now Type Ticket
4 | answer: \[(\d+(, )?){2,}\]
5 | load: ticket = [12, 47, 35]
6 | ok: Restored!
7 | error:
8 | ---
9 |
10 | Now, type:
11 |
12 | ticket
13 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_160.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Saved, Tucked Away
4 | answer: \[12, 35, 47\]
5 | load: ticket = [12, 47, 35]
6 | ok: You've sorted the list
7 | error:
8 | ---
9 |
10 | You've hung on to your lotto numbers, tucking them away inside a **variable** called ticket.
11 | But any other name, like _jimmyslist_, would have been fine too.
12 |
13 | Programming, you will discover, is mostly about working with variables.
14 |
15 | Let's put your lotto numbers in order, how about?
16 |
17 | Use:
18 |
19 | ticket.sort!
20 |
21 | You had a list. You sorted the list. The ticket variable is now changed.
22 | Did you notice that the _sort!_ method has a big, bright exclamation at the end?
23 | A lot of times Ruby methods shout like that if they alter the variable for good.
24 | It's nothing special, just a mark.
25 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_190.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Sadly, You Hate Toast Poetry
4 | answer: (toast){0}
5 | load: prev
6 | ok: Excellent
7 | error: Still smells like toast to me
8 | ---
9 |
10 | Look, it's okay. You don't have to like it. Hack it up, be my guest. Instead of toast, go for a
11 | melon or something. Try this to see the new poem:
12 |
13 | poem.gsub("toast", "honeydew")
14 |
15 | The **gsub** method is short for global substitute. It replaces all occurrences of "toast" with
16 | "honeydew".
17 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_20.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Using the editor
4 | answer: ^\d{1,}$
5 | ok: Good! You did a bit of math. See how the answer popped out?
6 | error: Type 2 + 6 in the editor
7 | ---
8 |
9 | The editor window is where you type your Ruby code. Hit the __Run__ button and
10 | watch it run!
11 |
12 | For example, try typing some math. Like:
13 |
14 | 2 + 6
15 |
16 | The output of your program should show itself in the output window.
17 | There should also be a line that tells you how well you did.
18 |
19 | > Alternatively you can hit the __Copy__ button to copy the example code to the editor.
20 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_200.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Ready, Aim
4 | answer: dnah ym morf nwolf sah tsaot yM
5 | load: prev
6 | ok: Okay, sure. So the whole poem has been turned backwards.
7 | error:
8 | ---
9 |
10 | Here's a question: what happens when we reverse this whole poem?
11 |
12 | poem.reverse
13 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_210.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Too Much Reversal
4 | answer: ^\["More still did (.+)
5 | load: prev
6 | ok: Yes, almost what we want
7 | error:
8 | ---
9 |
10 | So the whole poem's been turned backwards, letter-by-letter. I really wanted to just reverse the lines though.
11 | Move the last line up to first and the first line down to last.
12 |
13 | Backwards, but not __that__ backwards.
14 |
15 | Here's how:
16 |
17 | poem.lines.reverse
18 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_220.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Ringlets of Chained Methods
4 | answer: My toast has flown from my hand
5 | load: prev
6 | ok: Good show, my friend!
The join method took that array of lines and put them together into a string.
7 | error:
8 | ---
9 |
10 | So what do you see? What happened there? You typed __poem.lines.reverse__ and what happened?
11 |
12 | Two things happened. You turned the poem into a list using lines.
13 | Lines decides the way the string is split up and converts it into an Array.
14 |
15 | Then, you reversed that list. You had each line. You reversed them. That's it.
16 |
17 | Let's tack one more method on the end there:
18 |
19 | puts poem.lines.reverse.join
20 |
21 | Combining methods like this is called _method chaining_.
--------------------------------------------------------------------------------
/translations/en/try_ruby_260.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Wait, Did I Like Gravity's Rainbow?
4 | answer: ^(splendid|quite_good|mediocre|quite_not_good|abysmal)$
5 | load: books = {"Gravitys Rainbow" => :splendid, "The deep end" => :abysmal, "Living colors" => :mediocre}
6 | ok: I liked it a lot
7 | error:
8 | ---
9 |
10 | One great thing about Ruby is that names are often reused, which means fewer names you need to remember.
11 |
12 | Remember how we retrieved items from an array using a number:
13 | __puts ticket[1]__.
14 |
15 | For a hash this works the same way, except we don't use a number to get an element but a name.
16 |
17 | So, if you'd like to look up one of your old reviews, again put the title in the square. But leave off the equals.
18 | Just like this:
19 |
20 | puts books["Gravitys Rainbow"]
21 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_270.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Hashes as Pairs
4 | answer: ^\[".*"\]
5 | load: prev
6 | ok: You found the keys
7 | error:
8 | ---
9 |
10 | Keep in mind that hashes won't keep things in order. That's not their job. It'll just pair up
11 | two things: a __key__ and a __value__.
12 |
13 | In your reviews, the book's title is the key and the rating is the value.
14 |
15 | If you want to just see the titles of all the books you've reviewed:
16 |
17 | books.keys
18 |
19 | You can also try this with .values instead of .keys.
--------------------------------------------------------------------------------
/translations/en/try_ruby_290.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: A Tally
4 | answer: \w+
5 | ok: Yodelay!
6 | error:
7 | ---
8 |
9 | One of the amazing new things we've just used is a __block__. We're going to explore these more
10 | in this and the next lesson. But, basically, a block is a bit of Ruby code surrounded by curly
11 | braces.
12 |
13 | Let's try another block:
14 |
15 | 5.times { print "Odelay! " }
16 |
17 | Blocks are always attached to methods. Like the __times__ method, which takes the block and runs
18 | the code over and over. (In our example: five times.)
--------------------------------------------------------------------------------
/translations/en/try_ruby_30.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Numbers and Math
4 | answer: ^[0-9\.,-]{1,}$
5 | ok: Good
6 | error:
7 | ---
8 |
9 | Ruby recognizes numbers and mathematic symbols. You could try some other math like:
10 |
11 | 4 * 10
12 | 5 - 12
13 | 30 / 4
--------------------------------------------------------------------------------
/translations/en/try_ruby_310.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Now Arriving at Summary #4
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | This last lesson was a bit longer. You've probably used up three minutes learning about:
11 |
12 | ### Hashes
13 | The little dictionary with the curly pages: __{}__
14 |
15 | ### Symbols
16 | Tiny, efficient code words with a colon, like: __:splendid__
17 |
18 | ### Blocks
19 | Chunks of code which can be tacked on to many of Ruby's methods. Here's the code you used to
20 | build a scorecard:
21 | __books.values.each { |rate| ratings[rate] += 1 }__
22 |
23 | ### Next
24 | In the next lesson we will delve a little bit deeper into methods.
25 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_350.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: The Ripened Fruit of Your Own Creation
4 | answer: ^Tamed a shrew
5 | ok: That'll show those shrews
6 | error:
7 | load: def tame(number_of_shrews);number_of_shrews.times{puts "Tamed a shrew"};end;
8 | ---
9 |
10 | A new method is born. Let us use it now:
11 |
12 | tame 5
13 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_370.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Hello, Who's There? And Summary #5 Waves Its Hat!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Well done, well done, well done, well done!
11 |
12 | Truly, truly, truly, truly, truuuuuuuuly!
13 |
14 | Here's the last few minutes of your life in review:
15 |
16 | ### Methods
17 | Methods can be defined with __def__ and have a name. Methods make your program shorter
18 | and easier to read.
19 |
20 | ### Parameters
21 | Methods can have parameters.
22 |
23 | ### Return values
24 | Methods (almost) always return a value.
25 |
26 | ## Now
27 | To (be) or not to (be) is not a question to you anymore. Are you ready for some more Shakespeare?
28 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_470.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: The Stuff Apps are Made of
4 | answer:
5 | ok:
6 | error:
7 | ---
8 |
9 | You've opened up a new BlurbTM class. What is your blog entry made of?
10 | The content, sure. Also, a time when the BlurbTM was posted. And a mood.
11 |
12 | Okay, so you've got the first line of the class, here's the rest:
13 |
14 | class Blurb
15 | attr_accessor :content, :time, :mood
16 | end
17 |
18 | Class names always begin with a capital letter.
19 |
20 | (Still no output)
21 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_490.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: An Object, That Neat Little Package
4 | answer: Blurb:
5 | ok: Blurb updated
6 | error:
7 | load: prev;blurb1=Blurb.new;blurb1.content="Today Mount Hood Was Stolen!"
8 | ---
9 |
10 | Go ahead and set the BlurbTM time and mood:
11 |
12 | blurb1.time = Time.now
13 | blurb1.mood = :sick
14 |
15 | puts blurb1
16 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_50.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Say Your Name
4 | answer: [a-zA-Z]{1,1}
5 | ok: Perfect, you've formed a string from the letters of your name
6 | error:
7 | ---
8 |
9 | Sure, computers are handy and fast for math. Let's move on. Want to see your name reversed?
10 |
11 | First type your first name in quotes like this:
12 |
13 | "Jimmy"
14 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_60.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Say Your Name Backwards
4 | answer: \w+
5 | ok: dooG
6 | error:
7 | ---
8 |
9 | A string is a set of characters the computer can process. Imagine the letters are on a string of
10 | laundry line and the quotes are clothespins holding the ends. The quotes mark the beginning and end.
11 |
12 | To reverse your name, type:
13 |
14 | "Jimmy".reverse
15 |
16 | (Don't forget the dot!)
17 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_70.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: Counting the Letters
4 | answer: ^\d+$
5 | ok: Yep. Length is also a 'method'
6 | error:
7 | ---
8 |
9 | You have used the reverse __method__ on your name! By enclosing your name in quotes, you made a string. Then you called the reverse method, which works on strings to flip all the letters backwards.
10 |
11 | Now, let us see how many letters are in your name:
12 |
13 | "Jimmy".length
14 |
--------------------------------------------------------------------------------
/translations/en/try_ruby_80.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: EN
3 | title: On Repeat
4 | answer: (\w+)
5 | ok: Nice to meet you.Nice to meet you.Nice to meet you.
6 | error:
7 | ---
8 |
9 | Now, you're probably wondering what any of this is good for.
10 |
11 | Well, I'm sure you've been to a website that screamed, __Hey, your password is too short!__
12 |
13 | See, some programs use that simple __.length__ code.
14 |
15 | Watch this. Let's multiply your name by 5.
16 |
17 | "Jimmy" * 5
18 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_10.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: ¿Tienes 30 minutos? ¡Prueba Ruby ahora mismo!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Ruby es un lenguaje de programación de Japón que está revolucionando el desarrollo de software.
11 |
12 | La belleza de Ruby está en el equilibrio entre simplicidad y potencia.
13 |
14 | Escribe código Ruby en el editor y usa estos botones para navegar:
15 |
16 | - __Run__ → Ejecuta el código en el editor
17 | - __Copy__ → Copia el ejemplo al editor
18 | - __Next__ → Avanza a la siguiente lección
19 | - __Back__ → Retrocede a la lección anterior
20 |
21 | Pulsa Next para empezar a aprender.
22 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_100.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Para, estás loco de atar!
4 | answer: ^\d{1,}$
5 | ok: Sólo a strings (cadenas de texto) se les puede dar la vuelta
6 | error:
7 | ---
8 |
9 | No puedes darle la vuelta al número cuarenta. Imagino que puedes poner tu monitor delante del espejo, pero darle la vuelta a un número no tiene sentido.
10 |
11 | Ruby ha lanzado un mensaje de error que te dice que no hay un método para dar la vuelta a un número.
12 |
13 | Quizás, si conviertes antes el número en string:
14 |
15 | 40.to_s.reverse
16 |
17 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_110.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Las Naranjas son diferentes de las Manzanas
4 | answer: \[\]
5 | ok: Genial, eso es una lisa vacía
6 | error:
7 | ---
8 |
9 | Y los números son distintos de las letras.
10 |
11 | En Ruby puedes usar métodos sobre cualquier objeto, pero algunos métodos solo funcionan con cierto tipo de cosas.
12 |
13 | Lo bueno es que siempre puedes convertir algo en otro tipo de cosa usando los métodos "to" de Ruby.
14 |
15 |
16 | - __to_s__ convierte cosas en __s__trings (cadenas de texto)
17 | - __to_i__ convierte cosas en __i__ntegers (numeros enteros)
18 | - __to_a__ convierte cosas en __a__rrays (listas)
19 |
20 | __¿Qué son las arrays?__
21 |
22 | Son listas. Escribe un par de corchetes:
23 |
24 | []
25 |
26 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_120.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: En la cola
4 | answer: ^\[([-\.\d]+)(\s*,\s*[-\d\.]+){3,}\]$
5 | ok: Excelente
6 | error: Prueba a añadir un cuarto número a la lista
7 | ---
8 |
9 | Las listas (arrays) guardan cosas __en algún orden__.
10 |
11 | Como estar en la cola para comprar palomitas de maíz. Estás detrás de alguien y no se te ocurriría empujare a un lado, no? Además tienes a alguien detrás de tí, y no le pierdes de vista, correcto?
12 |
13 | Aquí hay una lista para tí. Números de lotería:
14 |
15 | [12, 47, 35]
16 |
17 |
18 | Prueba a añadir un número a esta lista: pon una coma detrás del 35 y a continuación un número, el espacio es opcional.
19 |
20 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_130.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Uno Levanta la Mano
4 | answer: ^47$
5 | ok: Correcto
6 | error:
7 | ---
8 |
9 | Una lista de números de lotería. ¿Cuál es el mayor?
10 |
11 | Prueba:
12 |
13 | [12, 47, 35].max
14 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_140.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Guardando una Lista
4 | answer: ^\[(\d+)(,\s*\d+){2,}\]$
5 | ok: ¡Guardada!
6 | error:
7 | ---
8 |
9 | Bien, bien. Pero es molesto tener que teclear esa lista cada vez que la necesitas, ¿verdad?
10 |
11 | Vamos a guardar nuestros números en un boleto, así:
12 |
13 | boleto = [12, 47, 35]
14 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_150.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Ahora Teclea Ticket
4 | answer: \[(\d+(, )?){2,}\]
5 | load: boleto = [12, 47, 35]
6 | ok: ¡Recuperado!
7 | error:
8 | ---
9 |
10 | Ahora, escribe:
11 |
12 | boleto
13 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_160.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Salvado, Guardado
4 | answer: \[12, 35, 47\]
5 | load: boleto = [12, 47, 35]
6 | ok: Has ordenado la lista
7 | error:
8 | ---
9 |
10 | Has almacenado tus números de la loto, guardándolos en una __variable__ llamada boleto.
11 | Cualquier otro nombre, como _listadejuan_ hubiera funcionado también.
12 |
13 | Programar, te darás cuenta, consiste principalmente en trabajar con variables.
14 |
15 | ¿Qué te parece si ordenamos los números de la lotería?
16 |
17 | Usa:
18 |
19 | boleto.sort!
20 |
21 | Tenías una lista. La has ordenado. La variable boleto ha cambiado.
22 | ¿Has notado que el método _sort! tiene una gran, brillante exclamación al final?
23 | Muchas veces los métodos de Ruby te gritan así si modifican una variable.
24 | No es nada especial, sólo una marca.
25 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_190.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Desafortunadamente, odias la poesía sobre tostadas
4 | answer: (toast){0}
5 | load: prev
6 | ok: Excelente
7 | error: Me sigue oliendo a tostada
8 | ---
9 |
10 | Mira, no importa. No tiene por qué gustarte. Arréglalo, por favor. En lugar de toast (tostada),
11 | prueba con un melón o algo. Prueba esto para ver el nuevo poema:
12 |
13 | poema.gsub("toast", "honeydew")
14 |
15 | El método __gsub__ es un diminutivo de "global substitute" (sustitución global). Reemplaza todas las ocurrencias de "toast" con
16 | "honeydew" (melón chino).
17 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_20.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Usando el editor
4 | answer: ^\d{1,}$
5 | ok: ¡ Bien ! Has hecho algo de matemáticas. ¿Has visto cómo apareció la respuesta?
6 | error: Escribe 2 + 6 en el editor
7 | ---
8 |
9 | La ventana del editor, abajo, es donde escribes tu código Ruby. Pulsa el botón __Run__ y mira cómo se ejecuta.
10 |
11 | Por ejemplo, prueba a escribir algo de matemáticas, como:
12 |
13 | 2 + 6
14 |
15 | La salida de tu programa debería aparecer en la ventana de Resultado ("Output"), arriba.
16 | Debería aparecer también una línea explicando si lo has hecho bien o mal.
17 |
18 |
19 | > También puedes pulsar el botón __Copy__ para copiar el ejemplo al editor.
20 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_200.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Apunten. Fuego
4 | answer: dnah ym morf nwolf sah tsaot yM
5 | load: prev
6 | ok: De acuerdo, sí. Se ha dado la vuelta el poema entero.
7 | error:
8 | ---
9 |
10 | Pregunta: ¿qué pasa si le damos la vuelta a todo este poema?
11 |
12 | poema.reverse
13 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_210.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Demasiado giro
4 | answer: ^\["More still did (.+)
5 | load: prev
6 | ok: Sí, casi lo que queremos
7 | error:
8 | ---
9 |
10 | Así que el poema entero se ha dado la vuelta, letra a letra. Pero yo solamente quería dar la vuelta a las líneas.
11 | Mover la última línea al principio y la primera al final.
12 |
13 | Al revés, pero no __tan__ al revés.
14 |
15 | Así es como se haría:
16 |
17 | poema.lines.reverse
18 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_220.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Tirabuzón de Métodos en Cadena
4 | answer: My toast has flown from my hand
5 | load: prev
6 | ok: Bien hecho, amigo mío.
El método join cogió el array de líneas y las puso juntas en un string.
7 | error:
8 | ---
9 |
10 | ¿Qué ves? ¿Qué ha pasado? Has escrito __poema.lines.reverse__ y ¿qué ha pasado?
11 |
12 | Han pasado dos cosas. Has convertido el poema en una lista usando lines.
13 | Lines decide la forma en la que un string se divide y lo convierte en un Array.
14 |
15 | Luego, has dado la vuelta a esa lista. Tenías cada una de las líneas. Les diste la vuelta. Eso es todo.
16 |
17 | Añadamos un nuevo método al final de la cadena:
18 |
19 | puts poema.lines.reverse.join
20 |
21 | Combinar métodos así se llama _encadenar métodos_.
22 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_270.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Hashes como Parejas
4 | answer: ^\[".*"\]
5 | load: prev
6 | ok: Encontraste las claves
7 | error:
8 | ---
9 |
10 | Ten en cuenta que los hashes no guardan las cosas en orden. Ese no es su trabajo. Simplemente emparejan dos cosas: una __clave__ y un __valor__.
11 |
12 | En tus reseñas, el título del libro es la clave, y la puntuación es el valor.
13 |
14 | Si quieres ver solo los títulos de todos los libros que has reseñado:
15 |
16 | libros.keys
17 |
18 | Puedes probar también con .values en lugar de .keys
19 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_290.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: El Total
4 | answer: \w+
5 | ok: ¡Requeteolé!
6 | error:
7 | ---
8 |
9 | Una de las impresionantes novedades que acabamos de usar es un __bloque__. Vamos a explorar
10 | un poco más en esta lección y en la siguiente. Pero básicamente, un bloque es un poco de código Ruby
11 | rodeado de llaves ({}).
12 |
13 | Probemos otro bloque:
14 |
15 | 5.times { print "¡Olé! " }
16 |
17 | Los bloques siempre se asocian a métodos. Por ejemplo el método __times__, que coge el bloque y ejecuta el código muchas veces (en nuestro ejemplo: cinco veces).
18 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_30.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Números y Matemáticas
4 | answer: ^[0-9\.,-]{1,}$
5 | ok: Bien
6 | error:
7 | ---
8 |
9 | Ruby reconoce números y símbolos matemáticos. Prueba otras operaciones como:
10 |
11 | 4 * 10
12 | 5 - 12
13 | 30 / 4
14 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_310.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Llegando al resumen #4
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Esta última lección ha sido un poco más larga. Probablemente habrás usado hasta tres minutos aprendiendo acerca de:
11 |
12 | ### Hashes
13 | El pequeño diccionario con las páginas curvas: __{}__
14 |
15 | ### Símbolos
16 | Pequeñas y eficientes palabras clave, con dos puntos, como __:esplendido__
17 |
18 | ### Bloques
19 | Trozos de código que se pueden añadir a muchos métodos de Ruby. Aquí está el código que usaste para calcular la cuenta de puntuaciones:
20 | __libros.values.each { |puntuacion| puntuaciones[puntuacion] += 1 }__
21 |
22 | ### Siguiente
23 | En la siguiente leccion ahondaremos un poco más en los métodos.
24 |
25 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_350.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: The Ripened Fruit of Your Own Creation
4 | answer: ^Domé una fierecilla
5 | ok: Así aprenderán esas fierecillas.
6 | error:
7 | load: def domar(numero_de_fierecillas); numero_de_fierecillas.times {puts "Domé una fierecilla"}; end;
8 | ---
9 |
10 | Ha nacido un nuevo método. Usémoslo:
11 |
12 | domar 5
13 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_370.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: ¿Hola, quién está ahí? ¡ Y el resumen #5 agita su sombrero !
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Bien hecho, bien hecho, bien hecho, ¡ bien hecho !
11 |
12 | De verdad, de verdad, de verdad, ¡ de verdaaaaaaaaaad !
13 |
14 | Aquí hay un resumen de los últimos minutos de tu vida:
15 |
16 | ### Métodos
17 | Los métodos se pueden definir con __def__ y tienen un nombre. Los métodos hacen tu programa más corto y fácil de leer.
18 |
19 | ### Parámetros
20 | Los métodos pueden recibir parámetros.
21 |
22 | ### Valor de retorno
23 | Los métodos (casi) siempre devuelven un valor.
24 |
25 | ## Ahora
26 | "To (be) or not to (be)" ya no es una incógnita para ti. ¿Listo para más Shakespeare?
27 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_470.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Las Cosas de las que están hechas las Aplicaciones
4 | answer:
5 | ok:
6 | error:
7 | ---
8 |
9 | Has abierto una nueva clase BlurbTM. ¿De qué estan hechas tus entradas del blog?
10 | El contenido, por supuesto. También la hora a la que el BlurbTM se publicó. Y un estado de ánimo.
11 |
12 | Bien, ya tienes la primera línea de la clase. Aquí está el resto:
13 |
14 | class Blurb
15 | attr_accessor :contenido, :tiempo, :animo
16 | end
17 |
18 | Los nombres de clases empiezan por mayúscula.
19 |
20 | (Todavía no hay salida en la pantalla)
21 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_490.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: El Objeto, ese Genial Pequeño Paquete
4 | answer: Blurb:
5 | ok: Blurb actualizado
6 | error:
7 | load: prev;blurb1=Blurb.new;blurb1.contenido="¡El Everest ha sido robado!"
8 | ---
9 |
10 | Ve y fija la hora y el ánimo del BlurbTM:
11 |
12 | blurb1.tiempo = Time.now
13 | blurb1.animo = :enfermo
14 |
15 | puts blurb1
16 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_50.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Di tu nombre
4 | answer: [a-zA-Z]{1,1}
5 | ok: Perfecto, has formado un string con las letras de tu nombre.
6 | error:
7 | ---
8 |
9 | Claro, los ordenadores son prácticos y rápidos para las matemáticas. Sigamos. ¿Quieres ver tu nombre al revés?
10 |
11 | Primero, teclea tu nombre entre comillas, así:
12 |
13 | "Juan"
14 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_60.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Di tu nombre al revés
4 | answer: \w+
5 | ok: neiB
6 | error:
7 | ---
8 |
9 | Un string es un conjunto de caracteres que el ordenador puede procesar. Imagina que las letras están
10 | en la cuerda de la colada, y que las comillas son las pinzas que sujetan los extremos. Las comillas marcan el principio y el final.
11 | Para dar la vuelta a tu nombre, teclea:
12 |
13 | "Juan".reverse
14 |
15 | (¡No te olvides del punto!)
16 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_70.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Contando letras
4 | answer: ^\d+$
5 | ok: Sí, length también es un 'método'
6 | error:
7 | ---
8 |
9 | Has usado el __método__ reverse en tu nombre. Has hecho un string escribiendo tu nombre entre comillas. Luego has llamado al método reverse, que trabaja con strings para darle la vuelta a todas las letras.
10 |
11 | Ahora, veamos cuántas letras tiene tu nombre:
12 |
13 | "Juan".length
14 |
--------------------------------------------------------------------------------
/translations/es/try_ruby_80.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ES
3 | title: Las Repeticiones
4 | answer: (\w+)
5 | ok: Encantado de conocerte.Encantado de conocerte.Encantado de conocerte.
6 | error:
7 | ---
8 |
9 | Probablemente te estés preguntando para qué vale todo esto.
10 |
11 | Bueno, seguro que has ido a un sitio web que te ha gritado: __¡Eh, tu contraseña es demasiado corta!__
12 |
13 | Algunos programas usan ese simple código: __.length__
14 |
15 | Mira esto. Multiplica tu nombre por 5:
16 |
17 | "Juan" * 5
18 |
--------------------------------------------------------------------------------
/translations/fr/try_ruby_10.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: 30 minutes de libre ? Essaie Ruby !
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Ruby est un language de programmation originaire du Japon qui a
11 | révolutionné le développement logiciel.
12 |
13 | La beauté de Ruby réside dans son équilibre entre simplicité et puissance.
14 |
15 | Tu peux saisir du code Ruby dans l'éditeur et utiliser les boutons suivants pour naviguer :
16 |
17 | - __Run__ → Executer le code dans l'éditeur
18 | - __Copy__ → Copier le code d'exemple dans l'éditeur
19 | - __Next__ → Basculer à la leçon suivante
20 | - __Back__ → Revenir à la leçon précédente
21 |
22 | Clique sur Next pour commencer à apprendre.
23 |
24 |
--------------------------------------------------------------------------------
/translations/fr/try_ruby_100.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Stop, t'es barge !
4 | answer: ^\d{1,}$
5 | ok: Seuls les strings peuvent être inversés
6 | error:
7 | ---
8 |
9 | On ne peut pas inverser le nombre quarante. J'imagine que tu
10 | pourrais tenir ton moniteur en face d'un mirroir, mais inverser un
11 | nombre n'est pas franchement très logique.
12 |
13 | Ruby a lancé un message d'erreur. Ruby t'explique qu'il n'y a pas de
14 | méthode pour inverser des nombres.
15 |
16 | Tu pourrais peut-être transformer ce nombre en string pour commencer :
17 |
18 | 40.to_s.reverse
19 |
--------------------------------------------------------------------------------
/translations/fr/try_ruby_110.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Les pommes ne sont pas des oranges.
4 | answer: \[\]
5 | ok: Parfait, voilà une liste vide.
6 | error:
7 | ---
8 |
9 | Et les nombres sont différents des strings.
10 |
11 | Bien qu'il soit possible d'utiliser des méthodes sur n'importe quel
12 | objet avec Ruby, certaines méthodes ne fonctionnent qu'avec certains
13 | types de choses. Mais il est toujours possible de passer d'un type à un
14 | autre avec les méthodes "to" to Ruby.
15 |
16 | - __to_s__ convertit les choses en __s__trings (chaîne de caractères)
17 | - __to_i__ convertit les choses en __i__ntegers (nombres entiers)
18 | - __to_a__ convertit les choses en __a__rrays (listes / tableaux)
19 |
20 | __Qu'est-ce qu'un array ?!__
21 |
22 | C'est une liste. Saisis une paire de crochets :
23 |
24 | []
25 |
--------------------------------------------------------------------------------
/translations/fr/try_ruby_120.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Faire la queue
4 | answer: ^\[(\d+)(,\s*\d+){3,}\]$
5 | ok: Excellent
6 | error: Essaye d'ajouter un quatrième nombre à la liste
7 | ---
8 |
9 | Les listes (arrays) stockent des choses __dans un ordre défini__.
10 |
11 | C'est un peu comme faire la queue pour acheter une baguette. Tu es
12 | derrière quelqu'un et ce sera impensable de les pousser pour passer
13 | devant, non? Et le mec derrière toi, tu gardes un œil sur lui, juste au
14 | cas où ?
15 |
16 | Voilà une liste pour toi. Des numéros de lotterie :
17 |
18 | [12, 47, 35]
19 |
20 | Essaie d'ajouter un nombre à cette liste: saisis une virgule après 35
21 | suivie d'un nombre. L'espace est facultatif.
22 |
--------------------------------------------------------------------------------
/translations/fr/try_ruby_130.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Un d'entre eux lève la main
4 | answer: ^47$
5 | ok: D'accord
6 | error:
7 | ---
8 |
9 | Une liste de numéros de lotterie. Lequel est le plus grand ?
10 |
11 | Essaye:
12 |
13 | [12, 47, 35].max
14 |
--------------------------------------------------------------------------------
/translations/fr/try_ruby_140.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Ranger une liste proprement
4 | answer: ^\[(\d+)(,\s*\d+){2,}\]$
5 | ok: Sauvegardé !
6 | error:
7 | ---
8 |
9 | Bien, bien. Cela dit c'est ennuyant d'avoir à retaper cette liste chaque
10 | fois que tu en as besoin, non ?
11 |
12 | Sauvegardons nos numéros dans un ticket comme ça :
13 |
14 | ticket = [12, 47, 35]
15 |
--------------------------------------------------------------------------------
/translations/fr/try_ruby_150.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Maintenant entre ticket
4 | answer: \[(\d+(, )?){2,}\]
5 | load: ticket = [12, 47, 35]
6 | ok: Réstoré!
7 | error:
8 | ---
9 |
10 | Maintenant, saisi:
11 |
12 | ticket
13 |
--------------------------------------------------------------------------------
/translations/fr/try_ruby_190.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Malheuresement, la poésie de biscotte c'est pas ton truc
4 | answer: (toast){0}
5 | load: prev
6 | ok: Excellent
7 | error: Ça sent toujours la biscotte pour moi
8 | ---
9 |
10 | Eh, c'est pas grave. T'es pas obligé d'aimer ça. Laisses toi aller et
11 | améliore mon poème. Au lieu d'une biscotte, tu peux essayer un melon
12 | pourquoi pas. Essaie de voir ce nouveau poème:
13 |
14 | poem.gsub("toast", "honeydew")
15 |
16 | La méthode __gsub__ est un raccourci pour *sub*stitution *g*lobale.
17 | Elle remplace toutes les instances du mot "toast" avec "honeydew".
18 |
--------------------------------------------------------------------------------
/translations/fr/try_ruby_20.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Utilisation de l'éditeur
4 | answer: ^\d{1,}$
5 | ok: Super ! Tu as fais un peu de maths. As-tu vu le résultat ?
6 | error: Entre 2 + 6 dans l'éditeur
7 | ---
8 |
9 | L'éditeur est l'endroit où tu tapes ton code Ruby, appuie sur le bouton __Run__
10 | et regarde le s'exécuter !
11 |
12 | Par exemple, essaie d'écrire des calculs. comme :
13 |
14 | 2 + 6
15 |
16 | La sortie de ton programme devrait s'afficher dans la fenêtre du bas.
17 | Il devrait également y avoir une ligne qui te dit comment tu t'en sors.
18 |
19 | > Autrement, tu peux appuyer sur le bouton __Copy__ pour copier le code d'exemple dans l'éditeur.
20 |
--------------------------------------------------------------------------------
/translations/fr/try_ruby_200.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Prêt, Viser
4 | answer: dnah ym morf nwolf sah tsaot yM
5 | load: prev
6 | ok: C'est plutôt logique. L'entièrement du poème a été inversé.
7 | error:
8 | ---
9 |
10 | Petite question : que se passe-t-il lorsque nous inversons entièrement "poem" (__poème__) ?
11 |
12 | poem.reverse
13 |
--------------------------------------------------------------------------------
/translations/fr/try_ruby_210.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Surplus d'inversion
4 | answer: ^\["More still did (.+)
5 | load: prev
6 | ok: Oui, c'est presque ce que nous voulons
7 | error:
8 | ---
9 |
10 | Tout le poème a donc été tourné à l'envers, lettre par lettre. Je voulais uniquement inverser les lignes.
11 | Mettre la dernière ligne en première et la première ligne en dernière.
12 |
13 | Inversé, mais pas __autant__ inversé.
14 |
15 | Voici comment:
16 |
17 | poem.lines.reverse
18 |
--------------------------------------------------------------------------------
/translations/fr/try_ruby_270.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Les Hashs vont de paires
4 | answer: ^\[".*"\]
5 | load: prev
6 | ok: Tu as trouvé les clés
7 | error:
8 | ---
9 |
10 | Garde à l'esprit que les hashes ne conservent pas les choses dans l'ordre. Ce n'est pas leur rôle. Ils associent simplement
11 | deux choses : une clé (__key__) et une valeur (__value__).
12 |
13 | Dans tes critiques, le titre du livre est la clé et la notation est la valeur.
14 |
15 | Si tu veux simplement voir les titres de tous les livres que tu as critiqués :
16 |
17 | livres.keys
18 |
19 | Tu peux aussi essayer cela avec .values au lieu de .keys.
--------------------------------------------------------------------------------
/translations/fr/try_ruby_290.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Un décompte
4 | answer: \w+
5 | ok: Houra!
6 | error:
7 | ---
8 |
9 | Une des choses étonnantes que nous venons d'utiliser est un bloc (__block__). Nous allons explorer cela plus en détail dans cette leçon et celle à venir. Mais, en gros, un bloc est un morceau de code Ruby entouré d'accolades '{' '}'.
10 |
11 | Essayons un autre bloc :
12 |
13 | 3.times { print "Hip! " }
14 |
15 | Les blocs sont toujours attachés à des méthodes. Comme la méthode __times__, qui prend le bloc et exécute le code à plusieurs reprises. (Dans notre exemple : trois fois.)
--------------------------------------------------------------------------------
/translations/fr/try_ruby_30.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Nombres et Mathématiques
4 | answer: ^[0-9\.,-]{1,}$
5 | ok: Parfait
6 | error:
7 | ---
8 |
9 | Ruby reconnaît les nombres et les symboles mathématiques. Tu peux essayer d'autres opérations mathématiques comme :
10 |
11 | 4 * 10
12 | 5 - 12
13 | 30 / 4
--------------------------------------------------------------------------------
/translations/fr/try_ruby_310.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Nous arrivons au resumé #4
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Cette dernière leçon était un peu plus longue. Tu as probablement utilisé environ trois minutes pour apprendre sur :
11 |
12 | ### Hashes
13 | Le petit dictionnaire avec les pages en boucle : __{}__
14 |
15 | ### Symbols
16 | De petits mots de code efficaces avec un deux-points, comme : __:splendide__
17 |
18 | ### Blocks
19 | Des morceaux de code qui peuvent être ajoutés à de nombreuses méthodes de Ruby. Voici le code que tu as utilisé pour construire une feuille de notation :
20 | __livres.values.each { |note| notations[note] += 1 }__
21 |
22 | ### La suite
23 | Dans la prochaine leçon, nous plongerons un peu plus profondément dans les méthodes.
--------------------------------------------------------------------------------
/translations/fr/try_ruby_350.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Le fruit mûr de ta création
4 | answer: ^Tamed a shrew
5 | ok: Ça leur apprendra, ces mégères (shrew)
6 | error:
7 | load: def tame(number_of_shrews);number_of_shrews.times{puts "Tamed a shrew"};end;
8 | ---
9 |
10 | Un nouveau méthode est née. Utilisons-la maintenant :
11 |
12 | tame 5
13 |
14 | > __P.S.__
15 | > Tamed a shrew = Mégère apprivoisée
--------------------------------------------------------------------------------
/translations/fr/try_ruby_370.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Bonjour, Qui est là ? Le résumé #5 fait signe de son chapeau !
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Bien joué, bien joué, bien joué, bien joué !
11 |
12 | Vraiment, vraiment, vraiment, vraiment, vraiiiiiiiiiment !
13 |
14 | Voici les dernières minutes de ta vie en revue :
15 |
16 | ### Méthodes
17 | Les méthodes peuvent être définies avec __def__ et ont un nom. Les méthodes rendent ton programme plus court
18 | et plus facile à lire.
19 |
20 | ### Paramètres
21 | Les méthodes peuvent avoir des paramètres.
22 |
23 | ### Valeurs de retour
24 | Les méthodes (presque toujours) retournent une valeur.
25 |
26 | ## Et Maintenant ?
27 | Être ou ne pas être n'est plus une question pour toi. Es-tu prêt pour un peu plus de Shakespeare ?
--------------------------------------------------------------------------------
/translations/fr/try_ruby_470.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Les éléments qui font une application
4 | answer:
5 | ok:
6 | error:
7 | ---
8 |
9 | Tu as crées une nouvelle classe BlurbTM. De quoi sont faits les articles de blog ?
10 | Le contenu (__content__), bien sûr. Mais aussi de l'heure à laquelle le BlurbTM a été publié (__time__). Et aussi une humeur (__mood__).
11 |
12 | Bien, tu as la première ligne de la classe, voici la suite :
13 |
14 | class Blurb
15 | attr_accessor :content, :time, :mood
16 | end
17 |
18 | Les noms de classe commencent toujours par une lettre majuscule.
19 |
20 | (Toujours pas de sortie)
--------------------------------------------------------------------------------
/translations/fr/try_ruby_490.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Un objet, ce petit paquet bien organisé.
4 | answer: Blurb:
5 | ok: Blurb mis à jour
6 | error:
7 | load: prev;blurb1=Blurb.new;blurb1.content="Aujourd'hui, le Mont Blanc a été volé !"
8 | ---
9 |
10 | A toi de jouer, définis le temps et l'humeur du BlurbTM :
11 |
12 | blurb1.time = Time.now
13 | blurb1.mood = :triste
14 |
15 | puts blurb1
--------------------------------------------------------------------------------
/translations/fr/try_ruby_50.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Dis ton nom
4 | answer: [a-zA-Z]{1,1}
5 | ok: Parfait, tu as formé une chaîne de caractères (string) à partir des lettres de ton nom.
6 | error:
7 | ---
8 |
9 | Bien sûr, les ordinateurs sont pratiques et rapides pour les calculs. Passons à autre chose : Veux-tu voir ton nom à l'envers ?
10 |
11 | Écris d'abord ton prénom entre guillemets comme ceci :
12 |
13 | "Jimmy"
14 |
--------------------------------------------------------------------------------
/translations/fr/try_ruby_60.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Dis ton nom à l'envers
4 | answer: \w+
5 | ok: ! iuO
6 | error:
7 | ---
8 |
9 | Une chaîne de caractères (string) est un ensemble de caractères que l'ordinateur peut traiter. Imagine que les lettres sont sur une corde
10 | à linge et que les guillemets sont des pinces à linge tenant les extrémités. Les guillemets marquent le début et la fin.
11 |
12 | Pour inverser ton nom, écris:
13 |
14 | "Jimmy".reverse
15 |
16 | (N'oublie pas le point !)
17 |
--------------------------------------------------------------------------------
/translations/fr/try_ruby_70.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Compter les lettres
4 | answer: ^\d+$
5 | ok: Oui. Length est aussi une 'methode'
6 | error:
7 | ---
8 |
9 | Tu as utilisé la __méthode__ reverse (__inverse__) sur ton nom ! En mettant ton nom entre guillemets, tu as créé une chaîne de caractères (string). Pour enfin appelé la méthode reverse qui fonctionne sur des chaînes de caractères (string) pour retourner toutes les lettres à l'envers.
10 |
11 | Maintenant, voyons combien de lettres il y a dans ton nom :
12 |
13 | "Jimmy".length
14 |
--------------------------------------------------------------------------------
/translations/fr/try_ruby_80.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: FR
3 | title: Répétition
4 | answer: (\w+)
5 | ok: EnchantéEnchantéEnchantéEnchantéEnchanté
6 | error:
7 | ---
8 |
9 | Maintenant, tu te demandes probablement à quoi tout cela peut servir.
10 |
11 | Et bien, je suis sûr que tu as déjà été sur un site web qui a gueulé : __Hé, ton mot de passe est trop court !__
12 |
13 | Tu as deviné ? certains programmes utilisent la méthode __.length__ (__longueur__) dans leur code.
14 |
15 | Voyons voir, et si essayait de multipler ton nom par 5.
16 |
17 | "Jimmy" * 5
18 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_10.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 30分ありますか? 今すぐRubyを試しましょう!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Rubyは日本発のプログラミング言語で、ソフトウェア開発に革命をもたらしています。
11 |
12 | Rubyの美しさはシンプルさと力強さの調和にあります。
13 |
14 | エディタ内でRubyのコードを書いて、次のボタンを使って移動できます。
15 |
16 | - __Run__ → エディタ内のコードを実行する
17 | - __Copy__ → 例のコードをエディタにコピーする
18 | - __Next__ → 次のレッスンに進む
19 | - __Back__ → 前のレッスンに戻る
20 |
21 | Next をクリックして学習をはじめましょう
22 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_100.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 止めて！おかしくなってしまったの？
4 | answer: ^\d{1,}$
5 | ok: 逆さまにできるのは文字列だけです
6 | error:
7 | ---
8 |
9 | 40という数を逆さまにはできません。
10 | モニタを鏡に向けて持ち上げることができるかもしれませんが、数字を逆さまにするということは理にかなっていません。
11 |
12 | Rubyはエラーメッセージを投げます。Rubyは数値を逆さまにするメソッドがないことを伝えています。
13 |
14 | あるいは、数値をまず文字列に変換すると良いかもしれません。
15 |
16 | 40.to_s.reverse
17 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_110.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 男の子とちがう女の子って
4 | answer: \[\]
5 | ok: 素晴らしい。これは空のリストです。
6 | error:
7 | ---
8 |
9 | 数値は文字列と異なります。
10 |
11 | Rubyでは任意のオブジェクトのメソッドを使用できますが、いくつかのメソッドは特定の種類でだけ動きます。
12 | けれど、Rubyの"to"メソッドを使えば、いつでもデータの種類を変換できます。
13 |
14 | - __to_s__ はデータを文字列(__s__tring)に変換します
15 | - __to_i__ はデータを整数(__i__nteger)に変換します
16 | - __to_a__ はデータを配列(__a__rray)に変換します
17 |
18 | __配列って何？！__
19 |
20 | 配列とはリストのことです。次のように、角かっこの対を入力してみてください。
21 |
22 | []
23 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_120.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 一列に並んで
4 | answer: ^\[([-\.\d]+)(\s*,\s*[-\d\.]+){3,}\]$
5 | ok: バッチリです
6 | error: リストの4番目に数値を追加してください
7 | ---
8 |
9 | リスト（配列）は__決まった順序で__ものを格納します。
10 |
11 | ポップコーンを買うために一列に並ぶようなものです。
12 | あなたは誰かの後ろに並んでいて、前にいる人たちを脇に押しやろうとは夢にも思っていません。ですよね？
13 | そして、後ろに並んでいる誰かにあなたは目を光らせている。でしょう？
14 |
15 | 次に示すのは、あなた専用のリストです。抽選番号のリストです。
16 |
17 | [12, 47, 35]
18 |
19 | このリストに数を1つ追加してください。
20 | 35のあとにカンマを入力し、続いて数を入力します。
21 | 空白を入力するかどうかは任意です。
22 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_130.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: だれか手を挙げて
4 | answer: ^47$
5 | ok: オーケー
6 | error:
7 | ---
8 |
9 | 抽選番号のリストがあります。いちばん大きな値はどれでしょう？
10 |
11 | 以下を試してみてください。
12 |
13 | [12, 47, 35].max
14 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_140.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: リストをしまい込む
4 | answer: ^\[(\d+)(,\s*\d+){2,}\]$
5 | ok: 保存しました！
6 | error:
7 | ---
8 |
9 | いい調子です。けれど、必要になるたびにリストを打ち直すのは気が滅入りますよね。
10 |
11 | ticketにリストを保存しましょう。次のようにします。
12 |
13 | ticket = [12, 47, 35]
14 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_150.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: ticketと入力してみる
4 | answer: \[(\d+(, )?){2,}\]
5 | load: ticket = [12, 47, 35]
6 | ok: 元の状態でした！
7 | error:
8 | ---
9 |
10 | では、入力してみましょう。
11 |
12 | ticket
13 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_160.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 保存して、しまい込みました
4 | answer: \[12, 35, 47\]
5 | load: ticket = [12, 47, 35]
6 | ok: リストをソートしました
7 | error:
8 | ---
9 |
10 | 抽選番号をメモし、それをticketという名前の__変数__にしまい込みました。
11 | ここで、変数の名前は_jimmyslist_のような別のものでも構いません。
12 |
13 | プログラミングとは、これからわかってくることだと思いますが、
14 | おおむね変数とうまくやるということです。
15 |
16 | 次に抽選番号を整列させてみましょうか。どうです？
17 |
18 | やり方は次の通りです。
19 |
20 | ticket.sort!
21 |
22 | リストを整列(sort)しました。変数ticketはもう変わっています。
23 | _sort!_メソッドのさいごに、大きく目立つ感嘆符があるのに気づきましたか？
24 | Rubyのメソッドは、しばしば変数の中身を変更してしまう時にこのように叫びます。
25 | ですがこれは何てことはない、ただの印です。
26 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_190.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 悲しいかな、トーストの詩が大嫌い
4 | answer: (toast){0}
5 | load: prev
6 | ok: すばらしい
7 | error: まだトーストの匂いがします
8 | ---
9 |
10 | ええ、大丈夫です。無理に好きになる必要はありません。お好きなようにハックしてください。
11 | トーストの代わりに、メロンや他の何かを使いましょう。
12 | 新しい詩を確認するために、次のコードを試してください。
13 |
14 | poem.gsub("toast", "honeydew")
15 |
16 | __gsub__メソッドはグローバル置換(global substitute)の略です。
17 | 上記はすべての"toast"を"honeydew"と置き換えます。
18 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_20.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: エディタを使う
4 | answer: ^\d{1,}$
5 | ok: よくできました! 計算が実行されました。出力された結果は見えていますか？
6 | error: エディタで 2 + 6 と入力してください
7 | ---
8 |
9 | 下にあるエディタウィンドウにRubyのコードを入力し、 __Run__ を押して実行されるのを見てみましょう!
10 |
11 | 例として、以下の様な数式を入力してみてください。
12 |
13 | 2 + 6
14 |
15 | プログラムの出力は、上にある出力ウィンドウに表示されます。
16 | また正しくできたかどうかを表示する行もあります。
17 |
18 | > あるいは、__Copy__ ボタンを押して例のコードをエディタにコピーすることもできます。
19 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_200.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 構えて、狙って
4 | answer: dnah ym morf nwolf sah tsaot yM
5 | load: prev
6 | ok: オーケー。詩全体が逆順に変わりました。
7 | error:
8 | ---
9 |
10 | ここで質問があります。
11 | この詩を丸ごと逆順にしたらどうなるでしょうか？
12 |
13 | poem.reverse
14 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_210.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: ひっくり返し過ぎました
4 | answer: ^\["More still did (.+)
5 | load: prev
6 | ok: いいですね、だいたい実現できました
7 | error:
8 | ---
9 |
10 | 句読点なども含めて、詩全体が逆順となってしまいました。
11 | 本当は行の順序をひっくり返したかったのです。
12 | 最後の行を最初に、最初の行は最後にするということです。
13 |
14 | 行は逆順にしますが、文自体は逆順に__しません__。
15 |
16 | どうやるかを次に示します。
17 |
18 | poem.lines.reverse
19 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_220.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: メソッドをつなげる
4 | answer: My toast has flown from my hand
5 | load: prev
6 | ok: いい感じですね！joinメソッドは、配列の各要素をつなげて、一つの文字列にしました。
7 | error:
8 | ---
9 |
10 | 何が確認できました？いったい何が起こりました？__poem.lines.reverse__と入力すると、何が起きたでしょう？
11 |
12 | 2つのことが起きました。linesを使って、詩を行ごとのリストにしました。
13 | linesは文字列を分解する方法を決定し、配列に変換します。
14 |
15 | では、さらにもう一つメソッドをつなげてみましょう。
16 |
17 | puts poem.lines.reverse.join
18 |
19 | このようにメソッドをつなげていくことを、__メソッド連鎖__といいます。
20 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_230.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: ここで、要約（その3）です
4 | answer: \{\}
5 | class: stretcher chapmark
6 | load: prev
7 | ok: 空のハッシュを作成しました！
8 | error:
9 | ---
10 |
11 | ### 感嘆符
12 | メソッドには、名前に感嘆符（もしくは疑問符）がつくものがあります。
13 | それらは、メソッドがどんな動きをするかを説明するためについているもので、どうということはありません。
14 |
15 | ### 文字列操作
16 | 文字列を検索し、置換しました。
17 |
18 | ### 連鎖
19 | メソッド連鎖をすると、より多くのことを一気におこなえます。
20 | 詩を分割し、逆順にし、ふたたび組み立てるために、__poem.lines.reverse.join__としました。
21 |
22 | もしかすると、もうちょっと詩をいじくってみたいですか？
23 | Stringのすべてのメソッド一覧はここにあります。
24 |
25 | 見に行ってみて、ちょっとだけ試してみてください。
26 | poem.downcaseやpoem.swapcaseなどをしてみると面白いかもしれません。
27 |
28 | ## 準備はいいですか？
29 | 次に行く準備が整ったら、次のように入力してください。
30 |
31 | books = {}
32 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_260.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 待って。Gravity's Rainbowは好きでしたっけ？
4 | answer: ^(splendid|quite_good|mediocre|quite_not_good|abysmal)$
5 | load: books = {"Gravitys Rainbow" => :splendid, "The deep end" => :abysmal, "Living colors" => :mediocre}
6 | ok: とても好きでした
7 | error:
8 | ---
9 |
10 | Rubyがすばらしい点のひとつに、名前がしばしば再利用されるという点があります。
11 | このおかげで、覚えておかないとならない名前は少なくなります。
12 |
13 | 配列から要素を取り出す際は、__puts ticket[1]__ のように数値を使う必要があったのを覚えてますか？
14 |
15 | ハッシュでも同様の方法で要素を取り出せます。ただし、数値ではなく名前を使用します。
16 |
17 | 古い書評を調べたくなったとします。ふたたび角かっこに書名を入力しましょう。けれどイコールから後ろは含めないでください。
18 | 次のようになります。
19 |
20 | puts books["Gravitys Rainbow"]
21 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_270.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: ハッシュはペア
4 | answer: ^\[".*"\]
5 | load: prev
6 | ok: キーを取り出しました
7 | error:
8 | ---
9 |
10 | 気をつけないといけないことがあります。ハッシュは順序を保持しません。
11 | それはハッシュの責務ではないからです。ハッシュはただ二つのものをペアにします。
12 | __キー__と__値__です。
13 |
14 | 書評を詰め込んだハッシュで言うと、書名がキーで評価が値です。
15 |
16 | もし評価した書籍の書名だけをすべて確認したいだけなら、次のようにします。
17 |
18 | books.keys
19 |
20 | .keysの代わりに.valuesを試すこともできます。
21 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_280.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 辛辣な書評をつけてしまった？
4 | answer: :mediocre
5 | load: books = {"Gravitys Rainbow" => :splendid, "The deep end" => :abysmal, "Living colors" => :mediocre, "Bumblebees" => :mediocre}
6 | ok: やった！すごいです。評価のスコアカードを作成しました
7 | error:
8 | ---
9 |
10 | 辛辣か不公平な書評をつけてしまいましたか？
11 | では、__ratings__という新しいハッシュを用意してスコアをつけていくようにしましょう。
12 |
13 | どうするかというと、そうですね、書評をカウントアップしていくことにします。以下を入力してください。
14 |
15 | ratings = Hash.new {0}
16 |
17 | books.values.each { |rate|
18 | ratings[rate] += 1
19 | }
20 |
21 | puts ratings
22 |
23 | コード中の棒線はパイプ文字です。キーボードだと、Enterキーの上あたりにあるはずです。
24 |
25 | このコードの_+= 1_という行は、値を1増やすという意味になります。
26 |
27 | ここで起きていることをぜんぶ理解できないとしても、心配しないでください。
28 | あとで明らかにしていきます。
29 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_290.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 数え上げる
4 | answer: \w+
5 | ok: Yodelay!
6 | error:
7 | ---
8 |
9 | たったいま使った、驚くべき新しい道具は__ブロック__です。
10 | ここから2つのレッスンでは、ブロックについて詳しく見ていくことにします。
11 | 基本的に、ブロックとは中かっこでくくられたRubyのコード片のことです。
12 |
13 | では、別のブロックも試してみましょう。
14 |
15 | 5.times { print "Odelay! " }
16 |
17 | ブロックは常にメソッドに渡されます。
18 | __times__メソッドのように、ブロックをとり、そのコード片を何回も実行したりします
19 | （上記の例は5回でした）。
20 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_30.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 数と数式
4 | answer: ^[0-9\.,-]{1,}$
5 | ok: よくできました
6 | error:
7 | ---
8 |
9 | Rubyは数と数学記号を理解できます。以下のような数式も入力してみましょう。
10 |
11 | 4 * 10
12 | 5 - 12
13 | 30 / 4
14 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_300.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: いまはいくつ？
4 | answer: ^[0-9]$
5 | ok: ちょうど良い回数、ブロックを実行しました！
6 | error: ブロックは0から9までの間で実行させてください
7 | ---
8 |
9 | ブロックを使った最初の例（評価をカウントしたプログラムです）で見たように、ブロックには値を渡すことができます。
10 | どんな値が__渡される__かは、ブロックを実行するメソッドによって決定されます。
11 |
12 | ブロックが__受け取った__値は、ブロックのはじめ、二つのパイプ文字（|）の間にある変数に置かれます。
13 |
14 | 次のブロックを使ったコードを試してみてください。
15 |
16 | 5.times { |time|
17 | puts time
18 | }
19 |
20 | ここでは、__.times__メソッドは変数__|time|__に値を送ります。
21 | time変数はブロックの中でしか参照できないということに注意してください。
22 |
23 | > ブロックのコードを複数行に分けて書くことができることに気づきましたか？こうすると、ちょっとばかりコードを読みやすくできます。
24 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_310.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 要約（その4）にたどり着きました
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | 最後のレッスンはちょっと長かったかもしれません。
11 | 以下のことを学ぶのに、だいたい3分くらいかかったでしょうか。
12 |
13 | ### ハッシュ
14 | ねじれたページ__{}__を持つ小さな辞書です。
15 |
16 | ### シンボル
17 | とても小さく効率的なコードで、__:splendid__のようにコロン付きの単語で表します。
18 |
19 | ### ブロック
20 | 多くのRubyのメソッドに付け加えることができるコード片です。
21 | スコアカードを組み立てるために使ったコードは、次のようなものでした。
22 | __books.values.each { |rate| ratings[rate] += 1 }__
23 |
24 | ### 次
25 | 次のレッスンではメソッドの内部についてもう少し深く掘り下げていこうと思います。
26 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_340.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: RubyでDef Leppardと書くとLeppardメソッドの定義になる
4 | answer: ^tame
5 | ok: ならしても、ダメにしない
6 | error:
7 | ---
8 |
9 | 大丈夫です。ちゃんとできました。あなたは独自のメソッドを定義しました。
10 | defに続いて、メソッドの名前を書きます。
11 | そして、必要な場合は、その後に引数のリストを書きます。
12 | けっして怖くないですし、危なくもありません！
13 | すべきことは、中身をRubyのコードで埋めて最後にendで終わることです。
14 |
15 | 以下に例を示します。
16 |
17 | def tame( number_of_shrews )
18 | number_of_shrews.times {
19 | puts "じゃじゃ馬をならしました"
20 | }
21 | end
22 |
23 | > __補足__
24 | > この章のタイトルにピンとこなかったでしょうか。
25 | > Def Leppard
26 | > はかつて有名だったイギリスのロックバンドです。
27 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_350.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 作成した熟成フルーツ
4 | answer: ^じゃじゃ馬をならしました
5 | ok: 飼いならされたじゃじゃ馬たちです
6 | error:
7 | load: def tame(number_of_shrews);number_of_shrews.times{puts "じゃじゃ馬をならしました"};end;
8 | ---
9 |
10 | 新しいメソッドが誕生しました。さっそく使ってみましょう。
11 |
12 | tame 5
13 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_360.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: ギブアンドテイク
4 | answer: \d+
5 | ok: いいです！ブラボー
6 | error:
7 | ---
8 |
9 | ほとんどのメソッドは、入力として複数のパラメータを必要とするだけでなく、__何かしらの値を戻します__。
10 | 先ほどのメソッドを少し変更して、戻り値を返すようにしました。以下を試してみてください。
11 |
12 | def tame( number_of_shrews )
13 | number_of_shrews.times {
14 | puts "Tamed a shrew"
15 | }
16 | return number_of_shrews
17 | end
18 |
19 | puts tame(3)
20 |
21 | ### return
22 | ここまでだいぶ先に進んできて、いろいろわかるようになってきたかと思います。ですので、ここではもう一つ別のヒントを出すことにしましょう。
23 | 上記のメソッドからは__return__という単語は省略できます。
24 | Rubyはメソッド内で評価された最後の値を自動的に返します。
25 |
26 | ですので、わたしたちは最後の行を__number\_of\_shrews__のように変更できます。
27 |
28 | なのですが、実は__.times__メソッドもまた_number\_of\_shrews_を返すので、最後の行をまったく取り除いてしまうことも可能です。つまり、実際には最初の実装でやりたかったことはすべてできてしまっていたのです！
29 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_370.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: やあ、誰がいますか？要約（その5）が帽子を振っています
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | よくやりました、よくやりました、よくやりました！
11 |
12 | ほんとうに、ほんとうに、ほんっとおぉぉぉぉぉに！
13 |
14 | 人生のもっとも直近の数分であなたがやったことを、ここでおさらいしましょう。
15 |
16 | ### メソッド
17 | メソッドは__def__のあとに名前を続けて定義します。
18 | メソッドはプログラムを短く、読みやすくできます。
19 |
20 | ### 引数
21 | メソッドは引数を持てます。
22 |
23 | ### 戻り値
24 | メソッドは（だいたいの場合）値を返します。
25 |
26 | ## 今
27 | 生きるべきか死ぬべきかはもう疑問ではなくなりました。
28 | シェイクスピアをもっと読む準備はできましたか？
29 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_40.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 異なる出力
4 | answer: ^[0-9\.,-]{1,}$
5 | ok: 正しく出力されました
6 | error:
7 | ---
8 |
9 | 数式をいくつか入力したのに、答えは最後の1つしか表示されなかったことに気づきましたか?
10 | 何が起こっているのでしょうか?
11 |
12 | > このWebサイトを使いやすくするため、プログラムの実行結果を
13 | > 上の出力用画面にコピーするようにしています。
14 | > なので、数式を入力すると、その結果が見られます。
15 | > __しかし、それは最後の結果だけです。__ そして出力が空だったときのみです。
16 |
17 | 2つ以上の数式を入力しても、Rubyは最後の数式の結果しか返してくれません。
18 |
19 | もちろん画面をコントロールすることもできます! それぞれの数式の前に __puts__ と(間に空白を入れて)入力してみましょう。
20 | putsは *'画面に何かを出力(put)する'* という意味になります。
21 |
22 |
23 | 以下を試してみましょう。
24 |
25 | puts 4 * 10
26 | puts 5 - 12
27 | puts 30 / 4
28 |
29 | 最後の数式のputsを削除して何が起こるか確認してみましょう。
30 |
31 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_440.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 腹ペコです
4 | answer: ^腹ペコじゃないです$
5 | ok: はい
6 | error: まさか10時にはお腹は空きませんよ！
7 | ---
8 |
9 | さて、ここまではとても順調に行っています。簡単だと感じたかもしれませんが、
10 | たった15分前までは__Rubyがいかなるものか__何も知らなかったことを覚えておいてください！
11 |
12 | 最後のステップです。ぜんぶを一つにしていきましょう。いいですか？
13 | 眩しい日差しの中、浜辺で光り輝くウィンドチャイムの響きのように、
14 | これまでやってきたことを調和させ、美しく奏でましょう！
15 |
16 | まず2つのメソッドを定義し、次に判定を行います。
17 |
18 | def hungry?(time_of_day_in_hours)
19 | puts "腹ペコです"
20 | true
21 | end
22 |
23 | def eat_an(what)
24 | puts "#{what}を食べます\n"
25 | end
26 |
27 | eat_an 'リンゴ' if hungry?(14)
28 |
29 | eat_an 'リンゴ' if hungry?(10)
30 |
31 | __hungry?__メソッドを、時間(引数で渡された値）が12未満だった場合に
32 | __"腹ペコじゃないです"__と表示してfalseを返すように変更できるか確かめてみてください。
33 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_450.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 要約（その6）まで来ました
4 | answer: \{\}
5 | class: stretcher chapmark
6 | ok: そうです。それが空のハッシュです
7 | error:
8 | ---
9 |
10 | あなたはレベル6のRuby聖職者です。偉大な仕事を為しました。確認していきましょう。
11 |
12 | ### データ
13 | インターネットからデータを読み込み、データ構造に変換し、値を選び出しました。
14 |
15 | ### 繰り返し
16 | ハッシュのすべての要素を繰り返し取り出し、さらにメソッドを連鎖させました。
17 |
18 | ### プリティプリント
19 | そして手に入った値が十分ではなかったので、人が読みやすい形に書式を整え、値を表示させました。
20 | つまり、__現実のプログラムを作りました！__
21 |
22 | ### if
23 | プログラムを__if__文と__else__文を使って制御する方法を学びました。
24 |
25 | ## そして
26 | 次は何でしょう？ここからは何を学ぶ必要があるでしょうか？
27 | これからが一番いいところです。
28 | あなたが進んできたのは、私たちがクラスを発見するまで辿ってきた長い道のりのようなものです。
29 | あと2つ、ここまで程は長くないレッスンをやれば、おしまいです。
30 |
31 | 以前、次のようなハッシュを作成しました。
32 |
33 | Hash.new
34 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_470.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: アプリを作るもの
4 | answer:
5 | ok:
6 | error:
7 | ---
8 |
9 | 新しくBlurbTMクラスを開きました。
10 | ブログエントリは一体何で作られるでしょう？そうです、コンテンツです。
11 | それからBlurbTMが投稿された時刻、そして気分も必要でしょう。
12 |
13 | 先ほどはクラスの最初の行を用意しました。以下が残りの部分になります。
14 |
15 | class Blurb
16 | attr_accessor :content, :time, :mood
17 | end
18 |
19 | クラス名は常に大文字から始まります。
20 |
21 | （まだ何も出力しません）
22 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_480.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: アクセサはぶらぶらとした手
4 | answer: Blurb:
5 | ok: はじめての手
6 | error:
7 | load: class Blurb;attr_accessor :content,:time,:mood;end
8 | ---
9 |
10 | なかなか素質がありますね。これで、新しいBlurbTMクラスを手に入れました。
11 |
12 | クラス定義の中で、attr\_accessorと呼ばれるメソッドを使いました。
13 | こうした属性(_attr_ibute)メソッドの多くは、クラスにわずかばかりの設定を加えます。
14 | これらの属性は、ちょうどクラスに付属する変数のようなものです。
15 |
16 | これがどういうことかを考えてみます。
17 | クラスは人のようなものです。星型の人を想像してください。
18 | そして属性は、体を構成し他の人との握手も可能にする、ぶらぶらとした手です。
19 |
20 | ### ここから
21 | BlurbTMを生成して、コンテンツを設定するために、以下のようにしてください。
22 |
23 | blurb1 = Blurb.new
24 | puts blurb1
25 | blurb1.content = "Today Mount Hood Was Stolen!"
26 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_490.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: オブジェクトとは、キチンとした小さなパッケージ
4 | answer: Blurb:
5 | ok: Blurbを更新しました
6 | error:
7 | load: prev;blurb1=Blurb.new;blurb1.content="Today Mount Hood Was Stolen!"
8 | ---
9 |
10 | 先に進み、BlurbTMに時刻と気分を設定してください。
11 |
12 | blurb1.time = Time.now
13 | blurb1.mood = :sick
14 |
15 | puts blurb1
16 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_50.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 名前を言ってみる
4 | answer: [a-zA-Z]{1,1}
5 | ok: 完ぺきです。名前を表す文字から文字列を作り出しました
6 | error:
7 | ---
8 |
9 | いいですね、コンピュータは計算を手軽にすばやく扱います。
10 | 次に移りましょう。逆さまになった名前を見てみたくないですか？
11 |
12 | まず、引用符のなかにあなたの苗字を入力してみてください。次のような感じです。
13 |
14 | "Jimmy"
15 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_500.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: ペースを速めて
4 | answer: ^\d{4}
5 | ok: 記録されました
6 | error:
7 | ---
8 |
9 | いい感じです。じゃあ、ちょっとだけ軽く何か作ってみましょう。
10 | BlurbTMするごとに毎回時間を設定したくはないでしょう。
11 |
12 | 内容の入力と気分の選択だけしたいですよね？
13 |
14 | __initialize__メソッドをクラスに追加しましょう。
15 | このメソッドは新しいBlurbTMがつくられるたびに呼び出されます。
16 | 同時に、BlurbTMの内容を40文字に制限することもできます。
17 |
18 | class Blurb
19 | attr_accessor :content, :time, :mood
20 |
21 | def initialize(mood, content="")
22 | @time = Time.now
23 | @content = content[0..39]
24 | @mood = mood
25 | end
26 | end
27 |
28 | Blurb.new(:sick).time
29 |
30 | （引数の__content=""__という部分は、内容が文字列であると確認するためにあります。
31 | こう書くことで、たとえcontent部分の引数が与えられなったとしても空文字が渡されます。）
32 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_510.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 意味ないものは拒むようにしつけました
4 | answer: Blurb:
5 | ok: Blurbが追加されました
6 | error:
7 | load: class Blurb;attr_accessor :content,:time,:mood;def initialize(mood, content="");@time=Time.now;@content=content[0..39];@mood=mood;end;end;blurb1=Blurb.new(:sick,"Today Mount Hood Was Stolen!")
8 | ---
9 |
10 | クラスの内側がどうなっているかを確認し、アットマークが付いたシンボル(@time)を使いました。
11 |
12 | クラスの__外側__では、アクセサを使います。
13 |
14 | > __blurb.time = Time.now__
15 |
16 | ですが、__内側__では__オブジェクトの変数__を使います。
17 |
18 | > __@time = Time.now__
19 |
20 | これらは実際には同じことです。しかしプログラムの2つの異なる場所では異なる表現を使います。
21 |
22 | ### 別のBlurbTMを作る
23 | 新しいBlurbTMを作成すると、initializeメソッドは新しい任意の引数用に使われます。
24 |
25 | あ、2つの引数が必要です。
26 |
27 | Blurb2 = Blurb.new :confused, "I can not believe Mt. Hood was stolen!"
28 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_520.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: キリンは要約（その7）を盗みません
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | load: prev;blurb2=Blurb.new :confused, "I can not believe Mt. Hood was stolen!"
9 | ---
10 |
11 | やっと、ここまできました。すべてを1つにしました。まだアプリを現実に近づけるつもりですが、その前にやったことを振り返りましょう。いいですか？
12 |
13 | ### クラス
14 | Rubyのすべてはオブジェクトです。クラスはオブジェクトを説明するもので、特定のオブジェクトがどう動くかを説明します。
15 | 例えば、いくつか新しいBlurbTMオブジェクトを作成したとすると、それらのオブジェクトはクラスによって説明されたということです。
16 | つまり、それらはBlubオブジェクトです。
17 | クラスを（ある種）現実世界のオブジェクトのモデルとして使うことができます。
18 |
19 | ### アクセサ
20 | アクセサは、オブジェクトの__外__から使うことのできる、オブジェクトに付けられた変数です。
21 | （blurb2.time = Time.now）
22 |
23 | ### オブジェクトの変数
24 | オブジェクト変数はアクセサで触れる変数と同じです。けれど、オブジェクトの__内側__にあります。
25 | （@time = Time.now）
26 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_60.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 名前を逆さまに言ってみる
4 | answer: \w+
5 | ok: たしまきでくよ
6 | error:
7 | ---
8 |
9 | コンピュータが処理できる文字の集まりのことを文字列といいます。
10 | 文字を一並びに干された洗濯物、引用符をその端をつまんでいる洗濯ハサミだと思ってください。
11 | 引用符は文字列のはじめとおわりを表します。
12 |
13 | 名前を逆さまにするには、つぎのように入力します。
14 |
15 | "Jimmy".reverse
16 |
17 | (ピリオドを忘れないで！)
18 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_70.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 文字数を数える
4 | answer: ^\d+$
5 | ok: そのとおり。lengthも'メソッド'です
6 | error:
7 | ---
8 |
9 | 名前を逆さまにする __メソッド__ を使いました！
10 | まず名前を引用符でくくり、文字列を作りました。
11 | そして文字列のreverseメソッドを呼び出しました。
12 | reverseメソッドは文字列のすべての文字を逆さまにひっくりかえす動きをします。
13 |
14 | それでは次に、名前が何文字かを表示させてみましょう。
15 |
16 | "Jimmy".length
17 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_80.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: 繰り返す
4 | answer: (\w+)
5 | ok: こんにちわ。こんにちわ。こんにちわ。
6 | error:
7 | ---
8 |
9 | 文字数が数えられると、どんないいことがあるの？と疑問に思っているかもしれません。
10 |
11 | ええと、Webサイトで __パスワードが短すぎます！__ と警告されたことがあるでしょう。
12 |
13 | そうした場面では、プログラムの中で __.length__ メソッドが使われていることがあります。
14 |
15 | 次に進みましょう。名前に5を掛けてみてください。
16 |
17 | "Jimmy" * 5
18 |
--------------------------------------------------------------------------------
/translations/ja/try_ruby_90.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: JA
3 | title: このくらいで要約（その1）にしましょう
4 | answer: NoMethodError|undefined|-e:in `eval'
5 | class: stretcher chapmark
6 | ok: いいえ、数を逆さまにはできません。'Next'を押してください
7 | error:
8 | ---
9 |
10 | ここまでの数分で学んだことを確認してみましょう。
11 |
12 | ### エディタ
13 | エディタにコードを入力しRunを押すと、出力ウィンドウに結果が出力されます。
14 | ほぼすべてのコードは、結果が表示されます。
15 |
16 | ### 数値と文字列
17 | 数値と文字列は、Rubyで計算やテキスト処理を行うためのオブジェクトです。
18 |
19 | ### メソッド
20 | reverseやlengthといった英語のメソッドを使いました。
21 | それと、乗算メソッド(\*)のような記号のメソッドも使いました。
22 | __メソッドは振る舞いを意味します！__
23 |
24 | ここまでやってきたことが学習の本質です。
25 | シンプルな物事を取り上げていじくり回すと、それらは新しい物事に変わります。
26 | 快適に進められていますか？そうであるよう望みます。
27 |
28 | ## オーケー
29 | ちょっとだけ不快なことをしてみましょう。数を逆さまにしてみてください。
30 |
31 | 40.reverse
32 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_10.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Имаш 30 минути? Започни со програмирање во Ruby веднаш!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Ruby е програмски јазик од Јапонија кој го револуционизира софтверскиот развој.
11 |
12 | Убавината на Ruby е во неговиот баланс помеѓу едноставноста и моќта.
13 |
14 | Можеш да пишуваш Ruby код во едиторот и можеш да ги користиш овие копчиња за навигација:
15 |
16 | - __Run__ → Го извршува кодот напишан во едиторот
17 | - __Copy__ → Го копира пример кодот напишан во едиторот
18 | - __Next__ → Те носи на следната лекција
19 | - __Back__ → Ти дозволува да се вратиш на претходната лекција
20 |
21 | Кликни Next да започнеш со учење.
22 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_100.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Стоп, ова е апсурдно!
4 | answer: ^\d{1,}$
5 | ok: Само стринговите можат да бидат прикажани во обратен редослед
6 | error:
7 | ---
8 |
9 | Не можеш да го прикажеш бројот четириесет во обратен редослед. Можеш да го држиш мониторот пред огледало, но прикажување на број во обратен редослед едноставно нема смисла.
10 |
11 | Ruby прикажа порака која ја објаснува грешката. Преку таа порака, Ruby ти кажува дека нема метод наречен reverse за броеви.
12 |
13 | Можеби ако прво го модифицираш бројот да биде стринг:
14 |
15 | 40.to_s.reverse
16 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_110.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Јаболката се различни од портокалите
4 | answer: \[\]
5 | ok: Одлично, ова е празна листа
6 | error:
7 | ---
8 |
9 | И броевите се различни од стринговите.
10 |
11 | Иако можеш да користиш методи врз било кој објект во Ruby, сепак некои методи единствено функционираат само за одредени типови.
12 | Но, секогаш можеш да извршиш конверзија помеѓу разни типови користејќи ги **to** методите во Ruby.
13 |
14 | - __to_s__ врши конверзија во стрингови (__s__ trings)
15 | - __to_i__ врши конверзија во цели броеви (__i__ ntegers)
16 | - __to_a__ врши конверзија во низи (__a__ rrays)
17 |
18 | __Што се низи?!__
19 |
20 | Низите се листи. Напиши пар од загради:
21 |
22 | []
23 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_120.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Чекање во ред
4 | answer: ^\[([-\.\d]+)(\s*,\s*[-\d\.]+){3,}\]$
5 | ok: Одлично
6 | error: Пробај да додадеш четврти број во низата
7 | ---
8 |
9 | Низите (листите) чуваат работи __во одреден редослед__.
10 |
11 | Како стоење во ред за пуканки. Ти си позади некој, и не ни помислуваш да го истуркаш на страна,
12 | нели? Исто, ја приметуваш личноста која стои позади тебе, нели?
13 |
14 | Еве листа за тебе. Броеви за лотарија:
15 |
16 | [12, 47, 35]
17 |
18 | Пробај да додадеш уште еден број во низата: стави запирка после 35 проследена со некој број. Празното место е опционално.
19 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_130.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Некој нека крене рака
4 | answer: ^47$
5 | ok: Супер
6 | error:
7 | ---
8 |
9 | Низа со броеви за лотарија. Кој од нив е најголем?
10 |
11 | Пробај го следново:
12 |
13 | [12, 47, 35].max
14 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_140.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Совладување на низи
4 | answer: ^\[(\d+)(,\s*\d+){2,}\]$
5 | ok: Зачувано!
6 | error:
7 | ---
8 |
9 | Ова е супер. Но, сигурно е здодевно да ја пишуваш повторно и повторно истата низа секогаш кога ќе ти притреба, нели?
10 |
11 | Ајде да ги зачуваме броевите внатре во **ticket**, како во примерот:
12 |
13 | ticket = [12, 47, 35]
14 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_150.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Сега, напиши Ticket
4 | answer: \[(\d+(, )?){2,}\]
5 | load: ticket = [12, 47, 35]
6 | ok: Низата е уште тука!
7 | error:
8 | ---
9 |
10 | Сега, напиши
11 |
12 | ticket
13 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_190.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: За жал, Toast поезијата не ти се допаѓа
4 | answer: (toast){0}
5 | load: prev
6 | ok: Прекрасно
7 | error: Сеуште ми мириса на toast мене
8 | ---
9 |
10 | Види, во ред е. Не мора да ти се допаѓа. Промени го, ако баш и сакаш. Наместо toast, оди по
11 | лубеница или нешто друго. Пробај го следново за да ја видиш новата поема:
12 |
13 | poem.gsub("toast", "honeydew")
14 |
15 | __gsub__ методот е скатено за глобална замена (анг. **global substitute**). Ги заменува сите прикажување на "toast" со
16 | "honeydew".
17 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_20.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Користење на едиторот
4 | answer: ^\d{1,}$
5 | ok: Одлично! Употреби малку математика. Примети ли како одговорот се прикажа одма?
6 | error: Напиши 2 + 6 во едиторот
7 | ---
8 |
9 | Едитор (анг. **Editor**) прозорецот во долниот десен агол е место за твојот Ruby код. Кликни на __Run__ копчето за го извршиш кодот!
10 |
11 | Можеш да започнеш со малку математика. На пример:
12 |
13 | 2 + 6
14 |
15 | Резултатот на твојата програма треба да се прикаже во прозорецот за резултат (анг. **Output**), сместен во горниот десен агол.
16 | Таму исто така треба да има бројка која ти покажува кој е резултатот од кодот.
17 |
18 | > Како алтернатива, можеш да кликнеш на __Copy__ за да го ископираш код примерокот во едиторот.
19 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_200.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Подготвен, нишани
4 | answer: dnah ym morf nwolf sah tsaot yM
5 | load: prev
6 | ok: Во ред. Целата поема е прикажана во обратен редослед.
7 | error:
8 | ---
9 |
10 | Прашање: што ќе се случи кога ќе ја прикажеме во обратен редослед целата поема?
11 |
12 | poem.reverse
13 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_210.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Премногу пресврти
4 | answer: ^\["More still did (.+)
5 | load: prev
6 | ok: Да, скоро до тоа што го посакуваме
7 | error:
8 | ---
9 |
10 | Значи, целата поема е прикажана во обратен редослед, буква по буква. Јас само сакав да ги прикажам
11 | редиците во обратен редослед.
12 | Да ги променам местата на последната редица со првата.
13 |
14 | Да наназад, но не __толку__ назад.
15 |
16 | Еве како:
17 |
18 | poem.lines.reverse
19 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_270.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Hash-овите како Парови
4 | answer: ^\[".*"\]
5 | load: prev
6 | ok: Ги пронајде клучевите
7 | error:
8 | ---
9 |
10 | Имај на ум дека hash-овите не ги чуваат работите во редослед. Тоа не е нивна работа. Нивната работа е
11 | само да направат пар од две работи: __клуч__ (анг. key) и __вредност__ (анг. value).
12 |
13 | Во твоите оцени, името на книгата претставува клуч, а рангот претставува вредност.
14 |
15 | Доколку сакаш да ги видиш само насловите од сите книги што си ги оценил, напиши:
16 |
17 | books.keys
18 |
19 | Можеш да го пробаш истово и со .values, наместо со .keys.
--------------------------------------------------------------------------------
/translations/mk/try_ruby_290.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Сума
4 | answer: \w+
5 | ok: Yodelay!
6 | error:
7 | ---
8 |
9 | Една од прекрасните нови работи кои сега ги искористивме е __блокот__ (анг. block). Ќе дознаеш повеќе за ова и во следната лекција. Но, во основа, блокот е мал Ruby код опкружен со __{ }__ наводници.
10 |
11 | Ајде да пробаме друг блок:
12 |
13 | 5.times { print "Odelay! " }
14 |
15 | Блоковите се секогаш поврзани за методи. Како кај __times__ методот, кој го зема блокот и го извршува
16 | одново и одново. (Во нашиот пример, пет пати.)
--------------------------------------------------------------------------------
/translations/mk/try_ruby_30.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Броеви и Математика
4 | answer: ^[0-9\.,-]{1,}$
5 | ok: Одлично
6 | error:
7 | ---
8 |
9 | Ruby препознава броеви и математички симболи. Можеш да пробаш и други операции, како:
10 |
11 | 4 * 10
12 | 5 - 12
13 | 30 / 4
--------------------------------------------------------------------------------
/translations/mk/try_ruby_310.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Стигнавме до Резиме #4
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Последнава лекција беше малку подолга. Најверојатно ти требаа три минути за да научиш:
11 |
12 | ### Hash-ови
13 | Синоним за малиот речник (анг. dictionary) со округли страни: __{ }__
14 |
15 | ### Симболи (анг. symbols)
16 | Мал, ефективен код од зборови, пред кои се ставаат две-точки, како: __:splendid__
17 |
18 | ### Блокови (анг. blocks)
19 | Делови код кој може да се прикачи на многу методи во Ruby. Следниот код го искористи за да го зачуваш резултатот:
20 | __books.values.each { |rate| ratings[rate] += 1 }__
21 |
22 | ### Следно
23 | Во следната лекција ќе учиме подетално за методи.
24 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_350.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Зрелите плодови на твојата креација
4 | answer: ^Tamed a shrew
5 | ok: That'll show those shrews
6 | error:
7 | load: def tame(number_of_shrews);number_of_shrews.times{puts "Tamed a shrew"};end;
8 | ---
9 |
10 | Нов метод е дефиниран. Ајде сега да го примениме:
11 |
12 | tame 5
13 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_370.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Здраво, кој е таму? Тука е Резимето #5!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Многу добро сторено, многу добро сторено, многу добро сторено, многу добро сторено!
11 |
12 |
13 | Навистина, навистина, навистина, навистина, навистинаааааа!
14 |
15 | Ова се последните минути од твојот живот во ретроспектива:
16 |
17 | ### Методи
18 | Методите се дефинираат со резервираниот збор __def__ и имаат име. Методите ја прават твојата
19 | програма пократка и полесна за читање.
20 |
21 | ### Параметри
22 | Методите може да имаат параметри.
23 |
24 | ### Return вредности
25 | Методите (скоро) секогаш враќаат вредност.
26 |
27 | ## Сега
28 | _Да се биде или не_ не е повеќе прашање за тебе. Дали си подготвен за прикажување
29 | повеќе од Шекспир?
30 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_440.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: МК
3 | title: Јас гладен
4 | answer: ^Јас не гладен
5 | ok: Yes
6 | error: Нема шанси да сум гладен во 10 часот наутро!
7 | ---
8 |
9 | Во ред, сѐ се вклопува одлично. Ова се едноставни работи за тебе, но запомни дека пред само 15 минути __немаше појма за Ruby__!
10 |
11 | Последен чекор. Ајде да сврземе сѐ заедно, може?
12 |
13 | Прво ќе дефинираме два методи, а потоа ќе донесеме одлука:
14 |
15 | def hungry?(time_of_day_in_hours)
16 | puts "Me hungry"
17 | true
18 | end
19 |
20 | def eat_an(what)
21 | puts "Me eat #{what}\n"
22 | end
23 |
24 | eat_an 'apple' if hungry?(14)
25 |
26 | eat_an 'apple' if hungry?(10)
27 |
28 | Сега, пробај да го смениш методот __hungry?__ да прикаже __"Јас не гладен"__ и да врати false кога времето е порано од 12 часот.
29 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_470.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: МК
3 | title: Работите кои ги сочинуваат апликациите
4 | answer:
5 | ok:
6 | error:
7 | ---
8 |
9 | Ти отвори нова BlurbTM класа. Од што се состои твојот елемент?
10 | Содржина (анг. content), се разбира. Исто така, треба да го зачуваш
11 | времето (анг. time) кога BlurbTM е креиран. И, расположение (анг. mood).
12 |
13 | Во ред, веќе ја имаш првата линија код од класата, еве го остатокот:
14 |
15 | class Blurb
16 | attr_accessor :content, :time, :mood
17 | end
18 |
19 | Името на класата секогаш започнува го голема буква.
20 |
21 | (Сеуште немаме резултат)
22 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_490.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: МК
3 | title: Објект, тоа мало убаво пакување
4 | answer: Blurb:
5 | ok: Blurb е ажуриран
6 | error:
7 | load: prev;blurb1=Blurb.new;blurb1.content="Today Mount Hood Was Stolen!"
8 | ---
9 |
10 | Те охрабрувам да пробаш да ставиш време и расположение на BlurbTM:
11 |
12 | blurb1.time = Time.now
13 | blurb1.mood = :sick
14 |
15 | puts blurb1
16 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_50.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Кажи ни го твоето име
4 | answer: [a-zA-Z]{1,1}
5 | ok: Совшрено, ти формираше стринг од буквите на твоето име
6 | error:
7 | ---
8 |
9 | Секако, компјутерите се корисни и брзи во математика. Ајде да продолжиме. Сакаш да го видиш твоето име напишано во обратен редослед?
10 |
11 | Прво напиши го твоето име во наводници, како во примерот:
12 |
13 | "Jimmy"
14 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_60.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Кажи ни го твоето име во обратен редослед
4 | answer: \w+
5 | ok: репуС
6 | error:
7 | ---
8 |
9 | Стрингот (анг. **String**) е сет од карактери кои компјутерот може да ги процесира. Замисли дека буквите се обесени на жица за алишта и наводниците се штипалки кои ги држат краевите. Наводниците го означуваат почетокот и крајот.
10 |
11 | За да го видиш твоето име во обратен редослед, напиши го следното:
12 |
13 | "Jimmy".reverse
14 |
15 | (Немој да ја заборавиш точката!)
16 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_70.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Броење на Букви
4 | answer: ^\d+$
5 | ok: Да. Length е исто така 'метод'
6 | error:
7 | ---
8 |
9 | Го искористи reverse __методот__ за твоето име! Со ставање на твоето име во наводници ти направи стринг. Потоа, го повика
10 | reverse методот, кој фунцкионира за стрингови и ги подредува буквите во обратен редослед.
11 |
12 | Сега, ајде да видиме од колку букви се содржи твоето име:
13 |
14 | "Jimmy".length
15 |
--------------------------------------------------------------------------------
/translations/mk/try_ruby_80.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: MK
3 | title: Повторувања
4 | answer: (\w+)
5 | ok: Мило ми е што те запознав.Мило ми е што те запознав.Мило ми е што те запознав.
6 | error:
7 | ---
8 |
9 | Сега, сигурно се прашуваш за што служи сето ова.
10 |
11 | Па, сигурно си посетил страна која скоро и да викала, __Извинете, вашата лозинка е премногу кратка!__
12 |
13 | Гледаш, некои програми користат многу едноставен __.length__ код.
14 |
15 | Погледни го ова. Ајде да го помножиме твоето име со бројот 5.
16 |
17 | "Jimmy" * 5
18 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_10.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Heb je 30 minuten over? Probeer Ruby eens uit!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Ruby is een programmeertaal uit Japan die software ontwikkeling op zijn kop zet!
11 |
12 | Het mooie van Ruby is de balans tussen eenvoud en kracht.
13 |
14 | Type wat Ruby code in de editor en gebruik de knoppen om TryRuby te bedienen:
15 |
16 | - __Run__ → Voert de code in de editor uit
17 | - __Copy__ → Kopieert de voorbeeld code naar de editor
18 | - __Next__ → Naar de volgende les
19 | - __Back__ → Ga terug naar de vorige les
20 |
21 | Klik op Next om te beginnen.
22 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_100.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Doe niet zo gek
4 | answer: ^\d{1,}$
5 | ok: Zie je, we kunnen alleen strings omdraaien
6 | error:
7 | ---
8 |
9 | Een nummer kan je niet omdraaien. Misschien kan je een spiegel naast je monitor houden,
10 | maar een nummer omdraaien kan echt niet.
11 |
12 | Ruby gaf daarom een foutmelding. Ruby wil je duidelijk maken dat er geen __reverse methode__
13 | bestaat voor nummers.
14 |
15 | Maar als je het nummer eerst eens om zou zetten naar een string:
16 |
17 | 40.to_s.reverse
18 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_130.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Kan ik mijn hand al opsteken ?
4 | answer: ^47$
5 | ok: Okee
6 | error:
7 | ---
8 |
9 | Ok, we hebben een lijst met bingo getallen. Wat is hoogste getal ?
10 |
11 | Probeer:
12 |
13 | [12, 47, 35].max
14 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_140.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Wie wat bewaart voor later
4 | answer: ^\[(\d+)(,\s*\d+){2,}\]$
5 | ok: Bewaard!
6 | error:
7 | ---
8 |
9 | Ok we hebben een lijst. Maar het is best wel irritant om die lijst iedere keer
10 | in te moeten typen als we 'em nodig hebben.
11 |
12 | We kunnen de lijst met bingo getallen bewaren op een kaart:
13 |
14 | kaart = [12, 47, 35]
15 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_150.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Tiep kaart
4 | answer: \[(\d+(, )?){2,}\]
5 | load: kaart = [12, 47, 35]
6 | ok: Opgehaald!
7 | error:
8 | ---
9 |
10 | En als je nu eens kaart intypt:
11 |
12 | kaart
13 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_20.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: De editor
4 | answer: ^\d{1,}$
5 | ok: Heel goed! Je hebt Ruby laten rekenen. Zag je het antwoord verschijnen ?
6 | error: Type 2 + 6 in de editor
7 | ---
8 |
9 | Het editor venster, rechtonder, is de plek om Ruby code in te voeren, tik daarna op de
10 | __Run__ knop om de resultaten te bekijken.
11 |
12 | Laten we eens beginnen met wat rekenwerk. Typ bijvoorbeeld dit in:
13 |
14 | 2 + 6
15 |
16 | De uitvoer van je programma zou in het 'output' venster rechtsboven moeten
17 | verschijnen.
18 | Als het goed is staat er ook een regel bij die je vertelt of je het goed hebt gedaan.
19 |
20 | > Je kunt trouwens ook op de __Copy__ knop klikken om de voorbeeldcode naar de editor te
21 | > kopiëren.
22 |
23 | Klik op __Next__ om naar de volgende les te gaan.
24 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_200.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Ready, Aim
4 | answer: dnah ym morf nwolf sah tsaot yM
5 | load: prev
6 | ok: Lijkt wel Latijn
7 | error:
8 | ---
9 |
10 | Even een vraagje: wat gebeurt er als we het hele gedicht omdraaien?
11 |
12 | vers.reverse
13 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_210.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Te veel van het goede
4 | answer: ^\["More still did (.+)
5 | load: prev
6 | ok: Ja, we zijn er bijna
7 | error:
8 | ---
9 |
10 | We hebben het hele vers omgedraaid, letter voor letter.
11 | Ik wilde eigenlijk alleen maar de volgorde van de regels omdraaien.
12 |
13 | Dus de regels achterstevoren. Niet de letters, dat zou achterlijk zijn.
14 |
15 | Zoiets:
16 |
17 | vers.lines.reverse
18 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_260.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Eh, wat vond ik ook al weer van De regenboog?
4 | answer: ^(uitstekend|quite_good|mediocre|quite_not_good|abysmal)$
5 | load: boeken = {"De regenboog" => :uitstekend, "Het puffertje" => :vreselijk, "Kleurenblind" => :matig}
6 | ok: O ja, ik vond het een meesterwerk
7 | error:
8 | ---
9 |
10 | Weet je nog hoe we een waarde uit een array haalden:
11 | __puts ticket[1]__.
12 |
13 | Bij een hash werkt dit hetzelfde, alleen gebruiken we geen nummer om een element op te zoeken
14 | maar een naam.
15 |
16 | Dus als je een oud boekverslag op wilt zoeken zet je nu de naam van het boek tussen de [ ]
17 | haken. En het = teken laten we weg:
18 |
19 | boeken["De regenboog"]
20 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_270.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: De hash als paar
4 | answer: ^\[".*"\]
5 | load: prev
6 | ok: Je hebt de sleutels gevonden
7 | error:
8 | ---
9 |
10 | In tegenstelling tot een array kent een hash geen volgorde van zijn elementen. Daar
11 | is een hash ook niet voor gemaakt.
12 |
13 | Een hash bevat alleen maar paren. Ieder paar bestaat uit een __sleutel__ en een
14 | __waarde__ (_key_ en _value_ in het Engels).
15 |
16 | In jouw boekverslagen is de titel van het boek de sleutel en de beoordeling is de waarde.
17 |
18 | Als je alle boektitels wilt zien kan je alle hash sleutels opvragen:
19 |
20 | boeken.keys
21 |
22 | Probeer dit ook eens met .values in plaats van .keys.
23 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_290.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Een blokje om
4 | answer: \w+
5 | ok: Yodelay!
6 | error:
7 | ---
8 |
9 | We hebben net een mooie en handige eigenschap van Ruby gebruikt, namelijk een __blok__.
10 | Daar gaan we in deze en de volgende les eens beter naar kijken.
11 |
12 | Heel simpel gezegd is een blok gewoon een stukje Ruby code dat tussen accolades { } staat.
13 |
14 | Hier heb ik nog een blok voor je:
15 |
16 | 5.times { print "Odelay! " }
17 |
18 | Een blok zit altijd vast aan een methode. In dit voorbeeld de __times__ methode.
19 | Times (keer) voert een blok meerdere keren uit. In dit geval 5 keer.
20 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_30.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Nummers en symbolen
4 | answer: ^[0-9\.,-]{1,}$
5 | ok: Klinkt goed
6 | error: Type 2 of 3 sommetjes
7 | ---
8 |
9 | Ruby herkent numbers en allerlei rekenkundige symbolen.
10 |
11 | Probeer nog eens wat sommetjes uit:
12 |
13 | 4 * 10
14 | 5 - 12
15 | 30 / 4
16 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_310.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Samenvatting 4 is hier
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Deel 3 duurde wat langer om door te nemen. Je hebt dit allemaal geleerd:
11 |
12 | ### Hash
13 | Een soort woordenboek met sleutels en waarden, die je maakt met: __{}__
14 |
15 | ### Symbolen
16 | Korte, duidelijke, efficiente woorden, die beginnen met een dubbele punt: __:uitstekend__
17 |
18 | ### Blokken
19 | Stukjes code die je aan allerlei Ruby methoden kunt hangen. Hiermee maakte je een
20 | scorelijst:
21 | __boeken.values.each { |beoordeling|
22 | scores[beoordeling] += 1
23 | }__
24 |
25 | ### En nu
26 | In de volgende lessen gaan we ons verder verdiepen in methoden.
27 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_350.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: De zoete vruchten van je eigen creatie
4 | answer: ^Een heks is getemd
5 | ok: Dat zal ze leren
6 | error:
7 | load: def tem( aantal_heksen );aantal_heksen.times{puts "Een heks is getemd"};end;
8 | ---
9 |
10 | En zo worden nieuwe methodes geboren.
11 |
12 | Ik wil 'em meteen gebruiken:
13 |
14 | tem 5
15 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_370.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Ben je er nog? Samenvatting 5 groet u
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Goed gedaan! Echt. Serieus. Ik meen het.
11 |
12 | Dit heb je in de afgelopen minuten geleerd:
13 |
14 | ### Methoden
15 | Methoden kan je definiëren met __def__ en een naam. Methodes zorgen ervoor dat je
16 | programma's korter en beter leesbaar zijn.
17 |
18 | ### Parameters
19 | Methodes kunnen parameters hebben.
20 |
21 | ### Return waarde
22 | Methodes geven (bijna) altijd een waarde terug.
23 |
24 | ## En verder
25 | To be or not to (be) weten we nu het antwoord wel op.
26 | Nog maar 3 delen te gaan.
27 | Interesse in meer Shakespeare?
28 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_470.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Bouwstenen
4 | answer:
5 | ok:
6 | error:
7 | ---
8 |
9 | Je hebt een nieuwe BlurbTM klasse gemaakt.
10 |
11 | Wat gaan we daar allemaal in bijhouden? De BlurbTM tekst uiteraard.
12 | En de datum en tijd van posten. En de stemming van de poster.
13 |
14 | We hebben de eerste regel van de klasse, dit is de rest:
15 |
16 | class Blurb
17 | attr_accessor :tekst, :tijd, :stemming
18 | end
19 |
20 | De naam van een klasse begint altijd met een hoofdletter.
21 |
22 | (Nog steeds geen output)
23 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_480.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Accessors, De Toegangspoorten
4 | answer: Blurb:
5 | ok: Mijn eerste Blurb
6 | error:
7 | load: class Blurb;attr_accessor :tekst,:tijd,:stemming;end
8 | ---
9 |
10 | Hee, grote klasse die BlurbTM klasse!
11 |
12 | In de klasse definitie staat een methode: __attr\_accessor__.
13 | Er zijn allerlei __attr__ibute methoden. Deze voegen wat eigenschappen toe aan je klasse.
14 | Attributen zijn gewoon variabelen die bij een klasse horen.
15 |
16 | De attr\_accessor methode die wij gebruikten betekent: iedereen heeft toegang (access)
17 | tot de klasse variabelen: tekst, tijd, en stemming.
18 |
19 | ### Dus
20 | Om een BlurbTM maken:
21 |
22 | blurb1 = Blurb.new
23 | puts blurb1
24 | blurb1.tekst = "Today Mount Hood Was Stolen!"
25 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_490.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Een Object, Een Pakketje
4 | answer: Blurb:
5 | ok: Blurb updated
6 | error:
7 | load: prev;blurb1=Blurb.new;blurb1.tekst="Today Mount Hood Was Stolen!"
8 | ---
9 |
10 | Maak de BlurbTM maar af. Voeg een tijd en stemming toe:
11 |
12 | blurb1.tijd = Time.now
13 | blurb1.stemming = :verdrietig
14 |
15 | puts blurb1
16 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_50.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Hoe heet je ?
4 | answer: [a-zA-Z]{1,1}
5 | ok: Mooi, je hebt een string gemaakt met alle letters van jouw naam
6 | error:
7 | ---
8 |
9 | Ja ja, computers zijn heel handig om mee te rekenen, maar dat kan mijn rekenmachine ook.
10 | Laten we eens wat anders doen. Wat dacht je van het verdraaien van je naam ?
11 |
12 | Type eerst je voornaam in de editor. Zet je naam wel tussen aanhalingstekens, bijvoorbeeld
13 | zoiets:
14 |
15 | "Jantje"
16 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_60.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Achterstevoren
4 | answer: \w+
5 | ok: deoG
6 | error:
7 | ---
8 |
9 | Een string is het Engelse woord voor reeks. Een string is dus gewoon een reeks tekens
10 | waar een computer iets mee kan.
11 |
12 | > Strings doen mij vaak denken aan een wasdrooglijn waaraan kleren hangen. De
13 | > aanhalingstekens aan het begin en einde zijn de wasknijpers.
14 |
15 | Om je naam om te draaien typ je:
16 |
17 | "Jantje".reverse
18 |
19 | (Vergeet de punt niet)
20 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_70.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Tellen maar
4 | answer: ^\d+$
5 | ok: Ja, 'length' is ook een methode
6 | error:
7 | ---
8 |
9 | Je hebt net je eerste __methode__ gebruikt.
10 | _Method_ op zijn Engels.
11 |
12 | Eerst maakte je een string door je naam tussen aanhalingstekens te zetten.
13 | Daarna gebruikte je de _reverse_ (omdraai) methode om de volgorde van alle
14 | letters van je naam om te draaien.
15 |
16 | Hoeveel letters zitten er eigenlijk in jouw naam ?
17 |
18 | "Jantje".length
19 |
--------------------------------------------------------------------------------
/translations/nl/try_ruby_80.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: NL
3 | title: Op herhaling
4 | answer: (\w+)
5 | ok: Aangenaam. Aangenaam. Aangenaam. Aangenaam. Aangenaam.
6 | error:
7 | ---
8 |
9 | Je vraagt je misschien af waar dit allemaal goed voor is.
10 |
11 | Je hebt vast wel eens ergens een wachtwoord moeten opgeven, om
12 | als antwoord te krijgen:
13 | __"Hee, je wachtwoord is te kort !"__
14 |
15 | Het programma van die website of app gebruikt ook zo'n simpele
16 | __lengte__ methode.
17 |
18 | Heb ik een leuk trucje voor. Vermenigvuldig je naam maar eens met vijf:
19 |
20 | "Jantje" * 5
21 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_10.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Tem 30 minutos? Dê uma chance ao Ruby agora!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Ruby é uma linguagem de programação criada no Japão que está revolucionando
11 | o desenvolvimento de software.
12 |
13 | A beleza do Ruby é encontrada em seu equilibrio entre simplicidade e poder.
14 |
15 | Você pode digitar algum código Ruby no editor e usar estes botões para navegar:
16 |
17 | - __Run__ → Executa o código que está no editor
18 | - __Copy__ → Copia o código de exemplo para o editor
19 | - __Next__ → Vai para a próxima lição
20 | - __Back__ → Retorna a lição anterior
21 |
22 | Clique em Next para iniciar o aprendizado.
23 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_100.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Pare, Você Está Latindo Como Um Louco!
4 | answer: ^\d{1,}$
5 | ok: Apenas strings podem ser invertidas
6 | error:
7 | ---
8 |
9 | Você não pode inverter o número 40. Eu acho que você pode segurar o seu monitor em frente a um espelho, mas inverter um número
10 | simplesmente não faz sentido.
11 |
12 | O Ruby lançou uma mensagem de erro. O Ruby está te dizendo que não há o método reverse para números.
13 |
14 | Talvez, se você tornar o número em uma string primeiro:
15 |
16 | 40.to_s.reverse
17 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_110.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Garotos São Diferentes de Garotas
4 | answer: \[\]
5 | ok: Ótimo, esta é uma lista vazia
6 | error:
7 | ---
8 |
9 | E números são diferentes de strings.
10 |
11 | Enquanto você pode usar métodos com qualquer objeto em Ruby, alguns métodos só funcionam com certos tipos de coisas.
12 | Mas você pode sempre converter diferentes tipos em Ruby usando os métodos "to".
13 |
14 | - __to_s__ converte coisas para __s__trings
15 | - __to_i__ converte coisas para __i__ntegers (números)
16 | - __to_a__ converte coisas para __a__rrays
17 |
18 | __O que são arrays?!__
19 |
20 | Eles são listas. Digite um par de colchetes:
21 |
22 | []
23 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_120.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Ficando na Fila
4 | answer: ^\[([-\.\d]+)(\s*,\s*[-\d\.]+){3,}\]$
5 | ok: Excelente
6 | error: Tente incluir um quarto número na lista
7 | ---
8 |
9 | Listas (arrays) guardam coisas __em alguma ordem__.
10 |
11 | É como ficar na fila para a pipoca. Você está atrás de alguém e você nem sonharia passar a frente dele,
12 | certo? E o cara atrás de você, você está de olho nele, certo?
13 |
14 | Aqui está uma lista para você. Números de loteria.
15 |
16 | [12, 47, 35]
17 |
18 | Tente adicionar um número a esta lista: digite uma virgula após o 35, então digite um número. O espaço é opcional.
19 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_130.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Um Levanta a Mão
4 | answer: ^47$
5 | ok: Ok
6 | error:
7 | ---
8 |
9 | Uma lista dos números da loteria. Qual é o maior?
10 |
11 | Tente:
12 |
13 | [12, 47, 35].max
14 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_140.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Colocando Uma Lista de Distância
4 | answer: ^\[(\d+)(,\s*\d+){2,}\]$
5 | ok: Salvo!
6 | error:
7 | ---
8 |
9 | Bom, bom. Mas é irritante ter que ficar digitando a lista toda vez que você precisar dela, não é?
10 |
11 | Vamos salvar os seus números dentro de um bilhete, assim:
12 |
13 | bilhete = [12, 47, 35]
14 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_150.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Agora Digite bilhete
4 | answer: \[(\d+(, )?){2,}\]
5 | load: bilhete = [12, 47, 35]
6 | ok: Restaurado!
7 | error:
8 | ---
9 |
10 | Agora, digite:
11 |
12 | bilhete
13 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_190.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Infelizmente, Você Odeia Poemas de Torradas
4 | answer: (torrada){0}
5 | load: prev
6 | ok: Excelente
7 | error: Continua cheirando a torrada para mim
8 | ---
9 |
10 | Olha, tudo bem. Você não tem que gostar disso. Hackeie isso, seja meu convidado. Ao invés de torrada,
11 | vá para melão ou algo do tipo. Tente isso para ver o novo poema:
12 |
13 | poema.gsub("torrada", "manga")
14 |
15 | O método __gsub__ é abreviação para substituição global. Ele substitui todas as ocorrências de "torrada" para
16 | "manga"
17 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_20.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Usando o editor
4 | answer: ^\d{1,}$
5 | ok: Ótimo! Você fez um pouco de matemática. Viu como a resposta apareceu?
6 | error: Digite 2 + 6 no editor
7 | ---
8 |
9 | A janela de edição na parte inferior é onde você digita o seu código Ruby, clique no botão __Run__
10 | e veja o seu código rodar!
11 |
12 | Por exemplo, tente digitar alguma expressão matemática. Como:
13 |
14 | 2 + 6
15 |
16 | A saída do seu programa será exibida na janela de saída na parte superior.
17 | Também deverá ter uma linha que lhe dirá o quão bem você fez.
18 |
19 | > Alternativamente, você pode apertar o botão __Copy__ para copiar todo o exemplo para o editor.
20 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_200.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Pronto, Mire
4 | answer: oãm ahnim ad uoov adarrot ahniM
5 | load: prev
6 | ok: Ok, claro. Então todo o poema foi invertido.
7 | error:
8 | ---
9 |
10 | Eis a questão: o que acontece quando nós invertemos todo o poema?
11 |
12 | poema.reverse
13 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_210.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Muita inversão
4 | answer: ^\["Mais ainda (.+)
5 | load: prev
6 | ok: Sim, quase o que queremos
7 | error:
8 | ---
9 |
10 | Então, todo o poema foi invertido, letra por letra. Eu realmente desejo inverter apenas as linhas.
11 | Fazer com que a última linha seja a primeira, e a primeira seja a última.
12 |
13 | De trás para frente, mas não __este__ de trás pra frente.
14 |
15 | Veja como:
16 |
17 | poema.lines.reverse
18 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_270.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Hashes como pares
4 | answer: ^\[".*"\]
5 | load: prev
6 | ok: Você encontrou as chaves
7 | error:
8 | ---
9 |
10 | Tenha em mente que hashes não mantém as coisas ordenadas. Este não é o trabalho dele. Ele apenas
11 | faz pares, os pares são: uma __key__ (chave) e um __value__ (valor).
12 |
13 | Em suas análises, o título do livro é a __key__, e a classificação é o __value__.
14 |
15 | Se você desejar ver apenas os titulos de todos os livros que você já análisou:
16 |
17 | livros.keys
18 |
19 | Você também pode tentar isso com .values ao invés de .keys.
20 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_290.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Um Cálculo
4 | answer: \w+
5 | ok: Yodelay!
6 | error:
7 | ---
8 |
9 | Uma das coisas incríveis que nós acabamos de usar é o __bloco__. Nós vamos explorar mais isso
10 | nesta e na próxima lição. Mas, basicamente, um bloco é um pedaço de código Ruby cercado por chaves {}.
11 |
12 | Vamos tentar outro bloco:
13 |
14 | 5.times { print "Odelay! " }
15 |
16 | Blocos são sempre associados a métodos. Como o método __times__, que pega o bloco e roda o código
17 | dele várias e várias vezes. (No nosso exemplo: cinco vezes).
18 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_30.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Numeros e Matemática
4 | answer: ^[0-9\.,-]{1,}$
5 | ok: Bom
6 | error:
7 | ---
8 |
9 | O Ruby reconhece números e símbolos matemáticos. Você pode tentar outras expressões matemáticas, como:
10 |
11 | 4 * 10
12 | 5 - 12
13 | 30 / 4
14 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_310.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Agora Desembarcando no Sumário #4
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Esta última lição é um pouco mais longa. Você provavelmente usou três minutos aprendendo sobre:
11 |
12 | ### Hashes
13 | O pequeno dicionário com páginas chaves: __{}__
14 |
15 | ### Símbolos
16 | Pequenos, eficientes palavras de código com dois pontos, como: __:esplendido__
17 |
18 | ### Blocos
19 | Trechos de código que podem ser usados com muitos métodos do Ruby. Aqui o código usado para
20 | construir o scorecard:
21 | __livros.values.each { |classificacao| classificacoes[classificacao] += 1 }__
22 |
23 | ### Próximo
24 | Na próxima lição nós iremos entrar um pouco mais a fundo nos métodos.
25 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_350.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: O Amadurecido Fruto de Sua Própria Criação
4 | answer: ^Megera domada
5 | ok: Isso vai mostrar essas megeras
6 | error:
7 | load: def domar(numero_de_megeras);numero_de_megeras.times{puts "Megera domada"};end;
8 | ---
9 |
10 | Um novo método nasceu. Vamos usa-lo agora:
11 |
12 | domar 5
13 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_370.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Olá, Quem Está Ai? E Sumário #5 Segura o Chapéu!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Muito bem, muito bem, muito bem, muito bem!
11 |
12 | Verdadeiramente, verdadeiramente, verdadeiramente, verdadeiramente, verdadeirameeeeeente!
13 |
14 | Aqui estão os últimos minutos da nossa vida revisados:
15 |
16 | ### Métodos
17 | Métodos podem ser definidos com __def__ e têm um nome. Métodos tornam os seus programas mais curtos
18 | e fáceis de ler.
19 |
20 | ### Parâmetros
21 | Métodos podem receber parâmetros.
22 |
23 | ### Retornar valores
24 | Métodos (quase) sempre retornam valores.
25 |
26 | ## Agora
27 | (Ser) ou não (ser) não é mais uma dúvida para você. Você está pronto para um pouco mais de Shakespare?
28 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_470.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: As Coisas Das Quais Os Apps São Feitos
4 | answer:
5 | ok:
6 | error:
7 | ---
8 |
9 | Você abriu a nova BlurbTM class. Do que a entrada do seu blog é feita?
10 | De conteúdo, claro. Também, a hora em que o BlurbTM foi postado. E o humor.
11 |
12 | Ok, então você tem a primeira linha da sua classe, aqui está o resto:
13 |
14 | class Blurb
15 | attr_accessor :conteudo, :hora, :humor
16 | end
17 |
18 | Nomes de classes sempre começam com letra maiúscula.
19 |
20 | (Continua sem saída na tela)
21 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_490.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Um Objeto, Este Pequeno Pacote Puro
4 | answer: Blurb:
5 | ok: Blurb Atualizado
6 | error:
7 | load: prev;blurb1=Blurb.new;blurb1.conteudo="Hoje, Mount Hood foi Roubado!"
8 | ---
9 |
10 | Vá em frente e defina o tempo e o humor do seu BlurbTM:
11 |
12 | blurb1.tempo = Time.now
13 | blurb1.humor = :doente
14 |
15 | puts blurb1
16 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_50.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Diga o seu nome
4 | answer: [a-zA-Z]{1,1}
5 | ok: Perfeito, você formou uma string com as letras do seu nome
6 | error:
7 | ---
8 |
9 | Claro, computadores são práticos e rápidos para operações matemáticas. Vamos continuar. Gostaria de ver o seu nome invertido?
10 |
11 | Primeiro digite o seu nome, entre aspas, desta forma:
12 |
13 | "Ricardo"
14 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_60.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Diga o seu nome de trás para frente
4 | answer: \w+
5 | ok: moB
6 | error:
7 | ---
8 |
9 | Uma string é um conjunto de caracteres que o computador consegue processar. Imagine que as
10 | letras estão em um varal de roupas, e as aspas são os pregadores segurando as extremidades.
11 | As aspas marcam o ínicio e o fim da string.
12 |
13 | Para inverter o seu nome, digite:
14 |
15 | "Ricardo".reverse
16 |
17 | (Não se esqueca do ponto!)
18 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_70.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Contando Letras
4 | answer: ^\d+$
5 | ok: Sim. Length também é um 'método'
6 | error:
7 | ---
8 |
9 | Você já usou o __método__ reverse no seu nome! Ao colocar seu nome entre aspas, você criou uma string. Então você chamou o método reverse, que
10 | funciona com strings e inverte a posição de todas as letras, deixando a string de trás para frente.
11 |
12 | Agora, vejamos quantas letras tem em seu nome:
13 |
14 | "Ricardo".length
15 |
--------------------------------------------------------------------------------
/translations/pt-br/try_ruby_80.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: PT-BR
3 | title: Na repetição
4 | answer: (\w+)
5 | ok: É um prazer conhece-lo.É um prazer conhece-lo.É um prazer conhece-lo.
6 | error:
7 | ---
8 |
9 | Agora, você provavelmente está se perguntando qual é a utilidade disto.
10 |
11 | Bem, eu tenho certeza que você já visitou alguma página que gritou: __"Ei, sua senha é muito curta!"__
12 |
13 | Viu? Alguns programas usam este simples código __.length__.
14 |
15 | Veja isso. Vamos múltiplicar seu nome por 5.
16 |
17 | "Ricardo" * 5
18 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_10.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Есть 30 минут? Дай Ruby шанс, и он тебя удивит!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Ruby - это язык программирования из Японии, который произвел революцию в веб-разработке.
11 |
12 | Прелесть Ruby в балансе между простотой и возможностями.
13 |
14 | Ты можешь ввести код на Ruby в редакторе и использовать кнопки для навигации:
15 |
16 | - __Run__ → Выполнить код, находящийся в редакторе
17 | - __Copy__ → Вставить/скопировать пример кода в редактор
18 | - __Next__ → Перейти к следующему уроку
19 | - __Back__ → Вернуться к предыдущему уроку
20 |
21 | Нажми Next для начала обучения.
22 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_100.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Остановись, ты сумасшедший!
4 | answer: ^\d{1,}$
5 | ok: Только строки могут быть развернуты задом наперед
6 | error:
7 | ---
8 |
9 | Ты не можешь развернуть число задом наперед. Я думаю, Вы, конечно можете держать монитор перед зеркалом, но разворачивание числа просто не имеет смысла.
10 |
11 | Ruby выведет сообщение с ошибкой. Ruby говорит Вам, что не существует метода reverse для чисел.
12 |
13 |
14 | Но можно попробовать преобразовать число 40 в строку для начала:
15 |
16 | 40.to_s.reverse
17 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_110.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Яблоки отличаются от апельсинов
4 | answer: \[\]
5 | ok: Отлично. Это пустой список.
6 | error:
7 | ---
8 |
9 | И числа отличаются от строк.
10 |
11 | В то время как использование методов применимо ко всем типам, некоторые методы работают только с определенными типами данных.
12 | Но Вы всегда можете преобразовать один тип в другой, используя методы вида "to"
13 |
14 | - __to_s__ преобразует в строки
15 | - __to_i__ преобразует в число
16 | - __to_a__ преобразует в массив
17 |
18 | __Что такое массив?!__
19 |
20 | Массив - это всего лишь список. Наберите 2 квадратные скобки:
21 |
22 | []
23 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_120.md:
--------------------------------------------------------------------------------
1 |
2 | ---
3 | lang: RU
4 | title: Очередь за попкорном
5 | answer: ^\[([-\.\d]+)(\s*,\s*[-\d\.]+){3,}\]$
6 | ok: Прекрасно!
7 | error: Попробуйте добавить четвертое число в массив.
8 | ---
9 |
10 | Списки (массивы) хранят элементы __в определенной последовательности__.
11 |
12 | Похоже на очередь за попкорном. Вы стоите за кем-то и не пытаетесь его оттолкнуть или передвинуть, верно?
13 | Также человек за Вами
14 |
15 | Вот список для Вас. Номера лотерейных билетов:
16 |
17 | [12, 47, 35]
18 |
19 | Попробуйте добавить число в массив. Наберите запятую и число после 35. Пробел не обязательно.
20 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_130.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Первый поднимает руку
4 | answer: ^47$
5 | ok: Хорошо
6 | error:
7 | ---
8 |
9 | Список номеров лотерейных билетов. А какой номер максимальный?
10 |
11 | Попробуйте:
12 |
13 | [12, 47, 35].max
14 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_140.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Спрячем список
4 | answer: ^\[(\d+)(,\s*\d+){2,}\]$
5 | ok: Сохранено!
6 | error:
7 | ---
8 |
9 | Хорошо, хорошо. Но неудобно же набирать каждый раз, когда он может понадобиться, не так ли?
10 |
11 | Давайте сохраним наши номера лотерейного билета вот так:
12 |
13 | ticket = [12, 47, 35]
14 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_150.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: А теперь наберите ticket
4 | answer: \[(\d+(, )?){2,}\]
5 | load: ticket = [12, 47, 35]
6 | ok: Восстановлен!
7 | error:
8 | ---
9 |
10 | А сейчас наберите:
11 |
12 | ticket
13 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_160.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Сохранен и спрятан
4 | answer: \[12, 35, 47\]
5 | load: ticket = [12, 47, 35]
6 | ok: Вы отсортировали список!
7 | error:
8 | ---
9 |
10 | Вы положили список номеров в __переменную__, называющуюся ticket.
11 | Но любое другое имя, такое как _ivanslist_, по-прежнему свободно.
12 |
13 | Занимаясь программированием, Вы заметите, что основная работа связана с переменными
14 |
15 | А давайте упорядочим список лотерейных билетов?
16 |
17 | Используйте:
18 |
19 | ticket.sort!
20 |
21 | У Вас есть список. Вы отсортировали список. Переменная ticket изменилась.
22 | А Вы заметили, что у метода __sort!__ на конце стоит восклицательный знак?
23 | Так Ruby сообщает нам, что переменная ticket будет изменена.
24 | Ничего необычного, просто запомните!
25 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_190.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: К сожалению, Вам не понравилась поэзия :(
4 | answer: (toast){0}
5 | load: prev
6 | ok: Прекрасно!
7 | error:
8 | ---
9 |
10 | Все в порядке. Это не обязательно должно было понравиться Вам. Попробуйте его, будьте моим гостем. Вместо тоста может быть
11 | пирог или что угодно. Попробуйте это, чтобы увидеть новый вариант поэмы:
12 |
13 | poem.gsub("тост", "медовик")
14 |
15 | Метод __gsub__ это сокращение global substitute (заменитель). Он заменяет все совпадения "тост" на
16 | "медовик".
17 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_20.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Использование редактора
4 | answer: ^\d{1,}$
5 | ok: Отлично! Вы немного попрактиковались в математике.
Видите полученный результат?
6 | error: Наберите 2 + 6 в редакторе
7 | ---
8 |
9 | Набирайте свой код на Ruby в окне редактора снизу, затем нажмите кнопку __Run__ и посмотрите его работу!
10 |
11 | Например, попробуем посчитать простое выражение:
12 |
13 | 2 + 6
14 |
15 | Результат вашей программы должен отображаться в окне вывода вверху.
16 | На следующей строке будет отображаться, настолько хорошо Вы справились.
17 |
18 |
19 | > Также Вы можете нажать кнопку __Copy__, чтобы скопировать код из примера в редактор.
20 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_200.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Готов, целься!
4 | answer: икур йеом зи летелыв тсот йоМ
5 | load: prev
6 | ok: Конечно, все стихотворение развернуло задом наперед.
7 | error:
8 | ---
9 |
10 | Вот вопрос, что произойдет:
11 |
12 | poem.reverse
13 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_210.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Слишком много слов наоборот
4 | answer: ^\["После того, как я (.+)
5 | load: prev
6 | ok: Да, то что нужно!
7 | error:
8 | ---
9 |
10 | Что ж, все стихотворение стало задом наперед. Слово за словом! Но я хочу всего лишь сделать это для строк.
11 | Переместим первую строку в конец, а последнюю в начало.
12 |
13 | Теперь делаем так:
14 |
15 | poem.lines.reverse
16 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_220.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Еще немного методов
4 | answer: Мой тост вылетел из моей руки
5 | load: prev
6 | ok: Отлично, мой друг!
Метод join взял строки из этого массива и соединил их в строку.
7 | error:
8 | ---
9 |
10 | Что Вы видите? Что произошло? Вы набрали __poem.lines.reverse__ и что случилось?
11 |
12 | Два события произошло. Первое: вы разбили стихотворения на строки, используя метод lines,
13 | и получили массив из них.
14 |
15 | Затем Вы развернули этот лист задом наперед. Вот и все!
16 |
17 | Давайте добавим еще один метод в конец:
18 |
19 | puts poem.lines.reverse.join
20 |
21 | Комбинирование методов называется: цепочка методов.
22 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_270.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Словари это пары
4 | answer: ^\[".*"\]
5 | load: prev
6 | ok: Вы нашли ключи
7 | error:
8 | ---
9 |
10 | Помните, что словари не хранят элементы в последовательности. Это не их задача.
11 | Они создают пару: ключ(key) : значение(value)
12 |
13 | В ваших отзывах, название книги - это ключ, а оценка - значение.
14 |
15 | Если вы хотите увидеть все названия книг, введите:
16 |
17 | books.keys
18 |
19 | Также попробуйте использовать .values вместо .keys.
20 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_290.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Подсчет
4 | answer: .+
5 | ok: Ура!
6 | error:
7 | ---
8 |
9 | Одна из потрясающих вещей, которую мы использовали это __block(блок)__. Мы изучим подробнее в
10 | этом и следующем уроке. Но, в основном, блок - это немного кода на Ruby, окруженного фигурными
11 | скобками.
12 |
13 | Давайте попробуем создать другой блок:
14 |
15 | 5.times { print "Ура! " }
16 |
17 | Блоки всегда привязаны к методам. Как метод __times__, который берет блок и запускает
18 | код снова и снова. (В нашем примере: пять раз.)
19 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_30.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Числа и математика
4 | answer: ^[0-9\.,-]{1,}$
5 | ok: Хорошо!
6 | error:
7 | ---
8 |
9 | Ruby понимает числа и математические операции. Попробуйте их использовать, как в примере:
10 |
11 | 4 * 10
12 | 5 - 12
13 | 30 / 4
14 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_300.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Есть минутка?
4 | answer: [0-9]$
5 | ok: Ты сделал все верно!
6 | error: Выполните блок 0-9 раз
7 | ---
8 |
9 | Как мы видели в первом примере с блоком (при подсчете оценок), мы можем передать значение блоку. Значение, которое
10 | вставляется определяется методом, который запускает блок.
11 |
12 | Значения, которые __принимает__ блок, помещаются в имя переменной в начале блока,
13 | между двумя символами pipe: |
14 |
15 | Попробуем это с помощью этого блока:
16 |
17 | 5.times { |time|
18 | puts time
19 | }
20 |
21 | Здесь метод __.times__ отдает значение переменной __|time|__. Но имейте в виду, что эта переменная известна
22 | только внутри блока
23 |
24 | > Заметили, что вы можете писать код на нескольких строках?
--------------------------------------------------------------------------------
/translations/ru/try_ruby_310.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Подводя итоги #4
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Этот урок был немного длиннее. Вы, вероятно, потратили на три минуты больше на его изучение:
11 | ### Словари
12 | Самый простой пример словаря: __{}__
13 |
14 | ### Символы
15 | Крошечные, эффективные кодовые слова с двоеточием, например: __:splendid__
16 |
17 | ### Блоки
18 | Куски кода, которые можно привязать ко многим методам Ruby. Вот код, который вы использовали для
19 | создания таблицы оценок:
20 | __books.values.each { |rate| ratings[rate] += 1 }__
21 |
22 | ### Далее
23 | В следующих уроках мы еще глубже погрузимся в методы
24 |
25 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_340.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: В Ruby, Def Leppard означает: определить метод Leppard *
4 | answer: ^tame
5 | ok: Tame is not lame
6 | error:
7 | ---
8 |
9 | Эй, хорошо, ты это сделал. Вы создали свой собственный метод. Вы начали с def, за которым следует имя метода.
10 | И список аргументов, которые будут нужны методу. Это не слишком страшно и опасно!
11 | Все, что нам нужно сделать, это заполнить его кодом на Ruby и закончить с ним.
12 |
13 | Вот код:
14 |
15 | def tame( number_of_shrews )
16 | number_of_shrews.times {
17 | puts "Tamed a shrew"
18 | }
19 | end
20 |
21 | > __P.S.__
22 | > Если вы не знаете это название, то прочтите
23 | > Def Leppard
24 | > это название известной Британской группы.
25 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_350.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Плод вашего собственного творения
4 | answer: ^Tamed a shrew
5 | ok: Вот и все!
6 | error:
7 | load: def tame(number_of_shrews);number_of_shrews.times{puts "Tamed a shrew"};end;
8 | ---
9 |
10 | Новый метод рожден. Попробуем его использовать:
11 |
12 | tame 5
13 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_370.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Кто здесь? Итоги #5 Снимите шляпу!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Отлично, Отлично, Отлично!
11 |
12 | Круто! Круто! Круууууто!
13 |
14 | Вот что мы еще узнали:
15 |
16 | ### Методы
17 | Методы могут быть определены с помощью __def__ и у них есть имя. Методы
18 | делают вашу программу короче и проще для чтения.
19 |
20 | ### Параметры
21 | У методов могут быть параметры
22 |
23 | ### Возвращаемое значение
24 | Методы зачастую возвращают какое-то значение
25 |
26 | ## А сейчас
27 | Готовы почитать немного Шекспира?
28 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_440.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Я голоден
4 | answer: ^Я не голоден
5 | ok: Да
6 | error: Без вариантов, я голоден в 10 утра!
7 | ---
8 |
9 | Это прекрасно, но имей ввиду, что ты не знал Ruby всего 15 минут назад!
10 |
11 | Давай теперь объединим все наши полученные навыки:
12 | Давайте определим 2 метода:
13 |
14 | def hungry?(time_of_day_in_hours)
15 | puts "Я голоден"
16 | true
17 | end
18 |
19 | def eat_an(what)
20 | puts "Я ем #{what}\n"
21 | end
22 |
23 | eat_an 'яблоко' if hungry?(14)
24 |
25 | eat_an 'яблоко' if hungry?(10)
26 |
27 | Попробуйте изменить метод __hungry?__ так, чтобы он печатал __"Я не голоден"__ и возвращал false
28 | когда время меньше 10.
29 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_470.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Приложения делаются
4 | answer:
5 | ok:
6 | error:
7 | ---
8 |
9 | Мы открыли новый BlurbTM класс. Чем наполнен ваш блог?
10 | Верно, контентом. Также временем, когда BlurbTM был опубликован. И настроением.
11 |
12 | Хорошо, так что у вас есть первая строка класса, вот и все:
13 |
14 | class Blurb
15 | attr_accessor :content, :time, :mood
16 | end
17 |
18 | Имена классов всегда с большой буквы.
19 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_490.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Объект, этот аккуратный маленький пакет
4 | answer: Blurb:
5 | ok: Blurb обновлен
6 | error:
7 | load: prev;blurb1=Blurb.new;blurb1.content="Today Mount Hood Was Stolen!"
8 | ---
9 |
10 | А теперь поменяй атрибуты нашего BlurbTM:
11 |
12 | blurb1.time = Time.now
13 | blurb1.mood = :sick
14 |
15 | puts blurb1
16 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_50.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Скажи свое имя!
4 | answer: [a-zA-Zа-яА-Я]{1,1}
5 | ok: Отлично, Вы сформировали строку из букв Вашего имени.
6 | error:
7 | ---
8 |
9 | Конечно, компьютеры удобны для расчетов. Но давайте попробуем что-то еще. А хотите вывести свое имя задом наперед?
10 |
11 | Для начала наберите свое имя в кавычках как тут:
12 |
13 | "Иван"
14 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_60.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Скажи свое имя наоборот
4 | answer: .+
5 | ok: !отурК
6 | error:
7 | ---
8 |
9 | Строка представляет собой набор символов, которые компьютер может обрабатывать. Представьте, что буквы, находящиеся в строке, - это
10 | белье на верёвке, а кавычки - прищепки, держащие концы этой веревки. Кавычки обозначают начало и конец.
11 |
12 | Чтобы получить имя задом наперед, наберите:
13 |
14 | "Ivan".reverse
15 |
16 | (И не забудьте про точку!)
17 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_70.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: Подсчет букв
4 | answer: ^\d+$
5 | ok: Ага! length - это тоже метод!
6 | error:
7 | ---
8 |
9 | Вы уже попробовали использовать __method__ reverse на своем имени! Заключив имя в кавычки, Вы создали строку. Затем Вы вызвали метод reverse, который работает со строками и разворачивает ее задом наперед.
10 |
11 | А теперь давайте посмотрим, сколько букв в Вашем имени:
12 |
13 | "Ivan".length
14 |
15 |
--------------------------------------------------------------------------------
/translations/ru/try_ruby_80.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: RU
3 | title: На повторе
4 | answer: (.+)
5 | ok: Рад Вас видеть. Рад Вас видеть. Рад Вас видеть.
6 | error: adfadsfadsf
7 | ---
8 |
9 | Сейчас Вам, наверное, интересно, зачем это нужно.
10 |
11 | Что ж, я уверен, Вы хоть раз замечали на сайте надпись: __Эй, твой пароль слишком короткий!__
12 |
13 | Смотрите, некоторые программы используют код __.length__.
14 |
15 | А теперь рассмотрим это. Давайте выведем Ваше имя 5 раз
16 |
17 | "Ivan" * 5
18 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_10.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: 30 Dakikan Var Mı? Varsa Ruby'i Bir Dene!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Ruby, Japonya'dan gelen yazılım endüstrisinde devrim yaratan bir programlama dilidir.
11 |
12 | Ruby'nin güzelliği, basitlik ve güç arasındaki dengesinde bulunur.
13 |
14 | Editöre Ruby kodu yazabilir ve bu butonları kullanabilirsin:
15 |
16 | - __Run__ → Editördeki kodu çalıştırır
17 | - __Copy__ → Örnek olarak verilen kodu editöre yapıştırır
18 | - __Next__ → Sonraki derse gitmeni sağlar
19 | - __Back__ → Önceki derse gitmeni sağlar
20 |
21 | Öğrenmeye başlamak için Next butonuna tıkla.
22 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_100.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Dur, Delilercesine Havlıyorsun!
4 | answer: ^\d{1,}$
5 | ok: Sadece string'ler tersine çevirilebilir
6 | error:
7 | ---
8 |
9 | 40 sayısını tersine çeviremezsin. Aslında düşününce, monitörünü bir aynaya doğru tutabilirsin tabii ki, ancak bir numarayı tersine çevirmenin pek bir mantığı yok.
10 |
11 | Ruby sana bir hata mesajı fırlattı. Ruby, sana reverse metodunun numaralar için var olmadığını anlatıyor.
12 |
13 | Eğer belki numara değerini ilk önce string'e çevirirsen:
14 |
15 | 40.to_s.reverse
16 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_110.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Elmalar Portakallardan Farklıdır
4 | answer: \[\]
5 | ok: Süper, boş bir liste belirdi
6 | error:
7 | ---
8 |
9 | Ve numaralar string'lerden farklıdırlar.
10 |
11 | Metodları herhangi bir obje üzerinde kullanabilsen de bazı metodlar sadece belirli tiplerde olan şeyler üzerinde çalışmaktadırlar.
12 | Ancak, istediğin zaman Ruby'nin "to" metodlarını kullanarak tipler arasında geçiş yapabilirsin.
13 |
14 | - __to_s__ şeyleri __s__tring'lere dönüştürür
15 | - __to_i__ şeyleri __i__nteger'lara (sayılara) dönüştürür
16 | - __to_a__ şeyleri __a__rrays'lere dönüştürür
17 |
18 | __Array'ler ne ya?!__
19 |
20 | Onlar listeler. Bir çift köşeli parantez yazıver:
21 |
22 | []
23 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_120.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Sırada Beklemek
4 | answer: ^\[([-\.\d]+)(\s*,\s*[-\d\.]+){3,}\]$
5 | ok: Süper
6 | error: Listeye döndüncü bir eleman eklemeyi dene
7 | ---
8 |
9 | Listeler(array'ler) __belirli bir sırada olan__ şeyleri depolarlar.
10 |
11 | Aynı biraz patlamış mısır için sırada beklemek gibi. Sen, birisinin arkasındasın ve onları kenara itmeyi düşünmezsin, değil mi?
12 | Ayrıca arkandaki kişi, ona dikkat ediyorsun değil mi?
13 |
14 | Al sana bir liste. Piyango numaraları:
15 |
16 | [12, 47, 35]
17 |
18 | Bu listeye bir numara eklemeyi dene: bir virgül ardından 35 yaz. Boşluk karakteri opsiyoneldir.
19 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_130.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Elini Kaldıran
4 | answer: ^47$
5 | ok: Tamam
6 | error:
7 | ---
8 |
9 | Piyango numaralarından oluşan bir liste. Hangisi en yüksek?
10 |
11 | Dene:
12 |
13 | [12, 47, 35].max
14 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_140.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Bir Listeyi Kenara Koymak
4 | answer: ^\[(\d+)(,\s*\d+){2,}\]$
5 | ok: Kaydedildi!
6 | error:
7 | ---
8 |
9 | Aferin, aferin. Ancak bu listeyi her ihtiyacın olduğundan tekrar tekrar yazmak sinir bozucu, değil mi?
10 |
11 | Hadi numaralarımızı şu şekilde bir bilete kaydedelim:
12 |
13 | ticket = [12, 47, 35]
14 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_150.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Şimdi Ticket Yaz
4 | answer: \[(\d+(, )?){2,}\]
5 | load: ticket = [12, 47, 35]
6 | ok: Geri yüklendi!
7 | error:
8 | ---
9 |
10 | Şimdi, şunu yaz:
11 |
12 | ticket
13 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_190.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Maalesef, Tost Şiirciliğinden Nefret Ediyorsun
4 | answer: (toast){0}
5 | load: prev
6 | ok: Mükemmel
7 | error: Hala bana tost gibi kokuyor
8 | ---
9 |
10 | Bak, problem değil. Beğenmek zorunda değilsin. Kafana göre değiştir, başımın üstünde yerin var.
11 | Tost yerine git kavan falan yaz. Yeni şiiri görmek için şunu yaz:
12 |
13 | poem.gsub("toast", "honeydew")
14 |
15 | __gsub__ metodu global substitute'un kısaltılmış hali. Kendisi "toast" yazan tüm yerleri
16 | "honeydew" ile değiştirecek.
--------------------------------------------------------------------------------
/translations/tr/try_ruby_20.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Editörü Kullanmak
4 | answer: ^\d{1,}$
5 | ok: Güzel! Biraz matematikle uğraştın. Cevabın nasıl çıkıverdiğini gördün mü?
6 | error: Editöre 2 + 6 yaz
7 | ---
8 |
9 | Ruby kodunu yazacağın yer editöründür. __Run__ butonuna bas ve çalışmasını izle!
10 |
11 | Mesela, biraz matematik yapmayı dene. Örneğin:
12 |
13 | 2 + 6
14 |
15 | Programının çıktısı, çıktı penceresinde gözükmeli.
16 | Ayrıca ne kadar iyi iş çıkardığını söyleyen bir satır olmalı.
17 |
18 | > Opsiyonel olarak, __Copy__ butonuna tıklayarak örnek kodu editörüne kopyalabilirsin.
19 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_200.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Hazır, Nişan Al
4 | answer: dnah ym morf nwolf sah tsaot yM
5 | load: prev
6 | ok: Tamam, peki. Şimdi şiir tersine geri dönüverdi.
7 | error:
8 | ---
9 |
10 | Hadi sana bir soru: bu tüm şiiri ters çevirirsek ne olur?
11 |
12 | poem.reverse
13 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_210.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Biraz Fazla Çeviriverdik
4 | answer: ^\["More still did (.+)
5 | load: prev
6 | ok: Aynen, nerdeyse istediğimiz gibi
7 | error:
8 | ---
9 |
10 | Görünüşe göre tüm şiir harf harf tamamen test çevirildi. Oysa ki ben sadece satırları ters çevirmek istemiştim.
11 | Son satırı başa, baş satırı sona çevirmek.
12 |
13 | Geri çevirmen ancak, __öyle__ geri çevirmek değil.
14 |
15 | İşle şöyle:
16 |
17 | poem.lines.reverse
18 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_220.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Zincirlenmiş Metodlardan Oluşan Bukleler
4 | answer: Tostum elimden fırlayıverdi
5 | load: prev
6 | ok: İyi iş yaptın!
join metodu o satırlardan oluşan array'i aldı ve bir string'e dönüştürdü.
7 | error:
8 | ---
9 |
10 | Ee, ne görüyorsun? Orda ne oldu? __poem.lines.reverse__ yazdın ve ne oldu?
11 |
12 | İki şey oldu. Şiiri satırlardan oluşan bir listeye dönüştürdün.
13 | Lines, string'in ayrıştırılacağı yönteme karar verip onu array'e dönüştürür.
14 |
15 | Sonra, o listeyi tersine çevirdin. Her bir satırın vardı. Onları tersine çevirdin. Bu kadar.
16 |
17 | Şu en sona bir tane daha metod ekleyiverelim:
18 |
19 | puts poem.lines.reverse.join
20 |
21 | Metodları böyle yazmaya _metod zincirlemesi_ denir.
--------------------------------------------------------------------------------
/translations/tr/try_ruby_270.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Çift Olarak Hash'ler
4 | answer: ^\[".*"\]
5 | load: prev
6 | ok: Anahtarları buldun
7 | error:
8 | ---
9 |
10 | Şunu unutma ki hash'ler şeyleri belirli bir sırada depolamaz. Bu onların işi değil. Hash'ler sadece şu iki şeyi
11 | çift haline getirirler: __key__ ve bir __value__.
12 |
13 | Senin değerlendirmelerinde, kitabın başlığı bir key ve değerlendirmeyse bir value.
14 |
15 | Eğer sadece tüm değerlendirdiğin kitapların başlıklarını görmek istiyorsan:
16 |
17 | books.keys
18 |
19 | Bunu ayrıca .keys yerine .values ile de deneyebilirsin.
--------------------------------------------------------------------------------
/translations/tr/try_ruby_290.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Bir Çetele
4 | answer: \w+
5 | ok: Yodelay!
6 | error:
7 | ---
8 |
9 | Kullandığımız mükemmel şeylerden bir tanesi __block__. Bunları bu derste daha çok keşfedeceğiz. Ancak,
10 | basitçe, bir block süslü parantezlerle çevrelenmiş Ruby kodudur.
11 |
12 | Hadi bir başka block daha deneyelim:
13 |
14 | 5.times { print "Odelay! " }
15 |
16 | Block'lar her zaman metodlara bağlıdırlar. Kodu alıp tekrar ve tekrar çalıştıran __times__ metodunda da olduğu gibi. (Bizim örneğimizde: beş kere.)
--------------------------------------------------------------------------------
/translations/tr/try_ruby_30.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Sayılar ve Matematik
4 | answer: ^[0-9\.,-]{1,}$
5 | ok: Süper
6 | error:
7 | ---
8 |
9 | Ruby, sayı ve matematiksel sayıları tanır. Şu şekilde matematik yapabilirsin:
10 |
11 | 4 * 10
12 | 5 - 12
13 | 30 / 4
--------------------------------------------------------------------------------
/translations/tr/try_ruby_310.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Şimdi Özete Geliyoruz #4
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Bu son ders biraz uzundu. Yaklaşık 3 dakikanı şunları öğrenmekle harcadın:
11 |
12 | ### Hashe'ler
13 | Şu şekilde oluşturulan küçük sözlük: __{}__
14 |
15 | ### Symbol'lar
16 | Küçük ve efektif olan, iki nokta üst üste ile şu şekilde yazılan kod isimleri: __:splendid__
17 |
18 | ### Block'lar
19 | Ruby'nin birçok metoduna takılabilecek kod yığınları. İşte puan kartını yapmak için kullandığın kod:
20 | __books.values.each { |rate| ratings[rate] += 1 }__
21 |
22 | ### Sonraki
23 | Sonraki derste metodlara daha derin bir dalış gerçekleştireceğiz.
24 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_350.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Yarattığın Şeyin Olgunlaşmış Meyvesi
4 | answer: ^Tamed a shrew
5 | ok: İşte bu o sivrilere haddini bildirecek
6 | error:
7 | load: def tame(number_of_shrews);number_of_shrews.times{puts "Tamed a shrew"};end;
8 | ---
9 |
10 | Yeni bir metod doğdu. Hadi şimdi kullanalım:
11 |
12 | tame 5
13 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_370.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Merhaba, Kim Orada? Ve Özet #5 Şapkasını Sallar!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Aferin, Aferin, Aferin, Aferin!
11 |
12 | Gerçekten, gerçekten, gerçekten, gerçekten, gerçekteeeen!
13 |
14 | Al sana hayatının son birkaç dakikasının özeti:
15 |
16 | ### Metodlar
17 | Metodlar, __def__ ve bir isim ile tanımlanabilirler. Metodlar programını daha kısa ve
18 | kolayca okunabilir hale getirir.
19 |
20 | ### Parametreler
21 | Metodların parametreleri olabilir.
22 |
23 | ### Return değerleri
24 | Metodlar (neredeyse) her zaman bir değer döndürürler.
25 |
26 | ## Şimdi
27 | Olmak ya da olmamak artık senin için bir soru değil. Biraz daha Shakespeare için hazır mısın?
28 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_470.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Aplikasyonların Yapıldığı Şey
4 | answer:
5 | ok:
6 | error:
7 | ---
8 |
9 | Yeni bir BlurbTM class'ı açtın. Blog girişin neyden oluşuyor?
10 | İçerikten, tabii ki. Ayrıca, BlurbTM'ün oluşturulduğu zaman BlurbTM. Ve bir ruh hali.
11 |
12 | Tamam, class'ın ilk satırını aldın, işte sonrası:
13 |
14 | class Blurb
15 | attr_accessor :content, :time, :mood
16 | end
17 |
18 | Class isimleri her zaman büyük bir harfle başlar.
19 |
20 | (Hala bir çıktı yok)
21 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_490.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Bir Obje, O Düzenli Küçük Paket
4 | answer: Blurb:
5 | ok: Blurb güncellendi
6 | error:
7 | load: prev;blurb1=Blurb.new;blurb1.content="Today Mount Hood Was Stolen!"
8 | ---
9 |
10 | Devam et ve BlurbTM'üm zaman ve ruh halini belirle:
11 |
12 | blurb1.time = Time.now
13 | blurb1.mood = :sick
14 |
15 | puts blurb1
16 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_50.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Adını Söyle
4 | answer: [a-zA-Z]{1,1}
5 | ok: Süper, adını oluşturan harflerden bir string oluşturdun
6 | error:
7 | ---
8 |
9 | Tabii, bilgisayarlar matematik için kullanışlı. Hadi devam edelim. İsmini ters bir şekilde görmek ister misin?
10 |
11 | Önce, ismini şu şekilde iki tırnak karakterleri arasında olacak şekilde yaz:
12 |
13 | "Ali Rıza"
14 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_60.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: İsmini Geriden Söyle
4 | answer: \w+
5 | ok: repüS
6 | error:
7 | ---
8 |
9 | Bir string, bilgisayarın işleyebileceği bir karakter(ler) kümesidir. String'leri çamaşır askısına
10 | asılmış çamaşırlar olarak, tırnakları da mandallar olarak düşünebilirsin. Tırnaklar başlangıç ve sonu belirler.
11 |
12 | İsmini terse çevirmek için bunu yaz:
13 |
14 | "Ali Rıza".reverse
15 |
16 | (Noktayı unutma!)
17 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_70.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Harfleri Saymak
4 | answer: ^\d+$
5 | ok: Aynen. Length de bir 'metod'
6 | error:
7 | ---
8 |
9 | İsminde reverse __metodunu__ kullandın! İsmini tırnak işaretleri arasına alarak bir string oluşturdun. Ardından reverse metodunu çağırarak sting üzerindeki tüm harfleri ters çevirdin.
10 |
11 | Şimdi, bakalım isminde kaç adet harf varmış:
12 |
13 | "Ali Rıza".length
14 |
--------------------------------------------------------------------------------
/translations/tr/try_ruby_80.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: TR
3 | title: Tekrarda
4 | answer: (\w+)
5 | ok: Tanıştığıma memnun oldum.Tanıştığıma memnun oldum.Tanıştığıma memnun oldum.
6 | error:
7 | ---
8 |
9 | Şimdi, muhtemelen bunların ne işine yarayacağını düşünüyorsun.
10 |
11 | Eminim ki önceden sana __Hey, şifren çok kısa!__ diye bağıran bir websitede bulunmuşsundur.
12 |
13 | Gördün mü, bazı programlar o basit __.length__ kodunu kullanıyor.
14 |
15 | Şuna bak. Hadi ismini 5 ile çarpalım.
16 |
17 | "Ali Rıza" * 5
18 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_10.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Є 30 хвилин? Дай Ruby шанс, і він тебе здивує!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Ruby – це мова програмування з Японії, яка створила передумови для революції у веб-розробці.
11 |
12 | Краса Ruby в її балансі між простотою і можливостями.
13 |
14 | Ти можеш ввести код на Ruby в редакторі і використовувати кнопки для навігації:
15 |
16 | - __Run__ → Виконати код, що знаходиться в редакторі
17 | - __Copy__ → Вставити/скопіювати приклад коду в редактор
18 | - __Next__ → Перейти до наступного уроку
19 | - __Back__ → Повернутися до попереднього уроку
20 |
21 | Натисни Next для початку навчання.
22 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_100.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Зупинись, ти здурів!)
4 | answer: ^\d{1,}$
5 | ok: Розгорнути можна тільки рядки
6 | error:
7 | ---
8 |
9 | Не можна розгорнути число задом наперед. Ти, звісно, можеш тримати монітор перед дзеркалом, але розгортання числа просто не має сенсу.
10 |
11 | Ruby виведе повідомлення з помилкою. Ruby каже тобі, що не існує методу reverse для чисел.
12 |
13 | Хіба може спробувати перетворити число 40 на рядок для початку:
14 |
15 | 40.to_s.reverse
16 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_110.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Яблука відрізняються від апельсинів
4 | answer: \[\]
5 | ok: Добре, це пустий список.
6 | error:
7 | ---
8 |
9 | А числа відрізняються від рядків.
10 |
11 | У той час як використання методів може бути застосовано до всіх об'єктів Ruby, деякі методи працюють тільки з певними типами даних.
12 | Але ти можеш перетворити один тип на інший, використовуючи методи типу "to"
13 |
14 | - __to_s__ перетворює на рядки
15 | - __to_i__ перетворює на число
16 | - __to_a__ перетворює на масив
17 |
18 | __Що таке масив?!__
19 |
20 | Масив – це просто список. Набери 2 квадратні дужки:
21 |
22 | []
23 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_120.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Черга по квитки
4 | answer: ^\[([-\.\d]+)(\s*,\s*[-\d\.]+){3,}\]$
5 | ok: Чудесно
6 | error: Спробуй додати четверте число до списку
7 | ---
8 |
9 | Списки (масиви) зберігають елементи __в певній послідовності__.
10 |
11 | Схоже на чергу по квитки. Ти стоїш за кимось і навіть не мрієш його відштовхнути або пересунути, чи не так? Також хлопчина за тобою, ти пильно слідкуєш за кожним його рухом.
12 |
13 | Ось ще список. Номери лотерейних квитків:
14 |
15 | [12, 47, 35]
16 |
17 | Спробуй додати число до масиву. Набери кому і число після 35. Пробіл не обов'язковий.
18 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_130.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Перший піднімає руку
4 | answer: ^47$
5 | ok: Ok
6 | error:
7 | ---
8 |
9 | Список номерів лотерейних квитків. А який номер максимальний?
10 |
11 | Спробуй:
12 |
13 | [12, 47, 35].max
14 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_140.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Сховаємо список
4 | answer: ^\[(\d+)(,\s*\d+){2,}\]$
5 | ok: Заховано!
6 | error:
7 | ---
8 |
9 | Добре. Але ж незручно набирати список кожного разу, коли він потрібен, так?
10 |
11 | Збережімо наші номери лотереї таким чином:
12 |
13 | ticket = [12, 47, 35]
14 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_150.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Тепер введи ticket
4 | answer: \[(\d+(, )?){2,}\]
5 | load: ticket = [12, 47, 35]
6 | ok: Видобуто!
7 | error:
8 | ---
9 |
10 | А зараз набери:
11 |
12 | ticket
13 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_160.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Збережено й заховано
4 | answer: \[12, 35, 47\]
5 | load: ticket = [12, 47, 35]
6 | ok: Ти відсортував список
7 | error:
8 | ---
9 |
10 | Ти поклав список номерів в __змінну__ з назвою ticket.
11 | Але будь-яке інше ім'я, як __andriilist__, теж згодиться.
12 |
13 | Займаючись програмуванням, ти помітиш, що це, переважно, робота зі змінними.
14 |
15 | Впорядкуймо список лотерейних квитків?
16 |
17 | Використай:
18 |
19 | ticket.sort!
20 |
21 | Ти мав простий список. Ти його відсортував. Змінна ticket теж змінилася.
22 | Ти помітив, що у методу __sort!__ на кінці стоїть великий знак оклику?
23 | Так Ruby повідомляє нам, що змінна ticket буде змінена не лише в цьому виразі, а й, також, в пам'яті.
24 | Нічого надзвичайного, просто запам'ятай!
25 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_190.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: На жаль, тобі не подобається така поезія
4 | answer: (toast){0}
5 | load: prev
6 | ok: Чудово
7 | error: Все одно канапка
8 | ---
9 |
10 | Все гаразд. Всі ми різні. Редагуй цей шматочок як хочеш. Замість канапки може бути грушка або що завгодно.
11 | Спробуй це, щоб побачити новий варіант поеми:
12 |
13 | poem.gsub("канапка", "грушка")
14 |
15 | Метод __gsub__ це скорочення global substitute (замінник). Він замінить всі збіги "канапка" на "грушка".
16 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_20.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Використання редактора
4 | answer: ^\d{1,}$
5 | ok: Чудово! Ти використовуєш математику. Бачив як з'явилася відповідь?
6 | error: Введи 2 + 6
7 | ---
8 |
9 | Набирай свій код на Ruby у вікні редактора знизу, потім натисни кнопку __Run__ і подивися як це працює!
10 |
11 | Наприклад, спробуймо порахувати простий вираз:
12 |
13 | 2 + 6
14 |
15 | Результат програми повинен відображатися у вікні вгорі. На наступному рядку буде відображатися, наскільки добре ти впорався.
16 |
17 | > Також ти можеш натиснути кнопку __Copy__ щоб скопіювати код з прикладу в редактор.
18 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_200.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Готовий, цілься!
4 | answer: кур з енем у алапив акпанак яоМ
5 | load: prev
6 | ok: Звісно, увесь віршик розвернутий задом наперед
7 | error:
8 | ---
9 |
10 | Питання для тебе: що станеться?
11 |
12 | poem.reverse
13 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_210.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Занадто багато слів навпаки
4 | answer: ^\["Тоді я найбільше (.+)
5 | load: prev
6 | ok: Так, майже те що треба
7 | error:
8 | ---
9 |
10 | Що ж, вся наша поема стала задом наперед, слово за словом! Але ж я всього лише хотів зробити це для рядків.
11 | Перемісти перший рядок на кінець, а останній на початок. Тобто навпаки, але не так.
12 |
13 | Ось як:
14 |
15 | poem.lines.reverse
16 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_220.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Ще трохи методів в ланцюжок
4 | answer: Моя канапка випала у мене з рук
5 | load: prev
6 | ok: Прекрасно, друже!
Метод join взяв масив рядків і з'єднав їх в один рядок'.
7 | error:
8 | ---
9 |
10 | Що ти бачиш тут? Що сталося? Ти набрав __poem.lines.reverse__ і що сталося?
11 |
12 | Дві речі. Перше: ти розбив віршик на рядки, за допомогою методу lines, і отримав масив з них.
13 |
14 | Потім ти розгорнув цей список задом наперед і розгорнув кожен рядок. От і все!
15 |
16 | Додамо ще один метод в кінець:
17 |
18 | puts poem.lines.reverse.join
19 |
20 | Комбінування методів таким чином називається __ланцюжком методів__.
21 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_270.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Словники це пари
4 | answer: ^\[".*"\]
5 | load: prev
6 | ok: Ти знайшов ключі
7 | error:
8 | ---
9 |
10 | Пам'ятай, що словники не зберігають елементи в послідовності. Це не їхнє завдання.
11 | Вони створюють пару з двох елементів: __ключ (key)__ і __значення (value)__
12 |
13 | У твоїх відгуках, назва книги це ключ, а оцінка – значення.
14 |
15 | Якщо ж хочеш побачити всі назви книг які ти оцінив, введи:
16 |
17 | books.keys
18 |
19 | Також спробуй використати .values замість .keys.
20 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_290.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Підрахунок
4 | answer: .+
5 | ok: Будьмо!
6 | error:
7 | ---
8 |
9 | Одна з приголомшливих речей, яку ми щойно використали це __блок (block)__.
10 | Ми вивчимо їх докладніше на цьому й наступному уроці. Та загалом блок – це трохи коду на Ruby, оточеного фігурними дужками.
11 |
12 | Спробуй створити інший блок:
13 |
14 | 5.times{ print "Будьмо!" }
15 |
16 | Блоки завжди прив'язані до методів. Як метод __times__, який бере блок і запускає код знову і знову. (В нашому прикладі: п'ять разів.)
17 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_30.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Числа і математика
4 | answer: ^[0-9\.,-]{1,}$
5 | ok: Добре
6 | error:
7 | ---
8 |
9 | Ruby розуміє числа і математичні операції. Спробуй дещо інше, наприклад:
10 |
11 | 4 * 10
12 | 5 - 12
13 | 30 / 4
14 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_300.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Є хвилинка?
4 | answer: [0-9]$
5 | ok: Дуже вчасно!
6 | error: Виконай від 0 до 9
7 | ---
8 |
9 | Як ми бачили в першому прикладі з блоком (при підрахунку оцінок), ми можемо передати змінну блокові.
10 | Значення, яке __вставляється__ визначається методом, який запускає блок.
11 |
12 | Змінні, які __приймає__ блок, поміщаються в ім'я змінної на початку блоку, між двома символами pipe: |
13 |
14 | Спробуймо це за допомогою цього блоку:
15 |
16 | 5.times {|time|
17 | puts time
18 | }
19 |
20 | Тут метод __.times__ посилає значення змінній __|time|__. Але майте на увазі, що ця змінна відома тільки всередині блоку.
21 |
22 | > Ти помітив, що можеш розділити код на декілька рядків? Так їх потім простіше читати.
23 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_310.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Підводячи підсумки #4
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Цей урок був дещо довшим і ти, ймовірно, витратив на три хвилини більше на його вивчення:
11 |
12 | ### Словники
13 | Найпростіший приклад словника: __{}__
14 |
15 |
16 | ### Символи
17 | Крихітні але ефективні кодові слова з двокрапкою, наприклад: __:splendid__
18 |
19 | ### Блоки
20 | Шматочки коду, які можна прив'язати до багатьох методів Ruby.
21 | Ось код, який ми використовували щоб створити таблицю оцінок:
22 | __books.values.each { |rate| ratings[rate] += 1 }__
23 |
24 | ### Далі
25 | На наступних уроках ми ще глибше зануримося в методи.
26 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_340.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: В Ruby, Def Leppard означає: визначити метод Leppard
4 | answer: ^tame
5 | ok: Tame is not lame
6 | error:
7 | ---
8 |
9 | В Ruby, Def Leppard означає: визначити метод Leppard
10 | Добре, ти це зробив. Ти створив свій власний метод. Почав з def, за яким іде ім'я методу. І список аргументів, які будуть потрібні методові. Це не дуже страшно і небезпечно! Все, що нам потрібно зробити, це заповнити його кодом на Ruby і закінчити з end.
11 |
12 | Ось код:
13 |
14 | def tame( number_of_shrews )
15 | number_of_shrews.times {
16 | puts "Tamed a shrew"
17 | }
18 | end
19 |
20 | > __P.S.__
21 | > Якщо ти не знаєш цю назву, Def Leppard це відома Британська рок-група Def Leppard
22 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_350.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Достиглий плід твоєї праці
4 | answer: ^Приборкав норовливу
5 | ok: Так їм!
6 | error:
7 | load: def tame(number_of_shrews);number_of_shrews.times{puts "Приборкав норовливу"};end;
8 | ---
9 |
10 | Новий метод народжено. Спробуємо його використати:
11 |
12 | tame 5
13 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_370.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Привіт, хто тут? Підсумки #5 вітають тебе!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Відмінно, відмінно, відмінно!
11 | Супер, супер, сууууупер!
12 |
13 | Ось що ми ще дізналися:
14 |
15 | ### Методи
16 | Методи можуть бути визначені за допомогою __def__ та мають ім'я.
17 | Методи роблять нашу програму коротшою і простішою для читання.
18 |
19 | ### Параметри
20 | Методи можуть мати параметри.
21 |
22 | ### Значення, що повертаються
23 | Методи (майже) завжди повертають якесь значення.
24 |
25 | ## А зараз
26 | Бути чи не (бути) не є для тебе більше великим питанням. Ти готовий почитати ще трохи Шекспіра?
27 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_440.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Я голодний
4 | answer: ^Я не голодний
5 | ok: Так
6 | error: Я не голодний о 10 ранку!
7 | ---
8 |
9 | Це прекрасно, це прості речі, але пам'ятай, що ти __не знав Ruby__ всього 15 хвилин тому!
10 |
11 | Тож тепер об'єднаємо всі наші отримані навички: визначимо 2 методи:
12 |
13 | def hungry?(time_of_day_in_hours)
14 | puts "Я голодний"
15 | true
16 | end
17 |
18 | def eat_an(what)
19 | puts "Я їм #{what}\n"
20 | end
21 |
22 | eat_an 'яблуко' if hungry?(14)
23 |
24 | eat_an 'яблуко' if hungry?(10)
25 |
26 | Спробуй змінити метод __hungry?__ так, щоб він друкував __"Я не голодний"__ і повертав false коли час буде менше 12-ї.
27 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_470.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Те з чого робляться додатки
4 | answer:
5 | ok:
6 | error:
7 | ---
8 |
9 | Ми відкрили новий BlurbTM class. клас. Чим наповнений ваш блог?
10 | Так, змістом! Також часом, коли BlurbTM був опублікований. І настроєм.
11 |
12 | Добре, тож у нас є перший рядок класу, ось решта:
13 |
14 | class Blurb
15 | attr_accessor :content, :time, :mood
16 | end
17 |
18 | Імена класів завжди починаються з великої літери (і знову ж, нічого не повертається).
19 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_490.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Об'єкт, цей акуратний маленький пакет
4 | answer: Blurb:
5 | ok: Blurb оновлено
6 | error:
7 | load: prev;blurb1=Blurb.new;blurb1.content="Today Mount Hood Was Stolen!"
8 | ---
9 |
10 | А тепер змінимо атрибути нашого BlurbTM:
11 |
12 | blurb1.time = Time.now
13 | blurb1.mood = :sick
14 |
15 | puts blurb1
16 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_50.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Назви своє ім'я!
4 | answer: [a-zA-Zа-яА-Я]{1,1}
5 | ok: Чудово, ти створив рядок з літер свого імені
6 | error:
7 | ---
8 |
9 | Звісно комп'ютери зручні для розрахунків. Але спробуймо щось іще. Хочеш вивести своє ім'я навпаки?
10 |
11 | Для початку набери своє ім'я в лапках як тут:
12 |
13 | "Андрій"
14 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_60.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Скажи своє ім'я навпаки
4 | answer: .+
5 | ok: оводуЧ
6 | error:
7 | ---
8 |
9 | Рядок є набором символів, які комп'ютер може обробляти. Уявіть, що букви, які знаходяться в рядку, – як білизна на мотузці, а лапки – прищіпки, які тримають кінці цієї мотузки. Лапки позначають початок і кінець.
10 |
11 | Щоб отримати ім'я задом наперед, набери:
12 |
13 | "Андрій".reverse
14 |
15 | (І не забудь точку!)
16 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_70.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: Підрахунок літер
4 | answer: ^\d+$
5 | ok: Так. Довжина рядка це також 'метод'
6 | error:
7 | ---
8 |
9 | Ти вже спробував __метод__ reverse на своєму імені! Уклавши ім'я в лапки, ти створив рядок. Потім ти викликав метод reverse, який працює з рядками і розгортає їх задом наперед.
10 |
11 | А тепер погляньмо, скільки літер у твоєму імені:
12 |
13 | "Андрій".length
14 |
--------------------------------------------------------------------------------
/translations/ua/try_ruby_80.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: UA
3 | title: На повторі
4 | answer: (.+)
5 | ok: Приємно познайомитись! Приємно познайомитись! Приємно познайомитись!
6 | error:
7 | ---
8 |
9 | Зараз тобі напевно цікаво, навіщо все це потрібно.
10 |
11 | Що ж, я впевнений, ти хоч раз помічав на сайті напис: __Ваш пароль занадто короткий!__
12 |
13 | Диви, деякі програми використовують простий код __.length__.
14 |
15 | Поглянь ще. Помнож своє ім'я на 5.
16 |
17 | "Андрій" * 5
18 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_10.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 有30分钟无事可做? 来尝试一下Ruby吧!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | Ruby是一门来自日本，并在软件开发领域引起了革命的编程语言。
11 |
12 | Ruby的美在于其语法简洁的同时保证了语言的强大。
13 |
14 | 你可以在编辑器中输入Ruby代码，用这些按钮来使用网站。
15 |
16 | - __Run__ → 在编辑器中执行代码
17 | - __Copy__ → 将示例代码粘贴至编辑器
18 | - __Next__ → 前往下一节课
19 | - __Back__ → 回到上一节课
20 |
21 | 点击 Next 开始学习.
22 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_100.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 停下，你在狂吠!
4 | answer: ^\d{1,}$
5 | ok: 只有字符串才能被逆置！
6 | error:
7 | ---
8 |
9 | 你不可以逆置数字40，我猜你可以抱着你的显示器并把它对着镜子，但逆置一个数字听起来就不合理。
10 |
11 | Ruby报错了。Ruby在告诉你并不存在逆置数字的方法。
12 |
13 | 但如果先把数字转换成字符呢:
14 |
15 | 40.to_s.reverse
16 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_110.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 苹果和橘子是不一样的
4 | answer: \[\]
5 | ok: 很棒，这是一个空列表
6 | error:
7 | ---
8 |
9 | 并且数字与字符串是不同的.
10 |
11 | 虽然你可以对Ruby中的任何对象使用方法，但某些方法只对某些特定种类的东西有用。
12 | 但你可以随意使用Ruby中的"to"方法来转换类型
13 |
14 | - __to_s__ 将对象转换为 （to __s__trings） 字符串
15 | - __to_i__ 将对象转换为 （to __i__ntegers (numbers)）整数
16 | - __to_a__ 将对象转换为 （to __a__rrays） 数组
17 |
18 | __数组又是什么？!__
19 |
20 | 他们是列表。 输入一组括号:
21 |
22 | []
23 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_120.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 排好队
4 | answer: ^\[([-\.\d]+)(\s*,\s*[-\d\.]+){3,}\]$
5 | ok: 超级棒
6 | error: 尝试加入第四个数
7 | ---
8 |
9 | 列表（数组）以 __特定的顺序__ 储存对象。
10 |
11 | 就像在排队买爆米花，你不会想着把你前面的人推开，但你却关注着你后面的人，对吧？
12 | 一个现成的列表，彩票数字:
13 |
14 | [12, 47, 35]
15 |
16 | 尝试在列表中增加一个数字：在35后面打一个逗号，然后输入一个数字，空格是选择性的，可加可不加。
17 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_130.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 有一个举手了
4 | answer: ^47$
5 | ok: 可以
6 | error:
7 | ---
8 |
9 | 由彩票数字组成的列表里，哪一个数最大?
10 |
11 | 试试这个:
12 |
13 | [12, 47, 35].max
14 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_140.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 把清单保存起来
4 | answer: ^\[(\d+)(,\s*\d+){2,}\]$
5 | ok: 保存成功!
6 | error:
7 | ---
8 |
9 | 不错，不错。但你并不想在每次你需要用到它的时候都重新打一遍，对吧？
10 |
11 | 让我们把数字保存在一个名为彩票（ticket）的的变量里:
12 |
13 | ticket = [12, 47, 35]
14 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_150.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 现在输入ticket
4 | answer: \[(\d+(, )?){2,}\]
5 | load: ticket = [12, 47, 35]
6 | ok: 还是原来的状态!
7 | error:
8 | ---
9 |
10 | 现在，输入:
11 |
12 | ticket
13 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_160.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 保存了，又藏起来了
4 | answer: \[12, 35, 47\]
5 | load: ticket = [12, 47, 35]
6 | ok: 你已经对列表进行了排序
7 | error:
8 | ---
9 |
10 | 把抽签号码记下来，把它装进了名为ticket的变量中。
11 | 这里，变量的名字也可以是其他的，比如 __jimmyslist__。
12 |
13 | 你会发现，编程主要与变量有关。
14 |
15 | 让我们把你的彩票号码排序一下，怎么样?
16 |
17 | 试用一下代码:
18 |
19 | ticket.sort!
20 |
21 | 你创建了一个列表。并将它排序了。变量ticket已经改变了。
22 | 你有没有注意到 __sort!__ 方法在结尾有一个又大又粗的感叹号?
23 | 很多时候，如果Ruby方法永久性地改变了变量，就会发出这样的声音。
24 | 没什么特别的，只是个标记。
25 |
26 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_170.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 元素
4 | answer: ^(12|35|47)$
5 | load: ticket = [12, 47, 35]
6 | ok: 完成
7 | error: 差一点
8 | ---
9 |
10 | 我们已经把在变量ticket里的彩票数字排序了，那怎么再把它们拿出来呢？
11 |
12 | 我们已经知道了可以用 __max__ 来得到最大的值。
13 | 同样的，你可以
14 | 用 __first__ 或者 __last__ 来得到第一个或是第二个元素。
15 | 可如果你想要一个特定的值呢？
16 |
17 | ### [ ]
18 | Ruby使用方括号[ ]来选择元素
19 | 方括号在Ruby中非常常见
20 | 它们就像用来瞄准目标的瞄准器
21 | 意味着“__我要去寻找__”，准备，瞄准。
22 |
23 | 让我们输出我们全部的彩票数字
24 |
25 | puts ticket[0]
26 | puts ticket[1]
27 | puts ticket[2]
28 |
29 | 我们为什么使用 [0], [1], [2]?
30 |
31 | 而不是 [1], [2] 和 [3]? 难道这是来自日本的神秘佛教计数法吗？不, 我们computer people就是喜欢从0开始数。不仅仅是Ruby，大多数编程语言都从0开始数。
32 |
33 | > 一个小提示: 你可以按 __Copy__ 按钮，把示例代码复制到编辑器中。
34 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_180.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 总结#2 来了
4 | answer: \w+
5 | class: stretcher chapmark
6 | load: poem = "My toast has flown from my hand\nAnd my toast has gone to the moon.\nBut when I saw it on television,\nPlanting our flag on Halley's comet,\nMore still did I want to eat it.\n"
7 | ok: 押韵吗?
8 | error:
9 | ---
10 |
11 | 现在，回顾一下你的第二分钟学了什么:
12 |
13 | ### Errors（错误）
14 | 如果你尝试逆置一个数字，Ruby就会告诉你这个。
15 |
16 | ### 数组
17 | 数组是以某种顺序来储存元素的列表。
18 | 我们也学了如何创造数组，与如何从中获取元素。
19 |
20 | ### 变量
21 | 变量保存事物，并赋予其名称。要想在变量中存储一些东西，这样:
22 | ticket = [14, 37, 18].
23 |
24 | ### 2/8
25 | 总共有八个部分。你已经走了八分之二了!这很简单，
26 | 你不觉得吗?后面还有更好玩的东西。
27 |
28 | 让我们改变一下方向。我在某个变量里给你塞了首诗。
29 | 看一看。输入:
30 |
31 | puts poem
32 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_190.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 真是悲哀啊，最讨厌有吐司的诗了
4 | answer: (toast){0}
5 | load: prev
6 | ok: 棒极了
7 | error: 还有吐司的味道。
8 | ---
9 |
10 | 看，这诗不错。你不需要喜欢它。
11 | 随便修改，可以把toast改成各种瓜。
12 | 试试下面这个，然后检查一下新的诗：
13 |
14 | poem.gsub("toast", "honeydew")
15 |
16 | __gsub__ 方法是global substitute的缩写。
17 | 它会将所有"toast"替换为"honeydew"。
18 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_20.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 如何使用编辑器
4 | answer: ^\d{1,}$
5 | ok: 不错！简单的数学，看到结果是如何显示的了吗？
6 | error: 在编辑器中输入 2 + 6
7 | ---
8 |
9 | 编辑器窗口可以输入Ruby代码，点击 __RUN__ 按钮，然后就可以运行了！
10 | 比如，输入一些数学，就像：
11 |
12 | 2 + 6
13 |
14 | 程序的输出会在OUTPUT窗口显示。
15 | 并且会有一行字告诉你你做的怎么样。
16 |
17 | > 或者你可以直接按 __Copy__ 按钮，代码会自动输入。
--------------------------------------------------------------------------------
/translations/zh/try_ruby_200.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 摆好姿势，瞄准
4 | answer: dnah ym morf nwolf sah tsaot yM
5 | load: prev
6 | ok: 好的,当然。所以整首诗被倒着写了。
7 | error:
8 | ---
9 |
10 | 有一个问题:当我们逆置整首诗会发生什么？
11 |
12 | poem.reverse
13 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_210.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 太多逆置了
4 | answer: ^\["More still did (.+)
5 | load: prev
6 | ok: 差不多是我们想要的了
7 | error:
8 | ---
9 |
10 | 所以整首诗按照字母的顺序，被逐一倒置了。这显然不是我想要的。我期望按照行的顺序进行倒置，比如第一行变成最后一行。那么如下操作：
11 |
12 | poem.lines.reverse
13 |
14 | 把最后一行移到第一行，把第一行移到最后一行。
15 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_220.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 链式方法的小环
4 | answer: My toast has flown from my hand
5 | load: prev
6 | ok: 好样的，我的朋友！
join方法把那个数组的行数放在一起，变成一个字符串。
7 | error:
8 | ---
9 |
10 | 那么你看到了什么？那里发生了什么？你输入了 __poem.lines.reverse__，发生了什么？
11 |
12 | 发生了两件事。你用lines把诗变成了一个列表。
13 | Lines 决定了字符串被分割的方式，并将其转换为一个数组。
14 |
15 | 然后，你反转了这个列表。每一行都是。你反转了它们。就这样了。
16 |
17 | 让我们再把一个方法放在最后：
18 |
19 | puts poem.lines.reverse.join
20 |
21 | 像这样的方法组合被称为_方法链_。
--------------------------------------------------------------------------------
/translations/zh/try_ruby_230.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 这里是总结(三)
4 | answer: \{\}
5 | class: stretcher chapmark
6 | load: prev
7 | ok: 创建了空hash!
8 | error:
9 | ---
10 |
11 | ### 感叹号
12 | 方法的名称中可能有感叹号(也有问号)。
13 | 这些只是为了更好地解释它们的功能。没什么大不了的。
14 |
15 | ### 字符串操作
16 | 搜索和更改字符串
17 |
18 | ### 链接
19 | 链接方法可以让您完成更多的工作。将一首诗分解，倒写，重新组合:
20 | __poem.lines.reverse.join__
21 |
22 | 你还想再弄点诗吗?
23 | string的所有方法列表在这里.
24 |
25 | 试试看这些吧: poem.downcase or poem.swapcase
26 |
27 | ## 准备好了?
28 | 准备好继续的话，输入:
29 |
30 | books = {}
31 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_240.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 一本空白的小书
4 | answer: ^(splendid|quite_good|mediocre|quite_not_good|abysmal)$
5 | load: books = {}
6 | ok: 是的，这是一个新的评论
7 | error: splendid, quite_good, mediocre, quite_not_good, abysmal.
请使用其中之一。另外，不要忘记冒号。
8 | ---
9 |
10 | 现在制作的是空的 __哈希（hash）__。哈希就像数组一样，不同之处在于每个元素都有自己的名字。
11 |
12 | 我们要在新的哈希中塞进一些简易的书评，
13 | 评价体系如下。
14 |
15 | - :splendid → 大师之作
16 | - :quite\_good → 很享受，啊对
17 | - :mediocre → 半好半坏
18 | - :quite\_not\_good → 特别差
19 | - :abysmal → 热气腾腾的残骸
20 |
21 | 要给一本书评分，把书名放在方括号里，把评分放在等号后面。比如说：
22 |
23 | books["Gravitys Rainbow"] = :splendid
24 |
25 | > 现在我想应该告诉你，TryRuby的所有课程都是相互独立的。
26 | > 所以，如果你在这里疯狂地输入书评，你只能在这一课中使用它们。
27 | > 如果你想在下一课使用你的评论，你应该复制/粘贴它们。
28 | > 不要太担心这个，每一课都有很多预定义的东西供你玩耍。
--------------------------------------------------------------------------------
/translations/zh/try_ruby_250.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 更多的评论
4 | answer: [3-9]
5 | load: books = {"Gravitys Rainbow" => :splendid}
6 | ok: 看到了吧，length方法不仅可以用于字符串，还可以用于数组和哈希。
7 | error:
8 | ---
9 |
10 | 继续增加书评吧。
11 | 要查看完整的列表，输入 __puts books__。
12 |
13 | 再重复一遍，评价体系是:splendid、:quite_good、:mediocre、:quite_not\ _good、:abysmal。
14 |
15 | 这些评价不是一串文字。在单词前面加冒号的话，那个就变成了 __符号__。
16 | 从计算机存储器的角度来看，符号比字符串成本更低。
17 | 如果你在程序中不断重复使用相同的单词，你就应该使用符号。
18 | 不是在内存上有那个单词的数千个副本，而是计算机只存储符号 __一次__。
19 |
20 | 更重要的是，用符号来表示它会告诉电脑这不仅仅是一个单词，而是在程序中有意义的。
21 |
22 | 如果输入了两个以上的书评，请使用 __books.length__ 确认哈希中有哪些书评：
23 |
24 | books["The deep end"] = :abysmal
25 | books["Living colors"] = :mediocre
26 |
27 | puts books
28 |
29 | puts books.length
30 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_260.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 等等，我喜欢Gravity's Rainbow吗?
4 | answer: ^(splendid|quite_good|mediocre|quite_not_good|abysmal)$
5 | load: books = {"Gravitys Rainbow" => :splendid, "The deep end" => :abysmal, "Living colors" => :mediocre}
6 | ok: 我超级喜欢
7 | error:
8 | ---
9 |
10 | Ruby的优点之一是名字经常被重复使用。
11 | 多亏了这个，必须要记住的名字变少了。
12 |
13 | 还记得从数组中提取元素的时候，像 __puts ticket[1]__ 那样需要使用数值吗?
14 |
15 | 哈希也可以用同样的方法提取元素。但是，使用名字而不是数值。
16 |
17 | 假设你想检查旧的书评。在括号里输入书名。但把等号去了。
18 | 如下所示：
19 |
20 | puts books["Gravitys Rainbow"]
21 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_270.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 哈希是成对的
4 | answer: ^\[".*"\]
5 | load: prev
6 | ok: 你找到键（keys）了
7 | error:
8 | ---
9 |
10 | 记住哈希并不会把储存的东西排好序，那不是它的工作，它只会把东西配对。
11 | 两个东西：__键__ 与 __值__
12 |
13 | 在你的评论中，书名是键，书评是值
14 |
15 | 如果你想看你评论过的书的题目:
16 |
17 | books.keys
18 |
19 | 你可以方法换成.values
--------------------------------------------------------------------------------
/translations/zh/try_ruby_280.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 你标准很高?
4 | answer: :mediocre
5 | load: books = {"Gravitys Rainbow" => :splendid, "The deep end" => :abysmal, "Living colors" => :mediocre, "Bumblebees" => :mediocre}
6 | ok: 不错，你已经为你的书评做了一个评分卡了
7 | error:
8 | ---
9 |
10 | 你写了刻薄或不公平的书评吗?
11 | 那么，让我们准备一个名为 __ratings__ 的新的哈希来打分吧。
12 |
13 | 怎么做呢?对啊，就是不断地增加书评。请输入以下内容:
14 |
15 | ratings = Hash.new {0}
16 |
17 | books.values.each { |rate|
18 | ratings[rate] += 1
19 | }
20 |
21 | puts ratings
22 |
23 | 代码中的直线是管道字符，位于键盘中Enter键的正上方
24 |
25 | _+= 1_表示:值增加1。
26 |
27 | 如果你不明白这里发生的一切，也不要担心。这将在稍后揭晓。
28 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_290.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 一个统计
4 | answer: \w+
5 | ok: Yodelay!
6 | error:
7 | ---
8 |
9 | 我们刚刚使用的一个美妙的新东西是 __块（block）__。我们将进一步探讨这些问题
10 | 在这一课和下一课。但是，基本上，块是由花括号包围的一小段Ruby代码
11 | 括号。
12 |
13 | 试一试另一个块:
14 |
15 | 5.times { print "Odelay! " }
16 |
17 | 块总是附加到方法上。比如 __times__ 方法，这个块将
18 | 一遍又一遍地运行代码。(在这个例子中，它将运行五次。)
--------------------------------------------------------------------------------
/translations/zh/try_ruby_30.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 数字与数学
4 | answer: ^[0-9\.,-]{1,}$
5 | ok: 不错
6 | error:
7 | ---
8 |
9 | Ruby能够识别数字和数学符号，试试看其他的算式：
10 |
11 | 4 * 10
12 | 5 - 12
13 | 30 / 4
--------------------------------------------------------------------------------
/translations/zh/try_ruby_300.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 你有时间吗?
4 | answer: ^[0-9]$
5 | ok: 次数对了
6 | error: 让这些块运行0次到9次
7 | ---
8 |
9 | 从第一个运用块的例子我们可以看到（在数评分时），我们可以给块传值。传什么值由控制块的方法来决定。
10 |
11 | 块中 __收到（received）__ 的值被放在块开头的在两个管道符号之间的变量名中: |
12 |
13 | Let's try that with this block:
14 |
15 | 5.times { |time|
16 | puts time
17 | }
18 |
19 | 这里，方法 __.times__ 给变量 __|time|__ 传了一个值。但是注意这个变量仅在块中有效。
20 |
21 | > 你可以尝试把代码分成几段，可以有助于你理解。
22 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_310.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 现在到了总结#4
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | 这最后一课稍微长一点。你可能已经用了三分钟的时间来学习:
11 |
12 | ###哈希
13 | 带有卷页的小字典:__{}__
14 |
15 | ###符号
16 | 带有冒号的微小、高效的代码，比如:__:splendid__
17 |
18 | ###块
19 | 可以添加到许多Ruby方法中的代码块。这是你用过的代码
20 | 建立一个记分卡:
21 | __books.values.each { |rate| ratings[rate] += 1 }__
22 |
23 | ###下一节
24 | 下一课我们将更深入地探讨方法。
25 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_320.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: To (be) or not to (be)
4 | answer:
5 | load: poem = "My toast has flown from my hand\nAnd my toast has gone to the moon.\nYada yada yada\n"
6 | ok:
7 | error:
8 | ---
9 |
10 | 一个还没有认真探讨的东西：方法参数
11 | 还记得我们怎么修改那首诗的吗：
12 | __poem.gsub("toast", "honeydew")__
13 |
14 | gsub方法需要两个参数，这两个参数即为括号中的那两个字符串。
15 |
16 | ### 括号
17 | 实际上，Ruby不是很在意你去掉括号，这样也可以运行:
18 | __poem.gsub "toast", "honeydew"__
19 |
20 | 实际上我们已经用了好多次一个带着括号的方法，很显然:
21 |
22 | puts "Hello"
23 | puts("Hello")
24 |
25 | 是的 __puts__ 是的 __puts__ 是一个方法，加不加括号对Ruby来说一样，但是
26 | 不加括号使代码更易读，并且节省时间
27 |
28 | >所以我想结论是，你可以用括号做任何你喜欢的事，只要你
29 | >代码读起来很好。
30 |
31 | ### to (be) or not to (be)
32 | 所以如果 _to_ 是一个方法 _be_ 是一个参数，我们现在知道这个古老问题的答案了
33 | 这只是单纯的个人喜好问题_to be_ or _to(be)_.
34 |
35 | 还想要更多的莎士比亚作品吗，继续读。
36 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_330.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 驯悍记
4 | answer: ^tame
5 | ok: 不错不错
6 | error:
7 | ---
8 |
9 | 你现在完全知道如何使用Ruby。我的意思是你已经掌握了基本的东西。
10 | 你只需要继续学习更多的方法和尝试更复杂的块。
11 |
12 | 但是Ruby还有一个方面我们还没有解决。制作你自己的方法。
13 | __Ahem!__ 让我们把它完成吧。
14 |
15 | 除了使用Ruby的内置方法（如puts, sort, times），你还可以定义
16 | 你可以定义你自己的方法。为什么这是个好主意？有两个原因。
17 |
18 | ### 让你的程序更短
19 | 如果你必须在你的代码的多个部分做同样的事情，那么把这些代码放在一个单独的方法中会比较容易。
20 | 把这些代码放在一个单独的方法中。你的代码会更短。
21 |
22 | ### 为了使你的代码更容易阅读
23 | 假设你的程序需要做很多不同的事情。
24 | 你可以把所有的代码塞进一个长的部分。但这将是非常困难的
25 | 阅读和理解这些代码。
26 |
27 | 相反，你应该把你的代码切割成不同的方法，并给每个方法一个容易理解的
28 | 的英文名称。你以后会感谢自己的。
29 |
30 | 那么，我们如何定义一个方法呢？就像这样。
31 |
32 | def tame( number_of_shrews )
33 | end
34 |
35 |
36 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_340.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 在Ruby中，Def Leppard 的意思是: 定义Leppard方法
4 | answer: ^tame
5 | ok: Tame is not lame
6 | error:
7 | ---
8 |
9 | 嘿，好吧，你做到了。你正在创建你自己的方法。你以def开头，后面是方法的名称。
10 | 还有一个方法需要的参数列表。这并不可怕，也不危险。
11 | 我们所要做的就是用Ruby来写满它，然后用end来结束它。
12 |
13 | 下面是代码：
14 |
15 | def tame( number_of_shrews )
16 | number_of_shrews.times {
17 | puts "Tamed a shrew"
18 | }
19 | end
20 |
21 | > __P.S.__
22 | > 如果你不懂这一章的标题
23 | > Def Leppard
24 | > 是一个，曾经很有名的，英语摇滚乐队的名字
25 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_350.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 自己创造的成熟的果实
4 | answer: ^Tamed a shrew
5 | ok: 这将让那些泼妇看到
6 | error:
7 | load: def tame(number_of_shrews);number_of_shrews.times{puts "Tamed a shrew"};end;
8 | ---
9 |
10 | 一个新的方法诞生了，让我们马上调用一下：
11 |
12 | tame 5
13 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_360.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 奉献与索取
4 | answer: \d+
5 | ok: 不错。好样的。
6 | error:
7 | ---
8 |
9 | 大多数方法不仅需要一些参数作为输入，而且也会 __返回__ 一些东西。
10 | 我对我们的方法做了一些改变，所以它将返回一个值给你。试试吧：
11 |
12 | def tame( number_of_shrews )
13 | number_of_shrews.times {
14 | puts "Tamed a shrew"
15 | }
16 | return number_of_shrews
17 | end
18 |
19 | puts tame(3)
20 |
21 | ### 返回
22 | 那么，既然你在这里变得如此高阶和能干，给你提示。
23 | 你可以在方法的最后一行省略 __return__ 这个词。
24 | Ruby将自动返回方法中最后使用的值。
25 |
26 | 所以我们修改最后一行为: __number\_of\_shrews__.
27 |
28 | 但是既然方法 __.times__ 也返回 _number\_of\_shrews_ 我么可以省去最后一整行，所以我们最初的方法已经做到了我们一直想做的事情。
29 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_370.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 你好，谁在那里？总结#5挥舞着它的帽子!
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | ---
9 |
10 | 做得好，做得好，做得好，做得好!
11 |
12 | 真的，真的，真的，真的，真真真真真真真的！
13 |
14 | 这里是你生命中上几分钟的回顾。
15 |
16 | ### 方法
17 | 方法可以用 __def__ 来定义，并且有一个名字。方法使你的程序更短,
18 | 而且更容易阅读。
19 |
20 | ### 参数
21 | 方法可以有参数。
22 |
23 | ### 返回值
24 | 方法（几乎）总是返回一个值。
25 |
26 | ## 现在
27 | To (be) or not to (be) 不再是一个问题了。准备好看更多的莎士比亚了吗？
28 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_40.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 输出多个结果
4 | answer: ^[0-9\.,-]{1,}$
5 | ok: 不错的put
6 | error:
7 | ---
8 |
9 |
10 | 你意识到就算你输入了许多算式，却仅输出最后一个算式的结果吗？
11 | 这是为什么？
12 |
13 | > 为了让这个网站易于使用，我已经通知Ruby让他把结果显示在输出框了。
14 | > 所以当你输入一个算式，你就可以得到一个结果。
15 | > __但只有最后一个算式有结果__。并且仅在输出为空的情况下。
16 |
17 | 所以当你打了两个或者以上的算式，Ruby只会显示最后一个算式的结果
18 | 。
19 |
20 | 你当然可以自己选择想要在屏幕上输出什么！只需要在每个算式前打上 __puts__。（记得要加空格）。puts的意思是：*打印某些东西在屏幕上*。
21 |
22 | 试试这个:
23 |
24 | puts 4 * 10
25 | puts 5 - 12
26 | puts 30 / 4
27 |
28 | 现在把最后一个算式前的puts去掉，看看会发生什么。
29 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_430.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 我们有一个惊人的结论
4 | answer: is not equal to 100$
5 | ok: 这样好多了
6 | error: 这肯定不对
7 | ---
8 |
9 | 看到这里面的两个等号了吗 __'abc' == 'def'__?
10 |
11 | __==__ 意为 __相等__.
12 | 我们之前见到的一个等号意为 __将值赋值于一个变量__.
13 |
14 | 让这一切变的更令人迷惑：你可以在if方法后面写一个赋值语句：
15 |
16 | a = 0
17 |
18 | if a = 100
19 | puts "Expression is true, but a is now: #{a}"
20 | else
21 | puts "#{a} is not equal to 100"
22 | end
23 |
24 | 把=换成==，看看会发生什么
25 |
26 | 我保证你有时会忘了打第二个等号。因为我也老是忘记。
27 |
28 | ### else
29 | 在上面的代码中我加入了else表达式，这一部分代码会在
30 | __if test-expression__ 判定为假的时候执行
31 |
32 | > if-then-else有很多变种，详情请见：
33 | > here.
34 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_440.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 我 饿
4 | answer: ^Me not hungry
5 | ok: 对
6 | error: 我不可能在上午10点饿
7 | ---
8 |
9 | 你已经有了很大进步。这对你来说是很简单的事情，但你记得吗，你在15分钟前还不知道什么是Ruby!
10 | 你还不知道 __有关Ruby的任何东西__！
11 |
12 | 最后一步。让我们把这一切联系起来，你懂的？让我们让它像一组非常漂亮的风铃一样响起来
13 | 在神奇的阳光下，在海滩上的闪闪发光的风铃！
14 |
15 | 我们先定义两种方法，然后再做出决定。
16 |
17 | def hungry?(time_of_day_in_hours)
18 | puts "Me hungry"
19 | true
20 | end
21 |
22 | def eat_an(what)
23 | puts "Me eat #{what}\n"
24 | end
25 |
26 | eat_an 'apple' if hungry?(14)
27 |
28 | eat_an 'apple' if hungry?(10)
29 |
30 | 试试看你能不能用 __hungry?__ 方法来得出 __"Me not hungry"__，并且在时间小于12时使其返回假。
31 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_450.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 总结 #6 意味着你已经走了很远
4 | answer: \{\}
5 | class: stretcher chapmark
6 | ok: 很好，这是一个空哈希
7 | error:
8 | ---
9 |
10 | 你是一个六级Ruby传教士了。我的意思是你做的很好，让我们来回顾一下：
11 |
12 | ### 数据
13 | 你从互联网上下载了一些数据，从这些数据中，你检索到了你想要的值。
14 |
15 | ### 迭代
16 | 你通过迭代一个哈希中的所有元素并且链接了一些方法。
17 |
18 | ### 漂亮的打印方式
19 | 如果这还不够，你利用格式化打印了一些值，使人们能够轻易读懂。实际上 __你已经写出了一个真正的程序！__
20 |
21 | ### IF
22 | 你已经学会了怎么用用 __if__ 和 __else__ 来操控你的程序。
23 |
24 | ## 那么
25 | 接下来会是什么? 你现在应该学些什么呢?
26 | 哈，精彩的部分来了，我们要接着学了。学完剩下的两节课，就结束了。
27 |
28 | 早前，我们想这样创建了哈希：
29 |
30 | Hash.new
31 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_470.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: App的内容
4 | answer:
5 | ok:
6 | error:
7 | ---
8 |
9 | 你已经创建了一个新的BlurbTM类。你会怎样设计界面？
10 | 信息BlurbTM的内容，当然。并且，发送的时间，还有情绪。
11 |
12 | 好的，下面是Blurb类的余下定义：
13 |
14 | class Blurb
15 | attr_accessor :content, :time, :mood
16 | end
17 |
18 | 类的名称始终以大写字母为开头。
19 |
20 | （仍然没有输出）
21 |
22 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_480.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 存储器是悬空的星星的角
4 | answer: Blurb:
5 | ok: 我的第一个Blurb
6 | error:
7 | load: class Blurb;attr_accessor :content,:time,:mood;end
8 | ---
9 |
10 | 嘿，不错的类。你已经有了一个新BlurbTM类。
11 |
12 | 在类的定义中，你使用了attr\_accessor方法。
13 | 在类定义中有很多像这样的 __attr（属）__ibute（性)方法或者其他的一些小设定。
14 | 这些属性是附着在类中的变量。
15 |
16 | 这样，把类想象成一个五角星，那些属性就是星星的角，共同组成了它。
17 |
18 | ### 现在
19 | 创建一个BlurbTM并设定好内容:
20 |
21 | blurb1 = Blurb.new
22 | puts blurb1
23 | blurb1.content = "Today Mount Hood Was Stolen!"
24 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_490.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 一个对象，整洁的小包裹
4 | answer: Blurb:
5 | ok: Blurb已更新
6 | error:
7 | load: prev;blurb1=Blurb.new;blurb1.content="Today Mount Hood Was Stolen!"
8 | ---
9 |
10 | 继续设置BlurbTM的时间和心情:
11 |
12 | blurb1.time = Time.now
13 | blurb1.mood = :sick
14 |
15 | puts blurb1
16 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_50.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 说出你的名字
4 | answer: [a-zA-Z]{1,1}
5 | ok: 完美，你已经构造了一个由你的名字的字母组成的字符串
6 | error:
7 | ---
8 |
9 | 当然，电脑们在数学方面非常拿手。我们继续，想看看你的名字如何被逆置？
10 |
11 | 第一步，把你的名字放进这样的引号里:
12 |
13 | "Jimmy"
14 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_500.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 让它更快
4 | answer: ^\d{4}
5 | ok: Noted
6 | error:
7 | ---
8 |
9 | 不错，你的app很棒。嘿，让我们把这件事情简化一下。
10 | 你不会每次发BlurbTM都想手动加一下时间的。
11 |
12 | 每次只手动写内容和心情对吧？
13 |
14 | 让我们把 __initialize__ 方法增加到类中。这个方法在会在每条BlurbTM创建的时候都被调用。
15 |
16 | 同时我们可以限制BlurbTM长度为40个字符。
17 |
18 | class Blurb
19 | attr_accessor :content, :time, :mood
20 |
21 | def initialize(mood, content="")
22 | @time = Time.now
23 | @content = content[0..39]
24 | @mood = mood
25 | end
26 | end
27 |
28 | Blurb.new(:sick).time
29 |
30 | (参数 __content=""__ 是为了确保即使没有content参数被传入初始化方法中，
31 | content也是字符串。)
32 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_510.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 你教会了你的app拒绝做无意义的事
4 | answer: Blurb:
5 | ok: Blurb已添加
6 | error:
7 | load: class Blurb;attr_accessor :content,:time,:mood;def initialize(mood, content="");@time=Time.now;@content=content[0..39];@mood=mood;end;end;blurb1=Blurb.new(:sick,"Today Mount Hood Was Stolen!")
8 | ---
9 |
10 | 你注意到在类的内部我们使用了@（@time）吗？
11 | 在类 __之外__，我们用存储器:
12 |
13 | > __blurb.time = Time.now__
14 |
15 | 但是在类 __之内__ 我们用 __对象的变量__:
16 |
17 | > __@time = Time.now__
18 |
19 | They're the exact same thing, but expressed in two different places of your program.
20 | 这两种方式是等效的，只是在程序的不同地方表达了。
21 |
22 | ### 创建另一个BlurbTM
23 | 当一个新的BlurbTM被创建了，初始化方法将被用来检查是否有新的参数传入。
24 |
25 | 额，我们需要两个新参数:
26 |
27 | Blurb2 = Blurb.new :confused, "I can not believe Mt. Hood was stolen!"
28 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_520.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 长颈鹿没有偷总结 #7
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | load: prev;blurb2=Blurb.new :confused, "I can not believe Mt. Hood was stolen!"
9 | ---
10 |
11 | 啊哈，你已经到这了，还完完整整的嘛。我们仍将努力使你的app成为现实，
12 | 但是现在，我们来回顾一下。
13 |
14 | ### 类
15 | 在Ruby中，一切皆对象。类会解释一个特定的对象是怎么工作的。
16 | 比如，你创建了几个BlurbTM对象并且在BlurbTM类中对其进行了解释。
17 | 换句话说：你把他们叫做Blurb对象。
18 | 你可以用类来搭建真实生活中的对象。
19 |
20 | ### Accessors（存储器）
21 | 存储器是附着在对象中的可以在对象 __外__ 被调用的变量。
22 | (blurb2.time = Time.now)
23 |
24 | ### 对象变量
25 | 对象变量就是用以存储器的变量，两者相同，但是在对象 __内__。
26 | (@time = Time.now)
27 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_560.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 总结#8，嘿放松你已经做的很棒了-总结
4 | answer:
5 | class: stretcher chapmark
6 | ok:
7 | error:
8 | load: def ruby(f);puts "Go to www.ruby-lang.org to download Ruby";end;class K;attr_reader :rb;end;my_first_program=K.new
9 | ---
10 |
11 | 最后一个小节需要一点时间来消化，会教会你怎么使用Ruby的。
12 |
13 | 如果你很享受，你可以在这里继续TryRuby Playground
14 | 或者下载并安装Ruby:
15 | ruby-lang.org
16 |
17 | Ruby安装好了之后，你可以创建一个文件，命名为
18 | _my\_first\_program.rb_，如果有一个文本编辑器，打一些Ruby代码然后用下面的指令来运行：
19 |
20 | ruby my_first_program.rb
21 |
22 | 有很多（免费）开发工具自带编辑器，文件浏览器和一个‘Ruby运行环境’
23 |
24 | ## 🎉庆祝一下🎉
25 | 你真的值得一个双层蛋糕➕双层糖霜，和一个家伙在你旁边弹双层吉他。
26 | 我的意思是，你完成了，真的！毫无疑问，你已经是一个 __官方认证的活跃的聪明的人!__。
27 |
28 | ## 更多
29 | 这个网站中还有一些文章。它们能为你接下去的学习指引道路。
30 |
31 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_60.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 倒着念你的名字
4 | answer: \w+
5 | ok: 错不
6 | error:
7 | ---
8 |
9 | 字符串是指电脑可以处理的字符的组合。想象一下许多字符们被挂在晾衣线上，而这两个引号就像是衣夹。引号代表开端和结尾。
10 |
11 | 用下面这行代码来逆置你的名字:
12 |
13 | "Jimmy".reverse
14 |
15 | (别忘了打!)
16 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_70.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 数字母
4 | answer: ^\d+$
5 | ok: 是滴，.length也是一个‘方法’（method）
6 | error:
7 | ---
8 |
9 | 你已经对你的名字使用了逆置（.reverse）方法(method)！
10 | 把你的名字放进引号，你就有了一个字符串。然后你调用了逆置方法，这可以让你的名字倒过来写。
11 |
12 | 现在，让我们看看你的名字中有多少字母:
13 |
14 | "Jimmy".length
15 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_80.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 重复中
4 | answer: (\w+)
5 | ok: 很高兴认识你。很高兴认识你。很高兴认识你。
6 | error:
7 | ---
8 |
9 | 现在，你可能想知道这些东西有什么用。
10 |
11 | 好吧，我相信你一定去过某些网站，它尖叫着说：__嘿，你的密码太短了！__。
12 |
13 | 懂了吧，有程序使用了那个简单的 __.length__ 代码。
14 |
15 | 看好了。让我们把你的名字乘以5。
16 |
17 | "Jimmy" * 5
18 |
--------------------------------------------------------------------------------
/translations/zh/try_ruby_90.md:
--------------------------------------------------------------------------------
1 | ---
2 | lang: ZH
3 | title: 总结（第一部分）就到此为止!
4 | answer: NoMethodError|undefined|-e:in `eval'
5 | class: stretcher chapmark
6 | ok: 不不不，你不能逆置一个数字，点击‘Next’来继续
7 | error:
8 | ---
9 |
10 | 让我们看看你在第一分钟内学到了什么。
11 |
12 | ### 编辑器
13 | 在编辑器中输入代码，并点击运行，就会在输出窗口中得到一个答案。
14 | (几乎)所有的代码都会给出一个答案。
15 |
16 | ### 数字和字符串
17 | 数字和字符串是Ruby的数学和文本对象。
18 |
19 | ### 方法（Methods）
20 | 你已经使用了英文方法，如reverse和length。以及如乘法的符号方法。\*
21 | __方法指的是执行的行为!__
22 |
23 | 这是你学习的本质。把简单的东西，玩弄它们，并把它们组合
24 | 新东西。是不是感到很舒服？保证你是的。
25 |
26 | ## 好吧。
27 | 让我们做一些不舒服的事情。试试颠倒一个数字。
28 |
29 | 40.reverse
30 |
--------------------------------------------------------------------------------