Quali consigli generali hai per giocare a golf in PHP? Sto cercando idee che possano essere applicate ai problemi del codice golf in generale che siano almeno in qualche modo specifiche per PHP (ad esempio "rimuovere i commenti" non è una risposta). Si prega di inviare un suggerimento per risposta.

Comprendi come variabili e spazi bianchi interagiscono con i costrutti del linguaggio di PHP.

Nel mio (per quanto breve) gioco del golf, ho scoperto che i costrutti del linguaggio di PHP (ad esempio eco, return, for, while, ecc.) Si comportano in modo poco intuitivo quando interagiscono con variabili e spazi bianchi.

echo$v;, per esempio, è perfettamente valido, così come lo sono return$v;e altri costrutti simili. Queste piccole riduzioni degli spazi bianchi possono portare a una significativa riduzione cumulativa della lunghezza.

Tieni presente, tuttavia, che le variabili prima dei costrutti del linguaggio richiedono uno spazio dopo, come nell'esempio seguente:

foreach($a AS$b){}

Poiché ASè un costrutto di linguaggio, non è necessario uno spazio prima della variabile $b, ma se si dovesse omettere lo spazio prima di essa , risultando $aAS, questo verrebbe analizzato come un nome di variabile e porterebbe a un errore di sintassi.

Usa le stringhe con saggezza.

Questa risposta è duplice. La prima parte è che quando si dichiarano le stringhe, è possibile utilizzare la conversione implicita di PHP di costanti sconosciute in stringhe per risparmiare spazio, ad esempio:

@$s=string;

Il @è necessario per ignorare le avvertenze Questo produrrà. Nel complesso, si ottiene una riduzione di un carattere.

è che a volte può essere efficace lo spazio per impostare una variabile sul nome di una funzione usata spesso. Normalmente potresti avere:

preg_match(..);preg_match(..);

Ma quando si gioca a golf, questo può essere abbreviato facilmente per:

@$p=preg_match;$p(..);$p(..);

Con solo due istanze di "preg_match", stai salvando solo un singolo carattere, ma più usi una funzione, più spazio risparmierai.

Non è sempre necessario scrivere controlli condizionali. Ad esempio, alcuni framework lo usano nella parte superiore dei loro file per bloccare l'accesso:

<?php defined('BASE_PATH')||die('not allowed');

O in normali funzioni

$value && run_this();

invece di

if($value) { run_this(); }

Usa la sintassi dell'array breve

A partire da PHP 5.4, le matrici possono essere dichiarate usando parentesi quadre (proprio come JavaScript) invece della array()funzione:

$arr=['foo','bar','baz'];
// instead of
$arr=array('foo','bar','baz');

Salverà cinque byte.

Ma può costare byte se hai "buchi" in un array associativo:

$arr=array(,1,,3,,5);
// is one byte shorter than
$arr=[1=>1,3=>3,5=>5];

lo svantaggio colpisce un po 'più tardi se puoi riempire i buchi con valori "vuoti":

$arr=[0,1,0,3,0,5,0,7,0,9,10,11];
// costs two byte more than
$arr=array(,1,,3,,5,,7,,9,,11);

Usa $ {0}, $ {1}, $ {2}, ... invece di $ a [0], $ a [1], $ a [2], ...

A meno che non si esegua una manipolazione di array, la maggior parte dei riferimenti a un indice di array $a[$i]può essere sostituita semplicemente $$i. Ciò è vero anche se l'indice è un numero intero, poiché i numeri interi sono nomi di variabili validi in PHP (anche se i letterali richiedono parentesi, ad esempio ${0}).

Considera la seguente implementazione del rubinetto Rabonowitz Wagon:

3.<?for(;$g?$d=0|($a[$g]=$d*$g--/2+($a[$g]?:2)%$g*1e4)/$g--:238<<printf($e?'%04d':'',$e+$d/$g=1e4)^$e=$d%$g;);

Questo può essere migliorato di 6 byte, semplicemente sostituendo entrambi i riferimenti di matrice $a[$g]con $$ginvece:

3.<?for(;$g?$d=0|($$g=$d*$g--/2+($$g?:2)%$g*1e4)/$g--:238<<printf($e?'%04d':'',$e+$d/$g=1e4)^$e=$d%$g;);

Scopri un ampio sottoinsieme delle funzioni della libreria .

La libreria di PHP è piuttosto vasta e offre moltissime funzioni utili che possono abbreviare notevolmente varie attività. Potresti semplicemente cercare ogni volta che provi a fare qualcosa, ma oltre a perdere tempo potresti non trovare nulla che corrisponda alla tua ricerca particolare. Il modo migliore è solo familiarizzare con la libreria e memorizzare i nomi delle funzioni e ciò che fanno.

Funzioni in esecuzione all'interno delle stringhe.

Prova questo:

$a='strlen';
echo "This text has {$a('15')} chars";

Oppure prova questo:

//only php>=5.3
$if=function($c,$t,$f){return$c?$t:$f;};
echo <<<HEREDOCS
    Heredocs can{$if(true,' be','not be')} used too and can{$if(<<<BE
{$if(true,1,0)}
BE
,'','not')} be nested
HEREDOCS;
//Expected output: Heredocs can be used too and can be nested

Funziona solo con le stringhe che usano "" e heredocs (NON confondere con nowdocs).

L'uso di funzioni nidificate è possibile solo all'interno di heredocs nidificati (o si verificheranno errori di analisi)!

divertente con i dattiloscritti

• !!$footrasformerà qualsiasi valore di verità in true(o 1in output), falsi valori (0, stringa vuota, array vuoto) in false(o output vuoto)
  Ciò sarà raramente necessario nel golf del codice, poiché nella maggior parte dei casi in cui è necessario un valore booleano, c'è un cast implicito comunque.

• (int)$foopuò essere scritto come $foo|0o foo^0, ma può richiedere parentesi.
  Per booleani e stringhe, $foo*1oppure +$foopuò essere utilizzato per eseguire il cast in int.

• A differenza della maggior parte delle altre lingue, PHP gestisce le stringhe con valori numerici come numeri. Quindi, se hai una stringa che contiene un numero con cui devi calcolare, calcola.
• L'altro modo non funziona: per moltiplicare qualsiasi numero in una variabile con 10, è possibile aggiungere uno zero: *10-> .0. Ma in questo caso, PHP prenderà il punto come punto decimale e si lamenterà. (È diverso se hai una quantità variabile di zero in una stringa.)
• Per trasformare un array in una stringa, utilizzare joininvece di implode.
  Se non hai bisogno di un delimitatore, non usarlo: join($a)fa lo stesso dijoin('',$a)
• Stringhe incrementali: la caratteristica più incredibile imo è quella che $s=a;$s++;produce $s=b;. Funziona con caratteri maiuscoli e minuscoli. $s=Z;$s++;risultati in $s=AA;.
  Questo funziona anche con maiuscole / minuscole: aZto bA, A1to A2, A9to B0e z99Zto aa00A.
  Il decremento non funziona sulle stringhe. (E non funziona NULL).
  Torna in PHP 3, $n="001";$n++;prodotto$n="002"; . Sono un po 'triste che l'hanno rimosso.

Qualunque cosa tu golf: tieni sempre a portata di mano la tabella delle priorità degli operatori .

Usa le scorciatoie

Nel codice normale, è buona norma utilizzare <?phpe ?>. Tuttavia, questo non è un codice normale: stai scrivendo un codice golf. Invece di <?phpscrivere <?. Invece di <?php echoscrivere <?=. Non digitare ?>alla fine: è completamente opzionale. Se è necessario ?>per qualche motivo (ad esempio per l'output del testo, ed è più breve in qualche modo, o qualcosa del genere, non mettere un punto e virgola prima di esso - non è necessario, poiché?> implica il punto e virgola.

Sbagliato (decisamente troppo lungo):

<?php echo ucfirst(trim(fgets(STDIN)));?>s!

Corretta:

<?=ucfirst(trim(fgets(STDIN)))?>s!

scorrere tra le stringhe

può essere fatto con 26 byte o con 24 fino a 18:

foreach(str_split($s)as$c)  # A) 26 - general
for($p=0;a&$c=$s[$p++];)    # B) 24 - general
for($p=0;$c=$s[$p++];)      # C) 22 - if $s has no `0` character
for(;a&$c=$s[$p++];)        # D) 20 - if $p is already NULL or 0 (does NOT work for false)
for(;$c=$s[$p++];)          # E) 18 - both C and D

for(;$o=ord($s[$p++]);)     # F) 23 - work on ASCII codes, if $s has no NULL byte and D
for(;~$c=$s[$p++];)         # G) 19 - if $s has no chr(207) and D

$a&$bfa un AND bit per bit sui (codici ascii di) i caratteri in $ae $b
e risulta in una stringa che ha la stessa lunghezza del più corto di $ae $b.

Usa operatori ternari

if(a==2){some code;}else{some other code;}

può essere abbreviato in questo:

(a==2?some code:some other code);

Più breve, eh?

con qualsiasi altro nome ... alias di funzione

uso ...

• join invece di implode
• chopinvece di rtrim( chopin PERL è diverso!)
• die invece di exit
• fputs invece di fwrite
• is_intinvece di is_integerois_long
• is_realinvece di is_floatois_double
• key_exists invece di array_key_exists
• mysql invece di mysql_db_query

... per nominare gli alias più importanti. Dai un'occhiata a http://php.net/aliases per ulteriori informazioni.

Gli array associativi possono essere uniti +all'operatore.

Invece di:

$merged = array_merge($a, $b);

Uso:

$merged = $a + $b;

Nota che l' +operatore lavora anche con array indicizzati, ma probabilmente non fa ciò che desideri.

array_flip vs array_search

uso

array_flip($array)[$value]

invece di

array_search($value,$array)

per salvare 1 byte in array in cui la ricorrenza di ciascun valore è unica

alcuni fatti interessanti su variabili variabili

Ho dovuto condividerli (anche prima di aver verificato che almeno uno di loro aiuta a giocare a golf):

• Usa lettere: $x=a;$$x=1;$x++;$$x=2;echo"$a,$b";stampe1,2
  ma altre operazioni aritmetiche non funzionano con le lettere.
• Come primo accennato in precedenza , è possibile utilizzare numeri puri come nomi di variabili:
  $a=1;$$a=5;$a++;$$a=4;${++$a}=3;echo${1},${2},${3};stampe543 .
• Puoi utilizzare non solo i [0-9a-zA-Z_]nomi delle variabili, ma OGNI stringa:
  $x="Hello!";$$x="Goodbye.";echo${"Hello!"};stampe Goodbye..
• Ma: tutto tranne che [a-zA-Z_][a-zA-Z_0-9]*come nomi di variabili richiede parentesi graffe per un uso letterale.
• Senza variabili definite, $$x=1imposta ${NULL}, che è uguale a ${false}e ${""}.

• $a=1;$$a=5;non solo imposta ${1}, ma anche ${true}.

• un altro, il più strano che abbia mai trovato finora: provalo $a=[];$$a=3;echo${[]};. Sì, stampa 3!

The reason for most of this: variable names are always evaluated to strings.
^{(Thanks @Christoph for pointing out.)}
So, whatever you get when you print or echo the expression, that´s what you get as variable name.

line breaks
if the output requires line breaks, use a physical line break (1 byte) instead of "\n"
This also gives you a possible benefit to chose between single and double quotes.

avoid quotes where possible

PHP implicitly casts unknown words to literal strings.

$foo=foo; is the same as $foo='foo'; (assuming that foo is neither a key word or a defined constant): $foo=echo; does not work.

BUT: $p=str_pad; does; and $p(ab,3,c) evaluates to abc.

Using string literals without quotes will yield a Notice for Use of undefined constant; but that won´t show if you use the default value for error_reporting (CLI parameter -n).

Arrow functions in PHP 7.4

PHP 7.4 is on RC2 version now and hopefully will be released in about 2 months. List of new features are here (this page can actually be updated when 7.4 is released). In 7.4, finally PHP has got the arrow functions, so not only function answers can be shorter now, but also passing closures to other functions can be a lot shorter too. Here are a few examples:

Return input + 1:

Anonymous function (closure) - 25 bytes - Try it online!

function($n){return$n+1;}

Arrow function - 12 bytes - Try it online!

fn($n)=>$n+1

Multiply items of first input (array of ints) by second input (int):

Anonymous function (closure) - 72 bytes - Try it online!

function($a,$n){return array_map(function($b)use($n){return$b*$n;},$a);}

Arrow function - 38 bytes - Try it online!

fn($a,$n)=>array_map(fn($b)=>$b*$n,$a)

Did you notice that $n is accessible in the inner function without a use $n statement? Yeah that is one of the arrow function features.

As a side note, I could not get arrow functions to work recursively (call the same arrow function inside itself), because we cannot give them a name and storing them as a closure in a variable like $f doesn't make $f accessible withing itself (sad). So this example doesn't work and using $f in first line causes a fatal error:

$f=fn($n)=>$n?$f($n-1):0;
$f(5); // Causes error: "PHP Notice: Undefined variable: f" + "PHP Fatal error: Uncaught Error: Function name must be a string"

But calling an arrow function withing a different arrow function works:

$f1=fn($n)=>$n+1;
$f2=fn($n)=>$f1($n-1);
$f1(2) // Returns 3
$f2(2) // Returns 2

Regarding file I/O:

Linking to another related question, the answers to which fit here.

Directly dereference arrays returned from functions.

E.g., instead of this:

$a = foo();
echo $a[$n];

You can do:

echo foo()[$n];

This works with methods too:

echo $obj->foo()[$n];

You can also directly dereference array declarations:

echo [1, 2, 3, 4, 5][$n];

Use end() instead of array_pop()

The end() function doesn't just move the internal pointer to the end of the array, it also returns the last value. Note of course that it doesn't remove that value, so if you don't care what the array contains afterwards, you can use it instead of array_pop().

double array_flip vs in_array vs array_unique

in this special case a double array_flip saves 10 Bytes

($f=array_flip)($k=$f($c))) remove all double values in the array and I have dropped this $c=[], , |in_array($o,$c) and replace array_keys($c) with $k

for([,$x,$y]=$argv;a&$o=$y[$i];$i++)
$x[$i]==$o?:$c[$x[$i]]=$o; # if char string 1 not equal char string 2 set key=char1 value=char2
echo strtr($x,($f=array_flip)($k=$f($c)))==$y # boolean replacement string 1 equal to string 2
    ?join($k)." ".join($c) # output for true cases
:0; #Output false cases

Online Version

against

for($c=[],[,$x,$y]=$argv;a&$o=$y[$i];$i++)
  $x[$i]==$o|in_array($o,$c)?:$c[$x[$i]]=$o; # if char string 1 not equal char string 2 set key=char1 value=char2
echo strtr($x,$c)==$y # boolean replacement string 1 equal to string 2
  ?join(array_keys($c))." ".join($c) # output for true cases
  :0; #Output false cases

Online version

against array_unique it saves 2 Bytes

for([,$x,$y]=$argv;a&$o=$y[$i];$i++)
  $x[$i]==$o?:$c[$x[$i]]=$o; # if char string 1 not equal char string 2 set key=char1 value=char2
echo strtr($x,array_unique($c))==$y # boolean replacement string 1 equal to string 2
  ?join(array_keys($c))." ".join($c) # output for true cases
  :0; #Output false cases

Online Version

After finding a bug in this program and replacement $x[$i]==$o?:$c[$x[$i]]=$o to ($p=$x[$i])==$o?:$k[$c[$p]=$o]=$p the double array_flip was not necessary longer

intersecting strings

Have you ever used
join("DELIMITER",str_split($s)) (31 bytes) or even
preg_replace(".","DELIMITER",$s) (32 bytes)
?

There´s a builtin for that:

Try chunk_split($s,1,"DELIMITER") (29 bytes).

If you omit the third parameter, chunk_split will use \r\n; that can save you 7 or 8 bytes.

But beware: chunk_split also appends the delimiter to the string,
so you may not get exactly what you want.

(If you don´t provide the chunk length, it will use 76. Rather unusual for code golf, but who knows.)

unset() vs INF

In a case search for a minimum in an array you can use instead of

unset($var[$k]);

$var[$k]=INF;

to save 3 Bytes

str_repeat

In some cases you have a input of characters and you should output them repeated with an input greater zero for each characters.

for(;--$z?:($c=$argn[$i++]).$z=$argn[$i++];)echo$c;

(52 bytes) is shorter than

for(;~$c=$argn[$i++];)echo str_repeat($c,$argn[$i++]);

or

for(;~$c=$argn[$i++];)echo str_pad($c,$argn[$i++],$c);

(54 bytes each)

How it works for example input a1b2c1

$z is not set (implicit NULL), so --$z does nothing and is falsy;

$c="a", $z="1" and $i=2 -> $c.$z="a1" is truthy -> output "a"

--$z=0; so we set $c="b", $z="2" (and $i=4) -> $c.$z="b2" is truthy -> output "ab"

--$z=1 -> output "abb"

--$z=0; so we set $c="c" and $z=1 $c.$z="c1" is true output "abbc"

--$z=0 so $c="" and $z="" -> $c.$z="" is falsy -> loop breaks

Combining for loops

Suppose you have code of the following form:

for($pre1; $cond1; $post1) for($pre2; $cond2; $post2) $code;

this can generally be re-rolled in the following form:

for($pre1; $cond2 • $post2 || $cond1 • $pre2 • $post1; ) $code;

where • represents a generic combining operator. This usually results in an byte count reduction, but will likely require some creativity. $cond2 will need to be written so that it fails the first time through. $post1 should also fail to execute the first time, although it may be easier to refactor beforehand so that $post1 is not present.

If you're working with three or more nested loops, you can also combine two first, and then combine that to another, and so on. I find that it has generally been easier to combine from the inside outwards.

As an example, consider the following solution to the H-carpet fractal (97 bytes):

for(;$i<$n=3**$argn;$i+=print"$s\n")for($s=H,$e=1;$e<$n;$e*=3)$s.=str_pad($i/$e%3&1?$s:'',$e).$s;

This can be reformulated in the following way:

for(;($i+=$e&&print"$s\n")<$n=3**$argn;)for($s=H,$e=1;$e<$n;$e*=3)$s.=str_pad($i/$e%3&1?$s:'',$e).$s;

$e&&print prevents print on first iteration, and also does not increment $i.

and finally (93 bytes):

for(;$H>$e*=3or$e=($i+=$e&&print"$s\n")<${$s=H}=3**$argn;)$s.=str_pad($i/$e%3&1?$s:'',$e).$s;

$H>$e*=3 will fail the first time as both variables are undefined.

Removing characters in a string

join(explode(" ",$string));

saves 1 character compared to

str_replace(" ","",$string);

array_merge vs array_push

array_push($a,...$b); 

is one byte shorter than

$a=array_merge($a,$b);

Does not work the same with Associative arrays

variable-arg-list PHP >5.6

Use boolean operators instead of strtoupper() and strtolower()

If you're working exclusively with strings consisting of alphabet characters, you can use boolean operators to change them to uppercase or lowercase with fewer keystrokes than PHP's built-in functions.

Example:

// Convert lowercase to uppercase
$s = "g";
echo strtoupper($s);  // Outputs 'G', uses 20 characters
echo~" "&$s;          // Outputs 'G', uses 12 characters

// Convert uppercase to lowercase
$s = "G";
echo strtolower($s);  // Outputs 'g', uses 20 characters
echo$s^" ";           // Outputs 'g', uses 11 characters

// Switch case of each character
$s = "Gg";
echo$s^"  ";          // Outputs 'gG', uses 12 characters

Things are a little trickier for strings of arbitrary length, but the & and ^ operators will truncate the result to the length of the shorter input string. So for example, if $W is a string of spaces at least as long as any input $s, then ~$W&$s is equivalent to strtoupper($s), and $s|$W^$s is equivalent to strtolower($s) (whereas $s|$W by itself will produce a string with additional spaces unless $s and $W are of equal length).

use deprecated functions
If you can use POSIX instead of PERL regex without wasting more than 5 bytes on the expression, use ereg or eregi instead of preg_match, split or spliti instead of preg_split.
split Can also be used as a synonym for explode for most delimiters.

These functions are marked deprecated and will throw E_DEPRECATED notices, but (cannot find the source now) I think I have read that warnings and notices are ok.