DEV Community: Pedro Magnus

JavaScript Array Methods

Pedro Magnus — Tue, 08 Feb 2022 18:23:08 +0000

JavaScript Array Methods

JavaScript has a great range of functional methods with arrays, and that is what I'm going to try to show in this article.

Every method in this article iterates over the array to apply changes or return a value

Array Map

The array map is used to apply some logic to an array and return the result as an array.

// Frist we are creating a array of foods
> foods = ['apple','leberkässemmel','Pao de Queijo']
[ 'apple', 'leberkässemmel', 'Pao de Queijo' ]

// Then we apply the suffix sold out 
// to each food to indicate its state
> foods.map(food => `${food} sold out`)
[
  'apple sold out',
  'leberkässemmel sold out',
  'Pao de Queijo sold out'
]

Array Flat Map

The flat map is almost like the map, but it turns a matrix into an array without applying any logic, although, you can specify the depth that you want to flat.

 // Frist we create an Array of arrays or a matrix
> foods = [['Apple','Onion Rings'],['leberkässemmel','Bier'],[[[['Pao de Queijo', 'Feijoada']]]]]
[
  [ 'Apple', 'Onion Rings' ],
  [ 'leberkässemmel', 'Bier' ],
  [[[[ 'Pao de Queijo', 'Feijoada' ]]]]
]

// We can apply the flat method and 
// it will flatten the array but with the depth of 1
> foods.flat()
[
  'Apple',
  'Onion Rings',
  'leberkässemmel',
  'Bier',
  [[['Pao de Queijo',
  'Feijoada']]]
]


// Now specifying the depth the result is a flat array
> foods.flat(4)
[
  'Apple',
  'Onion Rings',
  'leberkässemmel',
  'Bier',
  'Pao de Queijo',
  'Feijoada'
]

Array Flat Map

The flatmap does the same thing as a map followed by a flat with depth 1.

// Now we have a matrix of foods with depth of 1
> foods = [['Apple','Onion Rings'],['leberkässemmel','Bier'],['Pao de Queijo', 'Feijoada']]
[
  [ 'Apple', 'Onion Rings' ],
  [ 'leberkässemmel', 'Bier' ],
  [ 'Pao de Queijo', 'Feijoada' ]
]

// Using the flatMap we are going to flat 
// the array and apply some logic to it, like the number of items.
> foods.flatMap(food => `${food} 10`)
[
  'Apple,Onion Rings 10',
  'leberkässemmel,Bier 10',
  'Pao de Queijo,Feijoada 10'
]

Array Find

The array find is used to find and return an element from an array

// We are creating our foods array again
// to find an specific element
> foods = ['Apple','Onion Rings','leberkässemmel','Bier','Pao de Queijo', 'Feijoada']
[
  'Apple',
  'Onion Rings',
  'leberkässemmel',
  'Bier',
  'Pao de Queijo',
  'Feijoada'
]

// The find element searches the array
// until a comparison return trues
> foods.find(food => food === 'Bier')
'Bier'

// It can be used with startsWith for instance
> foods.find(food => food.startsWith('A'))
'Apple'

// Or even with includes
> foods.find(food => food.includes('e'))
'Apple'

Array Filter

The array filter works like find, but it returns an array of elements found. Let's see the difference using the same examples

// Our Array
> foods = ['Apple','Onion Rings','leberkässemmel','Bier','Pao de Queijo', 'Feijoada']
[
  'Apple',
  'Onion Rings',
  'leberkässemmel',
  'Bier',
  'Pao de Queijo',
  'Feijoada'
]

// As we only have one Bier on our array, 
// its going to return one element array
> foods.filter(food => food === 'Bier')
[ 'Bier' ]

// The same thing will happen with the second example
> foods.filter(food => food.startsWith('A'))
[ 'Apple' ]

// Now in our last example things are going 
// to be different we will get every food
// except for Onion Rings, because it has 
// no E
> foods.filter(food => food.includes('e'))
[ 'Apple', 'leberkässemmel', 'Bier', 'Pao de Queijo', 'Feijoada' ]

Array Reduce

The array reduce is used to reduce the value from a callback function.

// Lets create array of number
> numbers = [1,2,3,4,5,6,7,8,9]
[
  1, 2, 3, 4, 5,
  6, 7, 8, 9
]

// The reduce method is going to reduce the array to a
// sum of all array numbers
> numbers.reduce((number, currentValue) => currentValue + number)
45

It's also possible to create new objects with reducing

// Lets create an array with emojis
> emojis = ['😛','😜','😇','😛','😜','😛','😇']
[
  '😛', '😜',
  '😇', '😛',
  '😜', '😛',
  '😇'
]

// Now lets put our logic inside reduce to count
// how many times each emoji has appeared
> emojis.reduce((objEmoji, emoji)=>{
    if(emoji in objEmoji){
      objEmoji[emoji]++
    }else{
      objEmoji[emoji] = 1
    }
  return objEmoji
  },{})
{ '😛': 3, '😜': 2, '😇': 2 }

Array Every

The array every method verifies if every element in the array is the one you are using to compare and returns a boolean as result.

//Lets create our emoji
> emojis = ['😈','😈','😈','😈']
[ '😈', '😈', '😈', '😈' ]

// As the emojis are not the same the
// comparison result is false
> emojis.every(emoji => emoji === '😇')
false

// Comparing with the same emoji
// the result is true
> emojis.every(emoji => emoji === '😈')
true

Array Some

The array some method verifies if one or more elements are present in the array and returns a boolean as result.

// Lets create our array of emojis
> emojis = ['😛','😜','😇','😛','😜','😱','👽']
[
  '😛', '😜',
  '😇', '😛',
  '😜', '😱',
  '👽'
]

// We are going to receive a true,
// because there is a 😱 emoji
> emojis.some(emoji => emoji === '😱')
true

// Now the return is going to be false,
// because there is no 😈 in our array
> emojis.some(emoji => emoji === '😈')
false

Array At

The array "at" is a new way to move over the array without the need of array.length

// Our array of emojis
> emojis = ['😛','😜','😇','😛','😜','😱','👽']
[
  '😛', '😜',
  '😇', '😛',
  '😜', '😱',
  '👽'
]

// The at index works as the same as a normal array,
// but you can use negative numbers to go
// from the last array position
> emojis.at(-1)
'👽'

Setting up Spring Kafka With Kotlin

Pedro Magnus — Tue, 08 Feb 2022 01:34:33 +0000

Creating Spring project

Consumer: https://github.com/magnuspedro/KafkaConsumer
Producer: https://github.com/magnuspedro/KafkaProducer

Description

This tutorial is going to show how to create a spring Kotlin application from scratch to create a Kafka consumer and producer and set up Kafka with docker. We also going to user Sleuth to trace our message over the services, so we can keep a track of each transaction.

Installation

To create a new spring project I'm going to use the start.spring.io with Kotlin.

The first service is going to be the producer as the following image:

The consumer witch is going to be our second sever is going to have the same configurations as the producer, but with a consumer on its name.

We are going to use sleuth because it traces all our requests over the services, and prints them on our logs.

now we are installing the logback lib to the project for logging. All we have to do is add the libs to the pom.xml so maven will know we want it as a dependency, and run nvm clean install to install it.



<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-core</artifactId>
    <version>1.2.6</version>
</dependency>

Setting Up Kafka with Docker

In the first step, we are going to set up Kafka with docker, using a docker-compose.yml file.



version: '2'
services:
  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000
    ports:
      - 22181:2181

  kafka:
    image: confluentinc/cp-kafka:latest
    depends_on:
      - zookeeper
    ports:
      - 29092:29092
    environment:
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092,PLAINTEXT_HOST://localhost:29092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1

The first service to be installed with our docker-compose is the zookeeper. The zookeeper allows you to create a Kafka cluster, and it's going to take care of the connection and distribution. The second service is Kafka itself.

Configuration

PLAINTEXT: We are setting the protocols to plaintext, which means that it's non-encrypted messages. It's not recommended for production, but it's alright for our tests.
Kafka Exposed Port: 29092
Zookeeper Exposed Port: 22181
Kafka Replication Factor: The replication factor is the number of clusters that the partitions are going to be replicated, in our case only on our main cluster 1.

For a better understanding of the variables and Kafka itself, I would recommend this article

Configuring The Producer

To be able to use produce Kafka messages we first need to implement a few configurations so we can send them to our Kafka server.

Properties Config

First, we are going to change the application.properties file to an application.yml, just because I like it better if you want you can keep the application.properties.

For the properties configurations, we are going to create a variable to the Kafka address and topic.



Kafka:
  bootstrapAddress: localhost:29092
  topics:
    product: product

We are using the localhost:29092 as it was set on our container.

Kafka Config

For the Kafka config file, we will use the address to create a Map that has our server address and then create a new topic with the name we defined on our application.yml file.
As we are creating a @Configuration it's going to be injected on running time to our code, so after spring finishing booting the topic is going to be created.



import org.apache.kafka.clients.admin.AdminClientConfig
import org.apache.kafka.clients.admin.NewTopic
import org.springframework.beans.factory.annotation.Value
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.kafka.core.KafkaAdmin

@Configuration
class KafkaConfig(
    @Value("\${kafka.bootstrapAddress}")
    private val servers: String,
    @Value("\${kafka.topics.product}")
    private val topic: String
) {

    @Bean
    fun kafkaAdmin(): KafkaAdmin {
        val configs: MutableMap<String, Any?> = HashMap()
        configs[AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG] = servers
        return KafkaAdmin(configs)
    }

    @Bean
    fun porduto(): NewTopic {
        return NewTopic(topic, 1, 1.toShort())
    }
}

Producer Config

Now we have the topic configuration, but we need to produce messages to post on the topic, for that we are going to create a producer.



import com.magnuspedro.kafka.producer.kafkaProducer.config.serializer.ProductSerializer
import org.apache.kafka.clients.producer.ProducerConfig
import org.apache.kafka.common.serialization.StringSerializer
import org.springframework.beans.factory.annotation.Value
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.kafka.core.DefaultKafkaProducerFactory
import org.springframework.kafka.core.KafkaTemplate
import org.springframework.kafka.core.ProducerFactory


@Configuration
class KafkaProducerConfig(
    @Value("\${kafka.bootstrapAddress}")
    private val servers: String
) {
    @Bean
    fun producerFactory(): ProducerFactory<String, Any> {
        val configProps: MutableMap<String, Any> = HashMap()
        configProps[ProducerConfig.BOOTSTRAP_SERVERS_CONFIG] = servers
        configProps[ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG] = StringSerializer::class.java
        configProps[ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG] = ProductSerializer::class.java
        return DefaultKafkaProducerFactory(configProps)
    }

    @Bean
    fun kafkaTemplate(): KafkaTemplate<String, Any> {
        return KafkaTemplate(producerFactory())
    }
}

The producer has even more configuration, it takes the server address, and two serializes. The key serializer is represented by the KEY_SERIALIZER_CLASS_CONFIG that is going to be a string and the VALUE_SERIALIZER_CLASS_CONFIG that is a custom serializer created to convert our product entity into JSON.

We are creating a KafkaTemplate implementation with our configured producer factory.

Custom serializer

For our custom serializer, we are going to use Jackosn to write a byte array from our entity. It has to be a byte array because we are implementing the Serializer Class from spring Kafka.



import com.fasterxml.jackson.databind.ObjectMapper
import com.magnuspedro.kafka.producer.kafkaProducer.entities.Product
import org.apache.kafka.common.errors.SerializationException
import org.apache.kafka.common.serialization.Serializer
import org.slf4j.LoggerFactory


class ProductSerializer : Serializer<Product> {
    private val objectMapper = ObjectMapper()
    private val log = LoggerFactory.getLogger(javaClass)

    override fun serialize(topic: String?, data: Product?): ByteArray? {
        log.info("Serializing...")
        return objectMapper.writeValueAsBytes(
            data ?: throw SerializationException("Error when serializing Product to ByteArray[]")
        )
    }

    override fun close() {}
}

For the serialization, we are only accepting data that is not null, or else we are going to throw a SerializationException.

Our Product file is going to be a simple Kotlin data class



import com.fasterxml.jackson.annotation.JsonProperty

data class Product(
    @JsonProperty("name")
    val name: String,
    @JsonProperty("sku")
    val sku: String?
)

We are adding the @JsonProperty annotation so Jackson knows the name of each field when it's going to convert it.

Test Controller

At last, we need something to send messages to the topic, I have chosen to create a controller, so we can change our objects and send as many as we want.



import com.magnuspedro.kafka.producer.kafkaProducer.entities.Product
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.beans.factory.annotation.Value
import org.springframework.http.HttpStatus
import org.springframework.http.ResponseEntity
import org.springframework.kafka.core.KafkaTemplate
import org.springframework.kafka.support.KafkaHeaders
import org.springframework.messaging.Message
import org.springframework.messaging.support.MessageBuilder
import org.springframework.validation.annotation.Validated
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController


@RestController
@RequestMapping("/product")
class LogController(
    @Value("\${kafka.topics.product}") val topic: String,
    @Autowired
    private val kafkaTemplate: KafkaTemplate<String, Any>
) {
    private val log = LoggerFactory.getLogger(javaClass)

    @PostMapping
    fun post(@Validated @RequestBody product: Product): ResponseEntity<Any> {
        return try {
            log.info("Receiving product request")
            log.info("Sending message to Kafka {}", product)
            val message: Message<Product> = MessageBuilder
                .withPayload(product)
                .setHeader(KafkaHeaders.TOPIC, topic)
                .setHeader("X-Custom-Header", "Custom header here")
                .build()
            kafkaTemplate.send(message)
            log.info("Message sent with success")
            ResponseEntity.ok().build()
        } catch (e: Exception) {
            log.error("Exception: {}",e)
            ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Error to send message")
        }
    }
}

On the controller, we are going to create a Message type, so we can add Kafka headers and custom headers when sending the message to the topic. We are going to add only one custom header and see if it's going to come back to us on our producer.

That finishes all the configurations we need to implement a simple Kafka producer, to send JSON messages.

Kafka Consumer

For the Kafka consumer, we are going to need the same basic configurations as our producer, we need to change our application.properties to application.yml and create the same Product entity, so we can change it back from JSON.

If you are going to run both projects on the same machine you need to change on project port, to do so you need to add this config to the application.yml file.



logging:
  level:
    root: info

Kafka Consumer Config

Our consumer config file is going to be similar to our producer.



import com.magnuspedro.kafka.consumer.KafkaConsumer.config.deserializer.ProductDeserializer
import org.apache.kafka.clients.consumer.ConsumerConfig
import org.apache.kafka.common.serialization.StringDeserializer
import org.springframework.beans.factory.annotation.Value
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.kafka.annotation.EnableKafka
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory
import org.springframework.kafka.core.ConsumerFactory
import org.springframework.kafka.core.DefaultKafkaConsumerFactory
import org.springframework.kafka.listener.ContainerProperties


@EnableKafka
@Configuration
class KafkaConsumerConfig(
    @Value("\${kafka.bootstrapAddress}")
    private val servers: String
) {

    @Bean
    fun consumerFactory(): ConsumerFactory<String?, Any?> {
        val props: MutableMap<String, Any> = HashMap()
        props[ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG] = servers
        props[ConsumerConfig.GROUP_ID_CONFIG] = "ppr"
        props[ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG] = StringDeserializer::class.java
        props[ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG] = ProductDeserializer::class.java
        props[ConsumerConfig.AUTO_OFFSET_RESET_CONFIG] = "earliest"
        return DefaultKafkaConsumerFactory(props)
    }

    @Bean
    fun kafkaListenerContainerFactory(): ConcurrentKafkaListenerContainerFactory<String, Any>? {
        val factory = ConcurrentKafkaListenerContainerFactory<String, Any>()
        factory.consumerFactory = consumerFactory()
        factory.containerProperties.ackMode = ContainerProperties.AckMode.MANUAL_IMMEDIATE
        factory.containerProperties.isSyncCommits = true;
        return factory
    }
}

Most of the configuration as said before is like our producer, and like it, we have a custom deserializer for the value.

Configuration

A committed message is a message that has already been read and confirmed to be consumed.

GROUP_ID_CONFIG: Is the identification of the group that the consumer belongs
AUTO_OFFSET_RESET_CONFIG: Set the configuration when Kafka consumer starts and has no committed messages, earliest meaning that it's going the get all the menages from the beginning and latest is going to get only the last message
AckMode.MANUAL_IMMEDIATE: Is setting the commit of the messages to be done manually

Custom Deserializer

For our custom deserializer, we are going to implement the Deserializer Class from Spring Kafka and override the deserialize method.



import com.fasterxml.jackson.databind.ObjectMapper
import com.magnuspedro.kafka.consumer.KafkaConsumer.entities.Product
import org.apache.kafka.common.errors.SerializationException
import org.apache.kafka.common.serialization.Deserializer
import org.slf4j.LoggerFactory
import kotlin.text.Charsets.UTF_8


class ProductDeserializer : Deserializer<Product> {
    private val objectMapper = ObjectMapper()
    private val log = LoggerFactory.getLogger(javaClass)

    override fun deserialize(topic: String?, data: ByteArray?): Product? {
        log.info("Deserializing...")
        return objectMapper.readValue(
            String(
                data ?: throw SerializationException("Error when deserializing byte[] to Product"), UTF_8
            ), Product::class.java
        )
    }

    override fun close() {}

}

For the deserialization, we are only going to convert the byte array that we received to a string with the UTF_8 char-set and use Jackson to convert back to our entity. As the serializer, we are going to throw an error if the data is null.

Kafka Consumer

For consuming messages we first need to create a Consumer, and for that Spring Kafka offers an annotation that creates a listener for the topic.



import org.apache.kafka.clients.consumer.ConsumerRecord
import org.slf4j.LoggerFactory
import org.springframework.kafka.annotation.KafkaListener
import org.springframework.kafka.support.Acknowledgment
import org.springframework.stereotype.Component

@Component
class Consumer {
    private val logger = LoggerFactory.getLogger(javaClass)

    @KafkaListener(topics = ["\${kafka.topics.product}"], groupId = "ppr")
    fun listenGroupFoo(consumerRecord: ConsumerRecord<Any, Any>, ack: Acknowledgment) {
        logger.info("Message received {}", consumerRecord)
        ack.acknowledge()
    }
}

After annotating our method with KafkaListener we are going to log the consumerRecord and acknowledge (commit the message), so we only consume once each message.

Results

Now for the results, I'm going to run both applications and send a post request with the JSON object using insomnia to the producer service that is going to send the message to Kafka and it's going to be consumed by the consumer.

Now we have the producer logs showing us that the message was sent to the Topic

Pay attention to the Trace ID b79dc0a696fa6550 that is going to be the same as even though we are receiving the message from another service

The message is too big to fit on my monitor so I'm going to pass it here as plain text



2022-02-07 22:27:09.178  INFO [,b79dc0a696fa6550,d95cf5541abb5fb9] 83720 --- [ntainer#0-0-C-1] c.m.k.c.K.infra.consumer.Consumer        : Message received ConsumerRecord(topic = product, partition = 0, leaderEpoch = 0, offset = 104, CreateTime = 1644283629123, serialized key size = -1, serialized value size = 42, headers = RecordHeaders(headers = [RecordHeader(key = X-Custom-Header, value = [67, 117, 115, 116, 111, 109, 32, 104, 101, 97, 100, 101, 114, 32, 104, 101, 114, 101]), RecordHeader(key = spring_json_header_types, value = [123, 34, 88, 45, 67, 117, 115, 116, 111, 109, 45, 72, 101, 97, 100, 101, 114, 34, 58, 34, 106, 97, 118, 97, 46, 108, 97, 110, 103, 46, 83, 116, 114, 105, 110, 103, 34, 125])], isReadOnly = false), key = null, value = Product(name=Test for Dev.To, sku=1232343))

There we have it, our message was propagated to our Kafka consumer and converted from JSON to our Product entity.

Git Commands used on my workflow

Pedro Magnus — Mon, 31 Jan 2022 18:51:06 +0000

What is Git?

Git is the most widely used versioning tool today. Git is an open-source project created in 2005 by Linus Torvalds, the same creator of the Linux kernel.

How does git work?

Git has a distributed architecture where every copy of the code is also a repository with a complete history of all changes. If the online repository has been deleted, there will still be a faithful copy on your machine.

Terminology

HEAD: The term is used to refer to the last change committed on your branch.

Repo: Abbreviation for repository

Branches

When a repository is created the main branch is also created. From the initial branch, it is possible to create branches of your code and then merge them into the main branch.
The main branch used to be called master branch, but it has changed on most common online repositories because it's a racist term that comes from master/slaves.

┐►Main
│
└┐►Release
 │
 └┐►Develop
  │
  └─►Feature

The image above represents what we call "Git flow", it's a way to separate branches to develop as a team, with branches representing a stage of development, feature being the new feature that is being implemented, the development being the development environment for testing, release being the homologation and the main being the production repository

Git Ignore

Git ignore is represented as a file called ".gitignore", as the name implies it is made to ignore files and/or directories. All documents with the same name written in the file will be ignored by git versioning.
There are sites to generate the gitignore file such as gitignore.io

# Git ignore para vscode
.vscode/*
!.vscode/settings.json
!.vscode/tasks.json
!.vscode/launch.json
!.vscode/extensions.json
*.code-workspace

# Local History for Visual Studio Code
.history/

### VisualStudioCode Patch ###
# Ignore all local history of files
.history
.ionide

The git ignore file is very important when you are using something like node with npm because all the libs that are used in the project are saved in the same directory as your project, so when you push it to the remote repo it's possible to push many gigs of data that you cloud download with npm install.

Git Commands

Nowadays many interfaces allow you to use git without writing a single command, but it's important to know what is happening from behind the scenes, that's why I'm bringing the main git commands.

Main Commands

These are the main basic commands everyone must know when using git. Most of these commands you are going to use every day for the rest of your developer life.

# Clone a repository to your machine
git clone <url>
# Add files to be committed 
git add <arquivo>
# Commit files and add a message
git commit -m <message>
# Show the repository status
git status
# Pull the changes from a remote repository
git pull origin <branch>
# Push the changes to a remote repository
git push origin <branch>
# Initiate a repository
git init

Configuration

The configuration commands normally are used only once when you set up your machine, but it's handy to have them written somewhere because it's very easy to forget.

# The --global flag makes the config
# been applied to the whole machine

# These commands must be set up
# before you first commit

# Add your email to commit Log
git config --global user.email {email}
# Add your name to a commit log
Git config --global user.name {name}

Branches Commands

The following commands are used to interact with branches.

# Create a new branch
git branch <name>
# Lists all branches local and remote
git branch -a
# Delete a branch
git branch -d <name>
# Changes from current branch to another
git checkout <branch>
# creates a new branch from current and
# changes to it.
git checkout -b <branch>
# merge two branches
git merge <branch>

It's good to remember that before you merge a remote repo to your branch always run the git fetch command to fetch the remote changes to your local repo.

Advanced commands

The advance commands are commands that make your life easier by changing history or saving changes on a stack. I normally use one of those commands once a week.

Git Stash

The stash command saves your uncommitted changes to a stack where you can retrieve them when needed.

# Save changes when they are not committed
git stash
# Save changes with a reference name
git stash save <name>
# List the references
git stash list
# Remove the last change from the stack and 
# add back to the code
git stash pop
# Add the last change to the code and
# live it on the stack
git stash apply
# Deletes the last change from the stack
git stash drop

Git commit

Back to commit commands now we have more advanced ones that can help us solve some small problems

# Add and commit at the same time
git commit -am <message>
# Changes the message from the last commit
git commit --amend -m <message>
# Add new changes to the commit
# To push the change to the remote repo
# you may need to use `--force`
git commit --amend --no-edit
# Revert the last change without deleting the logs
git revert <hash>
# Show the logs 
git log

Git Reset

Reset commands are very useful when you need to delete all changes you have done in your code or remove some commits without deleting the changed code

# Remove the commit and keep the changes 
git reset --soft HEAD~<commmit_number>
# Remove the commit delinting the changes
git reset --hard HEAD~<commit_number>
# Deletes the changes and go back to HEAD
git reset --hard HEAD

We always have to remember that git reset is a command that "rewrite history" which means that all you commit history will be going to be affected by the commanding. Be careful before using it.

Git Cherrypick

This is my favorite command of all. It allows you to copy a commit from one branch to another. It's very useful when you want to deploy some code but your release branch is dirty, you can simply copy your commit to the main branch and deploy it.

# Copy a commit to your current branch
git cherry-pick <hash>