เขียนด้านหน้า
วันนี้ฉันต้องการตรวจสอบความรู้เกี่ยวกับประเภทโหนดและความรู้แบบไหนที่ฉันต้องการสรุป ฉันเห็นบทความเกี่ยวกับ Google แต่ลิงค์ดั้งเดิมหายไป ฉันดึงบทความนี้ออกมาในภาพรวม หากผู้เขียนต้นฉบับมีคำถามใด ๆ โปรดติดต่อฉัน!
บทความนี้ขึ้นอยู่กับ JS บางส่วนและผู้เชี่ยวชาญจะข้ามไปโดยอัตโนมัติ! ฉันไม่เคยเขียนเกี่ยวกับ JS มาก่อนและแง่มุมนี้ค่อนข้างอ่อนแอดังนั้นฉันจึงพบปัญหาเมื่อเขียนโหนด นี่คืออาหารเสริมสำหรับความรู้ของฉัน!
ข้อความ
พื้นฐานของ node.js คือ JavaScript ภาษาสคริปต์ คุณสมบัติทั่วไปอย่างหนึ่งของภาษาสคริปต์ส่วนใหญ่คือ "ประเภทที่อ่อนแอ"
ต่างจาก PHP แม้ว่าจะมีตัวแปรใหม่ใน PHP แต่ก็ไม่จำเป็นต้องประกาศในขณะที่ JavaScript ยังต้องการ VAR เพื่อประกาศ var นี้ครอบคลุมความหมายทุกประเภทเช่น int, string, char ฯลฯ ใน C ++ และฟังก์ชั่น
เนื้อหาทั้งหมดในบทความนี้และบทความต่อไปนี้ได้รับการแก้ไขโดยใช้ VIM ใน Linux หรือ Cygwin (ถ้าไม่โปรดแปลงเป็นวิธีของคุณเอง) จากนั้นดูผลลัพธ์ภายใต้บรรทัดคำสั่ง
ไวยากรณ์พื้นฐาน
การประกาศตัวแปร
ใน C/C ++ เราประกาศตัวแปรเช่นนี้:
`` `C ++
การคัดลอกรหัสมีดังนี้:
เป็นโมฆะ foo () {}
int a = 0;
Char B = 'A';
ลอย c = 1.0f;
เป็นโมฆะ (*d) () = foo; /// <ลืมไปถ้านั่นคือสิ่งที่ฉันเขียนโดยย่อมันเป็นตัวชี้ฟังก์ชั่น
และใน node.js ดูเหมือนว่า:
`` `JavaScript
การคัดลอกรหัสมีดังนี้:
function foo () {}
var a = 0;
var b = 'a';
var c = 1.0;
var d = foo;
ดังนั้นไม่ว่าจะเป็นตัวแปรประเภทใดมันจะถูกแก้ไขด้วย var ใน node.js
คำสั่งวน
สำหรับ…ฉัน
คำสั่งลูปนี้โดยทั่วไปเหมือนกับ C/C ++ ทั้งคู่
`` `C ++
การคัดลอกรหัสมีดังนี้:
สำหรับ (int i = 0; i <foo; i ++)
-
-
-
และเนื่องจาก node.js เป็นประเภทที่อ่อนแอเพียงแค่ต้องการ:
`` `JavaScript
การคัดลอกรหัสมีดังนี้:
สำหรับ (var i = 0; i <foo; i ++) {
-
-
สำหรับ…ใน
นี่คือคำสั่งวนโพสต์รูปคล้ายกับ foreach ของ PHP
ตัวอย่างเช่นเรามีวัตถุ JSON ดังนี้:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
var foo = {
"สวัสดี": "โลก",
"Node": "JS",
"blahblah": "bar"
-
ในเวลานี้เราสามารถใช้ ... ในการวนซ้ำ:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
สำหรับ (คีย์ var ใน foo) {
console.log (key + ":" + foo [key]);
-
หากเราพิมพ์คำสั่งต่อไปนี้ในบรรทัดคำสั่ง:
การคัดลอกรหัสมีดังนี้:
$ node foo.js
เนื้อหาต่อไปนี้จะปรากฏบนหน้าจอ:
การคัดลอกรหัสมีดังนี้:
สวัสดี
: โลก
โหนด: JS
blahblah: บาร์
เคล็ดลับ: จากด้านบนสำหรับ ... ในคำสั่งใช้เพื่อสำรวจชื่อคีย์ของวัตถุ JSON อาร์เรย์และวัตถุโดยไม่ต้องให้การสำรวจค่าคีย์-ค่า หากคุณต้องการรับค่าคีย์คุณสามารถรับได้ในรูปแบบของ foo [<ชื่อคีย์ปัจจุบัน>] สิ่งนี้ยังคงแตกต่างจาก php foreach เล็กน้อย
ในขณะที่…ทำ… whill
ฉันจะไม่อธิบายเรื่องนี้มากนักมันไม่แตกต่างจากภาษาอื่น ๆ มันไม่มีอะไรมากไปกว่านั้นหากมีการประกาศตัวแปรมันก็เพียงพอที่จะใช้ VAR
ผู้ประกอบการ
-
นี่เป็นกรณีของผู้ให้บริการเหล่านี้เราควรให้ความสนใจกับ + มันสามารถดำเนินการกับทั้งสตริงและการดำเนินการเชิงตัวเลข แม้ว่าภาษาที่อ่อนแอจะบอกว่าประเภทอ่อนแอ แต่บางครั้งอาจปรากฏในรูปแบบของสตริงและบางครั้งอาจปรากฏในรูปแบบของค่าตัวเลข แต่เมื่อจำเป็นคุณยังต้องพูดถึงประเภทของมัน เราสามารถใช้รหัสต่อไปนี้เพื่อดูผลลัพธ์:
การคัดลอกรหัสมีดังนี้:
var a = "1";
var b = 2;
console.log (a + b);
console.log (parseint (a) + b);
ที่นี่ ParseInt เป็นฟังก์ชั่นในตัวของ Node.js ซึ่งใช้ในการแยกวิเคราะห์สตริงเป็นตัวแปรประเภท int
ผลการดำเนินการรหัสด้านบนคือ:
การคัดลอกรหัสมีดังนี้:
12
3
หมายเหตุ: ผลลัพธ์ของ console.log แรกคือ 12 เนื่องจาก A เป็นสตริง B จะถูกเพิ่มเป็นสตริงโดยระบบ ผลที่ได้คือทั้งสองสตริงถูกจับเข้าด้วยกันและกลายเป็น 12 ผลลัพธ์ของคอนโซลที่สองคือ 3 เพราะเราแปลง A แรกเป็นประเภท int และเพิ่มตัวแปรประเภท int สองตัวนั่นคือเพิ่มค่าและแน่นอนผลลัพธ์คือ 3
-
นี่คือจุดที่จะอธิบายว่าเมื่อความยาวของตัวดำเนินการตรรกะนี้คือ 2 (==,! =) มันจะกำหนดเฉพาะว่าค่าภายนอกเหมือนกัน แต่ไม่ได้กำหนดประเภท ชอบ
การคัดลอกรหัสมีดังนี้:
var a = 1, b = "1";
console.log (a == b);
ผลลัพธ์ของผลลัพธ์ของมันเป็นจริง แต่ถ้าเราเพิ่มสัญญาณที่เท่าเทียมกันเมื่อเราตัดสินตรงกลางเราจะทำการตัดสินอย่างเข้มงวด มันจะเป็นจริงเมื่อประเภทและค่าเหมือนกันมิฉะนั้นจะเป็นเท็จ กล่าวคือ
การคัดลอกรหัสมีดังนี้:
var a = 1, b = "1";
console.log (a === b);
เมื่อผลลัพธ์ที่ส่งคืนเป็นเท็จเพราะ A เป็นประเภท int ในขณะที่ B คือสตริง
โดยวิธีการพูดคุยเกี่ยวกับคำสั่งตามเงื่อนไข ในความเป็นจริงหากที่นี่ไม่แตกต่างจากภาษาอื่น ๆ มันเป็นเพียงปัญหาของสัญญาณที่เท่าเทียมกันสองสัญญาณและสัญญาณเท่ากันสามสัญญาณสำหรับผู้ให้บริการเชิงตรรกะหลายตัว ดังนั้นฉันจะไม่ให้คำพูดที่เหนื่อยมาก
ประเภทของ
ที่นี่ฉันจะถือว่ามันเป็นตัวดำเนินการมากกว่าฟังก์ชั่น
ฟังก์ชั่นของตัวดำเนินการนี้คือการตัดสินประเภทของตัวแปรและจะส่งคืนสตริงนั่นคือชื่อประเภท คุณจะรู้ว่าคุณเรียกใช้รหัสต่อไปนี้:
การคัดลอกรหัสมีดังนี้:
function foo () {}
var a = 0;
var b = 'shh ~ ซุปดอกไม้ไข่กำลังนอนหลับ -
var c = 1.0;
var d = foo;
var e = {"a": a};
var f = [1, 2, 3];
var g = null;
var h = ไม่ได้กำหนด;
console.log (typeof a);
console.log (typeof b);
console.log (typeof c);
console.log (typeof d);
console.log (typeof e);
console.log (typeof f);
console.log (typeof g);
console.log (typeof h);
ผลการดำเนินการที่นี่จะเป็น:
การคัดลอกรหัสมีดังนี้:
ตัวเลข
สาย
ตัวเลข
การทำงาน
วัตถุ
วัตถุ
วัตถุ
ไม่ได้กำหนด
null, undefined, nan
ใน JavaScript มีสามค่าพิเศษดังที่แสดงในชื่อ ทุกคนอาจคุ้นเคยกับคนแรก นอกจากนี้ยังมี C/C ++ แต่เป็นตัวพิมพ์ใหญ่และสาระสำคัญของมันคือหนึ่ง
`` `C ++
กำหนดค่า null 0
ใน JavaScript ความหมายของค่าทั้งสามนี้แตกต่างกัน
### โมฆะ ###
NULL เป็นวัตถุพิเศษซึ่งหมายถึงว่างเปล่า ตัวอย่างเช่น:
var a = null;
ทุกคนสามารถเข้าใจได้ดังนั้นฉันจะไม่อธิบาย แต่แตกต่างจาก C/C ++, ค่านี้ไม่เท่ากับ 0
### ไม่ได้กำหนด ###
สิ่งนี้หมายความว่าตัวแปรนี้ไม่ได้ประกาศ เพื่อแยกแยะความแตกต่างที่ดีขึ้นรหัสตัวอย่างของเรามีดังนี้:
`` `JavaScript
การคัดลอกรหัสมีดังนี้:
var a = {
"foo": null
-
console.log (a ["foo"]);
console.log (a ["bar"]);
ในรหัสข้างต้นเราสร้างค่าของ ["" foo "] ที่ว่างเปล่านั่นคือ Null และมันก็ไม่ได้ประกาศเลยมันไม่ได้ว่างเปล่า ทุกคนควรเดาผลลัพธ์ผลลัพธ์:
การคัดลอกรหัสมีดังนี้:
โมฆะ
ไม่ได้กำหนด
น่าน
นี่คือค่าที่ว่างเปล่าหมายเลขพิเศษ ชื่อเต็มไม่ใช่ตัวเลข มันค่อนข้างแปลก คุณสามารถเข้าใจว่าเป็นตัวแปรประเภทตัวเลขที่ไม่ใช่รูปแบบตัวเลขหรือตัวแปรประเภทตัวเลขที่มีข้อผิดพลาด
มันมักจะเกิดขึ้นเมื่อข้อผิดพลาดการดำเนินการเชิงตัวเลขแบบลอยตัว (เช่นหารด้วย 0) หรือแม้แต่ผู้ใช้สามารถสร้างตัวแปรเท่ากับ NAN ด้วยตัวเองเพื่อส่งคืนค่าข้อผิดพลาดเพื่อให้ทุกคนรู้ว่าฟังก์ชั่นมีข้อผิดพลาดในการดำเนินการ
เบ็ดเตล็ดเล็ก ๆ
ข้อความอื่น ๆ ที่เหลืออยู่นั้นคล้ายกับภาษาอื่น ๆ ที่มีอยู่เช่น break, switch, ดำเนินการต่อ ฯลฯ
ประเภทตัวแปร
ส่วนนี้ส่วนใหญ่พูดถึงวัตถุ JavaScript และประเภทอื่น ๆ เกือบจะเหมือนกัน
ประเภทพื้นฐาน
ประเภทพื้นฐานที่มีอยู่ใน node.js เกือบจะดังนี้:
ตัวเลข
สาย
บูลีน
อาร์เรย์
สามประเภทแรกสามารถกำหนดได้โดยตรงและการกำหนดอาร์เรย์เป็นเพียงการมอบหมายอ้างอิง หากค่าที่แน่นอนมีการเปลี่ยนแปลงในตัวแปรใหม่ค่าของตัวแปรเก่าจะเปลี่ยนไปเช่นกัน คุณสามารถลองใช้รหัสต่อไปนี้โดยตรง:
จาวาสคริปต์
var foo = [1, 2, 3];
var bar = foo;
บาร์ [0] = 3;
console.log (foo);
ส่งผลให้:
จาวาสคริปต์
[3, 2, 3]
กล่าวอีกนัยหนึ่งหากมีการคัดลอกอาร์เรย์ลงในอาร์เรย์ใหม่มันไม่สามารถใช้เพื่อกำหนดค่าโดยตรง แต่ต้อง "คัดลอกลึก"
ที่นี่เราต้องพูดคุยเกี่ยวกับสามวิธีในการสร้างอาร์เรย์
ประเภทแรก:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
var dog = new Array ();
สุนัข [0] = "shh ~";
สุนัข [1] = "ซุปดอกไม้ไข่";
สุนัข [2] = "นอนหลับ";
ประเภทที่สอง:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
var dog = new Array ("Shh ~", "Egg Flower Soup", "Sleeping");
ประเภทที่สี่:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
var dog = [
"shh ~",
"ซุปดอกไม้ไข่"
"นอนหลับ"
-
โดยส่วนตัวแล้วฉันชอบวิธีการเขียนที่สามซึ่งค่อนข้างรัดกุม
วัตถุ JSON
ที่นี่ฉันนำวัตถุ JSON แยกกันแทนที่จะจำแนกเป็นวัตถุ JavaScript ถ้าฉันคิดว่าฉันทำให้เข้าใจผิดเล็กน้อยฉันสามารถข้ามส่วนนี้ได้โดยตรง
ความแตกต่างระหว่างวัตถุ JSON และวัตถุจาวาสคริปต์คือไม่ว่าจะใช้ในการจัดเก็บข้อมูลเท่านั้นแทนที่จะเป็นอินสแตนซ์ของคลาส ในความเป็นจริงสาระสำคัญของ JSON คือสัญลักษณ์วัตถุ JavaScript
สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ JSON โปรดสารานุกรมด้วยตัวคุณเอง
การประกาศวัตถุ JSON ใน node.js นั้นง่ายมาก:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
var dog = {
"pre": "shh ~",
"sub": {
"ชื่อ": "ซุปดอกไม้ไข่"
"Act": "Sleeping",
"เวลา": 12
-
"suf": ["ฉันพูด", "มันกำลังนอนหลับ", "มันกำลังนอนหลับ"]
-
มีสองวิธีในการรับค่าคีย์ของชื่อคีย์ที่แน่นอนในวัตถุ JSON อย่างแรกคือการเชื่อมต่อกับจุดและที่สองคือการใช้วงเล็บ:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
สุนัข
.pre;
สุนัข ["pre"];
หมายเหตุ: เมื่อใช้จุดด้านบนคีย์ใน JSON จะถูกติดตามโดยตรง หากคุณปฏิบัติต่อคีย์เป็นตัวแปรคุณสามารถลองใช้กับ Dog [Key]: ตอนนี้คุณสามารถลองด้วยตัวเองและใช้สำหรับ ... ในการสำรวจวัตถุ JSON ด้านบน อย่าลืมใช้ typeof ~
พื้นฐานของคลาส (วัตถุ)
การพูดอย่างเคร่งครัดคลาสของ node.js ไม่สามารถพิจารณาคลาสได้ ในความเป็นจริงมันเป็นเพียงชุดของฟังก์ชั่นเพิ่มตัวแปรสมาชิกบางอย่าง สาระสำคัญของมันคือฟังก์ชั่น
อย่างไรก็ตามเพื่อประโยชน์ของสามัญสำนึกเราจะเรียกมันว่า "คลาส" ถัดไปและใหม่กว่าและอันที่มีการสร้างอินสแตนซ์เรียกว่า "วัตถุ"
เนื่องจากคลาสมีฟังก์ชั่นมากมายหรือสาระสำคัญของมันคือฟังก์ชั่นเราอาจพูดคุยเกี่ยวกับพื้นฐานของฟังก์ชั่นเมื่อเราไม่ระวัง
การประกาศและการสร้างอินสแตนซ์ของชั้นเรียน
การประกาศชั้นเรียนนั้นง่ายมากอย่าหัวเราะ:
จาวาสคริปต์
ฟังก์ชั่น foo () {
-
-
ตกลงเราได้เขียนคลาส Foo
จริงหรือปลอม? - จริง.
ไม่เชื่อ? หากคุณไม่เชื่อคุณสามารถพิมพ์รหัสและอ่านได้:
จาวาสคริปต์
var bar = new foo ();
อย่ามองว่ามันเป็นฟังก์ชั่นถ้าเขียนในรูปแบบดังกล่าว (ใหม่) มันเป็นอินสแตนซ์ของคลาสนี้
และที่เรียกว่า Foo () นี้เป็นตัวสร้างของคลาส Foo () นี้
ตัวแปรสมาชิก
มีสองวิธีที่ดีในการรับตัวแปรสมาชิก
สิ่งแรกคือการใช้สิ่งนี้ <ชื่อตัวแปร> ในตัวสร้างคลาสหรือตัวสร้างใด ๆ คุณสามารถประกาศตัวแปรสมาชิกได้ตลอดเวลาและจะไม่ส่งผลกระทบต่อการใช้งานภายนอก อย่างไรก็ตามแม้ว่าคุณจะใช้เมื่อไม่ได้ประกาศ แต่ก็จะมีการสนับสนุนที่ไม่ได้กำหนดไว้ นี่เป็นวิธีแรก:
การคัดลอกรหัสมีดังนี้:
จาวาสคริปต์
ฟังก์ชั่น foo () {
this.hello = "World";
-
หมายเหตุ: นี่คือตัวแปรสมาชิกของคลาสการโทรเฉพาะเมื่อมีการเพิ่มสิ่งนี้มิฉะนั้นมันเป็นเพียงตัวแปรท้องถิ่นในฟังก์ชัน มีความจำเป็นที่จะต้องแยกแยะว่ามีขอบเขตการกระทำของตัวแปรนี้หรือไม่
วิธีที่สองคือการประกาศนอกคอนสตรัคเตอร์หรือฟังก์ชั่นสมาชิกใด ๆ และรูปแบบของมันคือ <ชื่อคลาส> .prototype. <ชื่อตัวแปร>:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่น foo () {
-
-
foo.prototype.hello = "World";
ไม่ว่าวิธีใดข้างต้นคือการประกาศตัวแปรสมาชิกเราสามารถเห็นผลกระทบ:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
var bar = new foo ();
console.log (bar.hello);
คุณสามารถแก้ไขคลาสนี้ได้เช่นนี้:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่น foo () {
this.hello = "World";
-
foo.prototype.hello = "ซุปดอกไม้ไข่";
จากนั้นใช้รหัสด้านบนเพื่อส่งออก
ลองคิดดูว่าทำไมผลผลิตจึงเป็นโลกแทนที่จะเป็นซุปไข่
ตัวสร้าง
เราได้กล่าวไว้ก่อนหน้านั้นว่า Foo () เป็นตัวสร้าง จากนั้นเห็นได้ชัดว่าเราสามารถส่งพารามิเตอร์ไปยังตัวสร้างดังนั้นเราจึงมีรหัสต่อไปนี้:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
// รหัส 2.1
ฟังก์ชั่น foo (สวัสดี) {
ถ้า (สวัสดี === ไม่ได้กำหนด) {
this.hello = "World";
} อื่น {
this.hello = สวัสดี;
-
-
เราเห็นการตัดสินที่แปลกถ้า (สวัสดี === ไม่ได้กำหนด) การใช้งานการตัดสินนี้คืออะไร? ความเป็นไปได้แรกคือผู้พัฒนาส่งความเจ็บปวดที่ไม่ได้กำหนดไว้เป็นพิเศษ ในเวลานี้มันไม่ได้กำหนด
มีสถานการณ์อื่น เราพูดตั้งแต่แรกว่าจาวาสคริปต์เป็นภาษาที่อ่อนแอ ในความเป็นจริงมันไม่ได้เป็นเพียงแค่ประเภทที่อ่อนแอ แต่พารามิเตอร์การส่งสัญญาณของมันก็ยังไม่ได้ควบคุมมาก คุณสามารถผ่านมากขึ้นหรือน้อยลง (ตราบใดที่คุณมั่นใจว่าโปรแกรมจะไม่ทำผิดพลาดเมื่อคุณผ่านไม่มากก็น้อย) ก็โอเคในหลักการ พารามิเตอร์ของการผ่านหลายครั้งจะถูกละเว้นโดยอัตโนมัติในขณะที่พารามิเตอร์ของการผ่านเพียงไม่กี่ครั้งจะถูกเสริมด้วย undefined
เพียงดูรหัสต่อไปนี้แล้วคุณจะเข้าใจ:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
// เชื่อมต่อรหัส 2.1 เปิด
var bar1 = new foo ();
var bar2 = ใหม่ foo ("ซุปดอกไม้ไข่");
โปรดส่งออกสองบาร์สวัสดีตัวแปรด้วยตัวเองและคุณจะพบว่าหนึ่งคือโลกและอีกอันคือซุปไข่ เห็นได้ชัดว่าเมื่อ BAR1 แรกของเราได้รับการประกาศมันจะได้รับการยกย่องโดยอัตโนมัติโดย Node.js:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
var bar1 = ใหม่ foo (ไม่ได้กำหนด);
ดังนั้นจึงมีคำพูดว่ามันเป็นโลก
นอกจากนี้ในตัวสร้างนี้เราจะเห็นว่าพารามิเตอร์ที่ผ่านเข้ามาคือสวัสดีและมีตัวแปรสมาชิกในคลาสนี้นั่นคือนี่คือเฮลโล อย่างไรก็ตามเราได้กล่าวก่อนหน้านี้ว่าขอบเขตนั้นแตกต่างกันเมื่อมีสิ่งนี้และนี่ไม่ใช่ พารามิเตอร์นั้นใช้ในตัวสร้างเท่านั้นในขณะที่พารามิเตอร์นี้เป็นตัวแปรสมาชิก ใช้สิ่งนี้เพื่อแยกแยะพวกเขาทันทีดังนั้นจึงไม่สำคัญแม้ว่าชื่อเดียวกันจะเป็น
ฟังก์ชั่นสมาชิก
การประกาศฟังก์ชั่นสมาชิก
การประกาศฟังก์ชั่นสมาชิกนั้นคล้ายกับวิธีการประกาศครั้งที่สองของตัวแปรสมาชิกนั่นคือ <ชื่อคลาส> .prototype. <ชื่อฟังก์ชัน> = <unction>;
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
// เชื่อมต่อรหัส 2.1 เปิด
ฟังก์ชั่น Sethello (สวัสดี) {
this.hello = สวัสดี;
-
foo.prototype.sethello = Sethello;
bar1.sethello ("เค้กไข่");
เนื่องจากรหัสข้างต้นชัดเจนเราใช้ฟังก์ชัน Sethello ของคลาส Foo ซึ่งเราสามารถปรับเปลี่ยนค่าของ foo.hello
แต่มันไม่ลำบากเลยที่จะเขียนแบบนี้เหรอ? ต่อไปฉันจะพูดถึงคุณสมบัติที่สำคัญของฟังก์ชั่น JavaScript
★ฟังก์ชั่นนิรนาม★
หลายครั้งฟังก์ชั่นบางอย่างของเรามีการอ้างอิงหรือเรียกในที่เดียวเท่านั้นดังนั้นจึงคุ้มค่าที่จะให้ชื่อฟังก์ชั่นนี้และไม่จำเป็นดังนั้นเราจึงสามารถเขียนฟังก์ชั่นนี้ชั่วคราวและถามผู้ที่อ้างอิงถึงการอ้างอิงและผู้ที่เรียกมันว่าเรียกมัน ดังนั้นฟังก์ชั่นสามารถละเว้นชื่อฟังก์ชั่นเช่น:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่น (สวัสดี) {
this.hello = สวัสดี;
-
สำหรับวิธีการเสนอราคาหรือเรียกมัน? หากต้องมีการยกระดับคลาสข้างต้นมันจะถูกเขียนขึ้นเช่นนี้:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
foo.prototype.sethello = ฟังก์ชั่น (สวัสดี) {
this.hello = สวัสดี;
-
วิธีการเขียนนี้เหมือนกับการประกาศฟังก์ชั่นสมาชิกและบันทึกรหัสจำนวนมาก และในความเป็นจริงโดยทั่วไปการประกาศฟังก์ชั่นสมาชิกในชั้นเรียนจะถูกประกาศในฟังก์ชั่นที่ไม่ระบุชื่อ
สำหรับวิธีการทำฟังก์ชั่นที่ไม่ระบุชื่อเรียกว่า? สิ่งนี้มักจะเขียนเช่นนี้เมื่อผ่านฟังก์ชั่นที่เรียกโดยฟังก์ชั่นบางอย่างเท่านั้น
ตัวอย่างเช่นเรามีต้นแบบของฟังก์ชัน:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
-
* เราจะผ่านสองตัวแปร A และ B
* หลังจากคำนวณค่าของ A+B แล้วส่งมอบให้กับ func (NUM)
* ไปที่เอาต์พุต
-
ฟังก์ชั่น sumab (a, b, func) {
var c = a + b;
func (a, b, c);
-
ตัวอย่างเช่นเรามีฟังก์ชั่นเอาท์พุทสองเวอร์ชันหนึ่งคือเอาต์พุตภาษาจีนและอีกอย่างคือเอาต์พุตภาษาอังกฤษ ดังนั้นหากเราไม่ใช้ฟังก์ชั่นที่ไม่ระบุชื่อ:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่น zh (a, b, sum) {
ค่าของ console.log (a + " +" + b + "คือ:" + sum);
-
ฟังก์ชั่น en (a, b, sum) {
console.log (a + "plus" + b + "คือ" + ผลรวม);
-
sumab (1, 2, zh);
sumab (3, 4, en);
ดำเนินการรหัสนี้หนึ่งครั้งและผลลัพธ์จะเป็น:
ค่า 1 + 2 คือ: 3
3 Plus 4 คือ 7
หากรหัสดังกล่าวอยู่ในรูปแบบของฟังก์ชั่นที่ไม่ระบุชื่อมันจะเป็น:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
sumab (1, 2, ฟังก์ชั่น (a, b, sum) {
ค่าของ console.log (a + " +" + b + "คือ:" + sum);
-
sumab (3, 4, ฟังก์ชั่น (a, b, sum) {
console.log (a + "plus" + b + "คือ" + ผลรวม);
-
แบบฟอร์มนี้มักจะใช้ในฟังก์ชั่นการโทรกลับ กลไกการโทรกลับเป็นสาระสำคัญของ Node.js หรือ JavaScript ฉันจะแนะนำมันในบทในอนาคต
วิธีประกาศฟังก์ชั่นนิรนามในการประกาศฟังก์ชั่นสมาชิก
แม้ว่าฉันจะได้พูดคุยเกี่ยวกับเรื่องนี้ในส่วนก่อนหน้า แต่ฉันจะพูดถึงเรื่องนี้อีกครั้ง
โดยปกติเมื่อเราประกาศฟังก์ชั่นสมาชิกในชั้นเรียนเราใช้ฟังก์ชั่นที่ไม่ระบุชื่อเพื่อประกาศเพราะอย่างไรก็ตามฟังก์ชั่นนั้นเป็นเพียงฟังก์ชั่นสมาชิกของคลาสนี้และจะไม่ถูกอ้างอิงหรือเรียกแยกต่างหากในสถานที่อื่นดังนั้นรหัสต่อไปนี้จึงมีอยู่:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
// เชื่อมต่อรหัส 2.1 เปิด
foo.prototype.sethello = ฟังก์ชั่น (สวัสดี) {
this.hello = สวัสดี;
-
ด้วยวิธีนี้เรามีฟังก์ชั่น Sethello ในคลาส Foo
2.3.4. การสุ่มชั้นเรียน
นี่คือเรื่องไร้สาระของฉันอีกครั้ง การสุ่มที่เรียกว่าคลาสหมายความว่าใน JavaScript คุณสามารถปรับเปลี่ยนชั้นเรียนของคุณได้ทุกที่ซึ่งมีความคล้ายคลึงกับทับทิม
ตัวอย่างเช่นสตริงเป็นคลาสจริงโดยมีตัวแปรสมาชิกเช่นความยาวและฟังก์ชั่นสมาชิกเช่น indexof และ substr แต่ถ้าเราคิดว่าบางส่วนของสตริงนี้ไม่สมบูรณ์แบบและต้องการเพิ่มวิธีการของเราเองเราสามารถเพิ่มฟังก์ชั่นลงในที่ที่คุณต้องการเช่น:
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
string.prototype.sb = function () {
var newsstr = "";
สำหรับ (var i = 0; i <this.length; i ++) {
if (i % 2 === 0) newsr += "s";
else newsr += "b";
-
ส่งคืน Newsr;
-
ความหมายของฟังก์ชั่นนี้คือการเติมสตริงเพื่อให้มันเข้าสู่การจุติของ SB
มาทดสอบกันเถอะ:
การคัดลอกรหัสมีดังนี้:
var str = "shh ~ ซุปดอกไม้ไข่กำลังนอนหลับ";
console.log (str.sb ());
คุณจะได้รับผลลัพธ์ต่อไปนี้:
SBSBSBSBSBSBS
ถ้าคุณพูดว่า "shhh ~ ซุปดอกไม้ไข่กำลังนอนหลับ" คอมพิวเตอร์ของคุณจะดุว่าคุณเป็นคนโง่สี่ครั้งครึ่ง (ทุบอย่างรวดเร็ว)
3. แนบ
3.1. สำเนาลึก
สำเนาที่เรียกว่าลึกที่เรียกว่าคือการสร้างอาร์เรย์หรือวัตถุใหม่ด้วยตัวเองและคัดลอกค่าตัวแปรประเภทพื้นฐานในอาร์เรย์ต้นฉบับหรือวัตถุทีละตัวแทนที่จะใช้การอ้างอิงไปยังอาร์เรย์หรือวัตถุแหล่งที่มา ดังนั้นสิ่งนี้เกี่ยวข้องกับการโทรแบบเรียกซ้ำหรืออะไรบางอย่าง
ด้านล่างเป็นฟังก์ชั่นสำเนาลึกที่ฉันใช้ คุณสามารถเขียนหนึ่งในของคุณเองและเพิ่มลงในฐานความรู้ Node.js ของคุณเอง
จาวาสคริปต์
การคัดลอกรหัสมีดังนี้:
ฟังก์ชัน CloneObject (SRC) {
var dest = {};
สำหรับ (คีย์ var ใน src) {
if (typeof src === "object") dest [key] = cloneObject (src [key]);
DEST ELSE [KEY] = SRC [คีย์];
-
กลับมาแล้ว;
-