How to avoid confusing when using scripting language?

I used to write a very strong type language, for example, java. I need to tell the complier what type of variable I w开发者_开发百科ill put in... for example...

 public static void sayHello(String aName)

I can ensure that the user will pass a string to me... But if I use php, I can do that...

 function sayHello($aName)

I still can call the sayHello, but I don't know what the param type......I can let the name more informative like this:

 function sayHelloWithString($aName)

But I can't stop the user pass in a int to me..... the user can still pass the int to me... ...it may cause lot of errors....How can I stop it? any ideas or experience shared? Thank you.

How about not stopping the user from passing in an int?

In php, you could check is_string, but of course, you'll miss out on objects that have __toString set, or the implicit conversion of numbers to strings.

If you must make your program cry in pain when a developer tries something different, you could specify a type in the later versions of PHP (i.e. function foo(ObjectType $bar)...)*

In most loosely typed languages, you want to set up fall-backs for the major types:

• number
• array
• string
• generic object

Be liberal in what you accept, be strict in what you send.

* Primitive types are not supported for type hinting

There's a few ways to deal with this...

1. Use an IDE that supports docblocks. This deals with the pre-runtime type checking when writing code.
2. Use type checking within your function This only helps with the runtime type checking, and you won't know when writing your code.
3. Depending on the type you can use built-in type hinting. This however only works for non-scalar values, specifically array and a class name.

1 - To implement #1 using a good IDE, you can docblock your function as such:

/**
 * Say hello to someone.
 *
 * @param string $aName
 **/
public function sayHello($aName) {

2 - To implement #2 use the is_ methods..

public function sayHello($aName) {
    if (!is_string($aName)) {
        throw new ArgumentException("Type not correct.");
    }
    // Normal execution

3 - You can't do this with your method above, but something like this.. Kindof the same as #2 apart from will throw a catchable fatal error rather than ArgumentException.

public function manipulateArray(array $anArray) {

It's worth noting that most of this is pretty irrelevant unless you're writing publicly usable library code.. You should know what your methods accept, and if you're trying to write good quality code in the first place, you should be checking this before hand.

Using a good IDE (I recommend phpStorm a thousand times over) you can and should utilise DocBlocks everywhere you can for all of your classes. Not only will it help when writing APIs and normal code, but you can use it to document your code, what if you need to look at the code 6 months later, chances are you're not going to remember it 100% :-)

Additionally, there's a lot more you can do with docblocks than just define parameter types, look it up.

You can check if what they passed is a string using: http://php.net/manual/en/function.is-string.php

Then provide appropriate error handling.

function sayHello($aName) {
  if (is_string($aName)) {
    //string OK!
  } else {
    echo "sayHello() only takes strings!";
  }
}

In PHP you can check whether the variable that has been passes is a string by using the is_string function:

 <?php 
 if (is_string($aName)) {
     echo "Yes";
 } else {
     echo "No";
 }
 ?>

Hope that helps.

Or alternatively /additionally use Type Casting to convert the variable to the required type

http://us3.php.net/manual/en/language.types.type-juggling.php

You have the option of checking to make sure the parameter is of the right type. However, it's worth considering what you'd do if it isn't. If you're just going to throw an exception, you might be better off just assuming it's the right type and the the exception be thrown when something you do isn't allowed. If you're not going to add any more useful information to the exception/error that would already be thrown, then there's not much point in checking it in the first place.

As to giving the user an indication of what type you want, I generally stick with including it in the variable name:

function sayHello($aNameStr)
function addItems($itemList)
...etc...

That, plus reasonable documentation, will mean the user can look at the function and figure out what they should be passing in in the first place.

Some scripting languages have tools that can help you. For example use strict in perl requires declaration of each variable before using. But still the language is weakly typed by definition.

Sometimes naming conventions help. For example we inherited from good old Fortran tradition that int variables' names should start from i, j, k, l, m, n. And this convention is used now at least for indexes.