Programming-Idioms.org

echo "Hello World" . PHP_EOL;

<?='Hello World'?>

<?php echo 'Hello World'; ?>

for ($i = 0; $i < 10; $i++) {
    echo 'Hello' . PHP_EOL;
}

foreach(range(1, 10) as $i)
  echo 'Hello'. PHP_EOL;

function finish($name) 
{
    echo "My job here is done. Goodbye $name";
}

function()
{
    echo "Hello World";
}

function square(int $x): int
{
    return $x * $x;
}

// square(4) -> 16
// square(3.4) -> Uncaught TypeError: Argument 1 passed to square() must be of the type int, float given

class Point
{
    /** @var float */
    public $x = 0.0;

    /** @var float */
    public $y = 0.0;
}

foreach ($items as $x){
    doSomething( $x );
}

array_map(func, $items);

foreach ($items as $i=>$x)
{
    echo "i=$i, x=$x"; echo '<br>';
}

$x = ['one' => 1, 'two' => 2];

class BNode
{
    public $data;
    public $lNode;
    public $rNode;

    public function __construct($item)
    {
        $this->data = $item;
        $this->lNode = null;
        $this->rNode = null;
    }
}

shuffle($x);

$x[ array_rand($x) ]

in_array($x, $list, true);

foreach ($mymap as $k=>$x)
{
    echo "Key=$k, Value=$x <br>";
}

function pick(float $a, float $b): float
{
    $rand = mt_rand() / mt_getrandmax();
    $rand *= ($b - $a);
    $rand += ($a);

    return $rand;
}

rand($a, $b)

public function dfs($f, $bt)
{
	if ($bt->left != null)
		$this->dfs($f, $bt->left);

	$f($bt);
	
	if ($bt->right != null)
		$this->dfs($f, $bt->right);
}

class Tree
{
    public $children = [];
    public $data;
    
    public function __construct($data, $children)
    {
        $this->data = $data;
        $this->children = $children;
    }
}

final class Node {
    public function __construct(public array $children, public mixed $data) {}
}

function dfs($f, $root)
{
    $f($root);
    foreach($root as $child)
    {
        dfs($child);
    }	
}

$x = array_reverse($x, true);

function search($x, array $m): ?array
{
    for ($j = 0; $j < count($m); $j++) {
        if (($i = array_search($x, $m[$j])) !== false) {
            return [$i, $j];
        }
    }

    return null;
}

$tmp = $a;
$a = $b;
$b = $tmp;

list($b, $a ) = [ $a, $b ];

[ $b, $a ] = [ $a, $b ];

$i = intval($s, 10);

$s = sprintf('%.2f', $x);

$s = "ネコ";

class AsyncOperation extends Thread
{
    private $name;

    public function __construct($arg)
    {
        $this->name = $arg;
    }

    public function run()
    {
        sleep(1);
        if ($this->name) {
            printf("Hello %s\n", $this->name);
        }
    }
}

$thread = new AsyncOperation("World");

if ($thread->start()) {
    $thread->merge(['name' => 'Alan']);
}

$x = array();
$x = array_pad($x, m, 1);
for($i = 0; $i < count($x); $i++){
  $x[$i] = array();
  $x[$i] = array_pad($x[$i],n,1);
}

$m = 3;
$n = 4;

$x = array_map(
    function () use ($m) { return array_fill(0, $m, 0); },
    range(1, $n)
);

$x = array_fill(0, $m, array_fill(0, $n, array_fill(0,$p,0)));

function cmp($a, $b)
{
    if ($a->p == $b->p) {
        return 0;
    }

    return ($a->p < $b->p) ? -1 : 1;
}

usort($items, 'cmp');

unset($items[$i]);

function f($i) {
	if($i == 0) {
		return 1;
	}

	return ($i * f($i-1));
}

function f(int $i): int
{
    if ($i == 0) {
        return 1;
    }

    return $i * f($i - 1);
}

function custom_exp($x, $n)
{
    if ($n === 0) {
        return 1;
    }

    if ($n === 1) {
        return $x;
    }

    if (!($n % 2)) {
        return custom_exp($x * $x, $n / 2);
    }

    return $x * custom_exp($x * $x, ($n - 1) / 2);
}

echo custom_exp(5, 10);

$mutex = Mutex::create();
Mutex::lock($mutex);
$x = f($x);
Mutex::unlock($mutex);
Mutex::destroy($mutex);

function compose($f, $g)
{
    return function ($x) use ($f, $g) {
        return $g($f($x));
    };
};

function compose($f,$g){
	return function($x) use($f,$g) {
		return $g($f($x));
	}
}

function curry($f, ...$argsCurried)
{
    return function (...$args) use ($f, $argsCurried) {
        $finalArgs = array_merge($argsCurried, $args);
        return call_user_func_array($f, $finalArgs);
    };
}

function add($n1, $n2)
{
    return $n1 + $n2;
}

$addFive = curry('add', 5);

echo $addFive(2), PHP_EOL;
echo $addFive(-5), PHP_EOL;

function curry($f, ...$argsCurried)
{
    return function (...$args) use ($f, $argsCurried) {
        return $f(...$argsCurried, ...$args);
    };
}

function add($n1, $n2)
{
    return $n1 + $n2;
}

$addFive = curry('add', 5);

echo $addFive(2), PHP_EOL;
echo $addFive(-5), PHP_EOL;

$t = mb_substr($s, $i, $j-$i, 'UTF-8');

$mystring = 'abc';
$findme   = 'a';
$pos = strpos($mystring, $findme);

// Nótese el uso de ===. Puesto que == simple no funcionará como se espera
// porque la posición de 'a' está en el 1° (primer) caracter.
if ($pos === false) {
    echo "La cadena '$findme' no fue encontrada en la cadena '$mystring'";
} else {
    echo "La cadena '$findme' fue encontrada en la cadena '$mystring'";
    echo " y existe en la posición $pos";
}

$mystring = 'abc';
$findme   = 'a';
$pos = strpos($mystring, $findme);

// Nótese el uso de ===. Puesto que == simple no funcionará como se espera
// porque la posición de 'a' está en el 1° (primer) caracter.
if ($pos === false) {
    echo "La cadena '$findme' no fue encontrada en la cadena '$mystring'";
} else {
    echo "La cadena '$findme' fue encontrada en la cadena '$mystring'";
    echo " y existe en la posición $pos";
}

$ok = str_contains($s, $word);

for ($i=0;$i<mb_strlen($s);$i++) {
    $characters[] = mb_substr($s, $i, 1, 'UTF-8');
}

$characters = array_reverse($characters);
$t = implode($characters);

$array_1 = [1,2,3,4,5];
$array_2 = [3,4];

foreach ($array_1 as $a) {
    foreach ($array_2 as $b) {
        if ($b == $a) {
            continue 2;
        }
    }
    echo $a
}

for ($y = 0; $y < count($m); $y++) {
    for ($x = 0; $x < count($m[$y]); $x++) {
        if ($m[$y][$x] == $v) {
            break 2;
        }
    }
}

array_splice($s, $i, 0, $x);

sleep(5);

$t = mb_substr($s, 0, 5, 'UTF-8');

$t = mb_substr($s, -5, null, 'UTF-8');

$s = "This string 
is spanning
three lines";

$s = <<<EOD
Huey
Dewey
Louie
EOD;

$chunks = preg_split('/ +/', $s);

while (true) {
    // do something
}

array_key_exists($k, $m)

in_array($v, $m, true);

$y = implode(', ', $x);

$s = array_sum($x);

$s = "$i";

$s = (string)$i;

$s = "{$i}";

$s = strval($i);

function p($element) {  /* .... */ }

$y = array_filter ($x, "p");

$lines = file_get_contents('f');
if ($lines === false) {
    // handle error...
}

fwrite(STDERR, "{$x} is negative\n");

$x = $argv[1];

$d = time();

$i = mb_strpos($x, $y, 0, 'UTF-8');

$x2 = str_replace($y, $z, $x);

$x = gmp_pow(3, 247);
echo gmp_strval($x);

$s = number_format($x * 100.0, 1) . '%';

gmp_binomial($n, $k);

$x = new BitSet($n);

srand($s);

srand(time());

echo implode(' ', array_slice($argv, 1)), PHP_EOL;

$x = gmp_gcd($a, $b);

$gcd = gmp_lcm($a, $b);
echo gmp_strval($gcd);

$s = sprintf("%b", $x);

do {
    echo '.';
} while ($c);

$y = (float) $x;

$y = (int)$x;

$y = (int) round($x);

$c = substr_count($s , $t);

preg_match_all("/htt+p/", $r, $matches)

$i = base_convert($i,10,2);
$x = str_replace(0,'',$i);
$c = strlen($x);

function _addingWillOverflow($x, $y): bool
{
    return (PHP_INT_MAX - $y) > $x;
}

function multiplyWillOverflow($x, $y)
{
      return ($x * $y) > PHP_INT_MAX;
}

exit();

die();

$memStart = memory_get_usage();
$buf = str_repeat("\x00", 1000 * 1000);
$memEnd = memory_get_usage();
echo $memEnd - $memStart, PHP_EOL;

throw new \InvalidArgumentException($x . ' is invalid.');

class Foo
{
    /** @var int */
    private $x;

    /**
     * @return int
     */
    public function getX()
    {
        return $this->x;
    }
}

class Foo
{
    /** @var int */
    private $x;

    public function getX(): int
    {
        return $this->x;
    }
}

$x = json_decode(file_get_contents('data.json'));

file_put_contents('data.json', json_encode($x));

function control($f) {
    $f();
}

echo is_object($x) ? get_class($x) : gettype($x);

$x = filesize($path);

$b = (bool) preg_match('#^http#', $s);

$b = (bool)preg_match("/{$suffix}$/", $s);

$d = DateTime::createFromFormat('U', $ts);

$x = date("Y-m-d", strtotime($d));

$formattedVar = date("Y-m-d", strtotime($unformattedVar));

# Take the unformated Variable, let PHP do it's best to
# 'understand' it and then format the resultant into the 
# desired format.

uasort($items, $c);

$s = file_get_contents($u);

class Test
{
    public $f1;
    private $f2;

    public function __construct($f1, $f2)
    {
        $this->f1 = $f1;
        $this->f2 = $f2;
    }
}

$x = new Test('foo', 42);

$options = array(
  XML_SERIALIZER_OPTION_INDENT        => '    ',
  XML_SERIALIZER_OPTION_RETURN_RESULT => true
  );

$serializer = new XML_Serializer($options);
$result = "<?xml version=\"1.0\"?>\n" . $serializer->serialize($x);
file_put_contents('data.xml', $result);

$s = $_SERVER['PHP_SELF'];

$dir = getcwd();

$dir = realpath(dirname(__FILE__));

$x = 'foo';

if (isset($x)) {
    echo $x;
}

if(@$foo) print($foo);

$blank = (empty(trim($s));

$blank = !trim($s);

exec($x . " a b");

ksort($mymap);
foreach($mymap as $k => $v) {
    echo 'k:', $k, ' ', 'v:', $v, PHP_EOL;
}

$b = ($x == $y);

$d1 = new DateTime('January 25 2016');
$d2 = new DateTime('January 26 2016');

$b = $d1 < $d2;

$s2 = str_replace($w, '', $s1);

$n = count($x);

$y = array_unique($x);

$x = array_unique($x);

fscanf(STDIN, "%d\n", $n);

$socket = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);
socket_bind($socket, '127.0.0.1', 1337);

socket_recvfrom($socket, $buffer, 16, 0, $fromAddr, $fromPort);
echo "[{$fromAddr}:{$fromPort}]\t{$buffer}";

// Send a test from the command line such as:
// echo "hello" > /dev/udp/127.0.0.1/1337

abstract class Suit
{
  const SPADES	 = 0;
  const HEARTS	 = 1;
  const DIAMONDS = 2;
  const CLUBS	 = 3;
}

enum Suit
{
    case SPADES;
    case HEARTS;
    case DIAMONDS;
    case CLUBS;
}

assert(_isConsistent);

function binarySearch(array $a, $x)
{
    $imin = 0;
    $imax = count($a) - 1;
    while ($imin <= $imax) {
        $imid = (int)floor($imin + ($imax-$imin) / 2);
        if ($a[$imid] === $x) {
            return $imid;
        }
        if ($a[$imid] < $x) {
            $imin = $imid + 1;
        } else {
            $imax = $imid - 1;
        }
    }
    return -1;
}

$start = hrtime(true);
foo();
$end = hrtime(true);
$t = $end - $start;
echo $t;

<?php
function foo() {
    return ['string', FALSE];
}

list($string, $boolean) = foo();

function foo(): void
{
    include 'foobody.txt';
}

if ($c1) {
  f1();
} else if ($c2) {
  f2();
} else if ($c3) {
  f3();
}

$start = microtime(TRUE);
f();
$end = microtime(TRUE);
echo $end - $start, PHP_EOL;

$ok = stripos($word, $s) === false;

$items = [$a, $b, $c];

$list_position = array_search($x, $items);
$specific_item = $items[$position];
unset($specific_item);

$newItems = array_diff($items, [$x]);

$b = preg_match('/\D/', $s) !== 1;

$f = tmpfile();

function createTempDir(): ?string
{
    $path = rtrim(sys_get_temp_dir(), DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . mt_rand() . microtime(true);
    if (mkdir($path)) {
        return $path;
    }
    return null;
}

unset($m[k]);

# beginner style
foreach( $items1 as $item ) print "$item\n";
foreach( $items2 as $item ) print "$item\n";

# five times faster
print implode("\n", $items1)."\n".implode("\n", $items2)."\n" ;

$s = dechex($x);

# php 5.3+
print array_reduce( array_map( null, $items1, $items2 ), function($c,$d){return $c.($c?"\n":'').implode("\n", $d); }, "")."\n" ;

#php 5.6+
print implode("\n", array_merge( ...array_map( null, $items1, $items2 )))."\n";

$b = file_exists($fp);

$f = floatval($s);

$t = preg_replace('/[^[:ascii:]]/', '', $s);

$p = rtrim($p, '/');

$s = (string) $c;

$t = $s . $i;

unlink($filepath);

$s = sprintf('%03d', $i);

const PLANET = 'Earth';

define('PLANET', 'Earth');

$y = array_intersect_key($x, array_flip(array_rand($x, $k)));

<?php

if (PHP_INT_SIZE === 4)
    f32();
else if (PHP_INT_SIZE === 8)
    f64();

array_map(function($v) use ($_c) {
    return $v*$c;
}, $_elements);

foreach(array_chunk($list, 2) as $x) {
    echo $x[0], ' ', $x[1], PHP_EOL;
}

$x = end($items);

$x = $items[array_key_last($items)];

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

$t = strpos($s, $p) === 0 ? substr($s, strlen($p)) : $s;

preg_replace("/{$w}$/u", '', $s);

$n = mb_strlen($s, 'UTF-8');

$n = count($mymap);

$s[]=$x;

$m[$k] = $v;

echo number_format(1000);

$ch = curl_init(); 
curl_setopt($ch, CURLOPT_URL, $u); 
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); 
curl_setopt($ch, CURLOPT_POST, 1);
$output = curl_exec($ch); 
curl_close($ch);

$a = array_map('hexdec', str_split($s, 2));

class Point
{
	public $x;
	public $y;

	public function __construct(float x, float y)
	{
		$this->x = x;
		$this->y = y;
	}
}

class Rectangle
{
	private $point1;
	private $point2;

	public function __construct(Point $point1, Point $point2)
	{
		$this->point1 = $point1;
		$this->point2 = $point2;
	}

	public function getCenter(): Point
	{
		return new Point(
			($this->point1->x + $this->point2->x) / 2,
			($this->point1->y + $this->point2->y) / 2
		);
	}
}

$x = scandir($d);

<?php $s='<?php $s=%c%s%c;printf($s,39,$s,39);';printf($s,39,$s,39);

<?php

$url = 'http://localhost/tester/log.php';
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_PUT, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$fields = array("id" => 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($fields));
$response = curl_exec($ch);

echo $response;

$t = date('Y-m-d',strtotime('+1 day'));

$d = new DateTime('tomorrow');
$t = $d->format('Y-m-d');

sleep(30);
f(42);

exit(0);

$y = array_map('T', array_filter($x, 'P'));

if (count(array_filter($a, function($v) { return $v > $x; })))
  f();

// or with intermediate steps
$tmp = array_filter(
  $a,
  function ($v) { return $v > $x; }
)
if (count($tmp))
  f();

// or with array reduce instead
if (
  array_reduce($a, 
    function($old, $item) { return $old or ($item > $x); }
  )
)
  f();

// Array reduce takes the old result $old, and 
// applies $item (from $a) to the old result 
// iteratively. We use the 'or' boolean operator
// to implement an 'any' operation.

$lines = file($path);
if ($lines === false)
  die("Can't open file $path");

exit($x);

$h = hypot($x, $y)

// before PHP 4.1
$h = sqrt($x*$x + $y*$y);

$foo = getenv("FOO") ?: "none";

switch ($str) {
  case "foo":
    foo();
    break;
  case "bar":
    bar();
    break;
  case "baz":
    baz();
    break;
  case "barfl":
    barfl();
    break;
}

$b = is_dir($path);

$c = array_intersect($a, $b)

$t = preg_replace('/\s+/', ' ', $s);

$t = $s;
do $t = str_replace('  ', ' ', $t, $count); while($count);

function search(array $haystack, string $needle, callable $doSuccess, callable $doFail)
{
    foreach ($haystack as $item) {
        if ($item === $needle) {
            $doSuccess();
            return;
        }
    }
    $doFail();
}

$items = ["foo", "bar", "baz", "qux"];
search(
    $items,
    "baz",
    static function () {
        echo "found it";
    },
    static function () {
        echo "not found";
    }
);

array_unshift($items, $x);

function f(?int $x = null) {
    echo $x ? 'Present' . $x : 'Not present';
}

array_pop($items);

print_r($a)

$c = count(array_unique($items));

$i = bindec($s);

$x = condition() ? "a" : "b";

echo $x;

$values = range(0, 5);
$valuesReversed = array_reverse($values);
foreach($valuesReversed as $value)
{
    printf("%s\n", $value);
}

$x = $d->format('H:i:s');

$s = str_repeat($v, $n);
echo $s;

<?php
    for ($n=1; $n<=100; $n++) {
        $out="";
        if ($n%3==0) {
            $out=$out."Fizz";
        }
        if ($n%5==0) {
            $out=$out."Buzz";
        }
        if ($out=="") {
            $out=$out.strval($n);
        }
        echo ($out."\n");
    }
?>

$iterator = new FilesystemIterator($p, FilesystemIterator::SKIP_DOTS);
$b = (iterator_count($iterator) === 0);

$n = strlen($s);

$s = $a.$b;

$s = "Our sun has {$x} planets";

$x = random_int(0, 17)