Copying the file to app/code/local/Mage/Core/functions.php should not be used because of the following reasons:

1. The entire file has to be copied over making it harder for us to identify what changes have been made.

2. Future upgrades could introduce new features that would not be available unless it is remembered to copy across the new version of that file and implement the changes again.

3. Future upgrades could address bugs with core that we would miss unless it is remembered to copy across the new version of that file and implement the changes again.

4. In respect to points 2 & 3 each upgrade could change the way things work that means revisiting what changes we need to make. In some cases this will be true for overriden methods as well but at least we can easily identify where those changes effect us.

5. What do you do if another person wants to use the same technique? Being able to identify what is core code and what is ours becomes more and more complex.

6. Keeping our code together as a “module” becomes more difficult as by copying in the core file means that we have effectively locked it into being “guaranteed” to run on the version of the software that we have copied the original code from. It also means reusing this work is a lot more difficult to do.

7. Identifying why the code was changed it much harder as it is outside our namespacing, ie all development related to “Example_Module” is in the namespace:

/app/code/core/local/Example/Module

whereas code copied to app/code/core/local/Mage only indicates that we have made a change to support an unknown feature etc.

Also Magento occasionally release patches which fixes bugs – these will only patch files inside core leaving your copied file without the patch.

What I would suggest instead is that you write your own function to do what you want and override the function to call your new function instead.

As mentioned by @tweakmag the disadvantages of creating a folder structure and copying the entire Model or controller for a single function override, most important being,

"Future upgrades could introduce new features that would not be available unless it is remembered to copy across the new version of that file and implement the changes again."

Thus a solution can be, to extend the core class (Model or controller) and just write the method you want to override, instead of copying all the methods.

For example, if you want to say, override a method getProductCollection in Mage_Catalog_Model_Category, here will be the steps:

1. Create a Custom Namespace/Module folder with etc folder in it
2. Register the module in app/etc folder by creating Namespace_Module.xml

3. setup the config.xml in Namespace/Module/etc/ :

   <?xml version="1.0"?>
     <config>
        <modules>
          <Namespace_Module>
            <version>1.0</version>
          </Namespace_Module>
         </modules>
         <global>
          <models>
           <catalog>
            <rewrite>
              <category>Namespace_Module_Model_Category</category>
            </rewrite>
           </catalog>
         </models>
        </global>
     </config>
   

4. create Model folder in Namespace_Module and a Php File Category.php

5. Now the main difference here is we extend the Magento's core class instead of writing all the methods

    <?php
     /**
      * Catalog category model
     */
      class Namespace_Module_Model_Category extends Mage_Catalog_Model_Category
       {
       public function getProductCollection()
        {
         // Include your custom code here!
         $collection = Mage::getResourceModel('catalog/product_collection')
         ->setStoreId($this->getStoreId())
         ->addCategoryFilter($this);
         return $collection;
       }
     }

The getProductCollection method is overridden so it'll be called instead of the method defined in the core model class.

Also an important point is:

When you override any methods in models, you should make sure that the data type of the return value of that method matches with the data type of the base class method. Since model methods are called from several core modules, we should make sure that it doesn't break other features!

This link gives a step by step approach to it

1. UOPZ

There's a way to do it without having to copy and maintain functions.php file from core, but it involves extension uopz (pecl install uopz), then you can rename magento's function (from foo to foo_uopzOLD for example) and define your own (https://secure.php.net/uopz)

It works and is very useful for magento - usually you'll bump into something you can not change. Uopz is very helpful in such cases.

pros: works ;), you don't have to redo it everytime you update Magento (if you do it right, because inside you still can call foo_uopzOLD so you can assure some backward compatibility... in some cases).

cons: it's little bit implicit

2. Composer post-install-cmd

If you don't like the above, but you use composer you can patch any file you want:

"scripts": {
    "post-install-cmd": "patch -p0 < change-core-functions.patch"
 }

pros: explicit (when patch fail - composer install fails), and since it's explicit - you can revisit and fix the patch every time you upgrade magento

cons: you have modified core file, so you probably would want to add it to .gitignore

3. Ugly solution (uglier than those above)

If none of the above is possible for you (really, give it a try with composer - there's no excuse for not using it). But when you really can not the only way I can think of - create app/local/Mage/Core/functions.php - define this one function you need - load original /app/core/Mage/Core/functions.php - surround every function foo() {...} with

if(!function_exists("foo"){ 
  function foo() {...}
}

• hold on to your chair and
• eval this SOB ;)