js面试

摘要：检测，并在发生无法或不愿意自己检测的变化时作出反应。在每个变更检测周期中调用，和之后。当每次销毁指令组件之前调用并清扫。

  1 function distinct(arr) {
        return arr.filter(function (elem,index,arr){
            return arr.indexOf(elem,index+1) === -1;
        });
    }
    console.log(distinct(arr));
    

  2 function unique(arr){
            var obj={};
            var reset=[];
            for(var i=0;i
    //字符串去重
    function strUnique(str){
        var arr=str.split("");
        var newarr=unique(arr);
        var newstr=newarr.join("");
        return newstr;
    }
    var str="adsdsdwesdsdds";
    console.log(strUnique(str));

求字符串出现的次数最多的字符次数
    1   var str="asdsdkdsksdlsldlsassss";
        var temp={};
        str.replace(/w{1}/g,function(val){
            temp[val]?temp[val]++:temp[val]=1;
        })
        String.prototype.split.call(temp,",")
        console.log(temp);
    
    
    2   var obj={};
        var max;
        var letter;
        for (var i=0;imax){
                    max=obj[str[i]];
                    letter=str[i];
                }
            }
            else{
                obj[str[i]]=1;
                max=obj[str[i]];
                letter=str[i];
            }
        }

        console.log(letter+":"+obj[letter]);
        console.log(obj);
        
     3  var str1=str.split("");
        str1.sort();
        str=str1.join("");
        var reg=/(w)1*/g;

        var arr=str.match(reg);
        console.log(arr);
        arr.sort(function(a,b){
            return a.length
解析url将参数放在对象中
    function parseUrl(url){
            var obj={};
            var val=url.split("?")[1];
            
            if(val!=null){
                var arr=val.split("&");
                for(var i=0;i
随机产生10个在1-100之间的数 并排序
var arr1=Array(10).join(",").split(",")
        .map(function(elem,index,arr){
        return Math.ceil(Math.random()*100+1);
    });
arr1.sort(function(a,b){
        return a
js实现二分法
 function binarySearch(items,value){
            var startindex=0;
            var stopIndex=items.length-1;
            var middle=Math.floor((startindex+stopIndex)/2);
            while(items[middle]!=value&&startindexitems[middle]){
                    startindex=middle+1;
                }
                middle=Math.floor((startindex+stopIndex)/2);
            }
            return (items[middle]!=value)?-1:middle;
}

js快速排序
function quickSort(arr){
    if(arr.length<=0){
      return arr;
    }
    var index=Math.floor(arr.length / 2);
    var cur=arr.splice(index,1);
    var left=[];
    var right=[];
    for(var i=0;iarr[i]){
        left.push(arr[i]);
      }else if(cur
AngularJs
Angular 应用：用带 Angular 扩展语法的 HTML 写 模板 ， 用 组件 类管理这些模板，用 服务 添加应用逻辑， 并在 模块 中打包发布组件与服务
钩子


ngOnChanges    
当 Angular （重新）设置数据绑定输入属性时响应。 该方法接受当前和上一属性值的 SimpleChanges 对象,
当被绑定的输入属性的值发生变化时调用，首次调用一定会发生在 ngOnInit 之前。

ngOnInit    
在 Angular 第一次显示数据绑定和设置指令 / 组件的输入属性之后，初始化指令 / 组件。
在第一轮 ngOnChanges 完成之后调用，只调用 一次 。

ngDoCheck    
检测，并在发生 Angular 无法或不愿意自己检测的变化时作出反应。
在每个 Angular 变更检测周期中调用， ngOnChanges 和 ngOnInit 之后。

ngAfterContentInit    
当把内容投影进组件之后调用。 
第一次 NgDoCheck 之后调用，只调用一次。
只适用于组件 。

ngAfterContentChecked    
每次完成被投影组件内容的变更检测之后调用。
ngAfterContentInit 和每次 NgDoCheck 之后调用
只适合组件 。

ngAfterViewInit    
初始化完组件视图及其子视图之后调用.
第一次 ngAfterContentChecked 之后调用，只调用一次。
只适合组件 。

ngAfterViewChecked    
每次做完组件视图和子视图的变更检测之后调用。
ngAfterViewInit 和每次 ngAfterContentChecked 之后调用。
只适合组件 。

ngOnDestroy    
当 Angular 每次销毁指令 / 组件之前调用并清扫。 在这儿反订阅可观察对象和分离事件处理器，以防内存泄漏.
在 Angular 销毁指令 / 组件之前调用。

Angular 2 : Template Driven Forms
import { Component } from "@angular/core";
import { Router , ROUTER_DIRECTIVES} from "@angular/router";
import { NgForm }    from "@angular/forms";

@Component({
    selector: "login",
    template: `
Login

    

        Username
        
    
    

        Password
        
    
    
`
   //For long form we can use **templateUrl** instead of template
})

export class LoginComponent{

    constructor(private router : Router){ }

    login (formValue: any, valid: boolean){
        console.log(formValue);
        
        if(valid){
            console.log(valid);
        }
    }    
}     


One way binding from parent component to nested component: [propertyName]
One way binding from nested component to parent component: (propertyName)
Two-way binding (a.k.a banana box notation) : [(propertyName

)]