Most of the code chunks I’ve seen about getting a file extension from a string are based on some sort of string manipulation.
$filename = '/my/path/image.jpeg'; echo substr($filename, strrpos($filename, '.') + 1); |
Howerver there is a more elegant solution.
$filename = '/my/path/image.jpeg'; echo strtolower(pathinfo($filename, PATHINFO_EXTENSION)); |
Thus you rely on PHP built in functions and it’s harder to overlook the exact string manipulation approach.
As you know in JavaScript when you define a variable with the special word “var” the scope of this variable is within the function. So when you simply wite “var a = 5” the variable named “a” has a global scope and can be accessed in any function in the global scope.
var a = 5; function f() { return a; } // returns 5 |
Thus f will return the value of “a” which equals to 5. You can also change the value of the global variable in the function body.
var a = 5; function f() { a = 10; return a; } console.log(a); // equals to 10 |
Now after we call the function f the value of “a” will equal to 10. This is because we reference the global variable “a” into the function body without using the keyword “var”. This means that if you put the “var” keyword the variable “a” inside the function body is no longer the same variable as the variable defined outside the body. It becames “local” and it’s visible only inside the function.
Continue reading OOP JavaScript: Accessing Public Methods in Private Methods
You should know that in JavaScript you cannot simply write a multilined code chunk, i.e. something like this:
var str = 'hello world'; |
This will result in an error, which can be a problem when you deal with large strings. Imagine a string containing some HTML that should be injected via innerHTML. Now one possible solution is to concatenate two or more strings, by splitting the initial string.
var str = 'hello' + 'world'; |
Howerver this solution result in some additional operations like concatenation. It can be very nice if there was something like the PHP multiline string format.
In PHP you have the same use case with strings. You can have a string concatenated over multiple lines, but you cannot split lines like so:
// the following line is wrong $str = 'hello world'; // a possible solution to the line above is $str = 'hello' . 'world'; // which is very similar to the js solution in the second example // ... but in PHP there is the so called HEREDOC $str = <<<EOD hello world EOD; |
The heredoc gives us the power to write multiline strings.
Actually in JavaScript there is something that’s exactly what Heredoc is meant to be for PHP. Take a look at the last example:
var text = <> this <br /> is my multi-line text </>.toString(); document.body.innerHTML = text; |
Thus you can write multiline strings in the JavaScript code.
JavaScript, being a functional language, differs from most of the procedural/object oriented languages we know. The object oriented approach in JavaScript is rather strange. However there is much power in making objects! The syntax is really odd and there are several approaches.
As many of you may know the most used notation is the JSON (JavaScript Object Notation).
{ 'key1' : 'val1' , 'key2' : 'val2' , 'key3' : 'val3' } |
Of course this is the very basic example. You can use as value any JavaScript object – another similar object or a function.
{ 'key1' : 'val1' , 'key2' : { 'inner_key1' : 'inner_val1' } , 'key3' : function() { return 10 + 5; } } |
The two examples above are showing an anonymous object in JavaScript, but you can assign this code to some variable.
var myObject = { 'key1' : 'val1' , 'key2' : 'val2' , 'key3' : 'val3' } |
or
var myObject = { 'key1' : 'val1' , 'key2' : { 'inner_key1' : 'inner_val1' } , 'key3' : function() { return 10 + 5; } } |
and then you can call the properties of these objects with the ‘.’ operator:
myObject.key1; myObject.key2.inner_key1; myObject.key3(); |
So far so good – this is the literal object notation in JavaScript. However there is another “objects” in JavaScript.
Continue reading Object Oriented JavaScript: Inheritance
It’s a well know fact that you can preform HTTP requests with CURL. Zend Framework does the same job with Zend_Http. Especially Zend_Http_Client can be used to “replace” the usual client – the browser, and to perform some basic requests.
I’ve seen mostly GET requests, although Zend_Http_Client can perform various requests such as POST as well.
// new HTTP request to some HTTP address $httpClient = new Zend_Http_Client('http://www.example.com/'); // GET the response $response = $httpClient->request(Zend_Http_Client::GET); |
Here’s a little snippet showing how to POST some data to a server.
// new HTTP request to some HTTP address $client = new Zend_Http_Client('http://www.example.com/'); // set some parameters $client->setParameterPost('name', 'value'); // POST request $response = $client->request(Zend_Http_Client::POST); |
Note that the request method returns a response. Thus if you are simulating a form submit action you can “redirect” to the desired page just like the form.
// new HTTP request to some HTTP address $client = new Zend_Http_Client('http://www.example.com/'); // set some parameters $client->setParameterPost('name', 'value'); // POST request $response = $client->request(Zend_Http_Client::POST); echo $response->location; |