Essayez SBP en direct !Try SBP now!

SBP - Shorter Built PHP


SBP est un compilateur intégré à SelfBuild qui vous permet d'écrire les syntaxes rébarbatives de PHP de manière beaucoup plus courtes et transparentes, d'ommettre les accolades, les points-virgules, d'utiliser des modèles de fichier générés en fonction du noms, chemin ou contenu du fichier et bien plus encore !
SBP is a compiler embedded in SelfBuild that allow you to code the redundant PHP syntaxes in a very shorter and cleaner way, without braces or semi-colons, using file patterns generated from there names, path or contenu. And it's just the begenning!
SBP s'ajoute à la collection de compilateurs déjà intégrés dans SelfBuild : CoffeScript pour le JavaScript, Stylus, Less et CSSB pour le CSS.
SBP is part of the SelfBuild compilers collection that already include: CoffeScript for JavaScript, Stylus, Less and CSSB for CSS.
Dernier taux de compression calculé : 82%
Last compression rate recorded: 82%

Essayez SBP en direct !

Try SBP now!

<? namespace Family Son:Father <<< Human - $age + __construct $age = null >age = $age + getAge <>age + isAdult <>age>18 * birthday >age++
<?php /* Generated By SBP */ namespace Family; class Son extends Father implements Human { private $age; public function __construct ($age = null) { $this->age = $age; } public function getAge () { return $this->age; } public function isAdult () { return $this->age>18; } protected function birthday () { $this->age++; }}

Short-tag PHP et omission des points-virgules

PHP Short-tag and semi-colon omission


.src/short_tag.php

<?
echo "Hello World!"
?>
=>

short_tag.php

<?php /* Generated By SBP */ 
echo "Hello World!";
?>

Utilisez les short-tags sans complexe, ils seront uniformisés par SBP lors de l'enregistrement évitant ainsi évitant ainsi toute erreur due à une désactivation des short-tags dans la configuration.

Never mind any longer about using short-tag, they will be completed for you.

Les points-virgules de fin de ligne peuvent aussi être supprimés sans problème.

Semi-colons are not needed at the end of lines.

Le commentaire /* Generated By SBP */ permet à SelfBuild de détecter les fichiers générés par SBP et de charger le cas échéant le fichier source dans l'éditeur.

The comment /* Generated By SBP */ allow SelfBuild to dect files generated by SBP and load them as it.

Omission des accolades

Braces omission


.src/if_else.php

<?
if $a
    for $i=1; $i<10; $i++
        if $i%2 is 0
            echo $i." est paire"

        elseif $i%3 is 0
            echo $i." est un multiple de 3"

        else
            echo $i." n'a rien de spécial"

else
    echo "a est faux"
?>
=>

if_else.php

<?php /* Generated By SBP */
if ($a) {
    for ($i=1; $i<10; $i++) {
        if ($i%2 === 0) {
            echo $i." est paire";
        }
        elseif ($i%3 === 0) {
            echo $i." est un multiple de 3";
        }
        else{
            echo $i." n'a rien de spécial";
}}}
else{
    echo "a est faux";
}?>

Toutes les accolades peuvent être omises du moment que l'indentation aligne correctement les blocs et leur contenu.

All braces can be omitted until as long as the indentation is respected.

Une tabulation et 4 espaces sont considérés comme équivalents par SBP.

SBP consider 4 spaces and 1 tab equivalent.

Les accolades sont rajoutées de manières à ce que les numéros de lignes des fichiers sources et compilés correspondent. Ainsi si une erreur Warning survient à la ligne 5 du fichier PHP compilé. Cela correspond bien à la ligne 5 du fichier SBP source.

Braces are completed in keeping the line numbers from source and compiled files match. So if an error occurs line 5 in the PHP generated file, it comes from line 5 in the SBP source file.

Les parenthèses après if, elseif, for, while, foreach, function, etc. peuvent être omises tant que la condition ou l'expression à mettre entre parenthèses est écrite sur une seule ligne.

Parentheses after if, elseif, for, while, foreach, function, etc. can be omitted as long as the condition take only one line.

Swtich


.src/switch.php

<?

$medal :=
    "gold" ::
        echo "Médaille d'or"
        :;
    "silver" ::
        echo "Médaille d'argent"
        :;
    d:
        echo "Médaille de bronze"

?>
=>

switch.php

<?php /* Generated By SBP */

switch($medal){
    case "gold":
        echo "Médaille d'or";
        break;
    case "silver":
        echo "Médaille d'argent";
        break;
    default:
        echo "Médaille de bronze";
}
?>

Les raccourcis :=, ::, d: et :; génèrent respectivement switch, case, default et break. Il faut cependant que chacun de ses symboles soit précédé d'au moins un espace, tabulation ou saut de ligne (ceci permet entre autre à SBP de différencier le cas où :: appelle case du cas où il sépare un nom de classe d'une constante ou méthode, par exemple dans MaClasse::maMethode()).

Shortcuts :=, ::, d: and :; generate respectivly switch, case, default and break. However, they must be preceded by a space, tab or new line to let SBP differenciate them from other uses (as MyClass::myMethod()).

Pour éviter tout comportement erroné, ces raccourcis doivent terminer une ligne. Et les lignes terminant par := ou :: ne doivent contenir qu'une seule expression.

To prevent all unexpected behaviour, this shortcuts must end the line. And lines ending with := or :: must contains only one expression.

Assignation


.src/assignation.php

<?
$text **= substr(0, 2)
substr(**$text, 0, 2)

$_POST['username'] **= stripslashes()
stripslashes(**$_POST['username'])
?>
=>

assignation.php

<?php /* Generated By SBP */ 
$text = substr($text, 0, 2);
$text = substr($text, 0, 2);

$_POST['username'] = stripslashes($_POST['username']);
$_POST['username'] = stripslashes($_POST['username']);
?>

Il est relativement fréquent d'avoir une variable comme premier paramètre d'une fonction et d'utiliser cette même variable pour récupérer le résultat de la fonction.

Often, a variable is the first argument of a function and the recip for the returned value of this function.

En SBP, il est possible de n'écrire que la fonction et de précéder le premier paramètre de ** qui génère alors automatiquement une assignation avant la fonction ou d'utiliser le symbole d'assignation **=.

With SBP, you can use ** in the function to assign the result of the function to the same variable as the one passed in the first argument. Or you can use **= to pass the variable as the left side as the first argument of the following function ang get the result in it.

"Variable" est à comprendre au sens large, vous pouvez également passer des attributs d'objet, des valeurs d'array, etc.

You can also pass object member, array property, etc.

.src/assignation_operateur.php

<?
$a &&= true
$a ||= true
$a (and= true)
$a (or= true)
$a (xor= false)
$a is= true
$a not= false
$a <>= "abc"
$a lt= 25
$a gt= -12.5/2
$a <== 25
$a >== 0
$a ==== "foo"
$a !=== "bar"
$a ?:= "default value"
// Équivalent pour PHP < 5.3
$a !?= "default value"
// Set default value only if it not set
$a !?== "default value"

/*
 * is, not, lt et gt sont aussi
 * disponibles dans le contexte normal
 */

if $a is 23
    echo "a is 23"
if $a not 23
    echo "a is not 23"
if $a lt 23
    echo "a is lesser than 23"
if $a gt 23
    echo "a is greater than 23"
?>
=>

assignation_operateur.php

<?php /* Generated By SBP */ 
$a = $a && true;
$a = $a || true;
$a = ($a and true);
$a = ($a or true);
$a = ($a xor false);
$a = $a === true;
$a = $a !== false;
$a = $a <> "abc";
$a = $a < 25;
$a = $a > -12.5/2;
$a = $a <= 25;
$a = $a >= 0;
$a = $a === "foo";
$a = $a !== "bar";
$a = $a ?: "default value";
// Équivalent pour PHP < 5.3
if(!$a) { $a = "default value"; }
// Set default value only if it not set
if(!isset($a)) { $a = "default value"; }

/*
 * is, not, lt et gt sont aussi
 * disponibles dans le contexte normal
 */

if ($a === 23) {
    echo "a is 23";
}if ($a !== 23) {
    echo "a is not 23";
}if ($a < 23) {
    echo "a is lesser than 23";
}if ($a > 23) {
    echo "a is greater than 23";
}?>

En PHP, il est possible d'utiliser certains opérateurs directement dans l'assignation. Mais pourquoi se limiter à certains et pourquoi ne pourrait-on pas TOUS les utiliser dans les assignations comme en Ruby par exemple ? SBP abolit toute discrimination et permet d'utiliser n'importe quel opérateur suivi du symbole = pour une assignation raccourcie. Les alias d'opérateurs is (pour ==), not (pour !=), lt (pour <) et gt (pour >) permettent d'éviter les conflits avec les opérateurs <=, >= === et !==.

PHP allow to use some operators in the assignation. But why only some of them? Why could we not use ALL of them in assignations like in Ruby? SBP abolish this discrimination and let you use any operated followed with = for a short assignation. Aliases is (for ==), not (for !=), lt (for <) and gt (for >) allow you to prevent from conflicts with <=, >= === and !==.

En cas de problème de précédence des opérateurs ou des parenthèses, vous pouvez entourer l'opérateur raccourci et l'expression ou valeur à droite de l'assignation de parenthèses. La partie à gauche de l'assignation est alors insérée dans cette parenthèse. Ces parenthèses sont nécessaires pour les opérateurs or, and et xor, car l'assignation est prioritaire sur ces opérateurs.

A problem with precedence? You can wrap the short operator and the expression or the value on the right side wiht parentheses. The left side part will be inserted in the parentheses. They will be needed with or, and and xor, as the assignation has the precedence on them.

Si vous écrivez $a and= true; sans les parenthèses cela transformé en $a = $a and true; or l'assignation étant prioritaire, cela équivaut à : ($a = $a) and true; ce qui n'est probablement pas ce que vous souhaitez. Pour tous les autres opérateurs, l'assignation n'est pas prioritaire.

If you write $a and= true; with no parentheses, it will be replaced with $a = $a and true;. As the assignation comes first, it's equivalant to: ($a = $a) and true; wich is probably not what you wanted to do. For other operators, the assignation is not priority.

.src/assignation_seul.php

<?
$var! // inverse
$var!! // conversion en booléen
$var~ // non binaire
?>
=>

assignation_seul.php

<?php /* Generated By SBP */ 
$var!; // inverse
$var!!; // conversion en booléen
$var~; // non binaire
?>

Les opérateurs one-hand ne sont pas en reste. Suivis d'un point-virgule ou d'une nouvelle ligne, ils permettent d'être appliqués directement à une variable.

One-hand operator can also be self-asigned. If they are followed by a semi-colon or a new line the result is assigned to the input variable.

Les fonctions

Functions


.src/fonction.php

<?
f cube $i
    <$i*$i*$i

$cubes = array_map(
    f° $i
        <$i*$i*$i

    ,[1, 2, 3]
)

@f cube $i
    <pow($i, 3)
?>
=>

fonction.php

<?php /* Generated By SBP */ 
function cube ($i) {
    return $i*$i*$i;
}
$cubes = array_map(
    function ($i) {
        return $i*$i*$i;
    }
    ,[1, 2, 3]
);

if(! function_exists('cube')) { function cube ($i) {
    return pow($i, 3);
} }?>

Remplaçons function par f et return par < (nécessite que < ne soit précédé d'aucune expression sur la même ligne sans quoi il sera considéré comme un signe inférieur par SBP).

Let's replace function with f and return with < (if < is not preceded by an expression, else it will be interpreted as lower than).

Pour les fonctions variables ou anonymes (disponibles depuis PHP 5.3), utilisez .

For anonymous functions (available since PHP 5.3), use .

Pour ne définir une fonction que si elle n'a pas déjà été définie, utilisez @f.

To define a function only if it not already exists, use @f.

Les classes

Classes


.src/classe.php

<?
Parent
    // Contenu de la classe Parent

Enfant:Parent
    // Contenu de la classe Enfant
    // qui hérite de Parent

Enfant:Parent <<< Interface1, Interface2
    // Contenu de la classe Enfant
    // qui hérite de Parent
    // et implémente 2 interfaces
?>
=>

classe.php

<?php /* Generated By SBP */ 
class Parent {
    // Contenu de la classe Parent
}
class Enfant extends Parent {
    // Contenu de la classe Enfant
    // qui hérite de Parent
}
class Enfant extends Parent implements Interface1, Interface2 {
    // Contenu de la classe Enfant
    // qui hérite de Parent
    // et implémente 2 interfaces
}?>

Remplaçons extends par : et le mot-clé class aux oubliettes !

Let's replace extends with : and forget the class keyword!

.src/classe_methodes.php

<?
Foo
    + pub
        echo "Méthode publique"
    * pro $arguments
        echo "Méthode protégée"
    - pri $a, $b
        <"Méthode privée"
    s+ sta
        <"Méthode statique et publique"
?>
=>

classe_methodes.php

<?php /* Generated By SBP */ 
class Foo {
    public function pub () {
        echo "Méthode publique";
    } protected function pro ($arguments) {
        echo "Méthode protégée";
    } private function pri ($a, $b) {
        return "Méthode privée";
    } static public function sta () {
        return "Méthode statique et publique";
}}?>

Définition de méthodes avec +, * et - (s+, s* et s- pour les méthodes statiques). < (compilé en return) est également disponible dans les méthodes.

Define the methods with +, * and - (s+, s* and s- for static methods). < (compiled into return) is also available in methods.

.src/classe_attributs.php

<?
Foo
    + $pub = "bar"
    * $pro = 42
    - $pri
?>
=>

classe_attributs.php

<?php /* Generated By SBP */ 
class Foo {
    public $pub = "bar";
    protected $pro = 42;
    private $pri;
}?>

Déclaration des attributs avec les mêmes symboles : +, * et -.

Same symbols for attributes: +, * and -.

.src/classe_this.php

<?
Foo
    + getAttrbiute
        <>attribute

    * doubleAttrbiute
        >attribute *=2

    * doubleTwiceAttrbiute
        >doubleAttrbiute()
        >doubleAttrbiute()
?>
=>

classe_this.php

<?php /* Generated By SBP */ 
class Foo {
    public function getAttrbiute () {
        return $this->attribute;
    }
    protected function doubleAttrbiute () {
        $this->attribute *=2;
    }
    protected function doubleTwiceAttrbiute () {
        $this->doubleAttrbiute();
        $this->doubleAttrbiute();
}}?>

Récupération des attributs et méthodes de l'objet $this avec >.

Call methods and attrbiute inside the classe with > instead of $this.

.src/classe_constante.php

<?
Bar
    NAME = "Foo Bar"

    s+ getName
        < :NAME

    s+ printName
        echo :NAME
?>
=>

classe_constante.php

<?php /* Generated By SBP */ 
class Bar {
    const NAME = "Foo Bar";

    static public function getName () {
        return  static::NAME;
    }
    static public function printName () {
        echo static::NAME;
}}?>

const est ajouté automatiquement devant un nom en majuscules suivi de =. Pour récupérer une constante dans la classe où elle a été déclarée (ou une classe fille), il suffit de faire :NOM_DE_LA_CONSTANTE qui sera remplacé à la compilation par static::NOM_DE_LA_CONSTANTE.

const is automatically added before an uppercase name followed by =. To get this constant inside the class or a subclass of it, use :CONSTANT_NAME, it will be compiled into static::CONSTANT_NAME.

Constantes SBP

SBP Constants


.src/server.php

<?

echo __QUERY_STRING
echo __AUTH_USER
echo __AUTH_PW
echo __PATH_INFO
echo __REQUEST_METHOD
echo __USER_AGENT
echo __REFERER
echo __HOST
echo __URI
echo __IP

// Ces constantes peuvent être modifiées
// Mais nous vous recommandons de ne pas le faire
__IP = "234.1.5.65"
=>

server.php

<?php /* Generated By SBP */ 

echo $_SERVER['QUERY_STRING'];
echo $_SERVER['AUTH_USER'];
echo $_SERVER['AUTH_PW'];
echo $_SERVER['PATH_INFO'];
echo $_SERVER['REQUEST_METHOD'];
echo $_SERVER['HTTP_USER_AGENT'];
echo $_SERVER['HTTP_REFERER'];
echo $_SERVER['HTTP_HOST'];
echo $_SERVER['REQUEST_URI'];
echo $_SERVER['REMOTE_ADDR'];

// Ces constantes peuvent être modifiées
// Mais nous vous recommandons de ne pas le faire
$_SERVER['REMOTE_ADDR'] = "234.1.5.65";

SBP propose un accès rapide à plusieurs valeurs de $_SERVER. __FILE et __DIR sont également disponible et renvoient respectivement le fichier SBP en cours d'exécution et le dossier contenant ce dernier. Notez que les constantes __FILE__ et __DIR__ renvoient quant à elles les chemins du fichiers PHP compilés et le dossier contant ce fichier.

SBP propose a short way to get some of the $_SERVER values. __FILE and __DIR are also available and return respectivly the SBP file path wich is running and the directory where this file is. Note that __FILE__ and __DIR__ return different paths, there give the compiled PHP file path and its directory.

Il est déconseillé de modifier directement les variables super-globales ($_GET, $_POST, $_SERVER, etc.), par conséquent, nous déconseillons d'assigner de nouvelles valeurs aux constantes SBP. La modification de __FILE ou __DIR provoquera une erreur. La modification des autres constantes est possible actuellement mais pourrait provoquer une erreur dans une version ultérieure.

You can modify super-global variable ($_GET, $_POST, $_SERVER, etc.), but you should better copy them and edit the copied variables. The same goes for SBP constants, you should avoid to assign a value to them. Modify __FILE or __DIR will throw an error. Other constants can be modified in this version but maybe not in a next version.

Arrays statiques

Static arrays


.src/array_short_syntax.php

<?

$array = {
    un = 1
    deux = 2
    trois = 3
}
=>

array_short_syntax.php

<?php /* Generated By SBP */ 

$array = array(
     'un' => 1
     'deux' => 2
     'trois' => 3
);

Une syntaxe ultra courte pour les arrays dont les clés sont statiques et sans caractères spéciaux.

An ultra-short syntax for arrays with static keys.

Opérateurs personnalisés

Custom operators


.src/custom_operators.php

<?

@f __sbp_in $needle, $haystack

    < is_array($haystack) ?
        in_array($needle, $haystack) :
        strpos($haystack, $needle) !== false


if 5 in [3, 5, 7, 11]
    echo "5 is in [3, 5, 7, 11]"
else
    echo "5 isn't in [3, 5, 7, 11]"

if "BA" in "tagaBAduru"
    echo "BA is in tagaBAduru"
else
    echo "BA isn't in tagaBAduru"
=>

custom_operators.php

<?php /* Generated By SBP */ 

if(! function_exists('__sbp_in')) {
  function __sbp_in ($needle, $haystack) {
    return  is_array($haystack) ?
        in_array($needle, $haystack) :
        strpos($haystack, $needle) !== false;

} }
if (__sbp_in(5, [3, 5, 7, 11])) {
    echo "5 is in [3, 5, 7, 11]";
}else{
    echo "5 isn't in [3, 5, 7, 11]";
}
if (__sbp_in("BA", "tagaBAduru")) {
    echo "BA is in tagaBAduru";
}else{
    echo "BA isn't in tagaBAduru";
}

Pour créer un nouveau mot-clé et lui définir un comportement, il suffit de créer une fonction __sbp_key_word en remplçant "key_word" par le mot-clé en question.

To create a new key word and define a behaviour to it, create a __sbp_key_word function and replace "key_word" with you own keyword.

Super-méthodes

Super-methods


.src/super_methods.php

<?

$sbpPath = 'path/where/sbp/is/installed/'
include_once $sbpPath . 'Src/Sbp/Handler.php'

// sqrt(25)
echo 25-->sqrt()

// pow(5, 3)
echo 5-->pow(3)

// array_sum([1, 3, 7])
echo [1, 3, 7]-->sum()

f array_custom($array, $a, $b)
    $array[] = $a+$b
    < $array

f str_custom($string, $a, $b)
    $string. = $a+$b
    < $string

// return [5, 3]
[5]-->custom(1, 2)

// return "abc3"
"abc"-->custom(1, 2)
=>

super_methods.php

<?php /* Generated By SBP */ 

$sbpPath = 'path/where/sbp/is/installed/';
include_once $sbpPath . 'Src/Sbp/Handler.php';

// sqrt(25)
echo (new \Sbp\Handler(25))->sqrt();

// pow(5, 3)
echo (new \Sbp\Handler(5))->pow(3);

// array_sum([1, 3, 7])
echo (new \Sbp\Handler([1, 3, 7]))->sum();

function array_custom($array, $a, $b){
    $array[] = $a+$b;
    return  $array;
}
function str_custom($string, $a, $b){
    $string. = $a+$b;
    return  $string;
}
// return [5, 3]
(new \Sbp\Handler([5]))->custom(1, 2)

// return "abc3"
(new \Sbp\Handler("abc"))->custom(1, 2);

L'opérateur -->ma_fonction permet d'exécuter ma_fonction sur la variable ou la valeur qui précède. Si la valeur est un array, la fonction array_ma_fonction est utilisée si elle existe ; si la valeur est de type string, la fonction preg_ma_fonction est utilisée si elle existe, sinon str_ma_fonction si elle existe et la valeur est passée en premier paramètre (sauf pour replace, replace_callback et filter : troisième paramètre et pour split, match et match_all : second paramètre).

The -->my_function operator will execute my_function on the previous variable or value. If the value is an array, the function array_my_function will be used if it exists; if the value is a string, the function preg_my_function will be used if it exists, else str_my_function if it exists and the value is passed as the first argument (except for replace, replace_callback and filter: third argument and for split, match and match_all: second argument).

Dans tous les autres cas, ma_fonction est utilisée et la valeur passée en premier paramètre.

In any other case, my_function is used and the value is the first argument.

Les super-méthodes utilisent Sbp\Handler, il faut donc inclure Sbp/Handler.php dans vos scripts, ou utiliser Sbp via Composer.

Super-methods use Sbp\Handler, so you must include Sbp/Handler.php in your scripts, or use Sbp via Composer.

Raccourcis pour les expressions régulières

Regular expression shortcuts


.src/regex.php

<?
$return = "AbcdEF"-->replace(/[a-z]/, '#')
=>

regex.php

<?php /* Generated By SBP */ 
$return = (new \Sbp\Handler("AbcdEF"))->replace('/[a-z]/', '#');

La syntaxe Java/JavaScript peut être utilisée pour créer une chaîne contenant une expression régulière.

The Java/JavaScript syntax can be used to create a regular expression contained in a string.

PHPUnit


.src/phpunit.php

<?

MathTest:\PHPUnit_Framework_TestCase

    +testSomeCalcs

        // should suivi d'un opérateur vérifie qu'une comparaison est vraie
        sqrt(25) should == 5
        6 should > 4
        // vérifier qu'une fonction renvoie true
        should class_exists('MathTest')
        // be après should devient is pour une conjugaison correcte dans le code
        strtolower('ABC') should be 'abc'
        // message personnalisé
        strtolower('ABC') should be 'abc', "strtolower devrait transformer ABC en abc"
        // be, is et === sont sensibles aux types
        7 should not be "7"
||
V

phpunit.php

<?php /* Generated By SBP */ 

class MathTest extends \PHPUnit_Framework_TestCase {

    public function testSomeCalcs () {

        // should suivi d'un opérateur vérifie qu'une comparaison est vraie
        $this->assertTrue(sqrt(25) == 5, 'sqrt(25) should == 5');
        $this->assertTrue(6 > 4, '6 should > 4');
        // vérifier qu'une fonction renvoie true
        $this->assertTrue(class_exists('MathTest'), 'should class_exists('MathTest')');
        // be après should devient is pour une conjugaison correcte dans le code
        $this->assertTrue(strtolower('ABC') === 'abc', 'strtolower('ABC') should be 'abc'');
        // message personnalisé
        $this->assertTrue(strtolower('ABC') === 'abc', "strtolower devrait transformer ABC en abc");
        // be, is et === sont sensibles aux types
        $this->assertFalse(7 === "7", '7 should !== be "7"');
}}

Une syntaxe claire et légère pour les tests unitaires PHPUnit.

A clear and short syntax for PHPUnit unit tests.

Container (disponible dans SelfBuild)

Container (with SelfBuild only)


.class.php.container

<?

{CamelCase}:Object

    {content}

    + __destruct

        log("{file}")
        // {basename}
        // {name}
        // {camelCase}

?>

.src/ma_classe.class.php


- $privateAttribute = 42
* $protectedAttribute = "foo"
+ $publicAttribute = "bar"

- privateMethod
    <>privateAttribute;

* protectedMethod $val
    >privateAttribute = $val

+ publicMethod
    echo >privateAttribute
    < true
=>

ma_classe.class.php

<?php /* Generated By SBP */   class MaClasse extends Object {      
    private $privateAttribute = 42;
    protected $protectedAttribute = "foo";
    public $publicAttribute = "bar";
    
    private function privateMethod () {
        return $this->privateAttribute;
    }
    protected function protectedMethod ($val) {
        $this->privateAttribute = $val;
    }
    public function publicMethod () {
        echo $this->privateAttribute;
        return  true;
    }
    public function __destruct () {

        log("/sbp/files/ma_classe.class.php");
        // ma_classe.class.php
        // ma_classe
        // maClasse
}}
?>

Le modèle .extension.container est appliqué lors de l'enregistrement à tous les fichiers portant l'extension .extension et pour lesquels vous avez activé SBP via l'icône Minifier.

The .extension.container is applied on .extension files when SBP is selected via the button Minifier.

Les sauts de lignes précédents {content} sont remplacés par des espaces de sorte que les numéros de lignes du fichier PHP compilés correspondent aux numéros de lignes du fichier SBP source.

New lines before {content} are replaced with spaces to keep the line numbers of the SBP source and PHP compiled files match.

Des tags de remplacement sont alors disponibles dans ces containers :

Replaced tags are available in containers:

Il manque quelque chose ?

It's missing something?


Des idées, suggestions, vous rencontrez des difficultés à l'utilisation ? Discutons-en ci-dessous.

Ideas, suggestions, any trouble in using it? Let's talk about it below.

N'hésitez pas à indiquer les syntaxes, fonctions et parties les plus récurrentes de vos codes PHP, pour orienter les choix des prochains ajouts de SBP.

Do not hesite to wich syntaxes, functions or code blocks you use most in you PHP codes to help us to choose the next features we'll implement.

comments powered by Disqus