DEV Community: Megan Miller

PHP For JavaScript Developers

Megan Miller — Fri, 01 May 2020 21:06:50 +0000

I started learning how to code in 2012 with HTML and CSS. Ever since the start of my coding journey, PHP has been one of the languages I’ve always wanted to learn. It’s everywhere. However, looking at it back in 2012, a freshly graduated high school student; I felt completely out of my depth. You can find out more about my journey here if you’re curious.

As a recent JavaScript-focused bootcamp grad, I’ve decided that I want to try to learn PHP again. It has been pretty difficult to find resources about PHP that aren’t focused on people who have never touched a line of code before. So, that’s why I’m writing this. I want to be able to help other people like me who just need a quick guide to the differences between their chosen language and the language they want to pick up.

General Syntax

One of the biggest differences between PHP’s syntax and JavaScript’s is that semicolons are required at the end of lines in PHP. I struggled with this a lot at first—still do sometimes—so that’s why I wanted to note it here first and foremost.

Using The Language

In JavaScript you don’t have to do anything particularly special to be able to run the code beyond making sure your file has a .js extension. However, in PHP you need to use tags, even in a file designated with the .php extension.

<?php 
# code here
?>

Declaring Variables

Creating a variable in PHP is super simple. Much like JavaScript, PHP is a dynamically typed language, and as such you don’t have to declare the type of the variable when you create it. It uses the $ symbol to denote variables.

$myvar = 'value';

By default in PHP any variable you declare is mutable. It can be changed absolutely anywhere.

Declaring Constants

PHP has a special function called define that is used to specifically create variables that can’t be changed. It takes two arguments: the name of the variable, and the value you want to assign to it. By default this function sets the variable name you create to be case sensitive. This can be overridden by passing true as a third argument to the function.

define('CONSTANT_NAME', value, true);

Declaring Arrays

Much like JavaScript arrays can be created with standard bracket notation or with a function in PHP. That said, PHP’s associative array is equivalent to a JavaScript Object, and is the only way to create a collection of key/value pairs in PHP without importing a module of some kind. Assigning a value to a key in PHP is denoted by =>.

$myArray = ['key1' => 'value', 'key2' => 'value', 'key3' => 'value'];

Functions
Functions in PHP are very similar to JavaScript (ES5 specifically).

function myFunc($param) {
    return $param;
}

The only real difference I’ve been able to find between the two languages in this regard is that PHP has an operator that changes the argument you pass in from being value based, to being referential: the &.

$myVar = 10;
echo $myVar; # displays 10

function addTen(&$param) {
    return $param += 10;
}

addTen($myVar);

echo $myVar; # displays 20

Loops

Much like Functions, loops aren’t that much different from the way they’re written in JavaScript. One exception being PHP’s foreach loop which changes based on the type of array you’re trying to loop over.

Normal Array:

foreach($arrayName as $item) {
    # do code
}

Associative array:

foreach($myArray as $key => $value) {
    # do code
}

Classes & OOP Methodology

Classes are one place where PHP differs from JavaScript quite heavily. Though PHP didn’t start out as an Object Oriented Programming Language—similarly to JavaScript—the functionality was added in later.

Access Modifier Keywords
In standard JS, modifier keywords aren’t needed for classes. For PHP, however, they are.

The Modifiers that you have in PHP are:

public - This can be used outside the class, either by a script or another class.
private - The class that created this is the only one that can access it.
protected - This can only be accessed outside of the class if it is being called in a class that is a child of the class this belongs to.
static - Allows the use of a property or method without the class that property or method is a part of having to be instantiated.

When creating a class in PHP it’s best practice to utilize these keywords to tell the class what it needs to do with attributes and methods on the class.

class MyClass {
    private $classAttrib;
    public function __construct($classAttrib) {
        this->classAttrib = $classAttrib;
    }
}

You’ll notice a few things in the above the code snippet. The first will probably be the two modifier keywords. Here, we’re declaring a private variable called classAttrib which will only be accessible via MyClass. The second, is the public keyword which we’re using in conjunction with PHP’s built in __construct method. This allows us to instantiate a class as though it were a function, just like we would in JavaScript.

$myClass = new MyClass(someValue);

This and The Arrow

Continuing with the MyClass example above, you’ll notice that we’re using this in the same way that we would in JavaScript. The difference here, is that we’re using an arrow (->) to access classAttrib on the class. We’ll also use this pointer to access anything on the class that we need to use throughout our code.

Here’s the same class in JavaScript:

class MyClass {
    constructor(classAttrib) {
        this.classAttrib = classAttrib;
    }
}

Getters and Setters
Getters and Setters are class methods used to get and set (or update) information to do with the class attributes. In JavaScript we don’t typically need to make them, and similarly they aren’t required in PHP. That said, you’ll see them far more frequently in PHP, so I thought it would be prudent to go over here. Basically, these methods are the only things that should be directly modifying or otherwise interacting with the class attributes outside of the class.

# ... inside MyClass
    public function setClassAttrib($classAttrib) {
        return $this->classAttrib = $classAttrib;
    }

    public function getClassAttrib() {
        return $this->classAttrib;  
    }

Inheritance
Inheriting from parent classes in PHP is similar to JavaScript, with the exception being that we don’t use super to pass in the parent class’ attributes. Instead we use the :: operator. Also called the Scope Resolution Operator.

class SecondClass extends MyClass {
    private $newAttrib;
    public function __construct($classAttrib, $newAttrib) {
        parent::__construct($classAttrib);
        this->newAttrib = $newAttrib;
    }
}

PHP & JavaScript Similarities

Now that we’ve talked about a fair few of the differences between JavaScript and PHP, let’s talk about some similarities!

PHP has spread syntax! You can use the exact same syntax as in JavaScript, in both arguments (argument unpacking is available in PHP 5.6+) and arrays (available from PHP 7.4+)!
PHP has ternaries!
PHP has type coercion with the ==!

As I mentioned earlier, I'm still new to PHP, but I hope that this article was helpful to you! ❤️

Nevertheless, Megan Miller Coded

Megan Miller — Sat, 07 Mar 2020 06:13:00 +0000

A Little About Me...

This is my very first DEV article, so I thought it might be prudent to mention a few things about myself. I've been coding off and on for somewhere around 8-12 years. I'm visually impaired, and I love to read.

My Journey With Code So Far...

I began my coding journey sometime between 2008 and 2012. I hesitate to call it that because I wasn't really doing anything special. I was a bored high school student who had a hobby for writing, and I liked to create profiles for characters I was writing about. For the most part, all of the things I created were HTML & CSS. They weren't responsive. They didn't contain JavaScript. But I was so, so proud of them.

So, while I hesitate to call that part of my life part of my "coding journey," it was the reason I fell in love with code. Over the next several years, I tried to learn a ton of different things off and on. I started with advanced CSS stuff (like learning how to make tabs on a page that don't use any JS!). I also learned about the accessibility features in HTML like aria-labels, and how the different HTML tags work with Text-To-Speech (although being visually impaired myself, I still have a long way to go with this part!).

As I researched and learned, I picked up small amounts of knowledge on a bunch of different things. I learned some basic things about Linux (mostly Ubuntu and the CLI) and how to set up a server. I learned some things about PHP and MySQL. That said, I was aimless. I didn't have a goal, I was just learning to learn (I didn't even use git!). Learning to build. When things I wanted to do started to get too complicated, or the tutorial I was following ended up being incomplete, I would stop whatever project I was on and move to the next thing that interested me.

In a way, I kind of miss those days. That period of time where I just built to build with no end goal in mind except, "Hey! I want to make this. How do I do that?"

That said, as time went on, I felt kind of trapped. I loved building, but I didn't feel like I was going anywhere with it. As the realization crept up on me that I wanted a job in this field, it occurred to me exactly how much I didn't know. So, I continued to try and learn some "real" programming languages. I started with JavaScript and found myself bewildered. I didn't understand any of the syntax I read. I didn't know where to start to really learning about it. There had been so many tutorials about how to build specific things in what I had wanted to learn before. I could just google "How to build a blog from scratch" and get a ton of tutorials using PHP and MySQL.

Eventually, I decided I wanted to go to college for development, maybe some structure would help me. In high school, my grades weren't great, so there was no way I was getting into a 4-year school. Instead, I decided to try my local community college. None of the classes I took initially had to do with code, which I was sad about, but for a while, it was great! I loved most of my classes, and I had made friends in my major who were as jazzed about building things as I was. One day, though, something changed. I'm not even exactly sure what it was; at this point, it seems so long ago. One day I went to campus, and I was scared. Nothing was even happening. No one was talking to me, I was just excruciatingly uncomfortable. Enough so, that I called one of my parents to come to take me home since I can't drive. I never went back to school.

To this day, I don't know what happened, but I went to the doctor about a year after it happened and found out I had some form of anxiety that they gave me medication to help treat.

Once I stopped going to college, I fell back into my old habits. I googled around trying to find out what I should be learning to be a "real" developer, this caused me to bounce around different languages. JavaScript changed to C# to C++; all the while, if I got stuck, I would drop back to my roots. HTML & CSS. Eventually, I learned about Python, and I finally understood what I was looking at. I was elated, to say the least. I finally felt like I was getting somewhere.

Once I built a few things in Python, I decided to try and go back to learning JavaScript. I don't even remember why anymore. I was aimless again. I wanted structure, but I couldn't stick with anything, and it made me feel awful.

In September of 2018, one of my friends expressed interest in learning to code and asked if I would help them. I agreed, excited to have someone else in my friend group who was interested in code. After about three months of assisting them to find resources and explaining some concepts to them, they sent me a link to a boot camp, one of their friends had sent them. Lambda School.

After about three weeks of research. Looking at reviews, their CIRR report, and reading over the material available about their payment model, I decided to take the plunge and applied for a cohort starting on April 21st of 2019.

What could go wrong?

Enter: Lambda School...

I started the Fullstack Web Track on Monday, April 21st, 2019. I remember this date individually because the Friday before, I had moved from my parents' home in Virginia to Wisconsin to live with my long-distance partner of six years. The program started off simple, with things I already knew how to do: building sites in HTML and CSS. Then, we moved on to JavaScript. First, the basics, and later we learned about DOM manipulation. This was the first time I really understood how manipulating the DOM worked. It finally made sense. We covered all of this in a month and then started our first Build Week.

A Build Week at Lambda is precisely what it sounds like. You spend a week building something. It's not just you, though, you work with a cross-functional team. This could be people further than you in the same track, and/or students in another track. In my case, I had a group consisting of a React Developer, an IOS Developer, a UX student, and a Node Backend Developer. I was tasked with building the marketing page for an app that the other students in my group were working on. It's been almost a year at this point, so I don't remember everything that occurred, but I remember the experience being a pleasant one. The teammates that shared my track were extremely accommodating, answering my questions about their parts of the curriculum. The IOS and UX members of my team were also super friendly and easy to talk to. I had a ton of fun that build week, and I learned a lot.

The week following that build week, we started learning React. I struggled a ton with this part of the curriculum. It was a whole new way of thinking about things. This was also before Lambda started teaching functional React. Personally, I feel like learning the functional approach to React is much easier than classical at first, but I know not everyone will agree with me.

Sometime between JavaScript and React, the Section Lead--henceforth SL--of my cohort created a Women's channel. I learned a ton from the women that were in it, and they're all wonderful. It was because of this channel that I was able to apply to be a Part-Time Team Lead--TL, or even knew that I could. I was so excited! Could I help other students the way my TL had helped me? Yes! The thought of being able to help students who were struggling, giving them the same support my TL had given me made me so unbelievably happy. However, because of TL training, I had to miss out on my React build week and make it up later.

Because I was a PT TL, I was able to continue my student status into the Backend Unit, while working at night to help other students earlier on in the program than me.

It was around this time that Lambda added Hooks to the curriculum, and so my cohort was given the option to go back through the React Unit to learn them. I chose not to because I was super excited for Backend. I could get exposure to them through being a TL, and so that would be fine with me! This meant, though, that I lost my original TL group, and that made me sad. I really loved that group.

So, I moved through the backend unit, where we learned Node, Express, KnexJS to handle the SQL side of things, and Jest for testing. My excitement towards Backend was well placed. I lived for those lessons. Took to them like a fish to water. In a flash, the unit was over, and I was beginning another build week. For this one, I was tasked with building an API for my React Devs to pull in data from. In retrospect, I could have been a way better backend dev. I finished the schema and primary endpoints the weekend before the build week started, but I didn't fully understand what the app itself needed in terms of data, so my React Devs always had to ask me to add, and/or change things on my side of things. I also didn't realize I needed to write documentation for the API until near the end (it's been added to the build week rubric at this point, thankfully.)

It's worth noting here that I was still a PT TL at this point, so while I had something I could blame for my issues as a teammate, realistically, it had nothing to do with it.

I learned a lot about what communication actually meant during that build week, and I've endeavored to better support any teams I'm on since then. It was that build week that made me realize I really wasn't mentally ready for labs. I understood the material, and I could write it out, but I needed to learn more about being a good teammate. So, I put my student status on hold and became a Full-Time TL for a cohort starting all the way back at the very beginning of the web track.

I'm so glad I did.

The group of TLs headed by our two SLs were fantastic. I love all of them so much. I learned so much from them as teammates and friends. We worked together to make the students' time with us the best that we could. I loved my PT group so much, but I couldn't handle both FT and PT, so I had to say good-bye to them. Once I did, I was able to focus on my students and help them through whatever they needed. Some of them flexed, and it always made me sad when that happened because I felt like there was more I could have done that I didn't, but overall my experience as a FT TL was incredibly fulfilling. I learned so much in those 5 months, not only from the team that I worked with day-to-day but from my students as well.

Once my cohort reached Labs, my student status kicked back in, and I joined them in that part of the curriculum.

Labs is two months of building a production-level application and (potentially) deploying it with a group of other students from all across Lambda. My Labs team was made up of primarily team members from the former TLs of that cohort, the SL from my original cohort, one of our former students. Together, over 8 weeks, we built and deployed an app to the Google Play Store. It was a fantastic experience that I couldn't have done without my team. We were constantly talking in zoom while we coded. We had so many heart-to-heart conversations, and honestly, I consider all of them some of my closest friends.

After Labs, I hit the final stretch of LS. The Computer Science section. I've been in this part of the curriculum for about a month. CS has been hard. Extremely hard. I didn't realize how bad I was at real problem solving until I hit this point in the program. I've felt imposter syndrome before, but the amount of mental anguish I've felt this month has been surreal. Even though I've been passing everything, I've asked myself at least twice a week if I really belonged in the field. I don't know if it's just anxiety. If changing the way I look at problems and try to solve them is just making my "lizard brain" react negatively, but it's been hard. My TL has been such a big help, though. Every time I've voiced my doubts, he's reassured me that I can do this.

Today marks the completion of my first CS build week. I'm feeling pretty good about it right now. The build weeks for CS are separate from the primary curriculum, so all the students you're working with are at the same point as you. We were tasked with building a MUD in Python using whatever frontend framework we wanted, using either Django or Flask as our Backend. My team and I created our frontend using React using HTML5 canvas to render rooms generated on the Backend to the screen. I deployed the Backend, and one of my team members specifically worked on the algorithm to generate rooms.

Monday marks the beginning of Unit 2 of CS. After this month, I'm nervous and excited. But most importantly, I'm going to keep going.

I can't stop now.