AWK, 24 bytes

1,$0=index("(|)D",$NF)-1

Attempt This Online!

/\(/{$0=0}/\|/{$0=1}/\)/{$0=2}/D/{$0=3}1

Thunno 2 tB, 5 bytes

ṇ;Œ7%

Try it online!

Uses dingledooper's formula.

Explanation

ṇ;Œ7%  # Implicit input
       # Convert to codepoints
ṇ;     # Push compressed integer 160
  Π   # Take 160 mod each codepoint
   7%  # Mod each by 7
       # Implicit output of last item

Raku -p 23 Bytes -> 19 Bytes

$_=(4-.ords[*-1]*2%5)%4

$_=160%.ords[*-1]%7      #(with @dingledooper's formula)

Vyxal K, 7 bytes

td19%4%

Try it Online! -1 thanks to exedraj.

brainfuck, 94 bytes

,[[>++<-]>>,]>++++[<++++>-]<[+++<[>->+<[>]>[<+>-]<<[<]>-]>[-]<<<[>>>>>+<<]>>]>-[>+<-----]>---.

Try it online!

Uses Uriel's formula. Here's how it works:

,[[>++<-]>>,]

A nifty input loop that handles the optional nose and doubling the characters. It gets a character, doubles it into the next cell, then moves two cells over and tries to get another character. At the end, the tape looks something like

0 2*c1 0 2*c2 0 2*c3 0 ...
                     ^

This requires an implementation with EOF=0 or no change (which accounts for most of them including TIO).

>++++[<++++>-]<

Put 16 after the last doubled input. Now on to the main loop:

[+++<[>->+<[>]>[<+>-]<<[<]>-]>[-]<<<[>>>>>+<<]>>]

This loop will

• add 3 to the dividend (current cell). I do this because it's 2 bytes shorter to get 16 rather than 19, and these can be reused to construct 4 for the second dividend.
• compute the modulus of the previous%current cell.
• clear out a temporary variable
• check if the value of the cell 3 indices back is non-zero (which is only true on the first iteration since the loop ends 2 indices to the right of where it started). If it is, increment the cell where the next dividend will be (this sets up the second modulo 4).

For clarity, here's what the tape looks like during the first iteration, before the tempvar is cleaned:

0 2*c1 0 2*c2 0 0 tmp 2*c3%19 0 ...
                  ^

And the same for the second:

0 2*c1 0 2*c2 0 0 0 0 tmp 2*c3%19%4 0 ...
                      ^

So checking the cell 3 indices back is an easy way to see which iteration we're on without using a counter.

>-[>+<-----]>---.

And finally, a bit of wrapping abuse to add 48 to the result so it can be outputted.

There's probably room for improvement, particularly in the input loop or the memory layout, but this is the best I could come up with.

JavaScript, 2335

(・・? Did somebody say emoticons?

a = 
// The function:
(w)=>{(笑)=(w);ﾟωﾟﾉ= /｀ｍ´）ﾉ ~┻━┻   //*´∇｀*/ ['_']; o=(ﾟｰﾟ)  =_=3; c=(ﾟΘﾟ) =(ﾟｰﾟ)-(ﾟｰﾟ); (ﾟДﾟ) =(ﾟΘﾟ)= (o^_^o)/ (o^_^o);(ﾟДﾟ)={ﾟΘﾟ: '_' ,ﾟωﾟﾉ : ((ﾟωﾟﾉ==3) +'_') [ﾟΘﾟ] ,ﾟｰﾟﾉ :(ﾟωﾟﾉ+ '_')[o^_^o -(ﾟΘﾟ)] ,ﾟДﾟﾉ:((ﾟｰﾟ==3) +'_')[ﾟｰﾟ] }; (ﾟДﾟ) [ﾟΘﾟ] =((ﾟωﾟﾉ==3) +'_') [c^_^o];(ﾟДﾟ) ['c'] = ((ﾟДﾟ)+'_') [ (ﾟｰﾟ)+(ﾟｰﾟ)-(ﾟΘﾟ) ];(ﾟДﾟ) ['o'] = ((ﾟДﾟ)+'_') [ﾟΘﾟ];(ﾟoﾟ)=(ﾟДﾟ) ['c']+(ﾟДﾟ) ['o']+(ﾟωﾟﾉ +'_')[ﾟΘﾟ]+ ((ﾟωﾟﾉ==3) +'_') [ﾟｰﾟ] + ((ﾟДﾟ) +'_') [(ﾟｰﾟ)+(ﾟｰﾟ)]+ ((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+((ﾟｰﾟ==3) +'_') [(ﾟｰﾟ) - (ﾟΘﾟ)]+(ﾟДﾟ) ['c']+((ﾟДﾟ)+'_') [(ﾟｰﾟ)+(ﾟｰﾟ)]+ (ﾟДﾟ) ['o']+((ﾟｰﾟ==3) +'_') [ﾟΘﾟ];(ﾟДﾟ) ['_'] =(o^_^o) [ﾟoﾟ] [ﾟoﾟ];(ﾟεﾟ)=((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+ (ﾟДﾟ) .ﾟДﾟﾉ+((ﾟДﾟ)+'_') [(ﾟｰﾟ) + (ﾟｰﾟ)]+((ﾟｰﾟ==3) +'_') [o^_^o -ﾟΘﾟ]+((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+ (ﾟωﾟﾉ +'_') [ﾟΘﾟ]; (ﾟｰﾟ)+=(ﾟΘﾟ); (ﾟДﾟ)[ﾟεﾟ]='\\'; (ﾟДﾟ).ﾟΘﾟﾉ=(ﾟДﾟ+ ﾟｰﾟ)[o^_^o -(ﾟΘﾟ)];(oﾟｰﾟo)=(ﾟωﾟﾉ +'_')[c^_^o];(ﾟДﾟ) [ﾟoﾟ]='\"';(ﾟДﾟ) ['_'] ( (ﾟДﾟ) ['_'] (ﾟεﾟ+(ﾟДﾟ)[ﾟoﾟ]+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ (c^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ (c^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (c^_^o)+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ ((o^_^o) +(o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ ((o^_^o) +(o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (o^_^o))+ (c^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟｰﾟ)+ ((o^_^o) +(o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ (c^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(oﾟｰﾟo)+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ) .ﾟΘﾟﾉ+ (ﾟΘﾟ)+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (o^_^o)+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+((o^_^o) +(o^_^o))+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (o^_^o)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(oﾟｰﾟo)+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ) .ﾟΘﾟﾉ+ (ﾟΘﾟ)+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (o^_^o)+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+((o^_^o) +(o^_^o))+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (o^_^o)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟoﾟ]) (ﾟΘﾟ)) ('_');}
// Execute function:
a(':D');

I took it from this answer, encoded it with aaencode, and wrapped it an the arrow function.

Golfscript, 10 bytes

-1='(|)D'?

Try It Online!

Explanation:

-1=        # Gets the ASCII value of the final character. 
   '(|)D'? # Finds the index of that ASCII value, in the string '(|)D'. 

And then, the index value is implicitly printed.

Factor, 20 bytes

[ last "(|)D"index ]

Try it online!

Explanation:

If ":)" is on the data stack when this quotation is called...

• last Take the last element of the input.

  Stack: 41 (code point for ))

• "(|)D" Push a string to the stack.

  Stack: 41 "(|)D"

• index Find the index of 41 in "(|)D".

  Stack: 2

batch, 109 bytes 99 bytes

@For %%G in ("(=0",")=2","D=3","|=1")Do @Set %%G
@Set "T=%~1"
@<Nul Call Call Set/P"=%%%T:~-1%%%"

Perl 5 -p, 14 bytes

y/(|)D:-/0-3/d

Try it online!

Basically a port of my sed answer, but the y/// command in perl has the additional utilities of deleting extra characters and specifying ranges of characters, so this manages to be shorter and still contain :-/ and D: as essential parts of the code.

sed, 20 bytes

y/(|)D/0123/;s/:-*//

Pretty self explanatory. Replaces the the "mouth" characters with numbers using the y/// transform command and then strips off the eyes and the nose if they exist.

Try it online!

This is one byte longer, but perhaps it gets bonus points for having an emoticon in the code itself? :-\

y/(|)D/0123/;s/:-\?//

The shorter solution (16 bytes)

y/(|)D:-/0123  /

also works, but adds extra whitespace to each line of output. It also has two emoticons D: and :-/. :)

Try it online!

MAWP, 27 bytes

|2W!!92W1MP92W1MWA!!4P4WA:.

Try it!

International Phonetic Esoteric Language, 11 bytes

iʁ2f{J}ⱱ4ⱱo

Based on Uriel's formula.

iʁ2f{J}ⱱ4ⱱo
iʁ          (split the face into it's ord values)
  2f        (mouth * 2)
    {J}ⱱ    (mod 19) (base 26)
        4ⱱ  (mod 4)
          o (print)

MAWP 0.1, 27 bytes

|2W!!99M1MP99M1MWA!!4P4WA:.

Uses the modulo formula from @Uriel 's answer

JavaScript, 35 32 29 bytes

I based the logic off of the Java solution submitted April 2 and edited April 8, by branboyer. I suppose it would be referred to as a port of their answer, but I don’t know exactly how that’s supposed to be marked.

a=>"(|)D".indexOf(a[2]||a[1])

An anonymous function, taking a string and returning an integer. Please help me shorten it further, I’m new to golfing code. Just the code, without the way of inputting (no idea how to get input in try it online) is at this Try it online link

Python 3, 25 bytes

lambda s:160%ord(s[-1])%7

Try it online!

Math taken from @dingledooper

Mornington Crescent, 1820 bytes

Try it online!

A port of @dingledooper's fantastic Ruby answer, which just so happens to work seamlessly in Mornington Crescent because of a convenient 7 in it. Props to them!

Take Northern Line to Leicester Square
Take Northern Line to Leicester Square
Take Piccadilly Line to Turnpike Lane
Take Piccadilly Line to Turnpike Lane
Take Piccadilly Line to Leicester Square
Take Northern Line to Leicester Square
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Bakerloo Line to Baker Street
Take Bakerloo Line to Paddington
Take Bakerloo Line to Charing Cross
Take Bakerloo Line to Charing Cross
Take Northern Line to Moorgate
Take Circle Line to Moorgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to King's Cross St. Pancras
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Aldgate
Take Circle Line to Aldgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Preston Road
Take Metropolitan Line to Baker Street
Take Metropolitan Line to Preston Road
Take Metropolitan Line to Pinner
Take Metropolitan Line to Preston Road
Take Metropolitan Line to King's Cross St. Pancras
Take Victoria Line to Seven Sisters
Take Victoria Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Metropolitan Line to Pinner
Take Metropolitan Line to Preston Road
Take Metropolitan Line to Pinner
Take Metropolitan Line to Preston Road
Take Metropolitan Line to King's Cross St. Pancras
Take Circle Line to King's Cross St. Pancras
Take Northern Line to Mornington Crescent

The only major thing I feel I need to point out is how I got 160 in the program. To do this, I took the first letter of Paddington, which gives an ASCII value of 80 when run through Charing Cross, then multiplied it by 2 in Chalfont & Latimer to get 160. Subsequently, the program computes 160 % (ASCII of last character) % 7 via Preston Road, the formula found by @dingledooper.

Pyth, 8 bytes

x"(|)D"e

Try it online!

Exalanation

x"(|)D"e
          : Implicit evaluated input
       e  : Last element of input
 "(|)D"   : The string "(|)D"
x         : First occurrence of the last element of input in "(|)D"

Wolfram Language (Mathematica), 38 bytes

Mod[2Last@ToCharacterCode@#,19]~Mod~4&

Try it online!

This borrows Uriel's formula, which happens to be the same length as dingledooper's, but I can't help but wonder if another formula would be shorter. I will investigate.

For comparison, here's the string indexing solution (51 bytes):

("(|)D"~StringPosition~Last@Characters@#)[[1, 1]]-1&

Try it online!

PowerShell, 16 bytes

2*$args[-1]%19%4

Try it online!

PowerShell port of the modulo formula going around. Takes input via splatting

Hy, 33 bytes

(fn[s](%(%(*(ord(last s))2)19)4))

Try it online!

It's a basic port of Uriel's answer. I might be able to shorten it by getting rid of a % but I need to play around with the syntax.

C# (Visual C# Interactive Compiler), 17 14 bytes

Turns out Ranges finally started to actually exist and work! Thanks to an anonymous user for pointing this out (by proposing an edit, but anonymous users cannot comment...)

s=>160%s[^1]%7

Try it online!

J, 10 9 bytes

-1 byte thanks to FrownyFrog ang Bubbler

'(|)'i.{:

Try it online!

GolfScript, 11 bytes

)3?11%2/(p;

I'm convinced my method is the smallest possible, but this isn't the best possible one - just one of the earliest low-value ones.

)3?11%2/(p;
)           #Pop the last element of the string (as ascii value)
 3?         #Cube the number
   11%      #Modulo 11
      2/    #Divide by 2 (round down)
        (   #Decrement by one (gotta be 0 1 2 3, not 1 2 3 4)
         p; #Print the value we want, and shunt the rest of the stack

I used the following TIO to search for answers, and 11 popped up quite early. I also tried squares and higher powers, but they weren't as clean and short.

Try it online!

Every case!

T-SQL, 34 bytes

SELECT CHARINDEX(RIGHT(@,1),'|)D')-1

Requires the variable @ to be declared and assigned the input.

This code takes the right most character, and searches an indexed list of the possible mouthes. CHARINDEX returns a 1-based index. But, failing to find anything returns 0. So we leave the frown out of the search string (making the sad face even sadder).

Try it online! (SQL Fiddle)

C (gcc),  37  33 bytes

Saved 4 bytes on both versions thanks to @ceilingcat and @dingledooper

I overlooked the rule about the optional nose, so this is not as effective as expected.

f(char*s){s=390%~-s[*++s%9<1]&3;}

Try it online!

How?

Among the characters that we have to deal with, the hyphen is the only one whose ASCII code is congruent to \$0\$ modulo \$9\$. We use this property to decide whether we need to work on the second or the third character.

Given the ASCII code \$n\$ of the relevant smiley character, we apply the following formula to get the happiness:

$$h(n)=(390\bmod (n-1))\bmod 4$$

C (gcc),  36  32 bytes

Using Uriel's formula is 1 byte shorter.

f(char*s){s=s[*++s%9<1]*2%19&3;}

Try it online!

Kotlin, 27 24 bytes

-3 Refactor to remove it.

{"(|)D".indexOf(last())}

Try it online!

Python 3, 26 bytes

lambda s:ord(s[-1])*2%19%4

Try it online!

$$ f(x) = (2x \bmod 19) \bmod 4 $$

W, 7 bytes

☻M:ù·±♥

Uncompressed:

(|)D"azx

Explanation

         % Implicit quote
(|)D"    % The string "(|)D"
     az  % The last item of the input
       x % Where is ^ in the above string?

Excel, 25 bytes

=FIND(RIGHT(A1),"(|)D")-1

Red, 32 bytes

func[s][select"(0|1)2D3"last s]

Try it online!

APL (Dyalog), 11 8 bytes

3 bytes saved thanks to @Bubbler!

⊃'(|)'⍳⌽

Try it online!

       ⌽  reverse the string
⊃         take the last (now first) byte
 '(|)'⍳    index inside '(|)' (if not found ('D') returns the length (3))

Bash + GNU utilities, 17 bytes

tr '(|)D:-' 0-3\ 

Try it online!

Note: There's a space character after the backslash.

Input on stdin, output on stdout.

The challenge doesn't specify the format of the output. Depending on the input, this program may print the output in either %2d or %3d format (that is, with one or two spaces before the 0, 1, 2, or 3).

If that's not acceptable, then

tr -s '(|)D:-' 0-3\

(20 bytes) always prints the digit in %2d format. (There's a space after the backslash here too.)

Or

tr '(|)D:-' 0-4|tr -d 4

(23 bytes) prints just the digit (with no spaces).

05AB1E, 8 bytes

θÇx19%4%

Try it online!

Explanation

I used Uriel's formula.

θ        # Get mouth (last char)
 Ç       # ASCII value
  x      # Multiply by 2
   19%   # Modulo 19
      4% # Modulo 4

Keg, -hr, 18 bytes

?^⑵¦P0|\🄃1|R2|\¦3™

Try it online!

The same switch statement format, but with a different character checking criteria.

naz, 120 bytes

8a5m2x1v1a2x2v4a2x3v9a9a5a2x4v1x1f2r3x3v1e2f0x1x2f3x1v3e3x2v5e3x4v6e4f0x1x3f0m1o0x1x4f0m1a1o0x1x5f0m2a1o0x1x6f0m3a1o0x1f

Explanation (with 0x commands removed)

8a5m2x1v                 # Set variable 1 equal to 40 ("(")
1a2x2v                   # Set variable 2 equal to 41 (")")
4a2x3v                   # Set variable 3 equal to 45 ("-")
9a9a5a2x4v               # Set variable 4 equal to 68 ("D")
1x1f                     # Function 1
    2r                   # Read the second byte in the input string, removing it
      3x3v1e             # Jump back to the start of the function if it equals variable 3
            2f           # Otherwise, jump to function 2
1x2f                     # Function 2
    3x1v3e               # Jump to function 3 if the register equals variable 1
          3x2v5e         # Jump to function 5 if the register equals variable 2
                3x4v6e   # Jump to function 6 if the register equals variable 4
                      4f # Otherwise, jump to function 4
1x3f                     # Function 3
    0m1o                 # Output 0
1x4f                     # Function 4
    0m1a1o               # Output 1
1x5f                     # Function 5
    0m2a1o               # Output 2
1x6f                     # Function 6
    0m3a1o               # Output 3
1f                       # Call function 1

Raku, 19 bytes

{TR:d/(|)D:-/0123/}

Try it online!

Erlang (escript), 32 bytes

The verbosity offseted the bytecount.

h(I)->160rem lists:last(I)rem 7.

Try it online!

Io, 31 bytes

Io's strings are made of integers, so character-converting is unneccecary. Although Io doesn't allow us to index the last item of a sequence using last()...

method(x,160%x reverse at(0)%7)

Try it online!

MATL, 9 bytes

'|)D'jmfs

Try it online!

Explanation

'|)D' % Push this string
j     % Read input as unevaluated string
m     % ismember: true for chars of the first string that are present in the second
f     % find: (1-based) indices of true entries. The result will have length 0 or 1
s     % sum. This is needed to transform an empty array into 0
      % Implicitly display

Japt, 9 bytes

"(|)D"bUÌ

Try it

Jelly,  8  7 bytes

⁽$9,4ḥ’

A monadic Link accepting a list of characters which yields an integer in \$[0,3]\$.

Try it online!

How?

⁽$9,4ḥ’ - Link: list of characters, A
⁽$9     - base 250 literal = 10058
   ,4   - pair with four
     ḥ  - Jelly hash A using 10058 as a salt and [1,2,3,4] as the domain
      ’ - decrement

Previous 8 byter:

“|)D”iⱮS

Try it online!

How?

“|)D”iⱮS - Link: list of characters, A             e.g. ":-)"     OR  ":-("
      Ɱ  - map across c in A with:
     i   -   first index of c in (or 0 if not found):
“|)D”    -     list of characters = "|)D"               [0,0,2]       [0,0,0]
       S - sum                                          2             0

Charcoal, 10 bytes

Ｉ⌕(|)D§Ｓ±¹

Try it online! Link is to verbose version of code. Explanation:

       Ｓ    Input string
      §     Cyclically indexed by
         ¹  Literal 1
        ±   Negated
 ⌕          Find index in
  (|)D      Literal string of mouths
Ｉ           Cast to string
            Implicitly print

Retina 0.8.2, 16 12 bytes

T`-:(|)D`__d

Try it online!

T`

Enter transliteration mode

(|)D`d

Replace the mouth character with the corresponding digit (0 to 3)

-:`__

Remove each of - and : from the string.

Implicitly output the result, which will be a single digit.

Ruby, 20 bytes

s[-1].ord will give us the codepoint of the last character in the string, which we can then plug into this formula: $$(160 \bmod c) \bmod 7 $$

->s{160%s[-1].ord%7}

Try it online!

Perl 5 -p, 24 bytes

s/.*(.)/ord($1)*2%19%4/e

Try it online!

Steals the math from @Uriel's Python answer

Python 3, 28 27 bytes

lambda e:"(|)D".find(e[-1])

Try it online!

Because we don't care about the eyes/nose, we can just look at the mouth (the last character) and find its index in a string with all the mouths, ordered from saddest to happiest :) Thanks @Surculose Sputum!