JS笔记

Prompt() 输入框
Alert()提示框
Console.log() 日志
Temp 临时变量
Number 数字型
Max 最大值
Min 最小值
Nan 用来判断变量或者值 是否为数字 是数字返回false 不是数字返回true
String 字符串
Undefine 未定义
ToString( ) 转换成字符串
String() 强制转换
ParseInt(age) 转为数字型
ParseFloat() 转数字型 保小数
= 赋值
== 比较 用于相等比较 只会比较内容 不会比较类型
=== 既比较内容又比较类型
&& and 的意思 返回式两边都是ture 返回的才是ture
|| or的意思 两边只要有一边是ture 那返回就是true
Continue 和 break 的区别
Continue 关键字用于立即跳出本循环 继续下一次循环
Break关键字 用于立即跳出整个循环

数组 就是一组数据的集合存储在单个变量下
1 利用new 创建数组
Var arr new Array();
//创建了一个空数组

2 利用数组字面量创建数组
Var arr = [] ; //创建了一个空数组
可以放任何类型的数据

数组里面的数据一定要用逗号隔开
数组的索引
索引 用来访问数组的元素的序号 （数组下标从0 开始）

函数 函数就是封装了一段可被重复执行的代码 通过代码块实现大量代码的重复使用

调用的时候不要忘了添加小括号
函数不调用 自己不执行
声明函数本身 并不会执行代码 只有调用 函数时才会执行函数本身

函数封装
把一个或多个功能通过函数的方式封装起来 对外只提供一个接口

在声明函数的小括号里为形参
在函数调用的小括号 为实参

Break continue return 的区别
Break : 结束当前循环体
Continue : 跳出本次循环 继续下次循环
Return : 不仅可以退出循环 还能返回return 语句中的值 同时可以结束当前函数体内的代码
作用域
全局作用域：
作用域所有代码执行的环境或者一个独立的JS文件
局部作用域：
作用于函数内部的代码环境 就是局部作用域 因为跟函数有关系 所有称函数作用域
Js没有块级作用域 块级作用域用{}包裹

全局变量 ：
全局变量在代码任何位置都可使用
在全局作用域下 var 声明的变量
特殊情况下载函数内不使用var 声明的变量也是全局变量

局部变量：
局本变量只能在该函数内部使用 在函数内部 var 声明的变量为局部变量
函数的形参实际上是局部变量

预解析
预解析 JS引擎会把JS

let关键字
作用：用来声明变量的
语法：
let num = 1;
特点：
• 具有块级作用域
• 不会进行变量的提升
• 具有暂时性死区
const 关键字
作用：用来声明常量的；常量就是一个不可变化的值;
语法：

const num = 20;
特点：
• 具有块级作用域
• 不会进行变量的提升
• 初始化必须要赋值
• 不能去更改const所定义的值
o 简单数据类型，不能去修改值
o 复杂数据类型，不能修改地址值
var、let、const区别
• var 不具备块级作用域特点，只具备函数级别的作用域的特点，可以去修改值，存在变量的提升
• let 具备块级作用域的特点，不存在变量的提升，可以去修改值
• const 具备块级作用域的特点，不存在变量的提升，不可以去修改值
解构赋值
意思：分解数据结构，然后给变量进行赋值

function fn(){
    console.log(111);
}

//转成箭头函数

const fn = () => {
     console.log(111);
}
：

• 如果形参只有一个的话，可以去省略小括号
如果函数体里面只有一行代码，或者说这一行代码前面有一个关键字return，可以省略大括号

应用场景：当实参不确定的情况下使用，和arguments很像

ES6内置对象的扩展的方法
Array数组
扩展运算符
语法: …
应用场景： 合并数组，把伪数组转成数组

Array.from 方法
作用： 把伪数组转成真正的数组

Array.find 方法
作用：用来查找数组中匹配的元素，只会匹配第一个

let arr = [2,5,7];
var result = arr.find(value => value == 2);//这个函数里面写的是条件，只有当返回式true的情况下，才会返回相应的元素
console.log(result);
Array.findIndex 方法
作用：用来查找数组中匹配元素对应的索引号，使用跟 find一致
Array.includes 方法
作用：判断数组是否包含某一个元素
String 字符串
模板字符串
语法： let str = ``;//反引号
特点：
• 我们不需要利用+号去拼接变量，利用${}
• 可以在字符串里面去调用函数 ${fn()}
• 会保留空格跟换行，让我们代码看起来更加的整洁
startsWith和 endsWith 方法
作用：判断字符串是否以什么开头或者是结尾
repeat方法
作用：重复，copy几次

set 集合
也是一种数据类型，专门用来存储数据的；里面存储的元素都是唯一的，里面没有重复的值

//实例化set对象
var set = new Set([2,4,5]);
//操作set
set.add(6); //添加一个元素 2，4，5，6
set.delete(6);//删除一个元素 2,4,5
set.has(3); //判断是否有这个元素 如果有返回true，如果没有返回false
set.clear(); //清空

//遍历 forEach

set.forEach(value=>{
    //value 遍历的时候每一个元素的值
});

jQ操作 属性
$().prop(); 如果里面只有一个参数，代表获取值，如果两个参数，第一个 属性名 第二个 属性值
$().attr(); 如果里面只有一个参数，代表获取值，如果两个参数，第一个 属性名 第二个 属性值 自定义属性
$().data(); 操作这个元素对象的属性
jQ操作 文本属性
表单
$().val(); 表单元素的值 里面不带参数是获取值，如果里面有参数代表设置值
非表单
$().html(); === innerHTML 里面不带参数是获取值，如果里面有参数代表设置值
$().text(); === innerText 里面不带参数是获取值，如果里面有参数代表设置值
jQ获取指定的父辈元素
$().parents(‘选择器’);
jQ里面的遍历
//用来遍历 jQ对象

   $().each(function(i,ele){
        // i 代表是索引号  
        // ele  代表是DOM的对象
   });

// 遍历数据
$.each(需要遍历的数据,function(i,ele){
// i 遍历的索引 如果是对象，i是属性名
//ele 代表就是值
});
jQ的节点操作

1. 创建
   var li = $(‘写要添加的标签

3. ’);

4. 添加
   内部添加 --> 添加 子元素
   parent.append(li); //追加最后一个子孩子
   parent.prepend(li); //插入到第一个子孩子
   外部添加 --> 添加兄弟元素
   element.before(li); //在前面添加
   element.after(li); // 在后面添加

5. 删除
   element.remove(); 删除自身
   element.empty(); 删除所有子节点
   element.html(’’);
   jQ 大小
   $().width()|height() 获取元素的内容宽高
   $().innerWidth()|innerHeight() 获取元素的内容宽高 + padding
   $().outerWidth() | outerHeight() 获取的是元素内容 + padding + border 4
   如果参数是true 还需要加一个margin
   jQ的位置
   $().offset({
   left:
   }) //获取的是一个偏移的对象，里面有两个属性，left top 获取的是相对于整个文档的偏移量
   $().position(); 获取的是偏移的对象， 获取的是相对于带有定位的父辈元素的偏移量
   $().scrollTop()|scrollLeft() 获取的是垂直|水平方向滚动出去的距离
   构造函数
   构造函数一个泛指，并不是一个具体的对象，但是他是实例化对象的一个规则
   //声明了一个构造函数
   function Person(name,age){
   this.name = name;
   this.age = age;
   }
   // 需要实例化对象，才能用
   var person = new Person(‘八万’,81);
   原型对象
   什么是原型对象？ 它就是一个object对象，用来描述 实例化对象跟构造函数的关系 只要我们去声明了一个构造函数，那么系统就会帮我们自动初始化一个原型对象 我们可以通过构造的一个属性来获取原型对象 每一个实例化出来的对象都有一个属性来指向原型对象 通过原型对象也能获取构造
   Person.prototype; //获取原型对象
   var person = new Person();
   person.proto; //获取原型对象
   原型对象.constructor; //获取对应的构造
   原型链
   原型链来描述了一个继承的关系 面向对象的思想
   • 封装
   • 继承
   • 多态(抽象)原型链的图，大家是需要会画了查找规则： 就近原则，先从自身上找是否 有这个属性跟方法，如果没有，找对应的原型对象，如果有，直接用，如果没有继续往上去找，直到找到最上层，object的原型对象上，如果还没有，就找到null了
   继承
   概念：子承父业，孩子可以拥有父亲的一些属性跟方法 继承的方式
   原型继承
   核心：就是把孩子的原型对象设置成父亲的实例对象

   function Father(){
   this.name = ‘father’;
   }
   Father.prototype.sayHi = function(){

   }
   function Child(){

   }
   Child.prototype = new Father();

//因为我们自己实例化的对象里面没有constructor的属性
Child.prototype.constructor = Child;
var child = new Child();
child.sayHi();
特点：能够使用父亲原型上面的方法，但是不能传递属性的值
借调构造函数
核心： 在孩子的构造里面利用call方法来调用父亲的构造，因为call方法可以改变this的指向

 function Father(name){
     this.name = name;
 }
 function Child(name){
     Father.call(this,name);
 }
 var child = new Child('zs');

特点： 能够方便的设置属性的值，但是父亲原型上的方法不能被使用
组合继承
原型继承 + 借调构造函数

function Father(name){
     this.name = name;
}
Father.prototype.sayHi = function(){

}
function Child(name){
     Father.call(this,name);
}
Child.prototype = new Father();
Child.prototype.constructor = Child;
var child = new Child('zs');
child.sayHi();

call、apply、bind
call：会直接调用函数，方法里面的第一个参数就是改变this指向fn.call(obj,参数,…); 把fn里面的this改变成 obj对象
apply：会直接调用函数，方法里面的第一个参数就是改变this指向fn.apply(obj,[参数,…])把fn里面的this改变成 obj对象
bind：不会直接调用函数，方法里面的第一个参数就是改变this指向var newFn = fn.bind(obj,参数,…); 有一个返回值，返回的是一个新的函数newFn();把newFn里面的this改变成 obj对象
闭包
什么是闭包？
• 一个作用域访问了另外一个作用域的变量，除去了全局作用域
• 内部函数被其父函数外部的变量接收或者是直接调用
• 延长局部变量的声明周期
递归
函数自己调用自己，注意有出口
正则表达式
正则用来操作字符串的
• 校验
• 提取
• 替换 正则的一些语法：
元字符
/d 匹配的是数字/D 匹配的是非数字/w 匹配的是 数字 字母 下划线 /W 匹配的是 非数字，非字母 非下划线 /s 空格和换行 /S 非空格和换行 . 匹配任意字符，除了换行 ^ 以什么开头 $ 以什么结尾
限定符
• 前面的字符出现0次或者是多次
• 前面的字符出现1次或者是多次? 前面的字符出现0次或者1次{n} 出现了n次相应的字符{n,} 出现了n次或者是多次的字符{n,m} 出现了 n 到 m 之间的字符
[] 取中括号里面的对应的某一个字符[^] 取反的意思 | 两边只有有一边匹配就ok \ 转义符() 分组
在js里面如何使用正则
1.利用正则对象 var reg = new RegExp(正则表达式, 模式); 模式:i 忽略大小写 g 全局匹配2.利用字面量 var reg = /正则表达式/ig;正则对象里面有两个方法方便我们操作reg.test(匹配的字符串); 校验是否匹配 返回值是booleanreg.exec(匹配的字符串); 提取，但是只能提取一个string方法里面也能操作 string.match(reg); 提取，提取多个string.split(reg); 提取，提取多个 string.replace(reg,被替换的内容); 替换
分组提取 1.正则里面用小括号代表分组 2.调用操作正则表达式的方法3.就可以通过 RegExp.$n 可以对应分组的值 (n 代表第几组)
今天 ? 概念性的知识点

面向对象思想编程
封装
继承
抽象
继承是什么东西？
子承父业，孩子可以继承父亲的 属性跟方法

js里面如何实现继承
原型继承：把父亲实例化的对象赋值给孩子的原型对象
优点：可以继承父亲的属性跟方法，但是不能设置父亲的属性

function Father(){
    this.name = 'zs';
}
Father.prototype.makeMoney = function(){

}
function Child(){

}

//因为我们自己实例化的对象里面没有construtor属性

Child.prototype = new Father();
Child.prototype.constructor = Child;
var child = new Child();
child.name; 
child.makeMoney();

借调构造函数：利用原型方法 call方法来调用父亲的构造，让父亲的构造里面的this指向孩子
优点： 可以传递参数，改变构造里面的属性，但是不能调用父亲的方法

function Father(name){
    this.name = name;
}
Father.prototype.makeMoney = function(){

}
function Child(name){
    Father.call(this,name);
}

var child = new Child(‘ww’);//new 在内存中开辟一个新的空间 让this指向当前对象 执行构造函数里面的代码 返回当前对象
child.name;

组合继承
原型继承 + 借调构造函数

function Father(name){
    this.name = name;
}
Father.prototype.makeMoney = function(){

}
function Child(name){
    //借调构造函数来改变父亲里面的属性
    Father.call(this,name);
}

//原型继承

Child.prototype = new Fahter();
Child.prototype.constructor = Child; 
var child = new Child('zl');
child.makeMoney();

call、apply、bind
这三个方法都是干嘛的？ 都是改变调用函数里面的this的指向
function fn(){
this
}
fn.call(obj,实参,实参); // 直接调用函数，让里面的函数的this指向方法的第一个参数，实参 队列

fn.apply(obj,[实参,实参]);//直接调用函数，让里面函数的this指向方法的第一个参数，后面的实参是一个数组

var newFn = fn.bind(obj,实参,实参);//不会直接调用函数，把新的函数返回；让新函数里面this指向方法的第一个参数，后面是实参的队列
newFn();

函数里面相关的一些成员
fn.arguments 伪数组 ， 是实参的集合
fn.caller 函数的调用者，如果是在全局作用域调用的，那么返回的就是null
fn.name 函数的名字
fn.length 形参的个数

函数是一个对象

var fn = new Function('console.log()');
就是一个数据类型，就可以当作参数来传递，也能够当作返回值来看 

function fn(){
    return funtion(){
        console.log(111);
    }
}
fn()();

寄生继承

 function Father(name, age) {
            this.name = name;
            this.age = age;
        }
        Father.prototype.makeMoney = function() {

        }

        function Child(name, age) {
            //借调构造函数来改变父亲里面的属性
            Father.call(this, name, age);
        }
        //原型继承
        //寄生继承
        //在中间再来绑定一个函数，而这个函数里面什么都没有
        function P() {

        }
        //我把这个P的原型对象赋值成 Father的原型对象，然后把P的实例设置给Child的原型对象
        P.prototype = Father.prototype;
        Child.prototype = new P();
        Child.prototype.constructor = Child;
        var child = new Child('zl', 19);
        console.dir(child)

今天讲了什么？
闭包的概念
一个作用域访问了其他作用域的变量，除开全局作用域
闭包发生在函数身上
延长了作用域的生命没周期 特点
递归的概念
递归是函数自己调用自己，注意：递归要有出口
斐波那契数列：前面两个数的和等于第三个数
浅拷贝： 简单数据类型拷贝值，复杂数据类型拷贝地址值
深拷贝： 简单数据类型拷贝值，在拷贝复杂数据类型的时候，先创建一个新对象，然后把需要拷贝的对象进行遍历，把里面的属性一个一个取出来，设置到新对象里面

变量
什么是变量？
变量是用来存储数据的，关键字var 是在内存中开辟一个区间，来存储数据
如何用
1.申明变量
var 变量名;
2.给变量赋值
变量名 = 值;
3.调用
直接用 变量名;但是直接用变量名是看不到的，我们需要借助 日志输出
4.输出方式
console.log();
alert();
prompt() 输入框
变量名的命名规则和规范
• 由 数字、字母、下划线、$构成
• 不能用数字开头
• 严格区分大小写
• 不能用关键字和保留字段
• 遵循驼峰命名法
• 要有语义
操作符
算术运算符

• • • / % 先乘除后加减，如果有括号，先算小括号里面的
      比较运算符

< >= <= == ===
==: 只比较内容
===: 即比较内容又比较类型
逻辑运算符

&& || !
&&： and的意思， 操作符两边都是true，才会返回true，只要有一边为false，那么返回的就是false
逻辑中断：从左至右依次执行，如果当前表达式是true的话，继续往右执行，直到碰到表达式是false，那么就直接返回表达式的值
|| ： or 的意思，操作符两边只要有一边是true，那么就返回true，如果两边都是false，才返回的是false
逻辑中断：从左至右依次执行，如果当前表达式是false的话，继续往右执行，知道碰到表达式是true，那么就返回该表达式的值!：取反的意思
赋值运算符

var num = 10;
num +=5; // == num = num + 5;
前置运算符和后置运算符
前置++： 先自身加1，然后把值返回
后置++：先返回值，然后再自身加1
运算符的优先级
• 小括号
• 一元运算符
• 算术运算符
• 关系运算符
• 比较运算符
• 逻辑运算符
• 赋值运算符
流程控制
顺序流程
代码从上至下，依次执行
分支流程
一个分叉路口
if语句
语法：

if(条件表达式){
代码1
}else{
代码2
}
如果条件表达式为true，那么执行代码1，如果是false，那么执行代码2
多分支语法：

if(条件表达式){
    
}else if(条件表达式){
    
}else if(条件表达式){
    
}...

else{
    
}

从上至下依次去判断条件表达式是否成立，如果其中一个成立，会进入相应的执行语句，当代码执行完，不会再进入后面的分支
switch语句
语法

switch(value){
    case value1:
     break;
    case value2:
     break;
     ...
     default:
      break;
}

直接跳到与传递进来value值相等的这一个分支
循环流程
不停的执行一些代码
for循环
语法：

for(初始化变量; 条件表达式; 操作表达式){
//循环体
}
执行过程
• 1.执行初始化变量
• 2.执行条件表达式，如果成立，进入循环体，如果不成立，跳出循环
• 3.执行循环体里面的代码
• 4.执行 操作表达式
• 2 3 4 重复执行
双重for循环

for(初始化变量; 条件表达式; 操作表达式){
for(初始化变量; 条件表达式; 操作表达式){
//循环体
}
}
外层循环执行一次，内层循环执行所有次数
while循环
语法：

while(条件表达式){
//循环体
}
只有当条件表达式成立的时候，才会进入循环体，循环体执行完了，又会跳到条件表达式这里进行判断
do…while循环
语法：

do{

}while(条件表达式);
先执行do里面的循环体，然后再判断条件是否成立，如果成立，继续执行循环体，如果不成立，跳出循环
continue break return
continue： 跳出本次循环，循环还会继续，那么continue后面的代码不会执行
break： 跳出整个循环，循环不再继续，那么break后面的代码不会执行
return： 跳出循环，中止函数的执行，return后面跟什么就返回什么，如果return后面不跟东西，返回式 undefined
数据类型
简单数据类型
number 数值类型
整数 int
浮点数 float
如何把其他类型转成number

parseInt(‘60px’);//直接取整，后面的小数不要 60
parseFloat(‘60.2px’);// 获取小数 60.2
//如果说数值后面带了非数字类型的，会把数值返回，非数值的过滤掉
string 字符串
被引号引起来的，都是字符串
字符串如何拼接 用 + 号
如何把其他类型转成string

var num = 5;
num + ‘’;
boolean 布尔类型
true，false
隐式转换，只要是要条件表达式的地方，都会默认做一个隐式转换
只有5种情况转成false
• 0
• ‘’
• NaN
• null
• undefined
undefined 未定义
null 空对象
复杂数据类型
函数
函数是用来封装一定功能的代码块，可以重复来调用
语法：

//命名函数

function fn(){
    
}
//函数声明了不会自己执行里面代码，必须要调用
fn();

//匿名函数
var fn = function(){
    
}
fn();

参数
形参：写在函数的声明上面，相当于一个变量来占位
实参：写在函数的调用上面，是实实在在的值
返回值 return
arguments
是伪数组，是实参的集合，使用方法跟数组是一样的
自定义对象
对象是什么
指的是一类具体的事物
对象的初始化

//字面量的方式

var obj = {
    name: 'zs',
    age: 18,
    play: function(){
        
    }
}
//new Object 
var obj = new Object();
obj.name = 'zs';
obj.age = 18;
obj.play= function(){
    
}

//构造函数

function Person(name,age){
    this.name = name;
    this.age = age;
    this.play = function(){
        
    }
}

//需要去实例化对象 就是new对象
var obj = new Person(‘zs’,18);

//如何去使用属性或者调用方法呢
obj.name;//取属性值
obj.play();//调用方法
对象的遍历 for in

//构造函数
function Person(name,age){
this.name = name;
this.age = age;
this.play = function(){

}

}
//需要去实例化对象 就是new对象
var obj = new Person(‘zs’,18);

for(var key in obj){
//key 就是对象里面的属性名
obj[key]; //才能拿到属性值
}
内置对象
Math 算术对象
只要是做算术相关的，就找Math

Math.max(); //获取最大值
Math.min(); //获取最小值
Math.abs(); //绝对值
Math.floor(); //向下取整
Math.ceil();//向上取整
Math.round(); //四舍五入
Math.random(); //随机数 [0,1) 能娶到0，取不到1
Date 日期对象
只要是做日期相关的操作，找Date

var date = new Date();//获取的是当前时间
//需要做格式化
date.getFullYear();// 获取年份
date.getMonth(); //获取月份 0 ~ 11
date.getDate(); //获取日
date.getDay(); //获取星期
date.getHours(); //获取小时
date.getMinutes(); //获取分钟
date.getSeconds(); //获取秒

//获取毫秒的方法
date.valueOf();
date.getTime();
var date = +new Date();
Date.now();
Array 数组
数组 就是用来存放一组数据的
数组的声明方式

var arr = [];
var arr = new Array();
数组的方法

arr.push(); //追加元素
arr.pop(); //删除最后一个元素
arr.unshift(); //在第一个位置添加元素
arr.shift(); // 删除第一个元素
arr.indexOf();// 检测数组里面是否有这个元素
arr.length; //数组的长度
arr.reverse(); //翻转数组
arr.sort(); //排序
arr.join();//转换成字符串
遍历
就是把数组里面的元素一个一个拿出来，要配合for循环来使用
String 字符串

var str = ‘’;
str.substr(startIndex,length); //截取字符串
str.replace(要被替换的字符，替换的字符); //替换
str.split(需要切割的符号); //切割 返回值是一个数组
str.charAt(); //根据索引返回对应的字符
str.indexOf(); //根据字符检测对应的索引
str.length; //字符串的长度
typeof 检测简单数据类型
instanceof 用来检测复杂数据类型
作用域相关概念
作用域： 变量的作用范围
全局作用域： 整个页面，声明的变量是全局变量，整个页面都可以用
局部作用域：作用函数内部，声明的变量是局部变量，只能用于函数的内部
作用域链： 就是查询变量的规则，就近原则，先看本作用域中是否有，如果有，直接使用，如果没有，往上一层去找
预解析
执行js的时候分两步，先进行预解析，然后再执行代码
特点：

1. 会把变量的声明提升， var 提升，不包含赋值
2. 会把函数的生命提升，function 提升，不包含调用
   循环
   重复的去执行一段代码
3. for 循环
   语法：
   for(初始化变量; 条件表达式; 操作表达式){
   //循环体
   }
   执行流程
   1.先执行 初始化变量 var i = 1;
   2.执行 条件表达式 i<=100;
   3.如果条件表达式 为true，那么进入循环体，如果为false 直接跳出for循环
   4.执行 操作表达式 i+=2;
   5. 布置2 3 4 重复执行
   双重for循环

for(;?{
for(;?{

    }
}
    执行流程  外层执行一次，内层执行所有次数
    注意的一些细节点：

var sum = 0;
for(var i = 1; i <= 100; i++){
if(i % 2==0){
sum+=i;
}
}
i 起到了一个 计数器的作用
我们就可在循环体里面根据i的值不同，做不同的逻辑
2. while 循环
语法：
while(条件表达式){
//循环体
}
执行流程：
1. 判断条件表达式是否为true
2. 如果是true 进入循环体
3. 循环体执行完了，再判断条件表达式
4. 直到条件表达式为false 那么就跳出while循环
3. do…while
语法：
do{
//循环体
}while(条件表达式);
执行流程：
先执行 一次循环体
再去判断条件表达式
3个循环 什么情况下用哪个？
for 循环一般用于 有固定的循环次数 后续配合着遍历数组和集合
while do…while 不确定循环次数的时候

continue 跳出本次循环，还会执行剩余的循环 循环体里面 continue后面的代码 不会执行
break 跳出整个循环，循环不再继续， 循环体里面 break 后面的代码 不会执行

1. 函数里面的
   arguments 是一个伪数组，装的是 所有的实参的集合
   如何我想把所有的实参都取出来 怎么搞

   for(var i = 0; i < arguments.length; i++){
         arguments[i];
   }
   

   函数声明的 两种方式

   1. 命名函数

   function 名字(){

   }
   2. 匿名函数

var fn = function(){ //函数的表达式

      }
  自调用函数 

(function(){

 })()

;
作用域
变量的作用范围 增强了程序的可靠性 减少了命名冲突
全局作用域：整个页面，在这里声明的变量称为 全局变量，它的生命周期伴随整个页面
局部作用域：作用函数内部，在这里声明的变量称为 局部变量，他的生命周期伴随函数的调用
作用域链：
查询变量的规则， 就近原则， 如果使用了一个变量，那么先会在当前作用域中去寻找是否有，如果有，直接用，如果没有，往上一层作用域去寻找

预解析
在解析js之前 先会把一些东西提升到当前作用域的前面

1. 变量的声明 var 但是不包含赋值
2. 函数的声明 function 不包含函数的调用
3. 按照从上至下的顺序执行代码

对象
什么是对象？
万物皆对象 对象指的是一类具体的事务
对象的初始化方式

1. 对象的字面量

    var hero = {
        name: 'vn',
        sex:'女',
        sayHi:function(){
            
        }
    }
    console.log(hero.name, hero['name']);
    hero.sayHi();
   

   2. new Object();
      var hero = new Object();
      hero.name = ‘VN’;
      hero.sex = ‘女’;
      hero.sayHi = function(){

      }

3.构造函数
1. 声明构造函数
function Hero(name,sex){
this.name = name;
this.sex = sex;‘
this.sayHi = function(){

 }

}
var hero = new Hero(‘VN’,‘女’);

 new关键字的过程
   1.在内存中创建了一个空对象
   2.把this指向当前的对象
   3.执行构造函数里面的代码
   4.把当前对象返回

对象的遍历
利用什么语法啊 for in

  for(var k in hero){
        //k 就是对象里面的属性名
        // 取值得时候需要注意，必须要用 对象名[]
        hero[k];
    }