$a or $b --- TRUE if either $a or $b is TRUE.
$a || $b --- TRUE if either $a or $b is TRUE.

// У "||" приоритет выше, чем у "or"
$e = false || true; // $e будет присвоено значение (false || true), которое равно true
$f = false or true; // $f будет присвоено значение false

F>Давайте сравним, например, с Python-ом, который хвалят почем зря..

F>последнее время складывается ощущение, что у php просто плохая репутация и все его боятся

switch ("a") {
case 0:
    echo "0";
    break;
case "a": // никогда сюда не дойдет, потому что "a" уже заматчилось с 0
    echo "a";
    break;
}

привычное "сказуемое(подлежащее, [дополнения])" нарушено как минимум в explode, где СНАЧАЛА надо передать разделитель, а потом уж — "что делить"

                      ^ (строгая тип.)
                      |
      Erlang          |    
                      |  
                      |    Java, C#, Haskell
                      |
                      |
----------------------------------------------------->
(динам. тип.)         |               (статич. тип.)
                      |
                      |     
    Javascript        |
                      |         C/C++
    PHP               |
                      |
                      | (слабая тип.)

// php 5.2.6

$test = 3;
$TEST = 5;

var_dump( $test ); // 3
VAR_DUMP( $TEST ); // 5
VAR_dump( $Test ); // NULL

ExIt;

function hello()
{
    print 'hello';
}

function Hello()
{
    print 'hello';
}
// PHP Fatal error:  Cannot redeclare hello()

Let's get rid of unbound methods. When class C defines a method f, C.f
should just return the function object, not an unbound method that
behaves almost, but not quite, the same as that function object. The
extra type checking on the first argument that unbound methods are
supposed to provide is not useful in practice (I can't remember that
it ever caught a bug in my code) and sometimes you have to work around
it; it complicates function attribute access; and the overloading of
unbound and bound methods on the same object type is confusing. Also,
the type checking offered is wrong, because it checks for subclassing
rather than for duck typing.

Variables in PHP are represented by a dollar sign followed by the name of the variable. The variable name is case-sensitive.

$a = ${$b};

остутствие "проверки во время компиляции"

class A
{
    function hello()
    {
        print 'Hello I\'m A.';
    }
    
    function Foo()
    {
        $this->hello();
    }
}

class B
{
    function hello()
    {
        print 'Hello I\'m B.';
    }
    
    function Foo()
    {
        return A::Foo();
    }
}

$b = new B();
$b->Foo(); // печатает Hello I'm B :)

std::string s,d;
d="%опа";
s=d+"есть";

std::string s;
s="%опа"+"есть"+"а"+"слова"+"нет";

M>switch ("a") {
M>case 0:
M>    echo "0";
M>    break;
M>case "a": // никогда сюда не дойдет, потому что "a" уже заматчилось с 0
M>    echo "a";
M>    break;
M>}
M>

$ cat test.php
<?php
print 012389 . "\n";
?>
$ php test.php
83

$var = "Hello, $username! Today is $date";

А>std::string s;
А>s="%опа"+"есть"+"а"+"слова"+"нет";
А>

std::string s;
s="%опа" " есть" " а" " слова" " нет";

#присвоить x значение 22
set x 22
#присвоить y значение, содержащееся в x
set y $x

Г>>нарушено как минимум в explode, где СНАЧАЛА надо передать разделитель, а потом уж — "что делить").
DOO>Это взято из перла. И в перле на то были веские причины.

$has_father = ($dog['father'] != 0) or ($dog['father_name'] != '');
$b1 = ($dog['father'] != 0);
$b2 = ($dog['father_name'] != '');
$has_father = $b1 or $b2;
var_dump($b1);
var_dump($b2);
var_dump($has_father);

фазер равен нулю, а имя его непустое

выдаёт:

boolean false

boolean true

boolean false

ну чо за пипец, а?

DOO>>>Вообще-то это заимствовано из перла

F>и какие же?.

if(cond1 || cond2 && cond3 && !cond4) #первый вариант

if(x = test1() and y = test2()) #второй вариант

1.
function multiply($x) 
{
     $result = $x * $y;
     // Здесь программист забыл вернуть результат из функции!
     // Главное, что никаких warning'ов, а там и до пятницы недалеко.    
}

2.
class MyClass
{
    var $x;
    public function myMethod($a) {
            
        $x = $a; // Упс, здесь надо было написать $this->x = $a, но мы забыли про $this - ерунда  
                 // транслятор молчит значит усё в порядке!                
    }
}

3.
function sum($integer1, $integer2) 
{    
     return (int)$integer + (int)$integer2;
}

$sum =  sum(1, array(1, 2, 3)); // Cколько будет целое плюс массив? Транслятору пофиг. 
                                // Примечание: приводим тип потому что не доверяем входным данным от пользователя.

4.
function doSomething($x, $y, $z) // Какого типа $x, $y, $z? Угадай сам! 
{
     
}

5.
function makeMeHapy() // Эта функция должна была называться makeMeHappy. Ошибка обнаружится в багрепорте на следующее утро.
{
     
}

6.
function putToDatabase($integer) 
{
     //Для того чтобы избежать sql-injection это  надо постоянно кастить к ожидаемому типу
     //Где же пресловутая краткость динамических языков?
     return mysql_query("SELECT * FROM MyTable WHERE Id = " . (int)$integer);
}

function multiply($x) 
{
     $result = $x * $y;
     // Здесь программист забыл вернуть результат из функции!
     // Главное, что никаких warning'ов, а там и до пятницы недалеко.    
}

class MyClass
{
    var $x;
    public function myMethod($a) {
            
        $x = $a; // Упс, здесь надо было написать $this->x = $a, но мы забыли про $this - ерунда  
                 // транслятор молчит значит усё в порядке!                
    }
}

function sum($integer1, $integer2) 
{    
     return (int)$integer + (int)$integer2;
}

$sum =  sum(1, array(1, 2, 3)); // Cколько будет целое плюс массив? Транслятору пофиг. 
                                // Примечание: приводим тип потому что не доверяем входным данным от пользователя.

function doSomething($x, $y, $z) // Какого типа $x, $y, $z? Угадай сам! 
{
     
}

function makeMeHapy() // Эта функция должна была называться makeMeHappy. Ошибка обнаружится в багрепорте на следующее утро.
{
     
}

function myFunc(int x, MyClass y, dynamic z)
{
}

.>А так писать нельзя. Нужно писать: query("SELECT * FROM MyTable WHERE Id = ?").bind($integer).execute();
И как мне это поможет? Инъекции не будет? Ну да, но это никак не запретит мне передать неверный тип данных в метод bind и никто ничего не заметит.

Кто ни разу не нажигался на "if(x=1)" — поднимите руку

class A:
    def hello(self):
        print 'Hello I\'m A.'
        
    def Foo(self):
        self.hello()
        
        
class B:
    def hello(self):
        print 'Hello I\'m B.'
        
    def Foo(self):
        A.Foo(self)

b = B()
b.Foo()

Traceback (most recent call last):
  File "hghghg.py", line 49, in <module>
    b.Foo()
  File "hghghg.py", line 46, in Foo
    A.Foo(self)
TypeError: unbound method Foo() must be called with A instance as first argument (got B instance instead)

FR>Traceback (most recent call last):
FR>  File "hghghg.py", line 49, in <module>
FR>    b.Foo()
FR>  File "hghghg.py", line 46, in Foo
FR>    A.Foo(self)
FR>TypeError: unbound method Foo() must be called with A instance as first argument (got B instance instead)
FR>

>>> class A:
        def foo(self):
            print("A")
        def call_foo(self):
            self.foo()
        
>>> class B:
        def foo(self):
            print("B")        
        
>>> A.call_foo(B())
B

ВВ>$var = "Hello, $username! Today is $date";
ВВ>

greeting = "Привет, #{username}"

ВВ>$var = "Hello, $username! Today is $date";
ВВ>

for i in `ls`;
do
  mv $i ${i%.*}.newext;
done

std::string s,d;
d="%опа";
s=d+"есть";

работает, а

std::string s;
s="%опа"+"есть"+"а"+"слова"+"нет";

не работает

std::string s;
s="%опа" " есть" " а" " слова" " нет";

работает

printf(
  "A very suitable\n"
  "formatting!\n"
  "Isn't it?"
);