PHP: unset - Manual

[/] Downloads Documentation Get Involved Help PHP 7.0.0 Released Getting Started Introduction A simple tutorial Language Reference Basic syntax Types Variables Constants Expressions Operators Control Structures Functions Classes and Objects Namespaces Errors Exceptions Generators References Explained Predefined Variables Predefined Exceptions Predefined Interfaces and Classes Context options and parameters Supported Protocols and Wrappers Security Introduction General considerations Installed as CGI binary Installed as an Apache module Filesystem Security Database Security Error Reporting Using Register Globals User Submitted Data Magic Quotes Hiding PHP Keeping Current Features HTTP authentication with PHP Cookies Sessions Dealing with XForms Handling file uploads Using remote files Connection handling Persistent Database Connections Safe Mode Command line usage Garbage Collection DTrace Dynamic Tracing Function Reference Affecting PHP's Behaviour Audio Formats Manipulation Authentication Services Command Line Specific Extensions Compression and Archive Extensions Credit Card Processing Cryptography Extensions Database Extensions Date and Time Related Extensions File System Related Extensions Human Language and Character Encoding Support Image Processing and Generation Mail Related Extensions Mathematical Extensions Non-Text MIME Output Process Control Extensions Other Basic Extensions Other Services Search Engine Extensions Server Specific Extensions Session Extensions Text Processing Variable and Type Related Extensions Web Services Windows Only Extensions XML Manipulation Keyboard Shortcuts ? This help j Next menu item k Previous menu item g p Previous man page g n Next man page G Scroll to bottom g g Scroll to top g h Goto homepage g s Goto search (current page) / Focus search box var_dump » « unserialize PHP Manual Function Reference Variable and Type Related Extensions Variable handling Variable handling Functions Change language: English Brazilian Portuguese Chinese (Simplified) French German Japanese Korean Romanian Russian Spanish Turkish Other Edit Report a Bug unset (PHP 4, PHP 5, PHP 7) unset — Unset a given variable Description void unset ( mixed $var [, mixed $... ] ) unset() destroys the specified variables. The behavior of unset() inside of a function can vary depending on what type of variable you are attempting to destroy. If a globalized variable is unset() inside of a function, only the local variable is destroyed. The variable in the calling environment will retain the same value as before unset() was called. The above example will output: bar To unset() a global variable inside of a function, then use the $GLOBALS array to do so: If a variable that is PASSED BY REFERENCE is unset() inside of a function, only the local variable is destroyed. The variable in the calling environment will retain the same value as before unset() was called. The above example will output: something something If a static variable is unset() inside of a function, unset() destroys the variable only in the context of the rest of a function. Following calls will restore the previous value of a variable. The above example will output: Before unset: 1, after unset: 23 Before unset: 2, after unset: 23 Before unset: 3, after unset: 23 Parameters var The variable to be unset. ... Another variable ... Return Values No value is returned. Examples Example #1 unset() example Example #2 Using (unset) casting (unset) casting is often confused with the unset() function. (unset) casting serves only as a NULL -type cast, for completeness. It does not alter the variable it's casting. The above example will output: NULL string(6) "Felipe" Notes Note : Because this is a language construct and not a function, it cannot be called using variable functions . Note : It is possible to unset even object properties visible in current context. Note : It is not possible to unset $this inside an object method since PHP 5. Note : When using unset() on inaccessible object properties, the __unset() overloading method will be called, if declared. See Also isset() - Determine if a variable is set and is not NULL empty() - Determine whether a variable is empty __unset() array_splice() - Remove a portion of the array and replace it with something else add a note User Contributed Notes 48 notes up down 46 Kai Kunstmann ¶ 7 years ago Since unset() is a language construct, it cannot be passed anything other than a variable. It's sole purpose is to "unset" this variable, ie. to remove it from the current scope and destroy it's associated data. This is true especially for reference variables, where not the actual value is destroyed but the reference to that value. This is why you can't wrap 'unset()' in a user defined function: You would either unset a copy of the data if the parameter is passed by value, or you would just unset the reference variable within the functions scope if the parameter is passed by reference. There is no workaround for that, as you cannot pass 'scope' to a function in PHP. Such a function can only work for variables that exist in a common or global scope (compare 'unset($_GLOBALS[variable])'). I don't know how PHP handles garbage collection internally, but I guess this behavior can result in a huge memory leak: if a value variable goes out of scope with a second variable still holding a reference to the in-memory value, then unsetting that reference would still hold the value in memory but potentially unset the last reference to that in-memory data, hence: occupied memory that is rendered useless as you cannot reference it anymore. up down 35 j dot vd dot merwe at enovision dot net ¶ 5 years ago A sample how to unset array elements from an array result coming from a mysql request. In this sample it is checking if a file exists and removes the row from the array if it not exists. set_query ( "select * from documents where document_in_user = 0" ); //1 $documents = $db -> result_to_array ( $db -> get_result ()); //1 foreach ( $documents as $key => $row ) { //2 $file = "uploads/" . rawurldecode ( $row [ 'document_name' ]); if ( file_exists ( $file ) == FALSE ) { unset( $documents [ $key ]); //3 } } $documents = array_values ( $documents ); // reindex the array (4) ?> variables: mysql table = documents, array = $documents array key (index) = $key array row (record sort of speak) = $row explanation: 1. it gets the array from the table (mysql) 2. foreach goes through the array $documents 3. unset if record does not exist 4. the array_values($documents) reindexes the $documents array, for otherwise you might end up in trouble when your process will start expecting an array starting with key ($key) 0 (zero). up down 30 nox at oreigon dot de ¶ 7 years ago if you try to unset an object, please be careful about references. Objects will only free their resources and trigger their __destruct method when *all* references are unsetted. Even when they are *in* the object... sigh! a = $a ; #unset($a); # Just uncomment, and you'll see echo "No Message ... hm, what now?\n" ; unset( $a -> a ); unset( $a ); echo "Finally that thing is gone\n" ; ?> Of course the object completely dies at the end of the script. up down 26 Hayley Watson ¶ 2 years ago You don't need to check that a variable is set before you unset it. is harmless. is pointless complication. This doesn't apply to properties of objects that have __isset() methods that visibly change object state or __unset() methods that don't properly check their arguments or have extra side effects. The latter case means that __unset shouldn't do more than what it says on the tin, and also has the responsibility for checking (possibly using __isset()) that what it's being asked to do makes sense. The former case is just plain bad design. up down 30 franckraynal at free dot fr ¶ 10 years ago Here is another way to make 'unset' work with session variables from within a function : May it work with others than me... F. up down 25 andre at twg dot com dot au ¶ 11 years ago Only This works with register_globals being 'ON'. unset( $_SESSION['variable'] ); The above will not work with register_globals turned on (will only work outside of a function). $variable = $_SESSION['variable']; unset( $_SESSION['variable'], $variable ); The above will work with register_globals on & inside a function up down 19 thorry at thorry dot net ¶ 11 years ago The documentation is not entirely clear when it comes to static variables. It says: If a static variable is unset() inside of a function, unset() destroys the variable and all its references. The above example would output: 1 2 3 And it does! But the variable is NOT deleted, that's why the value keeps on increasing, otherwise the output would be: 1 1 1 The references are destroyed within the function, this handeling is the same as with global variables, the difference is a static variable is a local variable. Be carefull using unset and static values as the output may not be what you expect it to be. It appears to be impossible to destroy a static variable. You can only destroy the references within the current executing function, a successive static statement will restore the references. The documentation would be better if it would say: "If a static variable is unset() inside of a function, unset() destroys all references to the variable. " Example: (tested PHP 4.3.7) Would output: 1 1 2 2 3 3 up down 18 dan AT --nospam-- cubeland DOT co DOT uk ¶ 11 years ago dh at argosign dot de - it is possible to unset globals from within functions thanks to the $GLOBALS array: ' ; } test (); echo "x: $x
" ; // will result in /* x: x: */ ?> up down 15 phpmanual at kennel17 dot co dot uk ¶ 5 years ago Note that PHP 4 will generate a warning if you try to unset an array index that doesn't exist and whose parent doesn't exist. Example: RESULT: "Notice: Undefined index: Bar" On PHP5 no error is raised, which seems to me like the correct behaviour. Note that using unset($foo['Bar']) in the above example does not generate a warning in either version. (Tested on 4.4.9 and 5.2.4) up down 15 edouard dot berge at gmail dot com ¶ 5 years ago Warning! When unset from an array, if you unset all elements, the array is always set $tab=array('A'=>1,'B'=>2); unset($tab['A']); unset($tab['B']); echo isset($tab)." ".count($tab); output: 1 0 up down 16 Anonymous ¶ 8 years ago Just to confirm, USING UNSET CAN DESTROY AN ENTIRE ARRAY. I couldn't find reference to this anywhere so I decided to write this. The difference between using unset and using $myarray=array(); to unset is that obviously the array will just be overwritten and will still exist. Output with unset is: up down 13 pfreilly at umd dot umich dot edu ¶ 4 years ago Despite much searching, I have not yet found an explanation as to how one can manually free resources from variables, not so much objects, in PHP. I have also seen many comments regarding the merits and demerits of unset() versus setting a variable to null. Thus, here are the results of some benchmarks performed comparing unset() of numerous variables to setting them to null (with regards to memory usage and processing time): 10 variables: Unset: Memory Usage: 296 Time Elapsed: 1.0013580322266E-5 Null set: Memory Usage: 1736 Time Elapsed: 5.9604644775391E-6 50 variables: Unset: Memory Usage: 296 Time Elapsed: 3.6001205444336E-5 Null set: Memory Usage: 8328 Time Elapsed: 3.2901763916016E-5 100 variables: Unset: Memory Usage: 296 Time Elapsed: 5.6982040405273E-5 Null set: Memory Usage: 15928 Time Elapsed: 5.8174133300781E-5 1000 variables: Unset: Memory Usage: 296 Time Elapsed: 0.00041294097900391 Null set: Memory Usage: 168096 Time Elapsed: 0.00067591667175293 10000 variables: Unset: Memory Usage: 296 Time Elapsed: 0.0042569637298584 Null set: Memory Usage: 1650848 Time Elapsed: 0.0076930522918701 100000 variables: Unset: Memory Usage: 296 Time Elapsed: 0.042603969573975 Null set: Memory Usage: 16249080 Time Elapsed: 0.087724924087524 300000 variables: Unset: Memory Usage: 296 Time Elapsed: 0.13177299499512 Null set: Memory Usage: 49796320 Time Elapsed: 0.28617882728577 Perhaps my test code for the null set was flawed, but despite that possibility it is simple to see that unset() has minimal processing time impact, and no apparent memory usage impact (unless the values returned by memory_get_usage() are flawed). If you truly care about the ~4 microseconds saved over <50 variables, more power to you. Otherwise, use unset() to minimize script impact on your system. Note: Tested on PHP 5.3.8 installed via RPM on Fedora 14 up down 13 hessodreamy at gmail dot com ¶ 8 years ago To clarify what hugo dot dworak at gmail dot com said about unsetting things that aren't already set: unsetting a non-existent key within an array does NOT throw an error. up down 13 dibakar dot datta at gmail dot com ¶ 9 years ago Instead of using the unset function for unregistering your session or other array values you can also do this samll feature and get this task done with just 1 line code. Suppose, if you like to unregister your session store values. You can use: $_SESSION = array(); Well this syntax saves lot's of time instead of unsetting each values. up down 13 anon at no spam dot no address dot com ¶ 11 years ago Adding on to what bond at noellebond dot com said, if you want to remove an index from the end of the array, if you use unset, the next index value will still be what it would have been. Eg you have You would expect: Array([0] => 1, [1] => 4) as you want it to remove the last set key.... but you actually get Array ( [0] => 1 [4] => 2 [5] => 3 [6] => 4 ) This is since even though the last key is removed, the auto indexing still keeps its previous value. The only time where this would not seem right is when you remove a value off the end. I guess different people would want it different ways. The way around this is to use array_pop() instead of unset() as array_pop() refreshes the autoindexing thing for the array. This returns the expected value of x = Array([0] => 1, [1] => 4); Hope this helps someone who may need this for some odd reason, I did. up down 9 Andreas ¶ 5 years ago You can not unset a numeric key of an array, if key is a string. See this example: // Create a simple array with 3 different key types $test[1] = array( 10 => array('apples'), "20" => array('bananas'), '30' => array('peaches') ); $test[2] = (array) json_decode(json_encode($test[1])); $test[3] = (array) (object) $test[1]; // array form a stdClass object $testClass = new stdClass(); $testClass->{10} = array('apples'); $testClass->{"20"} = array('bananas'); $test[4] = (array) $testClass[6]; echo "

"; foreach($test as $testNum => $arr) { echo "\nTest: " . $testNum . " \n"; var_dump($arr); foreach($arr as $key => $fruit) { echo "key: " . $key . "\n"; echo "key exists: "; var_dump(array_key_exists(strval($key), $arr)); echo "typeof key is: " . gettype($key) . "\n"; unset($arr[$key]); } var_dump($arr); echo "\n" . str_repeat("-", 80); } echo "

"; And here is the output: Test: 1 array(3) { [10]=> array(1) { [0]=> string(6) "apples" } [20]=> array(1) { [0]=> string(7) "bananas" } [30]=> array(1) { [0]=> string(7) "peaches" } } key: 10 key exists: bool(true) typeof key is: integer key: 20 key exists: bool(true) typeof key is: integer key: 30 key exists: bool(true) typeof key is: integer array(0) { } -------------------------------------------------------------- Test: 2 array(3) { ["10"]=> array(1) { [0]=> string(6) "apples" } ["20"]=> array(1) { [0]=> string(7) "bananas" } ["30"]=> array(1) { [0]=> string(7) "peaches" } } key: 10 key exists: bool(false) typeof key is: string key: 20 key exists: bool(false) typeof key is: string key: 30 key exists: bool(false) typeof key is: string array(3) { ["10"]=> array(1) { [0]=> string(6) "apples" } ["20"]=> array(1) { [0]=> string(7) "bananas" } ["30"]=> array(1) { [0]=> string(7) "peaches" } } -------------------------------------------------------------- Test: 3 array(3) { [10]=> array(1) { [0]=> string(6) "apples" } [20]=> array(1) { [0]=> string(7) "bananas" } [30]=> array(1) { [0]=> string(7) "peaches" } } key: 10 key exists: bool(true) typeof key is: integer key: 20 key exists: bool(true) typeof key is: integer key: 30 key exists: bool(true) typeof key is: integer array(0) { } -------------------------------------------------------------- Test: 4 array(2) { ["10"]=> array(1) { [0]=> string(6) "apples" } ["20"]=> array(1) { [0]=> string(7) "bananas" } } key: 10 key exists: bool(false) typeof key is: string key: 20 key exists: bool(false) typeof key is: string array(2) { ["10"]=> array(1) { [0]=> string(6) "apples" } ["20"]=> array(1) { [0]=> string(7) "bananas" } } -------------------------------------------------------------- Fix the problem with a rebuild of the array: $oldArray = $array(); $array = array(); foreach($oldArray as $key => $item) { $array[intval($key)] = $item; } up down 9 lion_cat at mail ru ¶ 7 years ago about unset for arrays if you unset the last array member $ar[0]==2 $ar[1]==7 $ar[2]==9 unset ($ar[2]) after addition a new member by $ar[]=7, you will get $ar[0]==2 $ar[1]==7 $ar[3]==7, So, unset has no effect to internal array counter!!! up down 6 tigercat at aol dot com ¶ 3 years ago The combination of "global" and "unset" in functions can lead to some unexpected results. This is because the "global" function creates a reference to a variable at the time it's executed, so a variable can be deleted out from under a "global $my_variable" declaration in a function. Accessing data that's been deleted with an obsolete reference is usually a bad thing; in some languages it can generate a machine address fault. up down 9 clark at everettsconsulting dot com ¶ 10 years ago In PHP 5.0.4, at least, one CAN unset array elements inside functions from arrays passed by reference to the function. As implied by the manual, however, one can't unset the entire array by passing it by reference. ' ; // Value of $scalar is: Hello, there remove_variable ( $scalar ); // try to unset the variable echo 'Value of $scalar is: ' ; print_r ( $scalar ); echo '
' ; // Value of $scalar is: Hello, there $array = array( 'one' => 1 , 'two' => 2 , 'three' => 3 ); echo 'Value of $array is: ' ; print_r ( $array ); echo '
' ; // Value of $array is: Array ( [one] => 1 [two] => 2 [three] => 3 ) remove_variable ( $array ); // try to unset the array echo 'Value of $array is: ' ; print_r ( $array ); echo '
' ; // Value of $array is: Array ( [one] => 1 [two] => 2 [three] => 3 ) remove_element ( $array , 'two' ); // successfully remove an element from the array echo 'Value of $array is: ' ; print_r ( $array ); echo '
' ; // Value of $array is: Array ( [one] => 1 [three] => 3 ) ?> up down 6 stacionari at gmail dot com ¶ 7 years ago Sometimes you need to assigne values to an array index in some loop (if, while, foreach etc.) but you wish to set starting index key to some number greater then zero (lets say 5). One idea how to do this is: 0 ); //sets starting key to be 4 and assigns some value (lets say 0) unset( $myArray [ 4 ]); //delete this index key, but preserves further enumeration foreach( $values as $value ){ $myArray [] = $value ; //asign values to our array } print_r ( $myArray ); /* Output: Array ( [5] => 5 [6] => 10 [7] => 15 [8] => 100 ) */ ?> up down 6 Hayley Watson ¶ 8 years ago In regard to some confusion earlier in these notes about what causes unset() to trigger notices when unsetting variables that don't exist.... Unsetting variables that don't exist, as in does not trigger an "Undefined variable" notice. But triggers two notices, because this code is for unsetting an element of an array; neither $undefinedArray nor $undefinedKey are themselves being unset, they're merely being used to locate what should be unset. After all, if they did exist, you'd still expect them to both be around afterwards. You would NOT want your entire array to disappear just because you unset() one of its elements! up down 7 no at spam dot com ¶ 10 years ago In addition to what timo dot hummel at 4fb dot de said; >For the curious: unset also frees memory of the variable used. > >It might be possible that the in-memory size of the PHP Interpreter isn't reduced, but your scripts won't touch the memory_limit boundary. Memory is reused if you declare new variables. It might be worth adding that functions apparently don't free up memory on exit the same way unset does.. Maybe this is common knowledge, but although functions destroys variables on exit, it (apparently) doesn't help the memory. So if you use huge variables inside functions, be sure to unset them if you can before returning from the function. In my case, if I did not unset before return, then the script would use 20 MB more of memory than if I did unset. This was tested with php 5.0.4 on apache 2 on windows xp, with no memory limit. Before I did the test, I was under the impression that when you exit from functions, the memory used inside it would be cleared and reused. Maybe this should be made clear in the manual, for either unset() or in the chapter for functions. up down 4 macnimble at gmail dot com ¶ 6 years ago Two ways of unsetting values within an array: 52 , 'bananas' => 78 , 'peaches' => 'out of season' , 'pears' => 'out of season' , 'oranges' => 'no longer sold' , 'carrots' => 15 , 'beets' => 15 , ); echo "

Original Array:\n" , print_r ( $fruit_inventory , TRUE ), '

' ; # For example, beets and carrots are not fruits... $fruit_inventory = array_remove_key ( $fruit_inventory , "beets" , "carrots" ); echo "

Array after key removal:\n" , print_r ( $fruit_inventory , TRUE ), '

' ; # Let's also remove 'out of season' and 'no longer sold' fruit... $fruit_inventory = array_remove_value ( $fruit_inventory , "out of season" , "no longer sold" ); echo "

Array after value removal:\n" , print_r ( $fruit_inventory , TRUE ), '

' ; ?> up down 4 pauljamescampbell at gmail dot com ¶ 7 years ago Here's my variation on the slightly dull unset method. It throws in a bit of 80's Stallone action spice into the mix. Enjoy! up down 5 warhog at warhog dot net ¶ 11 years ago you may wan't to unset all variables which are defined, here's one way: $val ) { unset( $GLOBALS [ $key ]); } return serialize ( $a ); } unset_all_vars ( get_defined_vars ()); ?> you can also save than a serialized var of the "memory" and perhaps store this in a temporary file.. very usefull if you work with text files and/or file uploads when you've got very large variables. greetz up down 3 chad 0x40 herballure 0x2e com ¶ 8 years ago It is observed on PHP 5.1.6 that inside of a method will remove the reference to $this in that method. $this isn't considered "special" as far as unset() is concerned. up down -1 Anonymous ¶ 2 years ago This is a bug or i missing something? up down -3 Anonymous ¶ 5 years ago further I realized that an object, when getting detroyed, does care about destroying variable in object space visibility but not those in local visibility, be aware of the found pattern: other_object =new other_object_class (); } public function __destruct (){ //note that you always have to unset class objects, in order to get the resources released unset( $this -> other_object ); } public allocate_mem_A (){ $this -> buffer = file ( "/tmp/bigfile" ); } public allocate_mem_B (){ $buffer = file ( "/tmp/bigfile" ); } public allocate_mem_C (){ $buffer = file ( "/tmp/bigfile" ); unset( $buffer ); } public allocate_mem_D (){ $this -> other_buffer = file ( "/tmp/bigfile" ); } } //this does not lead to a resource problem $A =new release_test (); $A -> allocate_mem_A (); $A -> __destruct (); unset( $A ); //this DOES lead to a resource problem $B =new release_test (); $B -> allocate_mem_B (); $B -> __destruct (); unset( $B ); //this does not lead to a resource problem $C =new release_test (); $C -> allocate_mem_C (); $C -> __destruct (); unset( $C ); //this does not lead to a resource problem $D =new release_test (); $D -> allocate_mem_D (); $D -> __destruct (); unset( $D ); ?> up down -3 frank at agentbrand dot com ¶ 12 years ago Use array_values() after unset() to reindex your array. Note that unset() removes the index as a key, you will need to reindex your array again to get expected behavior up down -8 levitating at gmail dot com ¶ 7 years ago >> shame, but it doesn't seem to pop the stack. There is a simple solution to that. Delete the value, then use array_merge() on your array: up down -11 morfeu_gd at hotmail dot com ¶ 2 years ago To unset entire object/array recursively: $valor ){ print_r ( str_repeat ( "\t" , $nível_recursão ). "Deletando do vetor o elemento $key \r\n" ); limpar_vetor_objeto ( $valor ); unset( $valor ); } unset( $elemento ); } else if( is_object ( $elemento )){ foreach( $elemento as $key => $valor ){ print_r ( str_repeat ( "\t" , $nível_recursão ). "Deletando do objeto a propriedade $key \r\n" ); limpar_vetor_objeto ( $valor ); unset( $valor ); } unset( $elemento ); } $nível_recursão --; } ?> up down -10 muhamad_zakaria at yahoo dot com ¶ 10 years ago We have experienced when we applied 'unset' to the overloaded properties (PHP5), consider the code below: Var [ $var ] = $val ; } function __get ( $var ) { if(isset( $this -> Var [ $var ])) return $this -> Var [ $var ]; else return - 1 ; } } $SomeObj = new TheObj ; // here we set for real variables $SomeObj -> RealVar1 = 'somevalue' ; $SomeObj ->{ 'RealVar2' } = 'othervalue' ; $SomeObj ->{ 'RealVar' .( 3 )} = 'othervaluetoo' ; $SomeObj ->{ 'RealVar' . '4' } = 'anothervalue' ; // and here we set for virtual variables $SomeObj -> Virtual1 = 'somevalue' ; $SomeObj ->{ 'Virtual2' } = 'othervalue' ; $SomeObj ->{ 'Virtual' .( 3 )} = 'othervaluetoo' ; $SomeObj ->{ 'Virtual' . '4' } = 'anothervalue' ; // now we will try to unset these variables unset( $SomeObj -> RealVar1 ); unset( $SomeObj ->{ 'RealVar' .( 3 )}); //the lines below will catch by '__get' magic method since these variables are unavailable anymore print $SomeObj -> RealVar1 . "\n" ; print $SomeObj ->{ 'RealVar' .( 3 )}. "\n" ; // now we will try to unset these variables unset( $SomeObj -> Virtual1 ); unset( $SomeObj ->{ 'Virtual' .( 3 )}); //but, these variables are still available??? eventhough they're "unset"-ed print $SomeObj -> Virtual1 . "\n" ; print $SomeObj ->{ 'Virtual' .( 3 )}. "\n" ; ?> Please note that PHP doesn't have magic callback to unset overloaded properties. This is the reason why unset($SomeObj->Virtual1) doesn't work. But it does work when we set 'null' value such as the following code: Virtual1 = null ; $SomeObj ->{ 'Virtual' .( 3 )} = null ; // and now these variables are no longer available print $SomeObj -> Virtual1 . "\n" ; print $SomeObj ->{ 'Virtual' .( 3 )}. "\n" ; ?> Sound ugly, yeah? This applied to the "virtual" array variable too, see more at http://bugs.php.net/bug.php?id=33513 (at feedback) about it. PS: we used PHP version 5.1.0-dev from the CVS snapshot when we wrote the above codes. up down -11 RQuadling at GMail dot com ¶ 8 years ago If you want to remove a value from an array, then there is no direct mechanism. The following function uses the array_keys() function to find the key(s) of the value that you want to remove and then removes the elements for that key. I've also given some examples and the output. Beside scalar variables (integers, floats, strings, boolean), you can also use arrays as the values you want to remove. up down -14 harycary at netscape dot net ¶ 10 years ago If you ever have to unset all the variables of a class from within a funciton of that class use the following code: $val ); } $this -> greeting = $greeting ; ... } } ?> If anyone knows of a more effective way please post a reply. up down -18 David Sawyer, Metaface Development ¶ 6 years ago Here's a simple function to remove a variable from an HTTP Query String: ---------------------------- Example Usage #1: Let's say you want to remove the variable "fruit" from $page_url below... Output: http://www.example.com/script.php?color=red ---------------------------- Example Usage #2: To remove the variable "q" from the query string of the current page, try something like... up down -17 Maresa ¶ 8 years ago Note that since unset() returns void, you can't do this: isset($some_var) && unset($some_var); You'll get: Parse error: syntax error, unexpected T_UNSET in ... The reason is because it would parse as && ; which is not a valid PHP statement. Thus, the only alternative is to actually use if statement. up down -17 bedbin at gmail dot com ¶ 10 years ago usefull tip: if you have session variables like these. " ; $_SESSION [ "num" ] = array( 1 , 2 , 3 , 4 ); var_dump ( $_SESSION ); echo "-
" ; unset( $_SESSION ); var_dump ( $_SESSION ); ?> gives out: array(1) { ["num"]=> array(4) { [0]=> int(1) [1]=> int(2) [2]=> int(3) [3]=> int(4) } } - NULL if you use empty instead unset you get same output as first var_dump($_SESSION) gives. I hope help sb. up down -21 Metasansana ¶ 4 years ago A simple function to unset unwanted keys in an array: 1 , "B" => 2 , "C" => "a" ); foreach( $a as $key =>& $value ){ if( is_string ( $value ){ unset( $a [ $key ]); } } print_r ( $a ); ?> This should print: A=1 B=2. up down -18 timo dot hummel at 4fb dot de ¶ 11 years ago For the curious: unset also frees memory of the variable used. It might be possible that the in-memory size of the PHP Interpreter isn't reduced, but your scripts won't touch the memory_limit boundary. Memory is reused if you declare new variables. up down -22 gerry+phpnet at buzka dot com ¶ 8 years ago Quote from http://fr.php.net/session_unset "Do NOT unset the whole $_SESSION with unset($_SESSION) as this will disable the registering of session variables through the $_SESSION superglobal." So basically don't do: unset($_SESSION) Instead do: $_SESSION = array(); up down -22 thijs NOSPACE putman at gmail dot com ¶ 7 years ago "It is possible to unset even object properties visible in current context" Although the note is clear, in my case it required a little example to grasp its full impact: If your object uses overloaded properties (using the "__set()" magic method) and you unset one of your "real" properties, the "__set()" method will take over if you try to assign a value to this property again. In most cases, the "__set()" method is very much limited in the properties it can set. In my case, I only allow "__set()" to change a limited, predefined, set of properties. Most of them through their "public" name instead of their actual name... This generates a somewhat counter-intuitive situation: If you unset a variable, you expect its value to become "null", which remains true. You also expect to be able to set it again to another value. In the example described above this is not the case: The "__get()" method is invoked and, in my case, doesn't allow the property to be set again! up down -32 hugo dot dworak at gmail dot com ¶ 9 years ago If one tries to unset a typical variable that does not exist, no errors, warning or noticies will occur. However, if one tries to unset a non-existent array or an array with non-existent key, this will result in a notice. For instance: The output is (PHP 5.0.5): Notice: Undefined variable: undefinedKey Notice: Undefined variable: undefinedKey Notice: Undefined variable: undefinedArray up down -39 Sinured ¶ 8 years ago The main difference between and is, that unset() will reset the state to $var to something like "not set at all". up down -41 alex at bartl dot net ¶ 5 years ago unset($class_object) does not release resources allocated by the object. If used in loops, which create and destroy objects, that might easily lead to a resource problem. Explicitly call the destructor to circumvent the problem. __destruct (); unset( $my_class_object ); } ?> up down -2 magnesium dot oxide dot play+php at gmail dot com ¶ 1 year ago You can unset superglobals like $GLOBALS, $_GET etc., but causing an unususal behavior (as of PHP 5.3.3). 1) unsetting of superglobals is done globally, i.e. unsetting inside the function affects GLOBALLY. 2) Recreation of unset'ed superglobals can be done (recreated valiables are superglobals), but original functionality (in $GLOBALS, $_SESSION ...) has lost. up down -45 obsidianproject.co.uk ¶ 6 years ago A quick note on (unset) vs unset(). will return Notice: Undefined variable: a NULL will return NULL When using unset() php will throw an E_NOTICE if you try and access the variable after it has been unset, (unset) won't. This has been tested in PHP 5.3.0 up down -56 kdechant at midwestarts dot com ¶ 12 years ago As of PHP version 4.3.3, unset() results in a parse error if it is used with the @ error suppression operator. For example: @unset($var); // parse error unset(@$var); // parse error unset($var); // okay up down -69 bond at noellebond dot com ¶ 11 years ago Note that though global arrays will not be altered by a function, an array in an object WILL be altered if referenced within one of its methods. For example: function remove_index ($i) { unset($this->test_array[$i]); $temp_array = array_values($this->test_array); $this->test_array = $temp_array; } Will remove key $i from the object's array and reindex it. add a note Variable handling Functions boolval debug_​zval_​dump doubleval empty floatval get_​defined_​vars get_​resource_​type gettype import_​request_​variables intval is_​array is_​bool is_​callable is_​double is_​float is_​int is_​integer is_​long is_​null is_​numeric is_​object is_​real is_​resource is_​scalar is_​string isset print_​r serialize settype strval unserialize unset var_​dump var_​export Copyright © 2001-2015 The PHP Group My PHP.net Contact Other PHP.net sites Mirror sites Privacy policy