Adding variable for the context on a view, on Laravel 4 - php

Question

Lets say that I have a View that uses 3 variables, while developing on Laravel 4:
<ul>
<li>Name: {{name}}</li>
<li>Surname: {{surname}}</li>
<li>Age: {{age}}</li>
<ul>
In my controller, I could be adding the data to the view the following way.
$context = array('name' => $name, 'surname' => $surname, 'age' => $age);
return View::make('myview');
But this code isnt completely DRY, since I am writing twice the name of the variable. It would be optimal if I could do:
$context = array($name, $surname, $age);
return View::make('myview', $context);
This code seems tighter. But unfortunately, the view will give me an error "Undefined variable: name".
Is there any way to achieve this with Laravel?
UPDATE: Another option, as stated in some answers is using compact.
$context = compact('name', 'surname', 'age')
return View::make('myview', $context);
But the problem here is that you have to create all your context variable in one go. And programming is not always so convenient sadly. Sometimes you will want to be adding your elements to the context, as you go progressing through the function.
For instance:
$context = array($name, $surname, $age);
if ($age > 18){
$adult = "He is adult";
array_push($context, $adult);
}
return View::make('myview', $context);
So as you see, if I could use arrays, it wouldnt be a problem because I could push new elements into the $context with array_push. But I can not use arrays that way, unfortunately. And compact wouldn't allow me to push elements inside the context, would it?

Answer 1

You use compact(), a native PHP function (see docs):
compact — Create array containing variables and their values
For each of these, compact() looks for a variable with that name in the current symbol table and adds it to the output array such that the variable name becomes the key and the contents of the variable become the value for that key. In short, it does the opposite of extract().
Any strings that are not set will simply be skipped.
For example, to create an array with keys of name, surname, age, with their values respectively:
$name = 'foo';
$surname = 'bar';
$age = 99;
$context = compact("name", "surname", "age");
return View::make('myview', $context);
If you var_dump($context) you would get:
array(3) {
["name"] => string(3) "foo"
["surname"] => string(3) "bar"
["age"] => int(99)
}
Which is what you want to pass into View::make().
Update:
To respond the part of question about using array_push(). I don't think you can use array_push() regardless of compact() anyway. The View::make() still requires a two-dimensional array with key => values. Say you have this array:
$context = array(
'name' => 'foo',
'surname' => 'bar',
'age' => 99,
);
Doing an array_push($context, $adult) would give you:
array(4) {
["name"] => string(3) "foo"
["surname"] => string(3) "bar"
["age"] => int(99)
[0] => string(11) "He is adult"
}
You get [0] => string(11) "He is adult" instead of ["adult"] => string(11) "He is adult". You would not get your expected result in your view using array_push()
To answer "Sometimes you will want to be adding your elements to the context, as you go progressing through the function.", I say there are two ways:
1st approach: Append $context as you go. Similar to your example:
$context = compact("name", "surname", "age");
if ($age > 18) {
$context['adult'] = "He is adult"; // You need to do this way because array_push() does not support setting your own key.
}
return View::make('myview', $context);
Pros: No need to worry whether you have added your variable to the compact() yet.
Cons: To know what is being passed to your view, you need to scan your whole method for key/value that you appended to $context.
2nd approach: Prepare all data then compact them into $context only right before sending to the view.
$name = 'foo';
$surname = 'bar';
$age = 99;
if ($age > 18){
$adult = "He is adult";
}
$context = compact("name", "surname", "age", "adult");
return View::make('myview', $context);
Pros: Single point of compiling view context. You can easily see all variables that are compacted and sent to the view.
Cons: Misspellings are harder to detect. compact() can become really long if you are passing a lot of variables.