前端：JS延長加載的方式有哪些？

么是JS延遲加載？

JS延遲加載，也就是等頁面加載完成之后再加載JavaScript文件

為什么讓JS實現延遲加載？

js的延遲加載有助于提高頁面的加載速度。

Js延遲加載的方式有哪些？一般有以下幾種方式：

·defer屬性

·async屬性

·動態創建DOM方式

·使用jQuery的getScript方法

·使用setTimeout延遲方法

·讓JS最后加載

1、defer屬性

HTML 4.01為<script>標簽定義了defer屬性。標簽定義了defer屬性元素中設置defer屬性，等于告訴瀏覽器立即下載，但延遲執行標簽定義了defer屬性。

用途：表明腳本在執行時不會影響頁面的構造。也就是說，腳本會被延遲到整個頁面都解析完畢之后再執行在<script>元素中設置defer屬性，等于告訴瀏覽器立即下載，但延遲執行

<!DOCTYPE html>
<html>
<head>
	<script src="test1.js" defer="defer"></script>
	<script src="test2.js" defer="defer"></script>
</head>
<body>
<!--這里放內容-->
</body>
</html>

說明：雖然<script>元素放在了<head>元素中，但包含的腳本將延遲瀏覽器遇到</html>標簽后再執行HTML5規范要求腳本按照它們出現的先后順序執行。在現實當中，延遲腳本并不一定會按照順序執行defer屬性只適用于外部腳本文件。支持HTML5的實現會忽略嵌入腳本設置的defer屬性

2、async屬性

HTML5 為<script>標簽定義了async屬性。與defer屬性類似，都用于改變處理腳本的行為。同樣，只適用于外部腳本文件。標簽定義了async屬性。與defer屬性類似，都用于改變處理腳本的行為。同樣，只適用于外部腳本文件。

目的：不讓頁面等待腳本下載和執行，從而異步加載頁面其他內容。異步腳本一定會在頁面 load 事件前執行。不能保證腳本會按順序執行

<!DOCTYPE html>
<html>
	<head>
		<script src="test1.js" async></script>
		<script src="test2.js" async></script>
	</head>
<body>
<!--這里放內容-->
</body>
</html>

async和defer一樣，都不會阻塞其他資源下載，所以不會影響頁面的加載。

缺點：不能控制加載的順序

3、動態創建DOM方式

//這些代碼應被放置在</ body>標簽前(接近HTML文件底部)
<script type="text/javascript">
	function downloadJSAtOnload() {
		varelement = document .createElement("script");
		element.src = "defer.js";
		document.body.appendChild(element);
	}
	if (window. addEventListener)
		window.addEventListener("load" ,downloadJSAtOnload, false);
	else if (window.attachEvent)
		window.attachEvent("onload", downloadJSAtOnload) ;
	else
		window. onload =downloadJSAtOnload;
</script>

4、使用jQuery的getScript()方法

$.getScript("outer.js" , function(){	//回調函數，成功獲取文件后執行的函數
	console.log(“腳本加載完成")
});

5、使用setTimeout延遲方法的加載時間延遲加載js代碼，給網頁加載留出更多時間

<script type="text/javascript" >
	function A(){
		$.post("/1ord/1ogin" ,{name:username,pwd:password},function(){
			alert("Hello");
		});
	}
	$(function (){
		setTimeout('A()', 1000);	//延遲1秒
	})
</script>

6、讓JS最后加載

把js外部引入的文件放到頁面底部，來讓js最后引入，從而加快頁面加載速度例如引入外部js腳本文件時，如果放入html的head中,則頁面加載前該js腳本就會被加載入頁面，而放入body中，則會按照頁面從上倒下的加載順序來運行JavaScript的代碼。所以我們可以把js外部引入的文件放到頁面底部，來讓js最后引入，從而加快頁面加載速度。

上述方法2也會偶爾讓你收到Google頁面速度測試工具的“延遲加載javascript”警告。所以這里的解決方案將是來自Google幫助頁面的推薦方案。

//這些代碼應被放置在</body>標簽前(接近HTML文件底部)

<script type= "text/javascript">
	function downloadJSAtonload() {
		var element = document.createElement("script");
		element.src = "defer.js";
		document.body.appendChild(element);
	}
	if (window.addEventListener)
		window.addEventListener("load", downloadJSAtOnload, false);
	else if (window.attachEvent )
		window.attachEvent("onload", downloadJSAtonload);
	else window.onload = downloadJSAtOnload;
</script>

這段代碼意思等到整個文檔加載完后，再加載外部文件“defer.js”。

使用此段代碼的步驟：

6.1）復制上面代碼

6.2）粘貼代碼到HTML的標簽前 (靠近HTML文件底部)

6.3）修改“defer.js”為你的外部JS文件名

6.4）確保文件路徑是正確的。例如：如果你僅輸入“defer.js”，那么“defer.js”文件一定與HTML文件在同一文件夾下。

注意：

這段代碼直到文檔加載完才會加載指定的外部js文件。因此，不應該把那些頁面正常加載需要依賴的javascript代碼放在這里。而應該將JavaScript代碼分成兩組。一組是因頁面需要而立即加載的javascript代碼，另外一組是在頁面加載后進行操作的javascript代碼(例如添加click事件。

在前面

今年國慶假期終于可以憋在家里了不用出門了，不用出去看后腦了，真的是一種享受。這么好的光陰怎么浪費，睡覺、吃飯、打豆豆這怎么可能（耍多了也煩），完全不符合我們程序員的作風，趕緊起來把文章寫完。

這篇文章比較基礎，在國慶期間的業余時間寫的，這幾天又完善了下，力求把更多的前端所涉及到的關于文件上傳的各種場景和應用都涵蓋了,若有疏漏和問題還請留言斧正和補充。

自測讀不讀

以下是本文所涉及到的知識點，break or continue ?

文件上傳原理
最原始的文件上傳
使用 koa2 作為服務端寫一個文件上傳接口
單文件上傳和上傳進度
多文件上傳和上傳進度
拖拽上傳
剪貼板上傳
大文件上傳之分片上傳
大文件上傳之斷點續傳
node 端文件上傳

原理概述

原理很簡單，就是根據 http 協議的規范和定義，完成請求消息體的封裝和消息體的解析，然后將二進制內容保存到文件。

我們都知道如果要上傳一個文件，需要把 form 標簽的enctype設置為multipart/form-data,同時method必須為post方法。

那么multipart/form-data表示什么呢？

multipart互聯網上的混合資源，就是資源由多種元素組成，form-data表示可以使用HTML Forms 和 POST 方法上傳文件，具體的定義可以參考RFC 7578。

multipart/form-data 結構

看下 http 請求的消息體

請求頭：

Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryDCntfiXcSkPhS4PN 表示本次請求要上傳文件，其中boundary表示分隔符，如果要上傳多個表單項，就要使用boundary分割，每個表單項由———XXX開始，以———XXX結尾。

消息體- Form Data 部分

每一個表單項又由Content-Type和Content-Disposition組成。

Content-Disposition: form-data 為固定值，表示一個表單元素，name 表示表單元素的名稱，回車換行后面就是name的值，如果是上傳文件就是文件的二進制內容。

Content-Type：表示當前的內容的 MIME 類型，是圖片還是文本還是二進制數據。

解析

客戶端發送請求到服務器后，服務器會收到請求的消息體，然后對消息體進行解析，解析出哪是普通表單哪些是附件。

可能大家馬上能想到通過正則或者字符串處理分割出內容，不過這樣是行不通的，二進制buffer轉化為string,對字符串進行截取后，其索引和字符串是不一致的，所以結果就不會正確，除非上傳的就是字符串。

不過一般情況下不需要自行解析，目前已經有很成熟的三方庫可以使用。

至于如何解析，這個也會占用很大篇幅，后面的文章在詳細說。

最原始的文件上傳

使用 form 表單上傳文件

在 ie時代，如果實現一個無刷新的文件上傳那可是費老勁了，大部分都是用 iframe 來實現局部刷新或者使用 flash 插件來搞定，在那個時代 ie 就是最好用的瀏覽器（別無選擇）。

DEMO

這種方式上傳文件，不需要 js ，而且沒有兼容問題，所有瀏覽器都支持，就是體驗很差，導致頁面刷新，頁面其他數據丟失。

HTML

 <form method="post" action="http://localhost:8100" enctype="multipart/form-data">

        選擇文件:
            <input type="file" name="f1"/> input 必須設置 name 屬性，否則數據無法發送<br/>
<br/>
            標題：<input type="text" name="title"/><br/><br/><br/>

        <button type="submit" id="btn-0">上 傳</button>

</form>

復制代碼

文件上傳接口

服務端文件的保存基于現有的庫koa-body結合 koa2實現服務端文件的保存和數據的返回。

在項目開發中，文件上傳本身和業務無關，代碼基本上都可通用。

在這里我們使用koa-body庫來實現解析和文件的保存。

koa-body 會自動保存文件到系統臨時目錄下，也可以指定保存的文件路徑。

然后在后續中間件內得到已保存的文件的信息，再做二次處理。

ctx.request.files.f1 得到文件信息，f1為input file 標簽的 name
獲得文件的擴展名，重命名文件

NODE

/**
 * 服務入口
 */
var http = require('http');
var koaStatic = require('koa-static');
var path = require('path');
var koaBody = require('koa-body');//文件保存庫
var fs = require('fs');
var Koa = require('koa2');

var app = new Koa();
var port = process.env.PORT || '8100';

var uploadHost= `http://localhost:${port}/uploads/`;

app.use(koaBody({
    formidable: {
        //設置文件的默認保存目錄，不設置則保存在系統臨時目錄下  os
        uploadDir: path.resolve(__dirname, '../static/uploads')
    },
    multipart: true // 開啟文件上傳，默認是關閉
}));

//開啟靜態文件訪問
app.use(koaStatic(
    path.resolve(__dirname, '../static') 
));

//文件二次處理，修改名稱
app.use((ctx) => {
    var file = ctx.request.files.f1;//得道文件對象
    var path = file.path;
    var fname = file.name;//原文件名稱
    var nextPath = path+fname;
    if(file.size>0 && path){
        //得到擴展名
        var extArr = fname.split('.');
        var ext = extArr[extArr.length-1];
        var nextPath = path+'.'+ext;
        //重命名文件
        fs.renameSync(path, nextPath);
    }
    //以 json 形式輸出上傳文件地址
    ctx.body = `{
        "fileUrl":"${uploadHost}${nextPath.slice(nextPath.lastIndexOf('/')+1)}"
    }`;
});

/**
 * http server
 */
var server = http.createServer(app.callback());
server.listen(port);
console.log('demo1 server start ......   ');
復制代碼

CODE

https://github.com/Bigerfe/fe-learn-code/

ava中類的加載順序介紹(ClassLoader)

1、ClassNotFoundExcetpion

我們在開發中，經常可以遇見java.lang.ClassNotFoundExcetpion這個異常，今天我就來總結一下這個問題。對于這個異常，它實質涉及到了java技術體系中的類加載。Java的類加載機制是技術體系中比較核心的部分，雖然它和我們直接打交道不多，但是對其背后的機理有一定理解有助于我們排查程序中出現的類加載失敗等技術問題。

2、類的加載過程

　一個java文件從被加載到被卸載這個生命過程，總共要經歷5個階段，JVM將類加載過程分為：（加鏈初使卸）

加載->鏈接（驗證+準備+解析）->初始化（使用前的準備）->使用->卸載

（1）加載

首先通過一個類的全限定名來獲取此類的二進制字節流；其次將這個字節流所代表的靜態存儲結構轉化為方法區的運行時數據結構；最后在java堆中生成一個代表這個類的Class對象，作為方法區這些數據的訪問入口。總的來說就是查找并加載類的二進制數據。

（2）鏈接：

驗證：確保被加載類的正確性；

準備：為類的靜態變量分配內存，并將其初始化為默認值；

解析：把類中的符號引用轉換為直接引用；

（3）為類的靜態變量賦予正確的初始值

3、類的初始化

（1）類什么時候才被初始化

1）創建類的實例，也就是new一個對象

2）訪問某個類或接口的靜態變量，或者對該靜態變量賦值

3）調用類的靜態方法

4）反射（Class.forName(“com.lyj.load”)）

5）初始化一個類的子類（會首先初始化子類的父類）

6）JVM啟動時標明的啟動類，即文件名和類名相同的那個類

（2）類的初始化順序

1）如果這個類還沒有被加載和鏈接，那先進行加載和鏈接

2）假如這個類存在直接父類，并且這個類還沒有被初始化（注意：在一個類加載器中，類只能初始化一次），那就初始化直接的父類（不適用于接口）

3）加入類中存在初始化語句（如static變量和static塊），那就依次執行這些初始化語句。

4）總的來說，初始化順序依次是：（靜態變量、靜態初始化塊）–>（變量、初始化塊）–> 構造器；

如果有父類，則順序是：父類static方法 –> 子類static方法 –> 父類構造方法- -> 子類構造方法

4、類的加載

類的加載指的是將類的.class文件中的二進制數據讀入到內存中，將其放在運行時數據區的方法區內，然后在堆區創建一個這個類的java.lang.Class對象，用來封裝類在方法區類的對象。如：

類的加載的最終產品是位于堆區中的Class對象。Class對象封裝了類在方法區內的數據結構，并且向Java程序員提供了訪問方法區內的數據結構的接口。加載類的方式有以下幾種：

1）從本地系統直接加載

2）通過網絡下載.class文件

3）從zip，jar等歸檔文件中加載.class文件

4）從專有數據庫中提取.class文件

5）將Java源文件動態編譯為.class文件（服務器）

5、加載器

JVM的類加載是通過ClassLoader及其子類來完成的，類的層次關系和加載順序可以由下圖來描述：

（1）加載器介紹

1）BootstrapClassLoader（啟動類加載器）

負責加載$JAVA_HOME中jre/lib/rt.jar里所有的class，加載System.getProperty(“sun.boot.class.path”)所指定的路徑或jar。

2）ExtensionClassLoader（標準擴展類加載器）

負責加載java平臺中擴展功能的一些jar包，包括$JAVA_HOME中jre/lib/*.jar或-Djava.ext.dirs指定目錄下的jar包。載System.getProperty(“java.ext.dirs”)所指定的路徑或jar。

3）AppClassLoader（系統類加載器）

負責記載classpath中指定的jar包及目錄中class

4）CustomClassLoader（自定義加載器）

屬于應用程序根據自身需要自定義的ClassLoader，如tomcat、jboss都會根據j2ee規范自行實現。

（2）類加載器的順序

1）加載過程中會先檢查類是否被已加載，檢查順序是自底向上，從Custom ClassLoader到BootStrap ClassLoader逐層檢查，只要某個classloader已加載就視為已加載此類，保證此類只所有ClassLoader加載一次。而加載的順序是自頂向下，也就是由上層來逐層嘗試加載此類。

2）在加載類時，每個類加載器會將加載任務上交給其父，如果其父找不到，再由自己去加載。

3）Bootstrap Loader（啟動類加載器）是最頂級的類加載器了，其父加載器為null。

參考博文：https://blog.csdn.net/eff666/article/details/52203406

例子補充：

繼承的加載順序

由于static塊會在首次加載類的時候執行，因此下面的例子就是用static塊來測試類的加載順序。

package xing.test.thinking.chap7;
class A{
 static{
 System.out.println("A static");
 }
}
class B extends A{
 static{
 System.out.println("B static");
 }
}
class C extends B{
 private static D d = new D();
 static{
 System.out.println("C static");
 }
}
class D{
 static{
 System.out.println("D static");
 }
}
public class ExtendTest {
 public static void main(String[] args) {
 C c = new C();
 }
}

在上面的例子中，類C繼承B，B繼承A，而C有依賴于D。因此當創建C的時候，會自動加載C繼承的B和依賴的D，然后B又會加載繼承的A。只有A加載完，才能順利的加載B；BD加載完，才能加載C。這就是類的加載順序了。

A static
B static
D static
C static

所有的變量初始化完，才會執行構造方法

在類的加載過程中，只有內部的變量創建完，才會去執行這個類的構造方法。

package xing.test.thinking.chap7;
class A2{
 B2 b2 = new B2();
 static{
 System.out.println("A static");
 }
 public A2() {
 System.out.println("A2()");
 }
}
class B2{
 C2 c2 = new C2();
 D2 d2 = new D2();
 static{
 System.out.println("B static");
 }
 public B2() {
 System.out.println("B2()");
 }
}
class C2{
 static{
 System.out.println("C static");
 }
 public C2() {
 System.out.println("C2()");
 }
}
class D2{
 static{
 System.out.println("D static");
 }
 public D2() {
 System.out.println("D2()");
 }
}
public class VarTest {
 public static void main(String[] args) {
 A2 a2 = new A2();
 }
}

在上面的例子中，A2里面有B2變量，B2則有C2D2變量。因此類的加載還是先讀取到哪個，就執行相應的靜態塊。

當依賴的對象都定義完，才會執行構造方法：

A static
B static
C static
C2()
D static
D2()
B2()
A2()

靜態成員與普通成員類的加載區別

在類的加載過程中，靜態成員類的對象，會優先加載；而普通成員類的對象則是使用的時候才回去加載。

package xing.test.thinking.chap7;
class A3{
 B3 b3 = new B3();
 static C3 c4 = new C3();
 static{
 System.out.println("A3");
 }
}
class B3{
 static{
 System.out.println("B3");
 }
}
class C3{
 static{
 System.out.println("C3");
 }
}
public class StaticTest {
 public static void main(String[] args) {
 A3 a3 = new A3();
 }
}

輸出:

C3
A3
B3

總結

第一點，所有的類都會優先加載基類

第二點，靜態成員的初始化優先

第三點，成員初始化后，才會執行構造方法

第四點，靜態成員的初始化與靜態塊的執行，發生在類加載的時候。

第四點，類對象的創建以及靜態塊的訪問，都會觸發類的加載。

補充類構造方法的順序

看代碼：

package xing.test.thinking.chap8;
class A{
 public A() {
 System.out.println("A");
 }
}
class B extends A{
 public B() {
 System.out.println("B");
 }
}
class C extends B {
 private D d1 = new D("d1");
 private D d2 = new D("d2");
 public C() {
 System.out.println("C");
 }
}
class D {
 public D(String str) {
 System.out.println("D "+str);
 }
}
public class ExtendTest {
 public static void main(String[] args) {
 C c = new C();
 }
}

執行結果：

A
B
D d1
D d2
C

因此可以得出結論：

首先會調用基類的構造方法
其次，調用成員的構造方法
最后，調用自己的構造方法

參考博文：https://www.cnblogs.com/xing901022/p/5507086.html

在線咨詢

上一篇：HTML 顏色
下一篇：Web開發中常見的“亂碼”

您的項目需求

*請認真填寫需求信息，我們會在24小時內與您取得聯系。

整合營銷服務商