Posted by Ian on August 27, 2015 in
CSS,
HTML5One of the more common ways that you see collections of items displayed on the web are tile based layouts. Usually these tiles will consist of a container with an image and some sort of descriptive text below the image or as an overlay. Accomplishing this sort of layout in HTML and CSS is not particularly difficult but in some scenarios there are some interesting challenges to tackle, especially when it comes to responsive views. We will explore some of these in what follows.
Certainly in doing a layout of tiles you could use the grid of a CSS framework like Bootstrap or Foundation to put each individual tile into a grid column. But there are, shall we say, annoyances that come with trying to do this. For one thing, because Bootstrap is on a system of rows and grids you will have to count the number of items as they come back to figure out when to close out one row and start a new one. For example, if you wanted a two column grid of items and you were returning markup from the server you would have close out the Bootstrap row on every second item. We’ll be using PHP in our example. I do realize that normally in a production-grade app you would not (or should not) mix this UI content with your server sided logic like we do below. You’d probably use a templating engine of some sort. But this is just an example for the purposes of illustration… and developers do mix these two components together at times as I am sure you are probably aware.
So let’s say we have an associative array $data that has a “text” property as one of its keys. We could print the value of each item in our set in a Bootstrap grid layout like so…
$count = 0;
foreach ($data as $item) {
if($count == 0) {
$markup .= '<div class="row">';
}
$markup .= '<div class="col-md-6">'. $item["text"] .'</div>';
if ($count++ %2 == 0) {
$markup .= '</div>'
$count = 0;
}
}
Which might give us something like what we see here.
This works but it seems a bit awkward and weird. Because we are using a 2 column grid we have to count every other item and close out the row before starting a new row. If we wanted a 3 column grid we’d have to count every 3 items and so on. This might work okay in some scenarios, but in others we may not have the luxury of being able to use the Bootstrap grid with ease and consistency. What if, say, these results that we currently have could also be appended to via AJAX calls? You see a lot of this sort of thing on sites like Pinterest or Instagram and their infinite scrolling capabilities. As you scroll to the bottom more content gets loaded dynamically from the server from client side calls made in JavaScript.
The point is if you use Bootstrap and want to keep the layout consistent you’re going to have to always be keeping track of how many items you have and where you are in the Bootstrap row closing and opening phase. It’ gets a bit messy and awkward to maintain as functionality gets a bit more dynamic and complex. There probably is, for lack of a better term, a “cleaner” implementation we can take a look at.
Read More »
CSS,
HTML5,
responsive web design,
web developmentIn this section we will look at another interesting aspect of creating a web application using Node.js, Express, and MongoDB: referencing other data in the database. MongoDB is part of the NoSQL class of databases (as opposed to the traditional relational databases that have been so prevalent for so long). NoSQL databases store records as documents as opposed to relational databases which store records as rows in tables. Documents in NoSQL databases are basically collections of key value pairs sort of like JSON objects. As the MongoDB documentation describes in the introduction…
A record in MongoDB is a document, which is a data structure composed of field and value pairs. MongoDB documents are similar to JSON objects. The values of fields may include other documents, arrays, and arrays of documents.
You can find many articles out on the web discussing the difference between NoSQL databases and relational databases. MongoDB is a solution to a common problem and like with many things it has its advantages and its drawbacks.
But even with their structure, NoSQL database documents still have need to store references to other objects within them (somewhat like foreign keys). We have been creating data models of books in previous examples in this tutorial that have a “title” field, an “author” field, and an “isPublished” field. We have been storing the author as a string value. But really in a real-world application we’d more likely want to store a reference to an author that exists in an authors collection elsewhere. That way we could store additional information about an author or show a collection of books written by the same author. When you start relating and connecting data in this manner your application becomes truly dynamic and useful
Setup
So let’s create an “AuthorModel” and all of the scaffolding to put an “authors” section in the database. Like we’ve done before, we’ll want to follow the same process: define our model schema for our “AuthorModel,” add routes, add controllers, and add views. We will move fairly quickly through this. A lot of what we are doing was covered earlier in this tutorial. If there are any parts that seem unclear, please go back and review the content presented earlier to get a refresher on how this application is being structured.
So let’s start by defining our author schema in our Models.js file. This one will be a bit simpler than our book model schema. All we need to add here is a name. What will be important later on is the author _id value that we can associate with a book as a reference field…
var Author = new mongoose.Schema({
name: String
});
var BookModel = mongoose.model('Book', Book);
var UserModel = mongoose.model('User', User);
var AuthorModel = mongoose.model('Author', Author);
module.exports = {
BookModel: BookModel,
AuthorModel: AuthorModel,
UserModel: UserModel
};
And let’s continue with adding our author routes to the router.js file making sure to add a refenrece to our soon-to-be-created AuthorsController…
var HomeController = require('./controllers/HomeController');
var BookController = require('./controllers/BookController');
var AuthorController = require('./controllers/AuthorController');
// Routes
module.exports = function(app){
// Main Routes
app.get('/', HomeController.Index);
app.get('/other', HomeController.Other);
// Book Routes
app.get('/books', BookController.Index);
app.get('/books/add', BookController.BookAdd);
app.post('/books/add', BookController.BookCreate);
app.get('/books/edit/:id', BookController.BookEdit);
app.post('/books/edit', BookController.BookUpdate);
app.get('/books/delete/:id', BookController.BookDelete);
// Author Routes
app.get('/authors', AuthorController.Index);
app.get('/authors/add', AuthorController.AuthorAdd);
app.post('/authors/add', AuthorController.AuthorCreate);
app.get('/authors/edit/:id', AuthorController.AuthorEdit);
app.post('/authors/edit', AuthorController.AuthorUpdate);
app.get('/authors/delete/:id', AuthorController.AuthorDelete);
};
Read More »
Express.js,
JavaScript,
Model View Controller (MVC),
MongoDB,
Node.js,
web developmentIn previous installments we looked at getting started with creating an Express.js MVC application, creating controllers and views. And then we looked at middleware and creating a config file to store application constants.
Now we will look at something that truly makes an Express.js application dynamic (and fun): data-access… which essentially boils down to the use of a database to store, retrieve, and manipulate information.
Like many things in technology, people will always argue about what is the “best” way to do something and what the best technologies to use for doing that something are. And the way in which an application should store data is not going to be excluded from this discussion (read: Internet flame-war). It is not really part of our purposes to argue what is “best” or “better” when it comes to data-access, but it is probably worth pointing out that a lot of the Express.js and Node.js communities seem to have embraced NoSQL databases such as MongoDB, and CouchDB. There is even a full “stack” you will hear mentioned known as the MEAN stack (MongoDB, Express, AngularJS, and Node.js) — just like you’d hear of a LAMP stack (Linux, Apache, MySQL, and PHP). The inclusion of MongoDB in this shows its prominence in developer preference in Express and Node applications.
So, it is probably worth knowing a bit about how to use a MongoDB database in a Node.js and Express.js application because you are more than likely to come across it at some point in your life as a developer. So, resultantly, we’ll utilize MongoDB in our application.
Installing MongoDB
Head on over to MongoDBs home page and download MongoDB for your OS. You’ll probably just want to pick the standard install and won’t need any fancy cloud services at this point. Be sure to read through the installation section in the docs section of the site. and do the subsequent tutorials to make sure you can test out that MongoDB was installed correctly. There is a “Getting Started” section that should walk you through this where you can try out creating, reading, inserting and deleting data a sample MongoDB database.
After you have installed MongoDB create a new folder in the root of your application can call it “db”. This is where we are going to store our database and we’re going to point MongoDB to put all the files for this database in here.
To start things up, next go to the directory where you installed Mongo and navigate into the bin directory and open a command window. So on Windows, for example, if you installed in the C:\mongodb directory, you would open a command window or shell in C:\mongodb\bin. You could also get there by opening a command window anywhere and typing
cd "C:\mongodb\bin"
Then you would type the following into the command window where we should specify the path to the “db” folder we just created. So wherever your application lives on your system you’ll want to specify that path by running the following command.
mongod --dbpath "C:\path\to\application\db"
or if you’re using BASH, something like this…
mongod --dbpath /c/path/to/application/db
If all goes well, you should see a message saying that MongoDB is waiting for connections. By default at the time of this writing, the version of MongoDB being used waits for connections on port 28017… so you should see that reflected somewhere in the messaging. Leave this running by leaving this window open (you can minimize if you like).
NOTE: When you first run this command, MongoDB will create all the files it needs in the “db” folder we created, so you should see a number of files pop up in there. Some are quite large.
Now that we have MongoDB installed and we can connect to it, lets write some Node.js code to do some data operations! Woo hoo! Like with so many things we have done before, we will utilise a module to act as a wrapper for our data access with MongoDB. Remember, you could always set things up and write your own code in Node.js for accessing data. Using modules is basically just a way to circumvent all of that grunt work and manual labor involved in those processes. If somebody else has already done the heavy lifting in making a module, might as well make use of it.
Installing Mongoose
I am going to use a popular module for accessing MongoDB on npm called Mongoose.js (which like pretty much all Node.js modules is avialble on npm). There are probably some other modules that you could use, we’re just going to go with this one to start. So as we have done before when we are adding a new module, we need to update our package.json with a new reference to Mongoose. We will also add another module called body-parser which is going to be useful for getting data out of forms so we can save it in our database.
{
"name": "MVC-Express-Application",
"description": "An Express.js application using the MVC design pattern...",
"version": "0.0.1",
"dependencies": {
"express": "4.4.4",
"body-parser": "1.4.3",
"express-handlebars": "1.1.0",
"morgan": "1.1.1",
"errorhandler": "1.1.1",
"mongoose": "3.8.8"
}
}
Then again, we should open a shell in our project root directory and run
$ npm install
which will pull down all the Mongoose and body-parser files.
Read More »
Express.js,
JavaScript,
Model View Controller (MVC),
MongoDB,
Node.js,
web developmentI was developing an HTML5 mobile app for an organization. The app was very simple and essentially consisted of a number of different chapters with a lot of text in each. So the homepage of the app was just a list of the chapters and each list item linked to a chapter page. All the text was in a single page (HTML document) and the app framework would just show/hide the relevant portions of it when needed. A lot of mobile HTML5 frameworks do this implementation and it essentially amounts to a simple single page application. None of the content for this app was stored on a server.
However, one of the features requested was search in that they wanted the ability to search for a term and link to the term from a search page. This is usually pretty easy if content is stored in a database because all the infrastructure to run queries against content in said database is there for you. However if all the text is in a single page application, how would you 1. find it and 2, link to it? What follows is essentially my approach in what amounts to essentially a local search functionality in a single page application.
For starters, say we had the following HTML document…
<!doctype html>
<html>
<head>
<title>App</title>
</head>
<body>
<div id="home" class="page">
<ul id="menu" class="page">
<li><a href="#search">Search</a></li>
<li><a href="#chapter1">Chapter 1</a></li>
<li><a href="#chapter2">Chapter 2</a></li>
<li><a href="#chapter3">Chapter 3</a></li>
</ul>
</div>
<div id="chapter1" class="page">
<p>The quick brown fox jumped over the lazy dog.</p>
<p>How now brown cow?</p>
<p>Something else</p>
</div>
<div id="chapter2" class="page">
<p>Chapter 2 text here...</p>
<p>More text here...</p>
</div>
<div id="chapter3" class="page">
<p>Chapter 3 text here...</p>
<p>More text here...</p>
</div>
<div id="search" class="page">
<input id="search-box" type="search" />
<ul id="search-results"></ul>
</div>
</body>
</html>
Each div with the class “page” would be loaded into the main view when a user clicked on a link to the id of the <div> as can be seen in the menu page. For brevity, I’ve kept the content of each <div> really small but imagine that there were a number of chapters and each paragraph in each chapter had large amounts of text.
What I ended up doing is I added a class called “indexed” (to say that the content of this element is going to be indexed in the search functionality) and some “data-reference” attributes to each paragraph of text to be able to tell where in the application I was. If we were going to have for text *with links*, we’d need to have a way to tell “where we are” so that when we load that page we could scroll to the div that had the text that was searched for.
<!doctype html>
<html>
<head>
<title>App</title>
</head>
<body>
<div id="home" class="page">
<ul id="menu" class="page">
<li><a href="#search">Search</a></li>
<li><a href="#chapter1">Chapter 1</a></li>
<li><a href="#chapter2">Chapter 2</a></li>
<li><a href="#chapter3">Chapter 3</a></li>
</ul>
</div>
<div id="chapter1" class="page">
<p class="indexed" data-reference="1-1">The quick brown fox jumped over the lazy dog.</p>
<p class="indexed" data-reference="1-2">How now brown cow?</p>
<p class="indexed" data-reference="1-3">Something else</p>
</div>
<div id="chapter2" class="page">
<p class="indexed" data-reference="2-1">Chapter 2 text here...</p>
<p class="indexed" data-reference="2-2">More text here...</p>
</div>
<div id="chapter3" class="page">
<p class="indexed" data-reference="3-1">Chapter 3 text here...</p>
<p class="indexed" data-reference="3-2">More text here...</p>
</div>
<div id="search" class="page">
<input id="search-box" type="search" />
<ul id="search-results"></ul>
</div>
</body>
</html>
So as the user types into the search box if we use some jQuery and some RegEx we can 1. search through every “indexed” element for the text that was searched for and 2. populate the search results <div> with links to the various elements. It would look a little bit like this…
jQuery(document).ready(function(){
function search(searchedText) {
if(searchedText.trim() === ""){
jQuery('#search-results').empty().text('No results...');
return;
}
var res = jQuery(".indexed:contains('"+searchedText+"')").each( function() {
var current = jQuery(this).closest('div[class="page"]');
var regex = new RegExp(".{0,20}" + searchedText + ".{0,20}", "i");
var str = jQuery(this).text().match(regex);
var ref = jQuery(this).closest('[data-reference]');
jQuery('#search-results').append('<li><a href="#'+ current.attr('id') +'?reference='+ ref.attr('data-reference') +'">... '+ str +' ...</a> - '+ current.find('h1').text() +'</li>');
return;
});
if(res.length === 0) {
jQuery('#search-results').empty().text('No results...');
}
}
var searchResults = jQuery('#search-results'), searchTimeout;
jQuery('#search-box').on('keyup', function(){
var el = jQuery(this);
searchResults.empty();
clearTimeout(searchTimeout);
searchTimeout = setTimeout(function() {
search(el.val());
}, 1000);
});
});
So basically what we are saying here is that while we type into the search box, we will wait until the user is finished typing and then we will check each “indexed” element for the text we are searching for. If we find it we will create a link to that text to the chapter and append a query string value to the “data-reference” value of the element that contains the text. We can then use the event that fires every time the page changes (as a lot of mobile frameworks have) to check for this reference parameter in the url. If it is there we can do something like the following to scroll to the paragraph that contains the text we were searching for. We call the following scrollTo function on each change/load of a page.
function getParameter(name){
var match = RegExp('[?&]' + name + '=([^&]*)').exec(window.location);
return match && decodeURIComponent(match[1].replace(/\+/g, ' '));
}
function scrollTo() {
if(getParameter('reference')) {
jQuery('html,body').animate({
scrollTop: jQuery('[data-reference="'+ getParameter('reference') +'"]').prev().offset().top -20
}, 100);
}
}
The way things are set up at the moment, the regular expression will search for the exact text entered into the search box. Thus, search is case-snesitive at the moment. No matter. If we wanted to incorporate case-insensitivity into things we could simply add the following method…
// make :contains case insenstive for search
jQuery.expr[":"].contains = jQuery.expr.createPseudo(function(arg) {
return function( elem ) {
return jQuery(elem).text().toUpperCase().indexOf(arg.toUpperCase()) >= 0;
};
});
By implementing these sorts of techniques and methods, you can incorporate local search and linking into a single page application with a relatively small amount of code. You could take this and expand upon it pretty easily. So even within the perceived limitations of a single page application, you can find ways to implement dynamic functionality that you would expect from any other application. Until next time, happy searching!
View Demo
HTML5,
JavaScript,
jQuery,
mobile,
RegEx,
searchBecause JavaScript is such a flexible and dynamic language it’s always interesting to take a look at different ways of accomplishing things. In our ongoing studies of some of the inner-workings of the language we looked at the apply and call methods. Today we are going to look at their cousin bind.
So what does bind do? Much like apply and call, bind is going to have a lot to do with context and what the “this” keyword points to and it can sometimes be a little bit confusing as to what it is really doing at first. Let’s take a look at the description of bind() from the Mozilla Developer Network…
The bind() method creates a new function that, when called, has its this keyword set to the provided value, with a given sequence of arguments preceding any provided when the new function is called.
Hopefully it will make a bit more sense after we get through “this” (*Groan*)
One of the more common uses of the bind method within JavaScript applications is to pass the parent scope downward as you go multiple levels deep within methods within in object literal. For example, let’s say we had the following very general “actionClass” object literal. A lot of JavaScript applications use this pattern as an implementation…
<div class="button">Click me!</div>
<script type="javascript">
var actionClass = {
init: function(){
this.setEvents();
},
setEvents: function(){
// we will set events here...
},
doSomething: function(){
console.log('We are doing something');
},
doSomethingElse: function() {
console.log('We are doing something else');
}
};
actionClass.init();
</script>
As we can see we are calling the actionClass.init() method which will set up some event handlers. So let’s add an event where when we click an element we call another one of the methods within our actionClass object.
<div class="button">Click me!</div>
<script type="javascript">
var actionClass = {
init: function(){
this.setEvents();
},
setEvents: function(){
jQuery('.button').on('click', function(){
this.doSomething();
});
},
doSomething: function(){
console.log('We are doing something');
},
doSomethingElse: function() {
console.log('We are doing something else');
}
};
actionClass.init();
</script>
This code does not work. When we try to click the div we get “Uncaught TypeError: this.doSomething is not a function” Why is that? Well it is because the callback function for the click event has its own scope. “this” is now pointing at the function it is being called from. One way that developers solve this is by setting a variable to the parent scope. The following code works…
<div class="button">Click me!</div>
<script type="javascript">
var actionClass = {
init: function(){
this.setEvents();
},
setEvents: function(){
var self = this;
jQuery('.button').on('click', function(){
self.doSomething();
});
},
doSomething: function(){
console.log('We are doing something');
},
doSomethingElse: function() {
console.log('We are doing something else');
}
};
actionClass.init();
</script>
This is certainly a viable option and works fine for our simple example. However, as we go deeper and get more complex into multiple levels of nested functions with events or getting data asynchronously via AJAX requests or any number of other possibilities the process of constantly assigning variables to the scope that you want can get kind of messy. So what other approach can we take? This is where bind comes into the picture. We could also do something like the following…
<div class="button">Click me!</div>
<script type="javascript">
var actionClass = {
init: function(){
this.setEvents();
},
setEvents: function(){
jQuery('.button').on('click', function(){
this.doSomething();
}.bind(this));
},
doSomething: function(){
console.log('We are doing something');
},
doSomethingElse: function() {
console.log('We are doing something else');
}
};
actionClass.init();
</script>
Simply by attaching .bind(this) after our function closing bracket } we are changing the scope of the function. We longer need to say var self = this; This gives us a nice clean implementation for how we organize our code.
Read More »
JavaScript,
web development
