Changes between Initial Version and Version 1 of WF/Metodos

Timestamp:

07/24/07 15:01:38 (17 years ago)

Author:

trac

Comment:

--

WF/Metodos

@@ +1 @@
+= append =
+ ----
+
+void append (mixed var)
+
+
+
+void append (string varname, mixed var)
+
+
+
+void append (string varname, mixed var, boolean merge)
+
+
+
+Isso é usado para adicionar um elemento para um array fixado. Se você adicionar uma string como valor, isso irá converter-se para um valor de array e então adicioná-lo. Você pode explicitamente passar pares nomes/valores, ou arrays associativos contendo o par nome/valor. Se você passar o terceiro parâmetro opcional para true, o valor unir-se ao array atual ao invés de ser adicionado.
+
+
+
+    Notas Técnicas: O parâmetro de união respeita a chave do array, então se você mesclar dois índices númericos de um array, eles devem sobrescrever-se um ao outro ou em resultados não sequências de chave. Isso é diferente da função de PHP array_merge() que apaga as chaves e as renumera. 
+
+
+
+Exemplo 13-1. append
+
+
+
+// passing name/value pairs
+
+$smarty->append("Name","Fred");
+
+$smarty->append("Address",$address);
+
+
+
+// passing an associative array
+
+$smarty->append(array("city" => "Lincoln","state" => "Nebraska"));
+
+
+
+= append_by_ref =
+
+----
+
+void append_by_ref (string varname, mixed var)
+
+
+
+void append_by_ref (string varname, mixed var, boolean merge)
+
+
+
+Isso é usado para adicionar vlaores para o template por referência. Se você adicionar uma variável por referência e então alterar este valor o valor adicionado enxergará a alteração também. Para objetos, append_by_ref() também evita uma cópia em memória do objeto adicionado. Veja o manual do PHP em referenciando variáveis para uma melhor explanação sobre o assunto. Se você passar o terceiro parâmetro opcional para true, o valor irá ser mesclado com o array atual ao invés de adicioná-lo.
+
+
+
+    Notas Técnicas: O parâmetro de união respeita a chave do array, então se você mesclar dois índices númericos de arrays, eles devem sobrescrever-se um ao outro ou em resultados não sequências de chave. Isso é diferente da função de PHP array_merge() que apaga as chaves numéricas e as renumera. 
+
+
+
+Exemplo 13-2. append_by_ref
+
+
+
+// appending name/value pairs
+
+$smarty->append_by_ref("Name",$myname);
+
+$smarty->append_by_ref("Address",$address);
+
+
+
+= assign =
+
+----
+
+void assign (mixed var)
+
+
+
+void assign (string varname, mixed var)
+
+
+
+Isso é usado para fixar valores para o template. Você pode explicitamente passar pares de nomes/valores, ou um array associativo contendo o par de nome/valor.
+
+
+
+Exemplo 13-3. assign
+
+
+
+// passing name/value pairs
+
+$smarty->assign("Name","Fred");
+
+$smarty->assign("Address",$address);
+
+
+
+// passing an associative array
+
+$smarty->assign(array("city" => "Lincoln","state" => "Nebraska"));
+
+
+
+= assign_by_ref =
+
+----
+
+void assign_by_ref (string varname, mixed var)
+
+
+
+Isso é usado para fixar valores para o template por referência ao invés de fazer uma cópia. Veja o manual do PHP na parte sobre referência de variáveis para uma explanação mais detalhada.
+
+
+
+    Notas Técnicas: Isso é usado para fixar valores para o template por referência. Se você fixar uma variável por referência e então alterar o valor dela, o valor fixado enxergará o valor alterado também. Para objetos, assign_by_ref() também restringe uma cópia de objetos fixados em memória. Veja o manual do php em refereciando variáveis para uma melhor explanação. 
+
+
+
+Exemplo 13-4. assign_by_ref
+
+
+
+// passing name/value pairs
+
+$smarty->assign_by_ref("Name",$myname);
+
+$smarty->assign_by_ref("Address",$address);
+
+
+
+= clear_all_assign =
+
+----
+
+void clear_all_assign ()
+
+
+
+Isso limpa o valor de todas as variáveis fixadas.
+
+
+
+Exemplo 13-5. clear_all_assign
+
+
+
+// clear all assigned variables
+
+$smarty->clear_all_assign();
+
+
+
+= clear_all_cache =
+
+----
+
+void clear_all_cache (int expire time)
+
+
+
+Isso limpa completamente o cache de template. Como um parâmetro opcional, você pode fornecer um ano mínimo em segundos que o arquivo de cache deve ter antes deles serem apagados.
+
+
+
+Exemplo 13-6. clear_all_cache
+
+
+
+// clear the entire cache
+
+$smarty->clear_all_cache();
+
+
+
+= clear_assign =
+
+----
+
+void clear_assign (string var)
+
+
+
+Isso limpa o valor de uma variável fixada. Isso pode ser um valor simples, ou um array de valores.
+
+
+
+Exemplo 13-7. clear_assign
+
+
+
+// clear a single variable
+
+$smarty->clear_assign("Name");
+
+
+
+// clear multiple variables
+
+$smarty->clear_assign(array("Name","Address","Zip"));
+
+
+
+= clear_cache =
+
+----
+
+void clear_cache ( [string template [, string cache id [, string compile id [, int expire time]]]])
+
+
+
+Isso limpa o cache de um template específico. Se você tem múltiplos caches para este arquivo, você limpa o cache específico fornecendo o cache id como o segundo parâmetro. Você pode também passar um compile id como um terceiro parâmetro. Você pode "agrupar" templates juntos e então eles podem ser removidos como um grupo. Veja o caching section para maiores informações. Como um quarto parâmetro opcional, você pode fornecer um ano mínimo em segundos que o arquivo de cache deve ter antes dele ser apagado.
+
+
+
+Exemplo 13-8. clear_cache
+
+
+
+// clear the cache for a template
+
+$smarty->clear_cache("index.tpl");
+
+
+
+// clear the cache for a particular cache id in an multiple-cache template
+
+$smarty->clear_cache("index.tpl","CACHEID");
+
+
+
+= clear_compiled_tpl =
+
+----
+
+void clear_compiled_tpl (string tpl_file)
+
+
+
+Isso limpa a versão compilada do recurso de template especificado, ou todos os arquivos de templates compilados se nenhum for especificado. Essa função é para uso avançado somente, não normalmente necessária.
+
+
+
+Exemplo 13-9. clear_compiled_tpl
+
+
+
+// clear a specific template resource
+
+$smarty->clear_compiled_tpl("index.tpl");
+
+
+
+// clear entire compile directory
+
+$smarty->clear_compiled_tpl();
+
+
+
+= clear_config =
+
+----
+
+void clear_config ( [string var])
+
+
+
+Isso limpa todas as variáveis de configuração fixadas. Se um nome de variável é fornecido, somente esta variável é apagada.
+
+
+
+Exemplo 13-10. clear_config
+
+
+
+// clear all assigned config variables.
+
+$smarty->clear_config();
+
+
+
+// clear one variable
+
+$smarty->clear_config('foobar');
+
+
+
+= config_load =
+
+----
+
+void config_load ( string file [, string section])
+
+
+
+Isso carrega o arquivo de configuração de dados e fixa-o para o template. Isso funciona idêntico a função config_load.
+
+
+
+    Notas Técnicas: À partir da Smarty 2.4.0, variáveis de template fixadas são mantidas através de fetch() e display(). Variáveis de configuração carregadas de config_load() são sempre de escopo global. Arquivos de configuração também são compilados para execução rápida, e repeita o force_compile e compile_check parâmetros de configuração. 
+
+
+
+Exemplo 13-11. config_load
+
+
+
+// load config variables and assign them
+
+$smarty->config_load('my.conf');
+
+
+
+// load a section
+
+$smarty->config_load('my.conf','foobar');
+
+
+
+= display =
+
+----
+
+void display ( string template [, string cache_id [, string compile_id]])
+
+
+
+Isso mostra o template. Fornecendo um válido template resource tipo e path. Como um segundo parâmetro opcional, você pode passar um cache id. Veja o caching section para maiores informações.
+
+
+
+Como um terceiro parâmetro opcional, você pode passar um compile id. Isso está no evento que você quer compilar diferentes versões do mesmo template, como ter templates compilados separadamente para diferentes linguagens. Outro uso para compile_id é quando você usa mais do que um $template_dir mas somente um $compile_dir. Seta um compile_id em separado para cada $template_dir, de outra maneira templates com mesmo nome irão sobrescrever-se um ao outro. Você pode também setar a variável $compile_id ao invés de passar isso para cada chamada de display().
+
+
+
+Exemplo 13-12. display
+
+
+
+include("Smarty.class.php");
+
+$smarty = new Smarty;
+
+$smarty->caching = true;
+
+
+
+// only do db calls if cache doesn't exist
+
+if(!$smarty->is_cached("index.tpl"))
+
+{
+
+
+
+    // dummy up some data
+
+    $address = "245 N 50th";
+
+    $db_data = array(
+
+            "City" => "Lincoln",
+
+            "State" => "Nebraska",
+
+            "Zip" = > "68502"
+
+            );
+
+
+
+    $smarty->assign("Name","Fred");
+
+    $smarty->assign("Address",$address);
+
+    $smarty->assign($db_data);
+
+
+
+}
+
+
+
+// display the output
+
+$smarty->display("index.tpl");
+
+
+
+Use a sintaxe para template resources para mostrar arquivos fora do $template_dir directory.
+
+
+
+Exemplo 13-13. Exemplos de recursos da função display
+
+
+
+// absolute filepath
+
+$smarty->display("/usr/local/include/templates/header.tpl");
+
+
+
+// absolute filepath (same thing)
+
+$smarty->display("file:/usr/local/include/templates/header.tpl");
+
+
+
+// windows absolute filepath (MUST use "file:" prefix)
+
+$smarty->display("file:C:/www/pub/templates/header.tpl");
+
+
+
+// include from template resource named "db"
+
+$smarty->display("db:header.tpl");
+
+
+
+= fetch =
+
+----
+
+string fetch ( string template [, string cache_id [, string compile_id]])
+
+
+
+Isso retorna a saída do template ao invés de mostrá-lo. Fornecendo um tipo ou path válido template resource. Como um segundo parâmetro opcional, você pode passar o cache id. Veja o caching section para maiores informações.
+
+
+
+Como um terceiro parâmetro opcional, você pode passar um compile id. Isso está no evento que você quer compilar diferentes versões do mesmo template, como ter templates compilados separadamente para diferentes linguagens. Outro uso para compile_id é quando você usa mais do que um $template_dir mas somente um $compile_dir. Seta um compile_id em separado para cada $template_dir, de outra maneira templates com mesmo nome irão sobrescrever-se uns aos outros. Você pode também setar a variável $compile_id ao invés de passá-la para cada chamada de fetch().
+
+
+
+Exemplo 13-14. fetch
+
+
+
+include("Smarty.class.php");
+
+$smarty = new Smarty;
+
+
+
+$smarty->caching = true;
+
+
+
+// only do db calls if cache doesn't exist
+
+if(!$smarty->is_cached("index.tpl"))
+
+{
+
+
+
+    // dummy up some data
+
+    $address = "245 N 50th";
+
+    $db_data = array(
+
+            "City" => "Lincoln",
+
+            "State" => "Nebraska",
+
+            "Zip" = > "68502"
+
+            );
+
+
+
+    $smarty->assign("Name","Fred");
+
+    $smarty->assign("Address",$address);
+
+    $smarty->assign($db_data);
+
+
+
+}
+
+
+
+// capture the output
+
+$output = $smarty->fetch("index.tpl");
+
+
+
+// do something with $output here
+
+
+
+echo $output;
+
+
+
+= get_config_vars =
+
+----
+
+array get_config_vars ( [string varname])
+
+
+
+Isso retorna o valor da variável de configuração dada. Se nenhum parâmetro é dado, um array de todas as variáveis dos arquivos de configurações é retornado.
+
+
+
+Exemplo 13-15. get_config_vars
+
+
+
+// get loaded config template var 'foo'
+
+$foo = $smarty->get_config_vars('foo');
+
+
+
+// get all loaded config template vars
+
+$config_vars = $smarty->get_config_vars();
+
+
+
+// take a look at them
+
+print_r($config_vars);
+
+
+
+= get_registered_object =
+
+----
+
+array get_registered_object (string object_name)
+
+
+
+Isso retorna uma referência para um objeto registrado. Isso é útil para dentro de uma função customizada quando você precisa acessar diretamente um objeto registrado.
+
+
+
+Exemplo 13-16. get_registered_object
+
+
+
+function smarty_block_foo($params, &$smarty) {
+
+        if (isset[$params['object']]) {
+
+                // get reference to registered object
+
+                $obj_ref =& $smarty->&get_registered_object($params['object']);
+
+                // use $obj_ref is now a reference to the object
+
+        }
+
+}
+
+
+
+= get_template_vars =
+
+----
+
+array get_template_vars ( [string varname])
+
+
+
+Isso retorna o valor de uma variável fixada. Se nenhum parâmetro é dado, um array de todas as variávels fixadas é retornado.
+
+
+
+Exemplo 13-17. get_template_vars
+
+
+
+// get assigned template var 'foo'
+
+$foo = $smarty->get_template_vars('foo');
+
+
+
+// get all assigned template vars
+
+$tpl_vars = $smarty->get_template_vars();
+
+
+
+// take a look at them
+
+print_r($tpl_vars);
+
+
+
+= is_cached =
+
+----
+
+void is_cached (string template, [string cache_id])
+
+
+
+Isso retorna true se há um cache válido para esse template. Isso somente funciona se caching está setado para true.
+
+
+
+Exemplo 13-18. is_cached
+
+
+
+$smarty->caching = true;
+
+
+
+if(!$smarty->is_cached("index.tpl")) {
+
+    // do database calls, assign vars here
+
+}
+
+
+
+$smarty->display("index.tpl");
+
+
+
+Você pode também passar um cache id como um segundo parâmetro opcional no caso você quer múltiplos caches para o template dado.
+
+
+
+Exemplo 13-19. is_cached with multiple-cache template
+
+
+
+$smarty->caching = true;
+
+
+
+if(!$smarty->is_cached("index.tpl","FrontPage")) {
+
+    // do database calls, assign vars here
+
+}
+
+
+
+$smarty->display("index.tpl","FrontPage");
+
+
+
+= load_filter =
+
+----
+
+void load_filter (string type, string name)
+
+
+
+Essa função pode ser usada para carregar um filtro de plugin. O primeiro argumento especifica o tipo do filtro para carregar e pode ser um dos seguintes: 'pre', 'post', ou 'output'. O segundo argumento especifica o nome do filtro de plugin, por exemplo, 'trim'.
+
+
+
+Exemplo 13-20. Carregando filtros de plugins
+
+
+
+$smarty->load_filter('pre', 'trim'); // load prefilter named 'trim'
+
+$smarty->load_filter('pre', 'datefooter'); // load another prefilter named 'datefooter'
+
+$smarty->load_filter('output', 'compress'); // load output filter named 'compress'
+
+
+
+= register_block =
+
+----
+
+void register_block (string name, mixed impl, bool cacheable, array or null cache_attrs)
+
+
+
+Use isso para registrar dinamicamente blocos de funções de plugins. Passe no bloco de nomes de função, seguido por uma chamada de função PHP que implemente isso.
+
+
+
+A chamada de uma função-php impl pode ser (a) uma string contendo o nome da função ou (b) um array no formato array(&$object, $method) com &$object sendo uma referência para um objeto e $method sendo uma string contendo o nome do método ou (c) um array no formato array(&$class, $method) com $class sendo um nome de classe e $method sendo um método desta classe.
+
+
+
+$cacheable e $cache_attrs podem ser omitidos na maior parte dos casos. Veja Controlando modos de Saída de Cache dos Plugins para obter informações apropriadas.
+
+
+
+Exemplo 13-21. register_block
+
+
+
+/* PHP */
+
+$smarty->register_block("translate", "do_translation");
+
+
+
+function do_translation ($params, $content, &$smarty, &$repeat) {
+
+    if (isset($content)) {
+
+        $lang = $params['lang'];
+
+        // do some translation with $content
+
+        return $translation;
+
+    }
+
+}
+
+
+
+{* template *}
+
+{translate lang="br"}
+
+   Hello, world!
+
+{/translate}
+
+
+
+= register_compiler_function =
+
+----
+
+void register_compiler_function (string name, mixed impl, bool cacheable)
+
+
+
+Use isso para registrar dinamicamente uma função de plugin compilador. Passe no nome da função compilador, seguido pela função PHP que implemente isso.
+
+
+
+A chamada para função-php impl pode ser uma string contendo o nome da função ou (b) um array no formato array(&$object, $method) com &$object sendo uma referência para um objeto e $method sendo uma string contendo o nome do método ou (c) um array no formato array(&$class, $method) com $class sendo um nome de classe e $method sendo o método desta classe.
+
+
+
+$cacheable pode ser omitido na maioria dos casos. Veja Controlando modos de Saída de Cache dos Plugins para obter informações apropriadas. 
+
+
+
+= register_function =
+
+----
+
+void register_function (string name, mixed impl, bool cacheable, array or null cache_attrs)
+
+
+
+Use isso para registrar funções de plugins dinamicamente para o template. Passe no template o nome da função, seguido pelo nome da função PHP que implemente isso.
+
+
+
+A chamada para função-php impl pode ser (a) uma string contendo o nome da função ou (b) um array no formato array(&$object, $method) com &$object sendo uma referência para um objeto e $method sendo uma string contendo o nome do método ou (c) um array no formato array(&$class, $method) com $class sendo um nome de classe e $method sendo um método desta classe.
+
+
+
+$cacheable e $cache_attrs podem ser omitidos na maioria dos casos. Veja Controlando modos de Saída Cache dos Plugins para obter informações apropriadas.
+
+
+
+Exemplo 13-22. register_function
+
+
+
+$smarty->register_function("date_now", "print_current_date");
+
+
+
+function print_current_date ($params) {
+
+    extract($params);
+
+    if(empty($format))
+
+        $format="%b %e, %Y";
+
+    return strftime($format,time());
+
+}
+
+
+
+// agora você pode usar isso no Smarty para mostrar a data atual: {date_now}
+
+// ou, {date_now format="%Y/%m/%d"} para formatar isso.
+
+
+
+= register_modifier =
+
+----
+
+void register_modifier (string name, mixed impl)
+
+
+
+Use isso para modificar dinamicamente plugins registrados. Passe no template o nome do modificador, seguido da função PHP que implemente isso.
+
+
+
+A chamada da função-php impl pode ser (a) uma strin contendo o nome da função ou (b) um array no formato array(&$object, $method) com &$object sendo uma referência para um objeto e $method sendo uma string contendo o nome do método ou (c) um array no formato array(&$class, $method) com $class sendo um nome de classe e $method sendo um método desta classe.
+
+
+
+Exemplo 13-23. register_modifier
+
+
+
+// let's map PHP's stripslashes function to a Smarty modifier.
+
+
+
+$smarty->register_modifier("sslash","stripslashes");
+
+
+
+// now you can use {$var|sslash} to strip slashes from variables
+
+
+
+= register_object =
+
+----
+
+void register_object (string object_name, object $object, array allowed methods/properties, boolean format, array block methods)
+
+
+
+Isso é para registrar um objeto para uso no template. Veja a seção de objetos do manual para examplos. 
+
+
+
+= register_outputfilter =
+
+----
+
+void register_outputfilter (mixed function)
+
+
+
+Use isso para registrar dinamicamente filtros de saída para operações na saída do template antes de mostrá-lo. Veja Filtros de Saída de Templates para maiores informações de como configurar uma função de filtro de saída.
+
+
+
+A chamada da função-php function pode ser (a) uma string contendo um nome de função ou (b) um array no formato array(&$object, $method) com &$object sendo uma referência para um objeto e $method sendo uma string contendo o nome do método ou (c) um array no formato array(&$class, $method) com $class sendo um nome de classe e $method sendo um método desta classe. 
+
+
+
+= register_postfilter =
+
+----
+
+void register_postfilter (mixed function)
+
+
+
+Use isso para registrar dinamicamente pósfiltros para rodar templates após eles terem sido compilados. Veja pósfiltros de template para maiores informações de como configurar funções de pósfiltragem.
+
+
+
+A chamada da função-php function pode ser (a) uma string contendo um nome de função ou (b) um array no formato array(&$object, $method) com &$object sendo uma referência para um objeto e $method sendo uma string contendo o nome do método ou (c) um array no formato array(&$class, $method) com $class sendo um nome de classe e $method sendo um método desta classe. 
+
+
+
+= register_prefilter =
+
+----
+
+void register_prefilter (mixed function)
+
+
+
+Use isso para registrar préfiltros dinamicamente para rodar templates antes deles serem compilados. Veja template prefilters para maiores informações de como configurar uma função de préfiltragem.
+
+
+
+A chamada da função-php function pode ser (a) uma string contendo um nome de função ou (b) um array no formato array(&$object, $method) com &$object sendo uma referência para um objeto e $method sendo uma string contendo o nome do método ou (c) um array no formato array(&$class, $method) com $class sendo um nome de classe e $method sendo um método desta classe. 
+
+
+
+= register_resource =
+
+----
+
+void register_resource (string name, array resource_funcs)
+
+
+
+Use isso para registrar dinamicamente um recurso de plugin com a Smarty. Passe no nome o recurso e o array de funções PHP que implementam isso. Veja template resources para maiores informações de como configurar uma função para retornar templates.
+
+
+
+    Notas Técnicas: Um nome de recurso deve ter ao menos dois caracteres de comprimento. Um caracter do nome de recurso irá ser ignorado e usado como parte do path do arquivo como, $smarty->display('c:/path/to/index.tpl'); 
+
+
+
+A função-php-array resource_funcs deve ter 4 ou 5 elementos. Com 4 elementos os elementos são as functions-callbacks para as respectivas funções "source", "timestamp", "secure" e "trusted" de recurso. Com 5 elementos o primeiro elemento tem que ser um objeto por referência ou um nome de classe do objeto ou uma classe implementando o recurso e os 4 elementos seguintes tem que ter os nomes de métodos implementando "source", "timestamp", "secure" e "trusted".
+
+
+
+Exemplo 13-24. register_resource
+
+
+
+$smarty->register_resource("db", array("db_get_template",
+
+                                       "db_get_timestamp",
+
+                                       "db_get_secure",
+
+                                       "db_get_trusted"));
+
+
+
+= trigger_error =
+
+----
+
+void trigger_error (string error_msg, [int level])
+
+
+
+Essa função pode ser usada para saída de uma mensagem de erro usando Smarty. O parâmetro level pode ser um dos valores usados para a função de php trigger_error(), ex.: E_USER_NOTICE, E_USER_WARNING, etc. Por padrão é E_USER_WARNING. 
+
+
+
+= template_exists =
+
+----
+
+bool template_exists (string template)
+
+
+
+Essa função checa se o template especificado existe. Isso pode aceitar um path para o template no filesystem ou um recurso de string especificando o template. 
+
+
+
+= unregister_block =
+
+----
+
+void unregister_block (string name)
+
+
+
+Use isso para desregistrar dinamicamente um bloco de funções de plugin. Passe no bloco o nome da função. 
+
+
+
+= unregister_compiler_function =
+
+----
+
+void unregister_compiler_function (string name)
+
+
+
+Use essa função para desregistrar uma função de compilador. Passe o nome da função de compilador. 
+
+
+
+= unregister_function =
+
+----
+
+void unregister_function (string name)
+
+
+
+Use isso para desregistrar dinamicamente uma função de plugin do template. Passe no template o nome da função.
+
+
+
+Exemplo 13-25. unregister_function
+
+
+
+// nós não queremos que designers template tenham acesso aos nossos arquivos do sistema
+
+
+
+$smarty->unregister_function("fetch");
+
+
+
+= unregister_modifier =
+
+----
+
+void unregister_modifier (string name)
+
+
+
+Use isso para desregistrar dincamimente um modificador de plugin. Passe no template o nome do modificador.
+
+
+
+Exemplo 13-26. unregister_modifier
+
+
+
+// nós não queremos que designers de template usem strip tags para os elementos
+
+
+
+$smarty->unregister_modifier("strip_tags");
+
+
+
+== unregister_object ==
+
+----
+
+void unregister_object (string object_name)
+
+
+
+Use isso para desregistrar um objeto. 
+
+
+
+= unregister_outputfilter =
+
+----
+
+void unregister_outputfilter (string function_name)
+
+
+
+Use isso para desregistrar dinamicamente um filtro de saída. 
+
+
+
+= unregister_postfilter =
+
+----
+
+void unregister_postfilter (string function_name)
+
+
+
+Use isso para dinamicamente desregistrar um pósfiltro. 
+
+
+
+= unregister_prefilter =
+
+----
+
+void unregister_prefilter (string function_name)
+
+
+
+Use isso para dinamicamente desregistrar um préfiltro. 
+
+
+
+= unregister_resource =
+
+----
+
+void unregister_resource (string name)
+
+
+
+Use isso para dinamicamente desregistrar um recurso de plugin. Passe no parâmetro nome o nome do recurso.
+
+
+
+Exemplo 13-27. unregister_resource
+
+
+
+$smarty->unregister_resource("db");