requirejs.config({
    baseUrl: ‘js‘
});
// 依赖lib.js，实际加载的路径是 js/common/lib.js，而lib模块又依赖于util模块(‘./util‘)，解析后的实际路径为 js/common/util.js
require([‘common/lib‘], function(Lib){
    Lib.say(‘hello‘);
});

// 依赖util模块
define([‘./util‘], function(Util){
    return {
        say: function(msg){
            Util.say(msg);
        }
    };
});

requirejs.config({
    baseUrl: ‘js‘,
    paths: {
        lib: ‘common/lib‘
    }
});

// 实际加载的路径是 js/common/lib.js
require([‘lib‘], function(Lib){
    Lib.say(‘hello‘);
});

// util模块解析后的路径为 js/util.js
define([‘./util‘], function(Lib){
    return {
        say: function(msg){
            Lib.say(msg);
        }
    };
});

require([‘common/lib‘], function(Lib){
    Lib.say(‘hello‘);
});

/**
         * Given a relative module name, like ./something, normalize it to
         * a real name that can be mapped to a path.
         * @param {String} name the relative name
         * @param {String} baseName a real name that the name arg is relative
         * to.
         * @param {Boolean} applyMap apply the map config to the value. Should
         * only be done if this normalization is for a dependency ID.
         * @returns {String} normalized name
         */
function normalize(name, baseName, applyMap) {
  var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex, foundMap, foundI, foundStarMap, starI, normalizedBaseParts, baseParts = (baseName && baseName.split(‘/‘)),
  map = config.map,
  starMap = map && map[‘*‘];

  //Adjust any relative paths.
  if (name) {
    name = name.split(‘/‘);
    lastIndex = name.length - 1;

    // If wanting node ID compatibility, strip .js from end
    // of IDs. Have to do this here, and not in nameToUrl
    // because node allows either .js or non .js to map
    // to same file.
    if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
      name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, ‘‘);
    }

    // Starts with a ‘.‘ so need the baseName
    if (name[0].charAt(0) === ‘.‘ && baseParts) {
      //Convert baseName to array, and lop off the last part,
      //so that . matches that ‘directory‘ and not name of the baseName‘s
      //module. For instance, baseName of ‘one/two/three‘, maps to
      //‘one/two/three.js‘, but we want the directory, ‘one/two‘ for
      //this normalization.
      normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
      name = normalizedBaseParts.concat(name);
    }

    trimDots(name);
    name = name.join(‘/‘);
  }

  //Apply map config if available.
  if (applyMap && map && (baseParts || starMap)) {
    nameParts = name.split(‘/‘);

    outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
      nameSegment = nameParts.slice(0, i).join(‘/‘);

      if (baseParts) {
        //Find the longest baseName segment match in the config.
        //So, do joins on the biggest to smallest lengths of baseParts.
        for (j = baseParts.length; j > 0; j -= 1) {
          mapValue = getOwn(map, baseParts.slice(0, j).join(‘/‘));

          //baseName segment has config, find if it has one for
          //this name.
          if (mapValue) {
            mapValue = getOwn(mapValue, nameSegment);
            if (mapValue) {
              //Match, update name to the new value.
              foundMap = mapValue;
              foundI = i;
              break outerLoop;

            }
          }
        }
      }

      //Check for a star map match, but just hold on to it,
      //if there is a shorter segment match later in a matching
      //config, then favor over this star map.
      if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
        foundStarMap = getOwn(starMap, nameSegment);
        starI = i;
      }
    }

    if (!foundMap && foundStarMap) {
      foundMap = foundStarMap;
      foundI = starI;
    }

    if (foundMap) {
      nameParts.splice(0, foundI, foundMap);
      name = nameParts.join(‘/‘);
    }
  }

  // If the name points to a package‘s name, use
  // the package main instead.
  pkgMain = getOwn(config.pkgs, name);

  return pkgMain ? pkgMain: name;
}

main.js=>require([‘common/lib‘], function (Lib)=>common/util
main.js=>require([‘lib‘], function (Lib)=>util
main.js=>require([‘a/b/c/lib‘], function (Lib)=>a/b/c/util