每日1题重点分析

20190622 字符串操作相关

1、转换成字符串

var num=24;
//三种方法都可以
var mystr=num.toString();    //"24"
var mystr=String(num);    //"24"
var mystr="" + num;    //"24"

2、字符串分割

将字符串进行拆分返回一个新的数组，JavaScript就给我们提供了一个非常方便的函数：

var mystr="qingchenghuwoguoxiansheng,woaishenghuo,woaiziji";
var arr1=mystr.split(",");    //["qingchenghuwoguoxiansheng","woaishenghuo","woaiziji"];
var arr2=mystr.split("");        //["q","i","n","g","c","h","e","n","g","h","u","w","o","g","u","o","x","i","a","n","s","h","e","n","g",",","w","o","a","i","s","h","e","n","g","h","u","o",",","w","o","a","i","z","i","j","i"];

split()的第二个参数，表示返回的字符串数组的最大长度

var mystr="qingchenghuwoguoxiansheng,woaishenghuo,woaiziji";
var arr1=mystr.split(",",2); //["qingchenghuwoguoxiansheng","woaishenghuo"];
var arr2=mystr.split("",8); //["q","i","n","g","c","h","e","n"];

3、字符串替换

仅仅查找到字符串并不会是题目的停止，一般题目还经常会要求你去进行替换操作，那就继续看以下代码:

var mystr="wozaijinxingzifuchuantihuancaozuo,zifuchuantihuano";
var replaceStr=mystr.replace("zifuchuan"," ");    //wozaijinxing tihuancaozuo,zifuchuantihuano
var replaceStr=mystr.replace(/zifuchuan/," ");    //wozaijinxing tihuancaozuo,zifuchuantihuano
var replaceStr=mystr.replace(/zifuchuan/g," ");    //wozaijinxing tihuancaozuo, tihuano

默认只进行第一次匹配操作的替换，想要全局替换，需要置上正则全局标识g

4、获取字符串长度

获取字符串的长度经常会用到，方法很简单：

var mystr="qingchenghuwoguoxiansheng,woaishenghuo,woaiziji";
var arrLength=mystr.length;    //47

5、查询子字符串

判断字符串内是否包含子串，不少开发者会使用for循环来判断，而忘记了JavaScript提供子串函数：

indexOf()，该Of() 方法对大小写敏感。返回字符串中一个子串第一处出现的索引（从左到右搜索）。如果没有匹配项，返回 -1

stringObject.indexOf(searchvalue,fromindex)
searchvalue 必需。规定需检索的字符串值。
fromindex 可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的首字符开始检索。

var mystr="Hello world!";
var index=mystr.indexOf("llo");    //2
var index1=mystr.indexOf("l");    //2
var index2=mystr.indexOf("l",3);    //3

lastIndexOf()，该方法对大小写敏感。返回字符串中一个子串最后一处出现的索引（从右到左搜索），如果没有匹配项，返回 -1

stringObject.lastIndexOf(searchvalue,fromindex)
searchvalue 必需。规定需检索的字符串值。
fromindex 可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的最后一个字符处开始检索。

var mystr="Hello world!";
var index=mystr.lastIndexOf("llo");    //2
var index1=mystr.lastIndexOf("l");    //9
var index2=mystr.lastIndexOf("l",4);    //3

6、返回指定位置的字符或其字符编码值

查找给定位置的字符，可以使用如下函数：

var mystr="Hello World!";
var index=mystr.charAt(7);    //o

同样，它的一个兄弟函数就是查找对应位置的字符编码值，如：

var mystr="Hello World!";
var charCode=mystr. charCodeAt(7);    //111

7、 字符串匹配

可以直接通过字符串进行匹配，也可以通过正则进行匹配，可能需要你对正则表达式有一定的了解，先来看看match()函数：

		var mystr = "hi,mynameisguoxiansheng6guo,33iswho?";
		var matchStr = mystr.match("guo");
		console.log(matchStr);//["guo", index: 11, input: "hi,mynameisguoxiansheng6guo,33iswho?", groups: undefined]
		var matchStr1 = mystr.match("Guo");
		console.log(matchStr1); //null
		var regexp1 = /\d+/g;
		var regexp2 = /guo/g;
		var regexp3 = /guo/;
		var matchStr2 = mystr.match(regexp1);
		console.log(matchStr2); //["6", "33"]
		var matchStr3 = mystr.match(regexp2);
		console.log(matchStr3); //["guo", "guo"]
		var matchStr3 = mystr.match(regexp3);
		console.log(matchStr3); //["guo",index:11,input:"hi,mynameisguoxiansheng6guo,33iswho?"]
		console.log(matchStr3.index); //11
		console.log(matchStr3.input); //hi,mynameisguoxiansheng6guo,33iswho?

注意：1.此处使用字符串直接进行匹配，被匹配的字符串内包含要匹配的字符串时，返回所要匹配的字符串。

2.如果使用正则匹配字符串时，如果正则表达式没有 g (全局标识)标志，返回与正则匹配相同的结果。而且返回的数组拥有一个额外的 input 属性，该属性包含原始字符串。另外，还拥有一个 index 属性，该属性表示匹配结果在被字符串中的索引（以0开始，并且只返回第一个匹配的索引）。如果正则表达式包含 g 标志，则该方法返回匹配字符串的数组。

再来看看使用exec()函数：

var mystr="hi,mynameisguoxiansheng6,33iswho?";
var regexp1=/guo/g;
var matchStr=regexp1.exec(mystr);  //["guo"]
var regexp2=/guo/;
var matchStr1=regexp2.exec(mystr);    //["guo",index:11,input:"hi,mynameisguoxiansheng6,33iswho?"]
matchStr1.index    //11
matchStr1.input    //hi,mynameisguoxiansheng6,33iswho?

简单吧，仅仅是把正则和字符串换了个位置，即exec()函数是在正则上调用，传递字符串的参数。对于上面两个方法，匹配的结果都是返回第一个匹配成功的字符串，如果匹配失败则返回null。

再来看一个类似的函数search()：，也是只返回第一个匹配的索引

		var mystr = "hi,mynameisguoxiansheng6guo,33iswho?";
		var regexp1 = /guo/g;
		var matchStr = mystr.search(regexp1);
		console.log(matchStr); //11

进行正则匹配查找。如果查找成功，返回字符串中匹配的索引值。否则返回 -1

8、字符串连接

可以将两个或多个字符串进行加法操作，同时可以使用JavaScript提供的concat函数：

先看加法操作进行字符串连接：

var mystr1="Hello";
var mystr2="world!";
var newStr=mystr1+" "+mystr2;    //Hello world!

是不是很简单呀，那继续看看concat函数吧：

var mystr1="Hello";
var mystr2=" world,";
var mystr3="Hello";
var mystr4="guoxiansheng";
var newStr=mystr1.concat(mystr2+mystr3+" "+mystr4);    //Hello world,Hello guoxiansheng

concat()函数可以有多个参数，传递多个字符串，拼接多个字符串。

9、字符串切割和提取

有三种可以从字符串中抽取和切割的方法：

第一种，slice()函数：

var mystr="hello world!";
var sliceStr1=mystr.slice(-3);    //ld!
var sliceStr2=mystr.slice(-3,-1);    //ld
var sliceStr3=mystr.slice(3);    //lo world!
var sliceStr4=mystr.slice(3,7);    //lo w

第二种：substring()函数：

var mystr="hello world!";
var sliceStr1=mystr.substring(3);    //lo world!
var sliceStr2=mystr.substring(3,7);    //lo w

第三种：substr()函数：

var mystr="hello world!";
var sliceStr1=mystr.substr(3);    //lo world!
var sliceStr2=mystr.substr(3,7);    //lo worl

注：
1.slice() 可以为负数，如果起始位置为负数，则从字符串最后一位向前找对应位数并且向后取结束位置，如果为正整数则从前往后取起始位置到结束位置。
　　
2.substring()只能非负整数，截取起始结束位置同slice()函数一致。

3.substr()与第一、第二种函数不同，从起始位置开始截取，结束位置为第二个参数截取的字符串最大长度。

以上三种函数未填第二参数时，自动截取起始位置到字符串末尾。

10、字符串大小写转换

var mystr="Hello World!";
var lowCaseStr=mystr.toLowerCase();    //hello world!
var upCaseStr=mystr. toUpperCase();    //HELLO WORLD!

11、字符串去空格

trim方法用来删除字符串前后的空格

var mystr="     hello world      ";  
var trimStr=mystr.trim();    //hello world

常用的字符串操作

1、字符串去重

var str="aahhgggsssjjj";
function removeRepeat(msg){  
    var res=[];  
    var arr=msg.split("");  
    for(var i=0;i<arr.length;i++){  
        if(res.indexOf(arr[i])==-1){  
            res.push(arr[i]);  
        }  
    }  
    return res.join("");  
}  
removeRepeat(str);    //ahgsj

2、判断字符串中字符出现的次数

/*  
    1.先实现字符串去重  
    2.然后对去重后的数组用for循环操作，分别与原始数组中各个值进行比较，如果相等则count++,循环结束将count保存在sum数组中，然后将count重置为0  
    3.这样一来去重后的数组中的元素在原数组中出现的次数与sum数组中的元素是一一对应的  
*/  

    var str="aacccbbeeeddd";  
    var sum=[];  
    var res=[];  
    var count=0;  
    var arr=str.split("");  
    for(var i=0;i<arr.length;i++){  
        if(res.indexOf(arr[i])==-1){  
            res.push(arr[i]);  
        }  
    }  
    for(var i=0;i<res.length;i++){  
        for(var j=0;j<arr.length;j++){  
            if(arr[j]==res[i]){  
                count++;  
            }  
        }  
        sum.push(count);  
        count=0;  
    }  
    console.log(res);    //["a", "c", "b", "e", "d"]  
    for(var i=0;i<res.length;i++){  
        var str=(sum[i]%2==0)?"偶数":"奇数";  
        console.log(res[i]+"出现了"+sum[i]+"次");  
        console.log(res[i]+"出现了"+str+"次");  
    }  

20190621 构造函数是什么

构造函数的特点：
a:构造函数的首字母必须大写，用来区分于普通函数
b:内部使用的this对象，来指向即将要生成的实例对象
c:使用New来生成实例对象

function Person(name,age){
     this.name = name;    
     this.age = age;   
     this.sayHello = function(){   
         console.log(this.name +"say hello");
    }
}

var boy = new Person("bella",23);    
boy.sayHello(); // bella say hello

20190620 new和instanceof的内部机制

1. 创建一个新对象，同时继承对象类的原型，即Person.prototype；
2. 执行对象类的构造函数，同时该实例的属性和方法被this所引用，即this指向新构造的实例；
3. 如果构造函数return了一个新的“对象”，那么这个对象就会取代整个new出来的结果。如果构造函数没有return对象，那么就会返回步骤1所创建的对象，即隐式返回this。（一般情况下构造函数不会返回任何值，不过在一些特殊情况下，如果用户想覆盖这个值，可以选择返回一个普通的对象来覆盖。）

用代码来阐述

// let p = new Person()
let p = (function () {
    let obj = {};
    obj.__proto__ = Person.prototype;
    
    // 其他赋值语句...
    
    return obj;
})();

下面通过代码阐述instanceof的内部机制，假设现在有 x instanceof y 一条语句，则其内部实际做了如下判断：

 			function Y(name){
				this.name = name;
			}
			
			function Z(name){
				this.name = name;
			}
			
			var x = new Y('lxf');
			
			function checkInstanceof(Sup){
				while(x.__proto__ !== null) {
					if(x.__proto__ === Sup.prototype){
						return true;
					}
					try{
						x.__proto__ = x.__proto__.__proto__;
					}catch(e){
						return false;
					}
				}
				if(x.__proto__ == null){
					return false;
				}
			}
			
			console.log(checkInstanceof(Y)); //true
			console.log(checkInstanceof(Z)); //false,找不到x.__proto__.__proto__
    复制代码x会一直沿着隐式原型链__proto__向上查找直到x.__proto__.__proto__......===y.prototype为止，如果找到则返回true，也就是x为y的一个实例。否则返回false，x不是y的实例。

20190619 类相关

一.有一个类如下：
function Person(name) {
    this.name = name
}
let p = new Person('Tom');

1.  p.__proto__等于什么？
答案：
Person.prototype

2. Person.__proto__等于什么？
答案：
Function.prototype

解析：
1，2两问其实问的是同一个问题，都是考察原型链相关的知识，我们只需要记住一句话就可以迎刃而解。实例的__proto__属性（原型）等于其构造函数的prototype属性。实例p的构造函数为Person，而Person的构造函数为Function，结果就一目了然了。

3. 若将题干改为
function Person(name) {
    this.name = name
    return name;
}
let p = new Person('Tom');
实例化Person过程中，Person返回什么（或者p等于什么）？
答案：
{name: 'Tom'}

4. 若将题干改为
function Person(name) {
    this.name = name
    return {}
}
let p = new Person('Tom');

复制代码实例化Person过程中，Person返回什么（或者p等于什么）？
答案：
{}
解析

构造函数不需要显示的返回值。使用new来创建对象(调用构造函数)时，如果return的是非对象(数字、字符串、布尔类型等)会忽而略返回值;如果return的是对象，则返回该对象(注：若return null也会忽略返回值）。

20190618 for(let i = 0; i < 10; i++)和for(var i = 0; i < 10; i++)的思考

for(var i = 0; i < 10; i++){
    setTimeout(function(){  //当setTimeout执行的时候，for循环已经完成，i此时的值是10
        console.log(i);
    },100);
}
结果是很显而易见的，10次都是10，在面试前端的闭包知识时候很常见。 
用上let之后，

for(let i = 0; i < 10; i++){
    setTimeout(function(){
        console.log(i);
    },100);
}
结果是： 
0、1、2、3、4、5、6、7、8、9

这道题涉及了异步、作用域、闭包

settimeout是异步执行，10ms后往任务队列里面添加一个任务，只有主线上的全部执行完，才会执行任务队列里的任务，当主线执行完成后，i是4，所以此时再去执行任务队列里的任务时，i全部是4了。对于打印4次是：

每一次for循环的时候，settimeout都执行一次，但是里面的函数没有被执行，而是被放到了任务队列里面，等待执行，for循环了4次，就放了4次，当主线程执行完成后，才进入任务队列里面执行。
　　（注意：for循环从开始到结束的过程，需要维持几微秒或几毫秒。)
当我把var 变成let 时
for(let i=0;i<=3;i++){ setTimeout(function() { console.log(i) }, 10);}
打印出的是：0,1,2,3
当解决变量作用域，
因为for循环头部的let不仅将i绑定到for循环快中，事实上它将其重新绑定到循环体的每一次迭代中，确保上一次迭代结束的值重新被赋值。setTimeout里面的function()属于一个新的域，通过 var 定义的变量是无法传入到这个函数执行域中的，通过使用 let 来声明块变量，这时候变量就能作用于这个块，所以 function就能使用 i 这个变量了；这个匿名函数的参数作用域 和 for参数的作用域 不一样，是利用了这一点来完成的。这个匿名函数的作用域有点类似类的属性，是可以被内层方法使用的。

var声明的i，作用域不仅仅在for循环内，还在for循环的外部。
等同：var i;for(i = 0; i < 10; i++){}
而let声明只在代码块中有效。
不等同：let i;for(i = 0; i < 10; i++){}

在setTimeout的时候，匿名函数function(){console.log(i);}会被声明创建，当匿名函数执行的时候，会查找当前运行环境的 i 的值。
var声明的 i ，运行环境的 i 的值为10，但是let声明的 i，运行环境中 i 的值是每一个循环创建匿名函数时候的 i。
所以得到了0-9的值。
let替换var，可以很好的解决闭包的问题

拓展解析（例子）：

step1：f1、Promise对象实例化、f2被放入主线程的堆内存中；

step2：Promise对象实例化后的同步代码块被放入主线程的执行栈中执行，并且产生的异步任务被放入任务队列；

step3：f1被放入主线程的执行栈中执行（打印“我是F1”），for循环产生的1000个定时器（异步任务）放入任务队列；

step4：f2被放入主线程的执行栈中执行，连续5次；

step5：至此，主线程的执行栈中已经没有任务了，于是事件循环（event loop）机制从任务队列中取出一个任务放入主线程的执行栈中执行；

step6：等待主线程的执行栈中又没有任务了，事件循环机制再次去任务队列中取出任务；

step7：重复第6步。

解析：任务队列

上面提到了任务队列，任务队列就是等候执行的一系列任务，就好比锅里的饭，你只有把碗里的饭吃完了，才能再次去锅里再盛一碗（不要杠！）；

只有主线程的执行栈中没有了任务，事件循环机制才会去任务队列拿任务去执行。

由刚开始的图，你也看到了，任务队列是分不同类别并且是有优先级的。

任务队列又分为macro-task（宏任务）和micro-task（微任务）;
macro-task大概包括：script（整体代码）,setTimeout,setInterval,setImmediate,I/O,UI rendering;
micro-task大概包括：process.nextTick,Promise,Object.observe(已废弃),MutationObserver(html5新特性)
setTimeout/Promise等我们称之为任务源。而进入任务队列的是他们指定的具体执行任务。
来自不同任务源的任务会进入到不同的任务队列
优先级的话，micro-task > macro-task；

对于micro-task：process.nextTick > Promise.then

对于macro-task：setTimeout > setImmediate

拓展：要实现let的方法效果用立即执行函数也可获取

// 使用立即执行函数
for(var i = 0; i < 10; i++) {
    (function (i) {
        setTimeout(() => {
            console.log(i)
        }, 0);
    })(i);
}

20190617 实现一个三栏布局的网页，中间部分要自适应宽度并且优先加载。左边宽150px;右边栏宽200px;

考到的知识主为flex布局，答案不唯一

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
		<style type="text/css">
			body{
				margin: 0;
				padding: 0;
				display: flex;
			}
			.middle{
				order: 2;
				width: 100%;
			}
			.left{
				order: 1;
				width: 150px;
			}
			.right{
				order: 3;
				width: 200px;
			}
		</style>
	</head>
	<body>
		<div class="middle">2</div>
		<div class="left">1</div>
		<div class="right">3</div>
	</body>
</html>

20190616 隐式参数arguments

函数调用时浏览器每次传递的隐式参数this，今天要讲的是另外一个浏览器传递给函数的隐式参数arguments。

在函数调用的时候，浏览器每次都会传递进两个隐式参数：

1. 函数的上下文对象this

2. 封装实参的对象arguments

//多继承 
			Object.prototype.mix = function(){
				var i = 0,
					len = arguments.length,
					arg;
				for(;i < len;i++){
					arg = arguments[i];
					for(var property in arg){
						this[property] = arg[property];
					}
				}
			}
			
			var otherBook = {
				name:'dada'
			}
			var book1 = {
				age:11
			}
			var book2 = {
				jj:'dada'
			}
			
			otherBook.mix(book1,book2);
			console.log(otherBook); //{name: "dada", age: 11, mix: ƒ, jj: "dada"}

arguments.callee:
在函数内部，有两个特殊的对象：arguments 和 this。其中， arguments 的主要用途是保存函数参数， 但这个对象还有一个名叫 callee 的属性，该属性是一个指针，指向拥有这个 arguments 对象的函数。 请看下面这个非常经典的阶乘函数

function factorial(num){    
   if (num <=1) {         
      return 1;     
   } else {         
   return num * factorial(num-1)     
   } 
}  

定义阶乘函数一般都要用到递归算法；如上面的代码所示，在函数有名字，而且名字以后也不会变 的情况下，这样定义没有问题。但问题是这个函数的执行与函数名 factorial 紧紧耦合在了一起。为 了消除这种紧密耦合的现象，可以像下面这样使用 arguments.callee

function factorial(num){    
   if (num <=1) {         
      return 1;     
   } else {         
   return num * arguments.callee(num-1);
   } 
}  

20190615 详解 JavaScript的 call() 和 apply()

定义：ECMAScript规范为所有函数都包含两个方法(这两个方法非继承而来), call 和 apply 。这两个函数都是在特定的作用域中调用函数,能改变函数的作用域，实际上是改变函数体内 this 的值 。

call 和 apply

用法：调用函数，传递参数

	//定义一个add 方法
    function add(x, y) {
        return x + y;
    }

    //用call 来调用 add 方法
    function myAddCall(x, y) {
        //调用 add 方法 的 call 方法
        return add.call(this, x, y);
    }

    //apply 来调用 add 方法
    function myAddApply(x, y) {
        //调用 add 方法 的 applly 方法
        return add.apply(this, [x, y]);
    }

    console.log(myAddCall(10, 20));    //输出结果30
  
    console.log(myAddApply(20, 20));  //输出结果40

我们看到通过方法本身的call 和 apply 执行了该函数。

改变函数作用域

	var name = '小白';

    var obj = {name:'小红'};

    function sayName() {
        return this.name;
    }

    console.log(sayName.call(this));    //输出小白

    console.log(sayName. call(obj));    //输入小红

我们改变了函数运行的作用域， 通过绑定不同的对象，函数内部 this 也不同。最终输入结果才会这样。

高级用法，实现 js 继承

	//父类 Person
    function Person() {
        this.sayName = function() {
            return this.name;
        }
    }

    //子类 Chinese
    function Chinese(name) {
        //借助 call 实现继承
        Person.call(this);
        this.name = name;

        this.ch = function() {
            alert('我是中国人');
        }
    }

    //子类 America
    function America(name) {
        //借助 call 实现继承
        Person.call(this);
        this.name = name;

        this.am = function() {
            alert('我是美国人');
        }
    }


    //测试
    var chinese = new Chinese('成龙');
    //调用 父类方法
    console.log(chinese.sayName());   //输出 成龙

    var america = new America('America');
    //调用 父类方法
    console.log(america.sayName());   //输出 America

区别：

• 参数不同, apply 传入的是一个参数数组，也就是将多个参数组合成一个参数数组， call 从第二个参数开始依次传入.
• apply 可以直接将当前函数的arguments对象作为apply的第二个参数传入

结束语：
call 和 apply 最大的好处:方便我们解耦，对象不需要和方法有任何的耦合性，能使我们写出更好的面相对象程序。
大家如果看一些 js 框架底层的话会看到好多地方都有大量用到。