React JS Server side issue - window not found

Question

Hi I'm trying to use react-rte in my reactJS project. I have server side rendering and every time I want to use this package I get:

return /msie [6-9]\b/.test(window.navigator.userAgent.toLowerCase());
                               ^
ReferenceError: window is not defined

I guess the problem might be with isomorphic-tools but I don't know how to defer importing package to the client where window is going to be defined already.

Answer 1

Here is a npm library which can handle window, document and global object for you: Global .

Then you can safely write:

import window from 'global'

const mySpecialWindowFunction = () => {
    return /msie [6-9]\b/.test(window.navigator.userAgent.toLowerCase());
};

Answer 2

If you're doing server side rendering, there's a good chance that the global window object is going to be undefined because that is only something the client will understand.

Note: Initially, when you start up your project its going to render out a complete string of your DOM (at this point it will not know about window because it is server side, but then re-render with the client-side code to which your window object will be available!

There is a workaround that I am using in this case. This is what I have for my webpack plugin:

new webpack.DefinePlugin({
  'process.env.NODE_ENV': isDevelopment ? '"development"' : '"production"',
  'process.env.BROWSER': JSON.stringify(true),
  __DEV__: isDevelopment
}),

So I use process.env.BROWSER to my advantage because it will be defined as undefined if it is server side, and it will be true if the client side is done rendering.

Since everything just stops working when there isn't a window object on the server side we can add this:

const mySpecialWindowFunction = () => {

  /* START HACK */
  if (!process.env.BROWSER) {
    global.window = {}; // Temporarily define window for server-side
  }
  /* END HACK */

  return /msie [6-9]\b/.test(window.navigator.userAgent.toLowerCase());
};

That way, your console won't scream at you and doesn't stop the server side rendering, to which you can now carry on with your glorious day! Although I have to admit that this is a bit Hacky , but it gets the job done because all we want to do is let the server side render out the initial DOM string and then let the client-side take over.

Also Note: Don't worry about setting window as an empty object, it will be back to normal once the client-side finishes rendering.

Answer 3

For anyone else trying to figure why their SSR fails even though they are checking if window object is undefined.

You need to check if the window reference exists, not if it's value is null!

  if (typeof window === 'undefined') console.log('Window is not there')

Your window && and if (window) checks with are failing because in JavaScript not declared and 'undefined' are different things.

const a = undefined;
if (a) console.log('a');  // logs nothing, since 'a' is undefined
if (b) console.log('b');  // ReferenceError: b is not defined

And answer to the original question is that whenever accessing that need 'window' object, you need to make them conditional:

return (typeof window === 'undefined') ?
   'node' :
   /msie [6-9]\b/.test(window.navigator.userAgent.toLowerCase());

Answer 4

I've been using ReactJS.NET targeting build to client and server, and got the same problem.

The solution is to setoutput.globalObject to 'this' .

module.exports = {
  // ...
  output: {
    // ...
    globalObject: 'this'
  }
};

Without that option set, it's falling back to window which is working on client-only code.

Answer 5

When doing server-side-rendering, global like window , document will be undefined. And if you want to do it in isomorphic way, you have to test what environment is when rendering componets.

https://github.com/DavidWells/isomorphic-react-example

many example codes can be found on github, the link above is one of them, hope it can be helpful.

Answer 6

I tried setting it in my constants as a global import:

export const GLOBAL_WINDOW = (typeof self === 'object' && self.self === self && self) || (typeof global === 'object' && global.global === global && global) || this;

In this case it returns window or global object depending on weather your running it on client application or server.

Now you need to import this constant wherever you want to make use of window object.

Ex:

import { GLOBAL_WINDOW } from '../constants/Constants';

const user = JSON.parse(GLOBAL_WINDOW.localStorage.getItem('user'));

Answer 7

React supports Lazy loading via 'Suspense' specially for such purposes:

//add this to the top of your component
const RichTextEditor = React.lazy(() =>
  import("react-rte").then((module) => ({ default: module.Editor }))
);

render(){
     <Suspense fallback={<p>loading</p>}>
        <RichTextEditor />
     </Suspense>
}

Answer 8

我发现的另一个解决方案是，您可以在“componentDidMount”事件中使用“窗口变量”分配状态变量，并在“render”方法中测试您想要的状态变量是否为空或未定义，然后返回空值，直到“componentDidMount”完成。