05 scope

05.md

@@ -1,6 +1,5 @@
 # Функции, области видимости
 
-
 ## Trivia
 ### Повторяющиеся действия.
 
@@ -286,6 +285,135 @@ var num = prompt("Введите число");
 var b;
     b = console.log(a); //неработает, метод log объекта console возвращает undefined, т. е. ничего
     b = a; //работает
+
+function myLowerCase(str)
+{
+    console.log(str.toLowerCase()); //это просто пишет текст в консоли.
+}
+
+function rightUpperCase(str)
+{
+    return str.toUpperCase(); //это работает правильно
+}
+
+var lowerCase = myLowerCase("AbCdEf") //не работает.
+var upperCase = rightUpperCase("AbCdEf") //работает
 ```
 
 Что бы отличить результат выражения от вывода console.log, отметьте что возле значения выражения есть знак <.
+
+## Область видимости
+
+Как было указано выше, переменные, объявленные с `var` внутри функции, являются незаметными для окружающего кода и перекрывают совпадающие переменные
+внутри функции, оставляя невредимыми внешние переменные:
+
+```javascript
+var a = 5;
+
+alert("global a: " + a);
+function someFunctionWithA(){
+    var a = "string";
+    alert("function scope a: " + a);
+}
+
+alert("global a after function declaration" + a);
+someFunctionWithA()
+alert("global a after function execution" + a);
+```
+
+Область видимости создается **каждый раз** при **вызове** функции:
+
+```javascript
+
+debugger;
+function add(a,b)
+{
+    var result = a + b;
+    return result;
+}
+
+add(1,2)
+add(5,6)
+```
+
+Как видите, переменные `a`,`b` и `result` каждый раз имеют разные значения. При вызове область видимости создается, по выходу из функции - удаляется
+(*не всегда*).
+
+### Глобальная область видимости
+
+Если переменная создается **без** `var` в *любом* месте кода, в том числе в функции, она является глобальной, т. е. видимой везде. 
+
+```javascript
+debugger;
+function add(a,b)
+{
+    result = a + b;
+    return result;
+}
+
+result = add(1,2)
+alert(result);
+add(5,6)
+alert(result);
+```
+
+Как видно в примере выше, мы не можем расчитывать на целостность переменной `result`, пользуясь функцией `add`. Использование глобальных переменных
+в большинстве случаев неоправдано; они нужны в-основном только для каких-то общих данных для чтения. Например `Math.PI` является глобальной переменной,
+доступной только на чтение; то есть *константой*. Ваши же переменные будут доступны и на запись, будьте аккуратны используя их.
+
+**Общее правило для новичка**: всегда ставьте `var`.
+
+
+### Вложенные функции и их области видимости
+
+```javascript 
+var a = "0";
+var b = "0";
+var c = "0";
+
+function level1(){
+    var b = "1";
+    var c = "1";
+
+    function level2(){
+        var c = "2";
+        console.log("Level 2 scope: a: " + a + " b: " + b + " c: " + c);
+    }
+    level2();
+    console.log("Level 1 scope: a: " + a + " b: " + b + " c: " + c);
+}
+
+level1();
+console.log("Level 0 scope: a: " + a + " b: " + b + " c: " + c);
+```
+Проанализируйте вывод кода выше. Самая вложенная функция `level2` видит переменные своей области видимости (c), потом ищет значение на уровень
+выше (для переменной `b`), и на уровень еще выше (для `a`). Промежуточная функция `level1` *ничего* не знает о переменных в `level2`, но видит свою
+область видимости и глобальную. Глобальная же имеет свои переменные `a`, `b`, `c` в первозданном виде.
+
+```javascript 
+var a = "0";
+var b = "0";
+var c = "0";
+
+function level1(){
+    var b = "1";
+    var c = "1";
+    var d = "1";
+
+    function level2(){
+        var c = "2";
+        var e = "2";
+        console.log("Level 2 scope: a: " + a + " b: " + b + " c: " + c + " d: " + d + " e: " + e); 
+    }
+    level2();
+    console.log("Level 1 scope: a: " + a + " b: " + b + " c: " + c + " d: " + d + " e: " + e);
+}
+
+level1();
+console.log("Level 0 scope: a: " + a + " b: " + b + " c: " + c + " d: " + d + " e: " + e);
+```
+
+Данный пример иллюстрирует отсутствие переменных `e` в глобальной области видимости и `level1`, переменной `d` - в глобальной области видимости. Переменная
+`d` попадает из `level1` в `level2`.
+
+##