在過往學習的JavaScript都是在基礎，現在為大家介紹更為深入的JavaScript知識。

　　JavaScript函數

　　JavaScript函數和Java函數是有一部分相似的，所以學習起來也會相對簡單

　　基本構造

　　1.直接構造

　　//function代表函數標志，name為函數名稱，參數可有可無
　　function name( 參數 ) {
　　//...
　　return;
　　}

　　2.賦值構造

　　//相當于function為匿名函數，然后匿名函數所得出的值返回給name，因而name可以調用function函數
　　var name = function( 參數 ){
　　//...
　　}

　　注意：

　　在JavaScript中，return的地位就是可有可無，但

　　當存在return時，運行到return，結束函數，并返回該值

　　當不存在return時，全部運行完畢，結束函數，返回underfined值

　　調用函數方法

　　當調用函數時，直接書寫函數名稱并加上相對應的參數即可

　　name(參數)；

　　注意：

　　JavaScript可以傳入與之不對應的參數

　　當參數傳入較多，參數進入函數但不代表函數內任意參數，只是單純傳入參數

　　當參數傳入較少，參數進入函數，后面未傳入的參數在函數內部以underfined的形式存在

　　函數參數argument和rest

　　argument代表函數中傳入進來的所有參數，是一個數組

　　我們可以在函數中使用：

　　function name( ) {
　　//...
　　console.log(arguments[0])，
　　console.log(arguments[1])，
　　//...
　　}

　　rest代表函數中傳入進來的未定義的參數，需要提前在函數中定義

　　我們同樣可以在函數中使用：　

　var names = function(name,age,...rest){
　　//...
　　console.log(name);
　　console.log(age);
　　for(var value of rest){
　　console.log(value)
　　}
　　}

　　代碼調試

　　我們針對上面所有知識點給出相應代碼示例：

　　//我們演示argument
　　function name( ) {
　　//...
　　console.log(arguments[0])
　　}
　　//我們演示rest
　　var names = function(name,age,...rest){
　　//...
　　console.log(name);
　　console.log(age);
　　for(var value of rest){
　　console.log(value)
　　}
　　}

　　下面我們在網頁中進行調試：

　　name(1,2,3,"胡桃",true)

　　1

　　names("胡桃",18,"護膜","魔女")

　　胡桃

　　18

　　護膜

　　魔女

　　變量的作用域

　　對于任何含有變量的語言，作用域是必定存在的

　　對于JavaScript，var所定義的變量實際上也是存在作用域的

　　函數體內變量作用域解釋

　　1.假如在函數體中聲明，則在函數體外不可以使用

　　function test1() {
　　var x=1;
　　x=x+1;
　　}
　　x=x+2;//Uncaught ReferenceError: x is not defined

　　2.如果兩個函數使用了相同的變量名，只要在函數內部，則不產生沖突

　　function test1() {
　　var x=1;
　　x=x+1;
　　}
　　function test2(){
　　var x=1;
　　x=x+2;
　　}

　　3.內部函數可以使用外部函數的成員，但外部函數不能使用內部函數的成員

　　function test3(){
　　var x=1;
　　//內部函數使用外部函數的成員
　　function indextest(){
　　var y=1;
　　x = x+1;
　　console.log(x);
　　}
　　indextest();
　　//外部函數不可以使用內部函數成員
　　y=y+1;//Uncaught ReferenceError: y is not defined
　　}

　　4.當內部函數變量和外部函數變量重名時，由內向外查找，就近原則

　　function test4(){
　　var x=1;
　　function indextest() {
　　var x=2;
　　console.log(x);
　　}
　　indextest();//這里結果為2
　　}

　　良好的變量定義格式

　　我們在JavaScript函數中定義變量時，常常將所有變量在頭部定義完全，然后在后面使用

　　function test5(){
　　//在開頭定義好所有變量
　　var x=3,y=2,z,name;
　　//在后面可以隨便使用變量
　　x=x+2;
　　z=x+y;
　　}

　　全局變量

　　全局變量常常帶有window前綴，但默認帶有，所以不需要書寫

　　window屬于JavaScript下的一個對象，window之下包含我們所定義的全局變量以及各種函數方法

　　function test6(){
　　var x = 1;
　　//下面所輸出的x均為上方所定義的全局變量x
　　console.log(x);
　　console.log(window.x);
　　//下面所使用的alert和window.alert具有相同代碼相同作用
　　alert(x);
　　window.alert(x);
　　}

　　我們也可以通過重新定義window下的函數方法來更改該函數原有的操作

　　//在下述操作之后，alert不會產生輸出作用
　　window.alert = function() {
　　}
　　alert("Hello");

　　注意：

　　JavaScript實際上只有一個全局作用域，任何變量（包括函數），假如沒有在函數作用域內找到，就會向外查找，若在全局作用域內均未查找到，則報錯RefrenceError

　　局部變量

　　在JavaScript的ES5中會出現變量作用域過大導致代碼沖突的結果：

　　function test7(){
　　for(var x=1;x<10;x++){
　　console.log(x);
　　}
　　// 我們希望x的作用域只在for中，但它仍會被帶出for
　　x=x+1;
　　}

　　JavaScript在ES6中加入了新的定義類型let用來定義局部變量

　　function test7(){
　　for(let x=1;x<10;x++){
　　console.log(x);
　　}
　　//x則只在for中有作用
　　console.log(x);//Uncaught ReferenceError: x is not defined
　　}

　　常量Const

　　在JavaScript的ES6之前，我們定義常量只是采用常識約束：

　　我們假設全大寫字母的變量為常量

　　但實際上是可以修改的

　　//我們定義PI
　　var PI = 3.14；
　　//但我們仍舊可以修改
　　PI = 3.33；

　　但在JavaScript的ES6中，提供了const定義類型，它所定義的變量是真正的常量，是允許修改的：

　　//我們定義PI
　　const PI = 3.14;
　　//我們無法修改，下述代碼報錯
　　PI = 3.33;

　　方法的定義和調用

　　方法的物理定義：

　　對象中只存在兩種東西：屬性和方法

　　對象中的函數被我們稱為方法

　　方法示例

　　我們給出方法的示例：

　　var student = {
　　//對象中包含屬性
　　name:"胡桃",
　　//對象中包含方法
　　sing:function(){
　　//this指向當前對象的屬性
　　console.log(this.name + "在唱歌")
　　}
　　}
　　//我們在調用方法時，需要帶上對象并且加上（）
　　student.sing();

　　This和Apply的區別

　　我們稍微講解一下對象方法中的This和Apply：

　　This：無法指向，只能在對象的方法中出現，并且固定指向自身對象的屬性

　　Apply：可以控制this指向，在調用含有this的函數時調用，第一個參數是對象，后面是所需參數

　　我們給出案例進行講解：

　　//首先我們給出一個外部函數來計算年齡：
　　function getAge(){
　　//這里采用了Date內置對象，我們后面會講到，這里是獲得當前年份
　　var nowTime = new Date().getFullYear();
　　return nowTime - this.birth;
　　}
　　//我們創建一個對象(直接調用getAge，相當于this的使用)
　　var hutao = {
　　name:"胡桃",
　　birth:2002,
　　age: getAge
　　}
　　//我們直接對getAge采用apply方法，使其this指向hutao
　　//第一個參數是對象，后面均為參數所需值
　　getAge.apply(hutao,[]);

　　我們給出網頁端的操作:

　　//我們需要調用age時，是采用的age（）方法
　　console.log(hutao.age())
　　20
　　//這里采用getAge的apply方法
　　getAge.apply(hutao,[]);
　　20

　　內部對象

　　JavaScript的內部對象類似于我們Java中的常見類

　　它們同樣都是由他人創造并存在于JavaScript中，我們可以直接調用幫助我們編程

　　標準類型

　　我們先來介紹一些標準類型便于內部對象的講解

　　我們先給出一個新的方法，用于分析其類型：

　　typeof 類型對象

　　我們給出案例：

　　typeof 123

　　'number'

　　typeof "123"

　　'string'

　　typeof true

　　'boolean'

　　typeof []

　　'object'

　　typeof Math.abs

　　'function'

　　typeof undefined

　　'undefined'

　　Date日期對象

　　首先我們給出日期對象的定義方法：

　　var name = new Date();

　　我們通過日期對象來進行一些方法操作：

　　我們同時提供一些Date對象輸出日期的不同寫法（這里在網頁示例）：

　　now = new Date()
　　Thu Jul 14 2022 13:27:07 GMT+0800 (中國標準時間)
　　now.toLocaleString()
　　'2022/7/14 13:27:07'
　　now.toGMTString()
　　'Thu, 14 Jul 2022 05:27:07 GMT'

　　JSON字符串

　　我們先來介紹一下JSON：

　　在早期，所有數據傳輸都采用XML文件，但后來開始采用JSON傳輸

　　JSON是一種輕量級的數據交換格式

　　簡潔和清晰的層次結構使得JSON成為理想的數據交換語言

　　益于人的閱讀和書寫，也易于機器解析和生成，有效地提升了網絡傳輸效率

　　在JavaScript中一切皆為對象，任何JS所支持的類型都是對象

　　格式：

　　對象都采用{}

　　數組都采用[]

　　鍵值對都采用 key:value

　　我先在這里講解一下JSON的格式，并且給出對象進行對比：

　　//對象具有對象的形式
　　var obj = {
　　name:"萬葉",
　　eyes:"風"
　　}
　　//JSON雖然和對象相似，但實際上是字符串，內部所有元素都有"""所包圍
　　var json = '{"name":"萬葉","eyes":"風"}'

　　最后我們給出JSON和對象之間的轉換：

　　var obj = {
　　name:"萬葉",
　　eyes:"風"
　　}
　　//對象轉化為JSON字符串
　　var jsonUser = JSON.stringify(obj);
　　//JSON字符串轉化為對象
　　var wanye = JSON.parse('{"name":"萬葉","eyes":"風"}')

　　面向對象編程

　　首先面向對象編程是什么呢？

　　面向對象都具有一個模板類

　　我們根據模板類來產生對象并對其進行操作

　　JavaScript的類和對象

　　JavaScript的面向對象與其他面向對象有一點區別：

　　//我們先給出一個整體對象（類似于類，但類需要寫有數據）
　　var Student = {
　　name:"name",
　　age:18,
　　run:function() {
　　console.log(this.name + "running!")
　　}
　　};
　　//我們創建一個對象
　　var xiaoming = {
　　name:"xiaoming"
　　}
　　//然后我們讓小明的本源指向Student對象
　　xiaoming._proto_ = Student;
　　//下面是網頁測試給出的結果，我們可以看到xiaoming繼承了Student的方法
　　// xiaoming
　　// {name: 'xiaoming', _proto_: {…}}
　　// name: "xiaoming"
　　// _proto_: {name: 'name', age: 18, run: ?}
　　// [[Prototype]]: Object

　　但是在ES6版本之后，JavaScript給出了class關鍵字，具體化了類這個概念：

　　class定義模板：

　　class name{
　　//...
　　}

　　下面給出class案例：

　　class Student{
　　//class配置的constructor方法，用來創造對象的屬性
　　constructor(name){
　　this.name = name;
　　}
　　//方法直接在下面書寫即可
　　run(){
　　console.log(this.name + "running");
　　}
　　}
　　//創建新對象的方法（需要把所需參數寫入）
　　var yebao = new Student("yebao");

　　我們給出網頁調試結果：

　　yebao

　　Student{name: 'yebao'}

　　yebao.name

　　'yebao'

　　yebao.run()

　　4.html:19 yebaorunning

　　JavaScript進階之函數和對象詳細知識內容就先講到這里