1.restful協議規範

2.border 線： 

border-style:dotted solid double dashed; 

• 上邊框是點狀
• 右邊框是實線
• 下邊框是雙線
• 左邊框是虛線

3.怎麼判斷兩個物件相等？

obj={ a:1, b:2}obj2={ a:1, b:2}obj3={ a:1, b:2}

思路：轉換成字串比較

JSON.stringify(obj)==JSON.stringify(obj2);//true

JSON.stringify(obj)==JSON.stringify(obj3);//false

4.專案做過哪些記憶體優化

• 減少 HTTP
   請求數
• 減少 DNS 查詢
• 使用 CDN
• 避免重定向
• 圖片懶載入
• 減少 DOM 元素數量
• 減少 DOM 操作
• 使用外部 JavaScript 和 CSS
• 壓縮 JavaScript 、 CSS 、字型、圖片等
• 優化 CSS Sprite
• 使用 iconfont
• 字型裁剪
• 多域名分發劃分內容到不同域名
• 儘量減少 iframe 使用
• 避免圖片 src 為空
• 把樣式表放在 中
• 把指令碼放在頁面底部
  歡迎補充。。。

5.vue router 除了router-link 怎麼實現跳轉？

router.go(1)router.push('/')

6.vue router 跳轉和location.href 的區別？

router 監聽hash值變化

location.href 頁面跳轉。重新整理頁面。

7.vue實現雙向繫結實現原理？

通過 Object.defineProperty 實現的

8.require和import 的區別

require 執行時載入，JavaScript 引擎靜態分析先於模組載入。import（）函式動態載入

9.哪些是穩定排序？哪些是不穩定排序？

定義:
假定在待排序的記錄序列中，存在多個具有相同的關鍵字的記錄，若經過排序，這些記錄的相對次序保持不變，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序後的序列中，r[i]仍在r[j]之前，則稱這種排序演算法是穩定的；否則稱為不穩定的

穩定排序：
插入排序 [1]  ，氣泡排序 [2]  ，歸併排序 [3]  ，基數排序 [4]  ，計數排序 [5] 

不穩定排序：
快速排序 [1]，簡單選擇排序 [2]，希爾排序 [3]，堆排序 [4]

10.typeof obj === 'object'判斷obj是物件的弊端？如何改進？

var  obj = {};
var  arr = [];
var funcInstance = new (function (){});  
var isNull = null;

console.log(typeof obj === 'object');  //true
console.log(typeof arr === 'object');  //true
console.log(typeof funcInstance == 'object');  //true
console.log(typeof isNull === 'object');    // true

// constructor
({}).constructor === Object;  //true
([]).constructor === Array;  //true

// instanceof
({}) instanceof Object;  //true
([]) instanceof Array;   //true

// toString: 將當前物件以字串的形式返回
console.log(Object.prototype.toString.call(obj));  //[object Object]
console.log(Object.prototype.toString.call(arr));  //[object Array]
console.log(Object.prototype.toString.call(null));  //[object Null]

11. 補充題 下面會輸出什麼

var a = {};
var b = {name:"ZS"};
var c = {};
c[a] = "demo1";
c[b] = "demo2";
console.log(c[a]); // demo2
console.log(c); // Object {[object Object]: "demo2"}
c[a]、c[b]隱式的將物件a，b使用了toString（）方法進行了轉換，然後再對屬性賦值。
即：Object.prototype.toString.call(a) ==> [object Object] 
因此，c = { [object Object]: 'demo1'} ==> c = {[object Object]: 'demo2' }

12. 實現log函式

function log() {
    // var arr = [].slice.call(arguments);
    var arr = Array.from(arguments);
    var res = '';
    arr.forEach(elem => {
        res += elem + ' ';
    });
    console.log(`${res}`);
}

// 測試
log('hello', 'world');
log('hello world');

13.淺拷貝和深拷貝的區別？如何實現？

• 淺拷貝（shallow copy）：只複製指向某個物件的指標，而不復制物件本身，新舊物件共享一塊記憶體
• 深拷貝（deep copy）：複製並建立一個一摸一樣的物件，不共享記憶體，修改新物件，舊物件保持不變

  // 1. Object.assign
  
  let foo = {
      a: 1,
      b: 2,
      c: {
          d: 1,
      }
  }
  let bar = {};
  Object.assign(bar, foo);
  foo.a++;
  foo.a === 2 //true
  bar.a === 1 //true
  foo.c.d++;
  foo.c.d === 2 //true
  bar.c.d === 1 //false
  bar.c.d === 2 //true
  
  Object.assign()是一種可以對非巢狀物件進行深拷貝的方法;
  如果物件中出現巢狀情況，那麼其對被巢狀物件的行為就成了普通的淺拷貝。
  
  
  // 2. JSON.parse和JSON.stringify
  
  var obj1 = { body: { a: 10 } };
  var obj2 = JSON.parse(JSON.stringify(obj1));
  obj2.body.a = 20;
  console.log(obj1);   // { body: { a: 10 } } 
  console.log(obj2);   // { body: { a: 20 } }
  console.log(obj1 === obj2);   // false
  console.log(obj1.body === obj2.body);   // false
  
  用JSON.stringify把物件轉成字串，再用JSON.parse把字串轉成新的物件。
  但是，會破壞原型鏈，並且無法拷貝屬性值為function的屬性
  
  
  // 3. 遞迴
  
  var json1={
      "name":"shauna",
      "age":18,
      "arr1":[1,2,3,4,5],
      "string":'got7',
      "arr2":[1,2,3,4,5],
      "arr3":[{"name1":"shauna"},{"job":"web"}]
  };
  var json2={};
  
  function copy(obj1,obj2){
    var obj2 = obj2 || {};
    for(var name in obj1){
      if(typeof obj1[name] === "object"){ 
        obj2[name]= (obj1[name].constructor===Array)?[]:{}; 
        copy(obj1[name],obj2[name]); 
      }else{
        obj2[name]=obj1[name];  
      }
    }
    return obj2;
  }
  
  json2=copy(json1,json2)
  json1.arr1.push(6);
  alert(json1.arr1);  //123456
  alert(json2.arr1);  //12345