Skip to main content

Dead Simple React.js with Meteor

I spent a little time exploring the patterns involved in using React.js with Meteor. It's incredibly easy, it turns out. I'll show some examples here.

The setup:

meteor add kadira:flow-router
npm install react react-dom react-mounter
npm install react-addons-pure-render-mixin
meteor add react-meteor-data

Then of course remove all blaze related meteor packages. Ok, Some basic component patterns: Let's create one that accepts a single argument:

Hello.jsx

import React from 'react';
export const Hello = ({name}) => (
  <div>Hello, {name}</div>
);

That's all there is to it. Now, let's see a pattern for a component that takes two arguments. We can see that to add further arguments, we can just tack them on after the first two:

TwoArgs.jsx

import React from 'react';
export const TwoArgs = ({one, two}) => (
  <div>
    <h2>TwoArgs!</h2>
    <h3>One is: {one}</h3>
    <h3>Two is: {two}</h3>
  </div>
);

"But, I really want a button that sets some text!"  Alright then, glad you asked:

WithButton.jsx

import React from 'react';

const handleClick = (event) => {
  event.preventDefault();
  console.log('clicked');
  document.querySelector('#foo').innerHTML="Yeah, I clicked it";
};

const WithButton = () => (
  <div>
    <button onclick="handleClick">Click Me&lt/button>
    <p>A handsome button sits above me</div>
    <p id="foo"></>
  </div>
);


Now, lets make a layout we can render our components into:

Layout.jsx

import React, { Component } from 'react';

export const Layout = ({content}) => (
  <div>{content}</div>
);

Finally, let's set up some routing:

router.js

import React from 'react';
import { mount } from 'react-mounter';
import { Layout } from './Layout.jsx';
import { Hello } from './Hello.jsx';
import { TwoArgs } from './TwoArgs.jsx';
import { WithButton } from './WithButton.jsx';

FlowRouter.route("/", {
  action() {
   mount(Layout, {
     content: ()
   });
  }
});

FlowRouter.route("/momo", {
  action() {
   mount(Layout, {
     content: ()
   });
  }
});

FlowRouter.route("/buttn", {
  action() {
   mount(Layout, {
     content: ()
   });
  }
});

Comments

Popular posts from this blog

Codeigniter vs. Kohana Database access speeds

I was doing some basic profiling for a project in which I needed the fastest raw speed I could get with database queries. I'm a fan of Codeigniter for projects that are suitable for it, but had heard from some that Kohana was faster, so I decided to do a very basic comparison of the two. I was using MAMP for OSX, and created a very small db, with a table that had 3 fields: (id), (first), and (last). The data sample was also very small, only a few records. The basic query I tested was a "SELECT * FROM [table]". There is of course nothing remotely scientific about this. It was just a quick ad dirty, very limited comparison. Take it as such. Versions used: CI2.1.3, Kohana 3.3.0. Codeigniter I really like Codeigniter (CI). But, one thing that is very evident from their own profiling functions, is that CI is a bit of a memory hog! Essentially, the same Controller function running in CI takes approximately 10X more memory than in Kohana! This in itself is not ...

Passing Functions and Lambdas into Functions with Ruby

Ruby's New Style of Lambda Functions f = ->( m ) { p m } f.call( 1 ) #=> 1 Which of course means the same thing as: f = lambda { |n| p n } f.call(1) #=> 1 Ruby Proc Objects p = Proc.new { |n| p n + 2 } p.call(2) #=> 4 Using a Function as a Closure in Ruby def domo( k ) ->(m) { p m + k } end z = domo( 5 ) z.call( 5 ) #=> 10 Function :domo takes a single parameter. Within :domo , we create a lambda that takes a single parameter, and adds that parameter to the value :domo takes in as its parameter. Then, we assign z to be the result of the lambda in :domo with its 'k' parameter loaded with 5. When z is called, we pass (another) 5 to it. This parameter loads the lambdas n parameter. The lambda executes, essentially adding n (5) + k (5) and yielding the result of 10. The thing about closures such as this is, we can load the initial value of the lambda to be whatever we want it to be when assigning the function :domo '...

Using Boost on OS X with Jetbrains' AppCode

So, after a serious pain in the butt getting Boost installed using the homebrew boost keg (see my previous post ), I decided to test things out using AppCode. Obviously, since this is a "3rd party library", a little massaging has to be done to get the libraries and headers found, and it's sufficiently obscure to deserve a post. I will list the procedure using my rig (OS X). You can extrapolate from this to your own kit. Right-click on your project icon, and select, "Project Settings..." , and scroll down to the "Search Paths" heading. About the third or so option down is "Header Search Paths" . Open that, and select either or both your type of build (Debug/Release), and then double click to the right of it under the "value" column. This will open up a window where you can add a path. Click the "+" and enter the path to the location of your copy of Boost's Headers. In my case: /usr/local/Cellar/boost/1....