//發(fā)送一個get請求是這樣的:

//首先實例化一個XMLHttpRequest對象
var httpRequest = new XMLHttpRequest();

//注冊httpRequest.readyState改變時會回調(diào)的函數(shù),httpRequest.
//readyState共有5個可能的值,
//0	UNSENT (未打開)	open()方法還未被調(diào)用;
//1	OPENED  (未發(fā)送)	send()方法還未被調(diào)用;
//2	HEADERS_RECEIVED (已獲取響應(yīng)頭)	send()方法已經(jīng)被調(diào)用, 響應(yīng)頭和響應(yīng)狀態(tài)已經(jīng)返回;
//3	LOADING (正在下載響應(yīng)體)	響應(yīng)體下載中; responseText中已經(jīng)獲取了部分?jǐn)?shù)據(jù);
//4	DONE (請求完成)	整個請求過程已經(jīng)完畢.
httpRequest.onreadystatechange = function(){
 //該回調(diào)函數(shù)會被依次調(diào)用4次
 console.log(httpRequest.readyState);

 if(httpRequest.readyState===4){
   //請求已完成
   if(httpRequest.status===200){
     //http狀態(tài)為200
     console.log(httpRequest.response);

     var data = JSON.parse(httpRequest.response);
     console.log(data);
   }
 }

}

//請求的網(wǎng)址
var url = 'https://api.github.com/users/ruanyf';;
//該方法為初始化請求,第一個參數(shù)是請求的方法,比如GET,POST,PUT,第二個參數(shù)是請求的url
httpRequest.open('GET',url,true);

//設(shè)置http請求頭
httpRequest.setRequestHeader("Content-Type","application/json");

//發(fā)出請求,參數(shù)為要發(fā)送的body體,如果是GET方法的話，一般無需發(fā)送body,設(shè)為空就可以
httpRequest.send(null);

//請求的網(wǎng)址
var url = 'https://api.github.com/users/ruanyf';;
//發(fā)起get請求
var promise = fetch(url).then(function(response) {

   //response.status表示響應(yīng)的http狀態(tài)碼
   if(response.status === 200){
     //json是返回的response提供的一個方法,會把返回的json字符串反序列化成對象,也被包裝成一個Promise了
     return response.json();
   }else{
     return {}
   }

});
    
promise = promise.then(function(data){
  //響應(yīng)的內(nèi)容
	console.log(data);
}).catch(function(err){
	console.log(err);
})

fetch(url)
  .then(...)
  .catch(...)

fetch('https://api.github.com/users/ruanyf')
	// fetch()接收到的response是一個 Stream 對象
	// response.json()是一個異步操作，取出所有內(nèi)容，并將其轉(zhuǎn)為 JSON 對象
  .then(response => response.json()) 
  .then(json => console.log(json))
  .catch(err => console.log('Request Failed', err)); 

// 等價于以下寫法
async function getJSON() {
  let url = 'https://api.github.com/users/ruanyf';
  try {
    let response = await fetch(url);
    return await response.json();
  } catch (error) {
    console.log('Request Failed', error);
  }
}
console.log(getJSON());	// 獲取到的json數(shù)據(jù)

export const winFetch = async ({
  url,
  description,
  method,
  body,
}: {
  url: string;
  description: string;
  method: string;
  body: { [key: string]: any };
}) => {
  console.info(description, url, body);

  const res = await new Promise((resolve, reject) => {
    window
      .fetch(baseURL + url, {
        method,
        headers: { 'content-type': 'application/json' },
        mode: 'cors',
        credentials: 'include',
        body: JSON.stringify(body),
      })
      .then((response) =>
        response?.json().then(
          (json) => resolve(json),
          (err) => reject(err),
        ),
      );
  });

  return { data: res } as { data: { data: { [key: string]: any } } };
};

export async function delete(body: { id: number }) {
  const res = await winFetch({
    url: '/aaa/bbb/delete/',
    description: '刪除信息',
    method: 'DELETE',
    body,
  });
  return res.data.data;
}

async function fetchText() {
  let response = await fetch('https://api.github.com/users/ruanyf');
  console.log(response.status); // 200
  console.log(response.statusText);	// 
}
fetchText()

async function fetchText() {
  let response = await fetch('/readme.txt');
  if (response.status >= 200 && response.status < 300) {
    return await response.text();
  } else {
    throw new Error(response.statusText);
  }
}

if (response.ok) {
  // 請求成功
} else {
  // 請求失敗
}

const response = await fetch(url);

for (let [key, value] of response.headers) { 
  console.log(`${key} : ${value}`);  
}

// 或者
for (let [key, value] of response.headers.entries()) { 
  console.log(`${key} : ${value}`);  
}

const response = await fetch(url);
response.headers.get()：根據(jù)指定的鍵名，返回鍵值。
response.headers.has()： 返回一個布爾值，表示是否包含某個標(biāo)頭。
response.headers.set()：將指定的鍵名設(shè)置為新的鍵值，如果該鍵名不存在則會添加。
response.headers.append()：添加標(biāo)頭。
response.headers.delete()：刪除標(biāo)頭。
response.headers.keys()：返回一個遍歷器，可以依次遍歷所有鍵名。
response.headers.values()：返回一個遍歷器，可以依次遍歷所有鍵值。
response.headers.entries()：返回一個遍歷器，可以依次遍歷所有鍵值對（[key, value]）。
response.headers.forEach()：依次遍歷標(biāo)頭，每個標(biāo)頭都會執(zhí)行一次參數(shù)函數(shù)。

const response = await fetch(url);
response.text()：得到文本字符串，用于獲取文本數(shù)據(jù)，比如 HTML 文件。
response.json()：得到 JSON 對象。
response.blob()：得到二進制 Blob 對象，例如讀取圖片文件，顯示在網(wǎng)頁上。
response.formData()：得到 FormData 表單對象，主要用在 Service Worker 里面，攔截用戶提交的表單，修改某些數(shù)據(jù)以后，再提交給服務(wù)器。
response.arrayBuffer()：得到二進制 ArrayBuffer 對象，主要用于獲取流媒體文件。

// 先使用了response.text()，就把 Stream 讀完了。
// 后面再調(diào)用response.json()，就沒有內(nèi)容可讀了，所以報錯。
let text =  await response.text();
let json =  await response.json();  // 報錯

const response1 = await fetch('flowers.jpg');
// response.clone()復(fù)制了一份 Response 對象，然后將同一張圖片讀取了兩次
const response2 = response1.clone();

const myBlob1 = await response1.blob();
const myBlob2 = await response2.blob();

image1.src = URL.createObjectURL(myBlob1);
image2.src = URL.createObjectURL(myBlob2);

const response = await fetch('flower.jpg');
// response.body.getReader()方法返回一個遍歷器
const reader = response.body.getReader();

while(true) {
  // 這個遍歷器的read()方法每次返回一個對象，表示本次讀取的內(nèi)容塊
  const {done, value} = await reader.read();
  // done屬性是一個布爾值，用來判斷有沒有讀完
  if (done) {
    break;
  }
  // value屬性是一個 arrayBuffer 數(shù)組，表示內(nèi)容塊的內(nèi)容，而value.length屬性是當(dāng)前塊的大小
  console.log(`Received ${value.length} bytes`)
}

fetch(url, optionObj)

const response = fetch(url, {
  method: "GET",
  headers: {
    "Content-Type": "text/plain;charset=UTF-8"
  },
  body: undefined,
  referrer: "about:client",
  referrerPolicy: "no-referrer-when-downgrade",
  mode: "cors", 
  credentials: "same-origin",
  cache: "default",
  redirect: "follow",
  integrity: "",
  keepalive: false,
  signal: undefined
});

method：HTTP 請求的方法，POST、DELETE、PUT都在這個屬性設(shè)置。

headers：一個對象，用來定制 HTTP 請求的標(biāo)頭。

body：POST 請求的數(shù)據(jù)體。

cache：指定如何處理緩存?？赡艿娜≈等缦拢?
/*
	default：默認(rèn)值，先在緩存里面尋找匹配的請求。
	no-store：直接請求遠程服務(wù)器，并且不更新緩存。
	reload：直接請求遠程服務(wù)器，并且更新緩存。
	no-cache：將服務(wù)器資源跟本地緩存進行比較，有新的版本才使用服務(wù)器資源，否則使用緩存。
	force-cache：緩存優(yōu)先，只有不存在緩存的情況下，才請求遠程服務(wù)器。
	only-if-cached：只檢查緩存，如果緩存里面不存在，將返回504錯誤。
*/
mode: 指定請求的模式?？赡艿娜≈等缦拢?
/*
	cors：默認(rèn)值，允許跨域請求。
	same-origin：只允許同源請求。
	no-cors：請求方法只限于 GET、POST 和 HEAD，并且只能使用有限的幾個簡單標(biāo)頭，不能添加跨域的復(fù)雜標(biāo)頭，相當(dāng)于提交表單所能發(fā)出的請求。
*/
credentials：指定是否發(fā)送 Cookie?？赡艿娜≈等缦拢?
/*
	same-origin：默認(rèn)值，同源請求時發(fā)送 Cookie，跨域請求時不發(fā)送。
	include：不管同源請求，還是跨域請求，一律發(fā)送 Cookie。
	omit：一律不發(fā)送。
*/
signal：指定一個 AbortSignal 實例，用于取消fetch()請求

keepalive：用于頁面卸載時，告訴瀏覽器在后臺保持連接，繼續(xù)發(fā)送數(shù)據(jù)。
/*
一個典型的場景就是，用戶離開網(wǎng)頁時，腳本向服務(wù)器提交一些用戶行為的統(tǒng)計信息。
這時，如果不用keepalive屬性，數(shù)據(jù)可能無法發(fā)送，因為瀏覽器已經(jīng)把頁面卸載了。
*/
redirect: 指定 HTTP 跳轉(zhuǎn)的處理方法?？赡艿娜≈等缦拢?
/*
	follow：默認(rèn)值，fetch()跟隨 HTTP 跳轉(zhuǎn)。
	error：如果發(fā)生跳轉(zhuǎn)，fetch()就報錯。
	manual：fetch()不跟隨 HTTP 跳轉(zhuǎn)，但是response.url屬性會指向新的 URL，response.redirected屬性會變?yōu)閠rue，由開發(fā)者自己決定后續(xù)如何處理跳轉(zhuǎn)。
*/
integrity：指定一個哈希值，用于檢查 HTTP 回應(yīng)傳回的數(shù)據(jù)是否等于這個預(yù)先設(shè)定的哈希值。
/*
比如，下載文件時，檢查文件的 SHA-256 哈希值是否相符，確保沒有被篡改
fetch('http://site.com/file', {
  integrity: 'sha256-abcdef'
});
*/
referrer: 用于設(shè)定fetch請求的referer標(biāo)頭。
/*
這個屬性可以為任意字符串，也可以設(shè)為空字符串（即不發(fā)送referer標(biāo)頭）。
*/
referrerPolicy: 用于設(shè)定Referer標(biāo)頭的規(guī)則?？赡艿娜≈等缦拢?
/*
	no-referrer-when-downgrade：默認(rèn)值，總是發(fā)送Referer標(biāo)頭，除非從 HTTPS 頁面請求 HTTP 資源時不發(fā)送。
	no-referrer：不發(fā)送Referer標(biāo)頭。
	origin：Referer標(biāo)頭只包含域名，不包含完整的路徑。
	origin-when-cross-origin：同源請求Referer標(biāo)頭包含完整的路徑，跨域請求只包含域名。
	same-origin：跨域請求不發(fā)送Referer，同源請求發(fā)送。
	strict-origin：Referer標(biāo)頭只包含域名，HTTPS 頁面請求 HTTP 資源時不發(fā)送Referer標(biāo)頭。
	strict-origin-when-cross-origin：同源請求時Referer標(biāo)頭包含完整路徑，跨域請求時只包含域名，HTTPS 頁面請求 HTTP 資源時不發(fā)送該標(biāo)頭。
	unsafe-url：不管什么情況，總是發(fā)送Referer標(biāo)頭。
*/

let controller = new AbortController();

fetch(url, {
  signal: controller.signal
});

controller.signal.addEventListener('abort',
  () => console.log('abort!')
);
// controller.abort()方法用于發(fā)出取消信號。這時會觸發(fā)abort事件，這個事件可以監(jiān)聽
controller.abort(); // 取消
// 可以通過controller.signal.aborted屬性判斷取消信號是否已經(jīng)發(fā)出
console.log(controller.signal.aborted); // true

let controller = new AbortController();
setTimeout(() => controller.abort(), 1000);

try {
  let response = await fetch('/long-operation', {
    signal: controller.signal
  });
} catch(err) {
  if (err.name == 'AbortError') {
    console.log('Aborted!');
  } else {
    throw err;
  }
}