LearnJS
1.0.0
LearnJsเป็นความพยายามที่จะวาดภาพส่วนที่ดีที่สุดของ JavaScript ที่ค่อนข้างยากและหายาก เป็นที่น่าสังเกตว่านี่ไม่ใช่หนังสือ/ไกด์ในรูปแบบใด ๆ แต่เป็นการรวมตัวกันของแนวปฏิบัติที่ดีที่สุดการสร้างภาษาและตัวอย่างที่เรียบง่าย แต่มีประสิทธิภาพอื่น ๆ ที่ให้ความสำคัญกับเราว่าเราจะควบคุมภาษาที่ดีที่สุดได้อย่างไร
1.1 Declarations :
// bad
var arr = new Array ( ) ;
var str = new String ( ) ;
var num = new Number ( ) ;
var boo = new Boolean ( ) ;
var obj = new Object ( ) ;
var reg = new RegExp ( ) ;
var fun = new function ( ) ;
// good
var arr = [ ] ,
str = "" ,
num = 0 ,
boo = false ,
obj = { } ,
reg = / () / ,
fun = function ( ) { } ; เราต้องเข้าใจความจริงที่ว่าใน JavaScript ทุกอย่างเป็นวัตถุดังนั้นหากเราประกาศว่าเราประกาศสตริงโดยใช้วัตถุ String และเปรียบเทียบกับ var a = "" ผลลัพธ์ของการเปรียบเทียบจะเป็นเท็จ นี่เป็นเพียงเพราะถ้าเราประกาศสตริงโดยใช้วิธี bad และเปรียบเทียบกับสตริงที่ประกาศใช้วิธี good โดยพื้นฐานแล้วเรากำลังเปรียบเทียบสตริงกับวัตถุ (สตริง)
Semicolons :
// Snippet one
var foo = { }
foo . code = "this is javascript empire"
foo . engine = "node 0.12.7"
foo . author = "akhil pandey"
foo . version = 0.1
// Snippet two
var bar = { } ;
bar . name = "akhil pandey" ;
bar . url = "www.akhilhector.com" ;
bar . github = "AkhilHector" ;
bar . age = 20 ;
if ( typeof ( bar ) == typeof ( foo ) ) {
console . log ( "Semicolons donot matter at all" )
}โค้ดตัวอย่างหนึ่งและสองเหมือนกัน แต่ความแตกต่างพื้นฐานระหว่างตัวอย่างรหัสทั้งสองคือหนึ่งใช้เครื่องหมายอัฒภาคในความหมายของ lang- -uage แต่ในขณะที่อีกอันไม่ได้ โดยพื้นฐานแล้วเราได้รับการสอนให้ใช้เครื่องหมายอัฒภาคในภาษาเช่น C, C ++, Java ฯลฯ เนื่องจากบรรทัดของรหัสถูกยกเลิกโดยใช้ ';'; ' แต่ใน JavaScript สถานการณ์ทั้งหมดนั้นแตกต่างกัน ไม่มีความแตกต่างอย่างแน่นอนในการดำเนินการรหัสที่มีหรือไม่มีเครื่องหมายอัฒภาค
วิธีการส่วนหนึ่งของวัตถุ แผนที่ JavaScript:
2.1 แผนที่ . set ():
let m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . set ( "name" , "akhil pandey" ) //Map { { id: 1 } => 'foo', { id: 2 } => 'bar', 'name' => 'akhil pandey' } MAP .SET () เป็นวิธีที่ใช้ในการเพิ่มหรืออัปเดตองค์ประกอบด้วยคีย์และค่าเฉพาะในแผนที่ ที่นี่อาร์กิวเมนต์แรกคือคีย์ในขณะที่อาร์กิวเมนต์ที่สองคือค่า ปุ่มสามารถเป็นประเภทใดก็ได้ แต่จะดีกว่าที่จะใช้ objects เป็นปุ่มแทน strings เพราะถ้าเราใช้ strings เป็นคีย์จะไม่มีความแตกต่างอย่างมีนัยสำคัญระหว่าง Maps และ Objects
2.2 แผนที่ . get ():
var m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . get ( x ) ; //returns 'foo' แผนที่ . get () เป็นวิธีที่ใช้ในการดึงองค์ประกอบจากวัตถุ Map ด้วยคีย์เฉพาะ ดังนั้นคีย์จะถูกส่งผ่านเป็นอาร์กิวเมนต์และองค์ประกอบที่เกี่ยวข้องกับคีย์นั้นจะถูกส่งคืน หากไม่มีคีย์ถูกส่งผ่านเป็นอาร์กิวเมนต์แล้ววิธีการจะกลับมาโดย undefined
2.3 แผนที่ . has ():
var m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . has ( x ) // returns true
m1 . has ( "akhil" ) // retuqrns false แผนที่ .has () เป็นวิธีที่ระบุว่าองค์ประกอบที่มีคีย์ที่ร้องขออยู่ในแผนที่หรือไม่ วิธีการใช้เพียงหนึ่งอาร์กิวเมนต์ซึ่งเป็นคีย์และจะส่งคืน true ถ้าองค์ประกอบมีอยู่หรือ false หากองค์ประกอบไม่มีอยู่
2.4 แผนที่ ขนาด:
var m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . size ; MAP .Size เป็นคุณสมบัติ accessor ที่ส่งคืนจำนวนองค์ประกอบที่มีอยู่ในวัตถุ Map เนื่องจากเป็นคุณสมบัติของอุปกรณ์เสริมเราจึงไม่ควรเรียก/ใช้สิ่งนี้เช่นวิธีการดังนั้นถ้า m1.size() ถูกเรียกว่ามันจึงพ่นประเภทที่บอกว่า m1.size ไม่ใช่ฟังก์ชั่น ดังนั้นการเรียกที่ถูกต้องไปยังคุณสมบัตินั้นคือ m1.size
2.5 แผนที่ .lear ():
var m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . has ( x ) ; // returns true
m1 . clear ( ) ;
m1 . has ( x ) ; // returns false MAP .Clear () เป็นวิธีที่ล้าง/ลบองค์ประกอบทั้งหมดที่มีอยู่ในวัตถุ Map วิธีนี้ไม่ได้ใช้อาร์กิวเมนต์ใด undefined
2.6 แผนที่ . delete ():
var m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . has ( x ) ; // returns true
m1 . delete ( x ) ; // returns true
m1 . delete ( "something" ) ; // returns false
m1 . has ( x ) ; // returns false แผนที่ . delete () เป็นวิธีที่ใช้สำหรับการลบองค์ประกอบเฉพาะออกจากวัตถุ Map วิธีนี้ใช้อาร์กิวเมนต์เดียวเท่านั้นซึ่งเป็นคีย์และหากคีย์มีอยู่ใน Map จะลบองค์ประกอบและส่งคืน true แต่ถ้าคีย์ไม่มีอยู่ใน Map แล้วมันจะเป็น false
2.7 แผนที่ . keys ():
var m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . keys ( ) ; // MapIterator { { id: 1 }, { id: 2 } }
let iterator = m1 . keys ( ) ;
console . log ( iterator . next ( ) . value ) ; // { id: 1 }
console . log ( iterator . next ( ) . value ) ; // { id: 2 }
console . log ( iterator . next ( ) . value ) ; // undefined แผนที่ . keys () เป็นวิธีที่ใช้ในการส่งคืนคีย์ที่มีอยู่ในวัตถุ Map สำหรับแต่ละองค์ประกอบ วิธีการส่งคืนวัตถุ Map Iterator ซึ่งสามารถใช้สำหรับการรู้คีย์ที่มีอยู่ใน Map ในตัวอย่างข้างต้นมีการระบุวิธีการวนซ้ำบน แผนที่ . keys () โดยใช้ next() จะต้องสังเกตว่าเมื่อใช้งาน next() บนวัตถุ ตัววนซ้ำ ไม่ว่าจะเป็น value หรือ done เนื่องจากการใช้งานตรงไปข้างหน้าของ next() ส่งผลให้แสดง Object iterator.next().value ส่งคืนค่าของคีย์ที่มีอยู่ในอ็อบเจ็กต์ ตัววน ซ้ำในขณะที่ iterator.next().done การส่งคืนบูลีนบอกว่า false ถ้ามีคีย์เพิ่มเติมอยู่ในวัตถุ ตัววนซ้ำ และ true หากไม่มีคีย์อีกต่อไป
2.8 แผนที่ ค่า ():
var m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . values ( ) ; // MapIterator { 'foo', 'bar' }
let iterator = m1 . values ( ) ;
console . log ( iterator . next ( ) . value ) ; // foo
console . log ( iterator . next ( ) . value ) ; // bar
console . log ( iterator . next ( ) . value ) ; // undefined แผนที่ . values () เป็นวิธีการที่ใช้เพื่อส่งคืนค่าที่มีอยู่ในวัตถุ Map สำหรับแต่ละองค์ประกอบ วิธีการส่งคืนวัตถุ ตัววนซ้ำ ซึ่งสามารถใช้สำหรับการรู้ค่าที่มีอยู่ใน Map ในตัวอย่างข้างต้นมีการระบุวิธีการวนซ้ำบน แผนที่ . values () โดยใช้ next() จะต้องสังเกตว่าเมื่อใช้งาน next() บนวัตถุ ตัววนซ้ำ ไม่ว่าจะเป็น value หรือ done เนื่องจากการใช้งานตรงไปข้างหน้าของ next() ส่งผลให้แสดง Object iterator.next().value ส่งคืนค่าขององค์ประกอบเฉพาะที่มีอยู่ใน อ็อบเจ็กต์ ตัววนซ้ำในขณะที่ iterator.next().done จะส่งคืนบูลีนบอกว่า false หากมีค่าเพิ่มเติมอยู่ในวัตถุ ตัววนซ้ำ และ true หากไม่มีค่าใด ๆ อีกต่อไป
2.9 แผนที่ . entries ():
var m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . entries ( ) ; // MapIterator { [ { id: 1 }, 'foo' ], [ { id: 2 }, 'bar' ] }
let iterator = m1 . values ( ) ;
console . log ( iterator . next ( ) . value ) ; // [ { id: 1 }, 'foo' ]
console . log ( iterator . next ( ) . value ) ; // [ { id: 2 }, 'bar' ]
console . log ( iterator . next ( ) . value ) ; // undefined แผนที่ . entries () เป็นวิธีการที่ถูกฟ้องร้องเพื่อส่งคืนคีย์และค่าที่มีอยู่ในวัตถุ Map สำหรับแต่ละองค์ประกอบ วิธีการนี้ค่อนข้างคล้ายกับ แผนที่ . values () สำหรับความจริงที่ว่ามันส่งคืนวัตถุ ตัววนซ้ำ ที่สามารถใช้เพื่อทราบคีย์และค่าที่มีอยู่ใน Map ในตัวอย่างข้างต้นมีการจัดแสดงว่าจะทำซ้ำผ่าน แผนที่ . entries () โดยใช้ next() ความสามารถของวิธีการและวิธีการทำงานนั้นค่อนข้างคล้ายกับ แผนที่ . values () ยกเว้นความจริงที่ว่าคีย์จะถูกส่งกลับพร้อมกับค่าที่เราวนซ้ำผ่านวัตถุ ตัววนซ้ำ คล้ายกับวัตถุ ตัววนซ้ำ ใด ๆ เมื่อถึงจุดสิ้นสุดของระนาบมันจะโยนและ undefined นอกจากนี้ยังมีข้อสังเกตว่าวิธีอื่นใดที่ใช้กับวัตถุ ตัววนซ้ำ สามารถใช้กับสิ่งนี้ได้เนื่องจากเป็นวิธีเดียวกัน
MISC[Maps] : WeakMaps ถือได้ว่าเป็น แผนที่ ที่มีความแตกต่างในวิธีการของคอลเลกชันขยะที่เกิดขึ้นภายใต้ประทุน ในการวางไว้ในคำศัพท์ที่ง่ายและธรรมดาจะต้องมีบทเรียนแนวคิดเล็ก ๆ น้อย ๆ ที่บอกเพื่อนำมุมมอง ในจาวาสคริปต์ในวงกว้างทุกอย่างเป็น วัตถุ ดังนั้นช่วงเวลาที่คุณสร้างและหน่วยความจำจะถูกจัดสรรให้เหมือนกันและจนกว่า V8 จะเป็นของ GC โดยอัตโนมัติ (สั้นสำหรับการรวบรวมขยะ) วัตถุยังคงเป็นโหนดในกราฟ เป็นที่น่าสังเกตว่าจนกว่าจะไม่มีการอ้างอิงถึงวัตถุที่สร้างขึ้นในหน่วยความจำมันจะไม่เป็น GC ดังนั้นวัตถุทั้งหมดจะถูกจัดขึ้น tightly หรือ strongly โดยพื้นฐานแล้วความแตกต่างที่เกิดขึ้นกับ ความอ่อนแอ คือปุ่มของวัตถุจะถูกจัดขึ้น weakly จากนี้ไปหากวัตถุนั้นเป็น GC โดย V8 หรือโดยคุณแล้วรายการจะถูกลบออกจาก beakmap แต่ไม่ใช่ค่า ไม่มีความแตกต่างอย่างสิ้นเชิงระหว่างวิธี การแผนที่ และ beakmaps ทำงานแม้ว่า beakmaps จะยอมรับวัตถุเท่านั้นที่เป็นปุ่ม (อย่างเคร่งครัด) ให้เราดูด้านล่างเพื่อดูว่าพวกเขาเริ่มต้นอย่างไร:
var m1 = new WeakMap ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // WeakMap {}
m1 . set ( y , "bar" ) ; // WeakMap {}
m1 . get ( x ) ; // 'foo'
m1 . get ( y ) ; // 'bar'm1. เป็นที่น่าสังเกตว่าแม้ว่าวิธี ที่อ่อนแอ API จะโต้ตอบกับเราในลักษณะเดียวกับที่วัตถุ แผนที่ มีข้อ จำกัด ในการดำเนินการโดย Weakmaps API รองรับ get() , set() , has() และ delete() วิธีการ ณ ตอนนี้
MISC[Maps] : การใช้ ... Operator
วิธีการส่วนหนึ่งของวัตถุ JavaScript Set :
3.1 set .add ():
var s1 = new Set ( )
s1 . add ( 'akhil' )
s1 . add ( 123 )
s1 . add ( 456.789 )
s1 . add ( true )
s1 . add ( { id : 123456 } )
s1 . add ( NaN )
s1 . add ( null )
console . log ( s1 ) // Set { 'akhil', 123, 456.789, true, { id: 123456 }, NaN, null} SET .ADD () เป็นวิธีการ mutator สำหรับการเพิ่มค่าลงในชุด ขั้นตอนการบรรลุเป้าหมายนี้ตรงไปตรงมา เราเรียกวิธี add() ไปยังวัตถุ Set สร้างไว้แล้วและส่งผ่านค่าที่เราต้องการลงในชุดเป็นอาร์กิวเมนต์ เมื่ออาร์กิวเมนต์มากกว่าหนึ่งรายการถูกส่งผ่านไปยังวิธี add() มันจะละเว้นอาร์กิวเมนต์ที่เหลือและพิจารณาเฉพาะอาร์กิวเมนต์แรกเท่านั้น เป็นที่น่าสังเกตว่าวัตถุ Set ไม่มีข้อ จำกัด ใด ๆ กับประเภทของค่าที่ถูกส่งผ่านและไม่บังคับใช้ข้อ จำกัด ใด ๆ เมื่อเราสร้าง Set ที่ต่างกัน NaN , null ยังสามารถเป็นส่วนหนึ่งของ Set แม้ว่ามันจะไม่ได้รับการสนับสนุนให้เติมเต็ม Set ของค่านี้
3.2 set .has ():
var s1 = new Set ( )
s1 . add ( 123 )
s1 . add ( 456 )
s1 . add ( 789 )
s1 . add ( "akhil" )
s1 . add ( null )
s1 . has ( 123 ) // returns true
s1 . has ( NaN ) // returns false
s1 . has ( "akhil" ) // returns true
s1 . has ( 456.12 ) // returns false
s1 . has ( 123.0000000000000009123 ) // returns true Set .has () เป็นวิธีที่มีประโยชน์ในการพิจารณาว่าองค์ประกอบมีอยู่ใน Set หรือไม่ วิธีการส่งคืน true หากค่ามีอยู่และ false หากไม่มีค่า หากเราสังเกตตัวอย่างข้างต้นมีความแตกต่างเล็กน้อยระหว่างธรรมชาติที่คาดหวังของวิธีการกับความเป็นจริงของพื้นดิน s1.add(123.0000000000000009123) เป็นตัวอย่างหนึ่งที่ให้แสงสว่างในการแข่งขันที่ยาวนานในทศวรรษที่ยาวนานระหว่าง JavaScript และค่าจุดลอยตัว สิ่งนี้สามารถหลีกเลี่ยงได้ง่ายๆโดยใช้ หมายเลข . ความไม่แน่นอน () นอกจากนี้ใน JavaScript มันจะได้รับการสนับสนุนให้จัดการกับจุดลอยตัวอย่างระมัดระวัง
3.3 SET . Size:
var s1 = new Set ( [ 1 , 23 , 456 , 78910 ] )
var s2 = new Set ( )
s2 . add ( "akhil" )
s2 . add ( "chandu" )
s2 . add ( "adheeth" )
console . log ( s1 . size ) // returns 4
console . log ( s2 . size ) // returns 3 Set . Size ไม่ใช่วิธีการ แต่เป็นคุณสมบัติของวัตถุชุดที่มีประโยชน์สำหรับการกำหนดขนาดของ Set ในขณะที่คุณสามารถสังเกตได้จากตัวอย่างโค้ดด้านบนมันถูกเรียกว่าเหมือนวิธีการเข้าชม หากเราพยายามเรียกคุณสมบัติโดยใช้ size() แล้วมันจะโยน typeerror ว่า Set.size ไม่ใช่ฟังก์ชั่น
3.4 set .lear ():
var s1 = new Set ( )
s1 . add ( "akhil" )
s1 . add ( "krishna" )
s1 . add ( "pardhu" )
console . log ( s1 . has ( "akhil" ) ) // returns true
console . log ( s1 . has ( "krishna" ) ) // returns true
s1 . clear ( "pardhu" )
s1 . clear ( )
console . log ( s1 . has ( "akhil" ) ) // returns false
console . log ( s1 . has ( "pardhu" ) ) // returns false Set .Clear () เป็นวิธีที่ล้างองค์ประกอบทั้งหมดที่มีอยู่ในชุด สิ่งนี้ส่งผลให้การล้าง Set หากเราสังเกตในตัวอย่างโค้ดด้านบนมีความพยายามที่จะผ่านการโต้แย้งไปยังวิธี การชุด .lear () และโดยไม่คำนึงถึงข้อโต้แย้งใดที่ส่งผ่านไปยังวิธีการที่จะเพิกเฉยและดำเนินการ clear() ใน Set นอกจากนี้ยังไม่มีการ จำกัด จำนวนครั้งที่ดำเนินการ
3.5 set . delete ():
var s1 = new Set ( )
s1 . add ( "akhil" )
s1 . add ( "dusi" )
s1 . add ( "om" )
s1 . add ( "siddu" )
console . log ( s1 . has ( "akhil" ) )
console . log ( s1 . delete ( "akhil" ) )
console . log ( s1 . delete ( "foo" ) )
console . log ( s1 . has ( "akhil" ) )
for ( let item of s1 ) {
console . log ( item )
} Set .Delete () เป็นวิธีที่ใช้ในการลบองค์ประกอบออกจากชุด วิธีการยอมรับเพียงหนึ่งอาร์กิวเมนต์และส่งคืนค่าบูลีน true หรือ false หากอาร์กิวเมนต์มากกว่าหนึ่งรายการถูกส่งผ่านไปยัง delete() จากนั้นจะละเว้นอาร์กิวเมนต์ที่เหลือและพิจารณาเพียงแค่อาร์กิวเมนต์แรก
3.6 set . values ():
var s1 = new Set ( )
var s2 = new Set ( )
s1 . add ( "foo" )
s1 . add ( "bar" )
s1 . add ( "foobar" )
s1 . add ( "barfoo" )
for ( let items of s1 . values ( ) ) {
s2 . add ( items )
}
console . log ( s1 . values ( ) ) // returns SetIterator { 'foo', 'bar', 'foobar', 'barfoo' }
console . log ( s2 . values ( ) ) // returns SetIterator { 'foo', 'bar', 'foobar', 'barfoo' }
console . log ( s1 . has ( "foo" ) ) // returns true
console . log ( s2 . has ( "foo" ) ) // returns true Set .Values () เป็นวิธีที่ส่งคืนค่าที่มีอยู่ใน Set หากเราใช้ s1.values() ในลูปดังที่แสดงในตัวอย่างโค้ดด้านบนทั้งหมดที่เราได้รับกลับเป็นค่าที่เราวนซ้ำเหนือ Set นอกจากนี้สิ่งนี้อาจฟังดูคล้ายกับวิธีการใน Map แต่มีความแตกต่างเล็กน้อยซึ่งเป็น แผนที่ . values () จะส่งคืนค่าที่มีอยู่ใน Map และ แผนที่ . keys () จะส่งคืนเฉพาะปุ่มที่เชื่อมโยงกับทุกค่า/องค์ประกอบ ตอนนี้เนื่องจาก Set มีคีย์และค่าเป็นองค์ประกอบเดียวกันจึงมีความแตกต่างระหว่าง ชุด . values () และ ชุด . keys () เราจะถูกส่งคืนด้วยวัตถุที่ทำซ้ำเหมือนกันโดยไม่มีความแตกต่างเลย
3.7 set . entries ():
var s1 = new Set ( )
s1 . add ( "foo" )
s1 . add ( "goo" )
s1 . add ( "bar" )
s1 . add ( "gar" )
// the keys are
for ( let pairs of s1 . entries ( ) ) {
console . log ( "key[" + pairs [ 0 ] + "] => " + pairs [ 1 ] )
} SET .ENTRIES () เป็นวิธีที่ส่งคืนอาร์เรย์ของค่าสำหรับค่าที่มีอยู่ใน Set เราต้องเข้าใจว่าใน Set ค่าคีย์และค่ายังคงเหมือนเดิมดังนั้นเมื่อเราเรียกวิธี การตั้งค่า . entries () ทั้งหมดที่เราได้รับคืออาร์เรย์ nx2 ของค่าที่ n [0] และ n [1] มีค่าเดียวกัน นอกจากนี้เรายังสามารถกำหนด s1.entries() ให้กับตัวแปรหรือค่าคงที่และในกรณีนั้นเราจะได้รับวัตถุตัววนซ้ำที่สามารถเล่นได้โดยใช้ next()
MISC[Sets] : จุดอ่อน
MISC[Sets] : การใช้ ... Operator
วิธีการส่วนหนึ่งของวัตถุ อาร์เรย์ JavaScript:
4.1 อาร์เรย์ . push ():
var arr1 = [ 1 , 2 , 3 , 4 , 5 ] ;
arr1 . push ( 6 ) ;
console . log ( arr1 ) ; // it prints [1,2,3,4,5,6]อาร์เรย์ . push () เป็นเพียงฟังก์ชั่นการกลายพันธุ์สำหรับการเพิ่มองค์ประกอบลงในอาร์เรย์ ดังนั้นเราสามารถพูดถึงองค์ประกอบเป็นอาร์กิวเมนต์ไปยัง array function.push () และองค์ประกอบที่กล่าวถึงจะถูกเพิ่มเป็นองค์ประกอบสุดท้ายในอาร์เรย์
4.2 อาร์เรย์ . pop ()
var arr1 = [ 1 , 2 , 3 , 4 , 5 ] ;
arr1 . pop ( ) ; // removes last element from the array
arr1 . pop ( 23 ) ; // removes last element despite giving the number as argument
arr1 . pop ( "lol" ) ; // removes last element despite giving the string as argument
console . log ( arr1 ) ; // it prints [1,2,3,4]อาร์เรย์ . pop () เป็นเพียงฟังก์ชั่น mutator ง่าย ๆ สำหรับการลบองค์ประกอบสุดท้ายของอาร์เรย์ ดังนั้นวิธีการไม่ได้ใช้ข้อโต้แย้งแม้ว่าเราจะพยายามผ่านข้อโต้แย้งก็จะไม่นำมาใช้ มันดำเนินการเฉพาะการดำเนินการพื้นฐานของการลบองค์ประกอบสุดท้ายของอาร์เรย์
4.3 อาร์เรย์ . indexof ()
var arr1 = [ "akhil" , "chandu" , "adheeth" , "varma" ] ;
var arr2 = [ "akhil" , "chandu" , "adheeth" , "varma" , "akhil" , "shankar" , "akhil" ] ;
arr1 . indexOf ( "akhil" ) ; // returns 0 since akhil is present at index 0
arr1 . indexOf ( "adheeth" ) ; // returns 2 since adheeth is present at index 2
arr2 . indexOf ( "akhil" ) ; // returns 0 because it is the first occurrence of akhilarray .indexof () เป็นฟังก์ชัน accessor ที่สามารถใช้สำหรับการค้นหาดัชนีขององค์ประกอบเฉพาะในอาร์เรย์ อาร์กิวเมนต์ที่จะส่งผ่านไปยังสิ่งนี้คือค่าขององค์ประกอบในอาร์เรย์ นอกจากนี้ยังมีข้อสังเกตว่าเมื่อมีหลายเหตุการณ์ที่เกิดขึ้นขององค์ประกอบเดียวกันในข้อมูลจากนั้นการเกิดขึ้นครั้งแรกขององค์ประกอบในอาร์เรย์จะปรากฏขึ้น
4.4 อาร์เรย์ . lastindexof ()
var arr1 = [ "akhil" , "chandu" , "adheeth" , "varma" , "akhil" , "shankar" , "akhil" ] ;
arr1 . lastIndexOf ( "akhil" ) ; // returns 6 since akhil last occurred at index 6
arr1 . lastIndexOf ( "adheeth" ) ; // returns 2 since adheeth last occurred at index 2 array . lastindexof () เป็นฟังก์ชั่น accessor ค่อนข้างคล้ายกันในพฤติกรรมกับฟังก์ชัน indexOf แม้ว่าความแตกต่างคือ lastIndexOf ส่งคืนดัชนีของการเกิดขึ้นครั้งสุดท้ายขององค์ประกอบในอาร์เรย์
4.5 อาร์เรย์ . concat ()
var arr1 = [ "akhil" , "chandu" ] ;
var arr2 = [ "adheeth" , "varma" , "kp" ]
var arr3 = [ ]
arr1 . concat ( arr2 ) ; // returns [ 'akhil', 'chandu', 'adheeth', 'varma', 'kp' ]
arr2 . concat ( arr1 ) ; // returns [ 'adheeth', 'varma', 'kp', 'akhil', 'chandu' ]
arr3 = arr1 . concat ( arr2 )
console . log ( arr3 ) // returns [ 'akhil', 'chandu', 'adheeth', 'varma', 'kp' ] array .concat () เป็นฟังก์ชั่น accessor ที่ใช้ในการสร้างอาร์เรย์ใหม่จากอาร์เรย์ที่มีอยู่ ต้องใช้อาร์เรย์เป็นอาร์กิวเมนต์และหลังจากฟังก์ชั่นถูกดำเนินการอาร์เรย์ในอาร์กิวเมนต์จะถูกต่อกันกับการเรียกอาร์เรย์ concat()
4.6 อาร์เรย์ . splice ():
// case 1 :
var arr1 = [ 1 , 2 , 3 , 4 , 5 ] ;
nums = [ 6 , 7 , 8 , 9 , 10 ]
arr1 . splice ( 5 , 0 , nums )
console . log ( arr1 ) ; // it prints [1, 2, 3, 4, 5, [6, 7, 8, 9, 10]]
// case 2 :
var arr2 = [ 'one' ] ;
arr2 . splice ( 1 , 0 , 'two' , 'three' , 'four' , 'five' ) ;
console . log ( arr2 ) ; // it prints ['one', 'two', 'three', 'four', 'five']
// case 3 :
var arr3 = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ] ;
arr3 . splice ( 5 , 5 ) ;
console . log ( arr3 ) ; // it prints [1, 2, 3, 4, 5]อาร์เรย์ .splice () มีชุดการดำเนินการที่หลากหลายซึ่งสามารถดำเนินการได้ หากเราสังเกตกรณีที่ 1 เรากำลังเพิ่มองค์ประกอบลงในอาร์เรย์ Arr1 จากดัชนีที่ห้า นอกจากนี้หากเราสังเกตในกรณีที่ 2 เราจะเห็นได้ว่าโดยไม่ต้องกำหนดตัวแปรองค์ประกอบที่จะเพิ่มจะถูกส่งผ่านเป็นอาร์กิวเมนต์ต่อเนื่อง เป็นที่น่าสังเกตว่าการประกบไม่เพียง แต่สามารถดำเนินการในการเพิ่มองค์ประกอบ แต่ยังดำเนินการในการลบองค์ประกอบ ในฟังก์ชั่น splice () ถ้าเราเลือกค่าของอาร์กิวเมนต์ที่สองเป็น '0' องค์ประกอบจะถูกเพิ่มจากดัชนีที่ระบุเท่านั้นแม้ว่าค่าจะไม่ '0' จำนวนที่ระบุจะเป็นจำนวนองค์ประกอบที่จะถูกลบออก
4.7 อาร์เรย์ . Shift ():
var arr1 = [ 1 , 2 , 3 , 4 , 5 , "akhil" , "chandu" , "varma" , "kp" , "adheeth" ] ;
arr1 . shift ( ) ;
arr1 . shift ( 123 ) ;
arr1 . shift ( "lolagain" ) ;
console . log ( arr1 ) ; // it prints [4,5,6,"akhil","chandu","varma","kp","adheeth"]อาร์เรย์ . shift () ไม่แตกต่างจากวิธีการดังกล่าวข้างต้น array.pop () แม้ว่าความแตกต่างที่สำคัญจะเกิดขึ้นเกี่ยวกับดัชนีขององค์ประกอบที่จะถูกลบออก มันลบองค์ประกอบแรกของอาร์เรย์ เช่นเดียวกับ array.pop () วิธีนี้ยังไม่ได้รับการโต้แย้งและแม้ว่าการโต้แย้งจะผ่านไปแล้วมันก็ยังคงดำเนินการต่อไป
4.8 อาร์เรย์ . unshift ():
var arr1 = [ 1 , 2 , 3 , 4 , 5 ] ;
str = "akhil pandey" ;
arr1 . unshift ( str ) ;
console . log ( arr1 ) ; // it prints ["akhil pandey", 1, 2, 3, 4, 5];อาร์เรย์ . unshift () ตกอยู่ในหมวดหมู่เดียวกับของ array.push () เนื่องจากทั้งสองใช้เป็นฟังก์ชั่น mutator สำหรับการเพิ่มองค์ประกอบลงในอาร์เรย์ ความแตกต่างเพียงอย่างเดียวระหว่างวิธีการทั้งสองคือถ้าเราผ่านอาร์กิวเมนต์ไปยังอาร์เรย์ unshift () จากนั้นองค์ประกอบจะถูกเพิ่มเป็นองค์ประกอบแรกของอาร์เรย์ หากเราสังเกตตัวอย่างด้านบนเราจะเห็นได้ว่าดัชนีขององค์ประกอบ '1' ถูกเลื่อนไปยังสถานที่ต่อไปและ "Akhil Pandey" จะถูกเพิ่มเป็นองค์ประกอบแรกของอาร์เรย์ ดังนั้นแตกต่างจาก array.push () วิธีนี้ไม่ควรเข้าใจผิดสำหรับการเพิ่มองค์ประกอบเท่านั้นเนื่องจากมันเพิ่มองค์ประกอบในการเริ่มต้นของอาร์เรย์
4.9 Array .Reverse ():
var arr1 = [ 1 , 'akhil' , 'varma' , 'chandu' , 'adheeth' ] ;
arr1 . reverse ( ) ;
console . log ( arr1 ) ; // it prints ['adheeth', 'chandu', 'varma', 'akhil', 1]อาร์เรย์ . reverse () เป็นเพียงฟังก์ชั่น mutator ที่ใช้เพื่อย้อนกลับลำดับขององค์ประกอบในอาร์เรย์
4.10 Array .sort ():
var arr1 = [ 'varma' , 'chandu' , 'akhil' , 'adheeth' ] ;
var arr2 = [ 5 , 6 , 2 , 9 , 23 ] ;
arr1 . sort ( ) ;
arr2 . sort ( ) ;
console . log ( arr1 ) ; // it prints ['adheeth', 'akhil', 'chandu', 'varma']
console . log ( arr2 ) ; // it prints [2, 5, 6, 9, 23]Array .sort () ยังเป็นฟังก์ชัน mutator อื่นที่ใช้ในการวางองค์ประกอบตามลำดับ ทั้งสตริงและตัวเลขสามารถจัดเรียงได้โดยใช้วิธี array.sort () การเรียงลำดับจะเกิดขึ้นตามลำดับจากน้อยไปหามากดังนั้นหากสตริงหรือตัวละครเป็นองค์ประกอบแล้วขึ้นอยู่กับระดับตัวอักษรการเรียงลำดับจะเกิดขึ้น
4.11 Array .Map ():
function add ( arr ) {
return arr = "My name is " + arr ;
}
var arr1 = [ "akhil" , "varma" , "chandu" , "adheeth" , "kp" ] ;
var combine = arr1 . map ( add ) ;
console . log ( combine ) ;
/* it prints
[ 'My name is akhil',
'My name is varma',
'My name is chandu',
'My name is adheeth',
'My name is kp' ]
*/Array .Map () เป็นวิธีการที่เหมือนฟังก์ชันตัววนซ้ำ แต่ความแตกต่างพื้นฐานระหว่างสิ่งนี้และ array.foreach () คือ array.map () ส่งคืนอาร์เรย์ใหม่พร้อมผลลัพธ์ในขณะที่ array.foreach () ไม่คืนอาร์เรย์ใหม่
หมายเหตุ: array.map () เป็นวิธีที่ทรงพลังมากและสามารถนำไปใช้กับแอปพลิเคชันที่หลากหลาย แม้ว่าวิธีนี้จะวนซ้ำมากกว่าแต่ละองค์ประกอบโดยใช้ array.map () จะต้องดูอย่างระมัดระวังและไม่ควรนำไปใช้หากวัตถุประสงค์กำลังทำซ้ำองค์ประกอบบางอย่าง
4.14 อาร์เรย์ . reduce ():
function combine ( prev , curr ) {
return prev + curr ;
}
var arr1 = [ 1 , 2 , 3 , 4 , 5 ] ;
var arr2 = [ "one " , "two " , "three " , "four " , "five " ] ;
var numsum = arr1 . reduce ( combine ) ;
var worsum = arr2 . reduce ( combine ) ;
console . log ( numsum ) ; // it prints 15
console . log ( worsum ) ; // it prints "one two three four five "อาร์เรย์ . Reduce () เป็นวิธีการที่สามารถใช้กับอาร์เรย์ได้โดยใช้ฟังก์ชันเป็นอาร์กิวเมนต์ดังนั้นจึงทำให้ฟังก์ชั่นซ้ำกับองค์ประกอบอาร์เรย์ array.reduce () วนซ้ำองค์ประกอบอาร์เรย์และเมื่อถึงจุดสิ้นสุดของอาร์เรย์ให้ค่าเดียว
หมายเหตุ: array.reduceright () มีความคล้ายคลึงกับ array.reduce () มากกว่า แต่มันจะวนซ้ำองค์ประกอบอาร์เรย์จากองค์ประกอบขวาสุดไปยังองค์ประกอบซ้ายสุดแทนที่จะไปตามปกติ
TIPS[Arrays] :
MISC[Arrays] :
จัดการวัตถุอาร์เรย์โดยการเขียนวิธีการของคุณเอง :
var boo = [ ]
Array . prototype . foo = function ( ) {
console . log ( "We write our method inside this block" )
}
boo . foo ( ) // returns whatever is included inside the above mentioned code blockการเพิ่มวิธีการในอาร์เรย์พรีโตปเป้เป็นหลักหมายความว่าเรากำลังเพิ่มวิธีการลงในวัตถุอาร์เรย์ทั่วโลก ดังนั้นอาร์เรย์ prototype จะหมายความว่าการเพิ่มต้นแบบใหม่ให้กับวัตถุอาร์เรย์ที่มีอยู่ ดังนั้นการเปรียบเทียบที่ดีกว่าสามารถอธิบายได้ด้วยตัวอย่างโค้ดด้านล่าง
Array . prototype . union = function ( bar ) {
var l = this . length ;
var n = bar . length ;
for ( i = 0 ; i < n ; ++ i ) {
this [ l ] = bar [ i ] ;
l ++ ;
}
console . log ( this ) ;
}
var a = [ "one" , "two" ] ;
var b = [ "three" , "four" , "five" , "six" , "seven" ] ;
var c = [ 1 , 2 ] ;
var d = [ 3 , 4 , 5 , 6 , 7 ] ;
a . union ( b ) ;
c . union ( d ) ;การสังเกตต้นแบบอาร์เรย์ข้างต้นหากเราสามารถสังเกตได้อย่างรอบคอบว่ามันไม่มีอะไรนอกจากแบบจำลองการทำงานของวิธีการอาร์เรย์เมธอดอาร์เรย์ prototype.concat () ทำงานอย่างไร ดังนั้นในวิธีการ concat () อาร์เรย์อื่นจะถูกส่งผ่านเป็นอาร์กิวเมนต์ไปยังวิธีการและอาร์เรย์หลัก concats และขยายอาร์เรย์
สิ่งที่ควรค้นหาในตัวอย่างข้างต้นคือวิธีการเขียนวิธีการแบบกำหนดเองเพื่อให้เหมาะกับวัตถุประสงค์เฉพาะที่ไม่เพียง แต่ต้นแบบอาร์เรย์เท่านั้น
อาร์เรย์เชื่อมโยง :
โดยเฉพาะอย่างยิ่งนี่เป็นส่วนที่ดีของภาษาแม้ว่านี่จะเป็นส่วนสำคัญของภาษาการเขียนโปรแกรมจำนวนมากเช่น PHP และ Python แต่ก็มีการเปลี่ยนแปลงเล็กน้อยกับสิ่งที่เสนอในภาษาการเขียนโปรแกรมอื่น ๆ
[หมายเหตุ]: ใน Python มันไม่ได้เรียกหรือเรียกว่าเป็นอาร์เรย์เชื่อมโยง แต่มาพร้อมกับพจนานุกรมชื่อ
var a = [ ] ;
var b = [ ] ;
a [ "one" ] = "boo this is my first item" ;
a [ "two" ] = "foo this is my second item" ;
a [ "three" ] = "alas this is final item" ;
b [ 0 ] = "oh not again the first item" ;
b [ 1 ] = "cant help with the second item" ;
b [ 3 ] = "finally got rid with the third item" ;
console . log ( a ) ; // would display the contents of the array 'a'
console . log ( b ) ; // would display the contents of the array 'b'
var len1 = a . length ;
var len2 = b . length ;
var len3 = Object . keys ( a ) . length ;
console . log ( len1 ) ; // would display undefined
console . log ( len2 ) ; // would display 3
console . log ( len3 ) ; // would display 3ตัวอย่างด้านบนเป็นการใช้งานกรณีคลาสสิกของอาร์เรย์ที่มีดัชนีที่มีชื่อหรืออาร์เรย์เชื่อมโยง การใช้งานสามารถทำได้ตามที่กล่าวไว้ข้างต้นและการดำเนินการอาร์เรย์เกือบทั้งหมดยกเว้นบางส่วนสามารถดำเนินการได้อย่างราบรื่นมากด้วยดัชนีที่มีชื่อ ปัญหาเกิดขึ้นเมื่ออาร์เรย์ที่มีดัชนีที่มีชื่อถูกถามถึงความยาว เมื่อวิธีการ 'array.prototype.length ()' จะถูกส่งกลับจะส่งคืนเฉพาะความยาวของอาร์เรย์ที่มีดัชนี numberD ถ้าเราใช้ดัชนีที่มีชื่อว่ามันจะไม่ดีเพราะดัชนีเป็นสตริง แต่ไม่มีตัวเลขอีกต่อไป
ในกรณีเช่นนี้หากเราจำเป็นต้องส่งคืนความยาวของอาร์เรย์ที่มีการจัดทำดัชนีที่มีชื่อจากนั้น Object.keys (arrayname). ความยาวจะให้ความยาวของอาร์เรย์เดียวกันจะถูกอธิบายโดยการใช้ตัวแปรสามตัว 'len1', 'len2', 'len3' len1
วิธีการที่เป็นส่วนหนึ่งของวัตถุ สตริง JavaScript:
5.1 String .charat ():
var str1 = "akhil" ;
str1 . charAt ( - 1 ) ; // returns '' or empty string
str1 . charAt ( 3 ) ; // returns 'i' as it is located at position 3
str1 . charAt ( 7 ) ; // returns '' or empty string String .charat () เป็นวิธีการที่สามารถใช้สำหรับการกำหนดอักขระที่มีอยู่ในดัชนีเฉพาะของสตริงที่กำหนด ฟังก์ชั่นใช้เวลาเพียงหนึ่งอาร์กิวเมนต์และส่งคืนอักขระเป็นเอาต์พุต จะต้องสังเกตว่าเมื่อดัชนีที่ได้รับเป็นอินพุตหากมากกว่าหรือน้อยกว่าความยาวสตริงจากนั้นฟังก์ชั่นจะส่งคืน '' หรือสตริงว่างเป็นเอาต์พุต
5.2 สตริง . concat ():
var str1 = "akhil" ;
var str2 = "pandey" ;
str1 . concat ( str2 ) ; // returns the string 'akhilpandey'
str1 . concat ( 1234 ) ; // returns the string 'akhil1234'
str1 . concat ( true ) ; // returns the string 'akhiltrue'
str1 . concat ( null ) ; // returns the string 'akhilnull'
str1 . concat ( undefined ) ; // returns the string 'akhilundefined'
str1 . concat ( [ 1 , 2 , 3 , 4 , 5 ] ) ; // returns the string 'akhil1,2,3,4,5'
str1 . concat ( " " , 12 , 34 , 56 , 78 ) ; // returns the string 'akhil 12345678'
str1 . concat ( { a : "123" , b : "456" } ) ; // returns the string 'akhil[object Object]' String .concat () เป็นวิธีที่ใช้ในการรวมสายสองสายขึ้นไปเพื่อส่งคืนสตริงใหม่ โดยพื้นฐานแล้ววิธีนี้ใช้สำหรับการดำเนินการสตริง แต่ถ้าโดยทั่วไปแล้วสตริงจะถูกต่อกันกับประเภทอื่นผลลัพธ์จะเป็นสตริง หากเราสังเกตตัวอย่างข้างต้นเราจะเห็น str1.concat(true) ดังนั้นที่นี่สตริงผลลัพธ์คือ akhiltrue เป็น สตริง .concat () รวมค่าของทั้งสองอาร์กิวเมนต์และสร้างสตริงที่ต่อกันเป็นผลลัพธ์สุดท้าย ขณะนี้มีกรณีพิเศษสำหรับสมมติว่าหาก string พยายามที่จะเชื่อมต่อกับค่าเท็จผลลัพธ์จะเป็นการรวมกันของ string และค่าเท็จ
5.3 String .indexof ():
5.4 สตริง . lastindexof ():
5.5 String .link ():
5.6 String .Search ():
5.4 สตริง . slice ():
TIPS[Strings]:
string.slice () : method string.slice () สกัดส่วนหนึ่งของสตริงและส่งคืนสตริงใหม่ที่หั่นเป็นชิ้น สัญกรณ์ทั่วไปสำหรับการใช้วิธี string.slice คือ string.slice (pos1, pos2) โดยที่ใน pos1 คือตำแหน่งของดัชนีเริ่มต้นและ pos2 คือตำแหน่งของดัชนีการสิ้นสุด จุดที่จะระบุไว้ที่นี่คือถ้าเราใช้เมธอด string.slice () โดยผ่านพารามิเตอร์เชิงลบจากนั้นจะจบลงด้วยการนับและแยกสตริงจากจุดสิ้นสุดไปยังจุดเริ่มต้น และถ้าเรา donot ผ่านพารามิเตอร์ที่สองวิธีการแยกส่วนที่เหลือของสตริง
string.substring () : method string.slice () และ string.substring () ตกอยู่ในหมวดหมู่ของวิธีการเดียวกันที่สามารถใช้สำหรับการแยกชิ้นส่วนหรือชิ้นส่วนของสตริงจากสตริงต้นทาง ความแตกต่างในทั้งสองคือเราไม่สามารถใช้ดัชนีเชิงลบเมื่อใช้ String.substring () ตัวอย่างเช่นถ้าเราส่งดัชนีเชิงลบไปยังวิธีการเช่น string.substring (-7, -1) ดังนั้นมันจึงไม่ได้ระบุข้อผิดพลาดใด ๆ ที่บ่งบอกถึงความผิดพลาดที่เกิดขึ้นสำหรับการใช้ดัชนีเชิงลบ แต่แสดงสตริงโดยรวม
ใน JavaScript:
| ประเภท | สามารถเป็นวัตถุ | มักจะเป็นวัตถุ |
|---|---|---|
| บูลีน | ||
| ตัวเลข | ||
| สาย | ||
| วันที่ | ||
| คณิตศาสตร์ | ||
| การแสดงออกปกติ | ||
| อาร์เรย์ | ||
| ฟังก์ชั่น |
ดังนั้นโดยทั่วไปยกเว้นค่าดั้งเดิมทั้งหมดเป็นวัตถุใน JavaScript
6.1 Objects can be created using three methods :
// creating an oject using an Object literal
var staff = {
name : "somename" ,
branch : "somebranch" ,
salary : "somesalary" ,
age : 20
} ; // creating an object using new keyword
var admin = new Object ( ) ;
admin . name = "somename" ;
admin . department = "somedept" ;
admin . userid = 123 ;
admin . age = 20 ; // creating an object using the object constructor
function student ( name , github_nick , url , age ) {
this . name = name ;
this . github = "https://github.com/" + github_nick ;
this . url = url ;
this . age = age ;
} 6.2 Using the constructor for the above defined Object :
var akhil = new student ( "Akhil Pandey" , "AkhilHector" , "https://www.akhilhector.com" , "20" ) ; 6.3 Accessing object methods :
console . log ( akhil . github ) ;
console . log ( akhil . url ) ; 6.4 Using the prototype property :
student . prototype . show = function ( ) {
return this . name + " " + this . github + " " + this . age ;
} 6.5 Adding methods to the prototype :
function student ( name , github_nick , url , age ) {
this . name = name ;
this . github = "https://github.com/" + github_nick ;
this . url = url ;
this . age = age ;
this . show = function ( ) {
return this . name + " " + this . github + " " + this . age ;
}
} NOTE : วัตถุ Javasctipt นั้นไม่แน่นอนซึ่งหมายความว่าพวกเขาจะอ้างอิงโดยที่อยู่และไม่คุ้มค่า ตัวอย่างเช่นถ้า 'Master' เป็นวัตถุและ 'Master-Backup' ก็เป็นวัตถุอื่นถ้าเราผ่านวัตถุแล้วการเปลี่ยนหนึ่งอาจส่งผลให้เปลี่ยนวัตถุอื่นด้วย
{
var master = { foo : "foo" } ;
var master - backup = master ;
master . backup . bar = "bar" ; // this changes master.bar and master-backup.bar
}
Object . access . property = {
"Option1" : "we can use objectName.propertyName" ,
"Option2" : "Either we can write objectName[propertyName]"
} การปิดฟังก์ชั่นใน JavaScript เป็นเรื่องเกี่ยวกับตัวแปรที่ได้รับการรักษาและอ้างถึงในขอบเขตท้องถิ่นหรือระดับโลกอย่างไร ในตัวแปร JS สามารถให้ได้:
ไม่มีแนวคิดที่สร้างขึ้นสำหรับสิ่งที่เรียกว่าตัวแปรส่วนตัวดังนั้นเมื่อมีข้อกำหนดสำหรับการปิดสถานการณ์ดังกล่าวใน JS เพื่อกำหนดขอบเขตสำหรับตัวแปรที่เป็นส่วนตัวในขอบเขต
Currying เป็นกระบวนการสร้างฟังก์ชั่นโดยใช้ข้อโต้แย้งหลายอย่างและใช้บางส่วนผ่านชุดของฟังก์ชั่น ดังนั้นเพื่อให้เฉพาะเจาะจงคุณสามารถแยกฟังก์ชั่นที่กำหนดซึ่งใช้หลายอาร์กิวเมนต์เป็นชุดของฟังก์ชั่นที่มีส่วนร่วมของอาร์กิวเมนต์
ให้เราเป็นตัวอย่างทั่วไป:
การโทรหางไม่มีอะไรนอกจากการแทนที่แนวคิดของฟังก์ชั่นการเรียกซ้ำด้วยการวนซ้ำ ในทางนี้ไม่เพียง แต่สามารถประหยัดเวลาได้ แต่ยังช่วยประหยัดพื้นที่ได้เช่นความซับซ้อนของเวลาที่ดีขึ้นและความซับซ้อนของพื้นที่
// snippet one
function f ( n ) {
if ( n == 0 ) {
return 1 ;
}
else {
return n * f ( n - 1 ) ;
}
}
// snippet two
function f1 ( n ) {
function r ( n , m ) {
if ( n == 0 ) {
return m ;
}
else {
return r ( n - 1 , n * m ) ;
}
}
return r ( n , 1 ) ;
}การสังเกตทั้งอัลกอริทึมข้างต้นที่เขียนขึ้นเพื่อแฟคทอเรียลเราสามารถเข้าใจได้ว่า f () เป็นวิธีการเรียกซ้ำแบบดั้งเดิมที่ใช้ในการค้นหาแฟคทอเรียล แต่ F1 () เป็นอัลกอริทึมที่ดีที่สุดที่เรียกใช้ซึ่งดีกว่าและรวดเร็ว
แม้ว่าจะมีความพยายามที่ดีที่สุดเพื่อให้แน่ใจว่าเอกสารทั้งหมดไม่มีข้อผิดพลาดอาจมีกรณีเล็ก ๆ ที่อาจเกิดข้อผิดพลาด ในกรณีเช่นนี้โปรดยกประเด็นและช่วยฉันทำให้แผ่นโกงนี้ดีขึ้น
