Best way to add page specific JavaScript in a Rails 3 app?

Rails 3 has some unobtrusive JavaScript which is pretty cool.

But I was wondering what the best way is to include additional JavaScript for a particular page.

For example, where I might have previously done:

<%= f.radio_button :rating, 'positive', :onclick => "$('some_div').show();" %>

We can now make it unobtrusive with something like

<%= f.radio_button :rating, 'positive' %>

# then in some other file
$('user_rating_positive').click(function() {

So I guess my question is where/how to include that JavaScript? I don’t want to fill up the application.js file because this JavaScript is only applicable to this one view. Should I include a custom JavaScript file for each page somehow, or stick it in an instance variable that the header looks for?



What I like to do is include the per-view Javascript in a content_for :head block and then yield to that block in your application layout. For example

If it's pretty short then:

<% content_for :head do %>
  <script type="text/javascript">
    $(function() {
      $('user_rating_positve').click(function() {
<% end %>

or, if longer, then:

<% content_for :head do %>
  <script type="text/javascript">
    <%= render :partial => "my_view_javascript"
<% end %>

Then, in your layout file

  <%= yield :head %>

If you want to include javascript just on one page, you can include it on the page inline of course, however if you want to group your javascript and take advantage of the asset pipeline, minified js etc, it's possible to do so and have extra js assets which are combined and only loaded on specific pages by splitting your js into groups which only apply in certain controllers/views/sections of the site.

Move your js in assets into folders, with a separate manifest file for each, so if you had an admin js library that is only used on the backend, you might do this:

  • assets
    • javascripts
      • admin
        • ...js
      • admin.js (manifest for admin group)
      • application.js (manifest for app global group)
      • global
        • ...js

in the existing application.js

//= require jquery
//= require jquery_ujs
//= require_tree ./global // requires all js files in global folder

in a new admin.js manifest file

//= require_tree ./admin // requires all js files in admin folder

Make sure this new js manifest is loaded by editing config/production.rb

config.assets.precompile += %w( admin.js )

Then adjust your page layout so that you can include some extra js for the page head:

<%= content_for :header %>   

Then in views where you want to include this specific js group (as well as the normal application group) and/or any page-specific js, css etc:

<% content_for :header do %>
  <%= javascript_include_tag 'admin' %>  
<% end %>

You can of course do the same thing with css and group it in a similar way for applying only to certain areas of the site.


I prefer the following...

In your application_helper.rb file

def include_javascript (file)
    s = " <script type=\"text/javascript\">" + render(:file => file) + "</script>"
    content_for(:head, raw(s))

and then in your particular view (app/views/books/index.html.erb in this example)

<% include_javascript 'books/index.js' %>

... seems to work for me.


These answers helped me a ton! If anyone wants a little more...

  1. You need to put javascripts into manifests if you want them precompiled. However, if you require every javascript file from then all the javacsripts will be loaded every time you navigate to a different page, and the purpose of doing page-specific javascripts will be defeated.

Therefore, you need to create your own manifest file (e.g. speciifc.js) that will require all the page-specific javascript files. Also, modify require_tree from application.js


//= require jquery
//= require jquery_ujs
//= require_tree ./global


//= require_tree ./specific

Then in your environments/production.rb add this manifest to the precompiled list with the config option,

config.assets.precompile += %w( specific.js )

Done! All the shared javascripts that should always be loaded will be placed in app/assets/javascripts/global folder, and the page-spcific javascripts in app/assets/javascripts/specific. You can simply call the page-specific javascripts from the view like

<%= javascript_include_tag "specific/whatever.js" %> //.js is optional.

This is sufficient, but I wanted to make a use of javascript_include_tag params[:controller] too. When you create controllers, an associated coffeescript file is generated in app/assets/javascripts like other people mentioned. There are truly controller-specific javascripts, which are loaded only when the user reaches the specific controller view.

So I created another manifest controller-specific.js


//= require_directory .

This will include all the automatically-generated coffeescripts associated with controllers. Also, you need to add it to the precompiled list.

config.assets.precompile += %w( specific.js controller-specific.js )


My understanding is that the asset pipeline is meant to decrease page load-time by mashing all your js together into one (minified) file. While this may seem repugnant on the surface, it is actually a feature that already exists in popular languages like C and Ruby. Things like "include" tags are meant to prevent multiple inclusion of a file, and to help programmers organize their code. When you write and compile a program in C, all that code is present in every part of your running program, but methods are only loaded into memory when that code is being used. In a sense, a compiled program does not include anything to guarantee that the code is nicely modular. We make the code modular by writing our programs that way, and the operating system only loads into memory the objects and methods we need for a given locality. Is there even such a thing as "method-specific inclusion"? If your rails app is restful, this is essentially what you are asking for.

If you write your javascript so that it augments the behaviour of HTML elements on the page, then those functions are 'page-specific' by design. If there is some complicated code that you wrote in such a way that it will execute regardless of its context, maybe consider binding that code to an html element anyway (you could use the body tag, as described in the Garber-Irish method). If a function executes conditionally, the performance will probably be smaller than all those extra script tags.

I am thinking of using the paloma gem, as described in the rails apps project. Then you can make your javascript page-specific by including page-specific functions in a paloma callback:

Paloma.callbacks['users']['new'] = function(params){
    // This will only run after executing users/new action
    alert('Hello New Sexy User');

You use rails, so I know you love gems :)


You shouldn't be loading your JS or CSS files outside of the asset pipeline because you lose out on important features that make Rails so great. And you don't need another gem. I believe in using as few gems as possible, and using a gem isn't necessary here.

What you want is known as "Controller Specific Javascript" ("Action Specific Javascript is included at the bottom). This allows you to load a specific JavaScript file for a specific CONTROLLER. Trying to connect your Javascript to a View is kind of... backwards and doesn't follow the MVC design pattern. You want to associate it with your Controllers or actions inside your Controllers.

Unfortunately, for whatever reason, Rails devs decided that by default, every page will load every JS file located in your assets directory. Why they decided to do this instead of enabling "Controller Specific Javascript" by default I will never know. This is done through the application.js file, which includes the following line of code by default:

//= require_tree .

This is known as a directive. It's what sprockets uses to load every JS file in the assets/javascripts directory. By default, sprockets automatically loads application.js and application.css, and the require_tree directive loads every JS and Coffee file in their respective directories.

NOTE: When you scaffold (if you aren't scaffolding, now is a good time to start), Rails automatically generates a coffee file for you, for that scaffold's controller. If you want it to generate a standard JS file instead of a coffee file, then remove the coffee gem that is enabled by default in your Gemfile, and your scaffold will create JS files instead.

Ok, so the first step to enabling "Controller Specific Javascript" is to remove the require_tree code from your application.js file, OR change it to a folder within your assets/javascripts directory if you still need global JS files. I.E.:

//= require_tree ./global

Step 2: Go into your config/initializers/assets.rb file, and add the following:

%w( controllerone controllertwo controllerthree ).each do |controller|
  Rails.application.config.assets.precompile += ["#{controller}.js", "#{controller}.css"]

Insert the Controller names that you want.

Step 3: Replace the javascript_include_tag in your application.html.erb file with this (note the params[:controller] part:

<%= javascript_include_tag 'application', params[:controller], 'data-turbolinks-track': 'reload' %>

Restart your server and viola! The JS file that was generated with your scaffold will now only load when that controller is called.

Need to load a specific JS file on a specific ACTION in your controller, I.E. /articles/new ? Do this instead:


<%= javascript_include_tag "#{controller_name}/#{action_name}" if AppName::Application.assets.find_asset("#{controller_name}/#{action_name}") %>


config.assets.precompile += %w(*/*)

Then add a new folder with the same name as you controller in your assets/javascripts folder and put your js file with the same name as your action inside. It will then load it on that specific action.


Ok so maybe this is like the worst work around ever but i creat a controller method that just rendered out the .js file


def get_script
   render :file => 'app/assessts/javascripts/' + params[:name] + '.js'
def get_page
   @script = '/' + params[:script_name] + '.js?body=1'
   render page


%script{:src => @script, :type => "text/javascript"}

if for some reason we don't want to do this then let me know.


The preferred way to add JS is in footer, so you can do this way:


<% content_for :footer_js do %>
   This content will show up in the footer section
<% end %>


<%= yield :footer_js %>

If you don't want to use the asset pipeline or the complex work arounds to get that necessary page specific javascript (I sympathise), the simplest and most robust way, which achieves the same as the answers above but with less code is just to use:

<%= javascript_include_tag "my_javascipt_file" %>

Note: this does require one more http request per include tag than the answers which use content_for :head


Take a look at pluggable_js gem. You may find this solution easier to use.


Recent Questions

Top Questions

Home Tags Terms of Service Privacy Policy DMCA Contact Us

©2020 All rights reserved.