Embrace Dreams

In symfony2, if you want to get value from request, you have many ways:

forst, bind request to form, then you can use the entity, official document has details.

If you are using formtype, there is another two ways to get value,

first:

$postData = $request->request->get('slackiss_bundle_qingbundle_registertype');
$name_value = $postData['email'];


second:

$email = = $form["email"]->getData();


or

$defaultData = array('message' => 'Type your message here');
$form = $this->createFormBuilder($defaultData)
->add('name', 'text')
->add('email', 'email')
->add('message', 'textarea')
->getForm();

// data is an array with "name", "email", and "message" keys
$data = $form->getData();
}


If you do not use formtype, I mean, you are not using {{form_widget}}, you can get values:


echo $request->request->get('email');


About $request, the code is like:

public function doAction(Request $request)
{
}


or

$request = $this->getRequest();


Remember that the main advantage of standards is that every piece of code looks and feels familiar, it’s not about this or that being more readable.

Since a picture – or some code – is worth a thousand words, here’s a short example containing most features described below:

<!--?php 

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <fabien@symfony.com-->
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Acme;

class Foo
{
    const SOME_CONST = 42;

    private $foo;

    /**
     * @param string $dummy Some argument description
     */
    public function __construct($dummy)
    {
        $this-&gt;foo = $this-&gt;transform($dummy);
    }

    /**
     * @param string $dummy Some argument description
     * @return string|null Transformed input
     */
    private function transform($dummy)
    {
        if (true === $dummy) {
            return;
        }
        if ('string' === $dummy) {
            $dummy = substr($dummy, 0, 5);
        }

        return $dummy;
    }
}

Structure

• Never use short tags ( closing tag;
• Indentation is done by steps of four spaces (tabs are never allowed);
• Use the linefeed character (0x0A) to end lines;
• Add a single space after each comma delimiter;
• Don’t put spaces after an opening parenthesis and before a closing one;
• Add a single space around operators (==, &&, …);
• Add a single space before the opening parenthesis of a control keyword (if, else, for, while, …);
• Add a blank line before return statements, unless the return is alone inside a statement-group (like an if statement);
• Don’t add trailing spaces at the end of lines;
• Use braces to indicate control structure body regardless of the number of statements it contains;
• Put braces on their own line for classes, methods, and functions declaration;
• Separate the conditional statements (if, else, …) and the opening brace with a single space and no blank line;
• Declare visibility explicitly for class, methods, and properties (usage of var is prohibited);
• Use lowercase PHP native typed constants: false, true, and null. The same goes for array();
• Use uppercase strings for constants with words separated with underscores;
• Define one class per file;
• Declare class properties before methods;
• Declare public methods first, then protected ones and finally private ones.

Naming Conventions

• Use camelCase, not underscores, for variable, function and method names;
• Use underscores for option, argument, parameter names;
• Use namespaces for all classes;
• Suffix interfaces with Interface;
• Use alphanumeric characters and underscores for file names;
• Don’t forget to look at the more verbose Conventions document for more subjective naming considerations.

Documentation

• Add PHPDoc blocks for all classes, methods, and functions;
• Omit the @return tag if the method does not return anything;
• The @package and @subpackage annotations are not used.

Put braces on their own line for classes, methods, and functions declaration;