一.JS变量

• 1.变量是程序在内存中申请的一块用来存放数据的空间

var age; 声明一个 名称为age 的变量

age = 10; // 给 age 这个变量赋值为 10

同时声明多个变量 (var age = 10, name = 'zs', sex = 2; )

• var age ; console.log (age); | 只声明 不赋值 | undefined

• console.log(age) | 不声明 不赋值 直接使用 | 报错

• age = 10; console.log (age); | 不声明 只赋值 | 10

• **2.数据类型 **

• 简单数据类型 （Number,String,Boolean,Undefined,Null）

• 复杂数据类型 （object)

• NaN ，Not a number，代表一个非数值

2 获取检测变量的数据类型

2.1 typeof

typeof "";  //string
typeof 1;   //number
typeof false; //boolean
typeof undefined; //undefined
typeof function(){}; //function
typeof Symbol(); //symbol
typeof null; //object
typeof {}; //object
typeof []; //object
typeof new Date(); //object
typeof new RegExp(); //object

2.2 instanceof

{} instanceof Object; //true
[] instanceof Array;  //true
[] instanceof Object; //true
"123" instanceof String; //false
new String(123) instanceof String; //true

2.3 Object.prototype.toString() （这种最准确）

上面不能区分 Object Array
var gettype=Object.prototype.toString
gettype.call('aaaa') 输出 [object String] 
gettype.call(2222) 输出 [object Number] 
gettype.call(true) 输出 [object Boolean] 
gettype.call(undefined) 输出 [object Undefined] 
gettype.call(null) 输出 [object Null] 
gettype.call({}) 输出 [object Object] 
gettype.call([]) 输出 [object Array] 
gettype.call(function(){}) 输出 [object Function]

2.4 封装一个准确判断数据类型的函数

function getType(obj){
  let type  = typeof obj;
  if(type != "object"){
    return type;
  }
  return Object.prototype.toString.call(obj).replace(/^\[object (\S+)\]$/, '$1');
}

• 转换为数字型（重点）parseInt() parseFloat()

1.使用let关键字声明的变量具有块级作用域 ({}就是一个块)
2.防止循环变量变成全局变量
3.使用let声明的变量没有变量提升；具有暂时性死区特性
/* -------1.在一个大括号中 使用let关键字声明的变量才具有块级作用域 var关键字是不具备这个特点的--------- */
      if (true) {
      	let num = 100;
      	var abc = 200;
      }
      console.log(abc) //200
      console.log(num) // ReferenceError: num is not defined
/* -------2.防止循环变量变成全局变量--------- */
	  let arr = [];
      for (let i = 0; i < 2; i++) {
         arr[i] = function() {
            console.log(i);
         }
      }
      // console.log(i);  // 这里拿不到i 
      // for循环是同步执行的   但是arr里面保存的函数是独立的作用域
      // 打印i的时候 函数内没有  回去上级查找  上级作用域不是全局作用域  而是let产生的块级作用域
      arr[0](); // 0
      arr[1](); // 1
      // 此题的关键点在于每次循环都会产生一个块级作用域，每个块级作用域中的变量都是不同的，
      // 函数执行时输出的是自己上一级（循环产生的块级作用域）作用域下的i值.
      // =============================================================
      // for循环是同步的  只要index = 2的时候才会跳出for循环  此时index是全局作用域 等于2
      let arr2 = []
      for (var index = 0; index < 2; index++) {
         arr2[index] = function() {
            console.log(index);
         }
      }
      console.dir(arr2);
      console.log(index); // 2
      console.log(arr2[0]);
      arr2[0]() // 2
      arr2[1]() // 2
         /* 分析 当index等于0和1 的时候 执行循环  结果是向arr2中添加item  item是函数  但是函数并没有执行
         因为循环还没结束呢
         当index=2的时候 循环结束了 开始执行函数  函数的内容是输出index   此时index是全局变量 index=2 
         打印也可以发现 
         arr2[0] = ƒ () {
            console.log(index);
         }   输出的是index   二此时index=2
          */
/* -------3.使用let声明的变量没有变量提升；具有暂时性死区特性 --------- */
	  if (true) {
         console.log(num); // 报错 ReferenceError: num is not defined （证明不存在变量提升）
         let num = 20;
      }
/*  const 1.具备let的性质 2. 声明的常量必须有初始值  */
      //  简单数据类型 一但是赋值不可更改
      //  复杂数据类型  arr  obj 不能重新赋值（这样改变了内存地址 ） 但是可以增删里面的属性
      //  const 不可更改的是内存地址（重点）
      // const PI = 3.14;
      // PI = 100; 报错
      // const ary = [100, 200];
      // ary[0] = 123;
      // ary = [1, 2] 报错
      // ary.push(300)
      // console.log(ary);