I am reading through Learn you a haskell.It says:

null checks if a list is empty. If it is, it returns True, otherwise it returns False. Use this function instead of xs == [] (if you have a list called xs)

I tried in ghci:

xs = []
xs == []
null xs

Both of them are True.

I wonder what`s the different.
Should I use null function instead of == [] and why?

You should use null. In most cases it doesn't matter, but it is a good habit to get into anyway, because occasionally you may want to check if a list of non-comparable things is empty. Here is a short, crisp example showing this difference:

> null [id]
False
> [id] == []
<interactive>:1:1: error:
 • No instance for (Eq (a0 -> a0)) arising from a use of ‘==’
 (maybe you haven't applied a function to enough arguments?)
 • In the expression: [id] == []
 In an equation for ‘it’: it = [id] == []

There is a difference. In order to use x == [], the type of the elements should be a member of the Eq typeclass. Indeed, checking the equality of two elements is defined by:

instance Eq a => Eq a where
 [] == [] = True
 (x:xs) == (y:ys) = x == y && xs == ys
 _ == _ = False

That means that you can not use x == [] if x is for example a list of IO Ints.

null :: [a] -> Bool on the other hand, uses pattern matching. This is implemented as:

null :: [a] -> Bool
null [] = True
null (_:_) = False

So regardless what the type of the elements of the list are, it will at least typecheck.

In addition to the good answers given so far, null actually has type

null :: Foldable t => t a -> Bool

I don't know if you've gotten to typeclasses in LYAH, but the short of it is that null can be used not just for lists, but for any data structure that implements null.

This is to say that using null on a Map or a Set is valid, too.

> null Map.empty
True
> null (Map.singleton 1)
False
> null Set.empty
True
> null (Set.singleton 1)
False
> null []
True
> null [1]
False

I don't think it's especially common to write functions that need to be this general, but it doesn't hurt to default to writing more general code.

A side note

In many cases, you'll end up wanting to use a function like null to do conditional behavior on a list (or other data structure). If you already know that your input is a specific data structure, it's more elegant to just pattern match on its empty case.

Compare

myMap :: (a -> b) -> [a] -> [b]
myMap f xs
 | null xs = []
myMap f (x:xs) = f x : myMap f xs

to

myMap' :: (a -> b) -> [a] -> [b]
myMap' f [] = []
myMap' f (x:xs) = f x : myMap' f xs

In general, you should try to prefer pattern matching if it makes sense.

Also a simple function that filter all empty list would fail:

withoutEmpty = filter (== [])

and that would be:

withoutEmpty = filter null

Also look at @cole answer, it complements all the answers here, the typeclass Foldable has the null function there to be implemented:

To see more info of Foldable here