LearnJS
1.0.0
LearnJs- это попытка изобразить лучшие части JavaScript, которые довольно сложные и трудно найти. Следует отметить, что это не книга/руководство в какой -либо форме, а собрание лучших практик, языковых конструкций и других простых, но эффективных фрагментов, которые дают нам суть того, как мы можем использовать наилучшие из языка.
1.1 Declarations :
// bad
var arr = new Array ( ) ;
var str = new String ( ) ;
var num = new Number ( ) ;
var boo = new Boolean ( ) ;
var obj = new Object ( ) ;
var reg = new RegExp ( ) ;
var fun = new function ( ) ;
// good
var arr = [ ] ,
str = "" ,
num = 0 ,
boo = false ,
obj = { } ,
reg = / () / ,
fun = function ( ) { } ; Мы должны понимать тот факт, что в JavaScript все является объектом, поэтому для предположения, если мы объявим строку, используя объект String , и сравнить ее с var a = "" то результат сравнения будет ложным. Это просто потому, что если мы объявляем строку, используя bad путь и сравниваем ее со строкой, объявленной с использованием good способа, то мы в основном сравниваем строку с объектом (строкой).
Semicolons :
// Snippet one
var foo = { }
foo . code = "this is javascript empire"
foo . engine = "node 0.12.7"
foo . author = "akhil pandey"
foo . version = 0.1
// Snippet two
var bar = { } ;
bar . name = "akhil pandey" ;
bar . url = "www.akhilhector.com" ;
bar . github = "AkhilHector" ;
bar . age = 20 ;
if ( typeof ( bar ) == typeof ( foo ) ) {
console . log ( "Semicolons donot matter at all" )
}Кодовый фрагмент один и два одинаковы. Но фундаментальное различие между обоими образцами кода заключается в том, что один использует полуколоны в семантике Lang -Uage, но в то время как другой не делает. В основном нас учат использовать полуколоны на таких языках, как C, C ++, Java и т. Д. Поскольку строки кода завершаются с использованием ';' Но в JavaScript весь сценарий отличается. Нет абсолютно никакой разницы в выполнении кода с или без полуколонов.
Методы часть объекта карты Javascript:
2.1 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 () - это метод, который используется для добавления или обновления элемента с определенным ключом и значением на карте. Здесь первый аргумент является ключом, в то время как второй аргумент - это значение. Клавиши могут быть любого типа, но было бы предпочтительным использовать objects в качестве клавиш вместо strings потому что, если мы используем strings в качестве ключей, между Maps и 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 () - это метод, который указывает, присутствует ли элемент с запрошенным ключом на карте или нет. Метод принимает только один аргумент, который является ключом, и возвращает true если элемент присутствует, или false если элемент отсутствует.
2.4 Карта .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 Map .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 . В приведенном выше примере описывается, как итерация по карту .keys () с использованием next() . Следует отметить, что когда next() используется в объекте итератора либо value , либо done , потому что прямое использование next() приводит к отображению Object . iterator.next().value false iterator.next().done . true
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() Следует отметить, что когда next() используется в объекте итератора либо value , либо done , потому что прямое использование next() приводит к отображению Object . false ( iterator.next().done iterator.next().value 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 В приведенном выше примере он представлен в отношении того, как итерация по карте .Entries () с использованием next() . Способность метода и его способ работы очень похожи на карту . Подобно любому итераторному объекту, как только он достигнет конца самолета, он бросил бы и undefined . Кроме того, следует отметить, что любой другой метод, который применяется к итераторному объекту, может использоваться с этим, поскольку он один и тот же.
MISC[Maps] : Слабые карты можно рассматривать как карты с различиями в методологии, из которых коллекции мусора происходят под капотом. Чтобы выразить это в более простой и простой терминологии, должен быть небольшой концептуальный урок, чтобы принести перспективу. В JavaScript в целом все является объектом , поэтому в тот момент, когда вы создаете один, и память выделяется для того же самого, и пока V8 автоматически автоматически GC (короткий для мусора), объект остается как узел на графике. Следует отметить, что до тех пор, пока в памяти не будет никаких ссылок на объект, созданный в памяти, он не будет GC'D, поэтому все объекты удерживаются tightly или strongly . По сути, разница, которая приносится со слабыми картами, заключается в том, что ключи объекта weakly удерживаются впредь, если объект является GC'd от V8 или вам, тогда запись будет удалена из слабой карты , но не является значениями. Не существует резкой разницы между тем, как карты и слабые карты работают, хотя слабые карты принимают объекты только в виде ключей (строго). Давайте посмотрим ниже, чтобы увидеть, как они инициализированы:
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 SleadMap взаимодействует с нами так же, как и объект MAPS , существуют ограничения для операций, обеспечиваемых API ShideMaps . Он поддерживает get() , set() , has() и delete() методы на данный момент.
MISC[Maps] : использование ... оператора
Методы часть объекта набора JavaScript:
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 () - это метод мутатора для добавления значений в набор. Процедура достижения этого является простой. Мы называем метод add() к уже созданному объекту Set и передаваем значение, которое мы хотим, в набор в качестве аргумента. Когда более одного аргумента передается методу add() он просто игнорирует оставшиеся аргументы и рассматривает только первый аргумент. Следует отметить, что у Set -объекта нет никаких ограничений на тип проходящего значения, и он не обеспечивает каких -либо ограничений, когда мы делаем Set гетерогенными. NaN , null также может быть частью Set . Хотя это никогда не рекомендуется заполнять Set ценностями такого рода.
3.2 set .has ():
var s1 = new Set ( )
s1 . add ( 123 )
s1 . add ( 456 )
s1 . add ( 789 )
s1 . add ( "akhil" )
s1 . add ( null )
s1 . has ( 123 ) // returns true
s1 . has ( NaN ) // returns false
s1 . has ( "akhil" ) // returns true
s1 . has ( 456.12 ) // returns false
s1 . has ( 123.0000000000000009123 ) // returns true Set .has () - это метод, который полезен при определении того, существует ли элемент в Set или нет. Метод возвращает либо true если значение присутствует, и false если значение отсутствует. Если мы наблюдаем приведенный выше пример, существует небольшое неравенство между ожидаемой природой метода и его наземной реальностью. s1.add(123.0000000000000009123) является одним из примеров, который проливает некоторый свет на соперничество в длину десятилетия между значениями JavaScript и плавающей запятой. Этого можно избежать, просто используя число .toprecision (). Кроме того, в JavaScript всегда рекомендуется тщательно обрабатывать плавающие точки.
3.3 set . Size:
var s1 = new Set ( [ 1 , 23 , 456 , 78910 ] )
var s2 = new Set ( )
s2 . add ( "akhil" )
s2 . add ( "chandu" )
s2 . add ( "adheeth" )
console . log ( s1 . size ) // returns 4
console . log ( s2 . size ) // returns 3 SET .Size - это не метод, но это свойство объекта SETS, полезное для определения размера Set . Как вы можете наблюдать из приведенного выше фрагмента кода, он просто называется как метод доступа. Если мы попытаемся вызвать свойство, используя size() , то он бросает тип и высказывал Set.size не является функцией.
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 () - это метод, который очищает все элементы, присутствующие в наборе. Это приводит к опорожению Set . Если мы наблюдаем в приведенном выше фрагменте кода, существует попытка передать аргумент методу set .clear () и независимо от того, какой аргумент передается методу, который он просто игнорирует и выполняет операцию clear() в Set . Кроме того, нет никаких ограничений за количество раз, когда операция выполняется.
3.5 set .delete ():
var s1 = new Set ( )
s1 . add ( "akhil" )
s1 . add ( "dusi" )
s1 . add ( "om" )
s1 . add ( "siddu" )
console . log ( s1 . has ( "akhil" ) )
console . log ( s1 . delete ( "akhil" ) )
console . log ( s1 . delete ( "foo" ) )
console . log ( s1 . has ( "akhil" ) )
for ( let item of s1 ) {
console . log ( item )
} Set .delete () - это метод, используемый для удаления элемента из набора. Метод принимает только один аргумент и возвращает логическое значение true или false . Если для delete() передается более одного аргумента (), то он просто игнорирует оставшиеся аргументы и рассматривает только первый аргумент.
3.6 SET . Values ():
var s1 = new Set ( )
var s2 = new Set ( )
s1 . add ( "foo" )
s1 . add ( "bar" )
s1 . add ( "foobar" )
s1 . add ( "barfoo" )
for ( let items of s1 . values ( ) ) {
s2 . add ( items )
}
console . log ( s1 . values ( ) ) // returns SetIterator { 'foo', 'bar', 'foobar', 'barfoo' }
console . log ( s2 . values ( ) ) // returns SetIterator { 'foo', 'bar', 'foobar', 'barfoo' }
console . log ( s1 . has ( "foo" ) ) // returns true
console . log ( s2 . has ( "foo" ) ) // returns true SET . Values () - это метод, который возвращает значения, присутствующие в Set . Если мы используем s1.values() в цикле, как показано в приведенном выше фрагменте кода, то все, что мы возвращаемся, это значение, поскольку мы перечитываем над Set . Кроме того, это может звучать аналогично методу в Map , но есть небольшое различие, которое является map . Values () только возвращает значения, присутствующие в Map , а 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 (), все, что мы получаем, - это массив значений NX2, где n [0] и n [1] содержат одно и то же значение. Мы также можем назначить s1.entries() переменной или постоянной, и в этом случае мы получим объект итератора взамен, который можно воспроизвести, используя next() .
MISC[Sets] : слабые
MISC[Sets] : Использование ... Оператор
Методы часть объекта массива 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 () - это просто функция мутатора для добавления элементов в массив. Таким образом, мы можем просто упомянуть элемент как аргумент в функциональный массив .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]Array .pop () - просто простая функция мутатора для удаления последнего элемента массива. Таким образом, метод не принимает аргументы, хотя, если мы попытаемся передать аргументы, он их не возьмет. Он выполняет только основную работу удаления последнего элемента массива.
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 () - это функция доступа, которую можно использовать для поиска индекса определенного элемента в массиве. Аргумент, который должен быть передан этому, является значением элемента в массиве. Кроме того, следует отметить, что когда в данных появляется несколько случаев одного и того же элемента, отображается первое вхождение элемента в массиве.
4.4 массив .lastindexof ()
var arr1 = [ "akhil" , "chandu" , "adheeth" , "varma" , "akhil" , "shankar" , "akhil" ] ;
arr1 . lastIndexOf ( "akhil" ) ; // returns 6 since akhil last occurred at index 6
arr1 . lastIndexOf ( "adheeth" ) ; // returns 2 since adheeth last occurred at index 2 Array .lastIndexof () - это функция доступа, довольно похожая по поведению с функцией indexOf . Хотя разница в том, что lastIndexOf возвращает индекс последнего появления элемента в массиве.
4.5 массив .concat ()
var arr1 = [ "akhil" , "chandu" ] ;
var arr2 = [ "adheeth" , "varma" , "kp" ]
var arr3 = [ ]
arr1 . concat ( arr2 ) ; // returns [ 'akhil', 'chandu', 'adheeth', 'varma', 'kp' ]
arr2 . concat ( arr1 ) ; // returns [ 'adheeth', 'varma', 'kp', 'akhil', 'chandu' ]
arr3 = arr1 . concat ( arr2 )
console . log ( arr3 ) // returns [ 'akhil', 'chandu', 'adheeth', 'varma', 'kp' ] Array .concat () - это функция доступа, используемая для создания новых массивов из существующих массивов. Это требует массива в качестве аргумента, и после выполнения функции массив в аргументе объединяется с массивом 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 () имеет разнообразный набор операций, которые могут быть выполнены. Если мы наблюдаем случай 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"]Array .shift () ничем не отличается от вышеупомянутого массива методов. Pop (), хотя основное различие в том, что касается индекса элемента, который должен быть удален. Это удаляет первый элемент массива. Подобно Array.pop () Этот метод также не позволяет принимать аргументы, и хотя аргумент проходит, он продолжает выполнять свою работу.
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 () попадает в ту же категорию, что и у массива. Push (), поскольку оба они используются в качестве функций мутатора для добавления элементов в массив. Единственная разница между обоими методами заключается в том, что если мы перейдем к аргументу в Array.unshift (), то элемент будет добавлен в качестве первого элемента массива. Если мы наблюдаем вышеупомянутый фрагмент, мы увидим, что индекс элемента «1» смещен в следующее место, и «Ахил Пандей» добавляется в качестве первого элемента массива. Таким образом, в отличие от Array.push () Этот метод не должен быть неправильно понят только для добавления элементов, поскольку он добавляет элементы в начало массива.
4.9 Array .Reverse ():
var arr1 = [ 1 , 'akhil' , 'varma' , 'chandu' , 'adheeth' ] ;
arr1 . reverse ( ) ;
console . log ( arr1 ) ; // it prints ['adheeth', 'chandu', 'varma', 'akhil', 1]Array .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]Array .sort () также является еще одной функцией мутатора, которая используется для размещения элементов в порядке. Как строки, так и числа могут быть отсортированы с использованием метода Array.sort (). Сортировка происходит в порядке возрастания, поэтому, если строки или символы являются элементами, в зависимости от алфавитной шкалы сортировки происходит.
4.11 Массив .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 () - это метод, который больше похож на функцию итератора, но фундаментальное различие между этим и массивом.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 . 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 ) ;Наблюдая за приведенным выше прототипом массива, если мы можем внимательно наблюдать, что это не что иное, как рабочая копия того, как работает массив методов массива. Таким образом, в методе concat () другой массив передается в качестве аргумента методу и первичного массива Concats и расширяет массив.
В приведенном выше примере можно записано, как могут быть записаны пользовательские методы, чтобы соответствовать конкретной цели не только для прототипа массива, но и всех распознаваемых Javscript, таких как строка, число, regexp или сам объект.
Ассоциативные массивы :
Предпочтительно это в некоторой степени большая часть языка, хотя это была неотъемлемой частью многих языков программирования, таких как PHP и Python, существует небольшое изменение в том, что он предлагает в других языках программирования.
[Примечание]: В Python он не называется и не называется ассоциативными массивами, но поставляется с именными словарями.
var a = [ ] ;
var b = [ ] ;
a [ "one" ] = "boo this is my first item" ;
a [ "two" ] = "foo this is my second item" ;
a [ "three" ] = "alas this is final item" ;
b [ 0 ] = "oh not again the first item" ;
b [ 1 ] = "cant help with the second item" ;
b [ 3 ] = "finally got rid with the third item" ;
console . log ( a ) ; // would display the contents of the array 'a'
console . log ( b ) ; // would display the contents of the array 'b'
var len1 = a . length ;
var len2 = b . length ;
var len3 = Object . keys ( a ) . length ;
console . log ( len1 ) ; // would display undefined
console . log ( len2 ) ; // would display 3
console . log ( len3 ) ; // would display 3Приведенный выше фрагмент представляет собой классическую реализацию массивов с названными индексами или ассоциативными массивами. Реализация может быть выполнена, как упомянуто выше, и почти все операции массива, за исключением того, что некоторые могут быть выполнены очень плавно с названными индексами. Проблема возникает, когда массив с названными индексами просят его длины. Когда упоминается метод 'array.prototype.length ()', он возвращает только длину массива, у которого есть индекс numberd, если мы используем именованные индексы, то это не хорошо, потому что индексы - это строки, но больше не чисел.
В таком случае, если нам нужно вернуть длину названного индексированного массива, то Object.keys (ArrayName) .length даст длину массива. То же самое объясняется, взяв три переменных «len1», «Len2», «Len3», где оба «Len1», «Len3» хранят длины, но длины 3 -й, но длина, но длины, но и на длинах.
Методы, которые являются частью объекта 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 () - это метод, который можно использовать для определения символа, присутствующего в определенном индексе заданной строки. Функция берет только один аргумент, и она возвращает символ в качестве вывода. Следует отметить, что, когда индекс, указанный как вход, если либо больше, либо меньше длины строки, то функция просто возвращает '' или пустую строку в качестве вывода.
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 , поскольку string .concat () объединяет значение обоих аргументов и создает объединенную строку в качестве конечного результата. Теперь есть даже особые случаи для предположения, если string пытается объединить с фальшивыми значениями, результатом будет комбинация string и фальсификации.
5.3 String .IndexOf ():
5.4 string .lastIndexof ():
5.5 String .link ():
5.6 string .search ():
5.4 string .slice ():
TIPS[Strings]:
string.slice () : метод string.slice () по существу извлекает часть строки и возвращает новую строку, которая нарезается. Общая нотация для использования метода string.slice - это string.slice (pos1, pos2), где в Pos1 является положением исходного индекса, а Pos2 - позиция конечного индекса. Следует отметить здесь, если мы используем метод string.slice () путем передачи отрицательных параметров, он в конечном итоге подсчитывает и извлекая строку от конца до начала. И если мы пройдем второй параметр, метод извлекает остальную часть строки.
string.substring () : метод string.slice () и string.substring () попадает в ту же категорию методов, которые можно использовать для извлечения части или частей строки из исходной строки. Разница в обоих состоит в том, что мы не можем использовать отрицательные индексы при использовании метода string.substring (). Например, если мы передаем отрицательный индекс методу, такому как String.substring (-7, -1), то он, по сути, не выпускает какую-либо ошибку, указывающую на ошибку, сделанную для использования отрицательного индекса, но отображает строку в целом
В JavaScript:
| Типы | Могут быть объекты | Всегда объекты |
|---|---|---|
| Логические | ✔ | |
| Числа | ✔ | |
| Строки | ✔ | |
| Даты | ✔ | |
| Математика | ✔ | |
| Регулярные выражения | ✔ | |
| Массивы | ✔ | |
| Функции | ✔ |
Таким образом, в основном, кроме примитивных значений, все являются объектами в JavaScript
6.1 Objects can be created using three methods :
// creating an oject using an Object literal
var staff = {
name : "somename" ,
branch : "somebranch" ,
salary : "somesalary" ,
age : 20
} ; // creating an object using new keyword
var admin = new Object ( ) ;
admin . name = "somename" ;
admin . department = "somedept" ;
admin . userid = 123 ;
admin . age = 20 ; // creating an object using the object constructor
function student ( name , github_nick , url , age ) {
this . name = name ;
this . github = "https://github.com/" + github_nick ;
this . url = url ;
this . age = age ;
} 6.2 Using the constructor for the above defined Object :
var akhil = new student ( "Akhil Pandey" , "AkhilHector" , "https://www.akhilhector.com" , "20" ) ; 6.3 Accessing object methods :
console . log ( akhil . github ) ;
console . log ( akhil . url ) ; 6.4 Using the prototype property :
student . prototype . show = function ( ) {
return this . name + " " + this . github + " " + this . age ;
} 6.5 Adding methods to the prototype :
function student ( name , github_nick , url , age ) {
this . name = name ;
this . github = "https://github.com/" + github_nick ;
this . url = url ;
this . age = age ;
this . show = function ( ) {
return this . name + " " + this . github + " " + this . age ;
}
} NOTE . Объекты Javasctipt изменяются, что означает, что на них ссылаются адрес, а не значение. Например, если «мастер» является объектом, а «мастер-обратный» также является другим объектом, тогда, если мы передаем объекты, изменение одного может привести к изменению другого объекта.
{
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 ) ;
}Наблюдая за обоими алгоритмами выше, написанными для факториала, мы можем понять, что f () является традиционным рекурсивным методом, используемым для поиска факториала, но F1 () - это оптимизированный алгоритм хвостового вызова, который лучше и быстр.
Хотя были предприняты лучшие усилия, чтобы убедиться, что вся документация без ошибок, могут быть небольшие случаи, когда могли произойти ошибки. В таких случаях, пожалуйста, поднимите проблему и помогите мне сделать этот шпаргалка лучше.
