การสนทนาเชิงลึกเกี่ยวกับ JavaScript

TypeScript จะแทนที่ JavaScript หรือไม่

1. TypeScript นำมาซึ่งการคิดแบบพิมพ์เท่านั้น เนื่องจาก JavaScript เองไม่มีข้อจำกัดประเภทใดๆ เกี่ยวกับตัวแปร พารามิเตอร์ฟังก์ชัน ฯลฯ มาเป็นเวลานาน สิ่งนี้อาจนำความเสี่ยงด้านความปลอดภัยมาสู่โปรเจ็กต์ของเรา
2. ต่อมาชุดของรูปแบบข้อจำกัดประเภทปรากฏใน JavaScript ชุมชน.
   

เพื่อ

1. ทำการตรวจสอบประเภทบน JavaScript

3.Type มีต้นกำเนิดมาจาก JavaScript และเป็นของ

JavaScript

ไม่ว่า JavaScript ที่เราเขียนจะถูกส่งมอบให้กับเบราว์เซอร์ หรือการทำงานของ Node สุดท้ายแล้ว CPU จะต้องดำเนินการ ดังนั้น เราจึงจำเป็นต้องมีกลไก JavaScript เพื่อช่วยเราแปลโค้ด JavaScript เป็นคำสั่ง ของ CPU เพื่อดำเนินการ

ความสัมพันธ์ ระหว่างเคอร์เนลของเบราว์เซอร์และเอ็นจิ้น JS

ที่นี่เราใช้ WebKit เนื่องจากจริงๆ แล้ว WebKit ประกอบด้วยสองส่วน
WebCore: รับผิดชอบการแยกวิเคราะห์ HTML เลย์เอาต์ การเรนเดอร์ และงานอื่น ๆ ที่เกี่ยวข้อง

สภาพแวดล้อมตัวแปร

โค้ด JavaScript

ตัวแปร VO (Variable Object) ในมาตรฐาน ECMA ล่าสุด VO มีชื่ออื่นสำหรับสภาพแวดล้อมตัวแปร VE

GO (Clobal Object) อ็อบเจ็กต์โกลบอลและบริบทการดำเนินการโกลบอล

AO (Activation Objece) ) ) รวมถึง

การจัดการหน่วยความจำบริบทการดำเนินการฟังก์ชันและ

1. การจัดการหน่วยความจำที่รับรู้

การจัดการหน่วยความจำ JS

JavaScript จะจัดสรรหน่วยความจำให้เราเมื่อกำหนดตัวแปร
JS จัดสรรหน่วยความจำสำหรับประเภทข้อมูลพื้นฐานโดยตรงในพื้นที่สแต็กระหว่างการดำเนินการ
การจัดสรรหน่วยความจำของ JS สำหรับประเภทข้อมูลที่ซับซ้อนจะเปิดพื้นที่ในหน่วยความจำฮีป และอ้างอิงถึงตัวแปรค่าส่งคืนของตัวชี้ของพื้นที่นี้

การรวบรวมขยะของ JS

เพราะ ขนาดของหน่วยความจำมีจำกัด ดังนั้นเมื่อหน่วยความจำไม่มีอีกต่อไป จำเป็น เราจะต้องออกเพื่อเพิ่มพื้นที่หน่วยความจำเพิ่มเติม

ในภาษาอังกฤษคือ Garbage Collection หรือ GC
สำหรับอ็อบเจ็กต์ที่ไม่ได้ใช้อีกต่อไป เราเรียกพวกมันว่าขยะ พวกมันจำเป็นต้องรีไซเคิลเพื่อปล่อยพื้นที่หน่วยความจำเพิ่มเติม เช่น สภาพแวดล้อมรันไทม์ของ Java JVM และเอ็นจิ้น js ของสภาพแวดล้อมรันไทม์ของ JavaScript จะเป็นตัวรวบรวมขยะของหน่วยความจำ คนเก็บขยะ เรายังเรียกมันว่า GC สั้น ๆ ดังนั้นในหลาย ๆ ที่คุณจะเห็นว่า GC หมายถึงคนเก็บขยะจริง ๆ

คือ

คำจำกัดความของการปิดในวิทยาการคอมพิวเตอร์ (วิกิพีเดีย):
การปิด (อังกฤษ: การปิด) หรือที่เรียกว่าการปิดคำศัพท์ (การปิดคำศัพท์) หรือการปิดฟังก์ชั่น (การปิดฟังก์ชั่น);
เป็นเทคโนโลยีที่ใช้การเชื่อมโยงคำศัพท์ในภาษาการเขียนโปรแกรมที่รองรับฟังก์ชันชั้นหนึ่ง
ในการนำไปใช้งาน การปิดเป็นโครงสร้างที่เก็บฟังก์ชันและสภาพแวดล้อมที่เกี่ยวข้อง (เทียบเท่ากับตารางค้นหาสัญลักษณ์)
ความแตกต่างที่ใหญ่ที่สุดระหว่างการปิดและฟังก์ชันก็คือ เมื่อการปิดถูกดักจับ ตัวแปรอิสระ ของมันจะถูกกำหนด ณ เวลาของการดักจับ เพื่อให้สามารถทำงานได้ตามปกติแม้ว่าจะอยู่นอกบริบท ณ เวลาที่จับภาพ

ก็ตาม แนวคิดของการปิดปรากฏในทศวรรษ 1960 โปรแกรมแรกสุดที่ใช้การปิดคือ Scheme ดังนั้นเราจึงเข้าใจได้ว่าเหตุใดจึงมีการปิดใน JavaScript
เนื่องจากการออกแบบจำนวนมากใน JavaScript มาจาก Scheme

มาดูคำอธิบายของ MDN เกี่ยวกับการปิด JavaScript:
ฟังก์ชันถูกรวมเข้ากับการอ้างอิงถึงสถานะโดยรอบ (สภาพแวดล้อมของศัพท์) (หรือฟังก์ชันถูกล้อมรอบด้วยการอ้างอิง) การรวมกันนี้คือการปิด การปิดช่วยให้คุณเข้าถึงฟังก์ชันภายในขอบเขตได้ ของฟังก์ชันภายนอก
ใน JavaScript เมื่อใดก็ตามที่มีการสร้างฟังก์ชัน การปิดจะถูกสร้างขึ้นพร้อมกับฟังก์ชันที่ถูกสร้างขึ้น

;
    ชื่อ var = 'ทำไม'
    อายุ = 18
    แถบฟังก์ชัน() {
        console.log('บาร์',ชื่อ)
    -
    return bar}var fun = foo()fun()

สรุป:
ฟังก์ชั่นฟังก์ชั่นธรรมดาคือการปิดถ้าสามารถเข้าถึงตัวแปรอิสระที่ชั้นนอกทำหน้าที่ได้
จากมุมมองที่กว้าง: ฟังก์ชันใน JavaScript เป็นแบบปิด;
จากมุมมองที่แคบ: หากฟังก์ชันใน JavaScript เข้าถึงตัวแปรภายนอก จะเป็นการปิดตัวลง

ซึ่งชี้

ไปที่ขอบเขตส่วนกลาง:
เบราว์เซอร์: หน้าต่าง
สภาพแวดล้อมของโหนด: {}

ฟังก์ชั่นลูกศร ฟังก์ชั่นลูก

ศร ฟังก์ชั่นลูกศรเป็นวิธีการเขียนฟังก์ชั่นที่เพิ่มหลังจาก ES6 และมีความกระชับมากกว่าการแสดงออกของฟังก์ชั่น
ฟังก์ชันลูกศรจะไม่ผูกคุณลักษณะนี้และอาร์กิวเมนต์
ไม่สามารถใช้ฟังก์ชันลูกศรเป็นตัวสร้างได้ (ไม่สามารถใช้กับฟังก์ชันใหม่ได้ ข้อผิดพลาดจะเกิดขึ้น)

การทำความเข้าใจอาร์กิวเมนต์

คืออาร์เรย์ (แบบหลอก) (คล้ายอาร์เรย์) ที่สอดคล้องกับพารามิเตอร์ที่ส่งผ่านไปยังฟังก์ชันที่เข้าใจถึง

ฟังก์ชัน

JavaScript ล้วนๆ

มีแนวคิดที่สำคัญมากในการเขียนโปรแกรมเชิงฟังก์ชันที่เรียกว่าฟังก์ชันบริสุทธิ์ JavaScript สอดคล้องกับข้อกำหนดของการเขียนโปรแกรมเชิงฟังก์ชัน ดังนั้นจึงมีแนวคิดเกี่ยวกับ

คำจำกัดความของฟังก์ชันบริสุทธิ์ในวิกิพีเดีย:
ในการเขียนโปรแกรม หากฟังก์ชันตรงตามเงื่อนไขต่อไปนี้ ฟังก์ชันนี้เรียกว่าฟังก์ชันบริสุทธิ์ เมื่อฟังก์ชันมีค่าอินพุตเท่ากัน ฟังก์ชันเอาต์พุตของฟังก์ชันจะไม่เกี่ยวข้องกับข้อมูลที่ซ่อนอยู่อื่นๆ หรือสถานะอื่นนอกเหนือจากค่าอินพุต ฟังก์ชันที่ไม่เกี่ยวข้องกับเอาต์พุตภายนอกที่สร้างโดยอุปกรณ์ I/O ไม่สามารถมีผลข้างเคียงของฟังก์ชันที่สังเกตได้เชิงความหมาย เช่น "การทริกเกอร์เหตุการณ์" ทำให้อุปกรณ์เอาต์พุตเอาต์พุต หรือการเปลี่ยนแปลงเนื้อหาของอ็อบเจ็กต์อื่นนอกเหนือจากค่าเอาต์พุต . สรุป:
อินพุตที่กำหนดจะต้องสร้างเอาต์พุตที่แน่นอน
ในระหว่างการทำงานของฟังก์ชัน จะไม่มีผลข้างเคียงเกิดขึ้น

:

JavaScript Currying

Currying ยังเป็นแนวคิดที่สำคัญมากในการเขียนโปรแกรมเชิงฟังก์ชัน Wikipedia อธิบาย:
ในวิทยาการคอมพิวเตอร์ Currying (Currying) หรือแปลว่า Currying หรือ Currying เป็นฟังก์ชันที่รับหลายพารามิเตอร์ กลายเป็นฟังก์ชันที่รับพารามิเตอร์ตัวเดียว (พารามิเตอร์แรกของฟังก์ชันดั้งเดิม) และส่งคืนฟังก์ชันใหม่ที่ยอมรับ อาร์กิวเมนต์ที่เหลือและส่งกลับผลลัพธ์ การอ้างสิทธิ์ Curried: หากคุณแก้ไขอาร์กิวเมนต์บางข้อ คุณจะได้รับ

สรุปฟังก์ชันที่ยอมรับอาร์กิวเมนต์ที่เหลือ:
ส่งผ่านพารามิเตอร์เพียงบางส่วนไปยังฟังก์ชันเพื่อเรียกใช้ และปล่อยให้ฟังก์ชันส่งคืนพื้นที่ฟังก์ชันเพื่อประมวลผลพารามิเตอร์ที่เหลือ
กระบวนการนี้เรียกว่าการแกง

เหตุใดจึงต้องทำการแกง:
ในการเขียนโปรแกรมเชิงฟังก์ชัน เรามักจะหวังว่าปัญหาที่จัดการโดยฟังก์ชันนั้นง่ายที่สุดเท่าที่จะเป็นไปได้ แทนที่จะส่งการประมวลผลจำนวนมากให้กับฟังก์ชันเพื่อจัดการ

ฟังก์ชัน foo(x,y,c) {
    กลับ x + y + c
-
console.log(ฟู(10,20,30))

// ผลรวมฟังก์ชันแกง (x) {
    ฟังก์ชันส่งคืน (y) {
        ฟังก์ชั่นส่งคืน (z) {
            กลับ x + y + z
        -
    -
-
var a = ผลรวม(10)(20)(30)
console.log(ก)

// ลดความซับซ้อนของการแกง var sum2 = x => y => z => {
    กลับ x + y + z
-
console.log(sum2(10)(20)(30))

Combined functionCombined

function (Compose) function เป็นเทคนิคและโหมดการใช้ฟังก์ชั่นในการพัฒนา JavaScript:
ตัวอย่างเช่น ตอนนี้เราจำเป็นต้องเรียกใช้ฟังก์ชันกับข้อมูลบางอย่างและดำเนินการสองฟังก์ชัน fn1 และ fn2 ฟังก์ชันทั้งสองนี้จะถูกดำเนินการตามลำดับ หากเราจำเป็นต้องเรียกใช้ฟังก์ชันสองฟังก์ชันทุกครั้ง การดำเนินการดังกล่าวจะเกิดซ้ำกัน เพื่อรวมฟังก์ชั่นทั้งสองนี้เข้าด้วยกันและเรียกมันทีละฟังก์ชั่นโดยอัตโนมัติ?
กระบวนการนี้เป็นการรวมฟังก์ชันต่างๆ เข้าด้วยกัน ซึ่งเราเรียกว่า Compose Function

เนื้อหาอื่นๆ

ที่มีคำสั่ง

พร้อมคำสั่ง
+ฟังก์ชัน: คุณสามารถสร้างขอบเขตของคุณเองได้ ไม่แนะนำให้ใช้คำสั่ง with เนื่องจากอาจเป็นสาเหตุของข้อผิดพลาดที่ทำให้เกิดความสับสนและปัญหาความเข้ากัน

ได้ '}

// var message = "สวัสดีชาวโลก"

ฟังก์ชั่นฟู() {
แถบฟังก์ชัน () {
     ด้วย (obj2) {
          console.log (ข้อความ)
     -
-
บาร์()
-

ฟังก์ชัน

foo()

eval เป็นฟังก์ชันพิเศษที่สามารถเรียกใช้สตริงขาเข้าเป็นโค้ด JavaScript

var strFn = 'var message = "Hello world"; console.log(message);';
   eval(strFn)

ไม่แนะนำให้ใช้ eval ในการพัฒนา:
ความสามารถในการอ่านโค้ด eval ได้แย่มาก (ความสามารถในการอ่านโค้ดเป็นหลักการสำคัญของโค้ดคุณภาพสูง)
eval เป็นสตริง ดังนั้นจึงอาจถูกแก้ไขระหว่างการดำเนินการ ซึ่งอาจทำให้เกิดความเสี่ยงที่จะถูกโจมตี
การดำเนินการ eval ต้องผ่านล่าม JS และต้องได้รับการปรับให้เหมาะสมโดยกลไก JS

เข้มงวด

คือโหมด JavaScript ที่จำกัด ซึ่งทำให้โค้ดแยกออกจาก "โหมดเลอะเทอะ" โดยปริยาย
 เมื่อเบราว์เซอร์ที่รองรับโหมดเข้มงวดตรวจพบโหมดเข้มงวดในโค้ด พวกเขาจะตรวจสอบและรันโค้ดในลักษณะที่เข้มงวดยิ่งขึ้น โหมดเข้มงวดจะกำจัดข้อผิดพลาดที่ไม่มีการโต้ตอบดั้งเดิมบางอย่างโดยการโยนข้อผิดพลาดโหมดเข้มงวดทำให้เอ็นจิ้น Js สามารถดำเนินการปรับแต่งให้เหมาะสมยิ่งขึ้นได้ เมื่อรันโค้ดเป็นระยะ ๆ (ไม่จำเป็นต้องจัดการกับไวยากรณ์พิเศษบางอย่าง)

"use strict"; // Turn on strict mode var message = "hello world" console.log(message)

ข้อจำกัดของโหมดเข้มงวด <br/ > ที่นี่เราพูดถึงบางอย่าง ข้อจำกัดทางไวยากรณ์ที่เข้มงวดในโหมดเข้มงวด:
JavaScript ได้รับการออกแบบมาเพื่อให้นักพัฒนามือใหม่เริ่มต้นได้ง่ายขึ้น ดังนั้นบางครั้งไวยากรณ์ที่ไม่ถูกต้องจึงถูกแยกวิเคราะห์ตามปกติ อย่างไรก็ตาม ในโหมดเข้มงวด ข้อผิดพลาดดังกล่าวจะถือเป็นข้อผิดพลาด เพื่อให้

1. สามารถค้นพบและแก้ไขข้อผิดพลาดที่ไม่คาดคิดได้อย่างรวดเร็ว ตัวแปรโกลบอล

// 1. สร้างข้อความตัวแปรโกลบอลโดยไม่ตั้งใจ = "สวัสดีชาวโลก"
    console.log (ข้อความ)

    ฟังก์ชั่นฟู() {
        อายุ=20
    -
    ฟู()
    

Console.log (อายุ)

2. บางครั้งจะทำให้ล้มเหลวโดยไม่แจ้งให้ทราบ (หมายเหตุ: ไม่มีการรายงานข้อผิดพลาดและไม่มีผลกระทบ) การดำเนินการมอบหมายเพื่อส่งข้อยกเว้น

// ข้อผิดพลาดคงที่เริ่มต้น true.name = 'xiaoluo';
NaN = 123

3. กำลังพยายามลบแอตทริบิวต์ที่ไม่สามารถลบได้ในโหมดเข้มงวด
4. โหมดเข้มงวดไม่อนุญาตให้พารามิเตอร์ฟังก์ชันมีชื่อเดียวกัน

// พารามิเตอร์ฟังก์ชันไม่ได้รับอนุญาตให้มีชื่อเดียวกัน ฟังก์ชัน foo(x,y,x) {
    console.log(x,y,x)}foo(10,20,30)

5. ไม่อนุญาตให้ใช้ไวยากรณ์ฐานแปดของ 0

var num = 0o123 // Octal var num2 = 0x123 // เลขฐานสิบหก console.log(num,num2)

6. In โหมดเข้มงวด ใช้กับ

var obj2 = {name:'Tom',age:18,message:'obj2'}

ด้วย (obj2) {
      console.log (ข้อความ)
     }

7. ในโหมดเข้มงวด eval จะไม่อ้างถึงตัวแปร

var สำหรับเลเยอร์บนอีกต่อไป strFn = 'var message = "Hello world"; console.log(message);';
ประเมินผล(strFn)

console.log(ข้อความ)

8. การเชื่อมโยงนี้จะไม่ถูกแปลงเป็นวัตถุตามค่าเริ่มต้น ในโหมดเข้มงวด ฟังก์ชันที่ดำเนินการด้วยตนเองจะชี้ไปที่

ฟังก์ชันที่ไม่ได้กำหนด foo() {
    console.log(นี่) //ไม่ได้กำหนด
-
ฟู()