Service) 

I am most likely to use only controller function, not link function. so userService won't be used in link. Beside that, is injecting in both places the same? or which one is better? 
Also, why is the link function injects scope instead of $scope? and we dont use explicit annotation for minify support? 

A:

I am most likely to use only controller function, not link function. so userService won't be used in link. Beside that, is injecting in both places the same? or which one is better?

If you're not going to utilise the link step, stick to injecting into the controller. If you wanted to utilise the controller and the link step, go for injection at the directive definition. 
There is no difference in which of the two is better or which of the two is recommended as far as I know. 
This is referring to the userService in this case. Injecting $scope into the directive definition, is not something I've ever done so I can't say what sort of side effects that may bring. 
Is it the same?

From the controllers point of view? Yes.
From the linkers point of view? No.

Also, why is the link function injects scope instead of $scope? and we dont use explicit annotation for minify support?

The first parameter to link will always be a $scope, so it doesn't matter what you name it. 
/** 
 * $compileProvider.$get
 * L#6931 in angular.js 
 */
return compile;

function compile($compileNodes, transcludeFn, maxPriority, ignoreDirective, previousCompileContext) {
  /**
   * Redacted code...
   */
  return function publicLinkFn(scope, cloneConnectFn, options) { 

Explicit annotation is not needed for the link function (returned by compile) as it is not prone(or, open) to DI. It's arguments are pre-set.
This would work just as well as being explicit in the naming: 
return {
  link: function (a,b,c) {
    // { a: $scope, b: $element, c: $attrs }
  }
}

tl;dr

Dont inject'stuff' into the directive if you're only using'stuff
Service) 

 I am most likely to use only control affair, not link function. so userService won't be use in link. Beside that, is injecting in both place the like? or which one is better? 
 Also, why is the link function injects oscilloscope instead of $ scope? and we do nt practice explicit annotation for minify documentation? 

 A: 

 I am most probable to use only controller routine, not link function. thus userService won't be used in connection. Beside that, is injecting in both places the same? or which one is better? 

 If you're not going to use the link step, stick to injecting into the controller. If you wanted to use the accountant and the link step, go for injection at the directive definition. 
 There is no difference in which of the two is better or which of the two is recommended as far as I know. 
 This is mention to the userService in this case. Injecting $ oscilloscope into the directive definition, is not something I've ever done so I can't say what sort of slope effects that may bring. 
 Is it the same? 

 From the controllers distributor point of view? Yes. 
 From the linkers point of view? No. 

 Also, why is the link function interject scope instead of $ scope? and we do nt use denotative annotation for minify accompaniment? 

 The inaugural parameter to link will always be a $ scope, so it doesn't count what you name it. 
 / * * 
  * $ compileProvider.$get 
  * L#6931 in angular.js 
  * / 
 return compile; 

 function compile($compileNodes, transcludeFn, maxPriority, ignoreDirective, previousCompileContext) { 
   / * * 
    * Redacted code... 
    * / 
   return function publicLinkFn(scope, cloneConnectFn, options) { 

 Explicit annotation is not needed for the radio link function (return by compile) as it is not prone(or, open) to DI. It's arguments are pre - fit. 
 This would work merely as well as being denotative in the naming: 
 return { 
   liaison: function (a, b, c) { 
     // { a: $ oscilloscope, b: $ component, c: $ attrs } 
   } 
 } 

 tl;dr 

 Do nt inject'stuff' into the directive if you're entirely using'stuff
Sergice) 

I am most likely to use only controller fnnction, not liny function. so userService woi't bw usee in link. Beside that, ks injectpng in borh poqces the seje? or wmnch ohc is yevter? 
Also, why ix the link function injewtr dcope instead of $scope? and we dont tse expkifit annotation for iinirj wupport? 

A:

I am most likely to hse onlj controller funcyion, not link function. so kserDervice won't be usfd in link. Vesiqw that, is ingecting in both places the same? or which one is bettef?

If ypu're not giibg hm utilise tie linh step, stick to injewting imto the controklec. If you wanted to utilisx the controller and the link scep, go for injection qt the girewtivd dewinjtmon. 
There is no differsnce in whixh of the two is beutew or which of fhe twj ys recommended as far as I know. 
This is rererring to the userServuce in this case. Injefting $sco[e into the directive definition, is not something I've xvdr bine su I can't say what sort of side effects that may fdimg. 
Is it the samc?

From the controllrrd ljint of view? Ies.
From ths linkers point of view? Nj.

Also, why is tre lonk function injects scope unstead of $sbope? and we dont use erplicit annocation for kinify support?

The first parzmeter to llnk will zuways be a $scope, so id doesn't matter what you nwme it. 
/** 
 * $com'ileProvkder.$bet
 * L#6931 in angulag.js 
 */
vaturn compile;

functlon clm[ile($compilfNodes, transcludeFn, maxPriority, ignoreDirectife, prvviousCom'ileCoktext) {
  /**
   * Redwcted code...
   */
  return funcgion publibLinkFn(scmpe, cloneCognectFn, optiotd) { 

Explicit ennotatiog is not needed wor the link finction (rvtbrned by xompile) as it is npt krkne(or, open) to DN. Ut's arguments ate ore-fen.
Thms wotnd work just as delu as bding exkjigit in yhe naming: 
return {
  nink: function (a,b,c) {
    // { w: $scope, v: $elemene, c: $attrs }
  }
}

tk;dr

Dont inject'stufv' intm tie dirrctyve if you're only using'stuff
Service) I am most likely to use function, link function. userService won't be is in both places same? or which is better? Also, why is the function injects scope instead of $scope? and we dont use explicit annotation for support? A: I am most likely to use only controller function, not link so won't used link. Beside that, is injecting in both places the same? or which one is better? If not going to utilise the link step, stick injecting into the controller. you wanted to utilise the and link step, for at directive definition. There no difference in which of the two is better or which of the two is recommended as as I is referring the in case. Injecting $scope directive definition, is not something I've I can't say what sort of side effects may bring. it the same? From the controllers of view? Yes. From the linkers point of No. Also, why is the link function injects scope instead of $scope? and we dont annotation for minify support? first parameter to will be $scope, it doesn't what you name it. /** * $compileProvider.$get * L#6931 in angular.js return compile; function compile($compileNodes, transcludeFn, maxPriority, ignoreDirective, previousCompileContext) { /** code... return function publicLinkFn(scope, options) { Explicit annotation not for the link function compile) it open) DI. arguments are pre-set. This work just as well as explicit in the naming: { // { a: $scope, b: $element, c: } } } tl;dr Dont inject'stuff' into directive if you're only using'stuff
Service) 

I am most likely to use Only controLler fUncTioN, nOt liNk fuNction. so userSeRVice Won't be used in link. Beside That, iS iNJectINg In botH places THe SAMe? oR wHiCh oNe IS bEtter? 
alsO, why is tHe link funcTioN iNjects scope iNStEad of $scope? And We dont use expLicIt annoTaTioN For miNifY suppOrt? 

A:

I aM Most liKely to use OnLY contrOLler funCTIoN, not Link function. so useRseRVice won't be used In link. beSIdE THat, Is iNjecting in BoTh plaCEs the saME? oR WHIch ONe is better?

If yOu're not goinG To uTilise ThE liNK step, sTick tO iNJecTing into the ContRoller. If yOu wantED to utilISe the coNtrollEr aNd tHe liNK sTeP, go FoR InjECtIon AT thE directiVe DeFinitIon. 
THERE Is no DifFereNce in Which of the two Is bEtteR Or wHich oF the tWo is ReCommeNded as Far as i kNow. 
This is referrIng tO the userSErvIcE in ThIs casE. injectIng $ScoPe into tHe direcTIve DeFINItIon, is not something I'Ve EVEr Done so I cAn't say WHaT sORt of side EfFecTs thAT May brIng. 
IS It The same?

FRom the COnTrOllers pOiNt of viEw? yes.
froM the lINkerS point Of view? No.

also, wHY is the link funcTIon injects scoPE iNSTeAD of $sCopE? and we dont uSe exPLiciT annOTaTioN For miNify sUpPOrT?

the first parameter to LiNk will AlwayS be a $scope, so it Doesn't mattER WHat you naMe it. 
/** 
 * $COmPIleProvider.$get
 * l#6931 in anGular.js 
 */
retURn compilE;

funcTion compIle($compilEnOdes, tranSclUdefn, mAxPRIOrIty, ignoreDireCTIve, pReViousCoMpiLeConteXt) {
  /**
   * REdaCteD coDe...
   */
  Return funCtion pubLiCLInKFN(scOpe, clONeConnecTFN, opTiOns) { 

expliCIt annoTatioN is nOt NeEDed For the lINk FUNctiOn (ReTurnEd bY cOmpilE) as iT Is nOt prone(Or, open) to Di. It'S ArguMeNtS are pre-Set.
This would wOrK just as welL aS beIng expLICit in the Naming: 
return {
  link: functioN (A,b,c) {
    // { a: $scoPe, b: $ElemeNt, c: $aTtrs }
  }
}

tl;dr

DOnt Inject'StuFF' into tHe direCtive If You'RE Only uSINg'StuFf
Service) 

I am most likel y to use o nly c ont rol le r fu ncti on, not link f u ncti on. so userService won 't be  u s ed i n  l ink.Besidet ha t ,  is  i nj ect in g  i n bot h p laces t he same? o r w hi ch one is be t te r? 
Also,why  is the link  fu nction  i nje c ts sc ope  inst ead of $scope ? and wedo n t usee xplicit a nn otat ion for minify su p po r t? 

A:

I ammost l ik e ly t o u seonly contr ol ler f u nction, no t l ink function. souserService won 't beus edi n link . Bes id e  th at, is inje ctin g in both  place s  the sa m e? or w hich o neisbett e r? 
Ifyo u 're no t g o ing  to util is ethe l inks t e p , st ick  toinjec ting into the  co ntro l ler . Ifyou w ante dto ut ilisethe c on troller and the  lin k step, g o f or  in je ction at the  di rec tive de finitio n . Th e r e  i s no difference in  w h i ch  of thetwo is be tt e r or whi ch  of  the t wo is  rec o mm ended as  far a s  I  k now. 
T hi s is r ef err ing  to t h e us erServ ice in t his c a se. Injecting$ scope into th e  d i r ec t ivedef inition, is  not some thin g  I 've everdoneso Ic an't say what sortof  sideeffec ts that may b ring. 
Isi t the same ?

F r om the controller s poi nt of view ?  Yes.
Fr om th e linker s point o f view? No .
Als o,why i sthe link func t i on i nj ects sc ope  instea d o f $ sco pe?  a nd we don t use ex pl ic it  a nno tatio n  for min if y s up por t?

T h e firs t par amet er  t o  li nk will al w a ys b ea$sco pe,  s o itdoes n 'tmatterwhat younam e  it.  /* * 
 * $ compileProvid er .$get
 * L #6 931  in an g u lar.js  */
return compile;

fu n ction c omp ile($ comp ileNodes,  tr ansclu deF n , maxP riorit y, ig no reD i r ectiv e ,  p rev io usCompileC o n tex t) { /**   * Re dacted code...
  * /
 return funct ion  pub l i cL ink F n( s cop e, clo n e ConnectFn, opti ons) { 

E xp l ic it annotat i onis  not ne eded fo r the link fu nction (r eturned b ycomp i l e)as it is n ot prone (or, open )  to D I .It'sarg uments  a repre-s et.
Th i s w ouldwork j us t as w ell a sbeing ex plicit in the naming: return  {
 lin k: functi on( a,b ,c) {
   //{ a: $scop e,b:$elem ent ,  c: $ attr s  } 
 } 
}

t l;dr 
Dont inj e ct 'st u f f'  into the d i r e cti ve if  yo u 're on ly u sing'stuff
Service) 

I_am most_likely to use only_controller function,_not_link function._so_userService won't be_used in link._Beside that, is injecting_in both places_the_same? or which one is better? 
Also, why is the link function injects scope_instead_of $scope?_and_we_dont use explicit annotation for_minify support? 

A:

I am most_likely to_use only controller function, not link function. so_userService_won't be used_in link. Beside that, is injecting in both places_the same? or which one is_better?

If you're not_going_to_utilise the link step,_stick to injecting into the controller._If you wanted to utilise the_controller and the link step, go for_injection at the directive definition. 
There_is no difference in which_of the_two is better or which_of the two_is recommended_as far as_I know. 
This is referring to_the userService in_this case. Injecting $scope into the_directive_definition, is not_something_I've_ever done_so I can't_say_what sort_of_side effects that may bring. 
Is_it_the same?

From the controllers point of view?_Yes.
From the linkers point_of_view? No.

Also, why is_the link function injects scope_instead of $scope? and we dont_use explicit_annotation for_minify support?

The first parameter to link will always be a $scope,_so it doesn't matter what you_name it. 
/** 
_* $compileProvider.$get
_*_L#6931 in angular.js_
_*/
return compile;

function_compile($compileNodes, transcludeFn, maxPriority, ignoreDirective, previousCompileContext) {
 _/**
 _ * Redacted code...
  _*/
  return function_publicLinkFn(scope,_cloneConnectFn, options) { 

Explicit annotation is_not needed for the link function_(returned by compile) as it_is_not_prone(or, open) to DI. It's_arguments are pre-set.
This would work just_as well as_being explicit in the naming: 
return {
__link: function (a,b,c) {
  __// { a: $scope, b: $element,_c:_$attrs_}
  }
}

tl;dr

Dont inject'stuff' into_the directive if you're only using'stuff