Memory Game in React
Ok, I had quite a few thoughts on this.

State

Your state seems more complex than it needs to be, and some of it is hiding outside of the state variable.
I think all you really need to keep track of are:
 - What order the images are in
 - Which images are currently selected
 - Which images have been guessed correctly

I don't really understand what tempCheckArr is, how it's different from compareImgArr, or why it's an instance variable.

Extract stuff

I think you have too much stuff crammed into one component.
I think you need to extract pieces of logic that can be self contained.

Prime example: shuffleArray

Why is shuffleArray declared inside componentWillMount?
This is creating a new shuffleArray function every time MemoryGame is mounted.
I think shuffleArray should at least be outside of this component, and really should be in a some sort of RandomUtil.js file.

Card component

I would also extract out a Card component that renders a card.
It should know:
 - What image to display
 - Whether or not it's selected
 - Whether or not it's been guessed correctly

This way you can keep your MemoryGame component about managing the state of the game while the Card component focuses on presentation.

Other Thoughts


Your &lt;img&gt; tag doesn't need a key prop because it's not the top level thing in an array.
Why is ImagePieces declared on this. It seems like it should be part of state.
(Also why is the I in ImagePieces uppercase? It seems like this should be imagePieces)
Why are you shuffling ImagePieces in componentWillMount and not just in the constructor?
It's kinda gross to reach into the DOM to compare the elements src attribute, and it makes it harder to understand what you actually want to compare: that the two images selected are of the same thing
Why are you converting integers to strings when you put them into tempCheckArr and converting them back when you take them out? Wouldn't it be easier to just put integers into the array?


How I would write it

const IMAGES = ["cat", "cat", "dog", "dog", "horse", "horse", "pig",
  "pig", "snake", "snake", "fish", "fish"];

class MemoryGame extends Component {
  constructor(props) {
    super(props);

    // You can simplify your state a lot
    this.state = {
      cards: shuffleArray(IMAGES.slice()),
      selected: [], // indexes which have been selected
      correct: [] // indexes which have been guessed correctly
    };
  }

  // Don't need a componentWillMount

  onCardClick(clickedIndex) {
    const { selected, cards, correct } = this.state;

    if (selected.length === 0) { // selecting a first card
      this.setState({ selected: [clickedIndex] })
    } else if (selected.length === 1) { // they're selecting a second card
      if (cards[selected[0]] === cards[clickedIndex]) {
        // It's a match :)
        // Add selected cards to `correct` and reset selection
        this.setState({
            correct: correct.concat([selected[0], clickedIndex]),
            selected: []
        });
      } else {
        // It's not a match :(
        // Select it for now, and reset selection in a bit
        this.setState({ selected: [selected[0], clickedIndex] });
        setTimeout(() =&gt; {
          this.setState({ selected: [] })
        }, 1500);
      }
    }
    // Otherwise they already have 2 selected and we don't wanna do anything
  }

  render() {
    const { correct, selected, cards } = this.state;
    return (
      &lt;div&gt;
        &lt;h1&gt;Memory Game&lt;/h1&gt;
        &lt;div className="mui-panel wrapper"&gt;
          {cards.map((image, i) =&gt; (
            &lt;MemoryCard
              key={i}
              image={image}
              isCorrect={correct.includes(i)}
              isSelected={selected.includes(i)}
              onSelect={() =&gt; this.onCardClick(i)}
            /&gt;
          ))}
        &lt;/div&gt;
      &lt;/div&gt;
    );
  }
}

// Extracted into it's own component
const MemoryCard = ({ image, isSelected, isCorrect, onSelect }) =&gt; (
  &lt;div
    className="modal mui-panel"
    onClick={() =&gt; {
      // You can only select a card that's not already correct and
      // isn't currently selected
      if (!isCorrect &amp;&amp; !isSelected) {
        onSelect();
      }
    }}
  &gt;
    &lt;img
      style={{ visibility: (isCorrect || isSelected) ? 'visible' : 'hidden' }}
      src={"./" + image + ".jpg"}
      srcSet={"./" + image + "_lrg.jpg 1000w"}
      alt={image}
    /&gt;
  &lt;/div&gt;
);

// Probably in a different file
function shuffleArray(array) {
  for (let i = array.length - 1; i &gt; 0; i--) {
    let j = Math.floor(Math.random() * (i + 1));
    [array[i], array[j]] = [array[j], array[i]];
  }
  return array;
}

export default MemoryGame;