var num = 10;
var money = 1.2;
//字符串单引号和双引号都行，和java对比
var str = 'str';
var str2 = "str2";
var nul = null;
var flag = true;
//压根就没有定义叫undefined
//数组和对象
var arr = [];
var obj = {};

var num = 3;
var num = 4;
//前边的值会被后边的覆盖

//let 和 const 定义的变量不能不覆盖，不能重复定义。
let num = 3;
let num = 4;
//直接会报错

//cosnt定义的叫常量，定义之后的数据不能被修改
const num = 3;
num = 4;
//直接会报错

var arr = Array();
//Array 是个函数，猜一猜他的返回值就是个空数组

var arr = new Array();
//js里函数可以当类使用

var arr = [];

arr[0] = 123;
arr[1] = 234;

//这样当然方便
var arr = [123,234];

function getName(){

}

//这种方法没有参数没有返回值，右不打印没用让我们看见就毫无意义
function puls(){
    var a = 1 +1;
}
puls()
undefined

//参数是你要处理的数据，
//返回值就是处理的结果
//返回值可以给
function plus(num1,num2){

    return num1 + num2;

}
plus(23,34)
57

//可以使用另一个变量去接收返回值并进行利用
var num = plus(33,44)
num
77

//方法会在遇到return之后停止运行
function plus(num1,num2){
    console.log("before")
    return num1 + num2;
    console.log("after")
}

plus(34,45)
VM688:2 before
79

var obj = Object();
//Array 是个函数，猜一猜他的返回值就是个空数组

var obj = new Object();
//js里函数可以当类使用

var obj = {};

function User(name){
    this.name = name;
}

var user = new User('wusanshui');
console.log(user.name)

obj.name = 'zhangsan';
obj.age = 18;
onj.eat = function(){
    console.log(" I am eating! ")
}

//直接用json对象写一个对象出来
var user = {
    name: 'zhangsan',
    age: 10,
    eat: function(){
        console.log("i am eating！");
    }
}

function User(name){
    this.name = name;
    this.age = 18;
    this.eat = function(){
        console.log("I am eating!")
    }
}

var user = new User('wusanshui');

//new 出来的对象自然而然就拥有这些属性和方法

console.log(user.name);
调用方法
user.eat();

console.log(user['name']);
调用方法
user['eat']();

var flag = true;

if(flag){
   alert(true)
}else{
   alert(false)
}

var m = 2;
var x;
switch (m) { 
  case 0:x="今天是星期日"; 
  break; 
  case 1:x="今天是星期一"; 
  break; 
  case 2:x="今天是星期二"; 
  break; 
}

console.log(x);

let cars = [ '兰博基尼','CRV','卡宴',"奔驰是傻逼",'bwm' ];
for (var i=0;i<cars.length;i++)
{ 
    console.log(cars[i]);
}

var options = {
    name: 'zhangsan',
    age: 10
}
for(var attr in options){
    console.log(attr)
    //正确
    console.log(options[attr])
    //错误
    console.log(options.attr)
}

//元素节点
var mydiv = document.getElementById("div1")
mydiv.nodeType
1
//属性节点
mydiv.attributes[0].nodeType
2

//根据id获取一个元素节点
var div1 = document.getElementById("div1")
//根据标签名获取一堆节点的集合
var li1 = document.getElementsByTagName("li");
//根据class获取一堆元素节点
var div2 = document.getElementsByClassName("content");

//使用css选择器选择第一个匹配的元素节点
var d1 = document.querySelector(".content")
//根据css选择器选择一批能够被匹配到的所有的元素
var d1 = document.querySelectorAll(".content")

//不渲染html标签，标签会当做文本打印出来
mydiv.innerText = "jiasoushi"
//会将html标签渲染出来
mydiv.innerHTML = "<h1>123</h1>"

//直接把自己干掉
var mydiv = document.getElementById("div1")
mydiv.remove();

//清除内容
mydiv.innerText = “”;

//删除某个子元素节点
//1、找到这个字元素节点
var myul = document.getElementsByTagName('ul')[0];
//2、调用方法干掉，注意这个方法参数一定要是个元素节点
mydiv.removeChild(myul)

var div1 = document.getElementById("div1")
undefined
var child = document.getElementsByTagName("ul")[0]
undefined
child
<ul>​…​</ul>​
div1.removeChild(child );

//创建一个div标签，内存中
var mydiv = document.createElement("div");
//添加进几个属性
mydiv.setAttribute("name","mydiv");
mydiv.setAttribute("class","test");
//获取到我的div
var div1 = document.getElementById("div1");
//将内存中新建的div实实在在的加入到我的div中
div1.append(mydiv)

var mydiv = document.getElementById("div1")
//获取这个属性的值
mydiv.getAttribute("name")
//修改，同时可以添加一个属性的值
mydiv.setAttribute("name","cccc")
//删除一个属性
mydiv.removeAttribute("name")

//获取所有的属性节点的集合，是个可以当成数组
mydiv.attributes
//通过下标拿到第二个属性
mydiv.attributes[1]
//拿到属性的name
var attrName = mydiv.attributes[1].name
//拿到属性的值
var attrValue = mydiv.attributes[1].value
//修改这个属性的值
mydiv.attributes[1].value = "aaa"

var div1 = document.getElementById("div1");

//获取id的值
div1.id
"div1"
//给元素标签的id赋值
div1.id = "div2"
"div2"

//获取class属性
div1.className
"content aaa"
//为class属性赋值
div1.className = 'content'
"content"
div1.className
"content"

//直接修改行内样式
div1.style = 'background: black'
"background: black"

//js函数非常灵活，定义了参数传什么都行
var callback = function(fun){
    console.log(fun)
}
callback(1)
callback("123")
callback( {name:'zhangnan'} )
callback( [1,2,3] )

//实际上传什么，就要把这个参数当成什么来用
//要是传个方法就要在方法里找个合适的地方调用一下
var callback = function(fun){
    console.log(fun)
}

var test = function(fun){
    console.log("before");
    fun();
    console.log("after");
}

//你知道需要传方法却传了一个数字，更定不能调用，就会报错
test(1)
VM1038:2 before
VM1038:3 Uncaught TypeError: fun is not a function
    at test (<anonymous>:3:5)
    at <anonymous>:1:1
test @ VM1038:3
(anonymous) @ VM1060:1


var callback = function(){
    console.log("I am callback!")
}
test(callback);

//结果
VM1038:2 before
VM1151:2 I am callback!
VM1038:4 after

//callback就是个方法的名字
var callback = function(data){
    console.log("I am callback!"+data)
}

var test = function(fun){
    console.log("before");
    fun();
    console.log("after");
}

var test = function(fun){
    console.log("before");
    var i = 10;
    fun(i);
    console.log("after");
}
//可以直接传名字
test(callback)
VM1296:2 before
VM1255:2 I am callback!10
VM1296:5 after

//也能直接传个方法体进去
test( function(data){
    console.log("I am callback!"+data)
} )

VM1296:2 before
VM1363:2 I am callback!10
VM1296:5 after

//直接调用方法体也行
(function(){
    console.log(123)
})()
VM1427:2 123

var a  = function(){
    console.log(123)
}
//拿名字调用也行
a()
VM1452:2 123

//一次性定时器，会在多少毫秒后执行这个函数
//里边的是匿名函数，也叫回调函数（就是等过了两秒后回过头来再调用这个函数）
//返回值是个定时器，这个方法是在未来去执行某个函数
var timer = setTimeout( function(){
    console.log(123)
},2000 )

//如果时间未到，不想让他执行了，就需要取消这个定时器
clearTimeout(timer)

//周期性定时器，会每隔多少毫秒后执行这个函数
//里边的是匿名函数，也叫回调函数（就是等过了两秒后回过头来再调用这个函数）
//返回值是个定时器，这个方法是在未来去执行某个函数
var timer = setInterval( function(){
    console.log(123)
},2000 )

//如果时间未到，或者中途不想让他执行了，就需要取消这个定时器
clearInterval(timer)

//localStorage只要不人为删除，会浏览器被删除数据会一直在
//增加或修改一个
window.localStorage.setItem("name","lucy")
//获取
window.localStorage.getItem("name")
//删除一个
window.localStorage.removeItem("name")
//清空
window.localStorage.clear()

//sessionStorage网页被关闭就没有了
//增加或修改一个
window.sessionStorage.setItem("name","lucy")
//获取
window.sessionStorage.getItem("name")
//删除一个
window.sessionStorage.removeItem("name")
//清空
window.sessionStorage.clear()

//弹个提示窗口，调试也不要用，不优雅
alert(1)

//弹出确认框
//点击确定就是true 点击否就是false
var flag = confirm("您确定要退出吗?")
console.log(flag)

//弹出信息框
//输入信息后点击确定返回填的内容，点击取消返回none
var message = prompt("请填写您的手机号！");
console.log(message);
VM3797:2 1373838438

var message = window.prompt("请输入名字：")
undefined
message
"张楠"
var message = window.prompt("请输入名字：")
undefined
message
""
var message = window.prompt("请输入名字：")
undefined
message
null
var message = window.prompt("请输入名字：","liankun")

//回退
history.go(-1)
//向前
history.go(1)
//回退
history.back()
//向前
window.history.forward()

var div1 = document.getElementById("div1");
div1.addEventListener('click',function(){
    console.log("click");
})

var div1 = document.getElementById("div1");
div1.onclick = function(){
    console.log("click")
}

div1.onclick = null
或者
div1.onclick = false

var callback = function(){
    console.log("click")
}
var div1 = document.getElementById("div1");
//添加一个事件
div1.addEventListener('click',callback)
//移除一个事件
div1.removeEventListener('click',callback)

（常用）
onclick：点击某个对象时触发
ondblclick：双击某个对象时触发
onmouseover：鼠标移入某个元素时触发
onmouseout：鼠标移出某个元素时触发

（知道，不用）
onmouseenter：鼠标进入某个元素时触发
onmouseleave：鼠标离开某个元素时触发
onmousedown：鼠标按下时触发
onmouseup：鼠标抬起时触发
onmousemove：鼠标被移动时触发
onwheel：鼠标滚轮滚动时触发
oncontextmenu：点击鼠标右键时触发

ul.addEventListener('click',function(event){
            console.log('ul')
            event.stopPropagation();
        },true)

function test(){
    for( let i = 0 ; i < arguments.length ; i++ ){
        console.log(arguments[i])
    }
}

test(1,'2342',34,456,678,789,null);

VM1546:3 1
VM1546:3 2342
VM1546:3 34
VM1546:3 456
VM1546:3 678
VM1546:3 789
VM1546:3 null

function test1(){
    for( var i = 0 ; i < arguments.length ; i++  ){
        document.getElementById(arguments[i]).style = 'background:blue'
    }

}

test1()
test1('div1','div2')

function test(){
    console.log(this)
}

test()
和
window.test()
一样
结果：
VM1620:2 Window {parent: Window, opener: null, top: Window, length: 0, frames: Window, …}

function User(name){
    this.name = name;
    this.print = function(){
        console.log(this)
    }
}

let user = new User("李兴");

user.name
"李兴"

//使用user调用print this就是这个user
user.print()
VM1786:4 User {name: "李兴", print: ƒ}

let dog = {
            name: 'teddy',
            say: function (a,b) {
                var that = this;
                console.log(a,b)
                setTimeout(function(){
                    console.log('my name is ' + that.name)
                }, 1000);
            }
        }

dog.say();
// 这里say方法调用时的this指向调用say的dog对象，
// 而setTimeout方法调用时是由window对象负责调用，
// 所以setTimeoue的this指向window。
// 如果要在setTimeout内使用dog对象需要在外边进行保存

dog.say.call({name: '刘奇'},12,23)
dog.say.apply({name: '刘奇'},[23,45])

var fn = dog.say.bind({name: '刘奇'})
fn()

let site = 'itnanls';

function a() {
  let hd = 'zn.com';

  function b() {
      let cms = 'itnanls.cn';
      console.log(hd);
      console.log(site);
  }
  b();
}
a();

function hd() {
  let n = 1;
  return function() {
    let b = 1;
    return function() {
      console.log(++n);
      console.log(++b);
    };
  };
}
let a = hd()();
a(); //2,2
a(); //3,3

{
    let a = 9;
}
console.log(a); //ReferenceError: a is not defined
if (true) {
    var i = 1;
}
console.log(i);//1

for (let i = 0; i < 10; i++) {
  setTimeout(() => {
    console.log(i);
  }, 500);
}

function hd() {
  let name = '欣知';
  return function () {
    return name;
  }
}
let xzcms = hd();
console.log(xzcms()); //欣知

var adder = (function(start) {
            return function() {
                return start++;
            }
        })(10);

console.log(adder());
console.log(adder());
console.log(adder());
adder = null;

var plus = (function () {
            var cache = {};

            return function () {
                var key = [].join.call(arguments);
                if (key in cache) {
                    console.log('走了缓存')
                    return cache[key]
                }

                console.log('又计算了一次')
                var sum = 0;
                for (var i = 0; i < arguments.length; i++) {
                    sum += arguments[i]
                }
                cache[key] = sum;

                return sum;
            }
        })();

plus(1,2,3,4);
plus(1,2,3,4);
plus(1,2,3,4);

<body>
  <div desc="zn">在线学习</div>
  <div desc="xzcms">开源产品</div>
</body>
<script>
  let divs = document.querySelectorAll("div");
  divs.forEach(function(item) {
    item.addEventListener("click", function() {
      console.log(item.getAttribute("desc"));
    });
  });
</script>

let divs = document.querySelectorAll("div");
divs.forEach(function(item) {
  let desc = item.getAttribute("desc");
  item.addEventListener("click", function() {
    console.log(desc);
  });
  item = null;
});

let zn = { name: "楠哥" };
console.log(zn);

let x = {};
let y = {};
console.log(Object.getPrototypeOf(x) == Object.getPrototypeOf(y)); //true

let zn = { name: 3 };
console.log(zn.hasOwnProperty("name"));

let ng = Object.create(null, {
  name: {
    value: "楠哥"
  }
});
console.log(ng.hasOwnProperty("name")); //Error

//Object.keys是静态方法，不是原型方法所以是可以使用的
console.log(Object.keys(ng));

function User() {}
User.__proto__.view = function() {
  console.log("User function view method");
};
User.view();

User.prototype.show = function() {
  console.log("楠哥");
};
let zn = new User();
zn.show();
console.log(User.prototype == zn.__proto__);

let zn = new Object();
zn.name = "楠哥";
Object.prototype.show = function() {
  console.log("hodunren.com");
};
zn.show();

function User() {}
let ng = new User();
ng.show();
User.show();

function zn() {
  this.show = function() {
    return "show method";
  };
}
const obj = new zn(); //true
console.log(obj instanceof zn);

const obj2 = new obj.constructor();
console.dir(obj2.show()); //show method

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

function createByObject(obj, ...args) {
  const constructor = Object.getPrototypeOf(obj).constructor;
  return new constructor(...args);
}

let zn = new User("楠哥");
let ng = createByObject(zn, "楠哥", 12);
console.log(ng);

function A() {}
function B() {}
function C() {}

const c = new C();
B.prototype = c;
const b = new B();
A.prototype = b;
const a = new A();

console.dir(a instanceof A); //true
console.dir(a instanceof B); //true
console.dir(a instanceof C); //true
console.dir(b instanceof C); //true
console.dir(c instanceof B); //false

const a = {};
const b = {};
const c = {};

Object.setPrototypeOf(a, b);
Object.setPrototypeOf(b, c);

console.log(b.isPrototypeOf(a)); //true
console.log(c.isPrototypeOf(a)); //true
console.log(c.isPrototypeOf(b)); //true

let zn = {
  data: [1, 2, 3, 4, 5]
};
Object.setPrototypeOf(zn, {
  max: function(data) {
    return data.sort((a, b) => b - a)[0];
  }
});
console.log(zn.max(zn.data));

let ng = {
  lessons: { js: 100, php: 78, node: 78, linux: 125 }
};
console.log(zn.__proto__.max.call(ng, Object.values(ng.lessons)));

let zn = {
  data: [1, 2, 3, 4, 5]
};
console.log(Math.max.apply(null, Object.values(zn.data)));

let ng = {
  lessons: { js: 100, php: 78, node: 78, linux: 125 }
};
console.log(Math.max.apply(ng, Object.values(ng.lessons)));

let zn = {
  name: "楠哥"
};
let xinzhi = {
  show() {
    return this.name;
  }
};
let ng = {
  handle() {
    return `用户: ${this.name}`;
  }
};
xinzhi.__proto__ = ng;
zn.__proto__ = xinzhi;
console.log(zn.show());
console.log(zn.handle());
console.log(zn);

function User(name, age) {
  this.name = name;
  this.age = age;
}
User.prototype.show = function () {
    return `姓名:${this.name}，年龄:${this.age}`;
};
let lisi = new User('李四', 12);
let xiaoming = new User('小明', 32);
console.log(lisi.__proto__ == User.prototype); //true

function Person() {
  this.getName = function() {
    return this.name;
  };
}
function User(name, age) {
  this.name = name;
  this.age = age;
}
let lisi = new User("李四", 12);
Object.setPrototypeOf(lisi, new Person());
console.log(lisi.getName()); //李四

function User() {}
const lisi = new User();
const wangwu = new User();

lisi.name = "小明";
console.log(lisi.name);
console.log(lisi.hasOwnProperty("name"));

//修改原型属性后
lisi.__proto__.name = "张三";
console.log(wangwu.name);

//删除对象属性后
delete lisi.name;
console.log(lisi.hasOwnProperty("name"));
console.log(lisi.name);

function User() {
}
User.prototype.name = "楠哥";
const lisi = new User();
//in会在原型中检测
console.log("name" in lisi);
//hasOwnProperty 检测对象属性
console.log(lisi.hasOwnProperty("name"));

//以下实例用于搜索字符串中的字符 "e"：
var patt = /e/;
patt.test("The best things in life are free!");
字符串中含有 "e"，所以该实例输出为：
true