第2章 JavaScript数据类型--2（复杂数据类型，即对象、函数、数组；typeof和思维导图）读书笔记

"use strict";
var obj = {
    "var": "hello", 
    1e2: "23",
    3.2: "23",
    0X78: 34,
    1: "abu",   //如果键名是数值，会被自动转为字符串。
    //1p: "hello",  //报错。
    "1p":"hello",   //不报错
    p: function (x) {   //如果对象的属性是函数，通常称p为对象的方法
        return x;
    }
};

var obj2 = {
    bar: "wo"
};
obj.foo = obj2;
console.log(obj.foo.bar);  //wo。如果属性的值还是一个对象，就形成了链式引用。
obj.my = 123;   //属性可以动态创建，不必在对象声明时就指定。
console.log(obj.my);   //123

"use strict";
{foo: 123};//第一种可能是，这是一个表达式，表示一个包含foo属性的对象；第二种可能是，这是一个语句，表示一个代码区块，里面有一个标签foo，指向表达式123。
console.log({foo: 123});  //{ foo: 123 }   这里不是行首
({foo: 1235});//如果要解释为对象，最好在大括号前加上圆括号。因为圆括号的里面，只能是表达式，所以确保大括号只能解释为对象。
//({console.log(123)});  //报错

//差异在eval语句（作用是对字符串求值）中反映得最明显。
console.log(eval('{foo: 123}'));// 123
console.log(eval('({foo: 123})')) ;// {foo: 123}

"use strict";
var a = "bar";
var b = "bin";
var obj = {
    a: 23,
    bar: 21,
    b: "nji",
    1: "ki"
};
console.log(obj.a);   //23  引用对象obj的foo属性时，如果使用点运算符，foo就是字符串；
console.log(obj[a]);   //21   如果使用方括号运算符，但是不使用引号，那么foo就是一个变量，指向字符串bar。
console.log(obj["a"]); //23
console.log(obj[b]); //undefined   b是变量，指向字符串bin，但是因为在obj对象中没有定义键名为字符串bin的属性，故而为undefined
//console.log(obj.1);   //数字键不能使用点运算符，这里报错
console.log(obj[1]);  //ki,数字键只能使用放括号运算符，加不加双引号都行
console.log(obj["1"]);  //ki

"use strict";
var obj = {
    1: 12,
    bj: "br"
};
console.log(Object.keys(obj));  //[ '1', 'bj' ]。查看一个对象本身的所有属性，可以使用Object.keys方法。

var obj = {
    1: 12,
    bj: "br"
};
console.log(Object.keys(obj));  //[ '1', 'bj' ]。查看一个对象本身的所有属性，可以使用Object.keys方法。
console.log(delete obj[1]);  //返回true。delete命令用于删除对象的属性，删除成功后返回true。
console.log(Object.keys(obj));  //[ 'bj' ]
console.log(obj[1]);  //undefined
console.log(delete obj[1]);   //返回true 。注意，删除一个不存在的属性，delete不报错，而且返回true。

//只有一种情况，delete命令会返回false，那就是该属性存在，且不得删除。
var obj = Object.defineProperty({}, 'p', {
    value: 123,
    configurable: false
});

console.log(obj.p); // 123
console.log(delete obj.p );// false。严格模式下会报错

"use strict";
var obj = {
    1: 12,
    bj: "br"
};
//in运算符用于检查对象是否包含某个属性（注意，检查的是键名，不是键值），如果包含就返回true，否则返回false。
console.log(1 in obj);  //true
console.log("toString" in obj);  //true。in运算符的一个问题是，它不能识别哪些属性是对象自身的，哪些属性是继承的。
//可以使用对象的hasOwnProperty方法判断一下，是否为对象自身的属性。
console.log(obj.hasOwnProperty("toString"));  //false

"use strict";
var obj = {
    1: 12,
    bj: "br"
};
for(var key in obj){
    if(obj.hasOwnProperty(key)){
        console.log(key,obj[key]);
    }
}
/*输出
1 12
bj br
*/

//"use strict";
var obj = {
    1: 12,
    bj: "br",
    p1: 1
};
with (obj){
    p1 = 2;
    p2 = 3;  //果with区块内部有变量的赋值操作，必须是当前对象已经存在的属性，否则会创造一个当前作用域的全局变量。
}
console.log(obj.p1);  //2
console.log(obj.p2);  //undefined
console.log(p2);  //3
//另外这是因为with区块没有改变作用域，它的内部依然是当前作用域。这造成了with语句的一个很大的弊病，就是绑定对象不明确。

function 函数名(参数) {
    //函数体
}

"use strict";
//将一个函数赋值给变量。这时，这个函数又称函数表达式（Function Expression）
var myF =function x() {  //一般情况下，函数名可以不用。如果加上函数名，该函数名只在函数体内部有效，在函数体外部无效。
    console.log(typeof x);//一般情况下，
};

"use strict";
var add = new Function(
    "x",  //
    "y",  //
    "return x+y"  //除了这个参数是函数体，其他都是add的参数
);
console.log(add(1,2));   //3

"use strict";
// 1 采用function命令声明函数时，整个函数会像变量声明一样，被提升到代码头部
fun();  //返回“函数被提升了”。
function fun() {
    console.log("函数被提升了");  //
}

//2 如果采用赋值语句定义函数，JavaScript 就会报错。
fun1();   //报错，fun1 is not a function。原因是变量fun1只是被提升，并没有被赋值
var fun1 = function () {
    console.log("我没有被提升");
};

// 3 如果同时采用function命令和赋值语句声明同一个函数，最后总是采用赋值语句的定义
function myFun() {
    console.log("我是使用Function声明");
}
var myFun = function () {
    console.log("我是函数表达式赋值给变量");
};
myFun();//我是函数表达式赋值给变量

"use strict";
//1 函数的name属性返回函数的名字。
function fun() {
    console.log("11");
}
console.log(fun.name);  //fun

//2 如果是通过变量赋值定义的匿名函数，那么name属性返回变量名。
var myFun = function(){
    //第2种情况
};
console.log(myFun.name);  //myFun

//3 如果是通过变量赋值定义的具名函数，那么name属性返回function关键字之后的函数名。
var myFun1 =function myName() {
    //函数体
};
console.log(myFun1.name);  //myName

"use strict";
//利用函数的toString（）方法能返回函数的内部注释，返回多行字符串
function myFun() {
    /*
    我是
     多行
     字符串
    */
}
function mulString(fun) {
    var arr = fun.toString().split("\n");
    return arr.slice(2, arr.length - 2).join("\n");
}
console.log(mulString(myFun));   //记住这里的myFun后面不能加括号，否则会报错
/*输出如下：
    我是
     多行
     字符串
*/

//"use strict";
var a = 2;  //全局变量
function f() {
    var a = 1;  //局部变量，在函数内部会覆盖掉全局变量a
    var b= 2;   //局部变量
    c = 3;   //严格模式下报错。非严格模式下，在函数内部不使用var声明的变量是全局变量，函数外面也能访问
    console.log(a);
}
console.log(c); //这里报错，因为在函数内部定义的全局变量，只有在调用函数一次之后，变量才会有定义
f();  //1
console.log(b);  //报错，无法调用函数内部的局部变量
console.log(c); //3

"use strict";
//1 函数执行时所在的作用域，是定义时的作用域，而不是调用时所在的作用域。
var a = 1;
var x = function () {
    console.log(a);
};
function f() {
    var a = 2;
    x();   //其作用域是全局作用域，而不是f（）函数的作用域
}
f(); // 1

//2 如果函数A调用函数B，却没考虑到函数B不会引用函数A的内部变量。
var myF = function () {
    console.log(b);
};
function myY(f) {
    var b = 2;
    f();  //
}
myY(myF); //报错：b is not defined。因为传入参数myF之后，myF函数的作用域是全局函
          //全局作用域，不会调用myY（）函数内部的变量

//3 函数内部声明的函数，作用域绑定在函数内部，即闭包

//"use strict";
function f(a, a) {
    console.log(a);
}

f(1); // undefined。调用函数f的时候，没有提供第二个参数，a的取值就变成了undefined。严格模式下报错

"use strict";
function f1() {
    var n = "JavaScript";
    function f2() {
        console.log(n);
    }
    return f2;
}

"use strict";
function createIncrementor(start) {
    return function () {
        return start++;
    };
}
var inc = createIncrementor(5);  //记住这里需要将函数的调用赋值给一个变量，如果不赋值给变量，多次调用只是简单的调用而已
//start是函数createIncrementor的内部变量。通过闭包，start的状态被保留了，每一次调用都是在上一次调用的基础上进行计算。从中可以看到，闭包inc使得函数createIncrementor的内部环境，一直存在。所以，闭包可以看作是函数内部作用域的一个接口。
console.log(inc()); // 5
console.log(inc()); // 6
console.log(inc()); // 7

"use strict";
function Person(name) {
    var _age;
    function setAge(n) {
        _age = n;
    }
    function getAge() {
        return _age;
    }
    return {
        name: name,
        getAge: getAge,
        setAge: setAge
    };
}
var p1 = Person('张三');
p1.setAge(25);
console.log(p1.getAge()); // 25
//函数Person的内部变量_age，通过闭包getAge和setAge，变成了返回对象p1的私有变量。

(function(){ /* code */ }());
// 或者
(function(){ /* code */ })();

var i = function(){ return 10; }();
true && function(){ /* code */ }();
0, function(){ /* code */ }();

!function () { /* code */ }();

// 写法一
var tmp = newData;
processData(tmp);
storeData(tmp);

// 写法二（推荐使用）
(function () {
    var tmp = newData;
    processData(tmp);
    storeData(tmp);
}());

"use strict";
//以下数组的键分别设为字符串和小数，结果都不影响length属性。
// 因为，length属性的值就是等于最大的数字键加1，而这个数组没有整数键，所以length属性保持为0。
var arr = ["JavaScript"];
console.log(arr.length);  //1
arr['p'] = 'abc';
console.log(arr.length);  //1
arr[2.1] = 'abc';
console.log(arr.length);  //1

//如果数组的键名是添加超出范围的数值，该键名会自动转为字符串。
arr[-1] = 'a';
arr[Math.pow(2, 32)] = 'b';
console.log(arr.length);  //1
console.log(arr[-1]);  //a
console.log(arr[4294967296]);  //b。取键值时，数字键名会默认转为字符串。

"use strict";
var arr = ["a", "b", "c"];
console.log(arr.length);  //3。数组的长度为3
console.log(Object.keys(arr));  //[ '0', '1', '2' ]。返回的是数组中存在的键名

console.log(2 in arr);  //true
console.log("2" in arr);  //true
console.log(9 in arr);  //false。数组中的键名没有“9”，返回false

arr[8] = "h";   //这样设置之后，数组中多了一个名为“8”的键名，长度为9
console.log(arr.length);  //9。数组的长度为9，数组的length属性为键名中最大正数加1
console.log(Object.keys(arr));  //[ '0', '1', '2', '8' ]
console.log("8" in arr);  //true
console.log(6 in arr);  //false。数组中的键名没有“6”，返回false

"use strict";
var arr = [1, 2, 3, 4];
arr.foo = "非数字键";   //数组可以动态添加属性，键名为字符串
arr["jio"] = "Java";

//使用for ...in循环，会遍历数字键和非数字键
for (key in arr){
    console.log(key, arr[key]);
}
/*
输出为：
0 1
1 2
2 3
3 4
foo 非数字键
jio Java
*/

/*
使用for或者while循环遍历数组，如果使用的是数组的length属性，则只会访问数字键。
*/
for(var i = 0; i < arr.length; i++){
    console.log(arr[i]);
}

var j = 0;
while (j < arr.length){
    console.log(arr[j]);
    j++;
}
/*
for和while循环中输出均为
1
2
3
4
*/

"use strict";
var arr = [1, , 2, 3];
delete arr[3];
console.log(arr.length);  //4。使用delete命令不会影响length属性
console.log(arr);   //[ 1, <1 empty item>, 2, <1 empty item> ]。

var arr = Array.prototype.slice.call(arrayLike);

function print(value, index) {
    console.log(index + ' : ' + value);
}

Array.prototype.forEach.call(arrayLike, print); // arrayLike类似一个数组

"use strict";  //表示严格模式
var a = undefined;
var b = true;
var c = 10;
var d = "str";
function myFunction(){
    return 1;
}
var e = null;
var g = [1, 2, 3];
console.log(typeof(a));    //undefined
console.log(typeof(b));    //boolean
console.log(typeof(c));   //number
console.log(typeof(d));    //string
console.log(typeof(myFunction));  //function
console.log(typeof(myFunction()));  //number 请注意这里，注意，为何自己思考。
console.log(typeof(e));   //  object
console.log(typeof(g));   //  object