自调/回调函数与对象的创建、枚举、检测

//TODO 自调函数- 所谓自调函数就是在定义函数后自行调用

// TODO （）第一对括号放置匿名函数，（）第二对括号“立即调用”

方法一

方法二

方法三

方法四

匿名函数在调用括号外面

匿名函数在调用括号里面，两个括号分别传入参数

匿名函数括号前面加一个“+”

匿名函数括号前面加一个“！”

(function () {
console.log("javascript!")
})();

(function (name) {
console.log("hello" + name + "!")
}("javascript"));

+(function () {
console.log("javascript!")
})();

!(function () {
console.log("javascript!")
})();

//TODO 回调函数 – 当一个函数作为参数传递给另一个函数时，作为参数的函数被称之为回调函数。

举例：

function add(a,b) {
return a() + b();
}
var one = function () {
return 1;
};
var two = function () {
return 2;
};
console.log(add(one,two)); // TODO 3

// TODO one(),two()两个函数作为参数传给函数add，并被add执行,one()和two（）函数就叫做回调函数。

console.log(add(function (){return 1},function (){return 2})); //TODO 3

//TODO 可以直接用匿名函数来替代one（）和two（）两个函数，以作为目标函数的参数。

优点：

它可以在不做命名的情况下传递函数（这意味着可以节省全局变量）。
可以将一个函数调用操作委托给另一个函数（这意味着可以节省一些代码编写工作）。
回调函数也有助于提升性能。

// TODO javascript 不存在重载

function add( a , b ) {
return a + b;
}
function add( a , b , c) {
return a + b + c;
}
console.log(add(1,2)); // TODO 因函数名重名，第一个add函数的被覆盖，参数c为undefined - 1 + 2 + NaN = NaN
console.log(add(1,2,3)); //TODO  6

// TODO arguments对象模拟函数的重载效果

function add1() {
if (arguments.length == 2){
return arguments[0] + arguments[1];
}else if (arguments.length ==3 ){
return arguments[0] + arguments[1] + arguments[2];
}
}
console.log(add1(1,2)); // 3
console.log(add1(1,2,3)); // 6

对象分类：

内置/原生对象：

JavaScript 语言预定义的对象，由 JavaScript 解释器/引擎提供具体实现

宿主对象：

JavaScript 运行环境提供的对象。一般是由浏览器厂商提供实现，主要分为 BOM 和 DOM。

自定义对象：

由开发人员自主创建的对象

1.对象初始化器方式（通过字面值创建对象）

2.构造函数（Object）方式

3.利用Object.create()方法创建对象

4.通过构建函数方式创建对象（自定义）

var obj1 = {
//TODO 定义对象的属性
name : 'zhangwuji',
age : 18 ,
//TODO 当属性名比较长时，用引号引起来
'content-type': 'text/javascript',
//TODO 定义对象的方法
sayMe : function () {
console.log('this is zhangwuji')
}
};

var obj2 = new Object();
//TODO 定义对象的属性
obj2.name = 'zhouzhiruo';
obj2.age = '18';
//TODO 定义对象的方法
obj2.sayShe = function () {
console.log('this is zhouzhiruo');
};

var obj3 = Object.create(null);//TODO 通过传入一个null参数，创建一个原型为null的空对象
//TODO 定义对象的属性
obj3.name = 'xiaoyuer';
obj3.age = '18';
//TODO 定义对象的方法
obj3.sayHe = function () {
console.log('this is xiaoyuer');
};

/TODO  * 定义属性：this.属性名 = 值
//TODO  * 定义方法：this.方法名 = function（）{}
function Hero(){
this.name = 'zhangwuji';
this.sayMe = function(){
console.log('this is zhangwuji');
}
}
//TODO 通过构建函数方式创建对象
var hero = new Hero();
console.log(hero);

调用对象的属性和方法：

方法一

方法二 - 通用方式

//TODO 调用对象的属性
console.log(obj1.name);
console.log(obj1.age);
//TODO 调用对象的方法
obj1.sayMe();

console.log(obj1['name']);
console.log(obj1['age']);
console.log(obj1['content-type']);
obj1['sayMe']();

* TODO 定义函数的方式
* TODO      * 1.函数声明方式
* TODO          function 函数名（形参）{
* TODO                函数体
* TODO                返回值
* TODO         }
* TODO      * 2.字面量方式
* TODO          var 函数名 = function（形参）{
* TODO                函数体
* TODO                返回值
* TODO         }
* TODO      * 3.构造函数
* TODO          var 函数名 = new Function（形参，函数体）；
* TODO      结论：javascript中所有的函数都是一个Function对象

console.log(obj1.who); //TODO 访问一个不存在的属性，输出undefined
obj1.sayHe(); //TODO 访问一个不存在的方法，报错 obj1.sayHe is not a function

用delete关键字删除对象的属性或方法：

delete hero.age;

console. log(hero.age);//undefined

delete hero.sayMe;//删除方法不用加括号

hero.sayMe();//TypeError: hero.sayMe is not a function

遍历（枚举）对象

//TODO 遍历对象中的属性和方法
var hero = {
name : '小鱼儿',
age : 20 ,
job : '掌门',
sayWho : function () {
console.log('this is 小鱼儿');
}
};

1.for...in

2.Object.keys(object)

3.Object.getOwnPropertyNames(object)

for (var propertyName in hero){
if(hero[propertyName] instanceof Function){
//TODO 表示是对象的方法
hero[propertyName]()
}else {
//TODO 表示对象的属性
console.log(hero[propertyName]);
}
}

var result = Object.keys(hero);
console.log(result);
for (var i = 0 ; i < result.length ; i++){
console.log(result[i]);
if (hero[result[i]] instanceof Function){
hero[result[i]]()
}else {
console.log(hero[result[i]]);
}
}

var result = Object.getOwnPropertyNames(hero);
console.log(result);

检测对象的属性是否存在

1.用undefined检查

2.用in 关键字

3.用Object的hasOwnProperty（）方法

4.条件运算符

if (hero.job !== undefined){
console.log('存在');
}
console.log(hero.job);

if ('job' in hero){
console.log('存在');
}

if(hero.hasOwnProperty('job')){
console.log('存在');
}
console.log(hero.hasOwnProperty('job')); //true

hero.job !== undefined ? '存在' : '不存在';

//TODO 测试题
console.log(Object instanceof Object);// true
console.log(Object instanceof Function);// true
console.log(Function instanceof Function);// true
console.log(Function instanceof Object);// true

获取动态时间

function JSClock() {
var time = new Date();
var hour = time.getHours();
var minute = time.getMinutes();
var second = time.getSeconds();
var temp = "" + ((hour > 12) ? hour - 12 : hour);
if (hour == 0)
temp = "12";
temp += ((minute < 10) ? ":0" : ":") + minute;
temp += ((second < 10) ? ":0" : ":") + second;
temp += (hour >= 12) ? " P.M." : " A.M.";
return temp;
}
JSClock();
console.log(JSClock());

实践出真知~