Rails 4权威指南，第3版

需积分: 10 70 浏览量更新于2024-07-21 收藏 3.66MB PDF 举报

"《THE RAILS 4 WAY, 3RD EDITION》是由Obie Fernandez等人编写的关于Ruby on Rails框架的第三版书籍，由Addison-Wesley Professional出版社出版，于2014年6月8日发行。该书的ISBN号为0321944275（10位）和978-0321944276（13位），全书共912页，语言为英文，文件大小为4MB，格式为PDF。此书是作者们采用 Leanpub 平台进行轻量级工具和多次迭代的精益出版方式，旨在在开发过程中获取读者反馈，不断优化内容。" 《Rails 4 Way》这本书是针对Ruby on Rails 4版本的详细指南，作者团队包括Obie Fernandez、Kevin Faustino、Vitaly Kushner和Ari Lerner。这本书是他们对Ruby on Rails实践经验和专业知识的结晶。在内容方面，书中涵盖了Rails框架的各个方面，旨在帮助开发者深入理解和应用这一强大的Web开发工具。书中包含了前言、致谢、作者简介、介绍、推荐阅读和资源、目标以及先决条件等部分。介绍中强调了本书的创作理念，即通过精益出版的方式，不断根据读者反馈进行改进，确保内容与实际开发需求紧密结合。推荐阅读和资源部分可能列出了其他相关学习资料，以便读者扩展知识面。在目标部分，作者可能会明确指出本书旨在帮助读者掌握Rails 4的核心概念和技术，包括MVC架构、路由、数据库交互、ActiveRecord、测试、性能优化等方面。而先决条件则可能提醒读者需要具备一定的Ruby编程基础和Web开发经验，以便更好地理解书中的内容。作为一本面向高级开发者的书籍，它不仅适合初学者学习，也适用于已经有一定经验的Rails开发者提升技能。通过阅读《Rails 4 Way》，读者可以系统地学习如何利用Rails 4构建高效、可维护的Web应用程序，并了解最佳实践和最新趋势。此外，书中可能还包含了社区的反馈和讨论，使得读者能够参与到这个动态的开发环境中，与其他开发者交流心得，共同进步。

(Beta Version) Introduction

A proper introduction will included in the final release of this book.

At the time of this beta version’s writing, we are in the lead up to Railsconf 2013 and release of Rails 4.0.

It’s an exciting time for the Rails community; we have matured tremendously and our mainstream adoption

continues to pick up steam. Nearly 10 years after DHH first started playing with Ruby, it’s safe to say that

Rails remains a relevant and vital tool in the greater web technology ecosystem.

The Rails 4 Way is very much a team effort and would not be possible without the excellent work of Kevin

Faustino, Vitaly Kushner and Ari Lerner. Much thanks is also owed to my executive editor at Pearson, Debra

Williams-Cauley. Without her constant support and encouragement throughout the years, the Professional

Ruby Series would not exist.

About This Book

This book is not a tutorial or basic introduction to Ruby or Rails. It is meant as a day-to-day reference for the

full-time Rails developer. The more confident reader might be able to get started in Rails using just this book,

extensive online resources, and his wits, but there are other publications that are more introductory in nature

and might be a wee bit more appropriate for beginners.

Every contributor to this book works with Rails on a full time basis. We do not spend our days writing books

or training other people, although that is certainly something that we enjoy doing on the side.

This book was originally conceived for myself, because I hate having to use online documentation, especially

API docs, which need to be consulted over and over again. Since the API documentation is liberally licensed

(just like the rest of Rails), there are a few sections of the book that reproduce parts of the API documentation.

In practically all cases, the API documentation has been expanded and/or corrected, supplemented with

additional examples and commentary drawn from practical experience.

Hopefully you are like me—I really like books that I can keep next to my keyboard, scribble notes in, and fill

with bookmarks and dog-ears. When I’m coding, I want to be able to quickly refer to both API documentation,

in-depth explanations, and relevant examples.

Book Structure

I attempted to give the material a natural structure while meeting the goal of being the best-possible Rails

reference book. To that end, careful attention has been given to presenting holistic explanations of each

subsystem of Rails, including detailed API information where appropriate. Every chapter is slightly different

in scope, and I suspect that Rails is now too big a topic to cover the whole thing in depth in just one book.

Believe me, it has not been easy coming up with a structure that makes perfect sense for everyone. Particularly,

I have noted surprise in some readers when they notice that Active Record is not covered first. Rails is foremost

a web framework and at least to me, the controller and routing implementation is the most unique, powerful,

and effective feature, with Active Record following a close second.

(Beta Version) Introduction vi

Sample Code and Listings

The domains chosen for the code samples should be familiar to almost all professional developers. They

include time and expense tracking, auctions, regional data management, and blogging applications. I don’t

spend pages explaining the subtler nuances of the business logic for the samples or justify design decisions

that don’t have a direct relationship to the topic at hand. Following in the footsteps of my series colleague Hal

Fulton and The Ruby Way, most of the snippets are not full code listings—only the relevant code is shown.

Ellipses (…) denote parts of the code that have been eliminated for clarity.

Whenever a code listing is large and significant, and I suspect that you might want to use it verbatim in your

own code, I supply a listing heading. There are not too many of those. The whole set of code listings will not

add up to a complete working system, nor are there 30 pages of sample application code in an appendix. The

code listings should serve as inspiration for your production-ready work, but keep in mind that it often lacks

touches necessary in real-world work. For example, examples of controller code are often missing pagination

and access control logic, because it would detract from the point being expressed.

Some of the source code for my examples can be found at http://github.com/obie/tr3w_time_and_expenses.

Note that it is not a working nor complete application. It just made sense at times to keep the code in the

context of an application and hopefully you might draw some inspiration from browsing it.

Concerning 3rd-Party RubyGems and Plugins

Whenever you find yourself writing code that feels like plumbing, by which I mean completely unrelated to

the business domain of your application, you’re probably doing too much work. I hope that you have this

book at your side when you encounter that feeling. There is almost always some new part of the Rails API or

a third-party RubyGem for doing exactly what you are trying to do.

As a matter of fact, part of what sets this book apart is that I never hesitate in calling out the availability of

third-party code, and I even document the RubyGems and plugins that I feel are most crucial for effective

Rails work. In cases where 3rd-party code is better than the built-in Rails functionality, we don’t cover the

built-in Rails functionality (pagination is a good example).

An average developer might see his productivity double with Rails, but I’ve seen serious Rails developers

achieve gains that are much, much higher. That’s because we follow the Don’t Repeat Yourself (DRY) principle

religiously, of which Don’t Reinvent The Wheel (DRTW) is a close corollary. Reimplementing something

when an existing implementation is good enough is an unnecessary waste of time that nevertheless can be

very tempting, since it’s such a joy to program in Ruby.

Ruby on Rails is actually a vast ecosystem of core code, official plugins, and third-party plugins. That

ecosystem has been exploding rapidly and provides all the raw technology you need to build even the most

complicated enterprise-class web applications. My goal is to equip you with enough knowledge that you’ll be

able to avoid continuously reinventing the wheel.

Recommended Reading and Resources

Readers may find it useful to read this book while referring to some of the excellent reference titles listed in

this section.

(Beta Version) Introduction vii

Most Ruby programmers always have their copy of the “Pickaxe” book nearby, Programming Ruby (ISBN:

0-9745140-5-5), because it is a good language reference. Readers interested in really understanding all of the

nuances of Ruby programming should acquire The Ruby Way, Second Edition (ISBN: 0-6723288-4-4).

I highly recommend Peepcode Screencasts, in-depth video presentations on a variety of Rails subjects by the

inimitable Geoffrey Grosenbach, available at http://peepcode.com

Ryan Bates does an excellent job explaining nuances of Rails development in his long-running series of free

webcasts available at http://railscasts.com/

Regarding David Heinemeier Hansson a.k.a. DHH I had the pleasure of establishing a friendship with David

Heinemeier Hansson, creator of Rails, in early 2005, before Rails hit the mainstream and he became an

International Web 2.0 Superstar. My friendship with David is a big factor in why I’m writing this book today.

David’s opinions and public statements shape the Rails world, which means he gets quoted a lot when we

discuss the nature of Rails and how to use it effectively.

David has told me on a couple of occasions that he hates the “DHH” moniker that people tend to use instead

of his long and difficult-to-spell full name. For that reason, in this book I try to always refer to him as “David”

instead of the ever-tempting “DHH.” When you encounter references to “David” without further qualification,

I’m referring to the one-and-only David Heinemeier Hansson.

There are a number of notable people from the Rails world that are also referred to on a first-name basis in

this book. Those include:

• Yehuda Katz

• Jamis Buck

• Xavier Noria

Goals

As already stated, I hope to make this your primary working reference for Ruby on Rails. I don’t really

expect too many people to read it through end to end unless they’re expanding their basic knowledge of

the Rails framework. Whatever the case may be, over time I hope this book gives you as an application

developer/programmer greater confidence in making design and implementation decisions while working on

your day-to-day tasks. After spending time with this book, your understanding of the fundamental concepts

of Rails coupled with hands-on experience should leave you feeling comfortable working on real-world Rails

projects, with real-world demands.

If you are in an architectural or development lead role, this book is not targeted to you, but should make you

feel more comfortable discussing the pros and cons of Ruby on Rails adoption and ways to extend Rails to

meet the particular needs of the project under your direction.

Finally, if you are a development manager, you should find the practical perspective of the book and our

coverage of testing and tools especially interesting, and hopefully get some insight into why your developers

are so excited about Ruby and Rails.

1 Rails Environments and Configuration

[Rails] gained a lot of its focus and appeal because I didn’t try to please people who didn’t share

my problems. Differentiating between production and development was a very real problem for

me, so I solved it the best way I knew how.

—David Heinemeier Hansson

Rails applications are preconfigured with three standard modes of operation: development, test, and pro-

duction. These modes are basically execution environments and have a collection of associated settings that

determine things such as which database to connect to, and whether the classes of your application should be

reloaded with each request. It is also simple to create your own custom environments if necessary.

The current environment can be specified via the environment variable RAILS_ENV, which names the desired

mode of operation and corresponds to an environment definition file in the config/environments folder.

You can also set the environment variable RACK_ENV or as a last resort you may rely on the default being

development. Since this environment setting governs some of the most fundamental aspects of Rails, such as

class loading, in order to really understand the Rails way you should understand its environment settings.

In this chapter, we start by covering Bundler, a tool that manages gem dependencies for your Ruby application.

It takes a gem manifest file and is able to fetch, download, and install the gems in the manifest, and all child

dependencies. Then we move on to how Rails starts up and handles requests, by examining scripts such as

boot.rb and application.rb and the settings that make up the three standard environment settings (modes).

We also cover some of the basics of defining your own environments, and why you might choose to do so.

Note that this book is not written with absolute newcomers to Rails in mind. To make the most out of this

book, you should already be at least somewhat familiar with how to bootstrap a Rails application and the

meaning of MVC. If you are not, I recommend that you first take advantage of the excellent Ruby on Rails

Tutorial website¹ by Michael Hartl, another Professional Ruby Series author.

1.1 Bundler

Bundler² is not a technology that is specific to Rails 4, but it is the preferred way to manage your application’s

gem dependencies. Applications generated with Rails 4 use Bundler automatically, and you should not need

to install the bundler gem separately since it’s a dependency of Rails itself.

Since we believe that you should use Bundler, figuring out how to not use Bundler is left as an exercise for

adventurous and/or nonconformist readers.

One of the most important things that Bundler does is dependency resolution on the full list of gems specified

in your configuration, all at once. This differs from the one-at-a-time dependency resolution approach

employed by Rubygems and previous versions of Rails, which can (and often did) result in the following

hard-to-fix problem:

Assume that your system had the following Rubygem versions installed.

¹http://railstutorial.org

²http://gembundler.com

剩余736页未读，继续阅读

suixx036

粉丝: 0
资源: 6

Rails 4权威指南，第3版

The Rails 4 Way, 3rd edition.pdf

The Rails 4 Way

Beginning Rails 4, 3rd Edition.pdf

Agile Web Development with Rails中文版 3rd Edition

The Rails3 Way, 2nd Edition

The Rails 3 Way, 2nd Edition

The rails4 way

Agile Web Development with Rails.3rd Edition.2009

The Ruby Way--3rd Edition--2015-英文版

agile_web_development_with_rails_3rd_edition.9994652073.pdf

最新资源