Object discussion questions

discussion.md

Object Discussion Questions

There is some coding in this discussion. Feel free to write them in a REPL or in the comments below.

0. How is an object different from an array?
1. How does const work with objects?
2. Explain the difference between bracket syntax and dot syntax. Give an example of something that works with bracket syntax but not dot syntax. Give an example of something that works with dot syntax but not bracket syntax.
3. What are computed properties? Write an example code.
4. What is the difference between Object.keys and Object.entries? Write example code using both of them.
5. How do we get only the values of an object?

group (mohamad aghi, aya mydani, sara hamoud, irem kurt)

0- Arrays store the data in an ordered collection in which the data can be accessed using a numerical index while objects store in a pair form. We must put [] to arrays and {} to objects. We access values through the index in the array while we access values through key.(object.key())

1. when we declare an object using const we cant redeclare it again and we cant reassign it also .
   but we can make some changes to it means we can add, remove or edit keys and values.

2. the bracket notation allows us to access object properties using different values rather than the dot that just allows us to access the specified keys also we can't use variables with dot notation.

3. a property name that returns a value not just store it

4. Object.keys(obj) – returns an array of keys.
   Object.values(obj) - returns an array of [key, value] pairs.
   let user = {
   name: "John",
   age: 30
   };
   Object.keys(user) = ["name", "age"]
   Object.entries(user) = [ ["name","John"], ["age",30] ]

5. object.values(obj)

Cengiz aksakal, Amjad maqsouma, gizem haspolat, sobhan shams, Rama aldakkak:

0. The arrays cannot have a pair of values and keys. It is true that can have different types but we they cannot be like objects.
   Objects can have properties, we just write the key and its value will pop out. arrays only have values and index numbers.

1. const means constant by reference, which means that we cannot change place of the object in the memory but it can be modified in the terms of values.

2. obj.name (Dot notation)
   the disadvantages:
   it cannot be used with numbers with special characters like obj.0

   the advantages:
   it is easier to use because you do not have to inisialize variables or be aware of qoutations marks.

obj["name"] (Brackets notation)
the advantages:
we can use it with special characters
obj["1stname 2nd name"]

we can use it with computed properties
const customers = {
firstName: "John",
lastName: "Doe",
email: "johndoe@gmail.com"
};

console.log(customers.firstName);
// Output: John

const value = "firstName";

console.log(customers[value]);
// Output: John

3. A computed property is a property that calculates and returns a value, rather than just store it.
   const customers = {
   firstName: "John",
   lastName: "Doe",
   email: "johndoe@gmail.com"
   };

console.log(customers.firstName);
// Output: John

const value = "firstName";

console.log(customers[value]);
// Output: John

4. The Object.keys() method in JavaScript returns an array whose elements are strings corresponding to the enumerable properties
   Example :
   const object1 = {
   a: 'string',
   b: 50
   };

for (const [key, value] of Object.keys(object1)) {
console.log(${key}: ${value});
}

// expected output:
// "a"
// "b"

The Object.entries() method in JavaScript returns an array consisting of enumerable property [key, value] pairs of the object.
Example :
const object1 = {
a: 'string',
b: 50
};

for (const [key, value] of Object.entries(object1)) {
console.log(${key}: ${value});
}

// expected output:
// "a: string"
// "b: 50"

const object1 = {
a: 'string',
b: 50
};

for (const [key, value] of Object.values(object1)) {
console.log(${key}: ${value});
}

// expected output:
// "string"
// "50"

ghofran .nouh . mohammed . yaman
0)the object has value & key ..so it can store more detailed data.. while array store the data as a list .

1)const in object give us the possibility to change the object content .

2. the bracket notation allows us to access object properties using variable while dot not ,for example
   obj.123; // ❌ SyntaxError
   obj['123']; // ✅ 'digit'
   because it starts with a digits and every thing that works with dot notation dose work with bracket notation.

4)when we use( Object.keys) the return value is "string" but in case (Object.entries) the return value is array that consist of a key and a value.
Object.keys example:
const object1 = {
a: 'somestring',
b: 42,
c: false
};

console.log(Object.keys(object1));
object.entries example:
const object1 = {
a: 'somestring',
b: 42
};

for (const [key, value] of Object.entries(object1)) {
console.log(${key}: ${value});
}

// expected output:
// "a: somestring"
// "b: 42"

5)console.log(Object.values(object1));

https://docs.google.com/document/d/19nK9SKrTpPHMJHXhy785dIHvLoDGyNe4UeddXiSTJXE/edit?usp=sharing

Group 10
Hasan, Rama, Mohammed, and Melek
1)
Array is different type of object where order matter and it has hidden properties like an object using dot operator like "summary and length"" you can access these hidden property. Object is the preferred way to store collection of data for CRUD Data operations.
The Const keyword makes a variable itself immutable, not its assigned content meaning that Object's properties including keys and values can be changed but the data structure type of that declared Const variable can't be changed to other types.

The main difference between bracket and dot notation is that bracket notation allows us to access object properties using variables. To access JavaScript object properties using bracket notation, the key should be. Property identifiers have to be a String or a variable that references a String. Property identifiers cannot start with a number.
For the Arrays the method to access the elements is using the bracket syntax. array[0] the JavaScript engine takes the number 0 change it into string and access the element automatically where u cannot use dot operator.
For Objects, the preferred method to access the values of the keys is using the dot operator JavaScript ES5 (2015) new edition added more features such as .? for accessing objects and checking if this value exists without getting error from JavaScript.

Computed properties can be calculated outside and accessed from the inside of the object
In this example, the [Name] is a computed property of the rank object. The property name is derived from the value of the Name variable. the dynamical approach of changing the names of certain key or value inside an object can a good example to represent this phenomena, as shown below:
let Name = 'h';
const rank = {
a: 1,
b: 2,
[Name]: 3,
};
console.log(rank.c);
4)
Object.keys returns an array of keys after including the object indie the Brackets.
Object.entries it returns an array of the key and the value specifically .

you get the value of the object by using Object.Values and it will return an array of values.