Virtual DOM: React uses a Virtual DOM instead of the Real DOM. The Virtual DOM is a lightweight JavaScript representation of the Real DOM. When changes are made to the Virtual DOM, React compares the previous version with the new version and only updates the parts of the Real DOM that have changed. This process is fast, efficient and helps to improve the overall performance of the application.

Example: Let's say you have a list of items that you want to display on a page. If a new item is added to the list, the Real DOM would have to update the entire list, causing a slow render. With the Virtual DOM, only the minimum changes necessary to update the list are made, resulting in a faster and smoother update.

Server-side rendering: React allows for server-side rendering, which means that the initial render of the page can be done on the server, before it is sent to the client's browser. This can improve the load time and overall performance of the page, especially for slower internet connections.

Example: Imagine a website that has a lot of images and other media. Without server-side rendering, all of these images and media would have to be loaded on the client's browser, which can take a long time. With server-side rendering, the images and media can be loaded on the server first, and then sent to the client's browser, improving the overall performance of the page.

Uni-directional data flow or data binding: React follows a uni-directional data flow, which means that data flows in one direction from parent to child components. This helps to make the application more predictable and easier to debug. React also uses one-way data binding, which means that changes made to the data are reflected in the UI, but changes made to the UI are not reflected in the data.

Example: Consider a parent component that has a list of items and a child component that displays each item. If a new item is added to the list, the child component will automatically update to show the new item, because the data is flowing from the parent to the child. However, if a change is made to the item in the child component, that change will not be reflected in the parent component's list, because React follows one-way data binding.

Limitations of React are listed below:

1. React is just a library, not a full-blown framework: React is a JavaScript library for building user interfaces. It provides only the view layer of an application and doesn't offer features like routing, state management, etc. that are commonly found in full-blown frameworks. This means that developers need to rely on other libraries or write their own code to handle these tasks.
   
2. Its library is very large and takes time to understand: React has a large API surface area, which can make it difficult for new users to understand all of its features and how to use them effectively. It takes time to learn and master the intricacies of React, especially for those who are new to the front-end development world.
   
3. It can be little difficult for the novice programmers to understand: React uses concepts that may be unfamiliar to novice programmers, such as virtual DOM, components, and JSX. This can make it difficult for those who are new to programming to understand the core principles of React and how to use it effectively.
   
4. Coding gets complex as it uses inline templating and JSX: React uses JSX, a syntax extension for JavaScript, to create templates for components. While this approach can be powerful, it can also make code more complex and difficult to read, especially for those who are new to React. Additionally, React's use of inline templating can make it difficult to separate presentation logic from business logic, leading to a lack of separation of concerns in the code.