PHP OOP: Can a variable be seen in a function without passing it as a param?

That's not OOP - in OOP you'd declare a class, make r1, r2 and r3 its properties, and then they would be available in every method of the class. See a little tutorial about classes here.

Using global variables is a bad idea.

EDIT

Here's a sample code, like Sohnee asked:

Class Route {
    var $r1;
    var $r2;
    var $r3;

    function __construct($url)
    {
        $route = explode('/', $url);
        // Shorthand
        $this->r1=$route[0]; $this->r2=$route[1]; $this->r3=$route[2];
    }

    function test()
    {
            $path = $this->r1 . "/" . $this->r2 . "/" . $this->r3;
            echo $path;
    }

}

$a = new Route('http://stackoverflow.com/questions/');
$a->test();

In order to use global variables inside a function, you have to do it via the following way

$route = explode('/', $_SERVER["REQUEST_URI"]);
// Shorthand
$r1=$route[0]; $r2=$route[1]; $r3=$route[2];
// ...  
function edit($id)
{
    global $r1, $r2, $r3;  // after this the variables are available in function scope

}

Another option is to use global array $GLOBALS. Using this array a global variable can be accessed from any scope like this:

if ($GLOBALS["r1"] == "some value")
{ 
    // do something
}

ADD this inside the function.

global $r1, $r2, $r3;

This tells the function to use the variables from the global scope.

global variables can be seen inside a method using $GLOBALS

$GLOBALS — References all variables available in global scope

http://php.net/manual/en/reserved.variables.globals.php

<?php

$baz = 'foo';

clas Bar {

    public function __construct() {
        echo $GLOBALS['baz'];
    }
}

or inside a function declaring variables global

function bar() {
    global $baz;
    echo $baz
}

If $r1, $r2, and $r3 are defined outside any class or function definition, you can use the global keyword to access them, or directly call them from the $GLOBALS array. e.x.:

function edit($id){
  global $r1, $r2, $r3; //Rest of the function below this

or

$_SESSION['path'] = $GLOBALS['r1'].'/' //... etc.

Global variables can be accessed within functions, if you declare them as global (which creates a local reference to the global). However, globals are bad.

If the variable definition happens in "app/controller/edit.php", then the problem is as the warning tells you: the variables aren't defined yet. You use them on one line, but don't include the file that defines them until the next, so they aren't yet defined. It's the same as if the function were:

function edit($id) {
    $_SESSION['path'] = $r1 . "/" . $r2 . "/" . $r3;
    $route = explode('/', $_SERVER["REQUEST_URI"]);
    // Shorthand
    $r1=$route[0]; $r2=$route[1]; $r3=$route[2];
    ...
}

I recommend against the obvious fix: moving the require to before the line that uses the variables, as this shares one of the big problems with globals: the variables seemingly magically spring into existence, with no indication of how or where, making it harder to understand the function (and the rest of the code) simply by reading the function. It's a form of coupling.

Executing code by including files can occasionally be a useful trick, but it also often causes problems (as this question demonstrates). Generally, include files should only define things. For an OO approach, take whatever tasks are being performed by the included file and figure out what jobs the code is trying to achieve overall. Then, assign each task to the class that has the (single) responsibility of achieving each overall job. In this case, the specific task is breaking up a request into a route, and the overall job is dispatching a request to a controller. There should then be a dispatcher class that dispatches a request to the appropriate controller, with a method that parses the route. The method (which might be private or protected and called from the constructor) could store the route in instance variables for time-efficiency.

class RouteDispatcher {
    protected $route;

    function __construct() {
        $this->_parseRoute();
        ...
    }

    function dispatch() {
        ...
    }

    protected function _parseRoute() {
        $this->route = explode('/', $_SERVER['REQUEST_URI']);
    }

    ...
}

The entry point (the script that is first called to handle each request) would instantiate a RequestDispatcher, set any appropriate properties or call any necessary methods, then call RequestDispatcher::dispatch, which would create the appropriate controller and hand off control to its request handler.

In the general case, a good design can be trickier than this because your goal as a designer in creating classes that have a single responsibility is to cut down on the need to change them. If a class has only one responsibility, then the class will need to be changed only if the requirements for that responsibility change.