![](https://images.ecency.com/DQmYLqDznkyU1BjAnZBi1ZHicD71reoMbr9Kwn1CUE1kAPk/20220920_194337_0000.jpg)

Before I got to learn any programming language, I always hear people say if you know one language very well, then it won’t be difficult to learn another, you just have to be familiar with the new syntax but most of the concepts remain the same. I started with C before I moved to python and I learned a bit about python. I realized there are a lot of similarities between both languages and I also read that a lot of python syntax is influenced by C.

Then I started learning JavaScript and it’s basically the same story; there are a lot of similarities between it and the other two languages I learned earlier (C and python). Loops, data types, arrays, and conditional statements are some of the things that are common between these languages. I recently came across JavaScript objects and I will say they are currently my favorite thing in JavaScript, just like how dictionary is my favorite in python but as for structures in C, I wouldn’t say it’s my favorite because of how rigid it is to work with.

JavaScript objects, Python dictionaries, and C structures are very similar in the way they work, but JavaScript and Python provide more flexibility in the way those syntaxes are used and I will explain in a bit but first, let’s talk about how these things look in the 3 languages.

## JavaScript Objects
``` javascript
const person = {
name: "John",
dob: 1988,
age: 34,
eyeColor: "blue"
}
```
The items in an object exist in pairs called properties. In the above code, we declared a variable known as person and the curly braces tell us that this variable isn’t a normal one, but it’s indeed an object. The first item (or property) is `name` and its value is `John`. A property and its value are separated by a colon (:), while different properties are separated by a comma.

## Python Dictionaries
``` python
person = {
"name": "John",
"dob": 1988,
"age": 34,
"eyeColor": "blue"
}
```
This is basically the same as the JavaScript objects; each item exists in a key-value pair but the only difference here is that each of the keys is enclosed with quotation marks. Aside from that, every other thing is the same.

## C structures
``` c
typedef struct person {
char name[35];
int dob;
int age;
char eyeColor[10];
} person;
```
There are a lot of things going on here and that’s usually the problem with C; something that looks very simple to do in other languages is now looking complicated in C, but let's go through the code one by one. The first keyword there `typedef` is just a way of creating a custom data type in C (in this case, the custom data type is `struct person`). The next keyword is `struct` and that’s basically how you specify a structure, unlike other languages where you just have to use only a variable. The last thing at the end of the code is the name of this structure we declared and we called it `person`.

Within the code, you will notice that I have things like `char` and `int`, that’s because we have to specify the data type in C before they can be used, unlike in JavaScript and python where you don’t need to do that. The first variable there is `name[35]`, what’s the 35 doing there? C doesn’t have a default string datatype, so in order to store a string, you have to use an array of characters (That’s one crazy thing about C). What that line simply means is that I am creating a memory space where I can store 35 characters which will represent a string. `name[35]` doesn’t have any value and that’s because we are not allowed to assign values to each item inside a structure, we do that outside of it.
``` c
person newPerson = {"John", 1988, 34, "blue"};
```
Each of these values is assigned to the variables inside the structure in the way they appear here. So, “John” goes to `name[35]`, 1988 goes to `dob`, and so on. If you mix it up; maybe you wrote 34 before 1988, 34 will now go to `dob` while 1988 goes to `age`. To prevent something like that from happening, we can use another syntax
``` c
person newPerson  // creates a new structure called newPerson

newPerson.name = “John” // assigns a value to `name[35]`
```

## Accessing the property values of JavaScript objects,
We can access each property’s value by using two methods; either the dot notation method or the square bracket method.
``` javascript
let name = person["name"];
let dob = person["dob"];
let age = person.age;
let eyeColor = person.eyeColor;
```
I used both methods here and you can use anyone convenient for you but notice the differences in using both of them. The square bracket method requires you to enclose the property with quotation marks but that isn’t required when using the dot notation method. I assigned each of the values to a variable so that I can easily use it without having to access the value again. Now I can use the variable in a sentence like this: 
`console.log("The person's name is " + name + ", he is " + age + " years old and the color of his eyes is " + eyeColor);`

The output will be: **The person’s name is John, he is 34 years old and the color of his eye is blue.**

## Accessing the key values of python dictionaries
``` python
name = person["name"]
dob = person["dob"]
age = person["age"]
eyeColor = person["eyeColor"]
```
Only the square bracket method can be used to access the values of the keys in a dictionary and it’s a lot similar to how it is done in JavaScript objects
Each value is assigned to a variable and we can use it in a sentence: 
`print(f"The person's name is {name}, he is {age} years old and the color of his eyes is {eyeColor}")`

The output will be:  **The person’s name is John, he is 34 years old and the color of his eye is blue.**

## Accessing the item values of C structures
``` c
char *name = newPerson.name;
int dob = newPerson.dob;
int age = newPerson.age;
char *eyeColor = newPerson.eyeColor;
```
The dot notation method is used to access the items of a structure and the values can be stored in a variable to make things easier. `*name` is a pointer and that’s how we can store string items (string is just an array of characters). `name` points to the first character of the string (which is J) and we can use that to access every other character in the array.
The variables can now be used in a sentence: 
`printf("The person's name is %s, he is %i years old and the color of his eyes is %s\n", name, age, eyeColor);`

The output will be: **The person’s name is John, he is 34 years old and the color of his eye is blue.**

## Modifying the properties of a JavaScript object
It’s very simple to change the value of a property in an object, we simply have to access the property’s value and give it a new value
``` c
person.name = "Peter";
name = person.name
```
The name property in the `person` object will now have the value of Peter instead of John. That new property value can now be assigned to the same variable as before (or you can use a new one), then we can use it in the previoue sentence.
The new output will now be: **The person’s name is Peter, he is 34 years old and the color of his eye is blue.**

## Modifying the key values of a python dictionary
It’s very similar to how it is done in JavaScript objects, we just access the value of the key and assign it a new value.
``` python
person["name"] = "Peter"
name = person["name"]
```
When we use it in a sentence, the new output will now be: **The person’s name is Peter, he is 34 years old and the color of his eye is blue.**

## Modifying the items of a C structure
You might be thinking it will be as easy as just doing `newPerson.name = “Peter”` but this won’t work because C is just not as cooperative as other languages. That might work for other data types like integers and floats; `newPerson.age = 40` will work. But to modify the value of a string, we have to use a function called strcpy().
`strcpy(newPerson.name, "Peter");`

This simply copies Peter and uses it to overwrite whatever is the value of `newPerson.name`. We don’t need to assign it to a variable before it can be used, the previous variable will still work as usual. So, once we use the printf function to output the new sentence, we will have: **The person’s name is Peter, he is 34 years old and the color of his eye is blue.**

## Adding a new property to an object in JavaScript
If we want to add a new property to the object, maybe something like gender, we can easily do that with:
``` javascript
person.gender = "male";
let gender = person.gender
```
This will add `gender:male` to the object and we can now access this property's value just like we did the others and even use it in a sentence:
`console.log("The person's name is " + name + ", he is a " + gender + " and he is " + age + " years old. The color of his eyes is " + eyeColor);`

This will output: **The person’s name is Peter, he is a male and he is 34 years old. The color of his eye is blue.**

## Adding a new key to a dictionary in Python
It's similar to the syntax used in accessing a key's value. We can use two methods to do this and I will demonstrate them:
``` python
person["gender"] = "male"
person.update({"gender": "male"})
gender = person["gender"]
```
These two syntaxes will do the same thing. The second method uses the update() function to add the new item to the dictionary. We can now access the item's value and assign it to a variable that can now be used in a sentence.

## Adding a new item to a structure in C
Unfortunately you can't do this the way it was done in the other languages. Once a structure has been defined, you can't add to it later on. You will have to go back to the main structure body and add whatever new property you want or you can redefine a new structure with a different name, before you can add the new item.

This is why I said earlier that structures in C are rigid, it isn't flexible as objects and dictionaries. If you want to do complicated operations, it's better to use another data structure like hash tables.

## Conclusion
JavaScript objects are very powerful and they come with a lot of inbuilt methods (functions) and you can also create your own custom method as one of the properties of the object. I am still learning the various syntaxes and concepts associated with objects because I come from a C language background where we don't have objects and the only thing similar which are structures have a lot of limitations.

**Thanks for reading**

![](https://images.ecency.com/DQmbLhPcVduzukxbvrW8pAyEeLpgxqFs1sddNPJCm5xjM4V/img_0.018478079605897074.jpg)

**Connect with me on:**
**Twitter:** **[@kushyzeena](https://twitter.com/kushyzeena)**
**Readcash:** **[@kushyzee](https://read.cash/@Kushyzee)**
<div class = phishy> 
<strong>Lead image: created with Canva</strong>
</div>