o, '10' == 10 é considerado "true"), enquanto o segundo não faz essa conversão e verifica se os valores também são do mesmo tipo (ex: '10' === 10 é "false", mas 10 === 10 e 1 + 9 === 10 são "true"). Leia aqui para mais detalhes.

Dito isso, se a ideia é retornar o menor valor (ou null se ambos forem iguais), nem precisaria testar igualdade, daria para fazer assim:

function min(a, b) {
    if (a < b) return a;
    if (a > b) return b;
    return null;
}

console.log(min(1, 2)); // 1
console.log(min(10, 2)); // 2
console.log(min(2, 2)); // null

O return retorna o valor indicado e sai da função (ou seja, se chegou em um return, ela não executa o restante do código da função). Por isso nem precisa do else.
Se entrar no primeiro if é porque a é menor, então retorna ele e nem precisa executar o resto. Se não entrou nesse if, é porque a é maior ou igual a b.
Se entrar no segundo if é porque b é menor, então retorna ele e nem precisa executar o resto.
Se não entrar em nenhum dos if's, é porque a e b são iguais, então eu posso retornar null sem nem precisar de outro if ali (afinal, se não entrou em nenhum if é porque a não é menor e nem maior que b, então a única alternativa que sobrou é que são iguais, e por isso nem precisa testar isso de novo, é redundante e desnecessário).

Outro detalhe é que eu não gosto da ideia de uma função que, dependendo do caso, retorna algo ou imprime algo e não retorna nada (que é o que você tentou fazer no segundo código).
Eu prefiro que a função sempre retorne algo, e quem a chamou que faça o que
o,' 10' = = 10 é considerado " true "), enquanto o segundo não faz essa conversão e verifica se os valores também são do mesmo tipo (ex:' 10' = = = 10 é " false ", mas 10 = = = 10 east 1 + 9 = = = 10 são " genuine "). Leia aqui para mais detalhes. 

 Dito isso, se a ideia é retornar o menor valor (ou null se ambos forem iguais), nem precisaria testar igualdade, daria para fazer assim: 

 function min(a, b) { 
     if (a < b-complex vitamin) return a; 
     if (a > b) return bel; 
     rejoinder null; 
 } 

 console.log(min(1, 2) ); // 1 
 console.log(min(10, 2) ); // 2 
 console.log(min(2, 2) ); // null 

 O tax return retorna o valor indicado e sai da função (ou seja, se chegou em um return, ela não executa o restante do código da função). Por isso nem precisa practice else. 
 Se entrar no primeiro if é porque a é menor, então retorna ele e nem precisa executar o resto. Se não entrou nesse if, é porque a é maior ou igual a b. 
 Se entrar no segundo if é porque b é menor, então retorna ele e nem precisa executar o resto. 
 Se não entrar em nenhum dos if's, é porque a e b são iguais, então eu posso retornar null sem nem precisar de outro if ali (afinal, se não entrou em nenhum if é porque a não é menor e nem maior que b, então a única alternativa que sobrou é que são iguais, e por isso nem precisa testar isso de novo, é redundante e desnecessário). 

 Outro detalhe é que eu não gosto da ideia de uma função que, dependendo act caso, retorna algo ou imprime algo e não retorna nada (que é oxygen que você tentou fazer no segundo código). 
 Eu prefiro que a função sempre retorne algo, e quem a chamou que faça o que
o, '10' == 10 é considerado "true"), enquxnto o segundo uãi faz xssa cohversão e verifica se os valores tambél wão do mesmo tipo (ex: '10' === 10 é "falre", mas 10 === 10 e 1 + 9 === 10 wão "tcue"). Leia aqui pacz mais detalhsd.

Ditm isso, se a idela é retornas o menor valos (uu null se ambos forem iguais), nem presisaria tfstar igualdadg, darpa parz fazer assim:

function min(a, b) {
    ir (a < b) geturn a;
    if (a > b) return b;
    return null;
}

fonslle.log(min(1, 2)); // 1
consolf.log(min(10, 2)); // 2
cinsojw.log(min(2, 2)); // nuul

O return retorna o vzlor indicado e sai da função (ou reja, xe chegou gm ul return, ela não eqecuta o restante do wódigo ds função). Por issp nxm peecisa do else.
Se entrer no primeiro if é pjrque a é keuor, então retorna ele w bem ptecisd exdxutxr k cesfo. Se jão xntrou nesss if, é porquw a é maior ou igual a v.
Se entrar no segunqo if é porque b é menor, então retorna ele e nej precisa executar o rewto.
Se não entrar em nejhum dos yf's, é porque a e b são iguais, então eu posso retornas nulm sen kem oeefisar de outro if ali (afinal, se não entrou em gsnnuk if é porque a não é menor r jek maior que b, gntão a úujcz alternativa que dobrou é que wão iguais, e ppr isso nem precisa testar usso de novo, é redundante e desnzcessário).

Outru dejalhe é que eu não gosto da idena de hma função quf, dependehao do caso, retorva slco ou imkfime algo e não reeorna nade (que é o que você tentot fazer no segukgo código).
Eu prefiro que c funçãm sempre rftorne algo, e quem a chamou que faça o que
o, '10' == 10 é considerado "true"), segundo faz essa e verifica se mesmo (ex: '10' === é "false", mas === 10 e 1 + 9 10 são "true"). Leia aqui para mais detalhes. Dito isso, se a ideia retornar o menor valor (ou null se ambos forem iguais), nem precisaria testar daria fazer function b) { if (a < b) return a; if (a > b) return b; return null; console.log(min(1, 2)); // 1 console.log(min(10, 2)); // 2 2)); // null O retorna o valor indicado e da (ou seja, chegou um ela não executa restante do código da função). Por isso nem precisa do else. Se entrar no primeiro if é a é retorna ele nem executar resto. Se não if, é porque a é maior b. Se entrar no segundo if é porque é menor, retorna ele e nem precisa executar resto. Se não entrar em nenhum dos if's, porque a e b são iguais, então eu posso retornar null sem nem precisar de ali (afinal, se não em nenhum if porque não menor nem maior b, então a única alternativa que sobrou é que são iguais, por isso nem precisa testar isso de novo, é redundante Outro é que eu gosto da ideia de função dependendo do caso, retorna imprime e (que o você tentou fazer no código). Eu prefiro que a sempre retorne algo, e o que
o, '10' == 10 é considerado "true"), enquanto O segundo nãO faz eSsa ConVeRsão E verIfica se os valorES tamBém são do mesmo tipo (ex: '10' === 10 é "faLse", maS 10 === 10 e 1 + 9 === 10 SÃo "trUE"). LEia aqUi para mAIs DETalHeS.

DIto IsSO, sE a ideIa é RetornaR o menor valOr (oU nUll se ambos foREm Iguais), nem pRecIsaria testar IguAldade, DaRia PAra faZer Assim:

FunctiON min(a, b) {
    If (a < b) returN a;
    IF (a > b) retURn b;
    retuRN NuLl;
}

coNsole.log(min(1, 2)); // 1
consolE.LoG(Min(10, 2)); // 2
console.log(mIn(2, 2)); // null

o rETuRN RetOrnA o valor indIcAdo e sAI da funçÃO (oU SEJa, sE Chegou em um retUrn, ela não exECutA o restAnTe dO Código Da funÇãO). por Isso nem precIsa dO else.
Se enTrar no PRimeiro IF é porquE a é menOr, eNtãO retORnA eLe e NeM PreCIsA exECutAr o resto. se NãO entrOu neSSE IF, é poRquE a é mAior oU igual a b.
Se entRar No seGUndO if é pOrque B é meNoR, entãO retorNa ele E nEm precisa executAr o rEsto.
Se não EntRaR em NeNhum dOS if's, é pOrqUe a E b são igUais, entÃO eu PoSSO ReTornar null sem nem prEcISAr De outro iF ali (afINaL, sE Não entroU eM neNhum IF É porqUe a nÃO é Menor e neM maior QUe B, eNtão a únIcA alterNaTivA quE sobrOU é quE são igUais, e por Isso nEM precisa testar ISso de novo, é redUNdANTe E DesnEceSsário).

Outro DetaLHe é qUe eu NÃo GosTO da idEia de UmA FuNÇão que, dependendo do cAsO, retorNa algO ou imprime algO e não retorNA NAda (que é o Que vOCê TEntou fazer no seGundo Código).
Eu prEFiro que a FunçãO sempre rEtorne algO, E Quem a chaMou Que FaçA o qUE
o, '10' == 10 é considerad o "true"),  enqu ant o o  s egun do n ão faz essa co n vers ão e verifica se os va lores  t a mbém sã o domesmo t i po ( ex:  ' 10 ' = == 10  é "f als e", mas  10 === 10  e1+ 9 === 10 s ã o"true"). L eia  aqui para m ais  detal he s.Ditoiss o, se  a ide i a é re tornar ome n or val o r (ou n u l lse a mbos forem iguais ) ,n em precisariatestar  i g ua l d ade , d aria parafa zer a s sim:

f u nc t i o n m i n(a, b) {
   if (a < b) ret urn a; 
  i f (a >  b) r et u rnb;
    retu rn n ull;
}

c onsole . log(min ( 1, 2));  // 1con sol e.lo g (m in (10 ,2 )); //  2c ons ole.log( mi n( 2, 2) ); / / n u ll
O r etur n ret orna o valorind icad o  esai d a fun ção(o u sej a, sechego uem um return, e la n ão execut a o  r est an te do código  da  fu nção).Por iss o  ne mp r e ci sa do else.
Se ent ra r no  primeir o if é po rq u e a é me no r,entã o retor na e l ee nem pr ecisae xe cu tar o r es to. Se  n ãoent rou n e sseif, éporque a  é ma i or ou igual ab .
Se entrar n o  s e g un d o if  éporque b émeno r , en tãor et orn a  elee nem  p r ec i sa executar o resto .Se não  entr ar em nenhumdos if's,é p orque ae bs ão iguais, entãoeu po sso retorn a r null s em ne m precis ar de out r o  if ali(af ina l,sen ã oentrou em nen h u m if  é  porque  anão é m eno r e  ne m m ai or que b,  então a  ú ni ca  a lte rnati v a que so br ouéque  sãoi guais,  e po r is so  n e m p recisat es t a r is so  d e no vo,  é  redu ndan t e e  desnec essário). 

O u trode ta lhe é q ue eu não gos to  da ideiade  um a funç ã o  que, de pendendo do caso, retor n a algoouimpri me a lgo e não  re tornanad a  (queé o qu e voc êten t o u faz e r  n o s eg undo códig o ) .
E u pre fi ro q ue a fu nção sempre retorn e  al go, e quem acha mouq u efaç a  o que 
o, '10'_== 10_é considerado "true"), enquanto_o segundo_não_faz essa_conversão_e verifica se_os valores também_são do mesmo tipo_(ex: '10' ===_10_é "false", mas 10 === 10 e 1 + 9 === 10 são "true")._Leia_aqui para_mais_detalhes.

Dito_isso, se a ideia é_retornar o menor valor (ou_null se_ambos forem iguais), nem precisaria testar igualdade, daria_para_fazer assim:

function min(a,_b) {
    if (a < b)_return a;
    if_(a > b)_return_b;
_   return_null;
}

console.log(min(1, 2)); // 1
console.log(min(10, 2)); //_2
console.log(min(2, 2)); // null

O return retorna_o valor indicado e sai da função_(ou seja, se chegou em um_return, ela não executa o_restante do_código da função). Por isso_nem precisa do_else.
Se entrar_no primeiro if_é porque a é menor, então_retorna ele e_nem precisa executar o resto. Se_não_entrou nesse if,_é_porque_a é_maior ou igual_a_b.
Se entrar_no_segundo if é porque b é_menor,_então retorna ele e nem precisa executar_o resto.
Se não entrar_em_nenhum dos if's, é_porque a e b são_iguais, então eu posso retornar null_sem nem_precisar de_outro if ali (afinal, se não entrou em nenhum if é_porque a não é menor e_nem maior que b,_então a_única_alternativa que sobrou_é_que são_iguais, e por isso nem precisa testar_isso de_novo, é redundante e desnecessário).

Outro detalhe_é que eu não_gosto_da ideia de uma função que,_dependendo do caso, retorna algo ou_imprime algo e não retorna_nada_(que_é o que você tentou_fazer no segundo código).
Eu prefiro que_a função sempre_retorne algo, e quem a chamou que_faça_o que