具体来说，异步运行机制如下：
（1）所有同步任务都在主线程上执行，形成一个执行栈（execution context stack）。
（2）主线程之外，还存在一个"任务队列"（task queue）。只要异步任务有了运行结果，就在"任务队列"之中放置一个事件。
（3）一旦"执行栈"中的所有同步任务执行完毕，系统就会读取"任务队列"，看看里面有哪些事件。那些对应的异步任务，于是结束等待状态，进入执行栈，开始执行。
（4）主线程不断重复上面的第三步

var para=document.createElement("p"); //创建新的 <p> 元素
var node=document.createTextNode("这是新段落。"); //创建了一个文本节点
para.appendChild(node); //向 <p> 元素追加这个文本节点
var element=document.getElementById("div1");//向一个已有的元素追加这个新元素
element.appendChild(para); //向这个已有的元素追加新元素

function clone(obj) {var o;switch (typeof obj) {case 'undefined':break;case 'string':o = obj + '';break;case 'number':o = obj - 0;break;case 'boolean':o = obj;break;case 'object': //object分为两种，一种为Object，一种为Arrayif (obj === null) {o = null} else {if (Object.prototype.toString.call(obj).slice(8, -1) === 'Array') {o = [];for (var i = 0; i < obj.length; i++) {o.push(clone(obj[i]))}} else {o = {};for (var k in obj) {o[k] = clone(obj[k])}}}break;default:o = obj;break;}return o;}

        // 方法一：Array.prototype.clearRepeat = function () {var arr = []; //定义一个临时数组for (var i = 0; i < this.length; i++) {//通过遍历判断当前数组下标为i的元素是否保存到临时数组中//如果保存，则跳过，否则保存到临时数组if (arr.indexOf(this[i]) == -1) {arr.push(this[i]);}}return arr;};var test = [1, 6, 8, 8, 9, 9, 9, "a", "a"];test.clearRepeat();    //结果为[1, 6, 8, 9, "a"]// 方法二：Array.prototype.clearRepeat = function () {var arr = [this[0]]; //直接定义结果数组for (var i = 1; i < this.length; i++) { //从第二项开始遍历当前数组//对元素进行判断://如果当前数组元素在此数组中第一次出现的位置不是i//则第i项是重复的，否则直接存入结果数组if (this.indexOf(this[i]) == i) {arr.push(this[i]);}}return arr;};var test = [1, 6, 8, 8, 9, 9, 9, "a", "a"];test.clearRepeat();    //结果为[1, 6, 8, 9, "a"]
// 上面两种方法不推荐使用，因为indexOf()这个函数在执行的时候每次都会遍历一次数组，
//对性能影响比较大。比较适合小数据量的数组。//第三种使用的是hash表，把已经出现过的元素通过下标形式写入一个Object中，
//下标的引用要比数组的indexOf()方法搜索节省时间Array.prototype.clearRepeat = function() {var h = {};  //定义一个hash表var arr = [];  //定义一个临时数组for (var i = 0; i < this.length; i++) {if (!h[this[i]]) {h[this[i]] = true;arr.push(this[i]);}}return arr;};var test = [1, 6, 8, 8, 9, 9, 9, "1", "a"];console.log(test.clearRepeat())     //结果为[1, 6, 8, 9, "a"]
//此方法有缺陷，作为下标在转换后会变成字符串，
//那么对于1和“1”这样不同类型的值会对应到同一个下标而被去重。例如obj[1]和obj['1'],是相同的Array.prototype.clearRepeat = function() {var h = {};  //定义一个hash表var arr = [];  //定义一个临时数组for (var i = 0; i < this.length; i++) {var type = typeof this[i];if (!h[this[i]  + type])  {h[this[i]  + type]  = true;arr.push(this[i]);}}return arr;};//不用hash表的解决办法吗，使用原始sort()排序后相邻两个数值进行比较Array.prototype.clearRepeat = function() {this.sort(); //数组排序var arr = [this[0]]; //定义结果数组for (var i = 1; i < this.length; i++) { //从第二项开始遍历当前数组//判断两个相邻元素是否相等，如果相等说明数据重复，否则将元素写入结果数组if (this[i] !== arr[arr.length - 1]) {arr.push(this[i])}}return arr}var test = [1, 6, 8, 8, 9, 9, 9, "1", "a"];

1.闭包函数是指有权访问另一个函数作用域中的变量的函数
2.创建闭包函数最常见的方式是在一个函数内创建另一个函数，通过另一个函数访问这个函数的局部变量
3.闭包的特点：1函数嵌套函数，2 函数内部可以引用外部的参数和变量  3 参数和变量不会被垃圾回收机制回收4.闭包的优点：1 希望一个变量长期驻扎在内存中    *  2 避免全局变量的污染    *            3 私有变量存在5.闭包的实现 1：函数嵌套函数    *  2 外层函数返回内层函数    *           3 外面有一全局变量接受外层函数6.缺点： 闭包使用不当，会造成内存污染，正常无法被垃圾回收机制清掉，IE低版本会造成内存泄漏function fun1() {var num = 1;return function () {num++;return num;}}var s = fun1()// console.log(s());// //  自执行函数  的闭包var fun3 = function () {var num = 1;return {b: 6,sum: function () {return num + this.b}}}();// console.log(fun3.sum());/**  把函数名当参数调用*  回调函数** */function a() {console.log('a');}function b() {console.log('b');}function c(fun) {fun()}// c(a), c(b)// 循环var num = 0;function a(fun) {console.log(123);fun(fun)}function a2(fun) {num++;console.log(num);if (num > 10) return;fun(a2)}a(a2)

        function add(num) {if (num == 1) {return num;} else {return num + add(num - 1)}}console.log(add(100));

typeof 123, //"number"typeof 'dsfsf', //"string"typeof false, //"boolean"typeof [1,2,3], //"object"typeof {a:1,b:2,c:3}, //"object"typeof function(){console.log('aaa');}, //"function"typeof undefined, //"undefined"typeof null, //"object"typeof new Date(), //"object"typeof /^[a-zA-Z]{5,20}$/, //"object"typeof new Error() //"object"

   123 instanceof Number, //false'dsfsf' instanceof String, //falsefalse instanceof Boolean, //false[1,2,3] instanceof Array, //true{a:1,b:2,c:3} instanceof Object, //truefunction(){console.log('aaa');} instanceof Function, //trueundefined instanceof Object, //falsenull instanceof Object, //falsenew Date() instanceof Date, //true/^[a-zA-Z]{5,20}$/ instanceof RegExp, //truenew Error() instanceof Error //true

var num = new Number(123);
var str = new String('dsfsf');
var boolean = new Boolean(false);

var num  = 123;
var str  = 'abcdef';
var bool = true;
var arr  = [1, 2, 3, 4];
var json = {name:'wenzi', age:25};
var func = function(){ console.log('this is function'); }
var und  = undefined;
var nul  = null;
var date = new Date();
var reg  = /^[a-zA-Z]{5,20}$/;
var error= new Error();function Person(){}
var tom = new Person();// undefined和null没有constructor属性
console.log(tom.constructor==Person,num.constructor==Number,str.constructor==String,bool.constructor==Boolean,arr.constructor==Array,json.constructor==Object,func.constructor==Function,date.constructor==Date,reg.constructor==RegExp,error.constructor==Error
);
//所有结果均为true

var toString = Object.prototype.toString;toString.call(123); //"[object Number]"
toString.call('abcdef'); //"[object String]"
toString.call(true); //"[object Boolean]"
toString.call([1, 2, 3, 4]); //"[object Array]"
toString.call({name:'wenzi', age:25}); //"[object Object]"
toString.call(function(){ console.log('this is function'); }); //"[object Function]"
toString.call(undefined); //"[object Undefined]"
toString.call(null); //"[object Null]"
toString.call(new Date()); //"[object Date]"
toString.call(/^[a-zA-Z]{5,20}$/); //"[object RegExp]"
toString.call(new Error()); //"[object Error]"

function gettype(obj) {var type = typeof obj;if (type !== 'object') {return type;}//如果不是object类型的数据，直接用typeof就能判断出来//如果是object类型数据，准确判断类型必须使用Object.prototype.toString.call(obj)的方式才能判断return Object.prototype.toString.call(obj).replace(/^[object (S+)]$/, '$1');
}

jQuery.isArray(object)
jQuery.isFunction(value)
jQuery.isNumeric(value)
jQuery.isEmptyObject(obj)
jQuery.isPlainObject(value)

var obj = {text: '我的两个爱好：'
}function getHobby(a, b) {console.log(this.text + a + '和' + b)
}getHobby.call(obj, '足球', '羽毛球')
// 我的两个爱好：足球和羽毛球

var obj = {text: '我的两个爱好：'
}function getHobby(a, b) {console.log(this.text + a + '和' + b)
}getHobby.apply(obj, ['足球', '羽毛球'])
// 我的两个爱好：足球和羽毛球

var obj = {text: '我的两个爱好：'
}function getHobby(a, b) {console.log(this.text + a + '和' + b)
}getHobby.bind(obj, '足球', '羽毛球')()
// 我的两个爱好：足球和羽毛球

  // 后端没设置跨域时，可使用webpack进行配置// devServer: {//     // 代理//     proxy: {//         // 只要请求地址有'api'都会匹配上//         "/api": {//             target: "http://132.232.94.151:3005",//             ws: true,//             // 允许跨域//             changeOrigin: true,//             pathRewrite: {//                 "^/api": "" //通过pathRewrite重写地址，将前缀/api转为///             }//         }//     }// }

function trim(str) {if (str && typeof str === "string") {return str.replace(/(^s*)|(s*)$/g,""); //去除前后空白符}
}

console.log(a); // undefined  ===>  a已声明还没赋值，默认得到undefined值
var a = 100;
console.log(b); // 报错：b is not defined  ===> 找不到b这个变量
let b = 10;
console.log(c); // 报错：c is not defined  ===> 找不到c这个变量
const c = 10;

{let a = 1
}
console.log(a) // undefined

const a
控制台报错

const a=1
a=2
控制台报错

<script>
document.write(parseInt(10*Math.random())); 　//输出0～10之间的随机整数
document.write(Math.floor(Math.random()*10+1)); 　//输出1～10之间的随机整数
function RndNum(n){
var rnd="";
for(var i=0;i<n;i++)
rnd+=Math.floor(Math.random()*10);
return rnd;
}
document.write(RndNum(4));　　//输出指定位数的随机数的随机整数引用部分:   
1. 从1开始 至 任意值parseInt(Math.random()*上限+1); 
2. 从任意值开始 至 任意值parseInt(Math.random()*(上限-下限+1)+下限);   function fRandomBy(under, over){ 
switch(arguments.length){ 
case 1: return parseInt(Math.random()*under+1); 
case 2: return parseInt(Math.random()*(over-under+1) + under); 
default: return 0; 
} 
} 
document.write(fRandomBy(1,100));　　//输出指定范围内的随机数的随机整数