数据类型

六种

• 数值（number）
• 字符串（string）
• 布尔值（boolean）
• undefined
• null
• 对象（object）

//typeof返回一个值的数据类型
typeof 123 //"number"
typeof '123' // "string"
typeof false // "boolean"
function f() {}
typeof f
// "function"
typeof window // "object"
typeof {} // "object"
typeof [] // "object"

---

Number(null)	//0
Number(undefined)	//NaN

布尔值为false的几种值

• undefined
• null
• false
• 0
• NaN
• “”或’’(空字符串)

//Infinity 无穷
-1/-0 //Infinity
1/-0 //-Infinity
//数值正向溢出（overflow）、负向溢出（underflow）和被0除，JavaScript 都不报错
//Infinity与NaN比较，总是返回false。

parseInt('1000') // 1000
parseInt('1000', 10) // 1000
parseInt('1000', 2) // 8 二进制
parseInt('1000', 8) // 512 八进制
//字符串以0x或0X开头，parseInt会将其按照十六进制数解析。
parseInt('0x10') // 16

parseFloat	//浮点数
isNaN(123) //false 判断是否是NaN
isFinite(undefined) //true 判断是否是正常数值

//对象 

var obj = {
    //键值对：key：value
  	foo: 'Hello',
 	bar: 'World'
}
// 或
var obj = {
  'foo': 'Hello',
  'bar': 'World'
};
//键名为数值会自动转换为字符串

//键名又称为属性（property）
//属性的值为函数
var obj = {
  p: function (x) {
    return 2 * x;
  }
};
obj.p(1) // 2

// 链式引用，属性的值是对象
var o1 = {};
var o2 = { bar: 'hello' };
o1.foo = o2;
o1.foo.bar // "hello"


var obj = {
  p: 'Hello World'
};
//两种读取方法
obj.p // "Hello World"
obj['p'] // "Hello World"

var obj = {
  key1: 1,
  key2: 2
};
// 属性查看
Object.keys(obj);// ['key1', 'key2']
// 属性删除
var obj = { p: 1 };
Object.keys(obj) // ["p"]
delete obj.p // true
obj.p // undefined
Object.keys(obj) // []

var obj = { p: 1 };
'p' in obj // true
'toString' in obj // true，继承属性
var obj = {};
if ('toString' in obj) {
  console.log(obj.hasOwnProperty('toString')) // false
}


//for...in循环遍历对象的属性
//遍历所有可遍历的属性，包括继承的属性
var obj = {a: 1, b: 2, c: 3};

for (var i in obj) {
  console.log('键名：', i);
  console.log('键值：', obj[i]);
}
// 键名： a
// 键值： 1
// 键名： b
// 键值： 2
// 键名： c
// 键值： 3

// with语句
// 例一
var obj = {
  p1: 1,
  p2: 2,
};
with (obj) {
  p1 = 4;
  p2 = 5;
}
// 等同于
obj.p1 = 4;
obj.p2 = 5;
// 例二
with (document.links[0]){
  console.log(href);
  console.log(title);
  console.log(style);
}
// 等同于
console.log(document.links[0].href);
console.log(document.links[0].title);
console.log(document.links[0].style);

函数

// 函数声明，3种
function print(s) {
  console.log(s);
}

var print = function(s) {
  console.log(s);
};
var print = function x(){
  //函数名x只在函数体内部有效
  console.log(typeof x);
};

var add = new Function(
  'x',
  'y',
  'return x + y'
);
// 等同于
function add(x, y) {
  return x + y;
}
//函数多次声明会被覆盖

//name属性返回函数名
var myFunc = function () {};
function test(f) {
  console.log(f.name);
}
test(myFunc) // myFunc
//length 返回函数预期传入的参数个数
//JavaScript 允许省略参数。
//arguments对象包含了函数运行时的所有参数
//arguments对象带有一个callee属性，返回它所对应的原函数。
//toString方法返回一个字符串，内容是函数的源码。

//闭包（closure）
//定义在一个函数内部的函数
//作用：一个是可以读取函数内部的变量，另一个就是让这些变量始终保持在内存中，即闭包可以使得它诞生环境一直存在;封装对象的私有属性和私有方法
function createIncrementor(start) {
  return function () {
    return start++;
  };
}
var inc = createIncrementor(5);
inc() // 5
inc() // 6
inc() // 7

//eval命令接受一个字符串作为参数，并将这个字符串当作语句执行
eval('var a = 1;');
a // 1

数组

数组是一种特殊的对象

//length
//in 键名是否存在
var arr = [ 'a', 'b', 'c' ];
2 in arr  // true
'2' in arr // true
4 in arr // false

// for in
var a = [1, 2, 3];
for (var i in a) {
  console.log(a[i]);
}
// 1
// 2
// 3
var a = [1, 2, 3];

// for循环
for(var i = 0; i < a.length; i++) {
  console.log(a[i]);
}

// while循环
var i = 0;
while (i < a.length) {
  console.log(a[i]);
  i++;
}

var l = a.length;
while (l--) {
  console.log(a[l]);
}

//forEach
var colors = ['red', 'green', 'blue'];
colors.forEach(function (color) {
  console.log(color);
});
// red
// green
// blue