ITEC 325 2013spring ibarland

home—lects—exams—hws
D2L—breeze (snow day)

lect09a-includes-nesting-requires
nesting includes
php, javascript, and in general

Suppose main.php includes header.php which needs main-validate.js which uses utils.js.
But, main.php also requires utils.js in its own right. (Moreover, other other .php files will include javascript which includes utils.js.) How do we handle multiple includes?

1. Nest includes: A's code would just require B; then in turn B's code would require C.
   However, if A itself needed some of the functions inside B, it would re-include that file.

   Advantage: simple to maintain — if you want to use a function defined in my-utils, you only need to require that one file, and you don't have to worry about what pre-requisites my-utils has.

   Disadvantage: Underlying files may get included many times (perhaps you require files D, E, and F, and each of those requires my-utils.

   Here is an example where require-master.php requires both require-util.php and require-helper.php ; in turn, require-helper.php also requires require-util.php.

   A more difficult disadvantage: You can't always use relative paths: if require-master.php does a require('someOtherDir/my-utils.php'), and then require-helper.php happens to require('../../my-utils.php'), note that second relative path is relative to require-master.php, not relative to require-helper.php! [Solution: use require(dirname(__FILE__)."/".relative/Path], as mentioned below

2. Alternately, Don't nest any includes; if file A requires B which requires C, then A's code would require both C and B (in that order).

   Advantage: No file ever gets included more than once.
   Disadvantage: The programmer needs to be aware of (or frequently re-read documentation of) which other files include'd file needs

Language-specific issues

• Java: If several files use (say) java.sql.Date, it is not a problem: the language automatically uses a class loader to make sure that the necessary files (and any static blocks of code they contain) are included/executed exactly once, as needed.
• C/C++ The problem of multiple-includes was solved/hacked by having each file declare a boolean variable; if the variable was already defined it (hopefully) meant that the file had already been included by somebody else, and a pre-processor conditional would skip the file:

  // This is the file my-utils.h: #ifndef MY_UTILS_H // if the variable is *not* defined, then proceed: #define MY_UTILS_H // Define the variable, so next time the `ifndef` will be false. ⋮ // actual code #endif

• php

  In addition to include, there is a include_once. (Similarly, require and require_once). Always use the “_once” versions, for requiring function-definitions¹! (Some argue it's less efficient, but really the performance hit is negligible, and the savings in programmer-hours will occasionally be huge.)

  Note that the named constant __FILE__ is specific to the file being included! This is a particular good choice of behavior, for nesting includes: Rather than just use a relative path, concatentate the relative path to the end of __FILE__:

  require( dirname(__FILE__) . "/adjacent-util-file.php" );

• javascript

  First, just be sure to remember that the html tag “script” can either include the javascript as its body, or can have an attribute “src”:

  <script type="text/javascript">alert("inline javascript");</script> <script type="text/javascript" src="someOtherFile.js"></script> <-- NOTE: You can't use the ".../>" empty-tag abbreviation with tags like script, p, ... -->

  This works if you're in the middle of html.

  But what if you're inside javascript (say, inside a .js file) and you want to include a different file? Javascript does not have a native include function, but it can be created as a function which causes the browser to insert another script tag:

  function include(filename) { var scriptTag = document.createElement('script'); scriptTag.src = filename; scriptTag.type = 'text/javascript'; var head = document.getElementsByTagName('head')[0]; head.appendChild(scriptTag) }2

  or alternately (and less preferably):

  function include(filename) { document.write('<script type="text/javascript" src="' + jsFile + '"></scr' + 'ipt>'); }3

  What if you include the same javascript file several times? Note that this could incur a network-fetch penalty. Ideally the browser would just use a cached copy, but unless the server provides an expiration date in the http response header (which it may not be configured for), the browser technically should re-fetch.

  And even if a local cache is used, we still run into problems if there are global variables that get re-initialized. We can fix this ourselves, either manually using the ol' C pre-processor trick of defining a variable for each file, or write our own includeOnce which keeps an associative array of all filenames previously include'd. (Just be sure that the file where you write includeOnce is sure to not ever re-load itself, which would wipe out its own array of previous includes!)

home—lects—exams—hws
D2L—breeze (snow day)

©2012, Ian Barland, Radford University Last modified 2013.Mar.27 (Wed)

Please mail any suggestions (incl. typos, broken links) to ibarlandradford.edu