Octave, 52 46 40 bytes

['['-('"':'+'),'{'-(_='!':':'),_+'@','']

This evaluates to

9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

Explanation:

Here we are using the fact that character are implicitly converted to integers which here happens with the arithmetic operations +- and the range function :. When concatenated with an empty string ([...,'']), the numbers again are converted to characters.

Try it online!

Ruby, 42 bytes

->{[*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`]}

A function that returns a char array. A program that outputs just the characters is 49 bytes:

$><<([*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`])*''

This simply uses the ascii characters on either side of the relevant ranges to define a range. For example, ?/...?: means the characters between a forward slash and a colon, excluding the end. To get rid of the beginnings, we subtract an array containing the three beginning characters.

V, 8 7 bytes

1 byte saved thanks to @DJMcMayhem by putting it all in one regex statement

¬/{Ó×ü_

Try it online!

Outputs:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Note: × is not x or X, it is 0xd7

Hexdump:

00000000: ac2f 7bd3 d7fc 5f                        ./{..._

Explanation

¬/{            " inserts every character in the range / to {

Now the output looks like:

/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{

We have to remove all the non-alphanumeric characters and the _ (since it is not included in \W), so let's do that using regex

Ó×ü_           " removes every character that is non-alphanumeric or an underscore _ 
               " vim equivalent of :s/\W\|_//g

brainfuck, 77 76 75 72 bytes

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

Try it online!

How it works

The interpreter begins with a tape of 0 cells.

++++++++

This sets the first cell to 8, leaving the tape in the following state.

   8
   ^

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

This increments the second cell once, the third cell 6 times, the fourth cell 4 times, decrements the fifth cell once, then goes back to the beginning of the tape and decrements the first cell. After 8 iterations, the tape looks like follows.

  0   8  48  32  -8
  ^

>++

We advance to the second cell and increment it twice, getting ready to print the digits.

  0  10  48  32  -8
      ^

[>.+<-]

This prints the third cell, increments it, then goes back to the second cell and decrements it. After 10 iterations, we've printed 0123456789 and the tape looks like follows.

  0   0  58  32  -8
      ^

>>

Time to prep the tape for the letters! We begin by advancing two cells.

  0   0  58  32  -8   0   0
              ^

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

This increments the fifth cell once, the sixth cell twice, the seventh cell thrice, then goes back to the fourth cell and decrements it. After 32 iterations, the tape looks like follows.

  0   0  58   0  24  64  96
              ^

>++

As a last step before printing the letters, we advance to the fifth cell and increment it twice.

  0   0  58   0  26  64  96
                  ^

[>+.>+.<<-]

Finally, we advance to the sixth cell to increment and print it, do the same for the seventh cell, then go back to the fifth cell and decrement it. After 26 iterations, we've printed Aa...Zz.

Brainfuck, 89 85 bytes

Because brainfuck ignores alphanumeric characters anyway, this is just a constant-output challenge... (Edit: See Dennis' Solution for a version which is 10 bytes shorter)

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

Try it online!

This code is a good example of basic counted loops in brainfuck:

+[-[--<]>>--]   Create value 47: char just before '0'
++++++++++      Set adjacent cell to 10: to be used as a counter

[               While the counter is not 0:
 <+.              Increment and print the char
    >-            Decrement the counter
       ]        (End loop: Exits when all digits have been printed)


<++++++++>           The char is now at '9' so add 8 to make it 'A'
+[-[---<]>>-]<-      In another cell create lowercase 'a'
<<+++++[>+++++<-]>+  Create 26: the number of times to loop

[                While the counter is not 0:
 >.+               Print and increment the lowercase char
    <<<.+          Print and increment the uppercase char
         >>-       Decrement the counter
            ]    (End loop: Exits when all letters have been printed)

Note that this uses wrapping shortcuts to generate numbers, meaning that the interpreter needs to have 8-bit wrapping cells (such as the one I linked to).

6502 machine language, 74 70 68 bytes

Hex dump (6502 programs are generally not relocatable; the code here is stored starting at location $0603):

0600:          a9 24 0a 8d 20 06 8d 21 06 8d 23 06 8d 
0610: 25 06 09 20 8d 1a 06 8d 1c 06 ea aa ea a8 a9 00 
0620: ea ea 98 ea 8a ea a2 ff a9 7b a0 60 20 3a 06 a9 
0630: 5b a0 40 20 3a 06 a9 3a a0 2f 85 80 c8 e8 98 95 
0640: 00 c8 c4 80 d0 f7 60

You can see that this uses none of the prohibited bytes: $41 through $5a, $61 through $7a, or $30 through $39.

This is a function with no arguments that, when called, returns a pointer to the character array "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" at the top of the stack, in accordance with standard 6502 calling conventions.

By way of explanation, here's a disassembly:

Address  Hexdump   Disassembly
-------------------------------
$0603    a9 24     LDA #$24
$0605    0a        ASL A
$0606    8d 20 06  STA $0620
$0609    8d 21 06  STA $0621
$060c    8d 23 06  STA $0623
$060f    8d 25 06  STA $0625
$0612    09 20     ORA #$20
$0614    8d 1a 06  STA $061a
$0617    8d 1c 06  STA $061c
$061a    ea        NOP 
$061b    aa        TAX 
$061c    ea        NOP 
$061d    a8        TAY 
$061e    a9 00     LDA #$00
$0620    ea        NOP 
$0621    ea        NOP 
$0622    98        TYA 
$0623    ea        NOP 
$0624    8a        TXA 
$0625    ea        NOP 
$0626    a2 ff     LDX #$ff
$0628    a9 7b     LDA #$7b
$062a    a0 60     LDY #$60
$062c    20 3a 06  JSR $063a
$062f    a9 5b     LDA #$5b
$0631    a0 40     LDY #$40
$0633    20 3a 06  JSR $063a
$0636    a9 3a     LDA #$3a
$0638    a0 2f     LDY #$2f
$063a    85 80     STA $80
$063c    c8        INY 
$063d    e8        INX 
$063e    98        TYA 
$063f    95 00     STA $00,X
$0641    c8        INY 
$0642    c4 80     CPY $80
$0644    d0 f7     BNE $063d
$0646    60        RTS

The machine-language code is self-modifying. For stack manipulation, I needed to use PHA and PLA to push and pop the accumulator, but these instructions have opcodes $48 and $68, which are prohibited (they're the ASCII codes for the letters 'H' and 'h'). So, for PHA, I take the number $24, do an arithmetic shift left (ASL), and store the resulting $48 in the four spots in the code where it needs to be executed. Then, for PLA, I use a bitwise OR on the $48 in the accumulator to compute $68, and store it in the two spots in the code where it's needed.

There were several instructions other than PHA and PLA that I also couldn't use because their opcodes happen to be the same as ASCII letters or digits, but I found direct workarounds for those others.

The desired character array is computed and stored starting at location 0 (it doesn't really matter where it's stored since we just need to be sure that a pointer to it is returned the top of the stack).

You can try this out at Nick Morgan's 6502 assembler and emulator. Here's a screenshot; the monitor box at the bottom shows the output string (in locations $00 through $3D) after the program is run.

Haskell, 75 72 63 bytes

__=[_'|_'<-['/'..],'/'<_',_'<':'||'@'<_',_'<'['||'`'<_',_'<'{']

Try it online! Call with __. Output:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Thanks to xnor who suggested __ and _' as variable names instead of (!) or similar, saving 9 bytes. I especially like how _' breaks the syntax highlighting.

Explanation:

__ and _' are valid variable names. From the language specification:

An identifier consists of a letter followed by zero or more letters, digits, underscores, and single quotes. [...] Underscore, _, is treated as a lower-case letter, and can occur wherever a lower-case letter can. However, _ all by itself is a reserved identifier, used as wild card in patterns.

So the code is equivalent to

s=[c|c<-['/'..], '/'<c, c<':' || '@'<c, c<'[' || '`'<c, c<'{']

The range ['/'..] builds the infinite string

"/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\DEL\128\129\130 ..."

The list comprehension filters this string by keeping only the chars c for which holds

• '/'<c to get rid of /
• c<':' || '@'<c to get rid of :;<=>?@
• c<'[' || '(backtick)'<c to get rid of []^_`
• c<'{' to truncate everything after z

Brain-Flak, 171 bytes

Includes +3 for -A

(((((()()()){}){}){}){})(((()()())){}{}){({}[()]<(({})())>)}{}(({})(()()()()){})(((((()()()){}){}){}())<{({}[()]<(({})())>)}{}(({})(()()()){}())>){({}[()]<(({})())>)}{}

Try it online!

(((((()()()){}){}){}){}) # push 48
(((()()())){}{})         # push 9
{({}[()]<                # for 9..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()()){})       # pop a, push a, push a + 8
(((((()()()){}){}){}())< # push 26 and save a 26 for later
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()){}())       # pop a, push a, push a + 7
>)                       # push that 26 that we held
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for

There is probably a way to do this without having to repeat the add 1 "function".

PHP, 69 bytes

<?=~"ÏÎÍÌËÊÉÈÇƾ½¼»º¹¸·¶µ´³²±°¯®­¬«ª©¨§¦¥žœ›š™˜—–•”“’‘ŽŒ‹Š‰ˆ‡†…";

The code is stylized using Windows-1252 here. Below is a reversible xxd hexdump.

00000000: 3c 3f 3d 7e 22 cf ce cd cc cb ca c9 c8 c7 c6 be  <?=~"...........
00000010: bd bc bb ba b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 af ae  ................
00000020: ad ac ab aa a9 a8 a7 a6 a5 9e 9d 9c 9b 9a 99 98  ................
00000030: 97 96 95 94 93 92 91 90 8f 8e 8d 8c 8b 8a 89 88  ................
00000040: 87 86 85 22 3b                                   ...";

Try it online!

Jelly, 17 16 bytes

“:[{“/@`‘Ḷḟ"/ỌḊ€

Try it online!

How it works

“:[{“/@`‘Ḷḟ"/ỌḊ€  Main link. No arguments.

“:[{“/@`‘         Yield [[58, 91, 123], [47, 64, 96]].
         Ḷ        Unlength; map each n to [0, ..., n-1].
          ḟ"/     Reduce by vectorizing filter-false.
                  This yields [[47, ..., 57], [64, ..., 90], [96, ..., 122]].
             Ọ    Unordinal; replace each n with the corr. Unicode character.
              Ḋ€  Deqeue each; remove the first character of each of the three
                  generated strings ('/', '@', and '`').

05AB1E, 18 15 bytes

'/Ç`•£•Ÿç©á®þ«˜

Try it online!

'/Ç`•£•Ÿ            # Push [47..122] by converting the char `\` to ascii & base-214 of `£`.
        ç           # Convert to ASCII chars.
         ©          # Store full array in register.
          á         # Push the same array with ONLY letters.
           ®        # Push contents of register (char)[47..122].
            þ       # Push only the digits.
             «˜     # Concat to list, flatten it. 

I tried so many different approaches, but the key points here that made it hard:

- Basic commands will not work, only extended and a select few of the basics.
- Extended commands are pretty complex.
- Eval (.V) will not work.
- To push numbers you can do a base 214 compression.
- ALL sequence pushes (E.G. žK) won't work.
- ALL number pushes won't work, except for compression and the -1 an empty register pushes.

J, 171 bytes

(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

Ow... my brain hurts... Try it online!

Here's so you can see all of it one line (it won't run, though, with line breaks.)

(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*
_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

Only guaranteed to work with J version j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52, in that order. (Only the first 12 characters matter.)

Explanation

Most of the program is devoted to constant generation. With those constants replaced with their values, the program looks like this:

(62){.".(':',~(12){(9)!:(14)''),',',(":(65),(97),48),'+/',('.',~(10){(9)!:(14)''),":26

With some parentheses removed, and some numbers made nicer:

62{.".(':',~12{9!:14''),',',(":65 97 48),'+/',('.',~10{9!:14''),":26

This is composed of a bunch of , and ,~s, which append and prepend arguments. Here are the separate values:

1. ":26
2. ('.',~10{9!:14'')
3. '+/'
4. (":65 97 48)
5. ','
6. (':',~12{9!:14'')

1 is 26 as a string.

9!:14'' generates the following string on TIO:

j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52

with 2, we obtain the 10th character (i from linux), and add a . to the end of it, yielding i..

3 and 5 are self-explanatory.

4 is the list of numbers 65 97 48 as a string.

6 is similar to 2, except it's the 12th character (u from linux) and adds a : to the end, yielding u:.

This, all together, yields u:,65 97 48+/i.26. ". evaluates this, giving us:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(Note: +/ is tabulated addition.)

Then, with 62{., we take the first 62 characters from this, giving us ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.

JavaScript, 1223 bytes

_=~[]
$={}
___=++_
____=![]+""
$$$$=____[_]
__$=++_
$_$_=____[_]
_$_=++_
$_$$=($+"")[_]
$$_$=(_[_]+"")[_]
_$$=++_
$$$_=(!""+"")[_]
$__=++_
$_$=++_
$$__=($+"")[_]
$$_=++_
$$$=++_
$___=++_
$__$=++_
_="\\"
_$_$=$.$
_$$_=(!""+"")[__$]
_$__=$+""
_$=_$__[__$]
__$_=(_$_$+"")[__$]
__=_$__[$$_]
___$=(!""+"")[_$_]
$_=_$__[$_$]+_$+__$_+(!$+"")[_$$]+__+_$$_+___$+_$__[$_$]+__+_$+_$$_
$$=_$$_+(!""+"")[_$$]+__+___$+_$$_+__$_
$=___[$_][$_]
$($($$+"\""+$$__+_$+_+__$+$_$+$$_+_+__$+$$_+_$$+_$+____[_$_]+$$$_+"."+____[_$_]+_$+_+__$+$__+$$$+"('"+$_$_+$_$$+$$__+$$_$+$$$_+$$$$+_+__$+$__+$$$+_+__$+$_$+___+_+__$+$_$+__$+_+__$+$_$+_$_+_+__$+$_$+_$$+____[_$_]+_+__$+$_$+$_$+_+__$+$_$+$$_+_$+_+__$+$$_+___+_+__$+$$_+__$+_+__$+$$_+_$_+_+__$+$$_+_$$+__+___$+_+__$+$$_+$$_+_+__$+$$_+$$$+_+__$+$$$+___+_+__$+$$$+__$+_+__$+$$$+_$_+_+__$+___+__$+_+__$+___+_$_+_+__$+___+_$$+_+__$+___+$__+_+__$+___+$_$+_+__$+___+$$_+_+__$+___+$$$+_+__$+__$+___+_+__$+__$+__$+_+__$+__$+_$_+_+__$+__$+_$$+_+__$+__$+$__+_+__$+__$+$_$+_+__$+__$+$$_+_+__$+__$+$$$+_+__$+_$_+___+_+__$+_$_+__$+_+__$+_$_+_$_+_+__$+_$_+_$$+_+__$+_$_+$__+_+__$+_$_+$_$+_+__$+_$_+$$_+_+__$+_$_+$$$+_+__$+_$$+___+_+__$+_$$+__$+_+__$+_$$+_$_+__$+_$_+_$$+$__+$_$+$$_+$$$+$___+$__$+___+"')\"")())()

I ran console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890') through jjencode and golfed the result manually. There are definitely more optimizations that can be done.

Julia 0.4, 46 bytes

_()=['¥':'®';'¶':'Ï';'Ö':'ï'].-['~'-'	']

This is a generic function that returns a character array.

Try it online!

Alternate version, 47 bytes, ASCII-only

_(_=_==_)=['/'+_:':'-_;'@'+_:'['-_;'`'+_:'{'-_]

Try it online!

CJam, 15 bytes

"{`[@:/"_:,:^\-

Try it online!

Explanation

"{`[@:/" e# Push this string. Note that these are the characters just above and
         e# below the a-z, A-Z and 0-9 ranges, respectively.
_        e# Get a copy of the string.
:,       e# Turn each character into a range, i.e. all characters from the null byte
         e# to the the character below the given one. E.g. { is turned into "...xyz".
:^       e# Fold symmetric set difference over the list. Gives us the characters that
         e# appear in an odd number of the strings. Those are the letters, the digits
         e# as well as `, @ and /.
\        e# Pull the other copy of the string on top.
-        e# Remove these characters from the string. That leaves only the alphanumerics.

PHP 7.0+, 110 bytes

God bless bitwise strings!

<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^_,'%'^_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^_));

Replace the \n with a real *NIX-style newline.
It is present in the code to avoid problems with newlines, but isn't counted in the score.

This throws a bunch of warnings, but those could be supressed by appending an @ in front of every stray _.

Warning free, 113 bytes

<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^@_,'%'^@_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^@_));

Befunge, 73 72 59 bytes

<_^#!+`"`"\+*`\":"\`"/":\*`\"["\`"@":::::_@#-"{":+%"#$"
^,<

Try it online!

There's not a whole lot going on here. It's a single loop starting at zero (an implicit value from the empty stack) and ending at { (i.e. one character after z). To increment the loop counter without referencing 1, we use the sequence "$#"%+ (you can see that in reverse at the end of the first line), since $ (ASCII 36) modulo # (ASCII 35) is equal to 1.

The rest of the code is just a long boolean expression calculating if the character is in range. If so, we branch off and write it out, otherwise we continue to loop around and process the next character in the sequence. The branch commands all go upwards, since we can't use a v, but that's fine because the instruction pointer automatically wraps at the top of the playfield.

𝔼𝕊𝕄𝕚𝕟, 8 chars / 19 bytes

ᶐ+ᶛ+⩥Ⅹă⬯

Try it here!

ᶐ is the uppercase alphabet, ᶛ is the lowercase alphabet, and ⩥Ⅹă⬯ is range (⩥) from 0 to 10 (Ⅹ, the unicode roman numeral) minus 1, joined by (ă) nothing (⬯).

Actually 8 5 btyes

">"┘▀

How it works:

 ">"   Pushes > onto the stack as a string
           STACK: [>]
    ┘  Converts the top item of the stack to it's ordinal
           STACK: [62]
     ▀ Push all digits from base n(top item of the stack)
           STACK: [012...xyz]

Print is implicit at the end of the program.

Edit 1: Replaced putting the alphabet in lower/uppercase and then the number range(10) with just getting base 62's printable characters.

Try it online!

WSF, 145 bytes

Prtty much a direct translation of Dennis's answer.

Stack Exchange cannot display the code, so here is a reversible xxd hexdump:

00000000: 2020 2020 2020 2020 2020 2020 2020 2020                  
00000010: 0a20 200a 2020 200a 2020 2020 2020 2020  .  .   .        
00000020: 2020 2020 200a 2020 2020 2020 2020 200a       .         .
00000030: 2009 0920 0920 0920 0920 2009 0a09 200a   .. . . .  ... .
00000040: 2020 2020 0a20 200a 0909 2020 0920 2009      .  ...  .  .
00000050: 0a09 200a 200a 0a20 200a 2020 200a 2020  .. . ..  .   .  
00000060: 2020 200a 2020 2020 2020 0920 0920 0920     .      . . . 
00000070: 2009 0a09 200a 2020 2020 0a20 200a 2020   ... .    .  .  
00000080: 0909 200a 2020 0909 0920 0920 2009 0a09  .. .  ... .  ...
00000090: 0a

The interpreter runs it perfectly, producing the following output:

0123456789AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz

JavaScript (ES6), 812 bytes

$={}
____=!$+""
$$$$=____[___=_=+[]]
__$$=!_+""
_$_$=$.$+""
$_$_=____[__$=++_]
_$$_=__$$[_]
_$__=$+""
_$=_$__[_]
__$_=_$_$[_]
$_$$=_$__[_$_=++_]
$$_$=_$_$[_]
___$=__$$[_]
$$$_=__$$[_$$=++_]
$__=++_
$$__=_$__[$_$=++_]
__=_$__[$$_=++_]
$$$=++_
$___=++_
$__$=++_
$_=_$__[$_$]+_$+__$_+____[_$$]+__+_$$_+___$+_$__[$_$]+__+_$+_$$_
_$$$=$_[$_$]
$$=_$$_+__$$[_$$]+__+___$+_$$_+__$_
_="\\"
$=$[$_][$_]
$($($$+'"'+$$$$+_$+_$$$+"($ "+_$+$$$$+["[["+$__+$___,""+$_$+$___+"],["+$$_+$_$,""+$__$+__$+"],["+$__$+$$$,""+__$+_$_+_$$]+"]])"+$$$$+_$+_$$$+"(_=$["+___+"];_<$["+__$+"];_++)"+$$__+_$+$_[_$_]+$_[_$$]+_$+____[_$_]+$$$_+"."+____[_$_]+_$+_+__$+$__+$$$+"(\\"+__$+_$_+_$$+__+_$$$+_+__$+$_$+__$+$_[_$_]+_+__$+$__+$$$+"."+$$$$+_$$$+_$+_+__$+$_$+$_$+_+__$+___+_$$+_+__$+$_$+___+$_$_+_$$$+_+__$+___+_$$+_$+$$_$+$$$_+'(_))"')())()

Spent quite a long time golfing JJEncode (hat-tip to darrylyeo for that), but instead of golfing

console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

I golfed

for($ of[[48,58],[65,91],[97,123]])for(_=$[0];_<$[1];_++)console.log(String.fromCharCode(_))

Check the console under developer tools to see the entire output, as the stack console only keeps the latest output (everything C and after).