Ден: 13.10.2018

Static constructors

В PHP конструкторите и деструкторите не могат да са статични.

Гърми с Fatal: Constructors cannot be static…

Closure vs. Callable as input parameter type

Ако подаваш стринг като входен параметър на метод/функция, който стринг е име на callback функция, може да го дефинираш като тип callable

function patapan(callable $func_name) { }

И в двата случая може да подаваш като стринг името на функцията, но „The difference is, that a Closure must be an anonymous function, where callable also can be a normal function“.

Друга важна разлика е, че Closure е predefined class , a callable е тип.

The difference is, that a Closure must be an anonymous function, where callable also can be a normal function.

You can see/test this with the example below and you will see that you will get an error for the first one:

function callFunc1(Closure $closure) {
    $closure();
}

function callFunc2(Callable $callback) {
    $callback();
}

function xy() {
    echo 'Hello, World!';
}

callFunc1("xy"); // Catchable fatal error: Argument 1 passed to callFunc1() must be an instance of Closure, string given

callFunc2("xy"); // Hello, World!

Литература:

https://stackoverflow.com/questions/29730720/php-type-hinting-difference-between-closure-and-callable

Остатък от целочислено делене (%)

Раздели 5 кокала на 3 кучета по равно, без да режеш кокалите и трябва и да са по равно за всяко куче.

Единственото възможно е на всяко куче по един кокал и остават 2 кокала неподелени.

Тези 2 кокала са въпросният остатък от целочислено делене.

Decimal vs. Float

Най-просто – float закръгля, защото няма зададена прецизност, както decimal и обикновено съдържа безкрайни дроби.

При decimal се знае, че 0.333 е точно 0.333, a не 0.33333333333…∞ закръглено до 0.333333334, или отрязано до някъде.

Затова decimal е най-пододящ например за съхраняване на парични суми.

Float is Approximate-number data type, which means that not all values in the data type range can be represented exactly , it round up the values.

Where as Decimal is Fixed-Precision data type, which means that all the values in the data type range can be represented exactly with precision and scale, it doesn’t round up the values.

Use decimal for counted values
Use float/double for measured values

Some examples:

  • money (do we count money or measure money?)
  • distance (do we count distance or measure distance?)
  • scores (do we count scores or measure scores?)

We always count money and should never measure it. We usually measure distance. We often count scores.

Float се използва за сухраняване на стойности, които могат да бъдат закръглени поради това, че точната им стойност може и да не е ясна.

Decimal – обратното, трябва да знаем точно стойността, без закръгляне, без „отрязване“. С конкретна точност.

JS overriding

В JS явно няма overriding, защото ако предифинираш (оверрайднеш) функция, както по-долу, JS ще хойстне втората над първата.

function bar(){
    return 111;
}

function bar(a){
    return a;
}

alert(bar());
alert(bar(999));

Ще алертне първо undefined после 999 , защото ще използва втората функция.

JavaScript evaluates expressions from left to right

JavaScript evaluates expressions from left to right. Different sequences of one and the same operands can produce different results:
var x = 16 + 4 + „Volvo“;   // x becomes „20Volvo“
and
var x = „Volvo“ + 16 + 4;    // x becomes „Volvo164“

In JavaScript, a variable without a value, has the value undefined. Its type /typeof()/ is also undefined.
var car; // Value is undefined, type is undefined

Any variable can be emptied, by setting the value to undefined. The type will also be undefined.
car = undefined; // Value is undefined, type is undefined

length след изтриване на елемент

В JS като изтриеш елемент на масив, мястото му остава празно, а length не му се променя

var ccc = [111, 222, 333, 444];

console.log(ccc);
(4) [111, 222, 333, 444]
length:4

delete ccc[2];

console.log(ccc);
(4) [111, 222, empty × 1, 444]
length:4

Защо typeof null дава ‘object’?

До колкото разбрах, причините са исторически – още от първите версии на JS, променливите имали тип и стойност. Типът бил някакъв системен код, който код, специално за типа „обект“ бил 0.

Обаче и самата стойност NULL в JS се представяла като 0.
И така се получило нещо като съвпадение.

this… that…

(function(w){
    w.propEdno = 100;
    w.metoEdno = function(){
        alert(w.propEdno * 100);

        metoDve();

        this.metoTri();
    };

    var propDve = 200;
    var metoDve = function(){
        alert(propDve * 200);
    };

    this.propTri = 300;
    this.metoTri = function(){
        alert(propDve * this.propTri * 300);
    };
})(window);

// Ще алертне 10000, после 40000, после 18000000
window.metoEdno();

// Ще алертне 18000000
window.metoTri();

// Ще алертне 300
alert(window.propTri);

Демек, тези които са this.* са пъблик.

Self invoking functions

()();


(function(){})();


(function(w){
    w.propEdno = 100;
    w.metoEdno = function(){
        alert(w.propEdno * 100);
    };

    var propDve = 200;
    var metoDve = function(){
        alert(this.propDve * 100);
    };

    this.propTri = 300;
    this.metoTri = function(){
        alert(this.propTri * 100);
    };
})(window);

window.metoEdno();
window.metoDve();
window.metoTri(); metoTri(); this.metoTri();

window.metoEdno(); ще алертне 10,000, защото така metoEdno() и propEdno стават метод и пропърти на window обекта.

propDve и window.metoDve(); са private и ще дадат грешка от рода на Uncaught TypeError: window.metoDve is not a function… Те не могат да се викат отвън.

window.metoTri(); metoTri(); this.metoTri(); ще алертне 30,000 три пъти, защото:
1. първият път metoTri() и propTri стават public част от window обектът;
2. вторият път и двете стават public – от глобалният скоуп;
3. третия път this прави metoTri() и propTri също public.