LearnJS
1.0.0
LearnJses un intento de retratar las mejores partes de JavaScript que son bastante difíciles y difíciles de encontrar. Cabe señalar que este no es un libro/guía de ninguna forma, sino una congregación de las mejores prácticas, construcciones del lenguaje y otros fragmentos simples pero efectivos que nos da una esencia de cómo podemos aprovechar el mejor de los idiomas.
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 ( ) { } ; Tenemos que comprender el hecho de que en JavaScript todo es un objeto, por lo que para suponer que si declaramos una cadena usando el objeto String y lo comparamos con var a = "" entonces el resultado de la comparación sería falso. Esto es simplemente porque si declaramos una cadena usando la bad forma y la comparamos con una cadena declarada usando la good manera, entonces fundamentalmente estamos comparando una cadena con un objeto (cadena).
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" )
}El fragmento de código uno y dos son los mismos. Pero la diferencia fundamental entre ambas muestras de código es que se usa semicolones en la semántica de Lang- -Uage, pero mientras que el otro no. Básicamente, se nos enseña a usar semicolones en idiomas como C, C ++, Java, etc., ya que las líneas de código se terminan usando ';' Pero en JavaScript, todo el escenario es diferente. No hay absolutamente ninguna diferencia en la ejecución del código con o sin semicolones.
Métodos parte del objeto de mapa de JavaScript:
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 () es el método que se utiliza para agregar o actualizar un elemento con una clave y valor específicos en un mapa. Aquí el primer argumento es la clave, mientras que el segundo argumento es el valor. Las teclas pueden ser de cualquier tipo, pero sería preferible usar objects como claves en lugar de strings porque si usamos strings como teclas no habría ninguna diferencia significativa entre Maps y 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 () es un método que se utiliza para recuperar un elemento del objeto Map con una clave específica. Entonces, la clave se pasa como argumento y se devuelve el elemento asociado con esa clave. Si no se pasa ninguna clave como argumento, el método regresa con 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 MAP .HAS () es un método que indica si un elemento con la tecla solicitada está presente en el mapa o no. El método toma solo un argumento que es la clave y devuelve una true si el elemento está presente o false si el elemento no está presente.
2.4 mapa . Tamaño:
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 es una propiedad de accesor que devuelve el número de elementos presentes en el objeto Map . Dado que es una propiedad de accesor, no debemos llamar/usar esto como un método, por lo que si se llama m1.size() , entonces arroja un TypeError que dice m1.size no es una función. Por lo tanto, la llamada válida a esa propiedad es m1.size .
2.5 mapa .clar ():
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 () es un método que borra/elimina todos los elementos que están presentes en el objeto Map . El método no toma ningún argumento, sino que undefined a cambio.
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 () es el método que se utiliza para eliminar un elemento particular del objeto Map . El método solo toma un argumento que es la clave y si la clave está presente en el Map , elimina el elemento y devuelve una true , pero si la clave no está presente en el Map , lanza un 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 () es un método que se utiliza para devolver las teclas presentes en el objeto Map para cada elemento. El método devuelve un objeto iterador de mapa que se puede usar para conocer las teclas presentes en el Map . En el ejemplo anterior se describe cómo iterar sobre map . Keys () usando next() . Cabe señalar que cuando se usa next() en el objeto Iterator , ya sea value o done debe usarse porque un uso directo de next() da como resultado mostrar un Object . iterator.next().value Devuelve el valor de la clave presente en el objeto Iterator While iterator.next().done Devuelve un dicho booleano false si hay más claves presentes en el objeto Iterator y true si no hay más teclas 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 () es un método que se utiliza para devolver los valores presentes en el objeto Map para cada elemento. El método devuelve un objeto iterador que se puede utilizar para conocer los valores presentes en el Map . En el ejemplo anterior se describe cómo iterar sobre el mapa .values () usando next() . Cabe señalar que cuando se usa next() en el objeto Iterator , ya sea value o done debe usarse porque un uso directo de next() da como resultado mostrar un Object . iterator.next().value Devuelve el valor de un elemento particular presente en el objeto Iterator mientras iterator.next().done Devuelve un dicho booleano false si hay más valores presentes en el objeto Iterator y true si no hay más 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 () es un método que se demanda para devolver las teclas y los valores presentes en el objeto Map para cada elemento. El método es bastante similar al mapa .values () para el hecho de que devuelve un objeto iterador que podría usarse para conocer las teclas y los valores presentes en el Map . En el ejemplo anterior se muestra sobre cómo iterar sobre el mapa .Entries () usando next() . La capacidad del método y su forma de operación son bastante similares a MAP .Values (), excepto por el hecho de que las claves también se devuelven junto con los valores a medida que iteramos sobre el objeto Iterador . Similar a cualquier objeto iterador una vez que llegue al final de su avión, lanzaría y undefined . Además, debe tenerse en cuenta que cualquier otro método que se aplique a un objeto iterador podría usarse con esto, ya que es uno y lo mismo.
MISC[Maps] : los mapas débiles pueden considerarse como mapas con diferencias en la metodología de las cuales las colecciones de basura ocurren debajo del capó. Para ponerlo en una terminología más simple y simple, tiene que haber una pequeña lección conceptual para aportar perspectiva. En JavaScript, en general todo, todo es un objeto , por lo tanto, en el momento en que crea uno y la memoria se está asignando para el mismo y hasta que el V8 GC (abreviatura de basura se acumula) el objeto permanece como nodo en el gráfico. Cabe señalar que hasta que no haya referencias al objeto creado en la memoria, no se vería, por lo que todos los objetos se mantienen tightly o strongly . Entonces, esencialmente, la diferencia que se está trayendo con mapas débiles es que las claves del objeto se mantienen weakly en adelante, si el objeto es gc'd por v8 o por usted, la entrada se eliminaría del mapas débiles pero no es valores. No hay una gran diferencia entre la forma en que funcionan los mapas y los mapas débiles , aunque los mapas débiles solo aceptan objetos como claves (estrictamente). Miremos a continuación para ver cómo se inicializan:
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. Cabe señalar que, aunque la forma en que los mapas débiles interactúan con nosotros de la misma manera que el objeto MAPS , existen limitaciones en las operaciones proporcionadas por la API de WeakMaps . Admite get() , set() , has() y delete() métodos a partir de ahora.
MISC[Maps] : uso de ... operador
Métodos parte del objeto establecido JavaScript:
3.1 establecer .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 () es un método mutador para agregar valores a un conjunto. El procedimiento para lograr esto es sencillo. Llamamos al método add() al objeto Set ya creado y pasamos el valor que queremos al conjunto como argumento. Cuando se pasa más de un argumento al método add() simplemente ignora los argumentos restantes y considera solo el primer argumento. Cabe señalar que el objeto Set no tiene restricciones al tipo de valor que se está aprobando ni hace cumplir ninguna restricción cuando hacemos que el Set sea heterogéneo. NaN , null también puede ser parte de un Set . Aunque nunca se alienta a llenar el Set con valores de esta naturaleza.
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 () es un método que es útil para determinar si existe un elemento en el Set o no. El método devuelve el true si el valor está presente y false si el valor no está presente. Si observamos el ejemplo anterior, existe una pequeña disparidad entre la naturaleza esperada del método y su realidad terrestre. s1.add(123.0000000000000009123) es un ejemplo que arroja algo de luz sobre la larga rivalidad de la década entre JavaScript y los valores de punto flotante. Esto podría evitarse simplemente usando el número .toPrecision (). Además, en JavaScript siempre se alienta a manejar cuidadosamente los puntos flotantes.
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 no es un método, pero es una propiedad del objeto SETS útil para determinar el tamaño del Set . Como puede observar en el fragmento de código anterior, se solo llama como un método de accesor. Si intentamos llamar a la propiedad usando size() , lanza un typeError que dice Set.size no es una función.
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 () es un método que borra todos los elementos presentes en el conjunto. Esto da como resultado vaciar el Set . Si observamos en el fragmento de código anterior, hay un intento de pasar un argumento al método .Clear () e independientemente de qué argumento se pasa al método que simplemente ignora y realiza la operación clear() en el Set . Además, no hay restricción sobre la cantidad de veces en las que se realiza la operación.
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 () es un método utilizado para eliminar un elemento del conjunto. El método acepta solo un argumento y devuelve un valor booleano true o false . Si se pasa más de un argumento para delete() , simplemente ignora los argumentos restantes y considera solo el primer 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 () es un método que devuelve los valores presentes en el Set . Si usamos s1.values() en un bucle como se muestra en el fragmento de código anterior, entonces todo lo que recuperamos es un valor a medida que iteramos sobre el Set . Además, esto puede sonar similar al método en Map , pero hay una pequeña distinción, que es map .values () solo devolvería los valores presentes en el Map y el mapa . Keys () devolverían solo las claves asociadas con cada valor/elemento. Ahora, dado que un Set tiene la clave y el valor como el mismo elemento, no hay mucha distinción entre set .values () y set .keys (). Seríamos devueltos con los mismos objetos iterables sin ninguna diferencia.
3.7 set .Enentries ():
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 () es un método que devuelve una matriz de valores para los valores presentes en el Set . Tenemos que entender que en un Set , la clave y el valor siguen siendo los mismos, por lo que cuando llamamos al método set .entries (), todo lo que obtenemos es una matriz nx2 de valores donde n [0] y n [1] contienen el mismo valor. También podemos asignar s1.entries() a una variable o una constante y, en ese caso, obtendríamos un objeto iterador a cambio que podría reproducirse usando next() .
MISC[Sets] : setsetsetsides
MISC[Sets] : uso de ... operador
Métodos parte del objeto de matriz de JavaScript:
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 () es solo una función de mutador para agregar elementos a la matriz. Por lo tanto, podemos simplemente mencionar el elemento como un argumento a la función array.push () y el elemento mencionado se agregaría como el último elemento en la 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 () es solo una función de mutador simple para eliminar el último elemento de la matriz. Entonces, el método no toma argumentos, aunque si intentamos aprobar argumentos, no los tomaría. Realiza solo el funcionamiento básico de eliminar el último elemento de la matriz.
4.3 matriz .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 () es una función de accesorios que puede usarse para encontrar el índice de un elemento específico en una matriz. El argumento que se pasará a esto es el valor del elemento en la matriz. Además, debe tenerse en cuenta que cuando hay múltiples ocurrencias del mismo elemento en los datos, se muestra la primera ocurrencia del elemento en la matriz.
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 () es una función de accesorios, bastante similar en comportamiento a la función indexOf . Aunque, la diferencia es lastIndexOf devuelve el índice de la última ocurrencia del elemento en la 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 () es una función de accesorios utilizada para crear nuevas matrices a partir de matrices existentes. Se necesita una matriz como argumento y después de ejecutar la función, la matriz en el argumento se concatena a la matriz llamando concat() .
4.6 matriz .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 () tiene un conjunto variado de operaciones que podrían realizarse. Si observamos el caso 1, estamos agregando elementos a la matriz ARR1 desde el quinto índice. Además, si observamos en el caso 2, podemos ver que sin asignar una variable los elementos que se deben agregar se pasan como argumentos continuos. Cabe señalar que el empalme no solo puede realizar la acción de agregar elementos, sino que también realiza la acción de eliminar elementos. En la función Splice (), si elegimos el valor del segundo argumento para ser '0', entonces los elementos solo se agregarían desde el índice especificado, aunque si el valor no es '0', entonces el número especificado sería el número de elementos que se eliminarán.
4.7 Array .hift ():
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 .hift () no es diferente del método mencionado anteriormente Array.pop (), aunque la diferencia principal viene con respecto al índice del elemento que se eliminará. Elimina el primer elemento de la matriz. Similar a Array.pop () Este método también desnot, a pesar de que se pasa un argumento, continúa realizando su operación.
4.8 matriz .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 () cae en la misma categoría que la de Array.push (), ya que ambos se usan como funciones de mutador para agregar elementos a una matriz. La única diferencia entre ambos métodos es que si pasamos un argumento a Array.unshift (), entonces el elemento se agregaría como el primer elemento de la matriz. Si observamos el fragmento anterior, podemos ver que el índice del elemento '1' se desplaza al siguiente lugar y "Akhil Pandey" se agrega como el primer elemento de la matriz. Entonces, a diferencia de Array.push (), este método no debe malinterpretarse solo para agregar elementos, ya que agrega elementos al inicio de la matriz.
4.9 matriz .Reverse ():
var arr1 = [ 1 , 'akhil' , 'varma' , 'chandu' , 'adheeth' ] ;
arr1 . reverse ( ) ;
console . log ( arr1 ) ; // it prints ['adheeth', 'chandu', 'varma', 'akhil', 1]Array .Reverse () es solo una función mutadora que se usa para revertir el orden de los elementos en la 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 () también es otra función mutadora que se usa para poner los elementos en orden. Tanto las cadenas como los números se pueden ordenar utilizando el método Array.sort (). La clasificación se lleva a cabo en orden ascendente, por lo que si las cadenas o caracteres son elementos que dependen de la escala alfabética, la clasificación tiene lugar.
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 () es un método que se parece más a una función iteradora, pero la diferencia fundamental entre este y Array.ForEach () es que Array.Map () devuelve una nueva matriz con el resultado, mientras que Array.ForEach () no devuelve una nueva matriz con el resultado de la función.
Nota: Array.map () es un método muy poderoso y se puede aplicar a diversas aplicaciones. Aunque dado que este método itera sobre cada elemento usando Array.map () debe ser cuidadosamente considerado y no debe usarse si el propósito está iterando sobre algunos 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 () es un método que se puede usar con matrices tomando una función como argumento, haciendo que la función para iterar sobre los elementos de la matriz. Array.reduce () itera sobre los elementos de la matriz y, por lo tanto, al llegar al final de la matriz produce un solo valor.
Nota: Array.Reduceright () es más similar a Array.Reduce (), pero se itera sobre los elementos de la matriz desde el elemento más a la derecha hasta el elemento más a la izquierda, en lugar de ir de la manera habitual.
TIPS[Arrays] :
MISC[Arrays] :
Manipulando el objeto de matriz escribiendo sus propios 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 blockAgregar métodos a la matriz. Prototipo esencialmente significa que estamos agregando métodos al objeto de matriz global. Entonces, un array.prototype en realidad significaría que agregar un nuevo prototipo al objeto de matriz existente. Por lo tanto, se puede explicar una mejor analogía con el siguiente fragmento de código.
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 el prototipo de matriz anterior si podemos observar cuidadosamente que no es más que una réplica de funcionamiento de cómo funciona el método de matriz. Prototype.concat (). Entonces, en el método concat (), otra matriz se pasa como argumento al método y la matriz primaria concatifica y extiende la matriz.
Las cosas para buscar en el ejemplo anterior son cómo se pueden escribir métodos personalizados para adaptarse al propósito específico no solo para el prototipo de matriz sino también todos los objetos reconocidos por Javscript, como la cadena, el número, el regexp o el objeto en sí.
Matrices asociativas :
Preferiblemente, esta es una gran parte del lenguaje, aunque esta ha sido una parte integral de muchos lenguajes de programación como PHP y Python, hay un ligero cambio en lo que ofrece en otros lenguajes de programación a esto.
[Nota]: en Python no se llama ni se conoce como matrices asociativas, pero viene con los diccionarios de nombre.
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 3El fragmento anterior es una implementación clásica de casos de matrices con índices con nombre o matrices asociativas. La implementación se puede hacer como se mencionó anteriormente y casi todas las operaciones de matriz, excepto algunas, se pueden realizar muy bien con los índices nombrados. El problema surge cuando se solicita una matriz con índices con nombre por su longitud. Cuando se refiere el método 'array.prototype.length ()', devuelve solo la longitud de la matriz que tiene un índice NumberD, si usamos índices con nombre, entonces no es bueno porque los índices son cadenas pero ya no son números.
En tal caso, si necesitamos devolver la longitud de la matriz indexada nombrada, entonces Object.Keys (ArrayName). La longitud daría la longitud de la matriz. El mismo se explica al tomar tres variables 'Len1', 'Len2', 'Len3' donde 'Len1', 'Len3' almacenan las longitudes de A pero 'Len1' devuelve y 'Len3' 'Len3' Returns 3.
Métodos que forman parte del objeto de cadena JavaScript:
5.1 cadena .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 () es un método que puede usarse para determinar el carácter presente en un índice particular de la cadena dada. La función solo toma un argumento y devuelve el carácter como salida. Cabe señalar que cuando el índice dado como entrada es mayor o menor que la longitud de la cadena, la función solo devuelve '' o una cadena vacía como salida.
5.2 cadena .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]' La cadena .concat () es un método que se utiliza para combinar dos o más cadenas para devolver una nueva cadena. Fundamentalmente, este método se usa para las operaciones de cadena, pero si una cadena se concatena típicamente con otro tipo, el resultado será una cadena. Si observamos el ejemplo anterior, vemos str1.concat(true) por lo que aquí la cadena resultante es akhiltrue como cadena .concat () combina el valor de los argumentos y produce una cadena concatenada como resultado final. Ahora, incluso hay casos especiales para suponer, si se intenta string con valores falsos, entonces el resultado sería la combinación de la string y el valor de la falsificación.
5.3 cadena .indexof ()::
5.4 String .lastIndexof ()::
5.5 cadena .link ()::
5.6 String .Search ()::
5.4 String .Slice ()::
TIPS[Strings]:
string.slice () : el método string.slice () esencialmente extrae parte de una cadena y devuelve la nueva cadena que se corta. La notación general para usar el método String.slice es String.slice (POS1, POS2) donde en POS1 es la posición del índice inicial y POS2 es la posición del índice de finalización. El punto a tener en cuenta aquí es si usamos el método string.slice () pasando parámetros negativos, entonces termina contando y extrayendo la cadena desde el final hasta el inicio. Y si no pasamos el segundo parámetro, el método extrae el resto de la cadena.
string.substring () : el método string.slice () y string.substring () caen en la misma categoría de métodos que se pueden usar para extraer parte o partes de la cadena de la cadena de origen. La diferencia en ambos es que no podemos usar índices negativos al usar el método string.substring (). Por ejemplo, si transmitimos un índice negativo al método como String.Substring (-7, -1), entonces no aborda ningún error que indique el error cometido para usar el índice negativo, pero muestra la cadena como un todo
En JavaScript:
| Tipos | Pueden ser objetos | Son siempre objetos |
|---|---|---|
| Booleanos | ✔ | |
| Números | ✔ | |
| Instrumentos de cuerda | ✔ | |
| Fechas | ✔ | |
| Matemáticas | ✔ | |
| Expresiones regulares | ✔ | |
| Matrices | ✔ | |
| Funciones | ✔ |
Entonces, básicamente, excepto los valores primitivos, todos son objetos en 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 : Los objetos JavaSctipt son mutables, lo que significa que se hace referencia por la dirección y no el valor. Por ejemplo, si 'Master' es un objeto y 'Master-Backup' también es otro objeto, entonces, si pasamos los objetos, entonces cambiar uno podría dar lugar a cambiar el otro objeto también.
{
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]"
} Los cierres de funciones en JavaScript se trata de cómo se tratan y mencionan las variables en el alcance local o global. En JS se pueden dar variables:
No hay un concepto incorporado para algo llamado variables privadas, por lo que cuando hay un requisito para que tales cierres de escenarios se escriban en JS para hacer alcance para variables que tienen un alcance privado.
Currying es un proceso de construcción de una función tomando múltiples argumentos y aplicándolos parcialmente a través de una serie de funciones. Entonces, para ser específico, puede desglosar la función dada que lleva múltiples argumentos a series de funciones que toman parte de los argumentos.
Tomemos un ejemplo común:
Las llamadas de cola no son más que reemplazar esencialmente el concepto de funciones recursivas con bucle. En cierto modo, esto no solo puede ahorrar tiempo sino que también ahorra espacio, es decir, una mejor complejidad de tiempo y complejidad del espacio.
// 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 algoritmos anteriores escritos para factorial podemos entender que F () es el método recursivo tradicional utilizado para encontrar el factorial, pero F1 () es el algoritmo optimizado de la llamada de cola que es mejor y rápida.
Aunque se han realizado los mejores esfuerzos para asegurarse de que toda la documentación esté libre de errores, podría haber pequeños casos en los que podrían haber ocurrido errores. En tales casos, plantee un problema y ayúdame a mejorar esta hoja de trucos.
