View source for Ruby Programming/Overview

You do not have permission to edit this page, for the following reason:

Your IP address is in a range that has been blocked on all Wikimedia Foundation wikis.

The block was made by ‪Jon Kolbert‬. The reason given is Open proxy/Webhost: See the help page if you are affected .

Start of block: 05:37, 21 February 2024
Expiry of block: 05:37, 21 February 2029

Your current IP address is 18.188.245.194. The blocked range is 18.188.0.0/16.

Please include all above details in any queries you make.

If you believe you were blocked by mistake, you can find additional information and instructions in the Stewards Block Wizard.

You can view and copy the source of this page.

{{Ruby Programming/TopNav|next=Installing Ruby}}

Ruby is an [[w:Object-oriented programming|object-oriented]] [[w:Scripting programming language|scripting language]] originally developed by [[w:Yukihiro Matsumoto|Yukihiro Matsumoto]] (also known as Matz). The main website of the Ruby programming language is [http://www.ruby-lang.org/ ruby-lang.org]. Development began in February 1993 and the first alpha version of Ruby was released in December 1994. It was developed as an alternative to scripting languages like [[w:Perl|Perl]] and [[w:Python programming language|Python]].<ref name=oreilly-matz-interview>{{cite web | url=http://www.linuxdevcenter.com/pub/a/linux/2001/11/29/ruby.html | title=An Interview with the Creator of Ruby | author=Bruce Stewart | date=November 29, 2001 | publisher=O'Reilly | accessdate=2006-09-11 }}</ref> Ruby borrows heavily from Perl and the class library is essentially an object-oriented reorganization of Perl's functionality. Ruby also borrows from [[w:Lisp|Lisp]] and [[w:Smalltalk|Smalltalk]]. While Ruby does not borrow many features from Python, reading the code for Python helped Matz develop Ruby.<ref name=oreilly-matz-interview/>

[[w:macOS|MacOS]] comes with Ruby already installed. Most [[w:Linux|Linux]] distributions either come with Ruby preinstalled or allow you to easily install Ruby from the distribution's repository of [[w:free software|free software]]. You can also download and install Ruby on [[w:Microsoft Windows|Windows]]. The more technically adept can download the Ruby source code<ref name=ruby-download>{{cite web | url=http://www.ruby-lang.org/en/downloads/ | title=Download Ruby | accessdate=2006-09-11}}</ref> and compile it for most [[w:operating system|operating systems]], including [[w:Unix|Unix]], [[w:DOS|DOS]], [[w:BeOS|BeOS]], [[w:OS/2|OS/2]], Windows, and Linux.<ref name=ruby-about>{{cite web | url=http://www.ruby-lang.org/en/about/ | title=About Ruby | accessdate=2006-09-11}}</ref>

== Features ==

Ruby combines features from Perl, Smalltalk, [[w:Eiffel (programming language)|Eiffel]], [[w:Ada (programming language)|Ada]], Lisp, and Python.<ref name=ruby-about/>

=== Object Oriented ===

Ruby goes to great lengths to be a purely object oriented language. Every value in Ruby is an object, even the most primitive things: strings, numbers and even <tt>true</tt> and <tt>false</tt>. Every object has a ''class'' and every class has one ''superclass''. At the root of the class hierarchy is the class <tt>BasicObject</tt>, from which all other classes, including <tt>Object</tt>, inherit.

Every class has a set of ''methods'' which can be called on objects of that class. Methods are always called on an object — there are no “class methods”, as there are in many other languages (though Ruby does a great job at faking them).{{Citation needed|date=March 2015}}

Every object has a set of ''instance variables'' which hold the state of the object. Instance variables are created and accessed from within methods called on the object. Instance variables are completely private to an object. No other object can see them, not even other objects of the same class, or the class itself. All communication between Ruby objects happens through methods.

=== Mixins ===

In addition to classes, Ruby has ''modules''. A module has methods, just like a class, but it has no instances. Instead, a module can be included, or “mixed in,” to a class, which adds the methods of that module to the class. This is very much like inheritance but far more flexible because a class can include many different modules. By building individual features into separate modules, functionality can be combined in elaborate ways and code easily reused. Mix-ins help keep Ruby code free of complicated and restrictive class hierarchies.

=== Dynamic ===

Ruby is a very ''dynamic'' programming language. Ruby programs aren’t compiled, in the way that C or Java programs are. All of the class, module and method definitions in a program are built by the code when it is run. A program can also modify its own definitions while it’s running. Even the most primitive classes of the language like String and Integer can be opened up and extended. Rubyists call this ''monkey patching'' and it’s the kind of thing you can’t get away with in most other languages.

Variables in Ruby are dynamically typed, which means that any variable can hold any type of object. When you call a method on an object, Ruby looks up the method by name alone — it doesn't care about the type of the object. This is called ''duck typing'' and it lets you make classes that can pretend to be other classes, just by implementing the same methods.

=== Singleton Classes ===

When I said that every Ruby object has a class, I lied. The truth is, every object has ''two'' classes: a “regular” class and a ''singleton class''. An object’s singleton class is a nameless class whose only instance is that object. Every object has its very own singleton class, created automatically along with the object. Singleton classes inherit from their object’s regular class and are initially empty, but you can open them up and add methods to them, which can then be called on the lone object belonging to them. This is Ruby’s secret trick to avoid “class methods” and keep its type system simple and elegant.

=== Metaprogramming ===

Ruby is so object oriented that even classes, modules and methods are themselves objects! Every class is an instance of the class <tt>Class</tt> and every module is an instance of the class <tt>Module</tt>. You can call their methods to learn about them or even modify them, while your program is running. That means that you can use Ruby code to generate classes and modules, a technique known as ''metaprogramming''. Used wisely, metaprogramming allows you to capture highly abstract design patterns in code and implement them as easily as calling a method.

=== Flexibility ===

In Ruby, everything is malleable. Methods can be added to existing classes without [[w:Subclass (computer science)|subclassing]], operators can be [[w:Operator overloading|overloaded]], and even the behavior of the standard library can be redefined at runtime.

=== Variables and scope ===

You do not need to declare variables or variable scope in Ruby. The name of the variable automatically determines its scope.

* <tt>x</tt> is a local variable (or something other than a variable).
* <tt>'''$'''x</tt> is a global variable.
* <tt>'''@'''x</tt> is an instance variable.
* <tt>'''@@'''x</tt> is a class variable.     

=== Blocks ===

Blocks are one of Ruby’s most unique and most loved features. A block is a piece of code that can appear after a call to a method, like this:

<syntaxhighlight lang="ruby">
laundry_list.sort do |a,b|
  a.color <=> b.color
end
</syntaxhighlight>

The block is everything between the <tt>do</tt> and the <tt>end</tt>. The code in the block is not evaluated right away, rather it is packaged into an object and passed to the <tt>sort</tt> method as an argument. That object can be called at any time, just like calling a method. The <tt>sort</tt> method calls the block whenever it needs to compare two values in the list. The block gives you a lot of control over how <tt>sort</tt> behaves. A block object, like any other object, can be stored in a variable, passed along to other methods, or even copied.

Many programming languages support code objects like this. They’re called ''closures'' and they are a very powerful feature in any language, but they are typically underused because the code to create them tends to look ugly and unnatural. A Ruby block is simply a special, clean syntax for the common case of creating a closure and passing it to a method. This simple feature has inspired Rubyists to use closures extensively, in all sorts of creative new ways.

=== Advanced features ===

Ruby contains many advanced features.

* [[w:Exception handling|Exceptions]] for error-handling.
* A mark-and-sweep [[w:Garbage collection (computer science)|garbage collector]] instead of [[w:Reference counting|reference counting]].
* OS-independent [[w:Thread (computer science)|threading]], which allows you to write multi-threaded applications even on operating systems such as DOS. (this feature will disappear in [[w:YARV | 1.9]], which will use native threads)

You can also write extensions to Ruby in [[w:C (programming language)|C]] or embed Ruby in other software.

== References ==
<references/>

[[de:Ruby-Programmierung: Einleitung]]
[[fr:Programmation Ruby/Introduction]]
[[nl:Programmeren in Ruby/Over]]
[[pl:Ruby/Czym jest Ruby?]]
[[ru:Ruby/Основные свойства Ruby]]
[[zh:Ruby_Programming/Overview]]

Templates used on this page:

Template:BOOKCATEGORY (view source) (protected)
Template:BOOKNAME (view source) (protected)
Template:BOOKNAME/core (view source) (protected)
Template:BOOKNAME/inbook (view source) (protected)
Template:Category handler (edit)
Template:Citation needed (view source) (protected)
Template:Cite web (edit)
Template:Delink (edit)
Template:Evalx (view source) (protected)
Template:Fix (edit)
Template:Ifsubst (view source) (protected)
Template:Ruby Programming/TopNav (edit)
Module:Arguments (edit)
Module:Category handler (edit)
Module:Category handler/blacklist (edit)
Module:Category handler/config (edit)
Module:Category handler/data (edit)
Module:Category handler/shared (edit)
Module:Citation/CS1 (edit)
Module:Citation/CS1/COinS (edit)
Module:Citation/CS1/Configuration (edit)
Module:Citation/CS1/Date validation (edit)
Module:Citation/CS1/Identifiers (edit)
Module:Citation/CS1/Utilities (edit)
Module:Citation/CS1/Whitelist (edit)
Module:Citation/CS1/styles.css (edit)
Module:Delink (edit)
Module:Namespace detect/config (edit)
Module:Namespace detect/data (edit)
Module:String (view source) (protected)
Module:TScope (view source) (protected)
Module:Wikilisp (view source) (protected)
Module:Yesno (view source) (protected)

Return to Ruby Programming/Overview.

Retrieved from "https://en.wikibooks.org/wiki/Ruby_Programming/Overview"