嘍，大家好，這里是雷工筆記！

我們只管努力，剩下交給天意，或許哪天用的到，總比多刷半小時視頻要有意義吧。

一、常量

1、概念：使用const聲明的變量稱為“常量”。

2、應用場景：當某個變量永遠不會改變時，就能夠使用const 來聲明，而不是let。

3、命名規范：與變量一樣。

示例：

//聲明一個常量
const P=3.14
//輸出這個常量
console.log(P)

注意事項：常量不允許重新賦值，聲明的時候必須初始化。

提醒：不需要重新賦值的數據使用const。

二、const，let，var之間的區別：

1、在程序中如果值不會發生變化或不能改變，推薦使用const。

2、在程序中如果值不斷地發生改變，那么推薦使用let（var）。

3、const定義的常量必須設置默認值。

4、const定義的常量名不能重復。

5、const定義的常量必須先定義后使用。

三、后記

以上為JavaScript常量的基礎知識，比較簡單，一看就懂，想忘都難。

avaScript的組成部分

1. ECMAScript：JavaScript的核心，描述了語言的基本語法(var、for、if、array等)和數據類型(數字、字符串、布爾、函數、對象(obj、[]、{}、null)、未定義)。
2. 文檔對象模型：DOM（文檔對象模型）是 HTML 和 XML 的應用程序接口（API）。DOM 將把整個頁面規劃成由節點層級構成的文檔。
3. 瀏覽器對象模型：BOM（瀏覽器對象模型）對瀏覽器窗口進行訪問和操作。例如彈出新的瀏覽器窗口，移動、改變和關閉瀏覽器窗口等等。

JavaScript關鍵字和保留字

JavaScript描述了一組具有特定用途的關鍵字，一般用于控制語句的開始或結束，或者用于執行特定的操作等。

JavaScriptScript全部關鍵字
?

JavaScript還描述了另一組不能用作標識符的保留字。盡管保留字在JavaScript中還沒有特定的用途，但它們很有可能在將來被用作關鍵字。

?JavaScriptScript全部保留字
?

?JavaScriptScript瀏覽器定義的保留字
?

JavaScript變量

什么是變量？

1. 在JavaScript中，變量指的是一個可以改變的量。也就是說，變量的值在程序運行過程中是可以改變的。
2. 變量是用于存儲數據的"容器"。我們通過「變量名」獲取數據，甚至可以修改數據。
3. 變量的本質是程序在內存中申請的一塊用來存放數據的空間。

變量的命名

1.變量的名字就和我們的名字一樣，程序也需要通過名字來找到對應的數據。

例如：曹老師，我想要JavaScript的視頻。曹老師就是變量的名字，JavaScript的視頻就是變量的值。

2.在JavaScript中，給一個變量命名，我們需要遵循以下的原則：

• 變量必須以字母開頭
• 變量也能以 $ 和 _ 符號開頭（不過我們不推薦這么做）
• 變量名稱對大小寫敏感（y 和 Y 是不同的變量）
• JavaScript 語句和 JavaScript 變量都對大小寫敏感
• 變量的聲明不能使用保留字和關鍵字

變量的使用

1.定義變量時要使用var操作符（var是關鍵），后面跟一個變量名（變量名是標識符）。

例：var a=100;

如下圖所示：

全套前端課程及資料請伽薇xiaole45666

2.一個var也可以同時聲明多個變量名，其中變量名之間必須用英文逗號（,）隔開，例如：

var a=10,b=20,c=30;

JavaScript的常量

在JavaScript中，常量指的是一個不能改變的量。也就是說，常量的值從定義開始就是固定的，一直到程序結束都不會改變。

在JavaScript中，我們可以把常量看成是一種特殊的變量，之所以特殊，是因為它的值是不會變的。一般情況下，常量名全部大寫，別人一看就知道這個值很特殊，有特殊用途，如：var DEBUG=1

目前我們只需要簡單了解常量的知識，在之后的課程中我們會詳細講解。如需全套完整前端開發教程及配套資料請伽薇xiaole45666

應該是JavaScript系列教程第三期，這期準備講一下數據類型，常量以及變量的定義。

任何的編程語言都有自己的數據類型與數據結構，那么JavaScipt也有自己的數據類型，可以將其分為基本數據類型與引用數據類型！基本數據類型指的是簡單的數據段，引用數據類型指的是有多個值構成的對象。當我們把變量賦值給一個變量時，解析器首先要確認的就是這個值是基本類型值還是引用類型值。

在JavaScipt 中，基本類型（基本數值、基本數據類型）是一種既非對象也無方法或屬性的數據。有 7 種原始數據類型：

基本數據類型是保存在棧中的，存取的速度比較快。

引用數據類型我們通常統稱為Object類型，大致上分為一下5種：

引用數據類型是保存在堆當中的，這樣說可能不準確，準確的說法應該是引用數據類型的對象保存在了堆當中。

將堆和棧進行一下對比：

我們定義一個基本數據類型在棧中，應該是以下的情況。

上面的栗子就是定義了

const a = 1const b = 2const c = 3const d = 4

以上看起來是挺簡單的一對一的形式儲存的。

我們同樣來定義一下引用數據類型：

const e = new Object()const f = ee.name = 'orange'

以上代碼的存儲形式應該如下：

解釋一下上面圖片，左邊是一個棧，定義了一個引用數據類型，名稱叫做e，然后e在堆中開辟了一個空間，有了一個地址，所以棧中的值就是這個空間的地址，然后又定義了一個引用數據類型，叫做f，把e賦值給f，這個時候值也是指向了這個空間的地址。最后給這個空間加了一個值，name:'orange'。最后就是e和f其實是一個東西了。

如果你沒有聽清楚，沒搞明白，我來給你簡單翻譯一下！

假如你有一個空地，這個空地就是棧，然后這個空地上面來了a,b,c,d,e,f這幾個人（也就是名稱），然后呢a.b,c,d這四個人都是本地人，就在這個空地上修了個房間（也就是值），分別放了1,2,3,4。但是呢，e,f他不是本地人，人家有自己房子，跑到你的地方來了，他也修了東西，但是只是一個門，這個地址（也就是值）是他家（也就是堆），剛好f和e是一家人，所以就用了e的門，也通向了這個家（堆）。

不知道以上的解釋清楚了沒，在不清楚的話，私信我，我去做個動畫給你描述清楚！?。?！

在代碼中，我們是怎么判斷數據類型的，數據類型怎么轉化呢？

我們有很多方法可以用來判斷。

• typeof 基本只能判斷出基本數據類型，引用類型除了function外，都是 object 。

const typeOf = () => {    // 基本類型    console.log(typeof(1)); //number    console.log(typeof('1')); //string    console.log(typeof(null)); //object    console.log(typeof(false)); //boolean    console.log(typeof(undefined)); //undefined    console.log(typeof(Symbol())); //symbol    console.log(typeof(NaN)); //number    // 引用類型    console.log(typeof {}); //object    console.log(typeof []); //object    console.log(typeof Error('1')); //object    function A() {}    console.log(typeof A); //function}typeOf()

• instanceof 返回是true或false，只能對引用數據類型進行判斷。

const instanceOf = () => {    // 基本類型    console.log(1 instanceof Number); //false    console.log("1" instanceof String); //false    console.log(true instanceof Boolean); //false    console.log(null instanceof Object); //false    console.log(undefined instanceof Object); //false    console.log(Symbol() instanceof Symbol); //false    // 引用類型    console.log({} instanceof Object); //true    console.log([] instanceof Array); //true    console.log(Error('1') instanceof Error); //true    function A() {}    console.log(A instanceof Function); //true}instanceOf()

• Object.prototype.toString.call() 返回是一個[object xxx]的字符串，可以通過slice(8, -1)的方式來獲取完整的數據類型。

const stringCall = () => {    // 基本類型    console.log(Object.prototype.toString.call(1)); //[object Number]    console.log(Object.prototype.toString.call(1).slice(8, -1)) //Number    console.log(Object.prototype.toString.call('1').slice(8, -1)) //String    console.log(Object.prototype.toString.call(true).slice(8, -1)) //Boolean    console.log(Object.prototype.toString.call(null).slice(8, -1)) //Null    console.log(Object.prototype.toString.call(undefined).slice(8, -1)) //Undefined    console.log(Object.prototype.toString.call(NaN).slice(8, -1)) //Number    console.log(Object.prototype.toString.call(Symbol()).slice(8, -1)) //Symbol    // 引用數據類型    console.log(Object.prototype.toString.call({}).slice(8, -1)) //Object    console.log(Object.prototype.toString.call([]).slice(8, -1)) //Array    console.log(Object.prototype.toString.call(Error('1')).slice(8, -1)) //Error    function A() {}    console.log(Object.prototype.toString.call(A).slice(8, -1)) //Function}stringCall()

• 即可以判斷基本數據類型，也可以判斷引用數據類型，由于null和undefined沒有constructor，所以判斷不了，同時由于constructor可以改變，所以此方法如果改寫了constructor，就不準確了。

const constructorName = () => {    // 基本數據類型    console.log((1).constructor.name); //Number    console.log('1'.constructor.name); //String    // console.log((null).constructor.name); //報錯 Cannot read properties of null (reading 'constructor')    // console.log((undefined).constructor.name); //報錯 Cannot read properties of undefined (reading 'constructor')    console.log((true).constructor.name); //Boolean    console.log((NaN).constructor.name); //Number    console.log((Symbol()).constructor.name); //Symbol    // 引用數據類型    console.log(({}).constructor.name); //Object    console.log(([]).constructor.name); //Array    console.log((Error('1')).constructor.name); //Error    function A() {}    console.log((A).constructor.name); //Function}constructorName()

• 可以判斷基本數據類型，也可以判斷引用數據類型，由于null和undefined沒有constructor，所以判斷不了。因為constructor.toString().indexOf()也是用到了constructor，所以如果該寫了constructor后，就不準確了。

const toStringIndexOf = () => {    // 基本數據類型    console.log((1).constructor.toString()); //function Number() { [native code] }    console.log((1).constructor.toString().indexOf('Number') > -1) //true    console.log(('1').constructor.toString().indexOf('String') > -1) //true    // console.log((null).constructor.toString().indexOf('Null') > -1) //報錯，Cannot read properties of null (reading 'constructor')    // console.log((undefined).constructor.toString().indexOf('Undefined') > -1) //報錯， Cannot read properties of undefined (reading 'constructor')    console.log((Symbol()).constructor.toString().indexOf('Symbol') > -1) //true    console.log((true).constructor.toString().indexOf('Boolean') > -1) //true    console.log((NaN).constructor.toString().indexOf('Number') > -1) //true    // 引用數據類型    console.log(({}).constructor.toString().indexOf('Object') > -1) //true    console.log(([]).constructor.toString().indexOf('Array') > -1) //true    console.log((Error('1')).constructor.toString().indexOf('Error') > -1) //true    function A() {}    console.log((A).constructor.toString().indexOf('Function') > -1) //true}toStringIndexOf()

• 改寫constructor

const num = new Number(1)console.log((num).constructor.name); //Numberconsole.log((num).constructor.toString().indexOf('Number') > -1) //truefunction A() {}num.constructor = Aconsole.log((A).constructor.name); //Functionconsole.log((A).constructor.toString().indexOf('Function') > -1) //true

這里說的類型轉換是字符串和數值之間的轉換。

• toString()，18.toString()

• String()，String(18)

• 拼接，18+''

以上三種辦法都可以將數值類型轉化為字符串類型。

• Number()，Number('18')

• parseInt()，parseInt('18')

• parseFloat()，parseFloat('18')

• +或-，-'18'或者+'18'

以上四種方法都可以將字符串轉化為字符串。

我們在定義的時候，分為常量與變量，一般可以使用var,const,let來定義。

es5的時候我們都是用var來定義常量與變量。但是很容易造成變量提升或者變量的全局污染。所以我們現在很少使用這個了。

es6的方法，使用const來定義常量與變量。比如定義基礎數據類型的常量，const a=1，這個就是定義一個a 的常量，不可以更改。這里的不可以更改指的是基礎數據類型不能更改，引用數據類型不能更改其類型，但是可以更改其值。

const a = 1const b = { name:'orange', age:18}// 修改aa = 2 //這個肯定要報錯的b.age = 20 //這個可以更改

這也是es6的語法，使用let定義變量，不管是基礎數據類型還是引用數據類型都可以，同時可以更改。

let a = 1let b = {  name:'orange',  age:18}// 修改aa = 2b.age = 20b = 3