React Native - What is the benefit of using StyleSheet vs a plain object?

What exactly is the benefit of using StyleSheet.create() vs a plain object?

const styles = StyleSheet.create({
  container: {
    flex: 1
  }
}

Vs.

const styles = {
  container: {
    flex: 1
  }
}

There is no benefit. Period.

Myth 1: StyleSheet is more performant

There is absolutely no performance difference between StyleSheet and an object declared outside of render (it would be different if you're creating a new object inside render every time). The performance difference is a myth.

The origin of the myth is likely because React Native team tried to do this, but they weren't successful. Nowhere in the official docs you will find anything about performance: https://facebook.github.io/react-native/docs/stylesheet.html, while source code states "not implemented yet": https://github.com/facebook/react-native/blob/master/Libraries/StyleSheet/StyleSheet.js#L207

Myth 2: StyleSheet validates style object at compile time

This is not true. Plain JavaScript can't validate objects at compile time.

Two things:

• It does validate at runtime, but so does when you pass the style object to a component. No difference.
• It does validate at compile time if you're using Flow or TypeScript, but so does once you pass the object as a style prop to a component, or if you properly typehint object like below. No difference either.

const containerStyle: ViewStyle = {
   ...
}

Quoting directly from comment section of StyleSheet.js of React native

Code quality:

• By moving styles away from the render function, you're making the code easier to understand.

• Naming the styles is a good way to add meaning to the low level components in the render function.

Performance:

• Making a stylesheet from a style object makes it possible to refer to it by ID instead of creating a new style object every time.

• It also allows to send the style only once through the bridge. All subsequent uses are going to refer an id (not implemented yet).

Also StyleSheet validates your stylesheet content as well. So any error of incorrect style property is shown at time of compiling rather than at runtime when StyleSheet is actually implemented.

The accepted answer is not an answer to the OP question.

The question is not the difference between inline styles and a const outside the class, but why we should use StyleSheet.create instead of a plain object.

After a bit of researching what I found is the following (please update if you have any info). The advatanges of StyleSheet.create should be the following:

1. It validates the styles
2. Better perfomances because it creates a mapping of the styles to an ID, and then it refers inside with this ID, instead of creating every time a new object. So even the process of updating devices is faster because you don't send everytime all the new objects.

It used to be considered that using a StyleSheet was more performant, and was recommended for this reason by the RN team up until version 0.57, but it is now no longer recommended as correctly pointed out in another answer to this question.

The RN documentation now recommends StyleSheet for the following reasons, though I think these reasons would apply equally to plain objects that are created outside of the render function:

• By moving styles away from the render function, you're making the code easier to understand.
• Naming the styles is a good way to add meaning to the low level components in the render function.

So what do I think are the possible benefits of using StyleSheet over plain objects?

1) Despite claims to the contrary my testing on RN v0.59.10 indicates that you do get some validation when calling StyleSheet.create() and typescript (and probably flow) will also report errors at compile time. Even without compile time checking I think it's still beneficial to do run time validation of styles before they are used for rendering, particularly where components that use those styles could be conditionally rendered. This will allow such errors to be picked up without having to test all rendering scenarios.

2) Given that StyleSheet is recommended by the RN team they may still have hopes of using StyleSheet to improve performance in future, and they may have other possible improvements in mind as well, for example:

3) The current StyleSheet.create() run-time validation is useful, but a bit limited. It seems to be restricted to the type checking that you would get with flow or typescript, so will pick up say flex: "1" or borderStyle: "rubbish", but not width: "rubbish" as that could be a percentage string. It's possible that the RN team may improve such validation in future by checking things like percentage strings, or range limits, or you could wrap StyleSheet.create() in your own function to do that more extensive validation.

4) By using StyleSheet you are perhaps making it easier to transition to third party alternatives/extensions like react-native-extended-stylesheet that offer more.