+ Content
+ |
+ 1
+ |
+ 2
+ |
+ 3
+ |
+ 4
+ |
+ 5
+ |
+ 6
+ |
+ 7
+ |
+ 8
+ |
+ 9
+ |
+ 10
+ |
+ 11
+
+ Official Ruby FAQ
+ +--- + +{% include faq-notice.md %} + +## Iterators + +### What is an iterator? + +An iterator is a method which accepts a block or a `Proc` object. In the +source file, the block is placed immediately after the invocation of the +method. Iterators are used to produce user-defined control +structures---especially loops. + +Let's look at an example to see how this works. Iterators are often used to +repeat the same action on each element of a collection, like this: + +~~~ +data = [1, 2, 3] +data.each do |i| + puts i +end +~~~ + +Produces: + +~~~ +1 +2 +3 +~~~ + +The each method of the array `data` is passed the `do ... end` block, +and executes it repeatedly. On each call, the block is passed successive +elements of the array. + +You can define blocks with `{ ... }` in place of `do ... end`. + +~~~ +data = [1, 2, 3] +data.each { |i| + puts i +} +~~~ + +Produces: + +~~~ +1 +2 +3 +~~~ + +This code has the same meaning as the last example. However, in some cases, +precedence issues cause `do ... end` and `{ ... }` to act differently. + +~~~ +foobar a, b do ... end # foobar is the iterator. +foobar a, b { ... } # b is the iterator. +~~~ + +This is because `{ ... }` binds more tightly to the preceding expression +than does a `do ... end` block. The first example is equivalent to +`foobar(a, b) do ... end`, while the second is `foobar(a, b { ... })`. + +### How can I pass a block to an iterator? + +You simply place the block after the iterator call. You can also pass a +`Proc` object by prepending `&` to the variable or constant name that refers +to the `Proc`. + +### How is a block used in an iterator? + +{% include warnings/faq-out-of-date.html %} + +There are three ways to execute a block from an iterator method: +(1) the `yield` control structure; (2) calling a `Proc` argument +(made from a block) with `call`; and (3) using `Proc.new` followed by a call. + +The `yield` statement calls the block, optionally passing it one or more +arguments. + +~~~ +def my_iterator + yield 1, 2 +end + +my_iterator {|a, b| puts a, b } +~~~ + +Produces: + +~~~ +1 +2 +~~~ + +If a method definition has a block argument (the last formal parameter has +an ampersand (`&`) prepended), it will receive the attached block, converted +to a `Proc` object. This may be called using `prc.call(args)`. + +~~~ +def my_iterator(&b) + b.call(1, 2) +end + +my_iterator {|a, b| puts a, b } +~~~ + +Produces: + +~~~ +1 +2 +~~~ + +`Proc.new` (or the equivalent `proc` or `lambda` calls), when used in an +iterator definition, takes the block which is given to the method as its +argument and generates a procedure object from it. +(`proc` and `lambda` are effectively synonyms.) + +_[Update needed: `lambda` behaves in a slightly different way and +produces a warning `tried to create Proc object without a block`.]_ + +~~~ +def my_iterator + Proc.new.call(3, 4) + proc.call(5, 6) + lambda.call(7, 8) +end + +my_iterator {|a, b| puts a, b } +~~~ + +Produces: + +~~~ +3 +4 +5 +6 +7 +8 +~~~ + +Perhaps surprisingly, `Proc.new` and friends do not in any sense consume +the block attached to the method---each call to `Proc.new` generates a new +procedure object out of the same block. + +You can tell if there is a block associated with a method by calling +`block_given?`. + +### What does `Proc.new` without a block do? + +`Proc.new` without a block cannot generate a procedure object and an error +occurs. In a method definition, however, `Proc.new` without a block implies +the existence of a block at the time the method is called, and so no error +will occur. + +### How can I run iterators in parallel? + +Here an adoption of a solution by Matz, in +[\[ruby-talk:5252\]][ruby-talk:5252], that uses threads: + +~~~ +require "thread" + +def combine(*iterators) + queues = [] + threads = [] + + iterators.each do |it| + queue = SizedQueue.new(1) + th = Thread.new(it, queue) do |i, q| + send(i) {|x| q << x } + end + queues << queue + threads << th + end + + loop do + ary = [] + queues.each {|q| ary << q.pop } + yield ary + + iterators.size.times do |i| + return if !threads[i].status && queues[i].empty? + end + end +end + +def it1 + yield 1; yield 2; yield 3 +end + +def it2 + yield 4; yield 5; yield 6 +end + +combine(:it1, :it2) do |x| + # x is [1, 4], then [2, 5], then [3, 6] +end +~~~ + +[ruby-talk:5252]: https://blade.ruby-lang.org/ruby-talk/5252 diff --git a/ru/documentation/faq/6/index.md b/ru/documentation/faq/6/index.md new file mode 100644 index 0000000000..5cd8faf3eb --- /dev/null +++ b/ru/documentation/faq/6/index.md @@ -0,0 +1,293 @@ +--- +layout: page +title: "Official Ruby FAQ" +lang: ru + +header: | +
+ Content
+ |
+ 1
+ |
+ 2
+ |
+ 3
+ |
+ 4
+ |
+ 5
+ |
+ 6
+ |
+ 7
+ |
+ 8
+ |
+ 9
+ |
+ 10
+ |
+ 11
+
+ Official Ruby FAQ
+ +--- + +{% include faq-notice.md %} + +## Syntax + +### What is the difference between an immediate value and a reference? +{: #immediate} + +{% include warnings/faq-out-of-date.html %} + +`Fixnum`, `true`, `nil`, and `false` are implemented as immediate values. +With immediate values, variables hold the objects themselves, rather than +references to them. + +Singleton methods cannot be defined for such objects. Two `Fixnums` of the +same value always represent the same object instance, so (for example) +instance variables for the `Fixnum` with the value `1` are shared between +all the `1`'s in the system. This makes it impossible to define a singleton +method for just one of these. + +### What is the difference between `nil` and `false`? + +First the similarity: `nil` and `false` are the only two objects +that evaluate to `false` in a boolean context. +(In other words: they are the only “falsy” values, all other +objects are “truthy”.) + +However, `nil` and `false` are instances of different classes +(`NilClass` and `FalseClass`), and have different behavior elsewhere. + +We recommend that predicate methods (those whose name ends with a question +mark) return `true` or `false`. Other methods that need to indicate failure +should return `nil`. + +### Why is an empty string not `false`? + +Q: An empty string (`""`) returns `true` in a conditional expression! +In Perl, it's `false`. + +A: But Ruby is not Perl ;-). It's very simple: in Ruby, only `nil` +and `false` are false in conditional contexts. + +You can use `empty?`, compare the string to `""`, or compare the string's +`size` or `length` to `0` to find out if a string is empty. + +### What does `:name` mean? + +A colon followed by a name generates a Symbol object which corresponds +one to one with the identifier. During the duration of a program's +execution the same Symbol object will be created for a given name or string. +Symbols can also be created with `"name".intern` or `"name".to_sym`. + +Symbol objects can represent identifiers for methods, variables, and so on. +Some methods, like `define_method`, `method_missing`, or `trace_var`, +require a symbol. Other methods, e.g. `attr_accessor`, `send`, or `autoload`, +also accept a string. + +Due to the fact that they are created only once, Symbols are often used as +hash keys. String hash keys would create a new object for every single use, +thereby causing some memory overhead. +There is even a special syntax for symbol hash keys: + +~~~ +person_1 = { :name => "John", :age => 42 } +person_2 = { name: "Jane", age: 24 } # alternate syntax +~~~ + +Symbols can also be used as enumeration values +or to assign unique values to constants: + +~~~ +status = :open # :closed, ... + +NORTH = :NORTH +SOUTH = :SOUTH +~~~ + +### How can I access the value of a symbol? + +To get the value of the variable corresponding to a symbol, you can use +`symbol.to_s` or `"#{symbol}"` to get the name of the variable, and then +eval that in the scope of the symbol to get the variable's contents: + +~~~ +a = "This is the content of `a'" +b = eval("#{:a}") +a.object_id == b.object_id # => true +~~~ + +You can also use + +~~~ +b = binding.local_variable_get(:a) +~~~ + +If your symbol corresponds to the name of a method, you can use `send`: + +~~~ +class Demo + def hello + "Hello, world" + end +end + +demo = Demo.new +demo.send(:hello) +~~~ + +Or you can use `Object#method` to return a corresponding `Method` object, +which you may then call: + +~~~ +m = demo.method(:hello) # => #
+ Content
+ |
+ 1
+ |
+ 2
+ |
+ 3
+ |
+ 4
+ |
+ 5
+ |
+ 6
+ |
+ 7
+ |
+ 8
+ |
+ 9
+ |
+ 10
+ |
+ 11
+
+ Official Ruby FAQ
+ +--- + +{% include faq-notice.md %} + +## Methods + +### How does Ruby choose which method to invoke? + +Ruby binds all messages to methods dynamically. It searches first for +singleton methods in the receiver, then for methods defined in the receiver's +own class, and finally for methods defined in the receiver's superclasses +(including any modules which may have been mixed in). You can see the order +of searching by displaying `ClassName.ancestors`, which shows the ancestor +classes and modules of `ClassName`. + +If after searching the alternatives a matching method could not be found, +Ruby tries to invoke a method called `method_missing`, repeating the same +search procedure to find it. This allows you to handle messages to unknown +methods, and is often used to provide dynamic interfaces to classes. + +~~~ +module Emphasizable + def emphasize + "**#{self}**" + end +end + +class String + include Emphasizable +end + +String.ancestors + # => [String, Emphasizable, Comparable, Object, Kernel, BasicObject] + +"Wow!".emphasize # => "**Wow!**" +~~~ + +When the method `emphasize` is searched for, it is not found in class +`String`, so Ruby searches next in the module `Emphasizable`. + +In order to override a method that already exists in the receiver's class, +e.g. `String#capitalize`, you need to insert the module into the +ancestor chain in front of that class, by using `prepend`: + +~~~ +module PrettyCapitalize + def capitalize + "**#{super}**" + end +end + +class String + prepend PrettyCapitalize +end + +String.ancestors + # => [PrettyCapitalize, String, Comparable, Object, Kernel, BasicObject] + +"hello".capitalize # => "**Hello**" +~~~ + +### Are `+`, `-`, `*`, ... operators? + +`+`, `-`, and the like are not operators but method calls. +They can, therefore, be overloaded by new definitions. + +~~~ +class MyString < String + def -(other) + self[0...other.size] # self truncated to other's size + end +end +~~~ + +However, the following are built-in control structures, not methods, +which cannot be overridden: + +~~~ +=, .., ..., not, ||, &&, and, or, :: +~~~ + +To overload or to define the unary `+` and `-` operators, +you need to use `+@` and `-@` as the method names. + +`=` is used to define a method to set an attribute of the object: + +~~~ +class Test + def attribute=(val) + @attribute = val + end +end + +t = Test.new +t.attribute = 1 +~~~ + +If operators such as `+` and `-` are defined, Ruby automatically handles +the self assignment forms (`+=`, `-=`, and so on). + +### Where are `++` and `--` ? + +Ruby does not have the autoincrement and autodecrement operators. +You can use `+= 1` and `-= 1` instead. + +### What is a singleton method? +{: #singleton-method} + +A singleton method is an instance method associated with one specific object. + +You create a singleton method by including the object in the definition: + +~~~ +class Foo; end + +foo = Foo.new +bar = Foo.new + +def foo.hello + puts "Hello" +end + +foo.hello +bar.hello +~~~ + +Produces: + +~~~ +Hello +prog.rb:11:in `
+ Content
+ |
+ 1
+ |
+ 2
+ |
+ 3
+ |
+ 4
+ |
+ 5
+ |
+ 6
+ |
+ 7
+ |
+ 8
+ |
+ 9
+ |
+ 10
+ |
+ 11
+
+ Official Ruby FAQ
+ +--- + +{% include faq-notice.md %} + +## Classes and modules + +### Can a class definition be repeated? + +A class can be defined repeatedly. Each definition is added to the last +definition. If a method is redefined, the former one is overridden and lost. + +### Are there class variables? + +There are. A variable prefixed with two at signs (`@@`) is a class variable, +accessible within both instance and class methods of the class. + +~~~ +class Entity + + @@instances = 0 + + def initialize + @@instances += 1 + @number = @@instances + end + + def who_am_i + "I'm #{@number} of #{@@instances}" + end + + def self.total + @@instances + end +end + +entities = Array.new(9) { Entity.new } + +entities[6].who_am_i # => "I'm 7 of 9" +Entity.total # => 9 +~~~ + +However, you probably should use _class instance variables_ instead. + +### What is a class instance variable? + +Here the example of the previous section rewritten +using a class instance variable: + +~~~ +class Entity + + @instances = 0 + + class << self + attr_accessor :instances # provide class methods for reading/writing + end + + def initialize + self.class.instances += 1 + @number = self.class.instances + end + + def who_am_i + "I'm #{@number} of #{self.class.instances}" + end + + def self.total + @instances + end +end + +entities = Array.new(9) { Entity.new } + +entities[6].who_am_i # => "I'm 7 of 9" +Entity.instances # => 9 +Entity.total # => 9 +~~~ + +Here, `@instances` is a _class_ instance variable. It does not belong +to an instance of class `Entity`, but to the class object `Entity`, +which is an instance of class `Class`. + +Class instance variables are directly accessible only within class methods +of the class. + +### What is the difference between class variables and class instance variables? + +The main difference is the behavior concerning inheritance: +class variables are shared between a class and all its subclasses, +while class instance variables only belong to one specific class. + +Class variables in some way can be seen as global variables within +the context of an inheritance hierarchy, with all the problems +that come with global variables. +For instance, a class variable might (accidentally) be reassigned +by any of its subclasses, affecting all other classes: + +~~~ +class Woof + + @@sound = "woof" + + def self.sound + @@sound + end +end + +Woof.sound # => "woof" + +class LoudWoof < Woof + @@sound = "WOOF" +end + +LoudWoof.sound # => "WOOF" +Woof.sound # => "WOOF" (!) +~~~ + +Or, an ancestor class might later be reopened and changed, +with possibly surprising effects: + +~~~ +class Foo + + @@var = "foo" + + def self.var + @@var + end +end + +Foo.var # => "foo" (as expected) + +class Object + @@var = "object" +end + +Foo.var # => "object" (!) +~~~ + +So, unless you exactly know what you are doing and explicitly need +this kind of behavior, you better should use class instance variables. + +### Does Ruby have class methods? +{: #class-method} + +A [singleton method](../7/#singleton-method) of a class object is called a +class method. +(Actually, the class method is defined in the metaclass, but that is pretty +much transparent). Another way of looking at it is to say that a class method +is a method whose receiver is a class. + +It all comes down to the fact that you can call class methods without having +to have instances of that class (objects) as the receiver. + +Let's create a singleton method of class `Foo`: + +~~~ +class Foo + def self.test + "this is foo" + end +end + +# It is invoked this way. + +Foo.test # => "this is foo" +~~~ + +In this example, `Foo.test` is a class method. + +Instance methods which are defined in class `Class` can be used +as class methods for every(!) class. + +### What is a singleton class? + +A singleton class is an anonymous class that is created by subclassing the +class associated with a particular object. Singleton classes are another +way of extending the functionality associated with just one object. + +Take the lowly `Foo`: + +~~~ +class Foo + def hello + "hello" + end +end + +foo = Foo.new +foo.hello # => "hello" +~~~ + +Now let's say we need to add class-level functionality to just this one +instance: + +~~~ +class << foo + attr_accessor :name + + def hello + "hello, I'm #{name}" + end +end + +foo.name = "Tom" +foo.hello # => "hello, I'm Tom" +Foo.new.hello # => "hello" +~~~ + +We've customized `foo` without changing the characteristics of `Foo`. + +### What is a module function? + +{% include warnings/faq-out-of-date.html %} + +A module function is a private, singleton method defined in a module. +In effect, it is similar to a [class method](#class-method), +in that it can be called using the `Module.method` notation: + +~~~ +Math.sqrt(2) # => 1.414213562 +~~~ + +However, because modules can be mixed in to classes, module functions can +also be used without the prefix (that's how all those `Kernel` functions are +made available to objects): + +~~~ +include Math +sqrt(2) # => 1.414213562 +~~~ + +Use `module_function` to make a method a module function. + +~~~ +module Test + def thing + # ... + end + module_function :thing +end +~~~ + +### What is the difference between a class and a module? + +Modules are collections of methods and constants. They cannot generate +instances. Classes may generate instances (objects), and have per-instance +state (instance variables). + +Modules may be mixed in to classes and other modules. The mixed in module's +constants and methods blend into that class's own, augmenting the class's +functionality. Classes, however, cannot be mixed in to anything. + +A class may inherit from another class, but not from a module. + +A module may not inherit from anything. + +### Can you subclass modules? + +No. However, a module may be included in a class or another module to mimic +multiple inheritance (the mixin facility). + +This does not generate a subclass (which would require inheritance), but does +generate an `is_a?` relationship between the class and the module. + +### Give me an example of a mixin + +The module `Comparable` provides a variety of comparison operators +(`<`, `<=`, `==`, `>=`, `>`, `between?`). It defines these in terms +of calls to the general comparison method, `<=>`. However, it does +not itself define `<=>`. + +Say you want to create a class where comparisons are based on the number of +legs an animal has: + +~~~ +class Animal + include Comparable + + attr_reader :legs + + def initialize(name, legs) + @name, @legs = name, legs + end + + def <=>(other) + legs <=> other.legs + end + + def inspect + @name + end +end + +c = Animal.new("cat", 4) +s = Animal.new("snake", 0) +p = Animal.new("parrot", 2) + +c < s # => false +s < c # => true +p >= s # => true +p.between?(s, c) # => true +[p, s, c].sort # => [snake, parrot, cat] +~~~ + +All `Animal` must do is define its own semantics for the operator `<=>`, +and mix in the `Comparable` module. `Comparable`'s methods now become +indistinguishable from `Animal`'s and your class suddenly sprouts new +functionality. And because the same `Comparable` module is used by many +classes, your new class will share a consistent and well understood semantics. + +### Why are there two ways of defining class methods? + +You can define a class method in the class definition, and you can define +a class method at the top level. + +~~~ +class Demo + def self.class_method + end +end + +def Demo.another_class_method +end +~~~ + +There is only one significant difference between the two. +In the class definition you can refer to the class's constants directly, +as the constants are within scope. At the top level, you have to use the +`Class::CONST` notation. + +### What is the difference between `include` and `extend`? + +{% include warnings/faq-out-of-date.html %} + +`include` mixes a module into a class or another module. Methods from that +module are called function-style (without a receiver). + +`extend` is used to include a module in an object (instance). +Methods in the module become methods in the object. + +### What does `self` mean? + +`self` is the currently executing receiver, the object to which a method +is applied. A function-style method call implies `self` as the receiver. diff --git a/ru/documentation/faq/9/index.md b/ru/documentation/faq/9/index.md new file mode 100644 index 0000000000..6170dd8552 --- /dev/null +++ b/ru/documentation/faq/9/index.md @@ -0,0 +1,372 @@ +--- +layout: page +title: "Official Ruby FAQ" +lang: ru + +header: | +
+ Content
+ |
+ 1
+ |
+ 2
+ |
+ 3
+ |
+ 4
+ |
+ 5
+ |
+ 6
+ |
+ 7
+ |
+ 8
+ |
+ 9
+ |
+ 10
+ |
+ 11
+
+ Official Ruby FAQ
+ +--- + +{% include faq-notice.md %} + +## Built-in libraries + +### What does `instance_methods(false)` return? + +The method `instance_methods` returns an array containing the names of +instance methods in the receiving class or module. This will include +the methods in superclasses and in mixed in modules. + +`instance_methods(false)` or `instance_methods(nil)` returns the names +of just those methods which are defined in the receiver. + +### How do random number seeds work? + +If `rand` is called without a prior call to `srand`, +Ruby's pseudo-random number generator uses a random(ish) seed that +amongst other things uses an entropy source provided by the OS, +if available. +Successive runs of a program that does not use `srand` will generate +different sequences of random numbers. + +For testing purposes, you can get a predictable behavior with the same +series of numbers each time the program is run by calling `srand` +with a constant seed. + +### I read a file and changed it, but the file on disk has not changed. + +~~~ +File.open("example", "r+").readlines.each_with_index do |line, i| + line[0,0] = "#{i+1}: " +end +~~~ + +This program does _not_ add line numbers to the file `example`. It does read +the contents of the file, and for each line read does prepend the line number, +but the data is never written back. The code below _does_ update the file +(although somewhat dangerously, as it takes no backup before starting the +update): + +~~~ +File.open("example", "r+") do |f| + lines = f.readlines + lines.each_with_index {|line, i| line[0,0] = "#{i+1}: " } + f.rewind + f.puts lines +end +~~~ + +### How can I process a file and update its contents? + +Using the command-line option `-i`, or built-in variable `$-i`, you can read +a file and replace it. + +The code in the preceding question, which added line numbers to a file, +is probably best written using this technique: + +~~~ +$ ruby -i -ne 'print "#$.: #$_"' example +~~~ + +If you want to preserve the original file, use `-i.bak` to create a backup. + +### I wrote a file, copied it, but the end of the copy seems to be lost. + +This code will not work correctly: + +~~~ +require "fileutils" + +File.open("file", "w").puts "This is a file." +FileUtils.cp("file", "newfile") +~~~ + +Because I/O is buffered, `file` is being copied before its contents have been +written to disk. `newfile` will probably be empty. However, when the program +terminates, the buffers are flushed, and file has the expected content. + +The problem doesn't arise if you make sure that `file` is closed before +copying: + +~~~ +require "fileutils" + +File.open("file", "w") {|f| f.puts "This is a file." } +FileUtils.cp("file", "newfile") +~~~ + +### How can I get the line number in the current input file? + +As you read from a file, Ruby increments a line number counter in the global +variable `$.`. This is also available using the `lineno` attribute of the +`File` object. + +The special constant `ARGF` is a file-like object that can be used to read +all the input files specified on the command line (or standard input if there +are no files). `ARGF` is used implicitly by code such as: + +~~~ +while gets + print $_ +end +~~~ + +In this case, `$.` will be the cumulative number of lines read across all +input files. To get the line number in the current file, use + +~~~ +ARGF.file.lineno +~~~ + +You can also get the name of the current file using `ARGF.file.path`. + +### How can I use `less` to display my program's output? + +I tried the following, but nothing came out: + +~~~ +open("|less", "w").puts "abc" +~~~ + +That's because the program ends immediately, and `less` never gets a chance +to see the stuff you've written to it, never mind to display it. +Make sure that the IO is properly closed and it will wait until `less` ends. + +~~~ +open("|less", "w") {|f| f.puts "abc" } +~~~ + +### What happens to a `File` object which is no longer referenced? + +A `File` object which is no longer referenced becomes eligible for garbage +collection. The file will be closed automatically when the `File` object is +garbage collected. + +### I feel uneasy if I don't close a file. + +There are at least four good ways of ensuring that you do close a file: + +~~~ +# (1) +f = File.open("file") +begin + f.each {|line| print line } +ensure + f.close +end + +# (2) +File.open("file") do |f| + f.each {|line| print line } +end + +# (3) +File.foreach("file") {|line| print line } + +# (4) +File.readlines("file").each {|line| print line } +~~~ + +### How can I sort files by their modification time? + +~~~ +Dir.glob("*").sort {|a, b| File.mtime(b) <=> File.mtime(a) } +~~~ + +Although this works (returning a list in reverse chronological order) it +isn't very efficient, as it fetches the files' modification times from the +operating system on every comparison. + +More efficiency can be bought with some extra complexity: + +~~~ +Dir.glob("*").map {|f| [File.mtime(f), f] }. + sort {|a, b| b[0] <=> a[0] }.map(&:last) +~~~ + +### How can I count the frequency of words in a file? + +~~~ +freq = Hash.new(0) +File.read("example").scan(/\w+/) {|word| freq[word] += 1 } +freq.keys.sort.each {|word| puts "#{word}: #{freq[word]}" } +~~~ + +Produces: + +~~~ +and: 1 +is: 3 +line: 3 +one: 1 +this: 3 +three: 1 +two: 1 +~~~ + +### How can I sort strings in alphabetical order? + +If you want your strings to sort 'AAA', 'BBB', ..., 'ZZZ', 'aaa', 'bbb', +then the built-in comparison will work just fine. + +If you want to sort ignoring case distinctions, compare downcased versions of +the strings in the sort block: + +~~~ +array = %w( z bB Bb bb Aa BB aA AA aa a A ) +array.sort {|a, b| a.downcase <=> b.downcase } + # => ["a", "A", "Aa", "aA", "AA", "aa", "bB", "Bb", "bb", "BB", "z"] +~~~ + +If you want to sort so that the 'A's and 'a's come together, but 'a' is +considered greater than 'A' (so 'Aa' comes after 'AA' but before 'AB'), use: + +~~~ +array.sort {|a, b| (a.downcase <=> b.downcase).nonzero? || a <=> b } + # => ["A", "a", "AA", "Aa", "aA", "aa", "BB", "Bb", "bB", "bb", "z"] +~~~ + +### How can I expand tabs to spaces? +{: #tab-expansion} + +If `a` holds the string to be expanded, you could use one of: + +~~~ +1 while a.sub!(/(^[^\t]*)\t(\t*)/){$1+" "*(8-$1.size%8+8*$2.size)} +# or +1 while a.sub!(/\t(\t*)/){" "*(8-$~.begin(0)%8+8*$1.size)} +# or +a.gsub!(/([^\t]{8})|([^\t]*)\t/n){[$+].pack("A8")} +~~~ + +### How can I escape a backslash in a regular expression? + +`Regexp.quote('\\')` escapes a backslash. + +It gets trickier if you are using `sub` and `gsub`. Say you write +`gsub(/\\/, '\\\\')`, hoping to replace each backslash with two. +The second argument is converted to `'\\'` in syntax analysis. When the +substitution occurs, the regular expression engine converts this to `'\'`, +so the net effect is to replace each single backslash with another single +backslash. You need to write `gsub(/\\/, '\\\\\\')`! + +However, using the fact that `\&` contains the matched string, you could also +write `gsub(/\\/, '\&\&')`. + +If you use the block form of `gsub`, i.e. `gsub(/\\/) { '\\\\' }`, the string +for substitution is analyzed only once (during the syntax pass) and the +result is what you intended. + +### What is the difference between `sub` and `sub!`? + +In `sub`, a copy of the receiver is generated, substituted, and returned. + +In `sub!`, the receiver is altered and returned if any match was found. +Otherwise, `nil` is returned. + +Methods like `sub!`, which alter the attribute of the receiver, +are called [destructive methods](../7/#destructive-method). +Usually, if there are two similar methods and one is destructive, +the destructive one has a suffix `!`. + +~~~ +def foo(str) + str.sub(/foo/, "baz") +end + +obj = "foo" +foo(obj) # => "baz" +obj # => "foo" + +def foo(str) + str.sub!(/foo/, "baz") +end + +foo(obj) # => "baz" +obj # => "baz" +~~~ + +### Where does `\Z` match? + +`\Z` matches just before the last `\n` (newline) if the string ends +with a `\n`, otherwise it matches at the end of a string. + +### What is the difference between `thread` and `fork`? + +{% include warnings/faq-out-of-date.html %} + +Ruby threads are implemented within the interpreter, while `fork` invokes the +operating system to create a separately executing subprocess. + +Thread and fork have the following characteristics: + +* `fork` is slow, `thread` is not. +* `fork` does not share the memory space. +* `thread` does not cause thrashing. +* `thread` works on DOS. +* When `thread` gets in a deadlock, the whole process stops. +* `fork` can take advantage of pauses waiting for I/O to complete, + `thread` does not (at least not without some help). + +You probably shouldn't mix `fork` and `thread`. + +### How can I use `Marshal`? + +`Marshal` is used to store an object in a file or a string, and later +reconstitute it. Objects may be stored using: + +~~~ +Marshal.dump( obj [, io ] [, lev] ) +~~~ + +`io` is a writable `IO` object, `lev` designates the level to which objects +are dereferred and stored. If `lev` levels of dereferring are done and object +references still exist, then `dump` stores just the reference, not the object +referenced. This is not good, as these referenced objects cannot be +subsequently reconstructed. + +If `io` is omitted, the marshaled objects are returned in a string. + +You can load objects back using: + +~~~ +obj = Marshal.load(io) +# or +obj = Marshal.load(str) +~~~ + +where `io` is a readable `IO` object, `str` is the dumped string. + +### How can I use `trap`? + +`trap` associates code blocks with external events (signals). + +~~~ +trap("PIPE") { raise "SIGPIPE" } +~~~ diff --git a/ru/documentation/faq/index.md b/ru/documentation/faq/index.md new file mode 100644 index 0000000000..91c978b8f7 --- /dev/null +++ b/ru/documentation/faq/index.md @@ -0,0 +1,62 @@ +--- +layout: page +title: "Official Ruby FAQ" +lang: ru + +header: | +
+ Content
+ |
+ 1
+ |
+ 2
+ |
+ 3
+ |
+ 4
+ |
+ 5
+ |
+ 6
+ |
+ 7
+ |
+ 8
+ |
+ 9
+ |
+ 10
+ |
+ 11
+
+ Official Ruby FAQ
+ +--- + +This document contains Frequently Asked Questions about Ruby with answers. +{: .summary} + +This FAQ is based on "[The Ruby Language FAQ][original-faq]" originally +compiled by Shugo Maeda and translated into English by Kentaro Goto. +Thanks to Zachary Scott and Marcus Stollsteimer for incorporating +the FAQ into the site and for a major overhaul of the content. + +The code examples in this document have been run using Ruby 2.3. + +[original-faq]: http://ruby-doc.org/docs/ruby-doc-bundle/FAQ/FAQ.html + +{% include faq-notice.md %} + +## Content + +* [General questions](1/) +* [How does Ruby stack up against...?](2/) +* [Installing Ruby](3/) +* [Variables, constants, and arguments](4/) +* [Iterators](5/) +* [Syntax](6/) +* [Methods](7/) +* [Classes and modules](8/) +* [Built-in libraries](9/) +* [Extension library](10/) +* [Other features](11/) diff --git a/ru/downloads/branches/index.md b/ru/downloads/branches/index.md new file mode 100644 index 0000000000..f1f230032c --- /dev/null +++ b/ru/downloads/branches/index.md @@ -0,0 +1,38 @@ +--- +layout: page +title: "Ruby Maintenance Branches" +lang: ru +--- + +This page lists the current maintenance status of the various Ruby branches. +{: .summary} + +For more information about specific releases see the +[Releases page](../releases/). + +This is a preliminary list of Ruby branches and their maintenance status. +The shown dates are inferred from the English versions of release posts +or EOL announcements. + +The Ruby branches or release series are categorized below into +the following phases: + +* **normal maintenance** (bug fix): + Branch receives general bug fixes and security fixes. +* **security maintenance** (security fix): + Only security fixes are backported to this branch. +* **eol** (end-of-life): + Branch is not supported by the ruby-core team any longer and does + not receive any fixes. No further patch release will be released. + +{% include branches-timeline.html %} + +{% for branch in site.data.branches %} +### Ruby {{ branch.name }} + +status: {{ branch.status }}+release date: {{ branch.date }}
+normal maintenance until: {% if branch.security_maintenance_date %}{{ branch.security_maintenance_date }}{% else %}TBD{% endif %}
+EOL: {% if branch.eol_date %}{{ branch.eol_date }}{% else %}{% if branch.expected_eol_date %}{{ branch.expected_eol_date }} (expected){% else %}TBD{% endif %}{% endif %} + +{% endfor %} diff --git a/ru/downloads/mirrors/index.md b/ru/downloads/mirrors/index.md new file mode 100644 index 0000000000..310a55f811 --- /dev/null +++ b/ru/downloads/mirrors/index.md @@ -0,0 +1,49 @@ +--- +layout: page +title: "Mirror Sites" +lang: ru +--- + +{% comment %} +Not to be translated. Link to this page (/en/downloads/mirrors/) instead. +{% endcomment %} + +The Ruby source is available from a worldwide set of mirror sites. +Please try to use a mirror that is near you. +{: .summary} + +### Mirror sites via HTTP + +* [CDN][mirror-https-cdn] (fastly.com) +* [Japan][mirror-http-jp-ring] (RingServer) +* [Holland][mirror-http-nl] (XS4ALL) - only release packages +* [France][mirror-http-fr] (cyberbits.eu) +* [China 2][mirror-http-cn2] (Ruby China) +* [South Korea][mirror-http-kr] (Korea FreeBSD Users Group) + +### Mirror sites via FTP + +* [Japan][mirror-ftp-jp-ring] (RingServer) +* [Japan 3][mirror-ftp-jp3] (IIJ) +* [South Korea][mirror-ftp-kr] (Korea FreeBSD Users Group) +* [Germany][mirror-ftp-de] (FU Berlin) +* [Greece][mirror-ftp-gr] (ntua.gr) + +### Mirror sites via rsync + +* [France][mirror-rsync-fr] (cyberbits.eu) +* [South Korea][mirror-rsync-kr] (Korea FreeBSD Users Group) + +[mirror-https-cdn]: https://cache.ruby-lang.org/pub/ruby/ +[mirror-http-jp-ring]: http://www.ring.gr.jp/pub/lang/ruby/ +[mirror-http-nl]: http://www.xs4all.nl/~hipster/lib/mirror/ruby/ +[mirror-http-fr]: https://mirror.cyberbits.eu/ruby/ +[mirror-http-cn2]: https://cache.ruby-china.com/pub/ruby/ +[mirror-http-kr]: http://ftp.kr.freebsd.org/pub/ruby/ +[mirror-ftp-jp-ring]: ftp://ftp.ring.gr.jp/pub/lang/ruby/ +[mirror-ftp-jp3]: ftp://ftp.iij.ad.jp/pub/lang/ruby/ +[mirror-ftp-kr]: ftp://ftp.kr.freebsd.org/pub/ruby/ +[mirror-ftp-de]: ftp://ftp.fu-berlin.de/unix/languages/ruby/ +[mirror-ftp-gr]: ftp://ftp.ntua.gr/pub/lang/ruby/ +[mirror-rsync-fr]: rsync://rsync.cyberbits.eu/ruby/ +[mirror-rsync-kr]: rsync://rsync.kr.freebsd.org/ruby/ diff --git a/ru/downloads/releases/index.md b/ru/downloads/releases/index.md new file mode 100644 index 0000000000..bdbf09e595 --- /dev/null +++ b/ru/downloads/releases/index.md @@ -0,0 +1,36 @@ +--- +layout: page +title: "Ruby Releases" +lang: ru +--- + +This page lists individual Ruby releases. +{: .summary} + +For information about the current maintenance status of the various +Ruby branches see the +[Branches page](../branches/). + +### Ruby releases by version number + +This is a list of Ruby releases. +The shown dates correspond to the publication dates of the +English versions of release posts and may differ from the +actual creation dates of the source tarballs. + +
| Release Version | +Release Date | +Download URL | +Release Notes | +
|---|---|---|---|
| Ruby {{ release.version }} | +{{ release.date }} | +download | +more... | +