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" )
}코드 스 니펫 1과 2는 동일합니다. 그러나 두 코드 샘플 사이의 근본적인 차이점은 Lang -uage Semantics에서 세미콜론을 사용하지만 다른 코드 샘플은 반대 방향을 사용하지만 다른 코드 샘플은 세미콜론을 사용한다는 것입니다. 기본적으로 우리는 C, C ++, Java 등과 같은 언어로 세미콜론을 사용하도록 배웁니다. 코드 줄은 ';' 그러나 JavaScript에서는 전체 시나리오가 다릅니다. 세미콜론이 있거나없는 코드 실행에는 전혀 차이가 없습니다.
메소드 JavaScript MAP 객체의 일부 :
2.1 map .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 ()은 맵에서 특정 키와 값이있는 요소를 추가하거나 업데이트하는 데 사용되는 메소드입니다. 여기서 첫 번째 인수는 핵심이며 두 번째 인수는 가치입니다. 키는 모든 유형 일 수 있지만 문자열을 strings 로 사용하면 Maps 과 Objects 사이에 큰 차이가 없기 때문에 strings 대신 objects 열쇠로 사용하는 것이 바람직합니다.
2.2 map .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' map .get ()는 특정 키로 Map 객체에서 요소를 검색하는 데 사용되는 메소드입니다. 따라서 키는 인수로 전달되고 해당 키와 관련된 요소가 반환됩니다. 키가 인수로 전달되지 않으면 메소드가 undefined 상태에서 반환됩니다.
2.3 MAP .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 map .HAS ()는 요청 된 키가있는 요소가지도에 있는지 여부를 나타내는 메소드입니다. 이 메소드는 키인 하나의 인수 만 가져 가고 요소가 존재하거나 요소가없는 경우 false 있으면 true 반환합니다.
2.4 MAP .Size :
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는 Map 객체에 존재하는 요소 수를 반환하는 액세서 속성입니다. 액세서 속성이기 때문에 우리는 이것을 메소드처럼 호출/사용해서는 안됩니다. 따라서 m1.size() 호출되면 m1.size 함수가 아니라고 말하는 유형에 던져집니다. 따라서 해당 속성에 대한 유효한 호출은 m1.size 입니다.
2.5 MAP .Clear () :
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 map .delete ()는 Map 객체에서 특정 요소를 삭제하는 데 사용되는 메소드입니다. 이 메소드는 키인 하나의 인수 만 가져 가고 키가 Map 에 있으면 요소를 삭제하고 true 반환하지만 키가 Map 에 존재하지 않으면 false 발생합니다.
2.7 map .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 map .keys ()는 각 요소의 Map 객체에있는 키를 반환하는 데 사용되는 메소드입니다. 이 메소드는 Map 에있는 키를 알 수있는 맵 반복자 객체를 반환합니다. 위의 예에서는 next() 사용하여 .keys ()를 반복하는 방법이 설명되어 있습니다. next() 반복자 객체에서 사용하는 경우 next() 의 간단한 사용을 통해 Object 표시하기 때문에 value 사용하거나 done 해야합니다. iterator.next().value iterator.next (). iterator.next iterator.next().done 반환 객체에 더 많은 키가 존재하고 더 이상 열쇠가없는 경우 true 가있는 경우 false 말하기를 반환합니다.
2.8 map .Values () :
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 map .Values ()는 각 요소의 Map 객체에있는 값을 반환하는 데 사용되는 메소드입니다. 이 메소드는 Map 에 존재하는 값을 알기 위해 사용할 수있는 반복자 객체를 반환합니다. 위의 예에서는 next() 사용하여 .values ()를 반복하는 방법이 설명되어 있습니다. next() 반복자 객체에서 사용하는 경우 next() 의 간단한 사용을 통해 Object 표시하기 때문에 value 사용하거나 done 해야합니다. iterator.next().value 반복자 객체에 존재하는 특정 요소의 값을 반환하는 동안 iterator.next().done iterator 객체에 더 많은 값이있는 경우 false 말을 반환하고 더 이상 값이없는 경우 true .
2.9 map .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 map .Entries ()는 각 요소의 Map 객체에있는 키와 값을 반환하도록 고소 된 메소드입니다. 이 메소드는 Map 에 존재하는 키와 값을 알 수있는 반복자 객체를 반환한다는 사실에 대해 map .Values ()와 매우 유사합니다. 위의 예에서는 next() 사용하여 .entries ()를 반복하는 방법에 대해 표시됩니다. 메소드의 능력과 작동 방식은 Ierator 객체를 반복 할 때 키가 값과 함께 반환된다는 사실을 제외하고 .values ()와 매우 유사합니다. 일단 비행기의 끝에 도달하면 던지고 undefined 모든 반복 객체와 유사합니다. 또한, 반복자 객체에 적용되는 다른 방법은 하나가 동일하기 때문에 이것과 함께 사용할 수 있습니다.
MISC[Maps] : 약점은 후드에서 쓰레기 수집이 발생하는 방법론의 차이가있는 맵 으로 간주 될 수 있습니다. 그것을 더 간단하고 평범한 용어로 삼으려면 관점을 가져 오기 위해서는 약간의 개념적 교훈이 있어야합니다. JavaScript에서 광범위하게 모든 것이 객체 이므로, 하나를 생성하는 순간과 메모리가 동일하게 할당되고 V8이 자동으로 GC (쓰레기 수집)가 객체가 그래프의 노드로 유지 될 때까지 메모리가 할당됩니다. 메모리에 생성 된 객체에 대한 참조가 없을 때까지 GC'D가되지 않기 때문에 모든 객체가 tightly 또는 strongly 고정됩니다. 따라서 본질적으로 약점 으로 가져 오는 차이점은 객체의 키가 v8에 의해 gc'ded되면 객체의 키가 weakly 고정된다는 것입니다. 약점은 맵 과 약점이 작동하는 방식 사이에는 뚜렷한 차이가 없지만 약점은 객체를 키로 만 수용합니다 (엄격하게). 아래에서 초기화되는 방법을 살펴 보겠습니다.
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가 맵 객체와 동일한 방식으로 우리와 상호 작용하는 방식이지만 약점 API가 제공하는 작업에는 제한이 있습니다. get() , set() , has() 및 delete() 메소드를 지원합니다.
MISC[Maps] : ... 운영자 사용
메소드 JavaScript 세트 객체의 일부 :
3.1 세트 .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 ()는 세트에 값을 추가하기위한 뮤티터 방법입니다. 이것을 달성하는 절차는 간단합니다. 우리는 add() 메소드를 이미 생성 된 Set 객체로 호출하고 원하는 값을 세트로 인수로 전달합니다. 하나 이상의 인수가 add() 메소드로 전달되면 나머지 인수를 무시하고 첫 번째 인수 만 고려합니다. Set 객체는 전달되는 값 유형에 대한 제한이 없으며 Set 이질적으로 만들 때 제한을 시행하지 않는다는 점에 유의해야합니다. NaN , null 도 Set 의 일부가 될 수 있습니다. 비록이 특성의 값으로 Set 채우는 것이 권장되지 않습니다.
3.2 세트 .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와 부동 소수점 값 사이의 10 년간 경쟁에 대해 약간의 빛을 비추는 한 예입니다. 숫자 .teprecision ()을 사용하면 간단히 피할 수 있습니다. 또한 JavaScript에서는 항상 부동 소수점을 신중하게 처리하는 것이 좋습니다.
3.3 세트 .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 세트 .size는 메소드가 아니지만 Set 의 크기를 결정하는 데 유용한 세트 객체의 속성입니다. 위의 코드 스 니펫에서 관찰 할 수 있듯이 액세서 방법과 같습니다. size() 사용하여 속성 을 호출하려고하면 Set.size 함수가 아닙니다.
3.4 세트 .clear () :
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 비워집니다. 위의 코드 스 니펫에서 관찰되면 세트 .clear () 메소드에 인수를 전달하려는 시도가 있으며, 단지 무시하고 Set 에서 clear() 작업을 수행하는 메소드에 전달되는 인수에 관계없이 어떤 인수가 전달되는지에 관계없이 또한 작업이 수행되는 횟수에 대한 제한이 없습니다.
3.5 세트 .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 세트 .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 동일한 요소와 동일한 요소와 키와 값을 갖기 때문에 set .values ()와 set .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 에서 키와 값이 동일하게 유지된다는 것을 이해해야하므로 set .entries () 메소드를 호출 할 때 n [0]과 n [1]이 동일한 값을 포함하는 nx2 배열 값입니다. 또한 s1.entries() 변수 또는 상수에 할당 할 수 있으며,이 경우 next() 사용하여 재생할 수있는 반복 객체를받을 수 있습니다.
MISC[Sets] : 약점
MISC[Sets] : ... 운영자 사용
메소드 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 ()는 배열에 요소를 추가하기위한 뮤지토 기능 일뿐입니다. 따라서 요소를 함수 배열에 대한 인수로 언급 할 수 있으며 언급 된 요소는 배열의 마지막 요소로 추가됩니다.
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 ()은 배열의 마지막 요소를 제거하기위한 간단한 뮤티토터 기능입니다. 따라서이 방법은 인수를 받아들이지 않지만 논쟁을 통과하려고하면 인수를 받아들이지 않을 것입니다. 배열의 마지막 요소를 제거하는 기본 작동 만 수행합니다.
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 akhil배열 .indexof ()는 배열에서 특정 요소의 인덱스를 찾는 데 사용할 수있는 액세서 기능입니다. 이것에 전달되는 인수는 배열의 요소의 값입니다. 또한 데이터에 동일한 요소의 여러 발생이있을 때 배열에서 요소의 첫 번째 발생이 표시됩니다.
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 배열 .lastIndexof ()는 액세서 함수이며, 함수 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' ] 배열 .concat ()은 기존 배열에서 새 배열을 만드는 데 사용되는 액세서 기능입니다. 배열을 인수로 사용하고 함수가 실행 된 후 인수의 배열이 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 ()의 것과 동일한 범주에 속하며, 둘 다 배열에 요소를 추가하기위한 뮤지토 기능으로 사용되므로. 두 방법의 유일한 차이점은 인수를 Array.unshift ()로 전달하면 배열의 첫 번째 요소로 요소가 추가된다는 것입니다. 위의 스 니펫을 관찰하면 요소 '1'의 인덱스가 다음 장소로 이동하고 "Akhil Pandey"가 배열의 첫 번째 요소로 추가된다는 것을 알 수 있습니다. 따라서 array.push ()와 달리이 메소드는 배열 시작에 요소를 추가하므로 요소를 추가하기 위해서만 오해해서는 안됩니다.
4.9 배열 .reverse () :
var arr1 = [ 1 , 'akhil' , 'varma' , 'chandu' , 'adheeth' ] ;
arr1 . reverse ( ) ;
console . log ( arr1 ) ; // it prints ['adheeth', 'chandu', 'varma', 'akhil', 1]배열 .reverse ()는 배열에서 요소의 순서를 역전시키는 데 사용되는 뮤지티 함수 일뿐입니다.
4.10 배열 .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]배열 .sort ()는 또한 요소를 순서대로 두는 데 사용되는 또 다른 뮤지토 기능입니다. 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 ()는 반복자 함수와 비슷한 메소드이지만 this와 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 "Array .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배열에 메소드를 추가하는 것은 본질적으로 글로벌 배열 개체에 메소드를 추가하고 있음을 의미합니다. 따라서 Array.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에 대한 인수로 다른 배열이 전달되고 배열을 확장합니다.
위의 예에서 조회해야 할 사항은 어레이 프로토 타입뿐만 아니라 문자열, 번호, Regexp 또는 객체 자체와 같은 모든 javscript 인식 객체에 대한 특정 목적에 맞게 사용자 정의 메소드를 작성하는 방법입니다.
연관 배열 :
바람직하게는 PHP 및 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 ()'메소드가 참조되면 숫자 인덱스가있는 배열의 길이 만 반환합니다. 인덱스를 사용하면 인덱스가 문자열이지만 더 이상 숫자가 아니기 때문에 좋지 않습니다.
이 경우 이름이 지정된 인덱스 배열의 길이를 반환 해야하는 경우 객체 (ArrayName) .Length는 배열의 길이를 제공합니다. 동일한 변수 'len1', 'len2', 'len3', 'len3', len1 '의 길이는'len1 '의 길이를 모두 저장하는데, len1'의 길이는 3 번 길이로 돌아갑니다.
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 String .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 문자열 .indexof () :
5.4 String .lastIndexof () :
5.5 String .link () :
5.6 문자열 .search () :
5.4 문자열 .slice () :
TIPS[Strings]:
String.slice () : method string.slice ()는 본질적으로 문자열의 일부를 추출하고 슬라이스 된 새 문자열을 반환합니다. string.slice 메소드를 사용하기위한 일반적인 표기법은 string.slice (pos1, pos2)입니다. 여기서 POS1의 위치는 시작 인덱스의 위치이고 POS2는 엔드 인덱스의 위치입니다. 여기서 언급되는 요점은 음의 매개 변수를 전달하여 String.slice () 메소드를 사용하는 경우 끝에서 시작으로 문자열을 계산하고 추출하게됩니다. 그리고 우리가 두 번째 매개 변수를 통과하면 방법은 문자열의 나머지 부분을 추출합니다.
string.substring () : method string.slice () 및 string.substring ()은 소스 문자열에서 문자열의 부분 또는 부분을 추출하는 데 사용할 수있는 동일한 범주의 메소드에 속합니다. 두 가지의 차이점은 Method String.substring ()을 사용할 때 음수 인덱스를 사용할 수 없다는 것입니다. 예를 들어 String.substring (-7, -1)과 같은 메소드에 음수 인덱스를 전달하면 Negative Index를 사용하기 위해 발생한 실수를 나타내는 오류가 없지만 String을 전체 표시합니다.
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 객체는 음소거되므로 값이 아닌 주소로 참조됩니다. 예를 들어 'Mas
{
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로 작성됩니다.
카레는 여러 인수를 취하고 일련의 기능을 통해 부분적으로 적용하여 함수를 구축하는 과정입니다. 따라서 구체적으로, 여러 인수를 인수에 참여하는 일련의 함수로 가져 오는 주어진 기능을 분해 할 수 있습니다.
일반적인 예를 들어 보겠습니다.
테일 콜은 재귀 함수의 개념을 루프로 대체하는 것뿐입니다. 어떤 방식으로 이것은 시간을 절약 할 수있을뿐만 아니라 공간을 절약 할 수 있습니다. 즉, 더 나은 시간 복잡성과 공간 복잡성.
// 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 ) ;
}Factorial에 대해 작성된 위의 알고리즘을 모두 관찰하면 F ()가 Factorial을 찾는 데 사용되는 전통적인 재귀 방법이지만 F1 ()는 더 좋고 빠른 Tail Call 최적화 알고리즘이라는 것을 이해할 수 있습니다.
전체 문서가 오류가 없는지 확인하기 위해 최선의 노력을 기울 였지만 실수가 발생한 작은 사례가있을 수 있습니다. 이 경우 문제를 제기 하고이 치트 시트를 개선하도록 도와주세요.
