Голанг Генерицс Примери

Golang Generics Primeri



Голангова генеричка функција омогућава креирање кода за вишекратну употребу који је безбедан по типу и компатибилан са широким спектром типова. На срећу, додавање генерика у Го отвара нове путеве за поновну употребу кода и флексибилност. Најновија верзија Голанга са собом доноси дуго очекивану подршку за генеричке лекове.

Што је још важније, генерика одржава снажну сигурност Го-овог типа која омогућава статичку проверу типа у време компајлирања и обезбеђује исправност типа. Они пружају стандардизовано руковање грешкама унутар генеричког кода који побољшава јасноћу и могућност одржавања. Поред тога, они обезбеђују стандардизовано руковање грешкама унутар генеричког кода који побољшава јасноћу и могућност одржавања. У овом посту ћемо испитати неколико стварних Го генеричких апликација и примера.

Пример 1: Коришћење генеричке функције Голанг

Један од примарних случајева употребе генерика је креирање функција које могу да раде на различитим типовима. Овде идемо са једним од примера где се користи генеричка функција обима.







пакет главни
увоз 'фмт'
фунц обим [ р инт | флоат32 ]( полупречник р ) {
ц := 3 * 2 * радијус
фмт . Принтлн ( 'Генерички обим је: ' , ц )
}
фунц главни () {
био р1 инт = 7
био р2 флоат32 = 7 . 5
обим ( р1 )
обим ( р2 )
}

На почетку претходног кода, линија увози “фмт” пакет који обезбеђује функције за форматирани И/О, укључујући штампање излаза на конзоли. Затим дефинишемо генеричку функцију под називом „обим“ која узима радијус параметра генеричког типа „р“ који може бити или „инт“ или „флоат32“. Унутар функције израчунава обим множењем полупречника са константном вредношћу „3“, а затим множењем са „2“. Коначно, штампа израчунати обим користећи „фмт.Принтлн“.



Затим имамо главну функцију где су две променљиве, р1 и р2, декларисане и додељене вредностима 7 и 7.5, респективно. Након тога, функција „обим“ се позива два пута, преносећи р1 и р2 као аргументе.



Излаз приказује прорачун штампањем обима кругова у следећем:





Пример 2:  Коришћење генеричког интерфејса Голанг

Штавише, Голанг генерици нам помажу са својим интерфејсима. Интерфејси у Го-у су витални алат за олакшавање поновне употребе кода и полиморфизма. Омогућавајући им да функционишу са многим типовима, генерици повећавају снагу интерфејса. Следи изворни код генеричког интерфејса Голанг:



пакет главни
увоз 'фмт'
тип ЕмпАге интерфејс {
инт64 | инт32 | флоат32 | флоат64
}
фунц невГенерицФунц [ старост Старост ]( емп_Аге аге ) {
вал := инт ( емп_Аге ) + 1
фмт . Принтлн ( вал )
}
фунц главни () {
фмт . Принтлн ( 'Старост запослених' )
био Аге1 инт64 = 24
био Аге2 флоат64 = 25 . 5
невГенерицФунц ( Аге1 )
невГенерицФунц ( Аге2 )
}

У претходном изворном коду дефинисали смо интерфејс под називом „ЕмпАге“ који наводи могуће типове за старост запосленог. Интерфејс укључује типове инт64, инт32, флоат32 и флоат64. Овај интерфејс омогућава „генеричкој“ функцији да прихвати било који од ових типова као аргумент. Након тога користимо генеричку функцију под називом невГенерицФунц која узима параметар емп_Аге генеричког типа старости који може бити било који тип који задовољава интерфејс ЕмпАге. Унутар функције, она претвара емп_Аге у инт и повећава га за 1 као што је приказано.

Затим декларишемо две променљиве, Аге1 и Аге2, и додељујемо вредности 24 и 25,5, респективно, у главној функцији. Након тога, Аге1 и Аге2 се прослеђују као параметри функцији невГенерицФунц која се извршава два пута. Овим се старости повећавају за 1 и генеришу ажуриране вредности.

Излаз који се добија у следећем су узрасти из генеричке функције која користи интерфејс:

Пример 3: Коришћење генеричке структуре података Голанг

Штавише, Го генерика нам такође даје могућност да изградимо генеричке структуре података као што су стекови, редови и повезане листе. Размотрите имплементацију генеричког стека у следећем:

увоз 'фмт'
тип Гомила [ Т било који ] [] Т
фунц ( ст * Гомила [ Т ]) Гурни ( предмет Т ) {
ст = додати ( * ст , предмет )
}
фунц ( ст * Гомила [ Т ]) Поп () Т {
ако само ( * ст ) == 0 {
паника ( „Ништа у стеку“ )
}
индекс := само ( * ст ) - 1
предмет := ( * ст )[ индекс ]
* ст = ( * ст )[: индекс ]
повратак предмет
}
фунц главни () {
гомила := Нова ( Гомила [ инт ])
гомила . Гурни ( 1 )
гомила . Гурни ( 2 )
гомила . Гурни ( 3 )
фмт . Принтлн ( гомила . Поп ())
фмт . Принтлн ( гомила . Поп ())
фмт . Принтлн ( гомила . Поп ())
}

У претходном коду дефинисан је генерички тип под називом „Стек“ који представља стек. Чувар места „Т“ дозвољава стеку да задржи елементе било ког типа. Тип „Стацк“ је имплементиран као исечак елемената типа „Т“. Овде се примењују две функције за тип „Стацк“: „Пусх“ и „Поп“. Функција Пусх() је одговорна за додавање елемената стеку. Узима ставку аргумента типа „Т“ и додаје је основном пресеку помоћу функције аппенд().

Док функција Поп() узима почетну компоненту из стека и враћа је, она прво утврђује да ли је стек празан проценом величине основног пресека. Обавештење о грешци се шаље ако се чини да је стек празан што изазива панику. У супротном, преузима последњи елемент из исечка, уклања га из наслага тако што пресече исечак до другог до последњег елемента и враћа уклоњену ставку.

Затим, нови стог целих бројева се креира коришћењем синтаксе Стацк[инт] унутар главне функције овог кода. Након тога, метода „Пусх“ се затим позива три пута да би се стеку додали цели бројеви 1, 2 и 3. Међутим, метода „Поп“ се позива три пута накнадно да би се преузели и одштампали елементи из стека.

Следећи излаз показује да се елементи уклањају из стека обрнутим редоследом:

Пример 4: Коришћење генеричких ограничења Голанг

Го такође нуди прилагођена ограничења која омогућавају велику флексибилност и дефинишу специфичне захтеве за генеричке конструкције на основу њихових потреба за апликацијом. Код прилагођених генеричких ограничења је дат у следећем за демонстрацију:

пакет главни
увоз 'фмт'
тип Нумерицс интерфејс {
инт64 | флоат64
}
фунц главни () {
ФлоатВалуе := [] флоат64 { 2 . 0 , 4 . 0 , 6 . 0 , 8 . 0 , 10 . 0 }
ИнтегерВалуе := [] инт64 { 2 , 4 , 6 , 8 , 10 }
сум1 := генерицСум ( ФлоатВалуе )
сум2 := генерицСум ( ИнтегерВалуе
фмт . Принтлн ( 'Збир флоат64:' , сум1 )
фмт . Принтлн ( 'Збир инт64 :' , сум2 )

}
фунц генерицСум [ н Бројеви ]( бројевима [] н ) н {
био Ја сам н
за _ , на једном := домет бројевима {
сум += на једном
}
повратак сум
}

У претходном изворном коду дефинишемо Нумерички интерфејс методом „Сум“. Затим креирамо два прилагођена типа, „ФлоатВалуе“ и „ИнтегерВалуе“, који имплементирају нумерички интерфејс пружањем одговарајућих метода „Сум“. Функција генерицСум сада може да прихвати делове било ког типа који задовољавају нумерички интерфејс. Унутар функције понављамо елементе и позивамо методу „Сум“ да бисмо израчунали збир. Коначно, у главној функцији, креирамо исечке вредности ФлоатВалуе и ИнтегерВалуе и прослеђујемо их функцији генерицСум() која исправно израчунава збир елемената у сваком пресеку.

Очекивани излаз је сада видљив на следећем екрану:

Закључак

Истражили смо неке практичне примере Го генерика који укључују креирање генеричке структуре података и генеричке функције, дефинисање генеричког интерфејса и коришћење ограничења прилагођеног типа. Ови примери показују снагу и флексибилност коју генерици доносе програмском језику Го. Имајте на уму да генерисање генеричког кода током компилације обезбеђује ефикасну бинарну величину и време компилације.