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<arr.length;i++){
                if(!obj[arr[i]]){
                    obj[arr[i]]=1;
                    reset.push(arr[i]);
                }
            }

            return reset;
            
        }
        var arr=['1','2','3','1','4','5'];

        console.log(unique(arr));

//字符串去重
    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;i<str.length;i++ )
        {
            if(obj[str[i]]){
                obj[str[i]]++;
                if(obj[str[i]]>max){
                    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<b.length
        })
        console.log(arr[0][0]+':'+arr[0].length)

解析url將參數放在對象中

function parseUrl(url){
            var obj={};
            var val=url.split('?')[1];
            
            if(val!=null){
                var arr=val.split('&');
                for(var i=0;i<arr.length;i++){
                    var keyArr=arr[i].split('=');
                    obj[keyArr[0]]=keyArr[1];
                }
            }
            return obj;
        }
    
        var url='https://www.baidu.com?key=1&name=cx&age=12';
        console.log(parseUrl(url));

隨機產生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<b;
    })

js實現二分法

function binarySearch(items,value){
            var startindex=0;
            var stopIndex=items.length-1;
            var middle=Math.floor((startindex+stopIndex)/2);
            while(items[middle]!=value&&startindex<stopIndex){
                if(value<items[middle]){
                    stopIndex=middle-1;
                }
                else if(value>items[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;i<arr.length;i++){
      if(cur>arr[i]){
        left.push(arr[i]);
      }else if(cur<arr[i]){
        right.push(arr[i]);
      }
    }
    return quick(left).concat(cur,quick(right));
  }

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: `
<h2>Login</h2>
<form #f="ngForm" (ngSubmit)="login(f.value,f.valid)" novalidate>
    <div>
        <label>Username</label>
        <input type="text" [(ngModel)]="username" placeholder="enter username" required>
    </div>
    <div>
        <label>Password</label>
        <input type="password" name="password" [(ngModel)]="password" placeholder="enter password" required>
    </div>
    <input class="btn-primary" type="submit" value="Login">
</form>`
   //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

)]