├── LICENSE ├── README.md ├── cast-to-type.php ├── class.cast-to-type-php4.php ├── class.cast-to-type.php └── composer.json /LICENSE: -------------------------------------------------------------------------------- 1 | GNU GENERAL PUBLIC LICENSE 2 | Version 2, June 1991 3 | 4 | Copyright (C) 1989, 1991 Free Software Foundation, Inc., 5 | 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 6 | Everyone is permitted to copy and distribute verbatim copies 7 | of this license document, but changing it is not allowed. 8 | 9 | Preamble 10 | 11 | The licenses for most software are designed to take away your 12 | freedom to share and change it. By contrast, the GNU General Public 13 | License is intended to guarantee your freedom to share and change free 14 | software--to make sure the software is free for all its users. This 15 | General Public License applies to most of the Free Software 16 | Foundation's software and to any other program whose authors commit to 17 | using it. (Some other Free Software Foundation software is covered by 18 | the GNU Lesser General Public License instead.) You can apply it to 19 | your programs, too. 20 | 21 | When we speak of free software, we are referring to freedom, not 22 | price. Our General Public Licenses are designed to make sure that you 23 | have the freedom to distribute copies of free software (and charge for 24 | this service if you wish), that you receive source code or can get it 25 | if you want it, that you can change the software or use pieces of it 26 | in new free programs; and that you know you can do these things. 27 | 28 | To protect your rights, we need to make restrictions that forbid 29 | anyone to deny you these rights or to ask you to surrender the rights. 30 | These restrictions translate to certain responsibilities for you if you 31 | distribute copies of the software, or if you modify it. 32 | 33 | For example, if you distribute copies of such a program, whether 34 | gratis or for a fee, you must give the recipients all the rights that 35 | you have. You must make sure that they, too, receive or can get the 36 | source code. And you must show them these terms so they know their 37 | rights. 38 | 39 | We protect your rights with two steps: (1) copyright the software, and 40 | (2) offer you this license which gives you legal permission to copy, 41 | distribute and/or modify the software. 42 | 43 | Also, for each author's protection and ours, we want to make certain 44 | that everyone understands that there is no warranty for this free 45 | software. If the software is modified by someone else and passed on, we 46 | want its recipients to know that what they have is not the original, so 47 | that any problems introduced by others will not reflect on the original 48 | authors' reputations. 49 | 50 | Finally, any free program is threatened constantly by software 51 | patents. We wish to avoid the danger that redistributors of a free 52 | program will individually obtain patent licenses, in effect making the 53 | program proprietary. To prevent this, we have made it clear that any 54 | patent must be licensed for everyone's free use or not licensed at all. 55 | 56 | The precise terms and conditions for copying, distribution and 57 | modification follow. 58 | 59 | GNU GENERAL PUBLIC LICENSE 60 | TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 61 | 62 | 0. This License applies to any program or other work which contains 63 | a notice placed by the copyright holder saying it may be distributed 64 | under the terms of this General Public License. The "Program", below, 65 | refers to any such program or work, and a "work based on the Program" 66 | means either the Program or any derivative work under copyright law: 67 | that is to say, a work containing the Program or a portion of it, 68 | either verbatim or with modifications and/or translated into another 69 | language. (Hereinafter, translation is included without limitation in 70 | the term "modification".) Each licensee is addressed as "you". 71 | 72 | Activities other than copying, distribution and modification are not 73 | covered by this License; they are outside its scope. The act of 74 | running the Program is not restricted, and the output from the Program 75 | is covered only if its contents constitute a work based on the 76 | Program (independent of having been made by running the Program). 77 | Whether that is true depends on what the Program does. 78 | 79 | 1. You may copy and distribute verbatim copies of the Program's 80 | source code as you receive it, in any medium, provided that you 81 | conspicuously and appropriately publish on each copy an appropriate 82 | copyright notice and disclaimer of warranty; keep intact all the 83 | notices that refer to this License and to the absence of any warranty; 84 | and give any other recipients of the Program a copy of this License 85 | along with the Program. 86 | 87 | You may charge a fee for the physical act of transferring a copy, and 88 | you may at your option offer warranty protection in exchange for a fee. 89 | 90 | 2. You may modify your copy or copies of the Program or any portion 91 | of it, thus forming a work based on the Program, and copy and 92 | distribute such modifications or work under the terms of Section 1 93 | above, provided that you also meet all of these conditions: 94 | 95 | a) You must cause the modified files to carry prominent notices 96 | stating that you changed the files and the date of any change. 97 | 98 | b) You must cause any work that you distribute or publish, that in 99 | whole or in part contains or is derived from the Program or any 100 | part thereof, to be licensed as a whole at no charge to all third 101 | parties under the terms of this License. 102 | 103 | c) If the modified program normally reads commands interactively 104 | when run, you must cause it, when started running for such 105 | interactive use in the most ordinary way, to print or display an 106 | announcement including an appropriate copyright notice and a 107 | notice that there is no warranty (or else, saying that you provide 108 | a warranty) and that users may redistribute the program under 109 | these conditions, and telling the user how to view a copy of this 110 | License. (Exception: if the Program itself is interactive but 111 | does not normally print such an announcement, your work based on 112 | the Program is not required to print an announcement.) 113 | 114 | These requirements apply to the modified work as a whole. If 115 | identifiable sections of that work are not derived from the Program, 116 | and can be reasonably considered independent and separate works in 117 | themselves, then this License, and its terms, do not apply to those 118 | sections when you distribute them as separate works. But when you 119 | distribute the same sections as part of a whole which is a work based 120 | on the Program, the distribution of the whole must be on the terms of 121 | this License, whose permissions for other licensees extend to the 122 | entire whole, and thus to each and every part regardless of who wrote it. 123 | 124 | Thus, it is not the intent of this section to claim rights or contest 125 | your rights to work written entirely by you; rather, the intent is to 126 | exercise the right to control the distribution of derivative or 127 | collective works based on the Program. 128 | 129 | In addition, mere aggregation of another work not based on the Program 130 | with the Program (or with a work based on the Program) on a volume of 131 | a storage or distribution medium does not bring the other work under 132 | the scope of this License. 133 | 134 | 3. You may copy and distribute the Program (or a work based on it, 135 | under Section 2) in object code or executable form under the terms of 136 | Sections 1 and 2 above provided that you also do one of the following: 137 | 138 | a) Accompany it with the complete corresponding machine-readable 139 | source code, which must be distributed under the terms of Sections 140 | 1 and 2 above on a medium customarily used for software interchange; or, 141 | 142 | b) Accompany it with a written offer, valid for at least three 143 | years, to give any third party, for a charge no more than your 144 | cost of physically performing source distribution, a complete 145 | machine-readable copy of the corresponding source code, to be 146 | distributed under the terms of Sections 1 and 2 above on a medium 147 | customarily used for software interchange; or, 148 | 149 | c) Accompany it with the information you received as to the offer 150 | to distribute corresponding source code. (This alternative is 151 | allowed only for noncommercial distribution and only if you 152 | received the program in object code or executable form with such 153 | an offer, in accord with Subsection b above.) 154 | 155 | The source code for a work means the preferred form of the work for 156 | making modifications to it. For an executable work, complete source 157 | code means all the source code for all modules it contains, plus any 158 | associated interface definition files, plus the scripts used to 159 | control compilation and installation of the executable. However, as a 160 | special exception, the source code distributed need not include 161 | anything that is normally distributed (in either source or binary 162 | form) with the major components (compiler, kernel, and so on) of the 163 | operating system on which the executable runs, unless that component 164 | itself accompanies the executable. 165 | 166 | If distribution of executable or object code is made by offering 167 | access to copy from a designated place, then offering equivalent 168 | access to copy the source code from the same place counts as 169 | distribution of the source code, even though third parties are not 170 | compelled to copy the source along with the object code. 171 | 172 | 4. You may not copy, modify, sublicense, or distribute the Program 173 | except as expressly provided under this License. Any attempt 174 | otherwise to copy, modify, sublicense or distribute the Program is 175 | void, and will automatically terminate your rights under this License. 176 | However, parties who have received copies, or rights, from you under 177 | this License will not have their licenses terminated so long as such 178 | parties remain in full compliance. 179 | 180 | 5. You are not required to accept this License, since you have not 181 | signed it. However, nothing else grants you permission to modify or 182 | distribute the Program or its derivative works. These actions are 183 | prohibited by law if you do not accept this License. Therefore, by 184 | modifying or distributing the Program (or any work based on the 185 | Program), you indicate your acceptance of this License to do so, and 186 | all its terms and conditions for copying, distributing or modifying 187 | the Program or works based on it. 188 | 189 | 6. Each time you redistribute the Program (or any work based on the 190 | Program), the recipient automatically receives a license from the 191 | original licensor to copy, distribute or modify the Program subject to 192 | these terms and conditions. You may not impose any further 193 | restrictions on the recipients' exercise of the rights granted herein. 194 | You are not responsible for enforcing compliance by third parties to 195 | this License. 196 | 197 | 7. If, as a consequence of a court judgment or allegation of patent 198 | infringement or for any other reason (not limited to patent issues), 199 | conditions are imposed on you (whether by court order, agreement or 200 | otherwise) that contradict the conditions of this License, they do not 201 | excuse you from the conditions of this License. If you cannot 202 | distribute so as to satisfy simultaneously your obligations under this 203 | License and any other pertinent obligations, then as a consequence you 204 | may not distribute the Program at all. For example, if a patent 205 | license would not permit royalty-free redistribution of the Program by 206 | all those who receive copies directly or indirectly through you, then 207 | the only way you could satisfy both it and this License would be to 208 | refrain entirely from distribution of the Program. 209 | 210 | If any portion of this section is held invalid or unenforceable under 211 | any particular circumstance, the balance of the section is intended to 212 | apply and the section as a whole is intended to apply in other 213 | circumstances. 214 | 215 | It is not the purpose of this section to induce you to infringe any 216 | patents or other property right claims or to contest validity of any 217 | such claims; this section has the sole purpose of protecting the 218 | integrity of the free software distribution system, which is 219 | implemented by public license practices. Many people have made 220 | generous contributions to the wide range of software distributed 221 | through that system in reliance on consistent application of that 222 | system; it is up to the author/donor to decide if he or she is willing 223 | to distribute software through any other system and a licensee cannot 224 | impose that choice. 225 | 226 | This section is intended to make thoroughly clear what is believed to 227 | be a consequence of the rest of this License. 228 | 229 | 8. If the distribution and/or use of the Program is restricted in 230 | certain countries either by patents or by copyrighted interfaces, the 231 | original copyright holder who places the Program under this License 232 | may add an explicit geographical distribution limitation excluding 233 | those countries, so that distribution is permitted only in or among 234 | countries not thus excluded. In such case, this License incorporates 235 | the limitation as if written in the body of this License. 236 | 237 | 9. The Free Software Foundation may publish revised and/or new versions 238 | of the General Public License from time to time. Such new versions will 239 | be similar in spirit to the present version, but may differ in detail to 240 | address new problems or concerns. 241 | 242 | Each version is given a distinguishing version number. If the Program 243 | specifies a version number of this License which applies to it and "any 244 | later version", you have the option of following the terms and conditions 245 | either of that version or of any later version published by the Free 246 | Software Foundation. If the Program does not specify a version number of 247 | this License, you may choose any version ever published by the Free Software 248 | Foundation. 249 | 250 | 10. If you wish to incorporate parts of the Program into other free 251 | programs whose distribution conditions are different, write to the author 252 | to ask for permission. For software which is copyrighted by the Free 253 | Software Foundation, write to the Free Software Foundation; we sometimes 254 | make exceptions for this. Our decision will be guided by the two goals 255 | of preserving the free status of all derivatives of our free software and 256 | of promoting the sharing and reuse of software generally. 257 | 258 | NO WARRANTY 259 | 260 | 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY 261 | FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN 262 | OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES 263 | PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED 264 | OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 265 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS 266 | TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE 267 | PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, 268 | REPAIR OR CORRECTION. 269 | 270 | 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING 271 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR 272 | REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, 273 | INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING 274 | OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED 275 | TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY 276 | YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER 277 | PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE 278 | POSSIBILITY OF SUCH DAMAGES. 279 | 280 | END OF TERMS AND CONDITIONS 281 | 282 | How to Apply These Terms to Your New Programs 283 | 284 | If you develop a new program, and you want it to be of the greatest 285 | possible use to the public, the best way to achieve this is to make it 286 | free software which everyone can redistribute and change under these terms. 287 | 288 | To do so, attach the following notices to the program. It is safest 289 | to attach them to the start of each source file to most effectively 290 | convey the exclusion of warranty; and each file should have at least 291 | the "copyright" line and a pointer to where the full notice is found. 292 | 293 | {description} 294 | Copyright (C) {year} {fullname} 295 | 296 | This program is free software; you can redistribute it and/or modify 297 | it under the terms of the GNU General Public License as published by 298 | the Free Software Foundation; either version 2 of the License, or 299 | (at your option) any later version. 300 | 301 | This program is distributed in the hope that it will be useful, 302 | but WITHOUT ANY WARRANTY; without even the implied warranty of 303 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 304 | GNU General Public License for more details. 305 | 306 | You should have received a copy of the GNU General Public License along 307 | with this program; if not, write to the Free Software Foundation, Inc., 308 | 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 309 | 310 | Also add information on how to contact you by electronic and paper mail. 311 | 312 | If the program is interactive, make it output a short notice like this 313 | when it starts in an interactive mode: 314 | 315 | Gnomovision version 69, Copyright (C) year name of author 316 | Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. 317 | This is free software, and you are welcome to redistribute it 318 | under certain conditions; type `show c' for details. 319 | 320 | The hypothetical commands `show w' and `show c' should show the appropriate 321 | parts of the General Public License. Of course, the commands you use may 322 | be called something other than `show w' and `show c'; they could even be 323 | mouse-clicks or menu items--whatever suits your program. 324 | 325 | You should also get your employer (if you work as a programmer) or your 326 | school, if any, to sign a "copyright disclaimer" for the program, if 327 | necessary. Here is a sample; alter the names: 328 | 329 | Yoyodyne, Inc., hereby disclaims all copyright interest in the program 330 | `Gnomovision' (which makes passes at compilers) written by James Hacker. 331 | 332 | {signature of Ty Coon}, 1 April 1989 333 | Ty Coon, President of Vice 334 | 335 | This General Public License does not permit incorporating your program into 336 | proprietary programs. If your program is a subroutine library, you may 337 | consider it more useful to permit linking proprietary applications with the 338 | library. If this is what you want to do, use the GNU Lesser General 339 | Public License instead of this License. 340 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | [![GitHub license](https://img.shields.io/badge/license-GPLv2-blue.svg)](https://raw.githubusercontent.com/jrfnl/PHP-cast-to-type/main/LICENSE.md) 2 | [![CS](https://github.com/jrfnl/PHP-cast-to-type/actions/workflows/cs.yml/badge.svg)](https://github.com/jrfnl/PHP-cast-to-type/actions/workflows/cs.yml) 3 | [![Lint](https://github.com/jrfnl/PHP-cast-to-type/actions/workflows/lint.yml/badge.svg)](https://github.com/jrfnl/PHP-cast-to-type/actions/workflows/lint.yml) 4 | 5 | PHP-cast-to-type 6 | ================ 7 | 8 | PHP Class to consistently cast variables to a specific type. 9 | 10 | Returns either the value in the specified type or `null`. 11 | 12 | ### Features: 13 | - Consistent results across PHP versions. 14 | - Compatible with PHP4, PHP5 and PHP7 which makes it extra useful if you're coding for open source software where you don't know the library user's PHP version and the `filter_var()` functions may not be available. 15 | - Optionally recursively cast all values in an array to the choosen type (similar to `filter_var_array()` behaviour). 16 | - Optionally allow/disallow empty strings/arrays. 17 | - Will succesfully cast any of the following string values to their boolean counterpart (similar to `filter_var()` behaviour, but less case-sensitive). 18 | * True: `'1', 'true', 'True', 'TRUE', 'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON'`. 19 | * False: `'0', 'false', 'False', 'FALSE', 'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'`. 20 | - Support for casting of `SplType` objects. 21 | 22 | 23 | ### Some Usage examples: 24 | 25 | ```php 26 | $value = 'example'; 27 | $value = CastToType::_bool( $value ); // null 28 | 29 | $value = 'true'; 30 | $value = CastToType::_bool( $value ); // true 31 | 32 | $value = '123'; 33 | $value = CastToType::_int( $value ); // 123 34 | 35 | $value = array( '123' ); 36 | $value = CastToType::_int( $value ); // null 37 | $value = CastToType::_int( $value, $array2null = false ); // array( 123 ) 38 | ``` 39 | 40 | ### Available methods: 41 | 42 | All methods are static. 43 | 44 | - `CastToType::cast( $value, $type, $array2null = true, $allow_empty = true, $implode_array = false );` 45 | 46 | - `CastToType::_bool( $value, $array2null = true, $allow_empty = true );` 47 | - `CastToType::_int( $value, $array2null = true, $allow_empty = true );` 48 | - `CastToType::_float( $value, $array2null = true, $allow_empty = true );` 49 | - `CastToType::_string( $value, $array2null = true, $allow_empty = true );` 50 | - `CastToType::_array( $value, $allow_empty = true );` 51 | - `CastToType::_object( $value, $allow_empty = true );` 52 | - `CastToType::_null( $value );` 53 | 54 | #### Parameters: 55 | 56 | Param | Type | Description 57 | ----- | ---- | ----------- 58 | `$value` | mixed | Value to cast. 59 | `$type` | string | Type to cast to. Valid values: `'bool'`, `'boolean'`, `'int'`, `'integer'`, `'float'`, `'double'`, `'num'`, `'string'`, `'array'`, `'object'`. 60 | `$array2null` | bool | Optional. Whether to return `null` for arrays when casting to bool, int, float, num or string. If false, the individual values held in the array will recursively be cast to the specified type. Defaults to `true`. 61 | `$allow_empty` | bool | Optional. Whether to allow empty strings, empty arrays, empty objects. If false, `null` will be returned instead of the empty string/array/object. Defaults to `true`. 62 | 63 | 64 | ### Installation 65 | 66 | #### Requirements 67 | 68 | This package requires the PHP native [`ctype`](https://www.php.net/book.ctype) extension. 69 | 70 | #### Stand-alone 71 | 72 | 1. Head to the [Releases](https://github.com/jrfnl/PHP-cast-to-type/releases) page and download the latest release zip. 73 | 2. Extract the files and place them somewhere in your project hierarchy. 74 | 3. Require the class loader using `require_once '/path/to/cast-to-type.php';`. 75 | 76 | #### Composer 77 | 78 | If you are using PHP5+ (as you should), PHP-Cast-to_Type is also available as a [package](https://packagist.org/packages/jrfnl/PHP-cast-to-type) installable via Composer: 79 | 80 | ```sh 81 | composer require jrfnl/PHP-cast-to-type 82 | ``` 83 | 84 | 85 | ### Changelog: 86 | 87 | #### 2.1.0 (Nov 2022) 88 | * Allow for `double` as an alias for `float` in the `CastToType::cast()` method. Thanks [@nsrosenqvist] for the contribution. 89 | * Bug fix: string `ON` not recognized as truthy when casting to boolean. 90 | * The requirement for the `ctype` extension has been made explicit. 91 | * The primary branch has been renamed from `master` to `main`. 92 | * General housekeeping. 93 | 94 | #### 2.0.1 (Jan 2018) 95 | * Bugfix for PHP cross-version compatibility. This affected use of this class on PHP < 5.2.7. 96 | * General housekeeping. 97 | 98 | #### 2.0 (Jun 2015) 99 | * Updated the object casting to be in line with the way this is done in PHP7 for cross-version compatibility. 100 | Previously arrays with numerical keys cast to objects would be added to the object as a property called `array` with the value being the complete array. Now - as in PHP7 - each numerical array key will be cast to an individual property. 101 | This breaks backward-compatibility with v1.0 for array to object cast results, so please review your code if you relied on the old behaviour. 102 | * Fixed a bug in the object casting which would return `null` for non-objects cast to objects in PHP <= 5.1. 103 | * Fixed a bug in the object casting where an empty string would not return `null` while `$allow_empty` was set to `false`. 104 | 105 | #### 1.0 (2006 / Sept 2013) 106 | * Initial release. 107 | 108 | 109 | [@nsrosenqvist]: https://github.com/nsrosenqvist 110 | -------------------------------------------------------------------------------- /cast-to-type.php: -------------------------------------------------------------------------------- 1 | 16 | * @copyright (c) 2006-2022, Advies en zo, Meedenken en -doen All rights reserved. 17 | * @license http://www.opensource.org/licenses/lgpl-license.php GNU Lesser General Public License. 18 | * @since 1.0 19 | */ 20 | 21 | if ( version_compare( phpversion(), '5.0.0', '>=' ) ) { 22 | include dirname( __FILE__ ) . '/class.cast-to-type.php'; 23 | } 24 | else { 25 | include dirname( __FILE__ ) . '/class.cast-to-type-php4.php'; 26 | } 27 | -------------------------------------------------------------------------------- /class.cast-to-type-php4.php: -------------------------------------------------------------------------------- 1 | 23 | * @copyright (c) 2006-2022, Advies en zo, Meedenken en -doen All rights reserved. 24 | * @license http://www.opensource.org/licenses/lgpl-license.php GNU Lesser General Public License. 25 | * @since 1.0 26 | */ 27 | 28 | if ( ! class_exists( 'CastToType' ) ) { 29 | 30 | /** 31 | * CastToType 32 | * 33 | * @package CastToType 34 | * @version 2.1.0 35 | * @link https://github.com/jrfnl/PHP-cast-to-type 36 | * @author Juliette Reinders Folmer, {@link http://www.adviesenzo.nl/ Advies en zo} - 37 | * 38 | * @copyright (c) 2006-2022, Advies en zo, Meedenken en -doen 39 | * All rights reserved. 40 | * @license http://www.opensource.org/licenses/lgpl-license.php GNU Lesser General Public License. 41 | */ 42 | class CastToType { 43 | 44 | 45 | /** 46 | * Cast a value to specific variable type. 47 | * 48 | * @static 49 | * 50 | * @param mixed $value Value to cast. 51 | * @param string $type Type to cast to. 52 | * @param bool $array2null Optional. Whether to return null for arrays when casting to 53 | * bool, int, float, num or string. 54 | * If false, the individual values held in the array will recursively 55 | * be cast to the specified type. 56 | * Defaults to true. 57 | * @param bool $allow_empty Optional. Whether to allow empty strings, empty arrays, empty objects. 58 | * If false, null will be returned instead of the empty string/array/object. 59 | * Defaults to true. 60 | * 61 | * @return mixed|null 62 | */ 63 | function cast( $value, $type, $array2null = true, $allow_empty = true ) { 64 | 65 | // Have the expected variables been passed ? 66 | if ( isset( $value ) === false || isset( $type ) === false ) { 67 | return null; 68 | } 69 | 70 | $type = strtolower( trim( $type ) ); 71 | $valid_types = array( 72 | 'bool' => 1, 73 | 'boolean' => 1, 74 | 'int' => 1, 75 | 'integer' => 1, 76 | 'double' => 1, 77 | 'float' => 1, 78 | 'num' => 1, 79 | 'string' => 1, 80 | 'array' => 1, 81 | 'object' => 1, 82 | ); 83 | 84 | // Check if the typing passed is valid, if not return NULL. 85 | if ( ! isset( $valid_types[ $type ] ) ) { 86 | return null; 87 | } 88 | 89 | switch ( $type ) { 90 | case 'bool': 91 | case 'boolean': 92 | return CastToType::_bool( $value, $array2null, $allow_empty ); 93 | 94 | case 'integer': 95 | case 'int': 96 | return CastToType::_int( $value, $array2null, $allow_empty ); 97 | 98 | case 'double': 99 | case 'float': 100 | return CastToType::_float( $value, $array2null, $allow_empty ); 101 | 102 | case 'num': 103 | if ( is_numeric( $value ) ) { 104 | $value = ( ( (float) $value != (int) $value ) ? (float) $value : (int) $value ); 105 | } 106 | else { 107 | $value = null; 108 | } 109 | return $value; 110 | 111 | case 'string': 112 | return CastToType::_string( $value, $array2null, $allow_empty ); 113 | 114 | case 'array': 115 | return CastToType::_array( $value, $allow_empty ); 116 | 117 | case 'object': 118 | return CastToType::_object( $value, $allow_empty ); 119 | 120 | case 'null': 121 | default: 122 | return null; 123 | } 124 | } 125 | 126 | 127 | /** 128 | * Cast a value to bool. 129 | * 130 | * @static 131 | * 132 | * @param mixed $value Value to cast. 133 | * @param bool $array2null Optional. Whether to return null for an array or to cast the 134 | * individual values within the array to the chosen type. 135 | * @param bool $allow_empty Optional. Whether to allow empty arrays. Only has effect 136 | * when $array2null = false. 137 | * 138 | * @return bool|array|null 139 | */ 140 | function _bool( $value, $array2null = true, $allow_empty = true ) { 141 | $true = array( 142 | '1', 143 | 'true', 'True', 'TRUE', 144 | 'y', 'Y', 145 | 'yes', 'Yes', 'YES', 146 | 'on', 'On', 'ON', 147 | 148 | ); 149 | $false = array( 150 | '0', 151 | 'false', 'False', 'FALSE', 152 | 'n', 'N', 153 | 'no', 'No', 'NO', 154 | 'off', 'Off', 'OFF', 155 | ); 156 | 157 | if ( is_bool( $value ) ) { 158 | return $value; 159 | } 160 | elseif ( is_int( $value ) && ( $value === 0 || $value === 1 ) ) { 161 | return (bool) $value; 162 | } 163 | elseif ( ( is_float( $value ) && ! is_nan( $value ) ) && ( $value === (float) 0 || $value === (float) 1 ) ) { 164 | return (bool) $value; 165 | } 166 | elseif ( is_string( $value ) ) { 167 | $value = trim( $value ); 168 | if ( in_array( $value, $true, true ) ) { 169 | return true; 170 | } 171 | elseif ( in_array( $value, $false, true ) ) { 172 | return false; 173 | } 174 | else { 175 | return null; 176 | } 177 | } 178 | elseif ( $array2null === false && is_array( $value ) ) { 179 | return CastToType::recurse( $value, '_bool', $allow_empty ); 180 | } 181 | elseif ( is_object( $value ) && get_class( $value ) === 'SplBool' ) { 182 | if ( $value == true ) { 183 | return true; 184 | } 185 | elseif ( $value == false ) { 186 | return false; 187 | } 188 | else { 189 | return null; 190 | } 191 | } 192 | elseif ( is_object( $value ) && get_parent_class( $value ) === 'SplType' ) { 193 | return CastToType::spl_helper( $value, '_bool', $array2null, $allow_empty ); 194 | } 195 | 196 | return null; 197 | } 198 | 199 | 200 | /** 201 | * Cast a value to integer. 202 | * 203 | * @static 204 | * 205 | * @param mixed $value Value to cast. 206 | * @param bool $array2null Optional. Whether to return null for an array or to cast the 207 | * individual values within the array to the chosen type. 208 | * @param bool $allow_empty Optional. Whether to allow empty arrays. Only has effect 209 | * when $array2null = false. 210 | * 211 | * @return int|array|null 212 | */ 213 | function _int( $value, $array2null = true, $allow_empty = true ) { 214 | if ( is_int( $value ) ) { 215 | return $value; 216 | } 217 | elseif ( is_float( $value ) ) { 218 | if ( (int) $value == $value && ! is_nan( $value ) ) { 219 | return (int) $value; 220 | } 221 | else { 222 | return null; 223 | } 224 | } 225 | elseif ( is_string( $value ) ) { 226 | $value = trim( $value ); 227 | if ( $value === '' ) { 228 | return null; 229 | } 230 | elseif ( ctype_digit( $value ) ) { 231 | return (int) $value; 232 | } 233 | elseif ( strpos( $value, '-' ) === 0 && ctype_digit( substr( $value, 1 ) ) ) { 234 | return (int) $value; 235 | } 236 | else { 237 | return null; 238 | } 239 | } 240 | elseif ( $array2null === false && is_array( $value ) ) { 241 | return CastToType::recurse( $value, '_int', $allow_empty ); 242 | } 243 | elseif ( is_object( $value ) && get_class( $value ) === 'SplInt' ) { 244 | if ( (int) $value == $value ) { 245 | return (int) $value; 246 | } 247 | else { 248 | return null; 249 | } 250 | } 251 | elseif ( is_object( $value ) && ( get_class( $value ) === 'SplBool' || get_class( $value ) === 'SplFloat' || get_class( $value ) === 'SplString' ) ) { 252 | return CastToType::spl_helper( $value, '_int', $array2null, $allow_empty ); 253 | } 254 | 255 | return null; 256 | } 257 | 258 | 259 | /** 260 | * Cast a value to float. 261 | * 262 | * @static 263 | * 264 | * @param mixed $value Value to cast. 265 | * @param bool $array2null Optional. Whether to return null for an array or to cast the 266 | * individual values within the array to the chosen type. 267 | * @param bool $allow_empty Optional. Whether to allow empty arrays. Only has effect 268 | * when $array2null = false. 269 | * 270 | * @return float|array|null 271 | */ 272 | function _float( $value, $array2null = true, $allow_empty = true ) { 273 | if ( is_float( $value ) ) { 274 | return $value; 275 | } 276 | elseif ( $array2null === false && is_array( $value ) ) { 277 | return CastToType::recurse( $value, '_float', $allow_empty ); 278 | } 279 | elseif ( is_scalar( $value ) && ( is_numeric( trim( $value ) ) && ( floatval( $value ) == trim( $value ) ) ) ) { 280 | return floatval( $value ); 281 | } 282 | elseif ( is_object( $value ) && get_class( $value ) === 'SplFloat' ) { 283 | if ( (float) $value == $value ) { 284 | return (float) $value; 285 | } 286 | else { 287 | return null; 288 | } 289 | } 290 | elseif ( is_object( $value ) && ( get_class( $value ) === 'SplBool' || get_class( $value ) === 'SplInt' || get_class( $value ) === 'SplString' ) ) { 291 | return CastToType::spl_helper( $value, '_float', $array2null, $allow_empty ); 292 | } 293 | 294 | return null; 295 | } 296 | 297 | 298 | /** 299 | * Cast a value to string. 300 | * 301 | * @static 302 | * 303 | * @param mixed $value Value to cast. 304 | * @param bool $array2null Optional. Whether to return null for an array or to cast the 305 | * individual values within the array to the chosen type. 306 | * @param bool $allow_empty Optional. Whether to allow empty strings/arrays/objects. 307 | * 308 | * @return string|array|null 309 | */ 310 | function _string( $value, $array2null = true, $allow_empty = true ) { 311 | if ( is_string( $value ) && ( $value !== '' || $allow_empty === true ) ) { 312 | return $value; 313 | } 314 | elseif ( is_int( $value ) || is_float( $value ) ) { 315 | return strval( $value ); 316 | } 317 | elseif ( $array2null === false && is_array( $value ) ) { 318 | return CastToType::recurse( $value, '_string', $allow_empty ); 319 | } 320 | elseif ( is_object( $value ) && get_parent_class( $value ) === 'SplType' ) { 321 | if ( (string) $value == $value ) { 322 | return (string) $value; 323 | } 324 | else { 325 | return null; 326 | } 327 | } 328 | elseif ( is_object( $value ) && method_exists( $value, '__toString' ) ) { 329 | return (string) $value; 330 | } 331 | return null; 332 | } 333 | 334 | 335 | /** 336 | * Cast a value to array. 337 | * 338 | * @static 339 | * 340 | * @param mixed $value Value to cast. 341 | * @param bool $allow_empty Optional. Whether to allow empty strings/arrays/objects. 342 | * 343 | * @return array|null 344 | */ 345 | function _array( $value, $allow_empty = true ) { 346 | if ( is_array( $value ) !== true ) { 347 | $value = (array) $value; 348 | } 349 | 350 | if ( count( $value ) > 0 || $allow_empty === true ) { 351 | return $value; 352 | } 353 | return null; 354 | } 355 | 356 | 357 | /** 358 | * Cast a value to object. 359 | * 360 | * Please note: in a normal array to object cast pre-PHP7, array values with numerical keys are 'lost'. 361 | * This method checks whether the array contains numerical keys, if it doesn't it will do a 362 | * normal array to object cast. If it does, it will cast each numerically indexes value to a numerical 363 | * property, similar to the behaviour in PHP7. 364 | * 365 | * @static 366 | * 367 | * @param mixed $value Value to cast. 368 | * @param bool $allow_empty Optional. Whether to allow empty strings/arrays/objects. 369 | * 370 | * @return object|null 371 | */ 372 | function _object( $value, $allow_empty = true ) { 373 | if ( $allow_empty === false && ( is_string( $value ) && $value === '' ) ) { 374 | return null; 375 | } 376 | 377 | if ( is_array( $value ) === true ) { 378 | $has_num_keys = false; 379 | foreach ( $value as $k => $v ) { 380 | if ( is_int( $k ) ) { 381 | $has_num_keys = true; 382 | break; 383 | } 384 | } 385 | 386 | if ( $has_num_keys === false ) { 387 | $value = (object) $value; 388 | } 389 | else { 390 | $new_value = new stdClass(); 391 | foreach ( $value as $k => $v ) { 392 | $new_value->$k = $v; 393 | } 394 | $value = $new_value; 395 | unset( $new_value, $k, $v ); 396 | } 397 | } 398 | elseif ( is_object( $value ) !== true ) { 399 | $value = (object) $value; 400 | } 401 | 402 | if ( $allow_empty === false ) { 403 | $methods = get_class_methods( $value ); 404 | $properties = get_object_vars( $value ); 405 | if ( ( is_null( $methods ) || count( $methods ) === 0 ) && ( is_null( $properties ) || count( $properties ) === 0 ) ) { 406 | // No methods or properties found. 407 | $value = null; 408 | } 409 | } 410 | 411 | return $value; 412 | } 413 | 414 | 415 | /** 416 | * Cast a value to null (for completeness). 417 | * 418 | * @static 419 | * 420 | * @return null 421 | */ 422 | function _null() { 423 | return null; 424 | } 425 | 426 | 427 | /** 428 | * Recurse through an array. 429 | * 430 | * @static 431 | * @internal 432 | * 433 | * @param array $value Array holding values to cast. 434 | * @param string $method Calling method, i.e. cast to which type of variable. 435 | * Can only be _bool, _int, _float or _string. 436 | * @param bool $allow_empty Optional. Whether to allow empty arrays in the return. 437 | * 438 | * @return array|null 439 | */ 440 | function recurse( $value, $method, $allow_empty = true ) { 441 | if ( is_array( $value ) ) { 442 | if ( count( $value ) === 0 ) { 443 | if ( $allow_empty === true ) { 444 | return $value; 445 | } 446 | else { 447 | return null; 448 | } 449 | } 450 | else { 451 | foreach ( $value as $k => $v ) { 452 | $value[ $k ] = CastToType::$method( $v, false, $allow_empty ); 453 | } 454 | return $value; 455 | } 456 | } 457 | return null; 458 | } 459 | 460 | 461 | /** 462 | * Cast an SPL object to scalar. 463 | * 464 | * @static 465 | * 466 | * @since 2.0 467 | * 468 | * @param \SplType $value Value to cast. 469 | * @param string $method Calling method, i.e. cast to which type of variable. 470 | * Can only be _bool, _int, _float or _string. 471 | * @param bool $array2null Optional. Whether to return null for an array or to cast the 472 | * individual values within the array to the chosen type. 473 | * @param bool $allow_empty Optional. Whether to allow empty strings/arrays/objects. 474 | * 475 | * @return bool|int|float|string|null 476 | */ 477 | function spl_helper( $value, $method, $array2null = true, $allow_empty = true ) { 478 | switch ( get_class( $value ) ) { 479 | case 'SplBool': 480 | return CastToType::$method( (bool) $value, $array2null, $allow_empty ); 481 | 482 | case 'SplInt': 483 | return CastToType::$method( (int) $value, $array2null, $allow_empty ); 484 | 485 | case 'SplFloat': 486 | return CastToType::$method( (float) $value, $array2null, $allow_empty ); 487 | 488 | case 'SplString': 489 | return CastToType::$method( (string) $value, $array2null, $allow_empty ); 490 | 491 | default: 492 | return null; 493 | } 494 | } 495 | } 496 | 497 | } 498 | -------------------------------------------------------------------------------- /class.cast-to-type.php: -------------------------------------------------------------------------------- 1 | 22 | * @copyright (c) 2006-2022, Advies en zo, Meedenken en -doen All rights reserved. 23 | * @license http://www.opensource.org/licenses/lgpl-license.php GNU Lesser General Public License. 24 | * @since 1.0 25 | */ 26 | 27 | if ( ! class_exists( 'CastToType' ) ) { 28 | 29 | /** 30 | * CastToType 31 | * 32 | * @package CastToType 33 | * @version 2.1.0 34 | * @link https://github.com/jrfnl/PHP-cast-to-type 35 | * @author Juliette Reinders Folmer, {@link http://www.adviesenzo.nl/ Advies en zo} - 36 | * 37 | * @copyright (c) 2006-2022, Advies en zo, Meedenken en -doen 38 | * All rights reserved. 39 | * @license http://www.opensource.org/licenses/lgpl-license.php GNU Lesser General Public License. 40 | */ 41 | class CastToType { 42 | 43 | 44 | /** 45 | * Cast a value to specific variable type. 46 | * 47 | * @static 48 | * 49 | * @param mixed $value Value to cast. 50 | * @param string $type Type to cast to. 51 | * @param bool $array2null Optional. Whether to return null for arrays when casting to 52 | * bool, int, float, num or string. 53 | * If false, the individual values held in the array will recursively 54 | * be cast to the specified type. 55 | * Defaults to true. 56 | * @param bool $allow_empty Optional. Whether to allow empty strings, empty arrays, empty objects. 57 | * If false, null will be returned instead of the empty string/array/object. 58 | * Defaults to true. 59 | * 60 | * @return mixed|null 61 | */ 62 | public static function cast( $value, $type, $array2null = true, $allow_empty = true ) { 63 | 64 | // Have the expected variables been passed ? 65 | if ( isset( $value ) === false || isset( $type ) === false ) { 66 | return null; 67 | } 68 | 69 | $type = strtolower( trim( $type ) ); 70 | $valid_types = array( 71 | 'bool' => 1, 72 | 'boolean' => 1, 73 | 'int' => 1, 74 | 'integer' => 1, 75 | 'double' => 1, 76 | 'float' => 1, 77 | 'num' => 1, 78 | 'string' => 1, 79 | 'array' => 1, 80 | 'object' => 1, 81 | ); 82 | 83 | // Check if the typing passed is valid, if not return NULL. 84 | if ( ! isset( $valid_types[ $type ] ) ) { 85 | return null; 86 | } 87 | 88 | switch ( $type ) { 89 | case 'bool': 90 | case 'boolean': 91 | return self::_bool( $value, $array2null, $allow_empty ); 92 | 93 | case 'integer': 94 | case 'int': 95 | return self::_int( $value, $array2null, $allow_empty ); 96 | 97 | case 'double': 98 | case 'float': 99 | return self::_float( $value, $array2null, $allow_empty ); 100 | 101 | case 'num': 102 | if ( is_numeric( $value ) ) { 103 | $value = ( ( (float) $value != (int) $value ) ? (float) $value : (int) $value ); 104 | } 105 | else { 106 | $value = null; 107 | } 108 | return $value; 109 | 110 | case 'string': 111 | return self::_string( $value, $array2null, $allow_empty ); 112 | 113 | case 'array': 114 | return self::_array( $value, $allow_empty ); 115 | 116 | case 'object': 117 | return self::_object( $value, $allow_empty ); 118 | 119 | case 'null': 120 | default: 121 | return null; 122 | } 123 | } 124 | 125 | 126 | /** 127 | * Cast a value to bool. 128 | * 129 | * @static 130 | * 131 | * @param mixed $value Value to cast. 132 | * @param bool $array2null Optional. Whether to return null for an array or to cast the 133 | * individual values within the array to the chosen type. 134 | * @param bool $allow_empty Optional. Whether to allow empty arrays. Only has effect 135 | * when $array2null = false. 136 | * 137 | * @return bool|array|null 138 | */ 139 | public static function _bool( $value, $array2null = true, $allow_empty = true ) { 140 | $true = array( 141 | '1', 142 | 'true', 'True', 'TRUE', 143 | 'y', 'Y', 144 | 'yes', 'Yes', 'YES', 145 | 'on', 'On', 'ON', 146 | 147 | ); 148 | $false = array( 149 | '0', 150 | 'false', 'False', 'FALSE', 151 | 'n', 'N', 152 | 'no', 'No', 'NO', 153 | 'off', 'Off', 'OFF', 154 | ); 155 | 156 | if ( is_bool( $value ) ) { 157 | return $value; 158 | } 159 | elseif ( is_int( $value ) && ( $value === 0 || $value === 1 ) ) { 160 | return (bool) $value; 161 | } 162 | elseif ( ( is_float( $value ) && ! is_nan( $value ) ) && ( $value === (float) 0 || $value === (float) 1 ) ) { 163 | return (bool) $value; 164 | } 165 | elseif ( is_string( $value ) ) { 166 | $value = trim( $value ); 167 | if ( in_array( $value, $true, true ) ) { 168 | return true; 169 | } 170 | elseif ( in_array( $value, $false, true ) ) { 171 | return false; 172 | } 173 | else { 174 | return null; 175 | } 176 | } 177 | elseif ( $array2null === false && is_array( $value ) ) { 178 | return self::recurse( $value, '_bool', $allow_empty ); 179 | } 180 | elseif ( is_object( $value ) && get_class( $value ) === 'SplBool' ) { 181 | if ( $value == true ) { 182 | return true; 183 | } 184 | elseif ( $value == false ) { 185 | return false; 186 | } 187 | else { 188 | return null; 189 | } 190 | } 191 | elseif ( is_object( $value ) && get_parent_class( $value ) === 'SplType' ) { 192 | return self::spl_helper( $value, '_bool', $array2null, $allow_empty ); 193 | } 194 | 195 | return null; 196 | } 197 | 198 | 199 | /** 200 | * Cast a value to integer. 201 | * 202 | * @static 203 | * 204 | * @param mixed $value Value to cast. 205 | * @param bool $array2null Optional. Whether to return null for an array or to cast the 206 | * individual values within the array to the chosen type. 207 | * @param bool $allow_empty Optional. Whether to allow empty arrays. Only has effect 208 | * when $array2null = false. 209 | * 210 | * @return int|array|null 211 | */ 212 | public static function _int( $value, $array2null = true, $allow_empty = true ) { 213 | if ( is_int( $value ) ) { 214 | return $value; 215 | } 216 | elseif ( is_float( $value ) ) { 217 | if ( (int) $value == $value && ! is_nan( $value ) ) { 218 | return (int) $value; 219 | } 220 | else { 221 | return null; 222 | } 223 | } 224 | elseif ( is_string( $value ) ) { 225 | $value = trim( $value ); 226 | if ( $value === '' ) { 227 | return null; 228 | } 229 | elseif ( ctype_digit( $value ) ) { 230 | return (int) $value; 231 | } 232 | elseif ( strpos( $value, '-' ) === 0 && ctype_digit( substr( $value, 1 ) ) ) { 233 | return (int) $value; 234 | } 235 | else { 236 | return null; 237 | } 238 | } 239 | elseif ( $array2null === false && is_array( $value ) ) { 240 | return self::recurse( $value, '_int', $allow_empty ); 241 | } 242 | elseif ( is_object( $value ) && get_class( $value ) === 'SplInt' ) { 243 | if ( (int) $value == $value ) { 244 | return (int) $value; 245 | } 246 | else { 247 | return null; 248 | } 249 | } 250 | elseif ( is_object( $value ) && ( get_class( $value ) === 'SplBool' || get_class( $value ) === 'SplFloat' || get_class( $value ) === 'SplString' ) ) { 251 | return self::spl_helper( $value, '_int', $array2null, $allow_empty ); 252 | } 253 | 254 | return null; 255 | } 256 | 257 | 258 | /** 259 | * Cast a value to float. 260 | * 261 | * @static 262 | * 263 | * @param mixed $value Value to cast. 264 | * @param bool $array2null Optional. Whether to return null for an array or to cast the 265 | * individual values within the array to the chosen type. 266 | * @param bool $allow_empty Optional. Whether to allow empty arrays. Only has effect 267 | * when $array2null = false. 268 | * 269 | * @return float|array|null 270 | */ 271 | public static function _float( $value, $array2null = true, $allow_empty = true ) { 272 | if ( is_float( $value ) ) { 273 | return $value; 274 | } 275 | elseif ( $array2null === false && is_array( $value ) ) { 276 | return self::recurse( $value, '_float', $allow_empty ); 277 | } 278 | elseif ( is_scalar( $value ) && ( is_numeric( trim( $value ) ) && ( floatval( $value ) == trim( $value ) ) ) ) { 279 | return floatval( $value ); 280 | } 281 | elseif ( is_object( $value ) && get_class( $value ) === 'SplFloat' ) { 282 | if ( (float) $value == $value ) { 283 | return (float) $value; 284 | } 285 | else { 286 | return null; 287 | } 288 | } 289 | elseif ( is_object( $value ) && ( get_class( $value ) === 'SplBool' || get_class( $value ) === 'SplInt' || get_class( $value ) === 'SplString' ) ) { 290 | return self::spl_helper( $value, '_float', $array2null, $allow_empty ); 291 | } 292 | 293 | return null; 294 | } 295 | 296 | 297 | /** 298 | * Cast a value to string. 299 | * 300 | * @static 301 | * 302 | * @param mixed $value Value to cast. 303 | * @param bool $array2null Optional. Whether to return null for an array or to cast the 304 | * individual values within the array to the chosen type. 305 | * @param bool $allow_empty Optional. Whether to allow empty strings/arrays/objects. 306 | * 307 | * @return string|array|null 308 | */ 309 | public static function _string( $value, $array2null = true, $allow_empty = true ) { 310 | if ( is_string( $value ) && ( $value !== '' || $allow_empty === true ) ) { 311 | return $value; 312 | } 313 | elseif ( is_int( $value ) || is_float( $value ) ) { 314 | return strval( $value ); 315 | } 316 | elseif ( $array2null === false && is_array( $value ) ) { 317 | return self::recurse( $value, '_string', $allow_empty ); 318 | } 319 | elseif ( is_object( $value ) && get_parent_class( $value ) === 'SplType' ) { 320 | if ( (string) $value == $value ) { 321 | return (string) $value; 322 | } 323 | else { 324 | return null; 325 | } 326 | } 327 | elseif ( is_object( $value ) && method_exists( $value, '__toString' ) ) { 328 | return (string) $value; 329 | } 330 | return null; 331 | } 332 | 333 | 334 | /** 335 | * Cast a value to array. 336 | * 337 | * @static 338 | * 339 | * @param mixed $value Value to cast. 340 | * @param bool $allow_empty Optional. Whether to allow empty strings/arrays/objects. 341 | * 342 | * @return array|null 343 | */ 344 | public static function _array( $value, $allow_empty = true ) { 345 | try { 346 | if ( is_array( $value ) !== true ) { 347 | settype( $value, 'array' ); 348 | } 349 | 350 | if ( count( $value ) > 0 || $allow_empty === true ) { 351 | return $value; 352 | } 353 | return null; 354 | } 355 | catch ( Exception $e ) { 356 | // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_trigger_error 357 | trigger_error( $e->getMessage(), E_USER_WARNING ); 358 | } 359 | } 360 | 361 | 362 | /** 363 | * Cast a value to object. 364 | * 365 | * Please note: in a normal array to object cast pre-PHP7, array values with numerical keys are 'lost'. 366 | * This method checks whether the array contains numerical keys, if it doesn't it will do a 367 | * normal array to object cast. If it does, it will cast each numerically indexes value to a numerical 368 | * property, similar to the behaviour in PHP7. 369 | * 370 | * @static 371 | * 372 | * @param mixed $value Value to cast. 373 | * @param bool $allow_empty Optional. Whether to allow empty strings/arrays/objects. 374 | * 375 | * @return object|null 376 | */ 377 | public static function _object( $value, $allow_empty = true ) { 378 | if ( $allow_empty === false && ( is_string( $value ) && $value === '' ) ) { 379 | return null; 380 | } 381 | 382 | if ( is_array( $value ) === true ) { 383 | $has_num_keys = false; 384 | foreach ( $value as $k => $v ) { 385 | if ( is_int( $k ) ) { 386 | $has_num_keys = true; 387 | break; 388 | } 389 | } 390 | 391 | if ( $has_num_keys === false ) { 392 | $value = (object) $value; 393 | } 394 | else { 395 | $new_value = new stdClass(); 396 | foreach ( $value as $k => $v ) { 397 | $new_value->$k = $v; 398 | } 399 | $value = $new_value; 400 | unset( $new_value, $k, $v ); 401 | } 402 | } 403 | elseif ( is_object( $value ) !== true ) { 404 | $value = (object) $value; 405 | } 406 | 407 | if ( $allow_empty === false ) { 408 | if ( version_compare( phpversion(), '5.2.0', '>=' ) && class_exists( 'ReflectionObject' ) ) { 409 | $obj = new ReflectionObject( $value ); 410 | if ( ( count( $obj->getMethods() ) + count( $obj->getProperties() ) + count( $obj->getConstants() ) ) === 0 ) { 411 | // No methods, properties or constants found. 412 | $value = null; 413 | } 414 | } 415 | else { 416 | // PHP <= 5.1. 417 | $methods = get_class_methods( $value ); 418 | $properties = get_object_vars( $value ); 419 | if ( ( is_null( $methods ) || count( $methods ) === 0 ) && ( is_null( $properties ) || count( $properties ) === 0 ) ) { 420 | // No methods or properties found. 421 | $value = null; 422 | } 423 | } 424 | } 425 | 426 | return $value; 427 | } 428 | 429 | 430 | /** 431 | * Cast a value to null (for completeness). 432 | * 433 | * @static 434 | * 435 | * @return null 436 | */ 437 | public static function _null() { 438 | return null; 439 | } 440 | 441 | 442 | /** 443 | * Recurse through an array. 444 | * 445 | * @static 446 | * @internal 447 | * 448 | * @param array $value Array holding values to cast. 449 | * @param string $method Calling method, i.e. cast to which type of variable. 450 | * Can only be _bool, _int, _float or _string. 451 | * @param bool $allow_empty Optional. Whether to allow empty arrays in the return. 452 | * 453 | * @return array|null 454 | */ 455 | public static function recurse( $value, $method, $allow_empty = true ) { 456 | if ( is_array( $value ) ) { 457 | if ( count( $value ) === 0 ) { 458 | if ( $allow_empty === true ) { 459 | return $value; 460 | } 461 | else { 462 | return null; 463 | } 464 | } 465 | else { 466 | foreach ( $value as $k => $v ) { 467 | $value[ $k ] = self::$method( $v, false, $allow_empty ); 468 | } 469 | return $value; 470 | } 471 | } 472 | return null; 473 | } 474 | 475 | 476 | /** 477 | * Cast an SPL object to scalar. 478 | * 479 | * @static 480 | * 481 | * @since 2.0 482 | * 483 | * @param \SplType $value Value to cast. 484 | * @param string $method Calling method, i.e. cast to which type of variable. 485 | * Can only be _bool, _int, _float or _string. 486 | * @param bool $array2null Optional. Whether to return null for an array or to cast the 487 | * individual values within the array to the chosen type. 488 | * @param bool $allow_empty Optional. Whether to allow empty strings/arrays/objects. 489 | * 490 | * @return bool|int|float|string|null 491 | */ 492 | public static function spl_helper( $value, $method, $array2null = true, $allow_empty = true ) { 493 | switch ( get_class( $value ) ) { 494 | case 'SplBool': 495 | return self::$method( (bool) $value, $array2null, $allow_empty ); 496 | 497 | case 'SplInt': 498 | return self::$method( (int) $value, $array2null, $allow_empty ); 499 | 500 | case 'SplFloat': 501 | return self::$method( (float) $value, $array2null, $allow_empty ); 502 | 503 | case 'SplString': 504 | return self::$method( (string) $value, $array2null, $allow_empty ); 505 | 506 | default: 507 | return null; 508 | } 509 | } 510 | } 511 | 512 | } 513 | -------------------------------------------------------------------------------- /composer.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "jrfnl/php-cast-to-type", 3 | "description": "PHP Class to consistently cast variables to a specific type.", 4 | "homepage": "https://github.com/jrfnl/PHP-cast-to-type", 5 | "keywords": ["type casting","type juggling", "cross version"], 6 | "license": "GPL-2.0-or-later", 7 | "authors": [ 8 | { 9 | "name": "Juliette Reinders Folmer", 10 | "homepage": "https://github.com/jrfnl", 11 | "role": "Developer" 12 | } 13 | ], 14 | "support": { 15 | "issues": "https://github.com/jrfnl/PHP-cast-to-type/issues", 16 | "source": "https://github.com/jrfnl/PHP-cast-to-type" 17 | }, 18 | "require": { 19 | "php": ">=5.0", 20 | "ext-ctype": "*" 21 | }, 22 | "require-dev" : { 23 | "phpcompatibility/php-compatibility": "^9.3.0", 24 | "wp-coding-standards/wpcs": "^3.0.0", 25 | "php-parallel-lint/php-parallel-lint": "^1.3.2", 26 | "php-parallel-lint/php-console-highlighter": "^1.0.0" 27 | }, 28 | "autoload": { 29 | "files": ["class.cast-to-type.php"] 30 | }, 31 | "config": { 32 | "allow-plugins": { 33 | "dealerdirect/phpcodesniffer-composer-installer": true 34 | } 35 | }, 36 | "scripts": { 37 | "lint": [ 38 | "@php ./vendor/php-parallel-lint/php-parallel-lint/parallel-lint . --show-deprecated -e php --exclude vendor --exclude .git" 39 | ], 40 | "checkcs": [ 41 | "@php ./vendor/squizlabs/php_codesniffer/bin/phpcs" 42 | ], 43 | "fixcs": [ 44 | "@php ./vendor/squizlabs/php_codesniffer/bin/phpcbf" 45 | ] 46 | } 47 | } 48 | --------------------------------------------------------------------------------