Bummer! This is just a preview. You need to be signed in with a Basic account to view the entire video.

Preview

Start a free Basic trial
to watch this video

Sign up for Treehouse

Namespaces

4:58 with Jason Seifer

A namespace can be thought of as a container for other items. These things can be classes, constants, other modules, and more.

Code Samples

Multiple levels of modules can be used to namespace items:

module LaserBots
  module Console
    class Command
    end
  end

  module World
    class Player
      attr_reader :name
      def initialize(name)
        @name = name
      end
    end
  end
end

The classes, modules, and constants can then be accessed by using the constant resolution operator (::) to get to nested namespaces: 

player = LaserBots::World::Player.new("Jason")
puts player.name
  • 0:00

    Now, we're going to talk about namespaces.

  • 0:03

    A namespace can be thought of as a container for other items.

  • 0:08

    These things can be classes, constants, other modules and more.

  • 0:13

    The value in namespacing comes from having potential conflicts of names in our code.

  • 0:19

    As an example, let's say that we were writing a text based game.

  • 0:24

    The game has a couple of different concepts of commands

  • 0:27

    that are both completely separate.

  • 0:30

    When we start the game from our command prompt,

  • 0:32

    we can add a flag to change certain options for gameplay or set our name.

  • 0:37

    Similarly, our player can command other characters.

  • 0:41

    Let's see how namespaces work now using workspaces.

  • 0:45

    So now, let's take a little bit of a look at namespacing.

  • 0:49

    Right here, we've got this laser_bots.rb file.

  • 0:54

    This is eventually going to be a game about lasers and robots.

  • 1:00

    For right now, we have this class that represents a player and

  • 1:04

    the player just has a name attribute.

  • 1:07

    So we initialize the player to a new player variable, and

  • 1:11

    then write the player's name to the screen.

  • 1:15

    Now let's just go ahead and run that, and watch it work.

  • 1:18

    So I'm just going to run ruby laser_bots.rb, and

  • 1:22

    you can see it prints out the player's name.

  • 1:26

    Now if we wanna namespace this, we can do that by surrounding this with a module.

  • 1:34

    So let's go ahead and call this module,

  • 1:36

    LaserBots and we can indent everything here.

  • 1:46

    And now, this player class lives inside of the Laserbots module.

  • 1:54

    So let's run this again and it's gonna fail this time.

  • 1:57

    And we can see it says uninitialized constant player

  • 2:03

    and why does it say that, we clearly have a player class here.

  • 2:08

    But the thing is, it lives inside of the laser bot's module.

  • 2:12

    So we need to tell ruby where the player class is now and

  • 2:18

    we do that by typing the module that it's in first.

  • 2:24

    We access it just like a constant, which we saw in the last video.

  • 2:30

    So now we have this player object, and Ruby knows to look for

  • 2:33

    it inside of this LaserBots module.

  • 2:37

    So if we were to run this again, we can see that that works now.

  • 2:43

    Now one thing that's interesting is, we do not have to

  • 2:47

    specify the constant resolution operator if we're inside of a module.

  • 2:54

    So let's say we had a class called robot and

  • 2:58

    the robot class was inside of the LaserBots module,

  • 3:02

    we'll say robots have a name also,

  • 3:08

    it's pretty much the same as a player class but it can also target a player.

  • 3:20

    In that case, we could call something like Player.new and

  • 3:27

    let's just call this name here.

  • 3:31

    In this case, if we are in the same level of the module hierarchy,

  • 3:35

    we don't have to specify that constant resolution operator.

  • 3:42

    And in the same way, if we really wanted to,

  • 3:45

    we could have multiple levels of name spaces.

  • 3:50

    So for example, let's say we had

  • 3:54

    a console module inside here and that dealt with

  • 3:59

    writing things to the screen that could have a command class inside of it.

  • 4:05

    And then the same thing if we wanted to have things that actually dealt

  • 4:10

    with the game world, we could have a module called world and

  • 4:16

    that would be where we could put

  • 4:20

    the Player and Robot classes.

  • 4:35

    And now if we were to run this it would error out and let's just go ahead and

  • 4:39

    do that again and watch it fail.

  • 4:41

    Again, we can't find the constant LaserBots player,

  • 4:46

    in that case we need to change this to LaserBots::World::Player.

  • 4:51

    And that will access the class inside of this module.

You need to sign up for Treehouse in order to download course files.

Sign up