LearnJS
1.0.0
LearnJsé uma tentativa de retratar as melhores partes do JavaScript que são bastante difíceis e difíceis de encontrar. Deve -se notar que este não é um livro/guia de nenhuma forma, mas uma congregação de melhores práticas, construções de linguagem e outros trechos simples, porém eficazes, que nos dão uma essência de como podemos aproveitar o melhor da língua.
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 ( ) { } ; Temos que entender o fato de que, no JavaScript, tudo é um objeto; portanto, suponha que, se declararmos uma string usando o objeto String e compará -lo com var a = "" , o resultado da comparação seria falso. Isso ocorre simplesmente porque, se declararmos uma string usando a maneira bad e a compararmos com uma string declarada usando a good maneira e, fundamentalmente, estamos comparando uma string com um objeto (string).
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" )
}O snippet de código um e dois são iguais. Mas a diferença fundamental entre as duas amostras de código é que um usa semicolons na semântica de Lang -uage, mas enquanto o outro não. Basicamente, somos ensinados a usar semicolons em idiomas como C, C ++, Java etc, já que as linhas de código são encerradas usando ';' Mas em JavaScript, todo o cenário é diferente. Não há absolutamente nenhuma diferença na execução do código com ou sem semicolons.
Métodos parte do objeto JavaScript Mapa :
2.1 mapa .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 () é o método que é usado para adicionar ou atualizar um elemento com uma chave e valor específicos em um mapa. Aqui, o primeiro argumento é a chave enquanto o segundo argumento é o valor. As teclas podem ser de qualquer tipo, mas seria preferível usar objects como teclas em vez de strings , porque se usarmos strings como chaves, não haveria diferença significativa entre Maps e Objects .
2.2 mapa .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 () é um método usado para recuperar um elemento do objeto Map com uma chave específica. Portanto, a chave é passada como um argumento e o elemento associado a essa chave é retornado. Se nenhuma chave for passada como argumento, o método retornará com undefined .
2.3 mapa .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 Mapa .has () é um método que indica se um elemento com a chave solicitado está presente no mapa ou não. O método leva apenas um argumento que é a chave e retorna um true se o elemento estiver presente ou false se o elemento não estiver presente.
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 é uma propriedade acessadora que retorna o número de elementos presentes no objeto Map . Como é uma propriedade acessadora, não devemos chamar/usar isso como um método; portanto, se m1.size() for chamado, ele lança um TypeError dizendo que m1.size não é uma função. Portanto, a chamada válida para essa propriedade é m1.size .
2.5 mapa .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 () é um método que limpa/remove todos os elementos presentes no objeto Map . O método não leva nenhum argumento, mas lança undefined em troca.
2.6 mapa .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 () é o método que é usado para excluir um elemento específico do objeto Map . O método leva apenas um argumento que é a chave e se a chave estiver presente no Map , ele exclui o elemento e retorna um true , mas se a chave não estiver presente no Map , ele lança um false .
2.7 mapa .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 () é um método usado para retornar as teclas presentes no objeto Map para cada elemento. O método retorna um objeto de iterador de mapa que pode ser usado para conhecer as chaves presentes no Map . No exemplo acima, está descrito como iterar sobre o mapa .Keys () usando next() . Deve -se notar que, quando next() é usado no objeto Iterador , value ou done deve ser usado porque um uso direto do next() resulta na exibição de um Object . iterator.next().value retorna o valor da chave presente no objeto iterador enquanto iterator.next().done retém um ditado booleano false se houver mais chaves presentes no objeto Iterador e true se não houver mais chaves presentes.
2.8 mapa .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 () é um método usado para retornar os valores presentes no objeto Map para cada elemento. O método retorna um objeto iterador que pode ser usado para conhecer os valores presentes no Map . No exemplo acima, está descrito como iterar sobre o mapa .Values () usando next() . Deve -se notar que, quando next() é usado no objeto Iterador , value ou done deve ser usado porque um uso direto do next() resulta na exibição de um Object . iterator.next().value retorna o valor de um elemento específico presente no objeto iterador enquanto iterator.next().done Retorna um ditado booleano false se houver mais valores presentes no objeto iterador e true se não houver mais valores presentes.
2.9 mapa .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 () é um método que é processado para retornar as chaves e os valores presentes no objeto Map para cada elemento. O método é bastante semelhante ao mapa .Values () para o fato de retornar um objeto iterador que pode ser usado para conhecer as chaves e os valores presentes no Map . No exemplo acima, é exibido sobre como iterar sobre o mapa .Entries () usando next() . A capacidade do método e sua maneira de operação são bastante semelhantes para mapear .Values (), exceto pelo fato de que as chaves também são retornadas junto com os valores à medida que iteramos sobre o objeto Iterador . Semelhante a qualquer objeto de iterador quando atingir o final de seu plano, jogaria e undefined . Além disso, deve -se notar que qualquer outro método que se aplique a um objeto iterador possa ser usado com isso, pois é o mesmo.
MISC[Maps] : Mapas fracos podem ser considerados mapas com diferenças na metodologia da qual as coleções de lixo acontecem sob o capô. Para colocá -lo em terminologia mais simples e simples, deve haver uma pequena lição conceitual contada para trazer perspectiva. No JavaScript, tudo é um objeto , portanto, o momento em que você cria um e a memória está sendo alocada para o mesmo e até que o V8 automaticamente os GCs (abreviação de lixo coleta), o objeto permanece como um nó no gráfico. Deve -se notar que, até que não haja referências ao objeto criado na memória, ele não seria GC'D, então todos os objetos são mantidos tightly ou strongly . Então, essencialmente, a diferença que está sendo trazida com mapas fracos é que as chaves do objeto são mantidas weakly a partir de agora, se o objeto for gc'd por v8 ou por você, a entrada será removida do mapa fraco, mas não é valores. Não há diferença gritante entre a maneira como os mapas e os mapas fracos operam, embora os mapas fracos aceitem apenas objetos como chaves (estritamente). Vejamos abaixo para ver como eles são inicializados:
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. Deve -se notar que, embora a maneira como a API de mapas fracos interaja conosco da mesma maneira que o objeto Maps , existem limitações para as operações fornecidas pela API de fracos . Ele suporta métodos get() , set() , has() e delete() a partir de agora.
MISC[Maps] : Uso de ... Operador
Métodos parte do objeto 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 () é um método do mutador para adicionar valores a um conjunto. O procedimento para conseguir isso é direto. Chamamos o método add() para o objeto Set já criado e passamos o valor que queremos no conjunto como um argumento. Quando mais de um argumento é passado para o método add() ele apenas ignora os argumentos restantes e considera apenas o primeiro argumento. Deve -se notar que o objeto Set não possui nenhuma restrição ao tipo de valor que está sendo aprovado, nem aplica nenhuma restrição quando faz o Set heterogêneo. NaN , null também pode fazer parte de um Set . Embora, nunca seja incentivado a preencher o Set com valores dessa natureza.
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 () é um método útil para determinar se existe um elemento no Set ou não. O método retorna true se o valor estiver presente e false se o valor não estiver presente. Se observarmos o exemplo acima, há uma pequena disparidade entre a natureza esperada do método e sua realidade fundamental. s1.add(123.0000000000000009123) é um exemplo que lança alguma luz sobre a rivalidade de uma década entre os valores de JavaScript e pontos flutuantes. Isso pode ser evitado simplesmente usando o número .Toprecision (). Além disso, em JavaScript, é sempre incentivado a lidar com os pontos flutuantes com cuidado.
3.3 Definir .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 Definido .Size não é um método, mas é uma propriedade do objeto Sets útil para determinar o tamanho do Set . Como você pode observar no trecho de código acima, ele é chamado apenas como um método de acessório. Se tentarmos ligar para a propriedade usando size() , ele lança um TypeError dizendo Set.size não é uma função.
3.4 Set .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 () é um método que limpa todos os elementos presentes no conjunto. Isso resulta no esvaziamento do Set . Se observarmos no trecho de código acima, há uma tentativa de passar um argumento para o método .Clear () e independentemente de que argumento é passado para o método, ele simplesmente ignora e executa a operação clear() no Set . Além disso, não há restrição ao número de vezes em que a operação é realizada.
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 () é um método usado para remover um elemento do conjunto. O método aceita apenas um argumento e retorna um valor booleano true ou false . Se mais de um argumento for passado para delete() , ele apenas ignora os argumentos restantes e considera apenas o primeiro argumento.
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 () é um método que retorna os valores presentes no Set . Se usarmos s1.values() em um loop, como mostrado no trecho de código acima, tudo o que voltamos é um valor à medida que iteramos sobre o Set . Além disso, isso pode parecer semelhante ao método no Map , mas há uma pequena distinção, que é mapa .Values () retornaria apenas os valores presentes no Map e no mapa .Keys () retornaria apenas as teclas associadas a todos os valores/elemento. Agora, como um Set tem chave e valor como o mesmo elemento, não há muita distinção entre o set .Values () e Set .Keys (). Seríamos devolvidos com os mesmos objetos iteráveis, sem nenhuma diferença.
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 () é um método que retorna uma matriz de valores para os valores presentes no Set . Temos que entender que em um Set a chave e o valor permanecem os mesmos; portanto, quando chamamos o método .Entries (), tudo o que obtemos é uma matriz NX2 de valores em que n [0] e n [1] contêm o mesmo valor. Também podemos atribuir s1.entries() a uma variável ou uma constante e, nesse caso, obteríamos um objeto de iterador em troca que poderia ser reproduzido usando next() .
MISC[Sets] : Free Sets
MISC[Sets] : Uso de ... Operador
Métodos parte do objeto JavaScript Array :
4.1 Array .push ():
var arr1 = [ 1 , 2 , 3 , 4 , 5 ] ;
arr1 . push ( 6 ) ;
console . log ( arr1 ) ; // it prints [1,2,3,4,5,6]Array .push () é apenas uma função do mutador para adicionar elementos à matriz. Portanto, podemos simplesmente mencionar o elemento como um argumento para a matriz de funções.push () e o elemento mencionado seria adicionado como o último elemento na matriz.
4.2 Array .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]Array .pop () é apenas uma função simples do mutador para remover o último elemento da matriz. Portanto, o método não aceita argumentos, embora se tentarmos aprovar argumentos, ele não os levaria. Ele executa apenas a operação básica de remover o último elemento da matriz.
4.3 Array .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 () é uma função de acessador que pode ser usada para encontrar o índice de um elemento específico em uma matriz. O argumento a ser passado para isso é o valor do elemento na matriz. Além disso, deve -se notar que, quando há várias ocorrências do mesmo elemento nos dados, a primeira ocorrência do elemento na matriz é exibida.
4.4 Array .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 () é uma função de acessador, bastante semelhante em comportamento à função indexOf . Embora a diferença seja lastIndexOf retorna o índice da última ocorrência do elemento na matriz.
4.5 Array .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 () é uma função de acessório usada para criar novas matrizes a partir de matrizes existentes. É preciso uma matriz como um argumento e, após a função ser executada, a matriz no argumento é concatenada para a matriz chamando concat() .
4.6 Array .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]Array .splice () possui um conjunto variado de operações que podem ser executadas. Se observarmos o Caso 1, estamos adicionando elementos à matriz ARR1 do quinto índice. Além disso, se observarmos no caso 2, podemos ver que, sem atribuir uma variável, os elementos que devem ser adicionados são passados como argumentos contínuos. Deve -se notar que a emenda pode não apenas executar a ação de adicionar elementos, mas também executa a ação da remoção de elementos. Na função Splice (), se escolhermos o valor do segundo argumento a ser '0', os elementos serão adicionados apenas ao índice especificado, embora se o valor não for '0', o número especificado seria o número de elementos que serão removidos.
4.7 Array .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"]Array .Shift () não é diferente do método mencionado acima mencionado. POP (), embora a principal diferença ocorra em relação ao índice do elemento que deve ser removido. Ele remove o primeiro elemento da matriz. Semelhante ao Array.pop () Esse método também observa argumentos e, embora um argumento seja aprovado, ele continua a executar sua operação.
4.8 Array .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];Array .UNSHIFT () se enquadra na mesma categoria que a do Array.push (), pois ambos são usados como funções do mutador para adicionar elementos em uma matriz. A única diferença entre os dois métodos é que, se passarmos um argumento para Array.UnShift (), o elemento será adicionado como o primeiro elemento da matriz. Se observarmos o trecho acima, podemos ver que o índice do elemento '1' é deslocado para o próximo local e "Akhil Pandey" é adicionado como o primeiro elemento da matriz. Portanto, diferentemente do Array.Push (), esse método não deve ser mal compreendido apenas para adicionar elementos, pois adiciona elementos ao início da matriz.
4.9 Array . Reverse ():
var arr1 = [ 1 , 'akhil' , 'varma' , 'chandu' , 'adheeth' ] ;
arr1 . reverse ( ) ;
console . log ( arr1 ) ; // it prints ['adheeth', 'chandu', 'varma', 'akhil', 1]Array .versever () é apenas uma função do mutador que é usada para reverter a ordem dos elementos na matriz.
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 () também é outra função do mutador que é usada para colocar os elementos em ordem. Strings e números podem ser classificados usando o método Array.sort (). A classificação ocorre em ordem ascendente; portanto, se as cordas ou caracteres são elementos, dependendo da escala alfabética, a classificação ocorre.
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 () é um método que é mais como uma função de iterador, mas a diferença fundamental entre este e o Array.ForEach () é que o Array.map () retorna uma nova matriz com o resultado, enquanto o Array.ForEach () não retorna uma nova matriz com o resultado da função.
Nota: Array.map () é um método muito poderoso e pode ser aplicado a diversas aplicações. Embora, como esse método, o itera sobre cada elemento usando o Array.map () deva ser cuidadosamente visto e não deve ser usado se o objetivo estiver iterar sobre alguns elementos.
4.14 Array .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 () é um método que pode ser usado com matrizes, assumindo uma função como argumento, fazendo a função para iterar sobre os elementos da matriz. Array.Reduce () itera sobre os elementos da matriz e, assim, ao atingir o final da matriz, produz um único valor.
NOTA: Array.RedUcerright () é mais semelhante ao Array.Reduce (), mas itera sobre os elementos da matriz do elemento mais à direita para o elemento mais à esquerda, em vez de seguir a maneira usual.
TIPS[Arrays] :
MISC[Arrays] :
Manipulando o objeto da matriz escrevendo seus próprios métodos :
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 blockAdicionar métodos ao Array.Prototype significa essencialmente que estamos adicionando métodos ao objeto Global Array. Portanto, um array.Prototype significaria que adicionar um novo protótipo ao objeto Array existente. Portanto, uma analogia melhor pode ser explicada com o trecho de código abaixo.
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 ) ;Observar o protótipo da matriz acima se pudermos observar cuidadosamente, não é nada além de uma réplica de trabalho de como funciona o método da matriz.prototype.concat (). Assim, no método concat (), outra matriz é passada como um argumento para o método e a matriz primária concata e estende a matriz.
As coisas a procurar no exemplo acima são como os métodos personalizados podem ser gravados para se adequar ao objetivo específico não apenas ao protótipo da matriz, mas também a todos os objetos reconhecidos Javscript, como string, número, regexp ou o próprio objeto.
Matrizes associativas :
De preferência, essa é uma grande parte do idioma, embora essa tenha sido parte integrante de muitas linguagens de programação, como PHP e Python, há uma ligeira mudança no que ele oferece em outras linguagens de programação para isso.
[Nota]: Em Python, não é chamado ou referido como matrizes associativas, mas vem com os dicionários de nome.
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 3O snippet acima é uma implementação clássica de casos de matrizes com índices nomeados ou as matrizes associativas. A implementação pode ser feita conforme mencionado acima e quase todas as operações da matriz, exceto que algumas podem ser executadas com muita suavemente com índices nomeados. O problema surge quando uma matriz com índices nomeados é solicitada por seu comprimento. Quando o método 'Array.prototype.Length ()' é referido, ele retorna apenas o comprimento da matriz que possui Índice Numberd, se usarmos índices nomeados, não é bom porque os índices são strings, mas não são mais números.
Nesse caso, se precisarmos retornar o comprimento da matriz indexada, então objeto.
Métodos que fazem parte do objeto JavaScript String :
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 () é um método que pode ser usado para determinar o caractere presente em um índice específico da string fornecida. A função leva apenas um argumento e retorna o personagem como saída. Deve -se notar que, quando o índice fornecido como entrada se maior ou menor que o comprimento da string, a função retorna '' ou uma string vazia como saída.
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 () é um método usado para combinar duas ou mais strings para retornar uma nova string. Fundamentalmente, esse método é usado para operações de string, mas se uma string for tipicamente concatenada com outro tipo, o resultante será uma string. Se observarmos o exemplo acima, vemos str1.concat(true) , então aqui a sequência resultante é akhiltrue como string .Concat () combina o valor dos argumentos e produz uma string concatenada como resultado final. Agora, existem até casos especiais para supor, se uma string for tentada concatenar com valores falsamente, o resultado seria a combinação do valor da string e da falsidade.
5.3 String .Indexof ():
5.4 String .LastIndexOf ():
5.5 String .link ():
5.6 String .Search ():
5.4 String .slice ():
TIPS[Strings]:
string.slice () : o método string.slice () extrai essencialmente parte de uma string e retorna a nova string que é cortada. A notação geral para o uso do método String.slice é String.slice (POS1, POS2), onde em POS1 é a posição do índice inicial e POS2 é a posição do índice final. O ponto a ser observado aqui é se usarmos o método string.slice () passando parâmetros negativos, ele acaba contando e extraindo a string do final para o início. E se não passarmos no segundo parâmetro, o método extrai o restante da string.
string.substring () : o método string.slice () e string.substring () se enquadram na mesma categoria de métodos que podem ser usados para extrair parte ou partes da string da string de origem. A diferença em ambos é que não podemos usar índices negativos ao usar o método string.substring (). Por exemplo, se passarmos um índice negativo para o método como string.substring (-7, -1), ele essencialmente não exala nenhum erro indicando o erro cometido para usar o índice negativo, mas exibe a string como um todo
Em JavaScript:
| Tipos | Pode ser objetos | São sempre objetos |
|---|---|---|
| Booleanos | ✔ | |
| Números | ✔ | |
| Cordas | ✔ | |
| Datas | ✔ | |
| Matemática | ✔ | |
| Expressões regulares | ✔ | |
| Matrizes | ✔ | |
| Funções | ✔ |
Então, basicamente, exceto os valores primitivos, todos são objetos em 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 : Os objetos javasctipt são mutáveis, o que significa que eles são referenciados pelo endereço e não pelo valor. Por exemplo, se 'Master' for um objeto e 'mestre-backup' também é outro objeto, se passarmos nos objetos, alterar um poderá resultar em alterar o outro objeto também.
{
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]"
} O fechamento de funções no JavaScript é sobre como as variáveis estão sendo tratadas e referidas no escopo local ou global. Nas variáveis JS podem ser dadas:
Não existe um conceito embutido para algo chamado variáveis privadas; portanto, quando há um requisito para que esse fechamento de cenários seja escrito em JS para fazer o escopo para variáveis que são de escopo privado.
A curry é um processo de construção de uma função, assumindo vários argumentos e aplicando -os parcialmente através de uma série de funções. Portanto, para ser específico, você pode dividir a função dada que leva vários argumentos em uma série de funções que participam dos argumentos.
Vamos dar um exemplo comum:
As chamadas de cauda nada além de substituir essencialmente o conceito de funções recursivas pelo loop. De certa forma, isso pode não apenas economizar tempo, mas também economiza espaço, ou seja, melhor complexidade do tempo e complexidade do espaço.
// 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 ) ;
}Observando ambos os algoritmos acima escritos para fatorial, podemos entender que F () é o método recursivo tradicional usado para encontrar o fatorial, mas F1 () é o algoritmo otimizado para chamadas de cauda que é melhor e rápido.
Embora os melhores esforços tenham sido colocados para garantir que toda a documentação seja livre de erros, pode haver pequenas instâncias em que os erros possam ter ocorrido. Nesses casos, levante um problema e me ajude a melhorar esta folha de dicas.
