Scope Chain

In JavaScript, Scope Chain is a hierarchy of variable scopes, where each scope references its outer scope until the global scope is reached. Scope in JavaScript is a region of code where a variable can be accessed. It's important to note that any variable defined inside a function, including that function's parameters, is different from a variable with the same name defined outside the function.

JavaScript has two main types of scopes: Global Scope (a variable declared outside a function or declared with window object) and Local Scope (a variable declared inside a function). When it comes to React (or JavaScript in general), the scope chain resolution is used for variable look-up. If a certain variable is not found in the current scope, the system will look up in the outer scope, and the process continues until the variable is found or the global (window) scope is reached.

In a React component, every method you define has its own scope.

```jsx
class MyComponent extends React.Component {
constructor(props) {
super(props);
this.myVariable = "Hello"; // This variable is accessible in all methods
}

myMethod = () => {
let myLocalVariable = "World"; // This variable is only accessible inside myMethod
console.log(this.myVariable + " " + myLocalVariable); // Output: Hello World
}
}
```

In this example, 'myVariable' is accessible throughout the class because it's defined within the class's scope. In, 'myVariable' is part of the object that's created from 'MyComponent'. However, 'myLocalVariable' is only available within 'myMethod', because it's defined in the local scope of 'myMethod'. This is the concept of JavaScript's Scope Chain explained with respect to a React component. The Scope Chain defines the accessibility of variables in different parts of the code.